@hoverlover/cc-discord 0.3.2 → 0.4.0

package/hooks/check-discord-messages.ts

@@ -71,43 +71,88 @@ async function syncRuntimeContext({ hookEvent, hookInput }: { hookEvent: string;
   }
 }
 
+/**
+ * Build memory context using QMD semantic search.
+ *
+ * Queries the `agent-memory` QMD collection and formats results into the
+ * same MEMORY CONTEXT format the downstream prompts expect.
+ */
 async function buildMemoryContext({ queryText, runtimeState }: { queryText: string; runtimeState: any }) {
-  const memoryDbPath = join(DATA_DIR, "memory.db");
-  const memorySessionKey = buildMemorySessionKey({ sessionId, agentId });
+  if (!queryText?.trim()) return "";
 
-  let store: SqliteMemoryStore | undefined;
   try {
-    store = new SqliteMemoryStore({ dbPath: memoryDbPath, logger: noopLogger });
-    const coordinator = new MemoryCoordinator({ store, logger: noopLogger });
-    await coordinator.init();
+    const { execSync } = await import("node:child_process");
+
+    // Use `qmd search` (BM25) for fast keyword recall (~0.3s).
+    // `qmd query` would give LLM-reranked results but is too slow for a hook.
+    // -n 8 returns up to 8 relevant chunks.
+    // --min-score 0.3 filters low-relevance noise.
+    const raw = execSync(
+      `qmd search ${JSON.stringify(queryText)} -n 8 --min-score 0.3 --json 2>/dev/null`,
+      { encoding: "utf-8", timeout: 8_000 },
+    );
 
-    const packet = await coordinator.assembleContext({
-      sessionKey: memorySessionKey,
-      queryText,
-      runtimeContextId: runtimeState?.runtimeContextId || null,
-      runtimeEpoch: runtimeState?.runtimeEpoch || null,
-      includeSnapshot: true,
-      avoidCurrentRuntime: true,
-      activeWindowSize: 12,
-      maxCards: 6,
-      maxRecallTurns: 8,
-      maxTurnScan: 300,
-    });
+    const results: Array<{ docid: string; score: number; file: string; title: string; snippet: string }> =
+      JSON.parse(raw || "[]");
+
+    if (results.length === 0) return "";
+
+    // Expand the top results into readable turn snippets using `qmd get`.
+    // Each snippet in the JSON output has a line reference — we use `qmd get`
+    // to retrieve a fuller window of surrounding content.
+    const lines: string[] = [];
+    for (const result of results.slice(0, 8)) {
+      // Extract the path + line from the qmd:// URI
+      const qmdPath = result.file.replace(/^qmd:\/\//, "");
+      const lineMatch = result.snippet.match(/@@ -(\d+)/);
+      const lineNum = lineMatch ? parseInt(lineMatch[1], 10) : 1;
 
-    return coordinator.formatContextPacket(packet);
-  } catch {
-    return "";
-  } finally {
-    if (store) {
       try {
-        await store.close();
+        const content = execSync(
+          `qmd get "${qmdPath}:${lineNum}" -l 12 2>/dev/null`,
+          { encoding: "utf-8", timeout: 5_000 },
+        ).trim();
+
+        if (content) {
+          // Clean up markdown headers/frontmatter noise, keep the conversation content
+          const cleaned = content
+            .split("\n")
+            .filter((l: string) => !l.startsWith("---") && !l.startsWith("session_key:") && !l.startsWith("agent_id:"))
+            .join("\n")
+            .trim();
+
+          if (cleaned) {
+            const scoreLabel = `${Math.round(result.score * 100)}%`;
+            lines.push(`- [${scoreLabel}] ${truncateForMemory(cleaned, 320)}`);
+          }
+        }
       } catch {
-        /* ignore */
+        // Fall back to the snippet from the JSON
+        if (result.snippet) {
+          const snippetText = result.snippet
+            .replace(/@@ -\d+,?\d* @@.*\n?/, "")
+            .replace(/\(.*?before.*?after\)\n?/, "")
+            .trim();
+          if (snippetText) {
+            lines.push(`- [${Math.round(result.score * 100)}%] ${truncateForMemory(snippetText, 320)}`);
+          }
+        }
       }
     }
+
+    if (lines.length === 0) return "";
+    return `MEMORY CONTEXT:\nRelevant prior turns (semantic recall via QMD):\n${lines.join("\n")}`;
+  } catch {
+    return "";
   }
 }
 
+function truncateForMemory(text: string, maxLen: number): string {
+  const oneLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  if (oneLine.length <= maxLen) return oneLine;
+  return `${oneLine.slice(0, maxLen - 1)}…`;
+}
+
 let hookInput: any;
 try {
   const chunks: Buffer[] = [];

package/hooks/track-activity.ts

@@ -43,6 +43,9 @@ const toolInput = input.tool_input || input.toolInput || null;
 let db: InstanceType<typeof DatabaseSync>;
 try {
   db = new DatabaseSync(dbPath);
+  // WAL mode for better concurrency with the relay server's flush loop
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec("PRAGMA busy_timeout = 5000;");
 } catch {
   process.exit(0);
 }
@@ -107,7 +110,9 @@ try {
           INSERT INTO trace_events (session_id, agent_id, channel_id, event_type, tool_name, summary)
           VALUES (?, ?, ?, 'tool_start', ?, ?)
         `).run(sessionId, agentId, traceChannelId, toolName || "tool", summary);
-      } catch { /* fail-open */ }
+      } catch {
+        /* fail-open */
+      }
     }
 
     process.exit(0);
@@ -118,17 +123,21 @@ try {
     let elapsedTag = "";
     if (traceEnabled && hookEvent === "PostToolUse") {
       try {
-        const row = db.prepare(`
+        const row = db
+          .prepare(`
           SELECT started_at FROM agent_activity
           WHERE session_id = ? AND agent_id = ?
-        `).get(sessionId, agentId) as { started_at?: string } | undefined;
+        `)
+          .get(sessionId, agentId) as { started_at?: string } | undefined;
         if (row?.started_at) {
           const elapsedMs = Date.now() - new Date(row.started_at).getTime();
           if (elapsedMs >= 0 && elapsedMs < 600_000) {
             elapsedTag = `elapsed:${elapsedMs}|`;
           }
         }
-      } catch { /* best-effort */ }
+      } catch {
+        /* best-effort */
+      }
     }
 
     db.prepare(`
@@ -157,7 +166,9 @@ try {
           INSERT INTO trace_events (session_id, agent_id, channel_id, event_type, tool_name, summary)
           VALUES (?, ?, ?, 'tool_end', ?, ?)
         `).run(sessionId, agentId, traceChannelId, toolName || "tool", `${elapsedTag}${summary}`);
-      } catch { /* fail-open */ }
+      } catch {
+        /* fail-open */
+      }
     }
   }
 } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoverlover/cc-discord",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Discord <-> Claude Code relay: use your Claude subscription to power per-channel AI bots",
   "type": "module",
   "bin": {

package/scripts/migrate-memory-to-qmd.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+/**
+ * Phase 1: Export memory.db turns to markdown files for QMD indexing.
+ *
+ * Reads all sessions and turns from the SQLite memory store and writes them
+ * as markdown files grouped by session into the Obsidian vault's
+ * agent-memory/conversations/ folder.
+ *
+ * Output directory: ~/Library/Mobile Documents/iCloud~md~obsidian/Documents/iCloud/agent-memory/
+ *
+ * File layout:
+ *   agent-memory/
+ *     conversations/
+ *       <date>-<channel-id>.md   (one file per session, named by date)
+ *
+ * Each file contains YAML-style frontmatter and all turns in order.
+ */
+
+import Database from "bun:sqlite";
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ── Paths ──────────────────────────────────────────────────────────
+const DATA_DIR = join(homedir(), ".cc-discord", "data");
+const DB_PATH = join(DATA_DIR, "memory.db");
+const OBSIDIAN_VAULT = join(
+  homedir(),
+  "Library",
+  "Mobile Documents",
+  "iCloud~md~obsidian",
+  "Documents",
+  "iCloud"
+);
+const AGENT_MEMORY_DIR = join(OBSIDIAN_VAULT, "agent-memory");
+const CONVERSATIONS_DIR = join(AGENT_MEMORY_DIR, "conversations");
+
+// ── Types ──────────────────────────────────────────────────────────
+interface SessionRow {
+  session_key: string;
+  agent_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface TurnRow {
+  id: string;
+  session_key: string;
+  turn_index: number;
+  role: string;
+  content: string;
+  metadata_json: string | null;
+  created_at: string;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+/**
+ * Build a human-friendly filename from session metadata.
+ * Format: YYYY-MM-DD-<channel-id>.md
+ */
+function buildFilename(session: SessionRow): string {
+  // Extract date from created_at (ISO string → YYYY-MM-DD)
+  const date = session.created_at.slice(0, 10);
+  // Extract channel ID from session key (last segment after last colon)
+  const parts = session.session_key.split(":");
+  const channelId = parts[parts.length - 1] || "unknown";
+  return `${date}-${channelId}.md`;
+}
+
+/** Format a single turn as a markdown section. */
+function formatTurn(turn: TurnRow): string {
+  const roleLabel = turn.role === "user" ? "🧑 User" : "🤖 Assistant";
+  const ts = turn.created_at ? `  _(${turn.created_at})_` : "";
+
+  let meta = "";
+  if (turn.metadata_json) {
+    try {
+      const parsed = JSON.parse(turn.metadata_json);
+      if (parsed.runtimeContextId) {
+        meta = `\n> Runtime context: \`${parsed.runtimeContextId}\` epoch ${parsed.runtimeEpoch ?? "?"}`;
+      }
+    } catch {
+      // ignore malformed JSON
+    }
+  }
+
+  return `### Turn ${turn.turn_index} — ${roleLabel}${ts}${meta}\n\n${turn.content}\n`;
+}
+
+// ── Main ───────────────────────────────────────────────────────────
+function main() {
+  if (!existsSync(DB_PATH)) {
+    console.error(`❌  memory.db not found at ${DB_PATH}`);
+    process.exit(1);
+  }
+
+  const db = new Database(DB_PATH, { readonly: true });
+
+  // Fetch sessions
+  const sessions = db
+    .query<SessionRow, []>(
+      `SELECT session_key, agent_id, created_at, updated_at
+       FROM memory_sessions ORDER BY created_at`
+    )
+    .all();
+
+  console.log(`📦  Found ${sessions.length} session(s) in memory.db`);
+
+  // Verify Obsidian vault exists
+  if (!existsSync(OBSIDIAN_VAULT)) {
+    console.error(`❌  Obsidian vault not found at ${OBSIDIAN_VAULT}`);
+    process.exit(1);
+  }
+
+  // Prepare output directories
+  mkdirSync(CONVERSATIONS_DIR, { recursive: true });
+  console.log(`📂  Output directory: ${CONVERSATIONS_DIR}`);
+
+  let totalTurns = 0;
+  let filesWritten = 0;
+
+  for (const session of sessions) {
+    const turns = db
+      .query<TurnRow, [string]>(
+        `SELECT id, session_key, turn_index, role, content, metadata_json, created_at
+         FROM memory_turns
+         WHERE session_key = ?
+         ORDER BY turn_index`
+      )
+      .all(session.session_key);
+
+    if (turns.length === 0) {
+      console.log(`  ⏭  Skipping empty session: ${session.session_key}`);
+      continue;
+    }
+
+    totalTurns += turns.length;
+
+    // Build markdown with Obsidian-friendly filename
+    const filename = buildFilename(session);
+    const filePath = join(CONVERSATIONS_DIR, filename);
+
+    const frontmatter = [
+      "---",
+      `session_key: "${session.session_key}"`,
+      `agent_id: "${session.agent_id ?? ""}"`,
+      `source: cc-discord`,
+      `type: conversation`,
+      `created: "${session.created_at}"`,
+      `updated: "${session.updated_at}"`,
+      `turn_count: ${turns.length}`,
+      `first_turn: "${turns[0].created_at}"`,
+      `last_turn: "${turns[turns.length - 1].created_at}"`,
+      `tags:`,
+      `  - agent-memory`,
+      `  - conversation`,
+      `  - cc-discord`,
+      "---",
+    ].join("\n");
+
+    const header = `# Session: ${session.session_key}\n\n`;
+    const summary = `> **${turns.length} turns** · Agent \`${session.agent_id ?? "unknown"}\` · ${session.created_at} → ${session.updated_at}\n\n`;
+    const body = turns.map(formatTurn).join("\n---\n\n");
+
+    const markdown = `${frontmatter}\n\n${header}${summary}${body}`;
+
+    writeFileSync(filePath, markdown, "utf-8");
+    filesWritten++;
+    console.log(
+      `  ✅  ${filename} — ${turns.length} turn(s)`
+    );
+  }
+
+  db.close();
+
+  console.log(`\n🎉  Export complete!`);
+  console.log(`    Sessions exported : ${filesWritten}`);
+  console.log(`    Total turns       : ${totalTurns}`);
+  console.log(`    Output directory  : ${CONVERSATIONS_DIR}`);
+  console.log(`\nNext steps:`);
+  console.log(`  1. qmd collection remove cc-discord-memory  (remove old collection)`);
+  console.log(`  2. qmd collection add "${AGENT_MEMORY_DIR}" --name agent-memory`);
+  console.log(`  3. qmd embed`);
+  console.log(`  4. qmd query "test query"  — verify semantic search`);
+}
+
+main();

package/scripts/test-qmd-recall.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+/**
+ * Quick test: verify QMD-based memory recall works end-to-end.
+ */
+
+import { execSync } from "node:child_process";
+
+const queryText = "mattermost installation deployment";
+
+console.log(`Query: "${queryText}"\n`);
+
+const raw = execSync(
+  `qmd search ${JSON.stringify(queryText)} -n 8 --min-score 0.3 --json 2>/dev/null`,
+  { encoding: "utf-8", timeout: 8_000 },
+);
+
+const results: Array<{ docid: string; score: number; file: string; title: string; snippet: string }> =
+  JSON.parse(raw || "[]");
+
+console.log(`QMD returned ${results.length} result(s)\n`);
+
+const lines: string[] = [];
+for (const result of results.slice(0, 8)) {
+  const qmdPath = result.file.replace(/^qmd:\/\//, "");
+  const lineMatch = result.snippet.match(/@@ -(\d+)/);
+  const lineNum = lineMatch ? parseInt(lineMatch[1], 10) : 1;
+
+  try {
+    const content = execSync(
+      `qmd get "${qmdPath}:${lineNum}" -l 12 2>/dev/null`,
+      { encoding: "utf-8", timeout: 5_000 },
+    ).trim();
+
+    if (content) {
+      const cleaned = content
+        .split("\n")
+        .filter((l: string) => !l.startsWith("---") && !l.startsWith("session_key:") && !l.startsWith("agent_id:"))
+        .join("\n")
+        .trim();
+
+      if (cleaned) {
+        const scoreLabel = `${Math.round(result.score * 100)}%`;
+        const oneLine = cleaned.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+        lines.push(`- [${scoreLabel}] ${oneLine.slice(0, 320)}`);
+      }
+    }
+  } catch {
+    if (result.snippet) {
+      const snippetText = result.snippet
+        .replace(/@@ -\d+,?\d* @@.*\n?/, "")
+        .replace(/\(.*?before.*?after\)\n?/, "")
+        .trim();
+      if (snippetText) {
+        lines.push(`- [${Math.round(result.score * 100)}%] ${snippetText.replace(/\n/g, " ").slice(0, 320)}`);
+      }
+    }
+  }
+}
+
+console.log("MEMORY CONTEXT:");
+console.log("Relevant prior turns (semantic recall via QMD):");
+for (const line of lines) {
+  console.log(line);
+}

package/server/db.ts

@@ -11,6 +11,11 @@ mkdirSync(DATA_DIR, { recursive: true });
 
 export const db = new DatabaseSync(join(DATA_DIR, "messages.db"));
 
+// Enable WAL mode for better concurrent access between relay server and hook processes.
+// WAL allows readers and writers to operate concurrently without SQLITE_BUSY errors.
+db.exec("PRAGMA journal_mode = WAL;");
+db.exec("PRAGMA busy_timeout = 5000;");
+
 db.exec(`
   CREATE TABLE IF NOT EXISTS messages (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -170,14 +175,29 @@ export function getPendingTraceEvents(limit: number = 50): TraceEvent[] {
   }
 }
 
-export function markTraceEventsPosted(ids: number[]) {
-  if (!ids.length) return;
-  try {
-    const placeholders = ids.map(() => "?").join(",");
-    db.prepare(`UPDATE trace_events SET posted = 1 WHERE id IN (${placeholders})`).run(...ids);
-  } catch {
-    // fail-open
+export function markTraceEventsPosted(ids: number[]): boolean {
+  if (!ids.length) return true;
+  // Retry up to 3 times to handle SQLITE_BUSY from concurrent hook writes
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const placeholders = ids.map(() => "?").join(",");
+      db.prepare(`UPDATE trace_events SET posted = 1 WHERE id IN (${placeholders})`).run(...ids);
+      return true;
+    } catch (err) {
+      const code = (err as any)?.code;
+      if (code === "SQLITE_BUSY" && attempt < 2) {
+        // Brief sync delay before retry (Bun doesn't have Atomics.wait, use a spin)
+        const end = Date.now() + 50 * (attempt + 1);
+        while (Date.now() < end) {
+          /* spin wait */
+        }
+        continue;
+      }
+      console.error(`[Trace] markTraceEventsPosted failed (attempt ${attempt + 1}/3, ${ids.length} ids):`, err);
+      return false;
+    }
   }
+  return false;
 }
 
 export function insertTraceEvent(

package/server/memory.ts

@@ -1,51 +1,55 @@
 /**
  * Memory integration for the relay server.
- * Persists inbound/outbound turns and assembles memory context for context injection.
  *
- * Session key strategy:
- * When a channelId is provided, turns are written to a per-channel key
- * (discord:{sessionId}:{channelId}) so that per-channel subagents can
- * retrieve them. This matches the key that wait-for-discord-messages
- * uses on the read side (agentId = channelId).
+ * Writes new turns as markdown to the Obsidian vault's agent-memory folder
+ * and triggers QMD re-indexing. Reads are handled by the hook via `qmd query`.
+ *
+ * SQLite is retained solely for runtime-state tracking (context epochs).
  *
- * When no channelId is available, falls back to the legacy shared key
- * (discord:{sessionId}:{CLAUDE_AGENT_ID}).
+ * Session key strategy:
+ * When a channelId is provided, turns are appended to a per-channel
+ * conversation file. When no channelId is available, falls back to the
+ * legacy shared key.
  */
 
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { MemoryCoordinator } from "../memory/core/MemoryCoordinator.ts";
 import { buildMemorySessionKey } from "../memory/core/session-key.ts";
 import { SqliteMemoryStore } from "../memory/providers/sqlite/SqliteMemoryStore.ts";
 import { CLAUDE_AGENT_ID, DATA_DIR, DISCORD_SESSION_ID } from "./config.ts";
 
+// ── Paths ──────────────────────────────────────────────────────────
+const OBSIDIAN_VAULT = join(
+  process.env.HOME || "",
+  "Library",
+  "Mobile Documents",
+  "iCloud~md~obsidian",
+  "Documents",
+  "iCloud",
+);
+const AGENT_MEMORY_DIR = join(OBSIDIAN_VAULT, "agent-memory");
+const CONVERSATIONS_DIR = join(AGENT_MEMORY_DIR, "conversations");
+
 /** Legacy fallback key for turns without a channel association. */
 const fallbackSessionKey = buildMemorySessionKey({
   sessionId: DISCORD_SESSION_ID,
   agentId: CLAUDE_AGENT_ID,
 });
 
+/**
+ * SQLite store is retained only for runtime-state tracking.
+ * It is NOT used for reading/writing memory turns.
+ */
 export const memoryStore = new SqliteMemoryStore({
   dbPath: join(DATA_DIR, "memory.db"),
   logger: console,
 });
+await memoryStore.init();
 
-export const memory = new MemoryCoordinator({
-  store: memoryStore,
-  logger: console,
-});
-
-await memory.init();
+// ── Helpers ────────────────────────────────────────────────────────
 
-/**
- * Resolve the memory session key for a turn.
- * If channelId is available, produces a per-channel key matching what
- * the subagent's wait-for-discord-messages will query.
- */
 function resolveSessionKey(channelId?: string): string {
   if (channelId) {
-    // Subagents set AGENT_ID=channelId and build their key as:
-    //   buildMemorySessionKey({ sessionId, agentId: channelId })
-    // => discord:{sessionId}:{channelId}
     return buildMemorySessionKey({
       sessionId: DISCORD_SESSION_ID,
       agentId: channelId,
@@ -54,6 +58,83 @@ function resolveSessionKey(channelId?: string): string {
   return fallbackSessionKey;
 }
 
+/**
+ * Build the filename for a conversation file.
+ * Format: <date>-<channelId>.md (matches export script naming).
+ */
+function resolveConversationFile(sessionKey: string): string {
+  const parts = sessionKey.split(":");
+  const channelId = parts[parts.length - 1] || "unknown";
+
+  // Look for an existing file matching this channel
+  const { readdirSync } = require("node:fs");
+  mkdirSync(CONVERSATIONS_DIR, { recursive: true });
+  const files: string[] = readdirSync(CONVERSATIONS_DIR);
+  const existing = files.find((f: string) => f.endsWith(`-${channelId}.md`));
+  if (existing) return join(CONVERSATIONS_DIR, existing);
+
+  // No existing file — create a new one with today's date
+  const today = new Date().toISOString().slice(0, 10);
+  return join(CONVERSATIONS_DIR, `${today}-${channelId}.md`);
+}
+
+/**
+ * Format a turn as markdown, matching the export format.
+ */
+function formatTurnMarkdown(role: string, content: string, metadata: any): string {
+  const roleLabel = role === "user" ? "🧑 User" : "🤖 Assistant";
+  const ts = new Date().toISOString();
+
+  let meta = "";
+  if (metadata?.runtimeContextId) {
+    meta = `\n> Runtime context: \`${metadata.runtimeContextId}\` epoch ${metadata.runtimeEpoch ?? "?"}`;
+  }
+
+  // We use "Turn ?" because exact index doesn't matter for QMD search
+  return `\n---\n\n### Turn — ${roleLabel}  _(${ts})_${meta}\n\n${content}\n`;
+}
+
+/**
+ * Create a new conversation file with frontmatter.
+ */
+function createConversationFile(filePath: string, sessionKey: string, agentId: string): void {
+  const now = new Date().toISOString();
+  const frontmatter = [
+    "---",
+    `session_key: "${sessionKey}"`,
+    `agent_id: "${agentId}"`,
+    `source: cc-discord`,
+    `type: conversation`,
+    `created: "${now}"`,
+    `updated: "${now}"`,
+    `tags:`,
+    `  - agent-memory`,
+    `  - conversation`,
+    `  - cc-discord`,
+    "---",
+    "",
+    `# Session: ${sessionKey}`,
+    "",
+  ].join("\n");
+
+  writeFileSync(filePath, frontmatter, "utf-8");
+}
+
+/**
+ * Trigger a background QMD re-index so new turns become searchable.
+ * Non-blocking — we don't wait for it to finish.
+ */
+function triggerQmdReindex(): void {
+  try {
+    const { exec } = require("node:child_process");
+    exec("qmd update 2>/dev/null", { timeout: 30_000 });
+  } catch {
+    // Best-effort; QMD will catch up on next explicit update or query
+  }
+}
+
+// ── Main API ───────────────────────────────────────────────────────
+
 export async function appendMemoryTurn({
   role,
   content,
@@ -68,21 +149,40 @@ export async function appendMemoryTurn({
     const sessionKey = resolveSessionKey(channelId);
     const runtimeState = await memoryStore.readRuntimeState(sessionKey);
 
-    const result = await memory.appendTurn({
-      sessionKey,
-      agentId: channelId || CLAUDE_AGENT_ID,
-      role,
-      content,
-      metadata: {
-        ...metadata,
-        runtimeContextId: runtimeState?.runtimeContextId || null,
-        runtimeEpoch: runtimeState?.runtimeEpoch || null,
-      },
-    });
-    console.log(
-      `[Memory] persisted ${role} turn to ${sessionKey} (batch=${result?.batchId}, turns=${result?.counts?.turns})`,
-    );
+    const enrichedMetadata = {
+      ...metadata,
+      runtimeContextId: runtimeState?.runtimeContextId || null,
+      runtimeEpoch: runtimeState?.runtimeEpoch || null,
+    };
+
+    // Resolve (or create) the conversation markdown file
+    const filePath = resolveConversationFile(sessionKey);
+
+    if (!existsSync(filePath)) {
+      createConversationFile(filePath, sessionKey, channelId || CLAUDE_AGENT_ID);
+    }
+
+    // Append the new turn
+    const turnMd = formatTurnMarkdown(role, content, enrichedMetadata);
+    appendFileSync(filePath, turnMd, "utf-8");
+
+    // Update the frontmatter "updated" timestamp
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const updated = raw.replace(
+        /^updated: ".*"$/m,
+        `updated: "${new Date().toISOString()}"`,
+      );
+      if (updated !== raw) writeFileSync(filePath, updated, "utf-8");
+    } catch {
+      /* best-effort */
+    }
+
+    // Trigger non-blocking QMD re-index
+    triggerQmdReindex();
+
+    console.log(`[Memory/QMD] persisted ${role} turn to ${filePath}`);
   } catch (err: unknown) {
-    console.error("[Memory] failed to persist turn:", (err as Error).message);
+    console.error("[Memory/QMD] failed to persist turn:", (err as Error).message);
   }
 }

package/server/trace-thread.ts

@@ -6,17 +6,8 @@
  *   hooks write → trace_events table → flush loop reads → batches → posts to thread
  */
 
-import {
-  ChannelType,
-  type Client,
-  type TextChannel,
-  type ThreadChannel,
-} from "discord.js";
-import {
-  TRACE_FLUSH_INTERVAL_MS,
-  TRACE_THREAD_ENABLED,
-  TRACE_THREAD_NAME,
-} from "./config.ts";
+import { ChannelType, type Client, type TextChannel, type ThreadChannel } from "discord.js";
+import { TRACE_FLUSH_INTERVAL_MS, TRACE_THREAD_ENABLED, TRACE_THREAD_NAME } from "./config.ts";
 import {
   getPendingTraceEvents,
   getTraceThreadId,
@@ -241,7 +232,7 @@ function formatTimestamp(iso: string): string {
 /** Clean up text for display — convert literal \n to real newlines, preserve full content. */
 function cleanWhitespace(text: string): string {
   return String(text || "")
-    .replace(/\\n/g, "\n")   // convert literal \n to real newlines
+    .replace(/\\n/g, "\n") // convert literal \n to real newlines
     .replace(/[ \t]+/g, " ") // collapse horizontal whitespace (but keep newlines)
     .trim();
 }
@@ -284,14 +275,25 @@ async function flushTraceEvents(client: Client) {
       return true;
     });
 
-    // Even if filtered out, mark all as posted
-    postedIds.push(...channelEvents.map((e) => e.id));
-
-    if (!meaningful.length) continue;
+    // If all events were filtered out, mark them as posted immediately
+    if (!meaningful.length) {
+      postedIds.push(...channelEvents.map((e) => e.id));
+      continue;
+    }
 
     try {
       const thread = await ensureTraceThread(client, channelId);
-      if (!thread) continue;
+      if (!thread) {
+        // Can't get thread (cooldown or missing channel) — DON'T mark as posted
+        // so they'll be retried after cooldown expires. To prevent infinite
+        // growth, mark them posted if they're older than the cooldown period.
+        const now = Date.now();
+        for (const e of channelEvents) {
+          const age = now - new Date(e.created_at).getTime();
+          if (age > FAILURE_COOLDOWN_MS) postedIds.push(e.id);
+        }
+        continue;
+      }
 
       // Batch into a single message (Discord max 2000 chars)
       const lines = meaningful.map(formatTraceEvent);
@@ -300,6 +302,9 @@ async function flushTraceEvents(client: Client) {
       for (const batch of batches) {
         await thread.send(batch);
       }
+
+      // Only mark as posted AFTER successful Discord send
+      postedIds.push(...channelEvents.map((e) => e.id));
     } catch (err) {
       const code = (err as any)?.code;
       if (code === 50001 || code === 50013) {
@@ -307,13 +312,23 @@ async function flushTraceEvents(client: Client) {
         console.warn(`[Trace] No access to trace thread for channel ${channelId} (${code}) — backing off 5m`);
         threadCache.delete(channelId);
         failedChannels.set(channelId, Date.now());
+        // Mark as posted to avoid infinite retry on permanent access errors
+        postedIds.push(...channelEvents.map((e) => e.id));
       } else {
         console.error(`[Trace] Failed to post trace events for channel ${channelId}:`, err);
+        // Don't mark as posted — they'll be retried on next flush
       }
     }
   }
 
-  markTraceEventsPosted(postedIds);
+  if (postedIds.length > 0) {
+    const success = markTraceEventsPosted(postedIds);
+    if (!success) {
+      console.error(
+        `[Trace] CRITICAL: Failed to mark ${postedIds.length} events as posted — duplicates likely on next flush`,
+      );
+    }
+  }
 }
 
 /** Split lines into batches that fit within maxLen characters.

package/tools/send-discord.ts

@@ -16,6 +16,21 @@ const textParts: string[] = [];
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
+  if (arg === "--help" || arg === "-h") {
+    console.log(`
+Usage: send-discord [--channel <id>] [--reply <messageId>] "message"
+
+Options:
+  --channel  Target channel ID (defaults to AGENT_ID env var)
+  --reply    Message ID to reply to
+
+Examples:
+  send-discord "Build started"
+  send-discord --channel 123456789012345678 "Hello from Claude"
+  send-discord --reply 123456789012345678 "Thanks, on it"
+`);
+    process.exit(0);
+  }
   if (arg === "--channel" && args[i + 1]) {
     channelId = args[++i];
     continue;
@@ -24,6 +39,11 @@ for (let i = 0; i < args.length; i++) {
     replyTo = args[++i];
     continue;
   }
+  // Reject unrecognized flags — don't let them become message content
+  if (arg.startsWith("--")) {
+    console.error(`Unknown flag: ${arg}\nUse --help for usage.`);
+    process.exit(1);
+  }
   textParts.push(arg);
 }