@wipcomputer/memory-crystal 0.7.29 → 0.7.32

package/dist/mirror-sync.js

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-import {
-  pullFileSync
-} from "./chunk-3G3SFYYI.js";
-import {
-  Crystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  decryptJSON,
-  loadRelayKey
-} from "./chunk-KCQUXVYT.js";
-import {
-  ldmPaths,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-EXEZZADG.js";
-
-// src/mirror-sync.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
-var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
-var _ldmPaths = ldmPaths();
-var MIRROR_STATE_PATH = resolveStatePath("mirror-sync-state.json");
-function loadState() {
-  try {
-    if (existsSync(MIRROR_STATE_PATH)) {
-      const state = JSON.parse(readFileSync(MIRROR_STATE_PATH, "utf-8"));
-      return {
-        lastSync: state.lastSync || null,
-        lastHash: state.lastHash || null,
-        lastSize: state.lastSize || null,
-        lastDeltaChunkId: state.lastDeltaChunkId || 0,
-        totalImported: state.totalImported || 0
-      };
-    }
-  } catch {
-  }
-  return { lastSync: null, lastHash: null, lastSize: null, lastDeltaChunkId: 0, totalImported: 0 };
-}
-function saveState(state) {
-  const writePath = stateWritePath("mirror-sync-state.json");
-  writeFileSync(writePath, JSON.stringify(state, null, 2));
-}
-async function pullDelta(force2) {
-  if (!RELAY_URL || !RELAY_TOKEN) {
-    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
-  }
-  const relayKey = loadRelayKey();
-  const listResp = await fetch(`${RELAY_URL}/pickup/mirror`, {
-    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
-  });
-  if (!listResp.ok) {
-    throw new Error(`Relay list failed: ${listResp.status} ${await listResp.text()}`);
-  }
-  const listData = await listResp.json();
-  if (listData.count === 0) {
-    process.stderr.write("[mirror-sync] no delta available\n");
-    return false;
-  }
-  const config = resolveConfig();
-  const crystal = new Crystal(config);
-  await crystal.init();
-  const state = loadState();
-  let totalImported = 0;
-  for (const blob of listData.blobs) {
-    try {
-      const blobResp = await fetch(`${RELAY_URL}/pickup/mirror/${blob.id}`, {
-        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
-      });
-      if (!blobResp.ok) {
-        process.stderr.write(`[mirror-sync] failed to fetch blob ${blob.id}: ${blobResp.status}
-`);
-        continue;
-      }
-      const encryptedText = await blobResp.text();
-      const encrypted = JSON.parse(encryptedText);
-      let delta;
-      try {
-        delta = decryptJSON(encrypted, relayKey);
-      } catch (err) {
-        process.stderr.write(`[mirror-sync] blob ${blob.id} failed verification: ${err.message} \u2014 DISCARDED
-`);
-        await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
-          method: "DELETE",
-          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
-        });
-        continue;
-      }
-      if (!force2 && delta.maxId <= state.lastDeltaChunkId) {
-        process.stderr.write(`[mirror-sync] blob ${blob.id} already applied (maxId ${delta.maxId} <= watermark ${state.lastDeltaChunkId})
-`);
-        await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
-          method: "DELETE",
-          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
-        });
-        continue;
-      }
-      const imported = crystal.importChunks(delta.chunks);
-      totalImported += imported;
-      if (delta.maxId > state.lastDeltaChunkId) {
-        state.lastDeltaChunkId = delta.maxId;
-      }
-      process.stderr.write(
-        `[mirror-sync] blob ${blob.id}: ${imported}/${delta.chunkCount} chunks imported (ID ${delta.sinceId + 1}..${delta.maxId}), pushed=${delta.pushedAt}
-`
-      );
-      await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
-        method: "DELETE",
-        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
-      });
-    } catch (err) {
-      process.stderr.write(`[mirror-sync] error processing blob ${blob.id}: ${err.message}
-`);
-    }
-  }
-  state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
-  state.totalImported += totalImported;
-  saveState(state);
-  if (totalImported > 0) {
-    process.stderr.write(`[mirror-sync] done: ${totalImported} chunks imported, watermark=${state.lastDeltaChunkId}
-`);
-  }
-  return totalImported > 0;
-}
-var args = process.argv.slice(2);
-if (args.includes("--status")) {
-  const state = loadState();
-  const paths = ldmPaths();
-  const hasDb = existsSync(paths.crystalDb);
-  console.log("Mirror sync status:");
-  console.log(`  Relay URL:       ${RELAY_URL || "(not set)"}`);
-  console.log(`  Local crystal:   ${hasDb ? paths.crystalDb : "(none)"}`);
-  console.log(`  Last sync:       ${state.lastSync || "never"}`);
-  console.log(`  Delta watermark: chunk ID ${state.lastDeltaChunkId}`);
-  console.log(`  Total imported:  ${state.totalImported}`);
-  process.exit(0);
-}
-var force = args.includes("--force");
-pullDelta(force).then(async (updated) => {
-  try {
-    const { imported, deleted } = await pullFileSync();
-    if (imported > 0 || deleted > 0) {
-      process.stderr.write(`[mirror-sync] file sync: ${imported} imported, ${deleted} deleted
-`);
-    }
-  } catch (err) {
-    process.stderr.write(`[mirror-sync] file sync failed (non-fatal): ${err.message}
-`);
-  }
-  if (updated) {
-    process.stderr.write("[mirror-sync] done\n");
-  }
-  process.exit(0);
-}).catch((err) => {
-  process.stderr.write(`[mirror-sync] error: ${err.message}
-`);
-  process.exit(1);
-});

package/dist/oc-backfill.d.ts

@@ -1,19 +0,0 @@
-interface ExtractedMessage {
-    role: string;
-    text: string;
-    timestamp: string;
-    sessionId: string;
-}
-/** Extract messages from an OpenClaw session JSONL file.
- *  Reads from lastByteOffset for incremental processing.
- *  Returns extracted messages and new byte offset. */
-declare function extractOpenClawMessages(filePath: string, lastByteOffset?: number): {
-    messages: ExtractedMessage[];
-    newByteOffset: number;
-};
-/** Detect whether a JSONL file is OpenClaw format.
- *  Checks the first line for type:"session" with version field
- *  (OpenClaw uses this header; Claude Code does not). */
-declare function isOpenClawJsonl(filePath: string): boolean;
-
-export { type ExtractedMessage, extractOpenClawMessages, isOpenClawJsonl };

package/dist/oc-backfill.js

@@ -1,74 +0,0 @@
-// src/oc-backfill.ts
-import { existsSync, statSync, openSync, readSync, closeSync } from "fs";
-function extractOpenClawMessages(filePath, lastByteOffset = 0) {
-  if (!existsSync(filePath)) {
-    return { messages: [], newByteOffset: 0 };
-  }
-  const fileSize = statSync(filePath).size;
-  if (lastByteOffset >= fileSize) {
-    return { messages: [], newByteOffset: fileSize };
-  }
-  const fd = openSync(filePath, "r");
-  const bufSize = fileSize - lastByteOffset;
-  const buf = Buffer.alloc(bufSize);
-  readSync(fd, buf, 0, bufSize, lastByteOffset);
-  closeSync(fd);
-  const lines = buf.toString("utf-8").split("\n").filter(Boolean);
-  const messages = [];
-  let sessionId = "unknown";
-  for (const line of lines) {
-    try {
-      const obj = JSON.parse(line);
-      if (obj.type === "session" && obj.id) {
-        sessionId = obj.id;
-        continue;
-      }
-      if (obj.type !== "message") continue;
-      const msg = obj.message;
-      if (!msg || !msg.role) continue;
-      if (msg.role === "system" || msg.role === "tool") continue;
-      let text = "";
-      if (typeof msg.content === "string") {
-        text = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        const parts = [];
-        for (const block of msg.content) {
-          if (block.type === "text" && block.text) {
-            parts.push(block.text);
-          }
-          if (block.type === "thinking" && block.thinking) {
-            parts.push(`[thinking] ${block.thinking}`);
-          }
-        }
-        text = parts.join("\n\n");
-      }
-      if (text.length < 20) continue;
-      messages.push({
-        role: msg.role,
-        text,
-        timestamp: obj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        sessionId: obj.id || sessionId
-      });
-    } catch {
-    }
-  }
-  return { messages, newByteOffset: fileSize };
-}
-function isOpenClawJsonl(filePath) {
-  try {
-    const fd = openSync(filePath, "r");
-    const buf = Buffer.alloc(Math.min(1024, statSync(filePath).size));
-    const bytesRead = readSync(fd, buf, 0, buf.length, 0);
-    closeSync(fd);
-    const firstLine = buf.toString("utf-8", 0, bytesRead).split("\n")[0];
-    if (!firstLine) return false;
-    const obj = JSON.parse(firstLine);
-    return obj.type === "session" && typeof obj.version === "number";
-  } catch {
-    return false;
-  }
-}
-export {
-  extractOpenClawMessages,
-  isOpenClawJsonl
-};

package/dist/openclaw.d.ts

@@ -1,5 +0,0 @@
-declare const _default: {
-    register(api: any): void;
-};
-
-export { _default as default };

package/dist/openclaw.js

@@ -1,423 +0,0 @@
-import {
-  Crystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  ensureLdm,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-EXEZZADG.js";
-
-// src/dev-update.ts
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
-import { join, basename } from "path";
-var HOME = process.env.HOME || "";
-var STAFF_DIR = join(HOME, "Documents", "wipcomputer--mac-mini-01", "staff");
-var CC_REPOS = join(STAFF_DIR, "Parker", "Claude Code - Mini", "repos");
-var LESA_REPOS = join(STAFF_DIR, "L\u0113sa", "repos");
-var DEV_UPDATES_DIR = join(CC_REPOS, "wip-dev-updates");
-var LAST_RUN_PATH = resolveStatePath("dev-update-last-run.json");
-function loadLastRun() {
-  try {
-    if (existsSync(LAST_RUN_PATH)) {
-      return JSON.parse(readFileSync(LAST_RUN_PATH, "utf-8"));
-    }
-  } catch {
-  }
-  return null;
-}
-function saveLastRun(run) {
-  const writePath = stateWritePath("dev-update-last-run.json");
-  writeFileSync(writePath, JSON.stringify(run, null, 2));
-}
-function git(repoPath, cmd) {
-  try {
-    return execSync(`git -C "${repoPath}" ${cmd}`, {
-      encoding: "utf-8",
-      timeout: 1e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "";
-  }
-}
-function scanRepo(repoPath, since) {
-  if (!existsSync(join(repoPath, ".git"))) return null;
-  const name = basename(repoPath);
-  if (name === "_third-party-repos" || name === "wip-dev-updates") return null;
-  const recentCommits = git(repoPath, `log --oneline --since="${since}"`);
-  const uncommitted = git(repoPath, "status --porcelain");
-  if (!recentCommits && !uncommitted) return null;
-  const lines = [];
-  lines.push(`# ${name}`);
-  lines.push("");
-  if (recentCommits) {
-    lines.push("## Recent Commits");
-    lines.push("");
-    lines.push("```");
-    lines.push(...recentCommits.split("\n").slice(0, 10));
-    lines.push("```");
-    lines.push("");
-  }
-  if (uncommitted) {
-    lines.push("## Uncommitted Changes");
-    lines.push("");
-    lines.push("```");
-    lines.push(...uncommitted.split("\n").slice(0, 20));
-    lines.push("```");
-    lines.push("");
-  }
-  if (recentCommits) {
-    const diffStat = git(repoPath, `diff --stat "HEAD@{${since}}" HEAD`);
-    if (diffStat) {
-      lines.push("## Files Changed");
-      lines.push("");
-      lines.push("```");
-      lines.push(...diffStat.split("\n").slice(-15));
-      lines.push("```");
-      lines.push("");
-    }
-  }
-  const branch = git(repoPath, "branch --show-current") || "unknown";
-  lines.push(`**Branch:** ${branch}`);
-  lines.push("");
-  return lines.join("\n");
-}
-function runDevUpdate(author) {
-  const lastRun = loadLastRun();
-  if (lastRun) {
-    const elapsed = Date.now() - new Date(lastRun.timestamp).getTime();
-    if (elapsed < 60 * 60 * 1e3) {
-      return { reposUpdated: 0, files: [] };
-    }
-  }
-  let since = "6 hours ago";
-  if (lastRun?.timestamp) {
-    const lastDate = new Date(lastRun.timestamp);
-    const hoursAgo = Math.ceil((Date.now() - lastDate.getTime()) / (1e3 * 60 * 60));
-    since = `${Math.max(hoursAgo, 1)} hours ago`;
-  }
-  const now = /* @__PURE__ */ new Date();
-  const ts = [
-    String(now.getMonth() + 1).padStart(2, "0"),
-    String(now.getDate()).padStart(2, "0"),
-    String(now.getFullYear())
-  ].join("-") + "--" + [
-    String(now.getHours()).padStart(2, "0"),
-    String(now.getMinutes()).padStart(2, "0"),
-    String(now.getSeconds()).padStart(2, "0")
-  ].join("-");
-  const files = [];
-  const repoDirs = [CC_REPOS, LESA_REPOS];
-  for (const parentDir of repoDirs) {
-    if (!existsSync(parentDir)) continue;
-    let entries;
-    try {
-      entries = execSync(`ls "${parentDir}"`, { encoding: "utf-8" }).trim().split("\n");
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const repoPath = join(parentDir, entry);
-      const content = scanRepo(repoPath, since);
-      if (!content) continue;
-      const repoName = basename(repoPath);
-      const outDir = join(repoPath, "ai");
-      const outFile = join(outDir, `${now.toISOString().slice(0, 10)}--${now.toISOString().slice(11, 19).replace(/:/g, "-")}--${author}--dev-update-${repoName}.md`);
-      mkdirSync(outDir, { recursive: true });
-      const header = `*Auto-generated dev update by ${author} at ${now.toISOString().slice(0, 16).replace("T", " ")}*
-
-`;
-      writeFileSync(outFile, content.replace(/^# .+\n/, `$&
-${header}`));
-      files.push(`${repoName}/ai/${basename(outFile)}`);
-    }
-  }
-  if (false) {
-    try {
-      execSync(
-        `cd "${DEV_UPDATES_DIR}" && git add -A && git commit -m "${author} auto-dev-update ${ts}: ${files.length} repo(s)" --no-verify && git push --quiet`,
-        { encoding: "utf-8", timeout: 3e4, stdio: "pipe" }
-      );
-    } catch {
-    }
-  }
-  saveLastRun({
-    timestamp: now.toISOString(),
-    author,
-    reposUpdated: files.length
-  });
-  return { reposUpdated: files.length, files };
-}
-
-// src/openclaw.ts
-import {
-  existsSync as existsSync2,
-  readFileSync as readFileSync2,
-  readdirSync,
-  copyFileSync,
-  statSync,
-  mkdirSync as mkdirSync2
-} from "fs";
-import { join as join2 } from "path";
-var PRIVATE_MODE_PATH = resolveStatePath("memory-capture-state.json");
-function isPrivateMode() {
-  try {
-    if (existsSync2(PRIVATE_MODE_PATH)) {
-      const state = JSON.parse(readFileSync2(PRIVATE_MODE_PATH, "utf-8"));
-      return state.enabled === false;
-    }
-  } catch {
-  }
-  return false;
-}
-var OC_AGENT_ID = "oc-lesa-mini";
-function syncRawDataToLdm(logger) {
-  try {
-    const paths = ensureLdm(OC_AGENT_ID);
-    const HOME2 = process.env.HOME || "";
-    const ocDir = join2(HOME2, ".openclaw");
-    const sessionsDir = join2(ocDir, "agents", "main", "sessions");
-    if (existsSync2(sessionsDir)) {
-      let copied = 0;
-      for (const file of readdirSync(sessionsDir)) {
-        if (!file.endsWith(".jsonl")) continue;
-        const src = join2(sessionsDir, file);
-        const dest = join2(paths.transcripts, file);
-        if (idempotentCopy(src, dest)) copied++;
-      }
-      if (copied > 0) logger.info(`memory-crystal: synced ${copied} session files to LDM`);
-    }
-    const workspaceDir = join2(ocDir, "workspace");
-    if (existsSync2(workspaceDir)) {
-      syncDirRecursive(workspaceDir, paths.workspace, ".md");
-    }
-    const dailyDir = join2(ocDir, "workspace", "memory");
-    if (existsSync2(dailyDir)) {
-      for (const file of readdirSync(dailyDir)) {
-        if (!file.endsWith(".md")) continue;
-        if (/^\d{4}-\d{2}-\d{2}\.md$/.test(file)) {
-          const src = join2(dailyDir, file);
-          const dest = join2(paths.daily, file);
-          idempotentCopy(src, dest);
-        }
-      }
-    }
-  } catch (err) {
-    logger.warn(`memory-crystal: raw data sync failed (non-fatal): ${err.message}`);
-  }
-}
-function idempotentCopy(src, dest) {
-  try {
-    if (existsSync2(dest)) {
-      const srcStat = statSync(src);
-      const destStat = statSync(dest);
-      if (srcStat.size === destStat.size && srcStat.mtimeMs <= destStat.mtimeMs) return false;
-    }
-    const destDir = join2(dest, "..");
-    if (!existsSync2(destDir)) mkdirSync2(destDir, { recursive: true });
-    copyFileSync(src, dest);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function syncDirRecursive(srcDir, destDir, ext) {
-  if (!existsSync2(destDir)) mkdirSync2(destDir, { recursive: true });
-  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = join2(srcDir, entry.name);
-    const destPath = join2(destDir, entry.name);
-    if (entry.isDirectory()) {
-      syncDirRecursive(srcPath, destPath, ext);
-    } else if (entry.name.endsWith(ext)) {
-      idempotentCopy(srcPath, destPath);
-    }
-  }
-}
-var openclaw_default = {
-  register(api) {
-    const crystal = new Crystal(resolveConfig());
-    let initialized = false;
-    async function ensureInit() {
-      if (!initialized) {
-        await crystal.init();
-        initialized = true;
-      }
-    }
-    api.on("agent_end", async (event, ctx) => {
-      if (isPrivateMode()) return;
-      await ensureInit();
-      const messages = event.messages;
-      if (!messages || messages.length === 0) return;
-      const agentId = ctx.agentId || OC_AGENT_ID;
-      const sessionKey = ctx.sessionKey || "unknown";
-      const state = crystal.getCaptureState(agentId, sessionKey);
-      const storedCount = state.lastMessageCount;
-      let startIndex = storedCount;
-      if (messages.length < storedCount) {
-        api.logger.info(`memory-crystal: compaction detected (${storedCount} \u2192 ${messages.length} messages), resetting capture position`);
-        startIndex = 0;
-      }
-      if (messages.length <= startIndex) return;
-      const newTurns = [];
-      for (let i = startIndex; i < messages.length; i++) {
-        const msg = messages[i];
-        if (!msg.content) continue;
-        const role = msg.role;
-        if (role !== "user" && role !== "assistant") continue;
-        let text = "";
-        if (typeof msg.content === "string") {
-          text = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-        }
-        if (!text || text.length < 50) continue;
-        const maxSingleChunkChars = 2e3 * 4;
-        if (text.length <= maxSingleChunkChars) {
-          newTurns.push({
-            text,
-            role,
-            source_type: "conversation",
-            source_id: sessionKey,
-            agent_id: agentId,
-            token_count: Math.ceil(text.length / 4),
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        } else {
-          const chunks = crystal.chunkText(text);
-          for (const chunkText of chunks) {
-            newTurns.push({
-              text: chunkText,
-              role,
-              source_type: "conversation",
-              source_id: sessionKey,
-              agent_id: agentId,
-              token_count: Math.ceil(chunkText.length / 4),
-              created_at: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-      const totalTokens = newTurns.reduce((sum, c) => sum + c.token_count, 0);
-      if (totalTokens < 500) return;
-      try {
-        const count = await crystal.ingest(newTurns);
-        crystal.setCaptureState(agentId, sessionKey, messages.length, state.captureCount + 1);
-        api.logger.info(`memory-crystal: ingested ${count} chunks from ${sessionKey} (cycle ${state.captureCount + 1})`);
-      } catch (err) {
-        api.logger.error(`memory-crystal: ingest error: ${err.message}`);
-      }
-      syncRawDataToLdm(api.logger);
-    });
-    function toolResult(text, isError = false) {
-      return {
-        content: [{ type: "text", text }],
-        ...isError ? { isError: true } : {}
-      };
-    }
-    api.registerTool(
-      {
-        name: "crystal_search",
-        label: "Search Memory Crystal",
-        description: "Search memory crystal \u2014 semantic search across all conversations and stored memories.",
-        parameters: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "What to search for" },
-            limit: { type: "number", description: "Max results (default: 5)" },
-            agent_id: { type: "string", description: "Filter by agent" }
-          },
-          required: ["query"]
-        },
-        async execute(_id, params) {
-          try {
-            await ensureInit();
-            const results = await crystal.search(
-              params.query,
-              params.limit || 5,
-              params.agent_id ? { agent_id: params.agent_id } : void 0
-            );
-            if (results.length === 0) return toolResult("No results found.");
-            const formatted = results.map((r, i) => {
-              const score = (r.score * 100).toFixed(1);
-              const date = r.created_at?.slice(0, 10) || "unknown";
-              return `[${i + 1}] (${score}%, ${r.agent_id}, ${date}, ${r.role})
-${r.text}`;
-            }).join("\n\n---\n\n");
-            return toolResult(formatted);
-          } catch (err) {
-            return toolResult(`crystal_search error: ${err.message}`, true);
-          }
-        }
-      },
-      { optional: true }
-    );
-    api.registerTool(
-      {
-        name: "crystal_remember",
-        label: "Remember in Crystal",
-        description: "Store a fact, preference, or observation in memory crystal.",
-        parameters: {
-          type: "object",
-          properties: {
-            text: { type: "string", description: "The fact to remember" },
-            category: { type: "string", enum: ["fact", "preference", "event", "opinion", "skill"] }
-          },
-          required: ["text"]
-        },
-        async execute(_id, params) {
-          if (isPrivateMode()) {
-            return toolResult("Private mode is on. No memories are being stored. Use /private-mode off to resume.");
-          }
-          try {
-            await ensureInit();
-            const id = await crystal.remember(params.text, params.category || "fact");
-            return toolResult(`Remembered (id: ${id}): ${params.text}`);
-          } catch (err) {
-            return toolResult(`crystal_remember error: ${err.message}`, true);
-          }
-        }
-      },
-      { optional: true }
-    );
-    api.registerTool(
-      {
-        name: "crystal_forget",
-        label: "Forget Memory",
-        description: "Deprecate a memory by ID.",
-        parameters: {
-          type: "object",
-          properties: {
-            id: { type: "number", description: "Memory ID to deprecate" }
-          },
-          required: ["id"]
-        },
-        async execute(_id, params) {
-          try {
-            await ensureInit();
-            const ok = crystal.forget(params.id);
-            return toolResult(ok ? `Forgot memory ${params.id}` : `Memory ${params.id} not found`);
-          } catch (err) {
-            return toolResult(`crystal_forget error: ${err.message}`, true);
-          }
-        }
-      },
-      { optional: true }
-    );
-    api.on("before_compaction", (_event, _ctx) => {
-      try {
-        const result = runDevUpdate("lesa");
-        if (result.reposUpdated > 0) {
-          api.logger.info(`memory-crystal: auto-dev-update wrote ${result.reposUpdated} updates before compaction`);
-        }
-      } catch (err) {
-        api.logger.warn(`memory-crystal: auto-dev-update failed: ${err.message}`);
-      }
-    });
-    api.logger.info("memory-crystal plugin registered");
-  }
-};
-export {
-  openclaw_default as default
-};

package/dist/pair.d.ts

@@ -1,4 +0,0 @@
-declare function pairShow(): Promise<void>;
-declare function pairReceive(code: string): void;
-
-export { pairReceive, pairShow };