memory-crystal 0.2.0

package/ai/todos/inboxes/parker/2026-02-26--cc-mini--phase2-your-moves.md

@@ -0,0 +1,72 @@
+# Phase 2 -- Your Moves, Parker
+
+**From:** cc-mini
+**Date:** 2026-02-26
+**Branch:** `mini/phase2-relay` (ready, not merged to main yet)
+
+Code is done. Build passes. These are the things only you can do.
+
+## Now (before deploying)
+
+- [ ] **Review the branch.** `git log main..mini/phase2-relay --oneline` in the memory-crystal repo. 4 commits including the cc-air relay merge.
+
+- [ ] **Run migrate-db.** Moves crystal.db to `~/.ldm/memory/`. Stop gateway first.
+  ```bash
+  openclaw gateway stop
+  cd ~/Documents/wipcomputer--mac-mini-01/staff/Parker/Claude\ Code\ -\ Mini/repos/memory-crystal
+  node dist/cli.js migrate-db
+  openclaw gateway restart
+  ```
+  Verify: `node dist/cli.js status` should show data dir as `~/.ldm/memory/`.
+
+- [ ] **Deploy updated plugin.** Copy built files to extension dir:
+  ```bash
+  cd ~/Documents/wipcomputer--mac-mini-01/staff/Parker/Claude\ Code\ -\ Mini/repos/memory-crystal
+  npm run build
+  cp -r dist skills openclaw.plugin.json package.json ~/.openclaw/extensions/memory-crystal/
+  cd ~/.openclaw/extensions/memory-crystal && npm install --omit=dev
+  openclaw gateway restart
+  ```
+
+## When you're ready for relay (Air <-> Mini sync)
+
+- [ ] **Generate encryption key:**
+  ```bash
+  openssl rand -base64 32 > ~/.openclaw/secrets/crystal-relay-key
+  chmod 600 ~/.openclaw/secrets/crystal-relay-key
+  ```
+
+- [ ] **Copy key to MacBook Air** (same path, same permissions)
+
+- [ ] **Cloudflare setup:**
+  ```bash
+  wrangler login
+  wrangler r2 bucket create memory-crystal-relay
+  wrangler secret put AUTH_TOKEN_CC_AIR    # generate a random token
+  wrangler secret put AUTH_TOKEN_CC_MINI   # generate a random token
+  wrangler secret put AUTH_TOKEN_LESA      # generate a random token
+  wrangler deploy
+  ```
+
+- [ ] **Set env vars on Mini** (in your shell profile or launchd):
+  ```
+  CRYSTAL_RELAY_URL=https://memory-crystal-relay.<your-account>.workers.dev
+  CRYSTAL_RELAY_TOKEN=<cc-mini bearer token>
+  CRYSTAL_AGENT_ID=cc-mini
+  ```
+
+- [ ] **Set env vars on Air:**
+  ```
+  CRYSTAL_RELAY_URL=<same URL>
+  CRYSTAL_RELAY_TOKEN=<cc-air bearer token>
+  CRYSTAL_AGENT_ID=cc-air
+  ```
+
+- [ ] **End-to-end test:** Run a CC session on Air, check Mini picks it up via poller.
+
+Full checklist with more detail: `ai/todos/parker/2026-02-25--cc-air--setup-checklist.md`
+
+## Merge to main + release
+
+- [ ] **Merge branch:** `git checkout main && git merge mini/phase2-relay`
+- [ ] **Release:** `wip-release minor --notes="Phase 2: LDM scaffolding, JSONL archive, MD summaries, relay merge"`

package/dist/cc-hook.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cc-hook.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+import {
+  createCrystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+import {
+  encryptJSON,
+  loadRelayKey
+} from "./chunk-F3Y7EL7K.js";
+import {
+  ensureLdm,
+  ldmPaths
+} from "./chunk-PJ6FFKEX.js";
+
+// src/cc-hook.ts
+import {
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  statSync,
+  openSync,
+  readSync,
+  closeSync,
+  copyFileSync
+} from "fs";
+import { join, basename, dirname } from "path";
+var HOME = process.env.HOME || "";
+var CC_AGENT_ID = process.env.CRYSTAL_AGENT_ID || "cc-mini";
+var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
+var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
+var OC_DIR = join(HOME, ".openclaw");
+var LDM_DAILY = join(HOME, ".ldm", "agents", CC_AGENT_ID, "memory", "daily");
+var PRIVATE_MODE_PATH = join(OC_DIR, "memory", "memory-capture-state.json");
+var WATERMARK_PATH = join(OC_DIR, "memory", "cc-capture-watermark.json");
+var CC_ENABLED_PATH = join(OC_DIR, "memory", "cc-capture-enabled.json");
+function getCaptureMode() {
+  if (RELAY_URL && RELAY_TOKEN) return "relay";
+  return "local";
+}
+function isPrivateMode() {
+  try {
+    if (existsSync(PRIVATE_MODE_PATH)) {
+      const state = JSON.parse(readFileSync(PRIVATE_MODE_PATH, "utf-8"));
+      return state.enabled === false;
+    }
+  } catch {
+  }
+  return false;
+}
+function isCaptureEnabled() {
+  try {
+    if (existsSync(CC_ENABLED_PATH)) {
+      const state = JSON.parse(readFileSync(CC_ENABLED_PATH, "utf-8"));
+      return state.enabled !== false;
+    }
+  } catch {
+  }
+  return true;
+}
+function setCaptureEnabled(enabled) {
+  const dir = dirname(CC_ENABLED_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(CC_ENABLED_PATH, JSON.stringify({
+    enabled,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+}
+function loadWatermark() {
+  try {
+    if (existsSync(WATERMARK_PATH)) {
+      return JSON.parse(readFileSync(WATERMARK_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return { files: {}, lastRun: null };
+}
+function saveWatermark(wm) {
+  const dir = dirname(WATERMARK_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  wm.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(WATERMARK_PATH, JSON.stringify(wm, null, 2));
+}
+function extractMessages(filePath, lastByteOffset) {
+  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 = [];
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type !== "user" && obj.type !== "assistant") continue;
+      const msg = obj.message;
+      if (!msg) 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 || obj.type,
+        text,
+        timestamp: obj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: obj.sessionId || "unknown"
+      });
+    } catch {
+    }
+  }
+  return { messages, newByteOffset: fileSize };
+}
+function archiveTranscript(transcriptPath, agentId) {
+  try {
+    if (isPrivateMode()) return;
+    const paths = ensureLdm(agentId);
+    const dest = join(paths.transcripts, basename(transcriptPath));
+    if (existsSync(dest)) {
+      const srcMtime = statSync(transcriptPath).mtimeMs;
+      const dstMtime = statSync(dest).mtimeMs;
+      if (srcMtime <= dstMtime) return;
+    }
+    copyFileSync(transcriptPath, dest);
+  } catch {
+  }
+}
+function appendDailyLog(messages, agentId) {
+  try {
+    const paths = ldmPaths(agentId);
+    if (!existsSync(paths.root)) return;
+    if (!existsSync(paths.daily)) mkdirSync(paths.daily, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().slice(0, 10);
+    const timeStr = now.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZone: "America/Los_Angeles"
+    });
+    const logPath = join(paths.daily, `${dateStr}.md`);
+    const userMsg = messages.find((m) => m.role === "user");
+    if (!userMsg) return;
+    const snippet = userMsg.text.slice(0, 120).replace(/\n/g, " ").trim();
+    const line = `- **${timeStr}** ${snippet}${userMsg.text.length > 120 ? "..." : ""}
+`;
+    if (!existsSync(logPath)) {
+      writeFileSync(logPath, `# ${dateStr} - CC Daily Log
+
+`);
+    }
+    appendFileSync(logPath, line);
+  } catch {
+  }
+}
+async function dropAtRelay(messages) {
+  const relayKey = loadRelayKey();
+  const payload = {
+    agent_id: CC_AGENT_ID,
+    dropped_at: (/* @__PURE__ */ new Date()).toISOString(),
+    messages: messages.map((m) => ({
+      text: m.text,
+      role: m.role,
+      timestamp: m.timestamp,
+      sessionId: m.sessionId
+    }))
+  };
+  const encrypted = encryptJSON(payload, relayKey);
+  const body = JSON.stringify(encrypted);
+  let retries = 0;
+  while (retries < 4) {
+    try {
+      const resp = await fetch(`${RELAY_URL}/drop/conversations`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${RELAY_TOKEN}`,
+          "Content-Type": "application/octet-stream"
+        },
+        body
+      });
+      if (!resp.ok) {
+        const err = await resp.text();
+        throw new Error(`Relay drop failed: ${resp.status} ${err}`);
+      }
+      const result = await resp.json();
+      return messages.length;
+    } catch (err) {
+      retries++;
+      if (retries >= 4) throw err;
+      const delay = Math.min(1e3 * 2 ** retries, 3e4);
+      process.stderr.write(`  [relay retry ${retries}] ${err.message}, waiting ${delay}ms
+`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  return 0;
+}
+var BATCH_SIZE = 200;
+async function ingestLocal(messages) {
+  const config = resolveConfig();
+  const crystal = createCrystal(config);
+  await crystal.init();
+  const maxSingleChunkChars = 2e3 * 4;
+  const chunks = [];
+  for (const msg of messages) {
+    if (msg.text.length <= maxSingleChunkChars) {
+      chunks.push({
+        text: msg.text,
+        role: msg.role,
+        source_type: "conversation",
+        source_id: `cc:${msg.sessionId}`,
+        agent_id: CC_AGENT_ID,
+        token_count: Math.ceil(msg.text.length / 4),
+        created_at: msg.timestamp
+      });
+    } else {
+      for (const ct of crystal.chunkText(msg.text)) {
+        chunks.push({
+          text: ct,
+          role: msg.role,
+          source_type: "conversation",
+          source_id: `cc:${msg.sessionId}`,
+          agent_id: CC_AGENT_ID,
+          token_count: Math.ceil(ct.length / 4),
+          created_at: msg.timestamp
+        });
+      }
+    }
+  }
+  let total = 0;
+  for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+    const batch = chunks.slice(i, i + BATCH_SIZE);
+    let retries = 0;
+    while (retries < 4) {
+      try {
+        total += await crystal.ingest(batch);
+        break;
+      } catch (err) {
+        retries++;
+        if (retries >= 4) throw err;
+        const delay = Math.min(1e3 * 2 ** retries, 3e4);
+        process.stderr.write(`  [retry ${retries}] ${err.message}, waiting ${delay}ms
+`);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  return total;
+}
+var args = process.argv.slice(2);
+if (args.includes("--on")) {
+  setCaptureEnabled(true);
+  console.log("(*) Claude Code memory capture ON");
+  process.exit(0);
+}
+if (args.includes("--off")) {
+  setCaptureEnabled(false);
+  console.log("( ) Claude Code memory capture OFF");
+  process.exit(0);
+}
+if (args.includes("--status")) {
+  const mode = getCaptureMode();
+  console.log(isCaptureEnabled() ? "(*) CC capture: ON" : "( ) CC capture: OFF");
+  console.log(isPrivateMode() ? "( ) Private mode: ON (blocks all capture)" : "(*) Private mode: OFF");
+  console.log(`    Mode: ${mode}${mode === "relay" ? ` (${RELAY_URL})` : ""}`);
+  console.log(`    Agent ID: ${CC_AGENT_ID}`);
+  process.exit(0);
+}
+async function main() {
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+  const transcriptPath = hookData.transcript_path;
+  if (!transcriptPath || !existsSync(transcriptPath)) process.exit(0);
+  if (isPrivateMode() || !isCaptureEnabled()) process.exit(0);
+  archiveTranscript(transcriptPath);
+  const wm = loadWatermark();
+  const fileKey = transcriptPath;
+  if (!wm.files[fileKey]) {
+    const size = statSync(transcriptPath).size;
+    wm.files[fileKey] = { lastByteOffset: size, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    process.stderr.write(`[cc-memory-capture] seeded ${basename(transcriptPath)} at ${size} bytes
+`);
+    process.exit(0);
+  }
+  const lastOffset = wm.files[fileKey].lastByteOffset || 0;
+  const { messages, newByteOffset } = extractMessages(transcriptPath, lastOffset);
+  if (messages.length === 0) {
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    process.exit(0);
+  }
+  const totalTokens = messages.reduce((sum, m) => sum + Math.ceil(m.text.length / 4), 0);
+  if (totalTokens < 500) {
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    process.exit(0);
+  }
+  const mode = getCaptureMode();
+  try {
+    if (mode === "relay") {
+      const count = await dropAtRelay(messages);
+      process.stderr.write(`[cc-memory-capture] relayed ${count} messages (${totalTokens} tokens) from ${basename(transcriptPath)}
+`);
+    } else {
+      const count = await ingestLocal(messages);
+      process.stderr.write(`[cc-memory-capture] ${count} chunks (${totalTokens} tokens) from ${basename(transcriptPath)}
+`);
+    }
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    appendDailyLog(messages);
+    try {
+      const { generateSessionSummary, writeSummaryFile } = await import("./summarize.js");
+      const paths = ldmPaths();
+      const summaryMsgs = messages.map((m) => ({ role: m.role, text: m.text, timestamp: m.timestamp, sessionId: m.sessionId }));
+      const summary = await generateSessionSummary(summaryMsgs);
+      const sessionId = messages[0]?.sessionId || "unknown";
+      const agentId = process.env.CRYSTAL_AGENT_ID || "cc-mini";
+      writeSummaryFile(paths.sessions, summary, agentId, sessionId);
+    } catch {
+    }
+  } catch (err) {
+    process.stderr.write(`[cc-memory-capture] error: ${err.message}
+`);
+    process.exit(1);
+  }
+}
+main();