@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/dreams-ledger-KDX44I7R.js

@@ -1,290 +0,0 @@
-import "./chunk-I2KLQ2HA.js";
-
-// ../remnic-core/src/maintenance/dreams-ledger.ts
-import path from "path";
-import * as fsReadModule0 from "fs/promises";
-const appendFile = fsReadModule0.appendFile;
-const lstat = fsReadModule0.lstat;
-const mkdir = fsReadModule0.mkdir;
-const readdir = fsReadModule0.readdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-function dreamsLedgerPath(memoryDir) {
-  return path.join(memoryDir, "state", "dreams-ledger.jsonl");
-}
-async function appendDreamsLedgerEntry(memoryDir, entry) {
-  const ledgerPath = dreamsLedgerPath(memoryDir);
-  await mkdir(path.dirname(ledgerPath), { recursive: true });
-  await appendFile(ledgerPath, JSON.stringify(entry) + "\n", "utf-8");
-}
-async function readDreamsLedgerEntries(memoryDir) {
-  const ledgerPath = dreamsLedgerPath(memoryDir);
-  let raw;
-  try {
-    raw = await fileReader(ledgerPath, "utf-8");
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") return [];
-    throw err;
-  }
-  const entries = [];
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (typeof parsed !== "object" || parsed === null) continue;
-      if (typeof parsed.phase === "string" && (parsed.phase === "lightSleep" || parsed.phase === "rem" || parsed.phase === "deepSleep") && typeof parsed.startedAt === "string" && typeof parsed.completedAt === "string" && typeof parsed.durationMs === "number" && typeof parsed.itemsProcessed === "number") {
-        entries.push({
-          schemaVersion: 1,
-          startedAt: parsed.startedAt,
-          completedAt: parsed.completedAt,
-          durationMs: parsed.durationMs,
-          phase: parsed.phase,
-          itemsProcessed: parsed.itemsProcessed,
-          dryRun: parsed.dryRun === true,
-          trigger: parsed.trigger === "manual" ? "manual" : "scheduled",
-          notes: typeof parsed.notes === "string" ? parsed.notes : void 0
-        });
-      }
-    } catch {
-    }
-  }
-  return entries;
-}
-var ALL_PHASES = ["lightSleep", "rem", "deepSleep"];
-var MAX_WINDOW_HOURS = 24 * 365 * 100;
-function normalizeDreamsStatusWindowHours(value, fallback = 24) {
-  const raw = value === void 0 || value === null ? fallback : value;
-  if (typeof raw !== "number" || !Number.isFinite(raw) || !Number.isInteger(raw) || raw < 1 || raw > MAX_WINDOW_HOURS) {
-    throw new RangeError(`windowHours must be a positive integer no greater than ${MAX_WINDOW_HOURS}`);
-  }
-  return raw;
-}
-async function getDreamsStatus(memoryDir, windowHours = 24, now = /* @__PURE__ */ new Date()) {
-  const boundedWindowHours = normalizeDreamsStatusWindowHours(windowHours);
-  const nowMs = now.getTime();
-  if (!Number.isFinite(nowMs)) {
-    throw new RangeError("now must be a valid Date");
-  }
-  const windowMs = boundedWindowHours * 60 * 60 * 1e3;
-  const windowStart = new Date(nowMs - windowMs);
-  const windowEnd = now;
-  if (!Number.isFinite(windowStart.getTime())) {
-    throw new RangeError("windowHours produces an invalid status window");
-  }
-  const entries = await readDreamsLedgerEntries(memoryDir);
-  const windowEntries = entries.filter((e) => {
-    const ts = Date.parse(e.completedAt);
-    return Number.isFinite(ts) && ts >= windowStart.getTime() && ts < windowEnd.getTime();
-  });
-  const statusMap = /* @__PURE__ */ new Map();
-  for (const phase of ALL_PHASES) {
-    statusMap.set(phase, {
-      phase,
-      runCount: 0,
-      totalDurationMs: 0,
-      totalItemsProcessed: 0,
-      lastRunAt: null,
-      lastDurationMs: null
-    });
-  }
-  for (const entry of windowEntries) {
-    const status = statusMap.get(entry.phase);
-    if (!status) continue;
-    status.runCount += 1;
-    status.totalDurationMs += entry.durationMs;
-    status.totalItemsProcessed += entry.itemsProcessed;
-    if (status.lastRunAt === null || Date.parse(entry.completedAt) > Date.parse(status.lastRunAt)) {
-      status.lastRunAt = entry.completedAt;
-      status.lastDurationMs = entry.durationMs;
-    }
-  }
-  return {
-    windowStart: windowStart.toISOString(),
-    windowEnd: windowEnd.toISOString(),
-    phases: {
-      lightSleep: statusMap.get("lightSleep"),
-      rem: statusMap.get("rem"),
-      deepSleep: statusMap.get("deepSleep")
-    }
-  };
-}
-async function recordDreamsPhaseRun(options) {
-  const startedAt = options.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const completedAt = options.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));
-  const ledgerEntry = {
-    schemaVersion: 1,
-    startedAt,
-    completedAt,
-    durationMs: Number.isFinite(durationMs) ? durationMs : 0,
-    phase: options.phase,
-    itemsProcessed: Math.max(0, Math.floor(options.itemsProcessed)),
-    dryRun: options.dryRun === true,
-    trigger: options.trigger,
-    notes: options.notes
-  };
-  if (!ledgerEntry.dryRun) {
-    await appendDreamsLedgerEntry(options.memoryDir, ledgerEntry);
-  }
-  return ledgerEntry;
-}
-async function runDreamsPhase(options, governanceRunner, phaseRunner) {
-  const { memoryDir, phase, dryRun = false } = options;
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  let itemsProcessed = 0;
-  let notes;
-  if (phase === "lightSleep") {
-    if (!dryRun) {
-      if (!phaseRunner) {
-        throw new Error("light-sleep manual runs require a phase runner");
-      }
-      const result = await phaseRunner({ memoryDir, phase });
-      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));
-      notes = result.notes ?? `scored ${itemsProcessed} memories`;
-    } else {
-      try {
-        const ledgerPath = path.join(memoryDir, "state", "observation-ledger", "rebuilt-observations.jsonl");
-        let raw = "";
-        try {
-          raw = await fileReader(ledgerPath, "utf-8");
-        } catch {
-        }
-        const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-        const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
-        itemsProcessed = lines.filter((line) => {
-          try {
-            const obj = JSON.parse(line);
-            const timestamp = typeof obj.ts === "string" ? obj.ts : typeof obj.timestamp === "string" ? obj.timestamp : null;
-            if (!timestamp) return false;
-            const ms = Date.parse(timestamp);
-            return Number.isFinite(ms) && ms >= cutoff;
-          } catch {
-            return false;
-          }
-        }).length;
-        notes = `dry-run: would score ${itemsProcessed} observation entries`;
-      } catch (err) {
-        throw new Error(`light-sleep scan failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-  } else if (phase === "rem") {
-    if (!dryRun) {
-      if (!phaseRunner) {
-        throw new Error("REM manual runs require a phase runner");
-      }
-      const result = await phaseRunner({ memoryDir, phase });
-      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));
-      notes = result.notes ?? `REM pass assessed ${itemsProcessed} memories`;
-    } else {
-      try {
-        const stateFilePath = path.join(memoryDir, "state", "semantic-consolidation-last-run.json");
-        let lastRunAt = null;
-        try {
-          const stateRaw = await fileReader(stateFilePath, "utf-8");
-          const stateData = JSON.parse(stateRaw);
-          lastRunAt = stateData.lastRunAt ?? null;
-        } catch {
-        }
-        const memFiles = await listMemoryFiles(memoryDir);
-        itemsProcessed = memFiles.length;
-        notes = `dry-run: ${itemsProcessed} memories would enter REM consolidation pass${lastRunAt ? ` (last run: ${lastRunAt})` : " (never run)"}`;
-      } catch (err) {
-        throw new Error(`REM scan failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-  } else {
-    if (governanceRunner) {
-      try {
-        const result = await governanceRunner({ memoryDir, dryRun });
-        itemsProcessed = result.scannedMemories;
-        notes = result.notes ?? (dryRun ? `dry-run: ${result.appliedActionCount} actions proposed` : `${result.appliedActionCount} actions applied`);
-      } catch (err) {
-        throw new Error(`deep-sleep governance run failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    } else {
-      const memFiles = await listMemoryFiles(memoryDir);
-      itemsProcessed = memFiles.length;
-      notes = dryRun ? `dry-run: ${itemsProcessed} memories eligible for deep-sleep governance` : `assessed ${itemsProcessed} memories for deep-sleep governance`;
-    }
-  }
-  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));
-  let ledgerEntry;
-  try {
-    ledgerEntry = await recordDreamsPhaseRun({
-      memoryDir,
-      startedAt,
-      completedAt,
-      phase,
-      itemsProcessed,
-      dryRun,
-      trigger: "manual",
-      notes
-    });
-  } catch {
-  }
-  return {
-    phase,
-    dryRun,
-    durationMs: ledgerEntry?.durationMs ?? durationMs,
-    itemsProcessed,
-    notes,
-    ledgerEntry
-  };
-}
-function summarizeGovernanceResultForDreams(govResult, dryRun) {
-  const proposedCount = govResult.proposedActions.length;
-  const appliedCount = govResult.appliedActions.length;
-  const scannedCount = typeof govResult.summary?.scannedMemories === "number" && Number.isFinite(govResult.summary.scannedMemories) ? Math.max(0, Math.floor(govResult.summary.scannedMemories)) : govResult.reviewQueue.length;
-  return {
-    scannedMemories: scannedCount,
-    appliedActionCount: appliedCount,
-    notes: dryRun ? `shadow mode: ${proposedCount} actions proposed` : `applied ${appliedCount} actions`
-  };
-}
-async function listMemoryFiles(memoryDir) {
-  const out = [];
-  try {
-    const root = await lstat(memoryDir);
-    if (root.isSymbolicLink()) {
-      throw new Error(`memoryDir must not be a symlink: ${memoryDir}`);
-    }
-    if (!root.isDirectory()) return out;
-  } catch (err) {
-    if (err instanceof Error && /must not be a symlink/.test(err.message)) {
-      throw err;
-    }
-    return out;
-  }
-  async function walk(dir) {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.isSymbolicLink()) continue;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === "state" || entry.name === "archive" || entry.name === "namespaces" || entry.name === ".git") continue;
-        await walk(full);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        out.push(full);
-      }
-    }
-  }
-  await walk(memoryDir);
-  return out;
-}
-export {
-  appendDreamsLedgerEntry,
-  dreamsLedgerPath,
-  getDreamsStatus,
-  normalizeDreamsStatusWindowHours,
-  readDreamsLedgerEntries,
-  recordDreamsPhaseRun,
-  runDreamsPhase,
-  summarizeGovernanceResultForDreams
-};

package/dist/engine-7VG3IXKN.js

@@ -1,16 +0,0 @@
-import {
-  CompoundingEngine,
-  defaultTierMigrationCycleBudget
-} from "./chunk-QVTGUY3H.js";
-import "./chunk-4XDQ3KEC.js";
-import "./chunk-YXDXRE6N.js";
-import "./chunk-QMUQV5NP.js";
-import "./chunk-BQZ7JACP.js";
-import "./chunk-UFU5GGGA.js";
-import "./chunk-YGGGUTG3.js";
-import "./chunk-EH4AXGRO.js";
-import "./chunk-I2KLQ2HA.js";
-export {
-  CompoundingEngine,
-  defaultTierMigrationCycleBudget
-};

package/dist/extraction-judge-telemetry-O4ZVGLTU.js

@@ -1,14 +0,0 @@
-import {
-  EXTRACTION_JUDGE_VERDICT_CATEGORY,
-  judgeTelemetryPath,
-  readJudgeVerdictStats,
-  recordJudgeVerdict
-} from "./chunk-5ZW5XJQ6.js";
-import "./chunk-UFU5GGGA.js";
-import "./chunk-I2KLQ2HA.js";
-export {
-  EXTRACTION_JUDGE_VERDICT_CATEGORY,
-  judgeTelemetryPath,
-  readJudgeVerdictStats,
-  recordJudgeVerdict
-};

package/dist/fallback-llm-43UMEXNJ.js

@@ -1,10 +0,0 @@
-import {
-  FallbackLlmClient
-} from "./chunk-SWOYEQN2.js";
-import "./chunk-3A5ELHTT.js";
-import "./chunk-UFU5GGGA.js";
-import "./chunk-EH4AXGRO.js";
-import "./chunk-I2KLQ2HA.js";
-export {
-  FallbackLlmClient
-};

package/dist/first-start-migration-H2SAXAGR.js

@@ -1,263 +0,0 @@
-import {
-  TierMigrationExecutor
-} from "./chunk-BU5KJVWF.js";
-import {
-  applyUtilityPromotionRuntimePolicy,
-  decideTierTransition,
-  loadUtilityRuntimeValues
-} from "./chunk-LZCGPRHS.js";
-import "./chunk-BZ4EYURA.js";
-import "./chunk-3G7FAF6S.js";
-import "./chunk-25J4PXDH.js";
-import "./chunk-I2KLQ2HA.js";
-
-// ../remnic-core/src/maintenance/first-start-migration.ts
-import path from "path";
-import * as fsReadModule0 from "fs/promises";
-const access = fsReadModule0.access;
-const mkdir = fsReadModule0.mkdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const unlink = fsReadModule0.unlink;
-const writeFile = fsReadModule0.writeFile;
-var FIRST_START_DEMOTION_CAP = 50;
-var LIFECYCLE_INIT_DONE_MARKER = ".lifecycle-init-done";
-var LIFECYCLE_QMD_REFRESH_PENDING_MARKER = ".lifecycle-qmd-refresh-pending";
-function markerPath(memoryDir) {
-  return path.join(memoryDir, "state", LIFECYCLE_INIT_DONE_MARKER);
-}
-function qmdRefreshPendingPath(memoryDir) {
-  return path.join(memoryDir, "state", LIFECYCLE_QMD_REFRESH_PENDING_MARKER);
-}
-async function markerExists(memoryDir) {
-  try {
-    await access(markerPath(memoryDir));
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function writeMarker(memoryDir, now) {
-  const p = markerPath(memoryDir);
-  await mkdir(path.dirname(p), { recursive: true });
-  await writeFile(p, JSON.stringify({ createdAt: now.toISOString() }), "utf-8");
-}
-async function readQmdRefreshPending(memoryDir) {
-  try {
-    const raw = await fileReader(qmdRefreshPendingPath(memoryDir), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && typeof parsed.createdAt === "string" && typeof parsed.collection === "string" && parsed.collection.length > 0) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function pathExists(p) {
-  try {
-    await access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function writeQmdRefreshPending(memoryDir, now, collection) {
-  const p = qmdRefreshPendingPath(memoryDir);
-  await mkdir(path.dirname(p), { recursive: true });
-  await writeFile(p, JSON.stringify({ createdAt: now.toISOString(), collection }), "utf-8");
-}
-async function clearQmdRefreshPending(memoryDir) {
-  await unlink(qmdRefreshPendingPath(memoryDir)).catch(() => {
-  });
-}
-async function buildTierRoutingPolicy(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 refreshQmdCollection(qmd, collection, signal) {
-  if (typeof qmd.updateCollectionStrict === "function") {
-    await qmd.updateCollectionStrict(collection, { signal });
-    return;
-  }
-  await qmd.updateCollection(collection, { signal });
-}
-async function runFirstStartMigration(options) {
-  const {
-    storage,
-    config,
-    demotionCap = FIRST_START_DEMOTION_CAP,
-    dryRun = false,
-    qmd,
-    signal
-  } = options;
-  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))();
-  const abortedResult = (candidateCount2 = 0, demotedCount2 = 0, failureCount2 = 0) => ({
-    skipped: candidateCount2 === 0 && demotedCount2 === 0 && failureCount2 === 0,
-    skipReason: candidateCount2 === 0 && demotedCount2 === 0 && failureCount2 === 0 ? "aborted" : void 0,
-    dryRun,
-    candidateCount: candidateCount2,
-    demotedCount: demotedCount2,
-    failureCount: failureCount2,
-    cappedAt: demotionCap
-  });
-  if (signal?.aborted) {
-    return abortedResult();
-  }
-  if (!config.lifecyclePolicyEnabled) {
-    return {
-      skipped: true,
-      skipReason: "lifecyclePolicyEnabled is false",
-      dryRun,
-      candidateCount: 0,
-      demotedCount: 0,
-      failureCount: 0,
-      cappedAt: demotionCap
-    };
-  }
-  if (!config.qmdTierMigrationEnabled) {
-    return {
-      skipped: true,
-      skipReason: "qmdTierMigrationEnabled is false",
-      dryRun,
-      candidateCount: 0,
-      demotedCount: 0,
-      failureCount: 0,
-      cappedAt: demotionCap
-    };
-  }
-  if (await markerExists(config.memoryDir)) {
-    return {
-      skipped: true,
-      skipReason: "lifecycle-init-done marker already present",
-      dryRun,
-      candidateCount: 0,
-      demotedCount: 0,
-      failureCount: 0,
-      cappedAt: demotionCap
-    };
-  }
-  if (signal?.aborted) {
-    return abortedResult();
-  }
-  const policy = await buildTierRoutingPolicy(config);
-  if (signal?.aborted) {
-    return abortedResult();
-  }
-  const hotMemories = await storage.readAllMemories();
-  if (signal?.aborted) {
-    return abortedResult();
-  }
-  const demotionCandidates = hotMemories.filter((m) => {
-    const decision = decideTierTransition(m, "hot", policy, now);
-    return decision.changed && decision.nextTier === "cold";
-  });
-  const candidateCount = demotionCandidates.length;
-  const batch = demotionCandidates.slice(0, demotionCap);
-  if (dryRun) {
-    return {
-      skipped: false,
-      dryRun: true,
-      candidateCount,
-      demotedCount: 0,
-      failureCount: 0,
-      cappedAt: demotionCap
-    };
-  }
-  let demotedCount = 0;
-  let failureCount = 0;
-  let qmdRefreshPendingForRun = false;
-  const executor = qmd ? new TierMigrationExecutor({
-    storage,
-    qmd,
-    hotCollection: options.hotCollection ?? config.qmdCollection ?? "openclaw-engram",
-    coldCollection: options.coldCollection ?? config.qmdColdCollection ?? "openclaw-engram-cold"
-  }) : null;
-  const coldCollection = options.coldCollection ?? config.qmdColdCollection ?? "openclaw-engram-cold";
-  for (const memory of batch) {
-    if (signal?.aborted) {
-      return abortedResult(candidateCount, demotedCount, failureCount);
-    }
-    try {
-      if (executor) {
-        await executor.migrateMemory({
-          memory,
-          fromTier: "hot",
-          toTier: "cold",
-          reason: "first-start-lifecycle-migration"
-        });
-      } else {
-        await storage.migrateMemoryToTier(memory, "cold");
-      }
-      demotedCount += 1;
-    } catch {
-      const targetPath = storage.buildTierMemoryPath(memory, "cold");
-      const [targetExists, sourceExists] = await Promise.all([
-        pathExists(targetPath),
-        pathExists(memory.path)
-      ]);
-      const movedToCold = targetExists && !sourceExists;
-      if (movedToCold) {
-        if (!qmd) {
-          demotedCount += 1;
-          continue;
-        }
-        try {
-          await refreshQmdCollection(qmd, coldCollection, signal);
-          demotedCount += 1;
-          continue;
-        } catch {
-          qmdRefreshPendingForRun = true;
-          try {
-            await writeQmdRefreshPending(config.memoryDir, now, coldCollection);
-          } catch {
-          }
-          demotedCount += 1;
-          continue;
-        }
-      }
-      failureCount += 1;
-    }
-  }
-  if (signal?.aborted) {
-    return abortedResult(candidateCount, demotedCount, failureCount);
-  }
-  const persistedQmdRefreshPending = qmd ? await readQmdRefreshPending(config.memoryDir) : null;
-  const hasPersistedQmdRefreshPending = persistedQmdRefreshPending?.collection === coldCollection;
-  if (qmd && persistedQmdRefreshPending && persistedQmdRefreshPending.collection !== coldCollection) {
-    failureCount += 1;
-  }
-  if (qmd && (qmdRefreshPendingForRun || hasPersistedQmdRefreshPending)) {
-    try {
-      await refreshQmdCollection(qmd, coldCollection, signal);
-      await clearQmdRefreshPending(config.memoryDir);
-    } catch {
-      failureCount += 1;
-    }
-  }
-  if (failureCount === 0) {
-    await writeMarker(config.memoryDir, now);
-  }
-  return {
-    skipped: false,
-    dryRun: false,
-    candidateCount,
-    demotedCount,
-    failureCount,
-    cappedAt: demotionCap
-  };
-}
-export {
-  FIRST_START_DEMOTION_CAP,
-  LIFECYCLE_INIT_DONE_MARKER,
-  runFirstStartMigration
-};

package/dist/forget-ZECIDNL5.js

@@ -1,68 +0,0 @@
-import "./chunk-I2KLQ2HA.js";
-
-// ../remnic-core/src/maintenance/forget.ts
-var ForgetMemoryNotFoundError = class extends Error {
-  code = "memory_not_found";
-  constructor(id) {
-    super(`memory not found: ${id}`);
-    this.name = "ForgetMemoryNotFoundError";
-  }
-};
-var ForgetMemoryAlreadyForgottenError = class extends Error {
-  code = "already_forgotten";
-  constructor(id, forgottenAt) {
-    super(`memory ${id} was already forgotten at ${forgottenAt}`);
-    this.name = "ForgetMemoryAlreadyForgottenError";
-  }
-};
-async function forgetMemory(storage, request) {
-  const id = typeof request.id === "string" ? request.id.trim() : "";
-  if (id.length === 0) {
-    throw new Error("forget: memory id is required and must be non-empty");
-  }
-  const memory = await findMemoryById(storage, id);
-  if (!memory) {
-    throw new ForgetMemoryNotFoundError(id);
-  }
-  if (memory.frontmatter.status === "forgotten") {
-    throw new ForgetMemoryAlreadyForgottenError(
-      id,
-      memory.frontmatter.forgottenAt ?? "(unknown)"
-    );
-  }
-  const priorStatus = typeof memory.frontmatter.status === "string" ? memory.frontmatter.status : "active";
-  const now = (request.now ?? (() => /* @__PURE__ */ new Date()))();
-  const forgottenAt = now.toISOString();
-  const reason = typeof request.reason === "string" ? request.reason.trim() : "";
-  await storage.writeMemoryFrontmatter(memory, {
-    status: "forgotten",
-    forgottenAt,
-    forgottenReason: reason.length > 0 ? reason : void 0,
-    updated: forgottenAt
-  }, {
-    actor: "remnic-forget",
-    reasonCode: "operator_forget"
-  });
-  return {
-    id,
-    path: memory.path,
-    priorStatus,
-    forgottenAt,
-    reason
-  };
-}
-async function findMemoryById(storage, id) {
-  const hot = await storage.readAllMemories();
-  const hotMatch = hot.find((m) => m.frontmatter.id === id);
-  if (hotMatch) return hotMatch;
-  const archived = await storage.readArchivedMemories();
-  const archivedMatch = archived.find((m) => m.frontmatter.id === id);
-  if (archivedMatch) return archivedMatch;
-  const cold = await storage.readAllColdMemories();
-  return cold.find((m) => m.frontmatter.id === id) ?? null;
-}
-export {
-  ForgetMemoryAlreadyForgottenError,
-  ForgetMemoryNotFoundError,
-  forgetMemory
-};

package/dist/fs-utils-OYXSZSVV.js

@@ -1,39 +0,0 @@
-import {
-  assertIsDirectoryNotSymlink,
-  assertRealpathInsideRoot,
-  ensureDirExists,
-  fileExists,
-  fromPosixRelPath,
-  isPathInsideRoot,
-  listFilesRecursive,
-  prepareSafeArchiveRoot,
-  readJsonFile,
-  readUtf8FileStrict,
-  resolveSafeArchiveTarget,
-  sha256Bytes,
-  sha256File,
-  sha256String,
-  toPosixRelPath,
-  validateArchiveRelativePath,
-  writeJsonFile
-} from "./chunk-YKV4EFUI.js";
-import "./chunk-I2KLQ2HA.js";
-export {
-  assertIsDirectoryNotSymlink,
-  assertRealpathInsideRoot,
-  ensureDirExists,
-  fileExists,
-  fromPosixRelPath,
-  isPathInsideRoot,
-  listFilesRecursive,
-  prepareSafeArchiveRoot,
-  readJsonFile,
-  readUtf8FileStrict,
-  resolveSafeArchiveTarget,
-  sha256Bytes,
-  sha256File,
-  sha256String,
-  toPosixRelPath,
-  validateArchiveRelativePath,
-  writeJsonFile
-};