@mndrk/agx 2.0.25 → 2.0.32

package/cloud-runtime/standalone/lib/mesh-core/journal.ts

@@ -45,6 +45,13 @@ function parseMaxSeq(agentId: string, lines: string[]): number {
   return maxSeq;
 }
 
+function parseEntrySeq(agentId: string, entryId?: string | null): number {
+  const [idAgent, seqRaw] = String(entryId || "").split(":");
+  if (idAgent !== agentId) return 0;
+  const seq = parseInt(seqRaw || "0", 10);
+  return Number.isFinite(seq) ? seq : 0;
+}
+
 /** Get the next monotonic entry ID for an agent */
 export function getNextEntryId(agentId: string): string {
   const lines = readJournalLines(agentId);
@@ -90,6 +97,29 @@ export function readJournal(agentId: string, limit?: number): JournalEntry[] {
   return limit ? entries.slice(0, limit) : entries;
 }
 
+/** Read journal entries after a cursor, oldest first */
+export function readJournalSince(
+  agentId: string,
+  afterEntryId?: string | null,
+): JournalEntry[] {
+  const lines = readJournalLines(agentId);
+  const afterSeq = parseEntrySeq(agentId, afterEntryId);
+  const entries: JournalEntry[] = [];
+
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line) as JournalEntry;
+      if (parseEntrySeq(agentId, parsed.id) > afterSeq) {
+        entries.push(parsed);
+      }
+    } catch {
+      // skip malformed lines
+    }
+  }
+
+  return entries;
+}
+
 /** Read journal entries filtered by thread */
 export function readJournalByThread(
   agentId: string,

package/cloud-runtime/standalone/lib/mesh-core/self.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import type { AgentSelf, AgentIdentity, JournalEntry } from "./types";
 import { logActivity } from "./activity";
+import type { KnowledgeEntry, KnowledgeKind } from "../knowledge-store";
 
 const AGENTS_DIR = join(homedir(), ".agx", "agents");
 
@@ -10,6 +11,15 @@ function selfPath(agentId: string): string {
   return join(AGENTS_DIR, agentId, "self.md");
 }
 
+function reflectionStatePath(agentId: string): string {
+  return join(AGENTS_DIR, agentId, "reflection-state.json");
+}
+
+export interface ReflectionState {
+  lastProcessedJournalId: string | null;
+  updatedAt: string;
+}
+
 /** Read the current self snapshot */
 export function readSelf(agentId: string): AgentSelf | null {
   const path = selfPath(agentId);
@@ -64,6 +74,33 @@ export function writeSelf(
   logActivity(agentId, "self-updated", { meta: { version } });
 }
 
+export function readReflectionState(agentId: string): ReflectionState | null {
+  const path = reflectionStatePath(agentId);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as ReflectionState;
+    const lastProcessedJournalId =
+      typeof parsed?.lastProcessedJournalId === "string" && parsed.lastProcessedJournalId.trim()
+        ? parsed.lastProcessedJournalId.trim()
+        : null;
+    const updatedAt =
+      typeof parsed?.updatedAt === "string" && parsed.updatedAt.trim()
+        ? parsed.updatedAt
+        : new Date().toISOString();
+    return { lastProcessedJournalId, updatedAt };
+  } catch {
+    return null;
+  }
+}
+
+export function writeReflectionState(agentId: string, state: ReflectionState): void {
+  const dir = join(AGENTS_DIR, agentId);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const tmp = reflectionStatePath(agentId) + ".tmp";
+  writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  renameSync(tmp, reflectionStatePath(agentId));
+}
+
 /** Build the reflection prompt and return new self content */
 export function buildReflectionPrompt(
   identity: AgentIdentity,
@@ -117,3 +154,60 @@ Do NOT reference specific files, functions, or technical details from past conve
 
 Write in first person. Be specific about your strengths, gaps, comparative fit, and next direction. This is not a summary and not an autobiography. It is a concise specialization-oriented self-model. Keep it under 200 words.`;
 }
+
+function formatKnowledgeLines(existingMemories: KnowledgeEntry[]): string {
+  if (existingMemories.length === 0) return "(none)";
+  return existingMemories
+    .map((entry) => `- [${entry.kind}] ${entry.title}: ${entry.body}`)
+    .join("\n");
+}
+
+export function buildStructuredReflectionPrompt(
+  identity: AgentIdentity,
+  currentSelf: AgentSelf | null,
+  recentJournal: JournalEntry[],
+  teamSelves: AgentSelf[],
+  existingMemories: KnowledgeEntry[],
+): string {
+  const selfPrompt = buildReflectionPrompt(identity, currentSelf, recentJournal, teamSelves);
+
+  return `${selfPrompt}
+
+## Existing Agent Memories
+${formatKnowledgeLines(existingMemories)}
+
+## Output Format
+Return ONLY a JSON object with this exact shape:
+{
+  "self_model": "updated self-model text",
+  "memories": [
+    {
+      "kind": "pattern" | "preference" | "constraint" | "decision" | "lesson" | "gotcha",
+      "title": "short title",
+      "body": "one concise durable behavior-level memory",
+      "confidence": 0.0,
+      "durability": 0.0,
+      "tags": ["optional", "tags"],
+      "evidence": [{"id":"journal-entry-id","note":"short evidence note"}]
+    }
+  ]
+}
+
+Rules:
+- Emit 0-3 memories.
+- Memories must be durable behavior-level insights about how you work best, collaborate, decide, or fail repeatedly.
+- Do not include task-specific technical facts unless they clearly generalize into agent behavior.
+- Do not restate memories already covered in Existing Agent Memories.
+- If nothing genuinely new was learned, return an empty memories array.
+- Do not wrap the JSON in markdown fences.`;
+}
+
+export interface AgentReflectionMemoryDraft {
+  kind: KnowledgeKind;
+  title: string;
+  body: string;
+  confidence?: number;
+  durability?: number;
+  tags?: string[];
+  evidence?: Array<{ id?: string; note?: string }>;
+}

package/cloud-runtime/standalone/lib/orchestrator/chat-activities.ts

@@ -0,0 +1,60 @@
+import {
+  appendChatRunStep,
+  getChatRun,
+  listChatRunSteps,
+  updateChatRun,
+  updateChatRunStep,
+  type ChatRunRecord,
+  type ChatRunStepRecord,
+  type ChatRunStatus,
+} from "@/lib/history-store";
+
+export async function loadChatRunActivity(chatRunId: string): Promise<ChatRunRecord | null> {
+  return getChatRun(chatRunId);
+}
+
+export async function updateChatRunActivity(input: {
+  id: string;
+  status?: ChatRunStatus;
+  currentStep?: number;
+  stepsUsed?: number;
+  lastError?: string | null;
+  result?: Record<string, unknown> | null;
+  completedAt?: number | null;
+}): Promise<ChatRunRecord | null> {
+  return updateChatRun(input);
+}
+
+export async function appendChatRunStepActivity(input: {
+  chatRunId: string;
+  kind: string;
+  status: "queued" | "running" | "completed" | "failed";
+  participantId?: string | null;
+  inputPayload?: Record<string, unknown> | null;
+  outputPayload?: Record<string, unknown> | null;
+}): Promise<ChatRunStepRecord> {
+  const existingSteps = await listChatRunSteps(input.chatRunId);
+  return appendChatRunStep({
+    id: crypto.randomUUID(),
+    chatRunId: input.chatRunId,
+    stepIndex: existingSteps.length + 1,
+    kind: input.kind,
+    status: input.status,
+    participantId: input.participantId,
+    inputPayload: input.inputPayload,
+    outputPayload: input.outputPayload,
+  });
+}
+
+export async function completeChatRunStepActivity(input: {
+  stepId: string;
+  status: "completed" | "failed";
+  outputPayload?: Record<string, unknown> | null;
+}): Promise<ChatRunStepRecord | null> {
+  return updateChatRunStep({
+    id: input.stepId,
+    status: input.status,
+    outputPayload: input.outputPayload,
+    completedAt: Date.now(),
+  });
+}

package/cloud-runtime/standalone/lib/orchestrator/chat-processor.ts

@@ -0,0 +1,168 @@
+import type { Job } from "@/lib/queue/adapter";
+import { createMultiplexedStream } from "@/lib/stream-multiplexer";
+import { loadDbParticipants } from "@/lib/agent-participants";
+import { killByThread, killByWorkspace } from "@/lib/agent-process-registry";
+import type { ChatRunPayload, ChatRunJobData } from "@/lib/orchestrator/chat-types";
+import {
+  appendChatRunStepActivity,
+  completeChatRunStepActivity,
+  loadChatRunActivity,
+  updateChatRunActivity,
+} from "@/lib/orchestrator/chat-activities";
+
+function isChatRunPayload(value: unknown): value is ChatRunPayload {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<ChatRunPayload>;
+  return Boolean(
+    typeof candidate.threadId === "string" &&
+      typeof candidate.prompt === "string" &&
+      Array.isArray(candidate.participantIds)
+  );
+}
+
+async function handleStart(job: Job<ChatRunJobData>): Promise<void> {
+  const chatRun = await loadChatRunActivity(job.data.chatRunId);
+  if (!chatRun) {
+    console.warn(`[chat-processor] Chat run ${job.data.chatRunId} not found, skipping`);
+    return;
+  }
+  if (chatRun.status === "completed" || chatRun.status === "failed" || chatRun.status === "cancelled") {
+    return;
+  }
+  if (!isChatRunPayload(chatRun.payload)) {
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "failed",
+      lastError: "Chat run payload is missing or invalid",
+      completedAt: Date.now(),
+    });
+    return;
+  }
+
+  const step = await appendChatRunStepActivity({
+    chatRunId: chatRun.id,
+    kind: "model_turn",
+    status: "running",
+    inputPayload: {
+      participantIds: chatRun.payload.participantIds,
+      rootMessageId: chatRun.payload.rootMessageId,
+      maxRounds: chatRun.payload.maxRounds,
+    },
+  });
+
+  await updateChatRunActivity({
+    id: chatRun.id,
+    status: "running",
+    currentStep: step.stepIndex,
+    stepsUsed: step.stepIndex,
+    lastError: null,
+  });
+
+  try {
+    const library = await loadDbParticipants();
+    const participantIdSet = new Set(chatRun.payload.participantIds);
+    const participants = chatRun.payload.participantIds
+      .map((participantId) => library.find((participant) => participant.id === participantId))
+      .filter((participant): participant is NonNullable<typeof participant> => Boolean(participant));
+
+    if (participants.length === 0) {
+      throw new Error("No participants resolved for chat run");
+    }
+
+    const mentioned = new Set(
+      chatRun.payload.mentionedIds.filter((participantId) => participantIdSet.has(participantId))
+    );
+    const initialParallelIds = new Set(
+      chatRun.payload.initialParallelIds.filter((participantId) => participantIdSet.has(participantId))
+    );
+
+    const stream = createMultiplexedStream({
+      threadId: chatRun.payload.threadId,
+      allParticipants: participants,
+      mentioned,
+      initialParallelIds,
+      prompt: chatRun.payload.prompt,
+      projectContext: chatRun.payload.projectContext,
+      maxRounds: chatRun.payload.maxRounds,
+      recentHistory: chatRun.payload.recentHistory,
+      currentUserMessageId: chatRun.payload.currentUserMessageId,
+      rootMessageId: chatRun.payload.rootMessageId,
+    });
+
+    const reader = stream.getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+
+    await completeChatRunStepActivity({
+      stepId: step.id,
+      status: "completed",
+      outputPayload: {
+        completed: true,
+        participantCount: participants.length,
+      },
+    });
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "completed",
+      completedAt: Date.now(),
+      result: {
+        participantIds: participants.map((participant) => participant.id),
+        rootMessageId: chatRun.payload.rootMessageId,
+      },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await completeChatRunStepActivity({
+      stepId: step.id,
+      status: "failed",
+      outputPayload: { error: message },
+    });
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "failed",
+      lastError: message,
+      completedAt: Date.now(),
+      result: { error: message },
+    });
+  }
+}
+
+async function handleCancel(job: Job<ChatRunJobData>): Promise<void> {
+  const chatRun = await loadChatRunActivity(job.data.chatRunId);
+  if (!chatRun) return;
+
+  if (chatRun.rootMessageId) {
+    killByThread(chatRun.rootMessageId);
+  } else {
+    killByWorkspace(chatRun.threadId);
+  }
+
+  await updateChatRunActivity({
+    id: chatRun.id,
+    status: "cancelled",
+    lastError: job.data.payload?.reason || "Cancelled",
+    completedAt: Date.now(),
+    result: { cancelled: true },
+  });
+}
+
+async function processSingleJob(job: Job<ChatRunJobData>): Promise<void> {
+  switch (job.data.signal) {
+    case "start":
+      await handleStart(job);
+      break;
+    case "cancel":
+      await handleCancel(job);
+      break;
+    default:
+      console.warn(`[chat-processor] Unknown signal: ${job.data.signal}`);
+  }
+}
+
+export async function chatProcessor(jobs: Job<ChatRunJobData>[]): Promise<void> {
+  for (const job of jobs) {
+    await processSingleJob(job);
+  }
+}

package/cloud-runtime/standalone/lib/orchestrator/chat-types.ts

@@ -0,0 +1,29 @@
+import type { Participant } from "@/lib/types";
+import type { StreamProjectContext } from "@/lib/stream-multiplexer";
+
+export type ChatRunSignal = "start" | "cancel";
+
+export interface ChatRunPayload {
+  threadId: string;
+  prompt: string;
+  projectContext?: StreamProjectContext;
+  mentionedIds: string[];
+  initialParallelIds: string[];
+  maxRounds: number;
+  recentHistory: Array<{ id: string; name: string; content: string }>;
+  currentUserMessageId: string | null;
+  rootMessageId: string | null;
+  participantIds: string[];
+}
+
+export interface ChatRunJobData {
+  chatRunId: string;
+  userId: string;
+  signal: ChatRunSignal;
+  payload?: { reason?: string };
+}
+
+export interface ResolvedChatRunContext {
+  payload: ChatRunPayload;
+  participants: Participant[];
+}

package/cloud-runtime/standalone/lib/orchestrator/runtime.ts

@@ -0,0 +1,20 @@
+import { getQueue, QUEUE_NAMES } from "@/lib/queue/boss";
+import { taskProcessor } from "@/lib/orchestrator/processor";
+import { chatProcessor } from "@/lib/orchestrator/chat-processor";
+
+let bootstrapPromise: Promise<void> | null = null;
+
+export async function ensureOrchestratorRuntime(): Promise<void> {
+  if (bootstrapPromise) return bootstrapPromise;
+
+  bootstrapPromise = (async () => {
+    const queue = await getQueue();
+    await queue.work(QUEUE_NAMES.TASK_PROCESS, taskProcessor, { batchSize: 5 });
+    await queue.work(QUEUE_NAMES.CHAT_RUN_PROCESS, chatProcessor, { batchSize: 2 });
+  })().catch((error) => {
+    bootstrapPromise = null;
+    throw error;
+  });
+
+  return bootstrapPromise;
+}

package/cloud-runtime/standalone/lib/provider-clis.ts

@@ -0,0 +1,63 @@
+export type ProviderId = "claude" | "gemini" | "ollama" | "codex" | "zai";
+
+export interface ProviderCliDefinition {
+  id: ProviderId;
+  label: string;
+  bin: string;
+  description: string;
+  installCmd: string;
+  docsUrl: string;
+  recommended?: boolean;
+  installNote?: string;
+  statusLabel?: string;
+}
+
+export const PROVIDER_CLIS: ProviderCliDefinition[] = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    bin: "claude",
+    description: "Recommended for the fastest AGX setup.",
+    installCmd: "npm install -g @anthropic-ai/claude-code",
+    docsUrl: "https://docs.anthropic.com/en/docs/claude-code/quickstart",
+    recommended: true,
+    statusLabel: "Installed",
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    bin: "codex",
+    description: "OpenAI's terminal coding agent.",
+    installCmd: "npm install -g @openai/codex",
+    docsUrl: "https://github.com/openai/codex",
+    statusLabel: "Installed",
+  },
+  {
+    id: "gemini",
+    label: "Gemini CLI",
+    bin: "gemini",
+    description: "Google's CLI for Gemini workflows.",
+    installCmd: "npm install -g @google/gemini-cli",
+    docsUrl: "https://github.com/google-gemini/gemini-cli",
+    statusLabel: "Installed",
+  },
+  {
+    id: "ollama",
+    label: "Ollama",
+    bin: "ollama",
+    description: "Run local models on your machine.",
+    installCmd: "curl -fsSL https://ollama.com/install.sh | sh",
+    docsUrl: "https://ollama.com/download",
+    statusLabel: "Installed",
+  },
+  {
+    id: "zai",
+    label: "Z.AI",
+    bin: "claude",
+    description: "Use the Claude CLI with your Z.AI API key.",
+    installCmd: "npm install -g @anthropic-ai/claude-code",
+    docsUrl: "https://z.ai/",
+    installNote: "Requires Claude Code plus a configured Z.AI API key.",
+    statusLabel: "Via Claude CLI",
+  },
+];

package/cloud-runtime/standalone/lib/queue/boss.ts

@@ -5,6 +5,7 @@ let queue: QueueAdapter | null = null;
 
 export const QUEUE_NAMES = {
     TASK_PROCESS: "agx.task.process",
+    CHAT_RUN_PROCESS: "agx.chat.process",
     TASK_CLEANUP: "agx.task.cleanup",
 } as const;
 
@@ -24,4 +25,4 @@ export async function stopQueue(): Promise<void> {
 }
 
 // Re-export types if needed, or point consumers to adapter.ts
-export type { QueueAdapter };
+export type { QueueAdapter };

package/cloud-runtime/standalone/lib/repo-knowledge.ts

@@ -1,4 +1,5 @@
 import { getSQLiteDb } from "./sqlite-query-adapter";
+import { getKnowledgeNote } from "./knowledge-notes";
 
 export type RepoKnowledgeProducer = "human" | "system";
 
@@ -39,6 +40,19 @@ export function listRepoKnowledge(
   const db = getSQLiteDb();
   const producer = options?.producer;
 
+  if (producer === "system") {
+    const note = getKnowledgeNote("repo", repoId);
+    return note
+      ? [{
+        id: note.id,
+        repo_id: repoId,
+        content: note.content,
+        producer: "system",
+        created_at: note.updatedAt,
+      }]
+      : [];
+  }
+
   const rows = producer
     ? (db
         .prepare(
@@ -57,7 +71,7 @@ export function listRepoKnowledge(
         )
         .all(repoId) as RepoKnowledgeRow[]);
 
-  if (options?.includeLegacyHumanFallback === false || producer === "system") {
+  if (options?.includeLegacyHumanFallback === false) {
     return rows;
   }
 
@@ -139,7 +153,10 @@ export function listResolvedRepoKnowledge(repos: Array<{ id?: string; name: stri
       continue;
     }
 
-    const rows = listRepoKnowledge(repo.id);
+    const rows = [
+      ...listRepoKnowledge(repo.id, { producer: "human" }),
+      ...listRepoKnowledge(repo.id, { producer: "system", includeLegacyHumanFallback: false }),
+    ];
     for (const row of rows) {
       const content = row.content.trim();
       if (!content) continue;

package/cloud-runtime/standalone/lib/sqlite-query-adapter.ts

@@ -219,6 +219,84 @@ function runMigrations(db: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_repo_knowledge_producer ON repo_knowledge (producer);
   `);
 
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_entries (
+      id TEXT NOT NULL PRIMARY KEY,
+      scope TEXT NOT NULL CHECK(scope IN ('agent', 'repo', 'project')),
+      subject_id TEXT NOT NULL,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('outcome', 'decision', 'pattern', 'gotcha', 'preference', 'constraint', 'convention', 'lesson')),
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      confidence REAL,
+      durability REAL,
+      tags JSON NOT NULL DEFAULT '[]',
+      evidence JSON NOT NULL DEFAULT '[]',
+      metadata JSON NOT NULL DEFAULT '{}',
+      content_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(scope, subject_id, content_hash)
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_entries_scope_subject ON knowledge_entries (scope, subject_id, updated_at);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_entries_source ON knowledge_entries (source_type, source_id);
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_notes (
+      id TEXT NOT NULL PRIMARY KEY,
+      scope TEXT NOT NULL CHECK(scope IN ('agent', 'repo', 'project')),
+      subject_id TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      change_summary TEXT,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      metadata JSON NOT NULL DEFAULT '{}',
+      version INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(scope, subject_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_notes_scope_subject ON knowledge_notes (scope, subject_id);
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_note_versions (
+      id TEXT NOT NULL PRIMARY KEY,
+      note_id TEXT NOT NULL REFERENCES knowledge_notes(id) ON DELETE CASCADE,
+      version INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      change_summary TEXT,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      metadata JSON NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_note_versions_note_version
+      ON knowledge_note_versions (note_id, version DESC);
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS thread_knowledge_runs (
+      id TEXT NOT NULL PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      root_message_id TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('running', 'completed', 'failed')),
+      requested_scopes JSON NOT NULL DEFAULT '[]',
+      repo_inserted_count INTEGER NOT NULL DEFAULT 0,
+      project_inserted_count INTEGER NOT NULL DEFAULT 0,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      completed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_thread_knowledge_runs_root_created
+      ON thread_knowledge_runs (root_message_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_thread_knowledge_runs_thread_created
+      ON thread_knowledge_runs (thread_id, created_at DESC);
+  `);
+
   // Create project_threads table (replaces team_workspaces)
   db.exec(`
     CREATE TABLE IF NOT EXISTS project_threads (