@wipcomputer/memory-crystal 0.7.28 → 0.7.30

package/.worktrees/memory-crystal-private--cc-mini-fix-home-fallback/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@wipcomputer/memory-crystal",
+  "version": "0.7.29",
+  "description": "Sovereign memory system — local-first with ephemeral encrypted relay. Your memory, your machine, your rules.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wipcomputer/memory-crystal-private.git"
+  },
+  "type": "module",
+  "main": "dist/core.js",
+  "openclaw": {
+    "extensions": [
+      "./dist/openclaw.js"
+    ]
+  },
+  "bin": {
+    "crystal": "dist/cli.js",
+    "crystal-mcp": "dist/mcp-server.js"
+  },
+  "scripts": {
+    "build": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist && tsup src/worker.ts --format esm --outDir dist --no-dts && cp scripts/crystal-capture.sh scripts/ldm-backup.sh dist/",
+    "build:local": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist",
+    "build:worker": "tsup src/worker.ts --format esm --outDir dist --no-dts",
+    "build:cloud": "tsup src/worker-mcp.ts src/cloud-crystal.ts --format esm --outDir dist --no-dts",
+    "deploy:cloud": "bash -c 'git diff --quiet HEAD -- src/ wrangler-mcp.toml || (echo \"ERROR: uncommitted changes. commit before deploying.\" && exit 1)' && wrangler deploy --config wrangler-mcp.toml",
+    "build:demo": "tsup src/worker-demo.ts --format esm --outDir dist --no-dts",
+    "dev:demo": "wrangler dev --config wrangler-demo.toml",
+    "deploy:demo": "bash -c 'git diff --quiet HEAD -- src/ wrangler-demo.toml || (echo \"ERROR: uncommitted changes. commit before deploying.\" && exit 1)' && wrangler deploy --config wrangler-demo.toml",
+    "dev": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/crypto.ts --format esm --watch --outDir dist",
+    "check": "node dist/cli.js status",
+    "search": "node dist/cli.js search",
+    "migrate": "node dist/migrate.js",
+    "cloud:dev": "cd cloud && npx wrangler dev",
+    "cloud:deploy": "cd cloud && npx wrangler deploy",
+    "cloud:db:migrate": "cd cloud && npx wrangler d1 migrations apply memory-crystal-cloud --local",
+    "cloud:db:migrate:remote": "cd cloud && npx wrangler d1 migrations apply memory-crystal-cloud --remote"
+  },
+  "dependencies": {
+    "dream-weaver-protocol": "file:../dream-weaver-protocol-private",
+    "@lancedb/lancedb": "^0.15.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "agents": "^0.7.2",
+    "apache-arrow": "^18.1.0",
+    "better-sqlite3": "^11.8.1",
+    "qrcode-terminal": "^0.12.0",
+    "sqlite-vec": "^0.1.7-alpha.2",
+    "zod": "^4.3.6"
+  },
+  "optionalDependencies": {
+    "sqlite-vec-darwin-arm64": "^0.1.7-alpha.2"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260228.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "wrangler": "^3.95.0"
+  }
+}

package/.worktrees/memory-crystal-private--cc-mini-fix-home-fallback/scripts/crystal-capture.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Job: crystal-capture
+# Continuous capture for Claude Code sessions.
+# Reads JSONL files on disk, ingests into Crystal, exports MD sessions, writes daily logs.
+# Primary capture path. Runs every minute via cron.
+# The Stop hook (cc-hook.ts) is a redundancy check only.
+#
+# Source of truth: memory-crystal-private/scripts/crystal-capture.sh
+# Deployed to: ~/.ldm/bin/crystal-capture.sh (via crystal init)
+# Cron entry: * * * * * ~/.ldm/bin/crystal-capture.sh >> /tmp/ldm-dev-tools/crystal-capture.log 2>&1
+#
+# The Node poller fetches the OpenAI API key internally via opRead() in core.ts.
+# opRead uses: op read "op://Agent Secrets/OpenAI API/api key" with the SA token from
+# ~/.openclaw/secrets/op-sa-token. Do NOT call op from this shell script... it triggers
+# macOS TCC popups when run from cron.
+
+# Cron provides minimal PATH. Ensure Homebrew binaries (node, op) are findable.
+export PATH="/opt/homebrew/bin:$PATH"
+
+POLLER="$HOME/.ldm/extensions/memory-crystal/dist/cc-poller.js"
+NODE="/opt/homebrew/bin/node"
+
+if [ ! -f "$POLLER" ]; then
+  echo "ERROR: cc-poller not found at $POLLER"
+  exit 1
+fi
+
+# Single run: scan all sessions, ingest new turns, export MD, exit.
+$NODE "$POLLER" 2>&1

package/.worktrees/memory-crystal-private--cc-mini-fix-home-fallback/scripts/deploy-cloud.sh

@@ -0,0 +1,153 @@
+#!/usr/bin/env bash
+#
+# deploy-cloud.sh — Deploy Memory Crystal Cloud MCP server to Cloudflare.
+# Pulls all credentials from 1Password. No keys in env files.
+#
+# Usage:
+#   bash scripts/deploy-cloud.sh          # full setup (first time)
+#   bash scripts/deploy-cloud.sh deploy   # just redeploy Worker code
+#
+# Prerequisites:
+#   - wrangler CLI installed (npm install -g wrangler)
+#   - 1Password items populated:
+#     "Parker - Cloudflare Memory Crystal Keys" (api-token, account-id)
+#     "OpenAI API" (api key)
+
+set -euo pipefail
+
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_DIR"
+
+# ── Pull credentials from 1Password ──
+
+echo "Pulling credentials from 1Password..."
+
+OP_TOKEN=$(cat ~/.openclaw/secrets/op-sa-token)
+
+CF_API_TOKEN=$(OP_SERVICE_ACCOUNT_TOKEN="$OP_TOKEN" op item get "Parker - Cloudflare Memory Crystal Keys" \
+  --vault="Agent Secrets" --fields label=api-token --reveal)
+
+CF_ACCOUNT_ID=$(OP_SERVICE_ACCOUNT_TOKEN="$OP_TOKEN" op item get "Parker - Cloudflare Memory Crystal Keys" \
+  --vault="Agent Secrets" --fields label=account-id --reveal)
+
+OPENAI_API_KEY=$(OP_SERVICE_ACCOUNT_TOKEN="$OP_TOKEN" op item get "OpenAI API" \
+  --vault="Agent Secrets" --fields label="api key" --reveal)
+
+if [[ "$CF_API_TOKEN" == "REPLACE_WITH_CLOUDFLARE_API_TOKEN" || "$CF_ACCOUNT_ID" == "REPLACE_WITH_CLOUDFLARE_ACCOUNT_ID" ]]; then
+  echo "Error: Cloudflare credentials not yet filled in 1Password."
+  echo "Update 'Parker - Cloudflare Memory Crystal Keys' in Agent Secrets vault."
+  exit 1
+fi
+
+export CLOUDFLARE_API_TOKEN="$CF_API_TOKEN"
+export CLOUDFLARE_ACCOUNT_ID="$CF_ACCOUNT_ID"
+
+echo "  Cloudflare Account ID: ${CF_ACCOUNT_ID:0:8}..."
+echo "  Cloudflare API Token: ${CF_API_TOKEN:0:8}..."
+echo "  OpenAI API Key: ${OPENAI_API_KEY:0:8}..."
+
+# ── Deploy only? ──
+
+if [[ "${1:-}" == "deploy" ]]; then
+  echo ""
+  echo "Building and deploying Worker..."
+  npm run build:cloud
+  npx wrangler deploy --config wrangler-mcp.toml
+  echo "Done. Worker deployed."
+  exit 0
+fi
+
+# ── Full setup (first time) ──
+
+echo ""
+echo "=== Step 1: Create D1 database ==="
+
+# Check if database already exists
+DB_ID=$(npx wrangler d1 list --json 2>/dev/null | python3 -c "
+import sys, json
+dbs = json.load(sys.stdin)
+for db in dbs:
+    if db['name'] == 'memory-crystal-cloud':
+        print(db['uuid'])
+        break
+" 2>/dev/null || echo "")
+
+if [[ -z "$DB_ID" ]]; then
+  echo "Creating D1 database: memory-crystal-cloud"
+  DB_OUTPUT=$(npx wrangler d1 create memory-crystal-cloud 2>&1)
+  DB_ID=$(echo "$DB_OUTPUT" | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}' | head -1)
+  echo "  Created: $DB_ID"
+else
+  echo "  Already exists: $DB_ID"
+fi
+
+if [[ -z "$DB_ID" ]]; then
+  echo "Error: Could not get D1 database ID"
+  exit 1
+fi
+
+# Update wrangler-mcp.toml with database ID
+if grep -q 'database_id = ""' wrangler-mcp.toml; then
+  sed -i.bak "s/database_id = \"\"/database_id = \"$DB_ID\"/" wrangler-mcp.toml
+  rm -f wrangler-mcp.toml.bak
+  echo "  Updated wrangler-mcp.toml with database_id"
+fi
+
+echo ""
+echo "=== Step 2: Create Vectorize index ==="
+
+VEC_EXISTS=$(npx wrangler vectorize list --json 2>/dev/null | python3 -c "
+import sys, json
+indexes = json.load(sys.stdin)
+for idx in indexes:
+    if idx['name'] == 'memory-crystal-chunks':
+        print('yes')
+        break
+" 2>/dev/null || echo "")
+
+if [[ "$VEC_EXISTS" != "yes" ]]; then
+  echo "Creating Vectorize index: memory-crystal-chunks (1024 dims, cosine)"
+  npx wrangler vectorize create memory-crystal-chunks --dimensions 1024 --metric cosine
+  echo "  Created."
+else
+  echo "  Already exists."
+fi
+
+echo ""
+echo "=== Step 3: Run D1 migrations ==="
+
+npx wrangler d1 migrations apply memory-crystal-cloud --config wrangler-mcp.toml
+echo "  Migrations applied."
+
+echo ""
+echo "=== Step 4: Set Worker secrets ==="
+
+echo "$OPENAI_API_KEY" | npx wrangler secret put OPENAI_API_KEY --config wrangler-mcp.toml
+echo "  OPENAI_API_KEY set."
+
+# Generate signing key for OAuth tokens
+MCP_SIGNING_KEY=$(openssl rand -hex 32)
+echo "$MCP_SIGNING_KEY" | npx wrangler secret put MCP_SIGNING_KEY --config wrangler-mcp.toml
+echo "  MCP_SIGNING_KEY set (generated)."
+
+# Generate relay encryption key (base64, 32 bytes)
+RELAY_KEY=$(openssl rand -base64 32)
+echo "$RELAY_KEY" | npx wrangler secret put RELAY_ENCRYPTION_KEY --config wrangler-mcp.toml
+echo "  RELAY_ENCRYPTION_KEY set (generated)."
+
+echo ""
+echo "=== Step 5: Build and deploy ==="
+
+npm run build:cloud
+npx wrangler deploy --config wrangler-mcp.toml
+
+echo ""
+echo "=== Done ==="
+echo ""
+echo "Memory Crystal Cloud MCP server deployed."
+echo "Worker URL: https://memory-crystal-cloud.<your-subdomain>.workers.dev"
+echo ""
+echo "Next steps:"
+echo "  1. Test: curl https://memory-crystal-cloud.<subdomain>.workers.dev/health"
+echo "  2. Test OAuth: GET /.well-known/oauth-authorization-server"
+echo "  3. Connect from ChatGPT or Claude"

package/.worktrees/memory-crystal-private--cc-mini-fix-home-fallback/scripts/ldm-backup.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# Job: ldm-backup
+# Backs up the LDM directory (~/.ldm/) to a timestamped snapshot.
+# Handles SQLite databases safely (sqlite3 .backup if available, cp otherwise).
+#
+# Source of truth: memory-crystal-private/scripts/ldm-backup.sh
+# Deployed to: ~/.ldm/bin/ldm-backup.sh (via crystal init)
+#
+# Usage:
+#   ldm-backup.sh                     # backup to default location
+#   ldm-backup.sh --keep 14           # keep last 14 backups (default: 7)
+#   ldm-backup.sh --include-secrets   # include secrets/ dir
+#
+# Destination: $LDM_BACKUP_DIR or ~/.ldm/backups/
+
+set -euo pipefail
+
+# Cron provides minimal PATH
+export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+
+LDM_HOME="$HOME/.ldm"
+BACKUP_ROOT="${LDM_BACKUP_DIR:-$LDM_HOME/backups}"
+KEEP=7
+INCLUDE_SECRETS=false
+
+# Parse flags
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --keep)
+      KEEP="$2"
+      shift 2
+      ;;
+    --include-secrets)
+      INCLUDE_SECRETS=true
+      shift
+      ;;
+    *)
+      echo "Unknown flag: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ ! -d "$LDM_HOME" ]; then
+  echo "ERROR: LDM home not found at $LDM_HOME" >&2
+  exit 1
+fi
+
+TIMESTAMP=$(date +%Y-%m-%d-%H%M%S)
+DEST="$BACKUP_ROOT/$TIMESTAMP"
+
+echo "LDM Backup: $DEST"
+mkdir -p "$DEST"
+
+# ── Back up crystal.db (safe copy) ──
+
+CRYSTAL_DB="$LDM_HOME/memory/crystal.db"
+if [ -f "$CRYSTAL_DB" ]; then
+  mkdir -p "$DEST/memory"
+  if command -v sqlite3 &>/dev/null; then
+    # Safe backup via sqlite3 .backup (handles WAL mode correctly)
+    sqlite3 "$CRYSTAL_DB" ".backup '$DEST/memory/crystal.db'"
+    echo "  crystal.db:   backed up (sqlite3 .backup)"
+  else
+    # Fallback: file copy (may include partial WAL state)
+    cp "$CRYSTAL_DB" "$DEST/memory/crystal.db"
+    # Copy WAL and SHM if present
+    [ -f "$CRYSTAL_DB-wal" ] && cp "$CRYSTAL_DB-wal" "$DEST/memory/crystal.db-wal"
+    [ -f "$CRYSTAL_DB-shm" ] && cp "$CRYSTAL_DB-shm" "$DEST/memory/crystal.db-shm"
+    echo "  crystal.db:   backed up (file copy)"
+  fi
+else
+  echo "  crystal.db:   not found (skipped)"
+fi
+
+# ── Back up config ──
+
+if [ -f "$LDM_HOME/config.json" ]; then
+  cp "$LDM_HOME/config.json" "$DEST/config.json"
+  echo "  config.json:  backed up"
+fi
+
+# ── Back up state files ──
+
+if [ -d "$LDM_HOME/state" ]; then
+  cp -a "$LDM_HOME/state" "$DEST/state"
+  echo "  state/:       backed up"
+fi
+
+# ── Back up agents (transcripts, sessions, daily logs, journals) ──
+
+if [ -d "$LDM_HOME/agents" ]; then
+  cp -a "$LDM_HOME/agents" "$DEST/agents"
+  echo "  agents/:      backed up"
+fi
+
+# ── Back up secrets (optional) ──
+
+if [ "$INCLUDE_SECRETS" = true ] && [ -d "$LDM_HOME/secrets" ]; then
+  cp -a "$LDM_HOME/secrets" "$DEST/secrets"
+  chmod 700 "$DEST/secrets"
+  echo "  secrets/:     backed up"
+fi
+
+# ── Retention: remove old backups ──
+
+BACKUP_COUNT=$(ls -1d "$BACKUP_ROOT"/????-??-??-?????? 2>/dev/null | wc -l | tr -d ' ')
+if [ "$BACKUP_COUNT" -gt "$KEEP" ]; then
+  REMOVE_COUNT=$((BACKUP_COUNT - KEEP))
+  ls -1d "$BACKUP_ROOT"/????-??-??-?????? | head -n "$REMOVE_COUNT" | while read OLD; do
+    rm -rf "$OLD"
+    echo "  Removed old:  $(basename "$OLD")"
+  done
+fi
+
+echo "Done. $BACKUP_COUNT backups total (keeping $KEEP)."

package/.worktrees/memory-crystal-private--cc-mini-fix-home-fallback/scripts/migrate-lance-to-sqlite.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+// migrate-lance-to-sqlite.mjs — Copy all chunks + vectors from LanceDB to sqlite-vec.
+// Reads vectors directly from LanceDB (no re-embedding needed).
+// Deduplicates by SHA-256 hash of text content.
+//
+// Usage:
+//   node scripts/migrate-lance-to-sqlite.mjs [--dry-run] [--batch-size N]
+//
+// Data dir: ~/.openclaw/memory-crystal/
+
+import * as lancedb from '@lancedb/lancedb';
+import Database from 'better-sqlite3';
+import * as sqliteVec from 'sqlite-vec';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const BATCH_SIZE = 500;
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const batchSizeArg = args.find((_, i) => args[i - 1] === '--batch-size');
+  const batchSize = batchSizeArg ? parseInt(batchSizeArg) : BATCH_SIZE;
+
+  const openclawHome = process.env.OPENCLAW_HOME || join(process.env.HOME || homedir(), '.openclaw');
+  const dataDir = join(openclawHome, 'memory-crystal');
+  const lanceDir = join(dataDir, 'lance');
+  const sqlitePath = join(dataDir, 'crystal.db');
+
+  if (!existsSync(lanceDir)) {
+    console.error(`LanceDB directory not found: ${lanceDir}`);
+    process.exit(1);
+  }
+
+  // Open LanceDB
+  const lanceDb = await lancedb.connect(lanceDir);
+  const tableNames = await lanceDb.tableNames();
+  if (!tableNames.includes('chunks')) {
+    console.error('No "chunks" table in LanceDB');
+    process.exit(1);
+  }
+  const lanceTable = await lanceDb.openTable('chunks');
+  const totalLance = await lanceTable.countRows();
+  console.log(`LanceDB chunks: ${totalLance.toLocaleString()}`);
+
+  // Open SQLite + load sqlite-vec
+  const db = new Database(sqlitePath);
+  db.pragma('journal_mode = WAL');
+  sqliteVec.load(db);
+
+  // Ensure tables exist
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      text TEXT NOT NULL,
+      text_hash TEXT NOT NULL,
+      role TEXT,
+      source_type TEXT,
+      source_id TEXT,
+      agent_id TEXT,
+      token_count INTEGER,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_chunks_agent ON chunks(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source_type);
+    CREATE INDEX IF NOT EXISTS idx_chunks_hash ON chunks(text_hash);
+    CREATE INDEX IF NOT EXISTS idx_chunks_created ON chunks(created_at);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      text,
+      tokenize='porter unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS chunks_fts_insert AFTER INSERT ON chunks
+    BEGIN
+      INSERT INTO chunks_fts(rowid, text) VALUES (NEW.id, NEW.text);
+    END;
+  `);
+
+  const existingSqlite = (db.prepare('SELECT COUNT(*) as count FROM chunks').get()).count;
+  console.log(`SQLite chunks (before): ${existingSqlite.toLocaleString()}`);
+
+  if (dryRun) {
+    // Sample some rows
+    const sample = await lanceTable.query().limit(3).toArray();
+    console.log('\nSample (3 rows):');
+    for (const row of sample) {
+      console.log(`  [${row.source_type}] [${row.agent_id}] ${row.text?.slice(0, 80)}...`);
+      console.log(`    vector: ${row.vector?.length} dims, created: ${row.created_at}`);
+    }
+    console.log(`\nWould migrate ${totalLance.toLocaleString()} chunks.`);
+    console.log(`Estimated crystal.db growth: ~${Math.round(totalLance * 1536 * 4 / 1024 / 1024)}MB vectors + text`);
+    db.close();
+    return;
+  }
+
+  // Detect dimensions from first row
+  const [firstRow] = await lanceTable.query().limit(1).toArray();
+  const dimensions = firstRow.vector?.length;
+  if (!dimensions) {
+    console.error('Could not determine vector dimensions from LanceDB');
+    process.exit(1);
+  }
+  console.log(`Vector dimensions: ${dimensions}`);
+
+  // Create vec table if needed
+  const vecExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='chunks_vec'`).get();
+  if (!vecExists) {
+    db.exec(`CREATE VIRTUAL TABLE chunks_vec USING vec0(
+      chunk_id INTEGER PRIMARY KEY,
+      embedding float[${dimensions}] distance_metric=cosine
+    )`);
+    console.log(`Created chunks_vec table (${dimensions} dims)`);
+  }
+
+  // Build hash set of existing chunks for dedup
+  console.log('Building dedup hash set...');
+  const existingHashes = new Set();
+  const hashRows = db.prepare('SELECT text_hash FROM chunks').all();
+  for (const row of hashRows) {
+    existingHashes.add(row.text_hash);
+  }
+  console.log(`Existing unique hashes: ${existingHashes.size.toLocaleString()}`);
+
+  // Prepare insert statements
+  const insertChunk = db.prepare(`
+    INSERT INTO chunks (text, text_hash, role, source_type, source_id, agent_id, token_count, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertVec = db.prepare(`
+    INSERT INTO chunks_vec (chunk_id, embedding) VALUES (?, ?)
+  `);
+
+  // Read all rows from LanceDB in batches using offset/limit
+  let migrated = 0;
+  let skippedDedup = 0;
+  let offset = 0;
+  const startTime = Date.now();
+
+  while (offset < totalLance) {
+    const rows = await lanceTable.query().limit(batchSize).offset(offset).toArray();
+    if (rows.length === 0) break;
+
+    const transaction = db.transaction(() => {
+      for (const row of rows) {
+        const text = row.text || '';
+        const hash = createHash('sha256').update(text).digest('hex');
+
+        if (existingHashes.has(hash)) {
+          skippedDedup++;
+          continue;
+        }
+        existingHashes.add(hash);
+
+        const result = insertChunk.run(
+          text,
+          hash,
+          row.role || null,
+          row.source_type || null,
+          row.source_id || null,
+          row.agent_id || null,
+          row.token_count || Math.ceil(text.length / 4),
+          row.created_at || new Date().toISOString()
+        );
+
+        // sqlite-vec needs BigInt for integer primary keys
+        const chunkId = typeof result.lastInsertRowid === 'bigint'
+          ? result.lastInsertRowid
+          : BigInt(result.lastInsertRowid);
+
+        // Convert vector to Float32Array
+        const vector = row.vector;
+        const f32 = vector instanceof Float32Array ? vector : new Float32Array(Array.from(vector));
+        insertVec.run(chunkId, f32);
+
+        migrated++;
+      }
+    });
+    transaction();
+
+    offset += rows.length;
+    const elapsed = (Date.now() - startTime) / 1000;
+    const rate = Math.round(offset / elapsed);
+    const eta = Math.round((totalLance - offset) / rate);
+    process.stdout.write(
+      `\r  ${offset.toLocaleString()}/${totalLance.toLocaleString()} (${Math.round(offset / totalLance * 100)}%) ` +
+      `| migrated: ${migrated.toLocaleString()} | dedup: ${skippedDedup.toLocaleString()} ` +
+      `| ${rate}/s | ETA: ${eta}s   `
+    );
+  }
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  console.log(`\n\nMigration complete in ${elapsed}s:`);
+  console.log(`  Migrated:    ${migrated.toLocaleString()}`);
+  console.log(`  Dedup skip:  ${skippedDedup.toLocaleString()}`);
+
+  // Verify
+  const finalCount = (db.prepare('SELECT COUNT(*) as count FROM chunks').get()).count;
+  const ftsCount = (db.prepare('SELECT COUNT(*) as count FROM chunks_fts').get()).count;
+  console.log(`  SQLite chunks: ${finalCount.toLocaleString()}`);
+  console.log(`  FTS entries:   ${ftsCount.toLocaleString()}`);
+  console.log(`  LanceDB:       ${totalLance.toLocaleString()}`);
+
+  if (finalCount === ftsCount) {
+    console.log('  FTS sync: OK');
+  } else {
+    console.warn(`  WARNING: FTS count mismatch (${ftsCount} vs ${finalCount})`);
+  }
+
+  db.close();
+}
+
+main().catch(err => {
+  console.error(`Migration failed: ${err.message}`);
+  process.exit(1);
+});