@remnic/plugin-openclaw 1.0.54 → 9.3.515

package/dist/chunk-B52XADV3.js

@@ -1,244 +0,0 @@
-import {
-  gatherConsoleState
-} from "./chunk-MBIFE6SA.js";
-
-// ../remnic-core/src/console/tui.ts
-var ANSI_CLEAR_HOME = "\x1B[2J\x1B[H";
-var ANSI_HIDE_CURSOR = "\x1B[?25l";
-var ANSI_SHOW_CURSOR = "\x1B[?25h";
-var FRAME_INNER_WIDTH = 70;
-var DEFAULT_REFRESH_INTERVAL_MS = 2e3;
-function runConsoleTui(orchestrator, options = {}) {
-  const refreshIntervalMs = Math.max(
-    50,
-    options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS
-  );
-  const output = options.output ?? process.stdout;
-  const now = options.now ?? (() => Date.now());
-  const installSigintHandler = options.installSigintHandler ?? true;
-  let stopped = false;
-  let inFlight = false;
-  let inFlightTickPromise = null;
-  let traceWritePending = false;
-  let traceFramesDropped = 0;
-  let resolveDone;
-  const done = new Promise((resolve) => {
-    resolveDone = resolve;
-  });
-  safeWrite(output, ANSI_HIDE_CURSOR);
-  const tick = async () => {
-    if (stopped || inFlight) return;
-    inFlight = true;
-    try {
-      let snapshot = null;
-      let renderError = null;
-      try {
-        snapshot = await gatherConsoleState(orchestrator);
-      } catch (err) {
-        renderError = describeError(err);
-      }
-      if (stopped) return;
-      let frame;
-      try {
-        frame = renderFrame({ snapshot, renderError, now });
-      } catch (err) {
-        frame = `remnic console: render failed: ${describeError(err)}
-`;
-      }
-      safeWrite(output, ANSI_CLEAR_HOME);
-      safeWrite(output, frame);
-      if (snapshot && options.traceRecorder && !traceWritePending) {
-        traceWritePending = true;
-        void options.traceRecorder.append(snapshot).catch(() => {
-        }).finally(() => {
-          traceWritePending = false;
-        });
-      } else if (snapshot && options.traceRecorder) {
-        traceFramesDropped += 1;
-      }
-    } finally {
-      inFlight = false;
-    }
-  };
-  const launchTick = () => {
-    const p = runTickSafely(tick);
-    inFlightTickPromise = p;
-    void p.then(() => {
-      if (inFlightTickPromise === p) {
-        inFlightTickPromise = null;
-      }
-    });
-  };
-  launchTick();
-  const handle = setInterval(launchTick, refreshIntervalMs);
-  const sigintHandler = () => {
-    stop();
-  };
-  if (installSigintHandler) {
-    process.on("SIGINT", sigintHandler);
-  }
-  const stop = () => {
-    if (stopped) return;
-    stopped = true;
-    clearInterval(handle);
-    if (installSigintHandler) {
-      try {
-        process.removeListener("SIGINT", sigintHandler);
-      } catch {
-      }
-    }
-    safeWrite(output, ANSI_SHOW_CURSOR);
-    void (async () => {
-      try {
-        const pendingTick = inFlightTickPromise;
-        if (pendingTick) {
-          await pendingTick;
-        }
-      } finally {
-        resolveDone();
-      }
-    })();
-  };
-  return {
-    stop,
-    done,
-    getDroppedTraceFrames: () => traceFramesDropped
-  };
-}
-function renderFrame(input) {
-  const ts = new Date(input.now()).toISOString();
-  const lines = [];
-  lines.push(renderHeader(ts));
-  for (const panel of renderPanels(input)) {
-    lines.push(panel);
-  }
-  lines.push(renderFooter());
-  return lines.join("\n") + "\n";
-}
-function renderHeader(ts) {
-  const title = " remnic console ";
-  const trailing = ` ${ts} `;
-  const fillerLen = Math.max(
-    1,
-    FRAME_INNER_WIDTH - title.length - trailing.length
-  );
-  const filler = "\u2550".repeat(fillerLen);
-  return `\u2554${title}${filler}${trailing}\u2557`;
-}
-function renderFooter() {
-  return `\u255A${"\u2550".repeat(FRAME_INNER_WIDTH)}\u255D`;
-}
-function renderPanels(input) {
-  const lines = [];
-  const snap = input.snapshot;
-  if (input.renderError !== null) {
-    lines.push(panelLine("Error", `refresh failed: ${input.renderError}`));
-    lines.push(panelLine("Buffer", "(unavailable)"));
-    lines.push(panelLine("Extraction", "(unavailable)"));
-    lines.push(panelLine("Dedup", "(unavailable)"));
-    lines.push(panelLine("Maintenance", "(unavailable)"));
-    lines.push(panelLine("QMD", "(unavailable)"));
-    return lines;
-  }
-  if (snap) {
-    lines.push(
-      panelLine(
-        "Buffer",
-        `turns=${snap.bufferState.turnsCount} bytes=${snap.bufferState.byteCount}`
-      )
-    );
-    const verdicts = snap.extractionQueue.recentVerdicts;
-    const accepts = verdicts.filter((v) => v.kind === "accept").length;
-    const rejects = verdicts.filter((v) => v.kind === "reject").length;
-    lines.push(
-      panelLine(
-        "Extraction",
-        `queue=${snap.extractionQueue.depth}  recent verdicts: accept(${accepts})/reject(${rejects})`
-      )
-    );
-    const dedupSummary = formatDedupSummary(snap.dedupRecent, input.now);
-    lines.push(panelLine("Dedup", dedupSummary));
-    const maintSummary = formatMaintenanceTail(snap.maintenanceLedgerTail);
-    lines.push(panelLine("Maintenance", maintSummary));
-    lines.push(panelLine("QMD", formatQmdSummary(snap)));
-  }
-  if (snap && snap.errors.length > 0) {
-    const head = snap.errors[0];
-    lines.push(panelLine("Errors", head ?? ""));
-  }
-  return lines;
-}
-function formatDedupSummary(decisions, now) {
-  if (decisions.length === 0) return "no recent decisions";
-  const last = decisions[decisions.length - 1];
-  if (!last) return "no recent decisions";
-  const ageMs = ageMsFromIso(last.ts, now);
-  const ageStr = ageMs === null ? "T-?" : `T-${Math.round(ageMs / 1e3)}s`;
-  const fp = last.fingerprint ? `hash=${last.fingerprint}` : "hash=?";
-  return `recent: ${fp} decision=${last.decision} (${ageStr})`;
-}
-function formatMaintenanceTail(events) {
-  if (events.length === 0) return "no events";
-  const last = events[events.length - 1];
-  if (!last) return "no events";
-  return `n=${events.length}  last: ${last.category} ${truncate(last.summary, 40)}`;
-}
-function formatQmdSummary(snap) {
-  const probe = snap.qmdProbe.available ? "ok" : "down";
-  const uptimeH = snap.daemon.uptimeMs / 36e5;
-  const uptimeStr = uptimeH < 1 ? `${Math.round(snap.daemon.uptimeMs / 1e3)}s` : `${uptimeH.toFixed(1)}h`;
-  const mode = snap.qmdProbe.daemonMode ? "daemon" : "cli";
-  return `probe=${probe}  mode=${mode}  uptime=${uptimeStr}`;
-}
-function panelLine(label, value) {
-  const LABEL_WIDTH = 13;
-  const labelCol = padRight(label, LABEL_WIDTH);
-  const remaining = FRAME_INNER_WIDTH - LABEL_WIDTH - 2;
-  const valueCol = padRight(truncate(value, remaining), remaining);
-  return `\u2551 ${labelCol}${valueCol} \u2551`;
-}
-function padRight(s, width) {
-  if (s.length >= width) return s;
-  return s + " ".repeat(width - s.length);
-}
-function truncate(s, max) {
-  if (max <= 0) return "";
-  if (s.length <= max) return s;
-  if (max <= 1) return s.slice(0, max);
-  return s.slice(0, max - 1) + "\u2026";
-}
-function ageMsFromIso(iso, now) {
-  const ms = Date.parse(iso);
-  if (!Number.isFinite(ms)) return null;
-  const delta = now() - ms;
-  return delta < 0 ? 0 : delta;
-}
-async function runTickSafely(tick) {
-  try {
-    await tick();
-  } catch {
-  }
-}
-function safeWrite(output, chunk) {
-  try {
-    output.write(chunk);
-  } catch {
-  }
-}
-function describeError(err) {
-  if (err instanceof Error) return err.message;
-  try {
-    return String(err);
-  } catch {
-    return "unknown error";
-  }
-}
-function stripAnsi(s) {
-  return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
-}
-
-export {
-  runConsoleTui,
-  renderFrame,
-  stripAnsi
-};

package/dist/chunk-BQZ7JACP.js

@@ -1,389 +0,0 @@
-import {
-  AUTH_TAG_LENGTH,
-  ENVELOPE_HEADER_SIZE,
-  ENVELOPE_LAYOUT,
-  ENVELOPE_SALT_LENGTH,
-  ENVELOPE_VERSION,
-  IV_LENGTH,
-  generateSalt,
-  open,
-  seal
-} from "./chunk-YGGGUTG3.js";
-
-// ../remnic-core/src/secure-store/secure-fs.ts
-import { createCipheriv, randomBytes } from "crypto";
-import * as fsReadModule0 from "fs/promises";
-const lstat = fsReadModule0.lstat;
-const mkdir = fsReadModule0.mkdir;
-const openFile = fsReadModule0.open;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const readdir = fsReadModule0.readdir;
-const rename = fsReadModule0.rename;
-const unlink = fsReadModule0.unlink;
-const writeFile = fsReadModule0.writeFile;
-import path from "path";
-var SecureStoreLockedError = class extends Error {
-  constructor(message = "secure-store is locked \u2014 run `remnic secure-store unlock` to decrypt") {
-    super(message);
-    this.name = "SecureStoreLockedError";
-  }
-};
-var SecureStoreDecryptError = class extends Error {
-  constructor(message = "secure-store decryption failed \u2014 wrong key or tampered ciphertext") {
-    super(message);
-    this.name = "SecureStoreDecryptError";
-  }
-};
-var MAGIC_BYTES = Buffer.from("REMNIC-ENC", "ascii");
-var FILE_FORMAT_VERSION = 1;
-var FILE_FORMAT_FLAGS = 0;
-var MAGIC_HEADER_SIZE = MAGIC_BYTES.length + 2;
-function isEncryptedFile(buf) {
-  if (buf.length < MAGIC_HEADER_SIZE) return false;
-  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
-  return b.subarray(0, MAGIC_BYTES.length).equals(MAGIC_BYTES);
-}
-function encryptFileBody(plain, key, aad) {
-  const plainBuf = typeof plain === "string" ? Buffer.from(plain, "utf8") : plain;
-  const salt = generateSalt();
-  const envelope = seal(key, salt, plainBuf, aad ? { aad } : {});
-  const header = Buffer.alloc(MAGIC_HEADER_SIZE);
-  MAGIC_BYTES.copy(header, 0);
-  header.writeUInt8(FILE_FORMAT_VERSION, MAGIC_BYTES.length);
-  header.writeUInt8(FILE_FORMAT_FLAGS, MAGIC_BYTES.length + 1);
-  return Buffer.concat([header, envelope]);
-}
-function decryptFileBody(buf, key, aad) {
-  if (!isEncryptedFile(buf)) {
-    throw new Error("decryptFileBody: buffer does not start with REMNIC-ENC magic header");
-  }
-  const version = buf.readUInt8(MAGIC_BYTES.length);
-  if (version !== FILE_FORMAT_VERSION) {
-    throw new Error(
-      `decryptFileBody: unsupported file format version ${version} (this build supports ${FILE_FORMAT_VERSION})`
-    );
-  }
-  const flags = buf.readUInt8(MAGIC_BYTES.length + 1);
-  if (flags !== FILE_FORMAT_FLAGS) {
-    throw new Error(`decryptFileBody: unknown flags byte 0x${flags.toString(16).padStart(2, "0")}`);
-  }
-  const envelope = buf.subarray(MAGIC_HEADER_SIZE);
-  try {
-    return open(key, envelope, aad ? { aad } : {});
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new SecureStoreDecryptError(
-      `secure-store decryption failed: ${msg}`
-    );
-  }
-}
-function buildHeaderAad(salt) {
-  const out = Buffer.alloc(1 + ENVELOPE_SALT_LENGTH);
-  out.writeUInt8(ENVELOPE_VERSION, 0);
-  Buffer.from(salt).copy(out, 1);
-  return out;
-}
-function filePathAad(filePath, memoryDir) {
-  let rel = filePath;
-  if (memoryDir && path.isAbsolute(filePath)) {
-    rel = path.relative(memoryDir, filePath);
-  }
-  return Buffer.from(rel, "utf8");
-}
-async function readMaybeEncryptedFileBuffer(filePath, key, memoryDir) {
-  const buf = await fileReader(filePath);
-  if (!isEncryptedFile(buf)) {
-    return buf;
-  }
-  if (key === null) {
-    throw new SecureStoreLockedError(
-      `secure-store is locked \u2014 cannot read encrypted file at ${filePath}. Run \`remnic secure-store unlock\` to decrypt.`
-    );
-  }
-  const aad = filePathAad(filePath, memoryDir);
-  return decryptFileBody(buf, key, aad);
-}
-async function readMaybeEncryptedFile(filePath, key, memoryDir) {
-  return (await readMaybeEncryptedFileBuffer(filePath, key, memoryDir)).toString("utf8");
-}
-async function writeMaybeEncryptedFile(filePath, content, key, options = {}, memoryDir) {
-  const { mode = 384, atomic = true } = options;
-  await mkdir(path.dirname(filePath), { recursive: true });
-  let data;
-  if (key !== null) {
-    const aad = filePathAad(filePath, memoryDir);
-    data = encryptFileBody(content, key, aad);
-  } else {
-    data = content;
-  }
-  if (atomic) {
-    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    try {
-      await writeFile(tempPath, data, { mode });
-      await rename(tempPath, filePath);
-    } catch (err) {
-      try {
-        await unlink(tempPath);
-      } catch {
-      }
-      throw err;
-    }
-  } else {
-    await writeFile(filePath, data, { mode });
-  }
-}
-async function writeMaybeEncryptedFileFromChunks(filePath, chunks, key, options = {}, memoryDir) {
-  const { mode = 384, atomic = true } = options;
-  await mkdir(path.dirname(filePath), { recursive: true });
-  const writePath = atomic ? `${filePath}.tmp-${process.pid}-${Date.now()}` : filePath;
-  let completed = false;
-  try {
-    const handle = await openFile(writePath, "w", mode);
-    try {
-      if (key !== null) {
-        const salt = generateSalt();
-        const iv = randomBytes(IV_LENGTH);
-        const header = Buffer.alloc(MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE);
-        MAGIC_BYTES.copy(header, 0);
-        header.writeUInt8(FILE_FORMAT_VERSION, MAGIC_BYTES.length);
-        header.writeUInt8(FILE_FORMAT_FLAGS, MAGIC_BYTES.length + 1);
-        const envelopeOffset = MAGIC_HEADER_SIZE;
-        header.writeUInt8(ENVELOPE_VERSION, envelopeOffset + ENVELOPE_LAYOUT.version);
-        salt.copy(header, envelopeOffset + ENVELOPE_LAYOUT.salt);
-        iv.copy(header, envelopeOffset + ENVELOPE_LAYOUT.iv);
-        await handle.write(header);
-        const cipher = createCipheriv("aes-256-gcm", key, iv, { authTagLength: AUTH_TAG_LENGTH });
-        const aad = filePathAad(filePath, memoryDir);
-        cipher.setAAD(Buffer.concat([buildHeaderAad(salt), aad]));
-        for await (const chunk of chunks) {
-          if (chunk.length === 0) continue;
-          const encrypted = cipher.update(chunk);
-          if (encrypted.length > 0) await handle.write(encrypted);
-        }
-        const final = cipher.final();
-        if (final.length > 0) await handle.write(final);
-        const authTag = cipher.getAuthTag();
-        await handle.write(
-          authTag,
-          0,
-          authTag.length,
-          MAGIC_HEADER_SIZE + ENVELOPE_LAYOUT.authTag
-        );
-      } else {
-        for await (const chunk of chunks) {
-          if (chunk.length > 0) await handle.write(chunk);
-        }
-      }
-    } finally {
-      await handle.close();
-    }
-    if (atomic) {
-      await rename(writePath, filePath);
-    }
-    completed = true;
-  } finally {
-    if (!completed && atomic) {
-      await unlink(writePath).catch(() => {
-      });
-    }
-  }
-}
-async function migrateMemoryDirToEncrypted(dir, key, onBeforeEncrypt) {
-  const result = { encrypted: 0, skipped: 0, errors: [] };
-  const files = await collectEncryptableStorageFiles(dir);
-  for (const filePath of files) {
-    try {
-      const buf = await fileReader(filePath);
-      if (isEncryptedFile(buf)) {
-        result.skipped++;
-        continue;
-      }
-      if (onBeforeEncrypt) {
-        try {
-          await onBeforeEncrypt(filePath);
-        } catch {
-        }
-      }
-      const content = buf.toString("utf8");
-      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
-      const encrypted = encryptFileBody(content, key, aad);
-      const tempPath = `${filePath}.enc-tmp-${process.pid}-${Date.now()}`;
-      try {
-        await writeFile(tempPath, encrypted, { mode: 384 });
-        await rename(tempPath, filePath);
-        result.encrypted++;
-      } catch (writeErr) {
-        try {
-          const { unlink: unlink2 } = await import("fs/promises");
-          await unlink2(tempPath);
-        } catch {
-        }
-        throw writeErr;
-      }
-    } catch (err) {
-      result.errors.push({
-        filePath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return result;
-}
-async function decryptMemoryDirToPlaintext(dir, key) {
-  const result = { decrypted: 0, skipped: 0, errors: [] };
-  const files = await collectStorageManagedFiles(dir, isDecryptableStoragePath);
-  for (const filePath of files) {
-    try {
-      const buf = await fileReader(filePath);
-      if (!isEncryptedFile(buf)) {
-        result.skipped++;
-        continue;
-      }
-      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
-      const plaintext = decryptFileBody(buf, key, aad);
-      const tempPath = `${filePath}.dec-tmp-${process.pid}-${Date.now()}`;
-      try {
-        await writeFile(tempPath, plaintext, { mode: 384 });
-        await rename(tempPath, filePath);
-        result.decrypted++;
-      } catch (writeErr) {
-        try {
-          await unlink(tempPath);
-        } catch {
-        }
-        throw writeErr;
-      }
-    } catch (err) {
-      result.errors.push({
-        filePath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return result;
-}
-async function collectEncryptableStorageFiles(dir, rootDir = dir) {
-  return collectStorageManagedFiles(dir, isEncryptableStoragePath, rootDir);
-}
-async function collectStorageManagedFiles(dir, includeFile, rootDir = dir) {
-  const results = [];
-  let names;
-  try {
-    names = await readdir(dir, { encoding: "utf8" });
-  } catch {
-    return results;
-  }
-  for (const name of names) {
-    if (name.startsWith(".secure-store")) continue;
-    const full = path.join(dir, name);
-    let isDir = false;
-    let isFile = false;
-    try {
-      const s = await lstat(full);
-      if (s.isSymbolicLink()) continue;
-      isDir = s.isDirectory();
-      isFile = s.isFile();
-    } catch {
-      continue;
-    }
-    if (isDir) {
-      const sub = await collectStorageManagedFiles(full, includeFile, rootDir);
-      results.push(...sub);
-    } else if (isFile && includeFile(full, rootDir)) {
-      results.push(full);
-    }
-  }
-  return results;
-}
-function isEncryptableStoragePath(filePath, rootDir) {
-  const rel = path.relative(rootDir, filePath);
-  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
-  const normalized = normalizeStorageRelativePath(rel);
-  if (normalized === "profile.md") return true;
-  if (isEncryptableStateSidecar(normalized)) return true;
-  if (isEncryptableSummarySidecar(normalized)) return true;
-  const firstSegment = normalized.split("/", 1)[0];
-  return ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS.has(firstSegment) && normalized.endsWith(".md");
-}
-function isDecryptableStoragePath(filePath, rootDir) {
-  if (isEncryptableStoragePath(filePath, rootDir)) return true;
-  const rel = path.relative(rootDir, filePath);
-  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
-  const normalized = normalizeStorageRelativePath(rel);
-  const firstSegment = normalized.split("/", 1)[0];
-  return DECRYPTABLE_SIDECAR_ROOTS.has(firstSegment);
-}
-function normalizeStorageRelativePath(rel) {
-  const normalized = rel.split(path.sep).join("/");
-  const parts = normalized.split("/");
-  if (parts[0] === "namespaces" && parts.length >= 3) {
-    return parts.slice(2).join("/");
-  }
-  return normalized;
-}
-function storageAadRootForFile(filePath, rootDir) {
-  const rel = path.relative(rootDir, filePath);
-  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return rootDir;
-  const parts = rel.split(path.sep);
-  if (parts[0] === "namespaces" && parts.length >= 3 && parts[1]) {
-    return path.join(rootDir, "namespaces", parts[1]);
-  }
-  return rootDir;
-}
-var ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = /* @__PURE__ */ new Set([
-  "facts",
-  "corrections",
-  "procedures",
-  "reasoning-traces",
-  "artifacts",
-  "archive",
-  "entities",
-  "identity"
-]);
-var ENCRYPTABLE_STATE_SIDECARS = /* @__PURE__ */ new Set([
-  "state/behavior-signals.jsonl",
-  "state/buffer-surprise-ledger.jsonl",
-  "state/buffer.json",
-  "state/compression-guideline-draft-state.json",
-  "state/compression-guideline-state.json",
-  "state/compression-guidelines.draft.md",
-  "state/compression-guidelines.md",
-  "state/entity-synthesis-queue.json",
-  "state/fact-hashes.txt",
-  "state/memory-actions.jsonl",
-  "state/memory-lifecycle-ledger.jsonl",
-  "state/meta.json",
-  "state/reextract-jobs.jsonl",
-  "state/topics.json"
-]);
-function isEncryptableStateSidecar(normalized) {
-  return ENCRYPTABLE_STATE_SIDECARS.has(normalized);
-}
-function isEncryptableSummarySidecar(normalized) {
-  return normalized.startsWith("summaries/") && normalized.endsWith(".json");
-}
-var DECRYPTABLE_SIDECAR_ROOTS = /* @__PURE__ */ new Set([
-  "state",
-  "indexes",
-  "index",
-  "provenance"
-]);
-
-export {
-  SecureStoreLockedError,
-  SecureStoreDecryptError,
-  MAGIC_BYTES,
-  FILE_FORMAT_VERSION,
-  FILE_FORMAT_FLAGS,
-  MAGIC_HEADER_SIZE,
-  isEncryptedFile,
-  encryptFileBody,
-  decryptFileBody,
-  filePathAad,
-  readMaybeEncryptedFileBuffer,
-  readMaybeEncryptedFile,
-  writeMaybeEncryptedFile,
-  writeMaybeEncryptedFileFromChunks,
-  migrateMemoryDirToEncrypted,
-  decryptMemoryDirToPlaintext
-};

package/dist/chunk-BU5KJVWF.js

@@ -1,78 +0,0 @@
-// ../remnic-core/src/tier-migration.ts
-import { appendFile, mkdir } from "fs/promises";
-import path from "path";
-var TierMigrationExecutor = class {
-  storage;
-  qmd;
-  hotCollection;
-  coldCollection;
-  autoEmbed;
-  journalPath;
-  constructor(options) {
-    this.storage = options.storage;
-    this.qmd = options.qmd;
-    this.hotCollection = options.hotCollection;
-    this.coldCollection = options.coldCollection;
-    this.autoEmbed = options.autoEmbed === true;
-    this.journalPath = options.journalPath ?? path.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
-  }
-  async migrateMemory(request) {
-    const { memory, fromTier, toTier, reason } = request;
-    const targetPath = this.storage.buildTierMemoryPath(memory, toTier);
-    if (fromTier === toTier) {
-      const noChange = {
-        memoryId: memory.frontmatter.id,
-        fromTier,
-        toTier,
-        changed: false,
-        reason,
-        targetPath
-      };
-      await this.appendJournal(noChange);
-      return noChange;
-    }
-    const moved = await this.storage.migrateMemoryToTier(memory, toTier);
-    const result = {
-      memoryId: memory.frontmatter.id,
-      fromTier,
-      toTier,
-      changed: moved.changed,
-      reason,
-      targetPath: moved.targetPath
-    };
-    await this.appendJournal(result);
-    if (result.changed) {
-      const destinationCollection = this.collectionForTier(toTier);
-      const sourceCollection = this.collectionForTier(fromTier);
-      await this.qmd.updateCollection(destinationCollection);
-      if (this.autoEmbed) {
-        await this.qmd.embedCollection(destinationCollection);
-        if (sourceCollection !== destinationCollection) {
-          await this.qmd.embedCollection(sourceCollection);
-        }
-      }
-    }
-    return result;
-  }
-  collectionForTier(tier) {
-    return tier === "cold" ? this.coldCollection : this.hotCollection;
-  }
-  async appendJournal(result) {
-    const entry = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      memoryId: result.memoryId,
-      fromTier: result.fromTier,
-      toTier: result.toTier,
-      changed: result.changed,
-      reason: result.reason,
-      targetPath: result.targetPath
-    };
-    await mkdir(path.dirname(this.journalPath), { recursive: true });
-    await appendFile(this.journalPath, `${JSON.stringify(entry)}
-`, "utf-8");
-  }
-};
-
-export {
-  TierMigrationExecutor
-};