@hoverlover/cc-discord 0.3.3 → 0.5.0

package/.claude/skills/release/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: Release
+description: Analyze commits since last release and publish with intelligent semantic version bumping.
+---
+
+# Release
+
+Analyze all commits since the last version tag, determine the appropriate semantic version bump (major/minor/patch), and publish to npm.
+
+## Version Bump Rules
+
+Semantic versioning: `MAJOR.MINOR.PATCH`
+
+| Change Type | Bump | Indicators |
+|-------------|------|------------|
+| **Breaking** | MAJOR | `BREAKING CHANGE:`, `!:` suffix, API removals, incompatible changes |
+| **Feature** | MINOR | `feat:`, `feature:`, `add:`, new functionality, enhancements |
+| **Bugfix** | PATCH | `fix:`, `bugfix:`, `patch:`, corrections, typos, small improvements |
+
+The highest-impact change determines the bump (MAJOR > MINOR > PATCH).
+
+## Instructions
+
+### Step 1: Gather Release Context
+
+Run these commands in parallel:
+
+1. Get the last version tag:
+   ```bash
+   git describe --tags --abbrev=0
+   ```
+
+2. Get commits since last tag:
+   ```bash
+   git log $(git describe --tags --abbrev=0)..HEAD --oneline
+   ```
+
+3. Check npm login status:
+   ```bash
+   npm whoami 2>/dev/null || echo "NOT_LOGGED_IN"
+   ```
+
+### Step 2: Verify npm Authentication
+
+Check the result of `npm whoami`:
+
+**If logged in** (returns a username): Proceed to Step 3.
+
+**If not logged in** (returns "NOT_LOGGED_IN" or error): Use browser-based authentication:
+
+1. Connect to Chrome (with retry logic):
+   - Call `mcp__claude-in-chrome__tabs_context_mcp` with `createIfEmpty: true`
+   - If connection fails, wait 2 seconds and retry (up to 3 times)
+   - If connected, create a new tab using `mcp__claude-in-chrome__tabs_create_mcp`
+   - Note whether Chrome is available for later steps
+
+2. Start `npm login` in the terminal with a pseudo-terminal to get the login URL:
+   ```bash
+   script -q /dev/null npm login --auth-type=web 2>&1
+   ```
+
+3. The command will output a URL like `https://www.npmjs.com/login?next=/login/cli/...`
+
+4. Open the URL:
+   - **If Chrome connected:** Navigate the browser tab to that URL using `mcp__claude-in-chrome__navigate`
+   - **If Chrome unavailable:** Display the URL and ask user to open it manually
+
+5. Inform the user: "Please complete the npm login in the browser window."
+
+6. Wait for the login command to complete (it polls for authentication)
+
+7. Verify login succeeded:
+   ```bash
+   npm whoami
+   ```
+
+8. If still not logged in, ask user if they want to retry or abort
+
+### Step 3: Analyze Commits
+
+For each commit since the last tag, classify it:
+
+**Conventional Commit Patterns (primary):**
+- `fix:`, `fix(scope):` → PATCH
+- `feat:`, `feat(scope):` → MINOR
+- `BREAKING CHANGE:` in body or `!:` → MAJOR
+- `docs:`, `chore:`, `style:`, `refactor:`, `test:` → PATCH (maintenance)
+
+**Content Analysis (for non-conventional commits):**
+- Look at the commit message semantics
+- "Add", "Implement", "Introduce" → likely MINOR
+- "Fix", "Correct", "Repair", "Resolve" → likely PATCH
+- "Remove", "Delete API", "Breaking" → likely MAJOR
+- "Update", "Bump", "Improve" → likely PATCH
+- Release commits ("Bump installer to...") → skip (don't count)
+
+**When uncertain:** Default to PATCH unless the change clearly adds new functionality.
+
+### Step 4: Present Analysis
+
+Show the user:
+
+```
+Analyzing commits since vX.Y.Z...
+
+Commit Analysis:
+  [hash] [message] → [classification] ([bump type])
+  [hash] [message] → [classification] ([bump type])
+  ...
+
+Summary:
+  Breaking changes: N
+  New features: N
+  Bugfixes/maintenance: N
+
+Highest impact: [MAJOR|MINOR|PATCH]
+Proposed version: vX.Y.Z → vA.B.C
+
+Proceed with release?
+```
+
+Wait for user confirmation before proceeding.
+
+### Step 5: Execute Release
+
+#### 5a. Connect to Chrome Browser
+
+Before starting the release, establish a Chrome connection for browser-based npm authentication:
+
+1. Call `mcp__claude-in-chrome__tabs_context_mcp` with `createIfEmpty: true`
+2. If the connection fails (extension not connected error):
+   - Wait 2 seconds and retry
+   - Retry up to 3 times total
+   - If all retries fail, inform the user: "Chrome browser extension is not available. You'll need to open the npm auth URL manually when prompted."
+3. If connected, create a new tab using `mcp__claude-in-chrome__tabs_create_mcp`
+4. Store the tab ID for later use
+
+#### 5b. Run Release Script
+
+Run the release script in background mode to capture the auth URL:
+
+```bash
+script -q /dev/null ./scripts/release.sh [patch|minor|major] 2>&1
+```
+
+The script will:
+1. Validate agent configurations
+2. Bump version in package.json files
+3. Commit and tag the release
+4. Push to git
+5. Publish to npm with browser-based 2FA
+
+#### 5c. Handle npm Authentication
+
+Monitor the script output for the auth URL. When you see:
+```
+Authenticate your account at:
+https://www.npmjs.com/auth/cli/[unique-id]
+```
+
+**If Chrome is connected:**
+1. Navigate the browser tab to that URL using `mcp__claude-in-chrome__navigate`
+2. Inform the user: "Please complete the npm authentication in the browser."
+
+**If Chrome is not available:**
+1. Display the full URL to the user
+2. Inform them: "Please open this URL in your browser to authenticate."
+
+Wait for the script to complete (npm polls for authentication).
+
+### Step 6: Report Results
+
+After successful release, show:
+- New version number
+- npm package URL
+- Git tag created
+
+## Edge Cases
+
+**No commits since last tag:**
+- Inform user there's nothing to release
+- Ask if they want to force a patch bump anyway
+
+**All commits are release/chore commits:**
+- Default to PATCH bump
+- Note that only maintenance commits were found
+
+**Mixed signals in a commit:**
+- If a commit adds a feature but also fixes a bug, classify by primary intent
+- When truly ambiguous, ask the user
+
+## Safety Rules
+
+- Always show analysis and get confirmation before releasing
+- Verify npm login before attempting to publish (use browser auth if needed)
+- If any step fails, stop and report the error
+- Don't push or publish without explicit user approval

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoverlover/cc-discord",
-  "version": "0.3.3",
+  "version": "0.5.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/catchup.ts

@@ -4,7 +4,8 @@
  */
 
 import type { Client } from "discord.js";
-import { CATCHUP_MESSAGE_LIMIT, IGNORED_CHANNEL_IDS, ALLOWED_CHANNEL_IDS, isAllowedUser } from "./config.ts";
+import { CATCHUP_MESSAGE_LIMIT, IGNORED_CHANNEL_IDS, ALLOWED_CHANNEL_IDS, TRACE_THREAD_NAME, isAllowedUser } from "./config.ts";
+import { isTraceThread } from "./db.ts";
 import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
 import { startTypingIndicator } from "./typing.ts";
 
@@ -15,6 +16,7 @@ export async function catchUpMissedMessages(client: Client) {
   }
 
   let channelsScanned = 0;
+  let threadsCaughtUp = 0;
   let messagesCaughtUp = 0;
 
   for (const [, guild] of client.guilds.cache) {
@@ -47,8 +49,40 @@ export async function catchUpMissedMessages(client: Client) {
       } catch (err: unknown) {
         console.error(`[Catchup] Failed to fetch messages for #${channel.name} (${channel.id}):`, (err as Error).message);
       }
+
+      // Catch up active threads in this channel
+      if ("threads" in channel && channel.threads) {
+        try {
+          const activeThreads = await (channel as any).threads.fetchActive();
+          for (const [, thread] of activeThreads.threads) {
+            if (thread.name === TRACE_THREAD_NAME || isTraceThread(thread.id)) continue;
+            try {
+              const threadMessages = await thread.messages.fetch({ limit: CATCHUP_MESSAGE_LIMIT });
+              threadsCaughtUp++;
+              const sorted = [...threadMessages.values()]
+                .filter((m: any) => !m.author.bot && isAllowedUser(m.author.id))
+                .sort((a: any, b: any) => a.createdTimestamp - b.createdTimestamp);
+              let threadHasNew = false;
+              for (const msg of sorted) {
+                const isNew = await persistInboundDiscordMessage(msg);
+                if (isNew) {
+                  messagesCaughtUp++;
+                  threadHasNew = true;
+                }
+              }
+              if (threadHasNew) {
+                startTypingIndicator(client, thread.id, persistOutboundDiscordMessage);
+              }
+            } catch (err: unknown) {
+              console.error(`[Catchup] Failed for thread "${thread.name}" (${thread.id}):`, (err as Error).message);
+            }
+          }
+        } catch (err: unknown) {
+          console.error(`[Catchup] Failed to fetch threads for #${(channel as any).name}:`, (err as Error).message);
+        }
+      }
     }
   }
 
-  console.log(`[Catchup] Done — scanned ${channelsScanned} channel(s), caught up ${messagesCaughtUp} message(s)`);
+  console.log(`[Catchup] Done — scanned ${channelsScanned} channel(s), ${threadsCaughtUp} thread(s), caught up ${messagesCaughtUp} message(s)`);
 }

package/server/config.ts

@@ -94,6 +94,24 @@ export function isAllowedChannel(channelId: string): boolean {
   return true;
 }
 
+/**
+ * Thread-aware channel check for incoming messages.
+ * Allows threads whose parent channel is in the allowlist.
+ */
+export function isAllowedChannelForMessage(message: { channelId: string; channel?: any }): boolean {
+  if (!message.channelId) return false;
+  if (IGNORED_CHANNEL_IDS.has(message.channelId)) return false;
+  if (ALLOWED_CHANNEL_IDS.length === 0) return true;
+  if (ALLOWED_CHANNEL_IDS.includes(message.channelId)) return true;
+  // Thread: check parent channel
+  const ch = message.channel;
+  if (ch?.isThread?.() && ch.parentId) {
+    if (IGNORED_CHANNEL_IDS.has(ch.parentId)) return false;
+    return ALLOWED_CHANNEL_IDS.includes(ch.parentId);
+  }
+  return false;
+}
+
 export function isAllowedUser(userId: string | undefined): boolean {
   if (!userId) return false;
   if (ALLOWED_DISCORD_USER_IDS.length === 0) return true;

package/server/db.ts

@@ -133,6 +133,15 @@ export function getCurrentAgentActivity(sessionId: string, defaultAgentId: strin
   }
 }
 
+export function isTraceThread(threadId: string): boolean {
+  try {
+    const row = db.prepare("SELECT 1 FROM trace_threads WHERE thread_id = ?").get(threadId);
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+
 // ── Trace thread helpers ────────────────────────────────────────────
 
 export function getTraceThreadId(channelId: string): string | null {

package/server/index.ts

@@ -15,6 +15,7 @@ import {
   DISCORD_SESSION_ID,
   IGNORED_CHANNEL_IDS,
   isAllowedChannel,
+  isAllowedChannelForMessage,
   isAllowedUser,
   MESSAGE_ROUTING_MODE,
   RELAY_ALLOW_NO_AUTH,
@@ -26,7 +27,7 @@ import {
   TYPING_MAX_MS,
   validateConfig,
 } from "./config.ts";
-import { clearChannelModel, db, getAgentHealthAll, getChannelModel, setChannelModel } from "./db.ts";
+import { clearChannelModel, db, getAgentHealthAll, getChannelModel, isTraceThread, setChannelModel } from "./db.ts";
 import { memoryStore } from "./memory.ts";
 import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
 import { startTraceFlushLoop, stopTraceFlushLoop } from "./trace-thread.ts";
@@ -39,7 +40,12 @@ setInterval(cleanupOldAttachments, 10 * 60 * 1000);
 cleanupOldAttachments();
 
 const client = new Client({
-  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.GuildMessageThreads,
+  ],
 });
 
 function requireAuth(req: Request, res: Response): boolean {
@@ -104,7 +110,8 @@ client.once("clientReady", async () => {
 client.on("messageCreate", async (message) => {
   if (!message) return;
   if (message.author?.bot) return;
-  if (!isAllowedChannel(message.channelId)) return;
+  if (!isAllowedChannelForMessage(message)) return;
+  if (message.channel?.isThread?.() && isTraceThread(message.channelId)) return;
   if (!isAllowedUser(message.author?.id)) {
     console.log(`[Relay] Ignoring message from unauthorized user ${message.author?.id}`);
     return;
@@ -196,6 +203,34 @@ app.get("/api/channels", async (req: Request, res: Response) => {
       }
     }
 
+    // Optionally include active threads in allowed channels
+    if (req.query.include_threads === "true") {
+      for (const ch of [...channels]) {
+        try {
+          const parentChannel = await client.channels.fetch(ch.id);
+          if (parentChannel && "threads" in parentChannel) {
+            const activeThreads = await (parentChannel as any).threads.fetchActive();
+            for (const [, thread] of activeThreads.threads) {
+              if (isTraceThread(thread.id)) continue;
+              channels.push({
+                id: thread.id,
+                name: thread.name,
+                guildId: ch.guildId,
+                guildName: ch.guildName,
+                type: thread.type,
+                isThread: true,
+                parentChannelId: ch.id,
+                parentChannelName: ch.name,
+                model: getChannelModel(thread.id),
+              });
+            }
+          }
+        } catch {
+          /* skip */
+        }
+      }
+    }
+
     res.json({ success: true, channels });
   } catch (err: unknown) {
     console.error("[Relay] /api/channels failed:", err);

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/messages.ts

@@ -23,7 +23,14 @@ export async function formatInboundMessage(message: any) {
     fullText = "[No text content]";
   }
 
-  return `${author}: ${fullText}`;
+  // Add thread context if message is from a thread
+  let prefix = author;
+  if (message.channel?.isThread?.()) {
+    const threadName = message.channel.name || "thread";
+    prefix = `${author} [thread: ${threadName}]`;
+  }
+
+  return `${prefix}: ${fullText}`;
 }
 
 export async function persistInboundDiscordMessage(message: any): Promise<boolean> {