@remnic/plugin-openclaw 1.0.10 → 1.0.11

package/dist/chunk-YGGGUTG3.js

@@ -0,0 +1,125 @@
+// ../remnic-core/src/secure-store/cipher.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+var ENVELOPE_VERSION = 1;
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var ENVELOPE_SALT_LENGTH = 16;
+var AES_KEY_LENGTH = 32;
+var ENVELOPE_LAYOUT = Object.freeze({
+  version: 0,
+  salt: 1,
+  iv: 1 + ENVELOPE_SALT_LENGTH,
+  authTag: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH,
+  ciphertext: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+});
+var ENVELOPE_HEADER_SIZE = ENVELOPE_LAYOUT.ciphertext;
+function assertAesKey(key) {
+  if (!(key instanceof Uint8Array)) {
+    throw new Error("key must be a Uint8Array");
+  }
+  if (key.length !== AES_KEY_LENGTH) {
+    throw new Error(
+      `AES-256-GCM requires a ${AES_KEY_LENGTH}-byte key, got ${key.length}`
+    );
+  }
+}
+function seal(key, salt, plaintext, options = {}) {
+  assertAesKey(key);
+  if (!(salt instanceof Uint8Array) || salt.length !== ENVELOPE_SALT_LENGTH) {
+    throw new Error(
+      `salt must be ${ENVELOPE_SALT_LENGTH} bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  if (!(plaintext instanceof Uint8Array)) {
+    throw new Error("plaintext must be a Uint8Array");
+  }
+  let iv;
+  if (options.iv) {
+    if (options.iv.length !== IV_LENGTH) {
+      throw new Error(`iv must be ${IV_LENGTH} bytes, got ${options.iv.length}`);
+    }
+    iv = options.iv;
+  } else {
+    iv = randomBytes(IV_LENGTH);
+  }
+  const cipher = createCipheriv("aes-256-gcm", Buffer.from(key), Buffer.from(iv), {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const headerAad = buildHeaderAad(salt);
+  const finalAad = options.aad ? Buffer.concat([headerAad, Buffer.from(options.aad)]) : headerAad;
+  cipher.setAAD(finalAad);
+  const ciphertext = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  if (authTag.length !== AUTH_TAG_LENGTH) {
+    throw new Error(`unexpected auth tag length: ${authTag.length}`);
+  }
+  const envelope = Buffer.alloc(ENVELOPE_HEADER_SIZE + ciphertext.length);
+  envelope.writeUInt8(ENVELOPE_VERSION, ENVELOPE_LAYOUT.version);
+  Buffer.from(salt).copy(envelope, ENVELOPE_LAYOUT.salt);
+  Buffer.from(iv).copy(envelope, ENVELOPE_LAYOUT.iv);
+  authTag.copy(envelope, ENVELOPE_LAYOUT.authTag);
+  ciphertext.copy(envelope, ENVELOPE_LAYOUT.ciphertext);
+  return envelope;
+}
+function parseEnvelope(envelope) {
+  if (!(envelope instanceof Uint8Array)) {
+    throw new Error("envelope must be a Uint8Array");
+  }
+  if (envelope.length < ENVELOPE_HEADER_SIZE) {
+    throw new Error(
+      `envelope too short: need \u2265 ${ENVELOPE_HEADER_SIZE} bytes, got ${envelope.length}`
+    );
+  }
+  const buf = Buffer.from(envelope.buffer, envelope.byteOffset, envelope.byteLength);
+  const version = buf.readUInt8(ENVELOPE_LAYOUT.version);
+  if (version !== ENVELOPE_VERSION) {
+    throw new Error(
+      `unsupported envelope version: ${version} (this build supports ${ENVELOPE_VERSION})`
+    );
+  }
+  return {
+    version,
+    salt: buf.subarray(ENVELOPE_LAYOUT.salt, ENVELOPE_LAYOUT.salt + ENVELOPE_SALT_LENGTH),
+    iv: buf.subarray(ENVELOPE_LAYOUT.iv, ENVELOPE_LAYOUT.iv + IV_LENGTH),
+    authTag: buf.subarray(
+      ENVELOPE_LAYOUT.authTag,
+      ENVELOPE_LAYOUT.authTag + AUTH_TAG_LENGTH
+    ),
+    ciphertext: buf.subarray(ENVELOPE_LAYOUT.ciphertext)
+  };
+}
+function open(key, envelope, options = {}) {
+  assertAesKey(key);
+  const parsed = parseEnvelope(envelope);
+  const decipher = createDecipheriv("aes-256-gcm", Buffer.from(key), parsed.iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(parsed.authTag);
+  const headerAad = buildHeaderAad(parsed.salt);
+  const finalAad = options.aad ? Buffer.concat([headerAad, Buffer.from(options.aad)]) : headerAad;
+  decipher.setAAD(finalAad);
+  return Buffer.concat([decipher.update(parsed.ciphertext), decipher.final()]);
+}
+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 generateSalt() {
+  return randomBytes(ENVELOPE_SALT_LENGTH);
+}
+
+export {
+  ENVELOPE_VERSION,
+  IV_LENGTH,
+  AUTH_TAG_LENGTH,
+  ENVELOPE_SALT_LENGTH,
+  AES_KEY_LENGTH,
+  ENVELOPE_LAYOUT,
+  ENVELOPE_HEADER_SIZE,
+  seal,
+  parseEnvelope,
+  open,
+  generateSalt
+};

package/dist/chunk-YGXXBRV7.js

@@ -0,0 +1,10 @@
+// ../remnic-core/src/transfer/constants.ts
+var EXPORT_FORMAT = "openclaw-engram-export";
+var EXPORT_SCHEMA_VERSION = 1;
+var CAPSULE_SCHEMA_VERSION = 2;
+
+export {
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION,
+  CAPSULE_SCHEMA_VERSION
+};

package/dist/cipher-VHAFCG7Z.js

@@ -0,0 +1,27 @@
+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,
+  ENVELOPE_HEADER_SIZE,
+  ENVELOPE_LAYOUT,
+  ENVELOPE_SALT_LENGTH,
+  ENVELOPE_VERSION,
+  IV_LENGTH,
+  generateSalt,
+  open,
+  parseEnvelope,
+  seal
+};

package/dist/dreams-ledger-3I52ISYR.js

@@ -0,0 +1,285 @@
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/maintenance/dreams-ledger.ts
+import path from "path";
+import { appendFile, lstat, mkdir, readdir, readFile } from "fs/promises";
+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 readFile(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 readFile(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 readFile(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-65C2J63X.js → engine-VMTFKFGO.js}

@@ -1,10 +1,13 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-HCFFXBLV.js";
-import "./chunk-JJSNPSCD.js";
+} from "./chunk-L4PRBB2A.js";
+import "./chunk-XMSDA5WA.js";
+import "./chunk-TNH24SF6.js";
 import "./chunk-6OJAU466.js";
+import "./chunk-3I7RHWYT.js";
 import "./chunk-UFU5GGGA.js";
+import "./chunk-YGGGUTG3.js";
 import "./chunk-MLKGABMK.js";
 export {
   CompoundingEngine,

package/dist/{fallback-llm-LVK5PDIM.js → fallback-llm-WCWNGIQ3.js}

@@ -1,8 +1,9 @@
 import {
   FallbackLlmClient
-} from "./chunk-7TENHBV2.js";
+} from "./chunk-RQCTMECT.js";
 import "./chunk-3A5ELHTT.js";
 import "./chunk-UFU5GGGA.js";
+import "./chunk-I6B2W2IY.js";
 import "./chunk-MLKGABMK.js";
 export {
   FallbackLlmClient