@hoverlover/cc-discord 0.2.4 → 0.3.0

package/README.md

@@ -37,7 +37,6 @@ Edit those files with your credentials, then run again. Override the config loca
 git clone https://github.com/hoverlover/cc-discord.git
 cd cc-discord
 bun install
-bun run generate-settings
 bun start
 ```
 
@@ -120,6 +119,7 @@ Project-local env files take precedence over `~/.config/cc-discord/`, so cloned-
 | `MAX_ATTACHMENT_INLINE_BYTES` | `100000` | Max bytes for inline attachment content |
 | `MAX_ATTACHMENT_DOWNLOAD_BYTES` | `10000000` | Max bytes for downloaded attachments |
 | `ATTACHMENT_TTL_MS` | `3600000` | TTL for downloaded attachment files (ms) |
+| `CATCHUP_MESSAGE_LIMIT` | `100` | Messages to fetch per channel on startup for catch-up (`0` to disable) |
 
 ### `.env.worker` — required
 
@@ -262,6 +262,160 @@ In interactive mode, the orchestrator runs as a Claude Code session with a visib
 
 ---
 
+## Running as a daemon
+
+To keep cc-discord running across reboots and terminal closures, install it as a system service.
+
+### macOS (launchd)
+
+1. Find the full paths to `bunx` and `claude`:
+
+```bash
+which bunx    # e.g. /Users/you/.bun/bin/bunx
+which claude  # e.g. /Users/you/.local/bin/claude
+```
+
+2. Create the plist file (replace all `/Users/you/...` paths with your actual paths from step 1):
+
+```bash
+cat > ~/Library/LaunchAgents/com.cc-discord.plist << 'EOF'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.cc-discord</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <!-- Replace with the output of: which bunx -->
+    <string>/Users/you/.bun/bin/bunx</string>
+    <string>@hoverlover/cc-discord</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <!-- Must include directories for both bunx and claude -->
+    <key>PATH</key>
+    <string>/Users/you/.bun/bin:/Users/you/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>/tmp/cc-discord/launchd-stdout.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>/tmp/cc-discord/launchd-stderr.log</string>
+</dict>
+</plist>
+EOF
+```
+
+3. **Important:** launchd does not source your shell profile, so the `PATH` must explicitly include the directories for both `bunx` and `claude`. Verify the paths match your system.
+
+4. Load the service:
+
+```bash
+mkdir -p /tmp/cc-discord
+launchctl load ~/Library/LaunchAgents/com.cc-discord.plist
+```
+
+5. Manage the service:
+
+```bash
+# Check status
+launchctl list | grep cc-discord
+
+# Stop
+launchctl stop com.cc-discord
+
+# Start
+launchctl start com.cc-discord
+
+# Uninstall
+launchctl unload ~/Library/LaunchAgents/com.cc-discord.plist
+rm ~/Library/LaunchAgents/com.cc-discord.plist
+```
+
+### Linux (systemd)
+
+1. Find the full paths to `bunx` and `claude`:
+
+```bash
+which bunx    # e.g. /home/you/.bun/bin/bunx
+which claude  # e.g. /home/you/.local/bin/claude
+```
+
+2. Create the service file:
+
+```bash
+sudo cat > /etc/systemd/system/cc-discord.service << 'EOF'
+[Unit]
+Description=cc-discord — Discord <-> Claude Code relay
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+# Replace "you" with your username
+User=you
+# Replace with the output of: which bunx
+ExecStart=/home/you/.bun/bin/bunx @hoverlover/cc-discord
+# Ensure bun and claude are on PATH
+Environment=PATH=/home/you/.bun/bin:/home/you/.local/bin:/usr/local/bin:/usr/bin:/bin
+Environment=HOME=/home/you
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+```
+
+3. Replace `you` with your actual username and update the paths to match your system.
+
+4. Enable and start the service:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable cc-discord
+sudo systemctl start cc-discord
+```
+
+5. Manage the service:
+
+```bash
+# Check status
+systemctl status cc-discord
+
+# View logs
+journalctl -u cc-discord -f
+
+# Stop
+sudo systemctl stop cc-discord
+
+# Restart
+sudo systemctl restart cc-discord
+
+# Disable (won't start on boot)
+sudo systemctl disable cc-discord
+```
+
+### Notes
+
+- Both approaches run `bunx @hoverlover/cc-discord`, which is the same as `bun start` in the cloned repo.
+- Environment files are read from `~/.config/cc-discord/` — make sure those are configured before starting the service.
+- Application logs still go to `CC_DISCORD_LOG_DIR` (default `/tmp/cc-discord/logs`). The launchd/systemd logs are separate and capture startup errors.
+- Claude CLI must be authenticated (`claude auth login`) as the user the service runs under before starting.
+
+---
+
 ## Development
 
 ### Scripts
@@ -273,10 +427,8 @@ In interactive mode, the orchestrator runs as a Claude Code session with a visib
 | `bun run start:orchestrator` | Start headless orchestrator only |
 | `bun run start:orchestrator-interactive` | Start interactive orchestrator (terminal UI) |
 | `bun run dev` | Alias for `start:relay` |
-| `bun run generate-settings` | Generate `.claude/settings.json` with absolute hook paths |
 | `bun run memory:smoke` | Run memory system smoke test |
 | `bun run memory:inspect` | Inspect memory database contents |
-| `bun run memory:migrate` | Migrate memory to channel-scoped keys |
 | `bun run lint` | Run Biome linter |
 | `bun run lint:fix` | Run Biome linter with auto-fix |
 | `bun run format` | Format code with Biome |
@@ -284,7 +436,7 @@ In interactive mode, the orchestrator runs as a Claude Code session with a visib
 
 ### Hook system
 
-Claude Code hooks are configured in `.claude/settings.json` (generated from `.claude/settings.template.json` by `bun run generate-settings`). The template uses `__ORCHESTRATOR_DIR__` placeholders that are replaced with absolute paths at generation time.
+Claude Code hooks are configured in `.claude/settings.local.json`, generated automatically from `.claude/settings.template.json` when the relay starts. This file is gitignored and only exists while the relay is running — `start.sh` creates it on startup and removes it on shutdown so hooks don't interfere with normal development. The template uses `__ORCHESTRATOR_DIR__` placeholders that are replaced with absolute paths at generation time.
 
 | Hook | Event | Description |
 |---|---|---|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoverlover/cc-discord",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Discord <-> Claude Code relay: use your Claude subscription to power per-channel AI bots",
   "type": "module",
   "bin": {
@@ -25,10 +25,8 @@
     "start:orchestrator": "bash scripts/orchestrator.sh",
     "start:orchestrator-interactive": "bash scripts/start-orchestrator.sh",
     "dev": "bash scripts/start-relay.sh",
-    "generate-settings": "bash scripts/generate-settings.sh",
     "memory:smoke": "bun tools/memory-smoke.ts",
     "memory:inspect": "bun tools/memory-inspect.ts",
-    "memory:migrate": "bun scripts/migrate-memory-to-channel-keys.ts",
     "lint": "bunx biome check .",
     "lint:fix": "bunx biome check --write .",
     "format": "bunx biome format --write .",

package/scripts/channel-agent.sh

@@ -47,7 +47,7 @@ load_env_keys "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env" "${WORKE
 # Ensure bun is on PATH for hooks/tools
 export PATH="$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$ROOT_DIR/tools:$PATH"
 
-SETTINGS_PATH="$ROOT_DIR/.claude/settings.json"
+SETTINGS_PATH="$ROOT_DIR/.claude/settings.local.json"
 PROMPT_TEMPLATE="$ROOT_DIR/prompts/channel-system.md"
 
 if ! command -v claude >/dev/null 2>&1; then

package/scripts/generate-settings.sh

@@ -11,7 +11,7 @@ SCRIPT_DIR="$(cd "$(dirname "$_SCRIPT")" && pwd)"
 ORCHESTRATOR_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 TEMPLATE="$ORCHESTRATOR_DIR/.claude/settings.template.json"
-OUTPUT="$ORCHESTRATOR_DIR/.claude/settings.json"
+OUTPUT="$ORCHESTRATOR_DIR/.claude/settings.local.json"
 
 if [ ! -f "$TEMPLATE" ]; then
   echo "Template not found: $TEMPLATE"

package/scripts/start-orchestrator.sh

@@ -34,7 +34,7 @@ load_env_keys "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env.worker" "
 load_env_keys "$ROOT_DIR/.env" "${WORKER_KEYS[@]}"
 load_env_keys "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env" "${WORKER_KEYS[@]}"
 
-SETTINGS_PATH="$ROOT_DIR/.claude/settings.json"
+SETTINGS_PATH="$ROOT_DIR/.claude/settings.local.json"
 SYSTEM_PROMPT_PATH="$ROOT_DIR/prompts/orchestrator-system.md"
 
 if ! command -v claude >/dev/null 2>&1; then

package/scripts/start.sh

@@ -85,11 +85,11 @@ if [ -d "$ROOT_DIR/.claude/skills" ] && [ "$ROOT_DIR" != "$CC_DISCORD_HOME" ]; t
   done
 fi
 
-# Seed settings.json so Claude sees project config.
-if [ "$ROOT_DIR" != "$CC_DISCORD_HOME" ] && [ -f "$ROOT_DIR/.claude/settings.template.json" ]; then
+# Generate settings.local.json (hooks + relay permissions) so Claude agents see project config.
+if [ -f "$ROOT_DIR/.claude/settings.template.json" ]; then
   bash "$ROOT_DIR/scripts/generate-settings.sh"
-  if [ -f "$ROOT_DIR/.claude/settings.json" ]; then
-    cp "$ROOT_DIR/.claude/settings.json" "$CC_DISCORD_HOME/.claude/settings.json"
+  if [ "$ROOT_DIR" != "$CC_DISCORD_HOME" ] && [ -f "$ROOT_DIR/.claude/settings.local.json" ]; then
+    cp "$ROOT_DIR/.claude/settings.local.json" "$CC_DISCORD_HOME/.claude/settings.local.json"
   fi
 fi
 
@@ -120,6 +120,10 @@ cleanup() {
     wait "$RELAY_PID" 2>/dev/null || true
   fi
 
+  # Remove generated settings.local.json so hooks don't fire during normal development
+  rm -f "$ROOT_DIR/.claude/settings.local.json"
+  rm -f "$CC_DISCORD_HOME/.claude/settings.local.json"
+
   log "All processes stopped."
   exit 0
 }
@@ -145,7 +149,7 @@ RELAY_PORT="${RELAY_PORT:-3199}"
 RELAY_API_TOKEN="${RELAY_API_TOKEN:-}"
 
 # Ensure bun/curl/claude are findable
-export PATH="$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
+export PATH="$HOME/.bun/bin:$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
 
 # ---- Pre-flight: Claude auth check ----
 if ! claude auth status >/dev/null 2>&1; then

package/server/catchup.ts

@@ -0,0 +1,54 @@
+/**
+ * Catch-up: fetch recent messages from allowed channels on startup
+ * to fill in any messages missed while the relay was offline.
+ */
+
+import type { Client } from "discord.js";
+import { CATCHUP_MESSAGE_LIMIT, IGNORED_CHANNEL_IDS, ALLOWED_CHANNEL_IDS, isAllowedUser } from "./config.ts";
+import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
+import { startTypingIndicator } from "./typing.ts";
+
+export async function catchUpMissedMessages(client: Client) {
+  if (CATCHUP_MESSAGE_LIMIT <= 0) {
+    console.log("[Catchup] Disabled (CATCHUP_MESSAGE_LIMIT=0)");
+    return;
+  }
+
+  let channelsScanned = 0;
+  let messagesCaughtUp = 0;
+
+  for (const [, guild] of client.guilds.cache) {
+    const guildChannels = await guild.channels.fetch();
+    for (const [, channel] of guildChannels) {
+      if (!channel || !channel.isTextBased() || channel.isThread() || channel.isVoiceBased()) continue;
+      if (IGNORED_CHANNEL_IDS.has(channel.id)) continue;
+      if (ALLOWED_CHANNEL_IDS.length > 0 && !ALLOWED_CHANNEL_IDS.includes(channel.id)) continue;
+
+      try {
+        const messages = await channel.messages.fetch({ limit: CATCHUP_MESSAGE_LIMIT });
+        channelsScanned++;
+
+        // Sort oldest-first so they're persisted in chronological order
+        const sorted = [...messages.values()]
+          .filter((m) => !m.author.bot && isAllowedUser(m.author.id))
+          .sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+
+        let channelHasNew = false;
+        for (const msg of sorted) {
+          const isNew = await persistInboundDiscordMessage(msg);
+          if (isNew) {
+            messagesCaughtUp++;
+            channelHasNew = true;
+          }
+        }
+        if (channelHasNew) {
+          startTypingIndicator(client, channel.id, persistOutboundDiscordMessage);
+        }
+      } catch (err: unknown) {
+        console.error(`[Catchup] Failed to fetch messages for #${channel.name} (${channel.id}):`, (err as Error).message);
+      }
+    }
+  }
+
+  console.log(`[Catchup] Done — scanned ${channelsScanned} channel(s), caught up ${messagesCaughtUp} message(s)`);
+}

package/server/config.ts

@@ -83,8 +83,23 @@ export const MAX_ATTACHMENT_INLINE_BYTES = Number(process.env.MAX_ATTACHMENT_INL
 export const MAX_ATTACHMENT_DOWNLOAD_BYTES = Number(process.env.MAX_ATTACHMENT_DOWNLOAD_BYTES || 10_000_000);
 export const ATTACHMENT_TTL_MS = Number(process.env.ATTACHMENT_TTL_MS || 3_600_000);
 
+export const CATCHUP_MESSAGE_LIMIT = Number(process.env.CATCHUP_MESSAGE_LIMIT ?? 100);
+
 export const ATTACHMENT_DIR = join("/tmp", "cc-discord", "attachments");
 
+export function isAllowedChannel(channelId: string): boolean {
+  if (!channelId) return false;
+  if (IGNORED_CHANNEL_IDS.has(channelId)) return false;
+  if (ALLOWED_CHANNEL_IDS.length > 0) return ALLOWED_CHANNEL_IDS.includes(channelId);
+  return true;
+}
+
+export function isAllowedUser(userId: string | undefined): boolean {
+  if (!userId) return false;
+  if (ALLOWED_DISCORD_USER_IDS.length === 0) return true;
+  return ALLOWED_DISCORD_USER_IDS.includes(userId);
+}
+
 function loadDotEnv(path: string) {
   if (!existsSync(path)) return;
   const raw = readFileSync(path, "utf8");

package/server/index.ts

@@ -4,6 +4,7 @@ import { Client, GatewayIntentBits, REST, Routes, SlashCommandBuilder } from "di
 import express, { type NextFunction, type Request, type Response } from "express";
 import { cleanupOldAttachments } from "./attachment.ts";
 import { maybeNotifyBusyQueued } from "./busy-notify.ts";
+import { catchUpMissedMessages } from "./catchup.ts";
 import {
   ALLOWED_CHANNEL_IDS,
   ALLOWED_DISCORD_USER_IDS,
@@ -13,6 +14,8 @@ import {
   DISCORD_BOT_TOKEN,
   DISCORD_SESSION_ID,
   IGNORED_CHANNEL_IDS,
+  isAllowedChannel,
+  isAllowedUser,
   MESSAGE_ROUTING_MODE,
   RELAY_ALLOW_NO_AUTH,
   RELAY_API_TOKEN,
@@ -39,19 +42,6 @@ const client = new Client({
   intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
 });
 
-function isAllowedChannel(channelId: string): boolean {
-  if (!channelId) return false;
-  if (IGNORED_CHANNEL_IDS.has(channelId)) return false;
-  if (ALLOWED_CHANNEL_IDS.length > 0) return ALLOWED_CHANNEL_IDS.includes(channelId);
-  return true;
-}
-
-function isAllowedUser(userId: string | undefined): boolean {
-  if (!userId) return false;
-  if (ALLOWED_DISCORD_USER_IDS.length === 0) return true;
-  return ALLOWED_DISCORD_USER_IDS.includes(userId);
-}
-
 function requireAuth(req: Request, res: Response): boolean {
   if (RELAY_ALLOW_NO_AUTH) return true;
   const token = req.header("x-api-token") || req.header("authorization")?.replace(/^Bearer\s+/i, "");
@@ -104,6 +94,11 @@ client.once("clientReady", async () => {
 
   // Start live trace thread flush loop
   startTraceFlushLoop(client);
+
+  // Catch up messages missed while offline
+  catchUpMissedMessages(client).catch((err) => {
+    console.error("[Relay] Catch-up failed:", (err as Error).message);
+  });
 });
 
 client.on("messageCreate", async (message) => {

package/server/messages.ts

@@ -26,7 +26,7 @@ export async function formatInboundMessage(message: any) {
   return `${author}: ${fullText}`;
 }
 
-export async function persistInboundDiscordMessage(message: any) {
+export async function persistInboundDiscordMessage(message: any): Promise<boolean> {
   const normalizedContent = await formatInboundMessage(message);
   // In channel mode, route to channelId so per-channel subagents consume independently.
   // In agent mode (legacy), route to CLAUDE_AGENT_ID for single-agent consumption.
@@ -57,13 +57,15 @@ export async function persistInboundDiscordMessage(message: any) {
     });
 
     console.log(`[Relay] queued Discord message ${message.id} -> ${targetAgent}`);
+    return true;
   } catch (err: unknown) {
     const msg = String((err as any)?.message || "");
     if (msg.includes("UNIQUE constraint failed")) {
       // Discord can re-deliver in edge cases; idempotent ignore
-      return;
+      return false;
     }
     console.error("[Relay] failed to persist inbound message:", (err as Error).message);
+    return false;
   }
 }
 

package/scripts/migrate-memory-to-channel-keys.ts

@@ -1,149 +0,0 @@
-#!/usr/bin/env bun
-/**
- * One-time migration: re-key memory_turns from the legacy shared session key
- * (discord:default:claude-discord) into per-channel session keys
- * (discord:default:{channelId}).
- *
- * Each turn's channelId is read from its metadata_json. Turns without a
- * channelId are left in the old key.
- *
- * Turn indices are renumbered per-channel to be sequential, starting after
- * any existing turns already in that channel key.
- *
- * Usage:
- *   bun scripts/migrate-memory-to-channel-keys.ts [path/to/memory.db]
- */
-
-import { Database } from "bun:sqlite";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const defaultDataDir = process.env.CC_DISCORD_DATA_DIR || join(process.env.HOME || "", ".cc-discord", "data");
-const dbPath = process.argv[2] || join(defaultDataDir, "memory.db");
-
-console.log(`[migrate] Opening ${dbPath}`);
-const db = new Database(dbPath);
-
-const OLD_SESSION_KEY = "discord:default:claude-discord";
-
-// Read all turns under the old key
-const turns = db
-  .prepare(`
-  SELECT id, session_key, turn_index, role, content, metadata_json, created_at
-  FROM memory_turns
-  WHERE session_key = ?
-  ORDER BY turn_index ASC
-`)
-  .all(OLD_SESSION_KEY) as any[];
-
-console.log(`[migrate] Found ${turns.length} turns under ${OLD_SESSION_KEY}`);
-
-if (turns.length === 0) {
-  console.log("[migrate] Nothing to migrate.");
-  db.close();
-  process.exit(0);
-}
-
-// Group by channelId from metadata
-const byChannel = new Map<string, typeof turns>();
-const noChannel: typeof turns = [];
-
-for (const turn of turns) {
-  let channelId: string | null = null;
-  try {
-    const meta = JSON.parse(String((turn as any).metadata_json || "{}"));
-    channelId = meta.channelId || null;
-  } catch {}
-
-  if (!channelId) {
-    noChannel.push(turn);
-    continue;
-  }
-
-  if (!byChannel.has(channelId)) byChannel.set(channelId, []);
-  byChannel.get(channelId)!.push(turn);
-}
-
-console.log(`[migrate] Splitting into ${byChannel.size} channels:`);
-for (const [ch, chTurns] of byChannel) {
-  console.log(`  discord:default:${ch} -> ${chTurns.length} turns`);
-}
-if (noChannel.length > 0) {
-  console.log(`  (${noChannel.length} turns have no channelId -- left in old key)`);
-}
-
-// Find the current max turn_index for each target channel key
-function getMaxTurnIndex(sessionKey: string): number {
-  const row = db
-    .prepare("SELECT MAX(turn_index) as max_idx FROM memory_turns WHERE session_key = ?")
-    .get(sessionKey) as any;
-  return row?.max_idx ?? 0;
-}
-
-// Ensure per-channel session keys exist in memory_sessions
-const upsertSession = db.prepare(`
-  INSERT OR IGNORE INTO memory_sessions (session_key, created_at)
-  VALUES (?, datetime('now'))
-`);
-
-// Update each turn's session_key and re-index
-const updateTurn = db.prepare(`
-  UPDATE memory_turns SET session_key = ?, turn_index = ? WHERE id = ?
-`);
-
-// Copy runtime state for new keys
-const readRuntimeState = db.prepare(`
-  SELECT * FROM memory_runtime_state WHERE session_key = ?
-`);
-const upsertRuntimeState = db.prepare(`
-  INSERT OR IGNORE INTO memory_runtime_state (session_key, runtime_context_id, runtime_epoch, updated_at)
-  VALUES (?, ?, ?, datetime('now'))
-`);
-
-db.exec("BEGIN TRANSACTION");
-try {
-  const oldRuntime = readRuntimeState.get(OLD_SESSION_KEY) as any;
-
-  for (const [channelId, chTurns] of byChannel) {
-    const newKey = `discord:default:${channelId}`;
-    upsertSession.run(newKey);
-
-    // Start numbering after any existing turns in the target key
-    const startIndex = getMaxTurnIndex(newKey) + 1;
-
-    for (let i = 0; i < chTurns.length; i++) {
-      updateTurn.run(newKey, startIndex + i, chTurns[i].id);
-    }
-
-    // Bootstrap runtime state for the new key if it doesn't exist
-    if (oldRuntime) {
-      upsertRuntimeState.run(newKey, `migrated_from_${OLD_SESSION_KEY}`, 1);
-    }
-
-    console.log(
-      `[migrate] Updated ${chTurns.length} turns -> ${newKey} (indices ${startIndex}..${startIndex + chTurns.length - 1})`,
-    );
-  }
-
-  db.exec("COMMIT");
-  console.log("[migrate] Migration complete.");
-} catch (err) {
-  db.exec("ROLLBACK");
-  console.error("[migrate] Migration failed, rolled back:", (err as Error).message || err);
-  process.exit(1);
-}
-
-// Summary
-for (const [channelId] of byChannel) {
-  const newKey = `discord:default:${channelId}`;
-  const count = (db.prepare("SELECT COUNT(*) as cnt FROM memory_turns WHERE session_key = ?").get(newKey) as any).cnt;
-  console.log(`  ${newKey}: ${count} turns total`);
-}
-
-const remaining = (
-  db.prepare("SELECT COUNT(*) as cnt FROM memory_turns WHERE session_key = ?").get(OLD_SESSION_KEY) as any
-).cnt;
-console.log(`  ${OLD_SESSION_KEY}: ${remaining} turns remaining`);
-
-db.close();