@mndrk/agx 2.0.26 → 2.0.33

package/cloud-runtime/standalone/lib/history-store.ts

@@ -22,6 +22,8 @@ const REACTION_TYPES = new Set<ReactionType>([
   "clarify",
   "blocked",
 ]);
+const ACTIVE_AGENT_PROCESS_STALE_MS = 10 * 60 * 1000;
+const ACTIVE_CHAT_RUN_STALE_MS = 10 * 60 * 1000;
 const ALLOWED_TRANSITIONS: Record<ReactionType, Set<ReactionType>> = {
   ack: new Set<ReactionType>(["ack", "working"]),
   working: new Set<ReactionType>(["ack", "working", "done", "clarify", "blocked"]),
@@ -78,6 +80,15 @@ interface SearchMessagesResult {
   total: number;
 }
 
+interface SearchRow {
+  thread_id: string;
+  id: string;
+  role: "user" | "assistant";
+  participant_id: string | null;
+  timestamp: number;
+  root_message_id: string | null;
+}
+
 interface MessageRow {
   id: string;
   role: string;
@@ -125,6 +136,81 @@ interface GetThreadStatusSnapshotInput {
   processLimit?: number;
 }
 
+export type ChatRunStatus =
+  | "queued"
+  | "running"
+  | "awaiting_user"
+  | "blocked"
+  | "completed"
+  | "failed"
+  | "cancelled";
+
+export type ChatRunStepStatus = "queued" | "running" | "completed" | "failed";
+
+export interface ChatRunRecord {
+  id: string;
+  threadId: string;
+  rootMessageId: string | null;
+  userId: string;
+  projectSlug: string | null;
+  status: ChatRunStatus;
+  currentStep: number;
+  maxSteps: number;
+  stepsUsed: number;
+  lastError: string | null;
+  activeParticipantIds: string[];
+  payload: Record<string, unknown> | null;
+  result: Record<string, unknown> | null;
+  createdAt: number;
+  updatedAt: number;
+  completedAt: number | null;
+}
+
+export interface ChatRunStepRecord {
+  id: string;
+  chatRunId: string;
+  stepIndex: number;
+  kind: string;
+  status: ChatRunStepStatus;
+  participantId: string | null;
+  inputPayload: Record<string, unknown> | null;
+  outputPayload: Record<string, unknown> | null;
+  startedAt: number;
+  completedAt: number | null;
+}
+
+interface ChatRunRow {
+  id: string;
+  thread_id: string;
+  root_message_id: string | null;
+  user_id: string;
+  project_slug: string | null;
+  status: ChatRunStatus;
+  current_step: number;
+  max_steps: number;
+  steps_used: number;
+  last_error: string | null;
+  active_participant_ids: string;
+  payload_json: string | null;
+  result_json: string | null;
+  created_at: number;
+  updated_at: number;
+  completed_at: number | null;
+}
+
+interface ChatRunStepRow {
+  id: string;
+  chat_run_id: string;
+  step_index: number;
+  kind: string;
+  status: ChatRunStepStatus;
+  participant_id: string | null;
+  input_payload_json: string | null;
+  output_payload_json: string | null;
+  started_at: number;
+  completed_at: number | null;
+}
+
 export interface ThreadStatusSnapshot {
   rootMessage: GroupMessage | null;
   processes: ThreadStatusProcess[];
@@ -139,6 +225,16 @@ function hasSqliteObject(db: Database.Database, type: "table" | "trigger", name:
   return Boolean(row);
 }
 
+function isPidAlive(pid: number | null | undefined): boolean {
+  if (!Number.isFinite(pid) || !pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function initializeMessageSearch(db: Database.Database): void {
   const hasFtsTable = hasSqliteObject(db, "table", "messages_fts");
   db.exec(`
@@ -262,6 +358,64 @@ function migrateAgentProcessesAddId(db: Database.Database): void {
   `);
 }
 
+function parseJsonObject(value: string | null): Record<string, unknown> | null {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function parseJsonStringArray(value: string | null): string[] {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed) ? parsed.filter((item): item is string => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
+function toChatRunRecord(row: ChatRunRow): ChatRunRecord {
+  return {
+    id: row.id,
+    threadId: row.thread_id,
+    rootMessageId: row.root_message_id,
+    userId: row.user_id,
+    projectSlug: row.project_slug,
+    status: row.status,
+    currentStep: row.current_step,
+    maxSteps: row.max_steps,
+    stepsUsed: row.steps_used,
+    lastError: row.last_error,
+    activeParticipantIds: parseJsonStringArray(row.active_participant_ids),
+    payload: parseJsonObject(row.payload_json),
+    result: parseJsonObject(row.result_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    completedAt: row.completed_at,
+  };
+}
+
+function toChatRunStepRecord(row: ChatRunStepRow): ChatRunStepRecord {
+  return {
+    id: row.id,
+    chatRunId: row.chat_run_id,
+    stepIndex: row.step_index,
+    kind: row.kind,
+    status: row.status,
+    participantId: row.participant_id,
+    inputPayload: parseJsonObject(row.input_payload_json),
+    outputPayload: parseJsonObject(row.output_payload_json),
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+  };
+}
+
 function migrateLegacyTables(db: Database.Database): void {
   if (!isThreadScopedTable(db, "messages")) {
     db.exec(`
@@ -362,6 +516,36 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
         updated_at INTEGER NOT NULL,
         PRIMARY KEY (thread_id, message_id)
       );
+      CREATE TABLE IF NOT EXISTS chat_runs (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        root_message_id TEXT,
+        user_id TEXT NOT NULL,
+        project_slug TEXT,
+        status TEXT NOT NULL,
+        current_step INTEGER NOT NULL DEFAULT 0,
+        max_steps INTEGER NOT NULL DEFAULT 10,
+        steps_used INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT,
+        active_participant_ids TEXT NOT NULL DEFAULT '[]',
+        payload_json TEXT,
+        result_json TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS chat_run_steps (
+        id TEXT PRIMARY KEY,
+        chat_run_id TEXT NOT NULL,
+        step_index INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        participant_id TEXT,
+        input_payload_json TEXT,
+        output_payload_json TEXT,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
     `);
     migrateLegacyTables(db);
     migrateThreadReplyColumns(db);
@@ -380,6 +564,9 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
       CREATE INDEX IF NOT EXISTS idx_messages_thread_ts ON messages(thread_id, timestamp ASC);
       CREATE INDEX IF NOT EXISTS idx_reactions_thread_message ON message_reactions(thread_id, message_id, updated_at ASC);
       CREATE INDEX IF NOT EXISTS idx_logs_process_ts ON logs(agent_process_id, timestamp ASC);
+      CREATE INDEX IF NOT EXISTS idx_chat_runs_thread_updated ON chat_runs(thread_id, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_runs_status_updated ON chat_runs(status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_run_steps_run_step ON chat_run_steps(chat_run_id, step_index ASC);
     `);
     return run(db);
   } finally {
@@ -470,6 +657,51 @@ function clampPositiveInt(value: number | undefined, fallback: number, max: numb
   return Math.min(Math.max(Math.trunc(normalized), 1), max);
 }
 
+function tokenizeSearchTerms(query: string): string[] {
+  const matches = query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+  const seen = new Set<string>();
+  const tokens: string[] = [];
+  for (const match of matches) {
+    if (seen.has(match)) continue;
+    seen.add(match);
+    tokens.push(match);
+  }
+  return tokens;
+}
+
+function escapeLikePattern(value: string): string {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildSearchSnippet(content: string, terms: string[]): string {
+  const compact = stripAgxMarkers(content).replace(/\s+/g, " ").trim();
+  if (!compact) return "";
+
+  const searchTerms = terms.filter(Boolean);
+  const lowerContent = compact.toLowerCase();
+  const firstMatchIndex = searchTerms.reduce((best, term) => {
+    const index = lowerContent.indexOf(term);
+    if (index === -1) return best;
+    if (best === -1 || index < best) return index;
+    return best;
+  }, -1);
+
+  const start = firstMatchIndex >= 0 ? Math.max(0, firstMatchIndex - 48) : 0;
+  const end = firstMatchIndex >= 0 ? Math.min(compact.length, firstMatchIndex + 112) : Math.min(compact.length, 160);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < compact.length ? "..." : "";
+  const excerpt = `${prefix}${compact.slice(start, end)}${suffix}`;
+
+  if (searchTerms.length === 0) return excerpt;
+
+  const pattern = new RegExp(`(${searchTerms.map(escapeRegExp).join("|")})`, "giu");
+  return excerpt.replace(pattern, "<mark>$1</mark>");
+}
+
 function toGroupMessage(row: MessageRow, reactionMap: Map<string, MessageReaction[]>): GroupMessage {
   return {
     id: row.id,
@@ -584,7 +816,7 @@ export async function getProjectThreadIds(projectId: string): Promise<string[]>
   const { getSQLiteDb } = await import("@/lib/sqlite-query-adapter");
   const db = getSQLiteDb();
   const rows = db
-    .prepare("SELECT thread_id FROM project_threads WHERE project_id = ?")
+    .prepare("SELECT thread_id FROM project_threads WHERE project_id = ? ORDER BY created_at ASC")
     .all(projectId) as { thread_id: string }[];
   return rows.map((r) => r.thread_id);
 }
@@ -759,7 +991,7 @@ export async function getThreadStatusSnapshot(
     // These may not have an assistant message yet, so the primary query misses them.
     const activeProcessRows = db
       .prepare(
-        `SELECT ap.agent_id, ap.pid, ap.state, ap.since_message_id, ap.started_at, ap.last_activity,
+        `SELECT ap.id, ap.agent_id, ap.pid, ap.state, ap.since_message_id, ap.started_at, ap.last_activity,
                 m.content as response_to,
                 m.role as response_to_role,
                 m.participant_id as response_to_participant_id
@@ -770,6 +1002,7 @@ export async function getThreadStatusSnapshot(
            AND ap.state IN ('running', 'spawning')`
       )
       .all(scopedRootMessageId) as Array<{
+      id: number;
       agent_id: string;
       pid: number;
       state: string;
@@ -781,10 +1014,36 @@ export async function getThreadStatusSnapshot(
       response_to_participant_id: string | null;
     }>;
 
+    const now = Date.now();
+    const staleActiveProcessIds = activeProcessRows
+      .filter((ap) => {
+        const lastSeenAt = Math.max(ap.last_activity || 0, ap.started_at || 0);
+        if (lastSeenAt > now - ACTIVE_AGENT_PROCESS_STALE_MS) return false;
+        return !isPidAlive(ap.pid);
+      })
+      .map((ap) => ap.id);
+    const staleActiveProcessIdSet = new Set(staleActiveProcessIds);
+
+    if (staleActiveProcessIds.length > 0) {
+      const markStale = db.prepare(
+        `UPDATE agent_processes
+         SET state = 'error',
+             last_activity = ?
+         WHERE id = ?`
+      );
+      const markManyStale = db.transaction((ids: number[]) => {
+        for (const id of ids) {
+          markStale.run(now, id);
+        }
+      });
+      markManyStale(staleActiveProcessIds);
+    }
+
     // Merge: only add active processes not already represented
     const existingPids = new Set(processes.filter(p => p.processId != null).map(p => p.processId));
     const existingAgents = new Set(processes.filter(p => p.status === "running").map(p => p.agent));
     for (const ap of activeProcessRows) {
+      if (staleActiveProcessIdSet.has(ap.id)) continue;
       if (existingPids.has(ap.pid) || existingAgents.has(ap.agent_id)) continue;
       processes.push({
         processId: ap.pid || null,
@@ -887,6 +1146,250 @@ export async function saveMessages(threadId: string, messages: GroupMessage[]):
   });
 }
 
+export async function createChatRun(input: {
+  id: string;
+  threadId: string;
+  rootMessageId?: string | null;
+  userId: string;
+  projectSlug?: string | null;
+  maxSteps: number;
+  activeParticipantIds: string[];
+  payload?: Record<string, unknown> | null;
+}): Promise<ChatRunRecord> {
+  const now = Date.now();
+  return withDatabase((db) => {
+    db.prepare(
+      `INSERT INTO chat_runs (
+        id, thread_id, root_message_id, user_id, project_slug, status,
+        current_step, max_steps, steps_used, last_error, active_participant_ids,
+        payload_json, result_json, created_at, updated_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, 'queued', 0, ?, 0, NULL, ?, ?, NULL, ?, ?, NULL)`
+    ).run(
+      input.id,
+      input.threadId.trim() || LEGACY_THREAD_ID,
+      normalizeOptionalText(input.rootMessageId),
+      input.userId,
+      normalizeOptionalText(input.projectSlug),
+      clampPositiveInt(input.maxSteps, 10, 50),
+      JSON.stringify(input.activeParticipantIds),
+      input.payload ? JSON.stringify(input.payload) : null,
+      now,
+      now
+    );
+
+    const row = db.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(input.id) as ChatRunRow | undefined;
+    if (!row) {
+      throw new Error(`Failed to create chat run ${input.id}`);
+    }
+    return toChatRunRecord(row);
+  });
+}
+
+export async function sweepStaleChatRuns(input?: {
+  threadId?: string | null;
+  olderThanMs?: number;
+}): Promise<number> {
+  const normalizedThreadId = normalizeOptionalText(input?.threadId ?? null);
+  const thresholdMs = Number.isFinite(input?.olderThanMs)
+    ? Math.max(input!.olderThanMs!, 1)
+    : ACTIVE_CHAT_RUN_STALE_MS;
+  const now = Date.now();
+  const cutoff = now - thresholdMs;
+
+  return withDatabase((db) => {
+    const clauses = ["status = 'running'", "updated_at <= ?"];
+    const params: Array<string | number> = [cutoff];
+
+    if (normalizedThreadId) {
+      clauses.push("thread_id = ?");
+      params.push(normalizedThreadId);
+    }
+
+    const result = db
+      .prepare(
+        `UPDATE chat_runs
+         SET status = 'failed',
+             last_error = COALESCE(NULLIF(last_error, ''), 'Worker process died mid-execution'),
+             updated_at = ?,
+             completed_at = COALESCE(completed_at, ?)
+         WHERE ${clauses.join(" AND ")}`
+      )
+      .run(now, now, ...params);
+
+    return result.changes;
+  });
+}
+
+export async function getChatRun(chatRunId: string): Promise<ChatRunRecord | null> {
+  await sweepStaleChatRuns();
+  return withDatabase((db) => {
+    const row = db.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(chatRunId) as ChatRunRow | undefined;
+    return row ? toChatRunRecord(row) : null;
+  });
+}
+
+export async function listChatRuns(input: {
+  threadId?: string | null;
+  status?: ChatRunStatus | "active";
+  limit?: number;
+}): Promise<ChatRunRecord[]> {
+  await sweepStaleChatRuns({ threadId: input.threadId });
+  const normalizedThreadId = normalizeOptionalText(input.threadId ?? null);
+  const limit = clampPositiveInt(input.limit, 20, 100);
+  return withDatabase((db) => {
+    const clauses: string[] = [];
+    const params: Array<string | number> = [];
+
+    if (normalizedThreadId) {
+      clauses.push("thread_id = ?");
+      params.push(normalizedThreadId);
+    }
+
+    if (input.status === "active") {
+      clauses.push("status IN ('queued', 'running')");
+    } else if (input.status) {
+      clauses.push("status = ?");
+      params.push(input.status);
+    }
+
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db
+      .prepare(`SELECT * FROM chat_runs ${where} ORDER BY updated_at DESC LIMIT ?`)
+      .all(...params, limit) as ChatRunRow[];
+    return rows.map(toChatRunRecord);
+  });
+}
+
+export async function updateChatRun(input: {
+  id: string;
+  status?: ChatRunStatus;
+  currentStep?: number;
+  stepsUsed?: number;
+  lastError?: string | null;
+  payload?: Record<string, unknown> | null;
+  result?: Record<string, unknown> | null;
+  completedAt?: number | null;
+}): Promise<ChatRunRecord | null> {
+  return withDatabase((db) => {
+    const updates: string[] = ["updated_at = ?"];
+    const params: Array<string | number | null> = [Date.now()];
+
+    if (input.status) {
+      updates.push("status = ?");
+      params.push(input.status);
+    }
+    if (typeof input.currentStep === "number") {
+      updates.push("current_step = ?");
+      params.push(input.currentStep);
+    }
+    if (typeof input.stepsUsed === "number") {
+      updates.push("steps_used = ?");
+      params.push(input.stepsUsed);
+    }
+    if (input.lastError !== undefined) {
+      updates.push("last_error = ?");
+      params.push(normalizeOptionalText(input.lastError));
+    }
+    if (input.payload !== undefined) {
+      updates.push("payload_json = ?");
+      params.push(input.payload ? JSON.stringify(input.payload) : null);
+    }
+    if (input.result !== undefined) {
+      updates.push("result_json = ?");
+      params.push(input.result ? JSON.stringify(input.result) : null);
+    }
+    if (input.completedAt !== undefined) {
+      updates.push("completed_at = ?");
+      params.push(input.completedAt);
+    }
+
+    params.push(input.id);
+    db.prepare(`UPDATE chat_runs SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+
+    const row = db.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(input.id) as ChatRunRow | undefined;
+    return row ? toChatRunRecord(row) : null;
+  });
+}
+
+export async function appendChatRunStep(input: {
+  id: string;
+  chatRunId: string;
+  stepIndex: number;
+  kind: string;
+  status: ChatRunStepStatus;
+  participantId?: string | null;
+  inputPayload?: Record<string, unknown> | null;
+  outputPayload?: Record<string, unknown> | null;
+}): Promise<ChatRunStepRecord> {
+  const now = Date.now();
+  return withDatabase((db) => {
+    db.prepare(
+      `INSERT INTO chat_run_steps (
+        id, chat_run_id, step_index, kind, status, participant_id,
+        input_payload_json, output_payload_json, started_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.id,
+      input.chatRunId,
+      input.stepIndex,
+      input.kind,
+      input.status,
+      normalizeOptionalText(input.participantId),
+      input.inputPayload ? JSON.stringify(input.inputPayload) : null,
+      input.outputPayload ? JSON.stringify(input.outputPayload) : null,
+      now,
+      input.status === "completed" || input.status === "failed" ? now : null
+    );
+
+    const row = db.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id) as ChatRunStepRow | undefined;
+    if (!row) {
+      throw new Error(`Failed to append chat run step ${input.id}`);
+    }
+    return toChatRunStepRecord(row);
+  });
+}
+
+export async function updateChatRunStep(input: {
+  id: string;
+  status?: ChatRunStepStatus;
+  outputPayload?: Record<string, unknown> | null;
+  completedAt?: number | null;
+}): Promise<ChatRunStepRecord | null> {
+  return withDatabase((db) => {
+    const updates: string[] = [];
+    const params: Array<string | number | null> = [];
+    if (input.status) {
+      updates.push("status = ?");
+      params.push(input.status);
+    }
+    if (input.outputPayload !== undefined) {
+      updates.push("output_payload_json = ?");
+      params.push(input.outputPayload ? JSON.stringify(input.outputPayload) : null);
+    }
+    if (input.completedAt !== undefined) {
+      updates.push("completed_at = ?");
+      params.push(input.completedAt);
+    }
+    if (updates.length === 0) {
+      const existing = db.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id) as ChatRunStepRow | undefined;
+      return existing ? toChatRunStepRecord(existing) : null;
+    }
+    params.push(input.id);
+    db.prepare(`UPDATE chat_run_steps SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+    const row = db.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id) as ChatRunStepRow | undefined;
+    return row ? toChatRunStepRecord(row) : null;
+  });
+}
+
+export async function listChatRunSteps(chatRunId: string): Promise<ChatRunStepRecord[]> {
+  return withDatabase((db) => {
+    const rows = db
+      .prepare("SELECT * FROM chat_run_steps WHERE chat_run_id = ? ORDER BY step_index ASC, started_at ASC")
+      .all(chatRunId) as ChatRunStepRow[];
+    return rows.map(toChatRunStepRecord);
+  });
+}
+
 export async function updateMessageStatus(
   threadId: string,
   messageId: string,
@@ -919,6 +1422,24 @@ export async function clearHistory(threadId: string): Promise<void> {
   });
 }
 
+export async function deleteMessage(threadId: string, messageId: string): Promise<void> {
+  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+  const normalizedMessageId = messageId.trim();
+  if (!normalizedMessageId) return;
+
+  await withDatabase((db) => {
+    const tx = db.transaction((thread: string, msgId: string) => {
+      db.prepare(
+        `DELETE FROM message_reactions WHERE thread_id = ? AND message_id = ?`
+      ).run(thread, msgId);
+      db.prepare(
+        `DELETE FROM messages WHERE thread_id = ? AND id = ?`
+      ).run(thread, msgId);
+    });
+    tx(normalizedThreadId, normalizedMessageId);
+  });
+}
+
 export async function clearRootThread(threadId: string, rootMessageId: string): Promise<void> {
   const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
   const normalizedRootMessageId = rootMessageId.trim();
@@ -959,59 +1480,108 @@ export async function searchMessages(input: SearchMessagesInput): Promise<Search
   const requestedOffset = Number.isFinite(input.offset) ? Number(input.offset) : 0;
   const limit = Math.min(Math.max(Math.trunc(requestedLimit), 1), 100);
   const offset = Math.max(Math.trunc(requestedOffset), 0);
+  const searchTerms = tokenizeSearchTerms(normalizedQuery);
+  const ftsQuery = searchTerms.length > 0 ? searchTerms.map((term) => `${term}*`).join(" ") : null;
 
   return withDatabase((db) => {
-    const whereClauses = ["messages_fts MATCH ?"];
-    const whereParams: Array<string | number> = [normalizedQuery];
-    if (normalizedThreadId) {
-      whereClauses.push("m.thread_id = ?");
-      whereParams.push(normalizedThreadId);
-    }
+    const merged = new Map<string, MessageSearchResult & { sortRank: number; matchedByFts: boolean }>();
+
+    if (ftsQuery) {
+      const ftsWhereClauses = ["messages_fts MATCH ?"];
+      const ftsWhereParams: Array<string | number> = [ftsQuery];
+      if (normalizedThreadId) {
+        ftsWhereClauses.push("m.thread_id = ?");
+        ftsWhereParams.push(normalizedThreadId);
+      }
 
-    const whereSql = whereClauses.join(" AND ");
+      const ftsRows = db
+        .prepare(
+          `SELECT m.thread_id, m.id, m.role, m.participant_id, m.timestamp, m.root_message_id,
+                  snippet(messages_fts, 0, '<mark>', '</mark>', '...', 32) AS snippet,
+                  bm25(messages_fts) as rank
+           FROM messages_fts
+           JOIN messages m ON messages_fts.rowid = m.rowid
+           WHERE ${ftsWhereClauses.join(" AND ")}
+           ORDER BY rank ASC, m.timestamp DESC`
+        )
+        .all(...ftsWhereParams) as Array<SearchRow & { snippet: string; rank: number }>;
+
+      for (const row of ftsRows) {
+        const key = `${row.thread_id}:${row.id}`;
+        merged.set(key, {
+          threadId: row.thread_id,
+          messageId: row.id,
+          role: row.role,
+          participantId: row.participant_id,
+          snippet: row.snippet,
+          timestamp: row.timestamp,
+          rootMessageId: row.root_message_id,
+          sortRank: row.rank,
+          matchedByFts: true,
+        });
+      }
+    }
 
-    const rows = db
-      .prepare(
-        `SELECT m.thread_id, m.id, m.role, m.participant_id, m.timestamp, m.root_message_id,
-                snippet(messages_fts, 0, '<mark>', '</mark>', '...', 32) AS snippet,
-                bm25(messages_fts) as rank
-         FROM messages_fts
-         JOIN messages m ON messages_fts.rowid = m.rowid
-         WHERE ${whereSql}
-         ORDER BY rank ASC, m.timestamp DESC
-         LIMIT ? OFFSET ?`
-      )
-      .all(...whereParams, limit, offset) as Array<{
-      thread_id: string;
-      id: string;
-      role: "user" | "assistant";
-      participant_id: string | null;
-      snippet: string;
-      timestamp: number;
-      root_message_id: string | null;
-      rank: number;
-    }>;
+    const fallbackClauses: string[] = [];
+    const fallbackParams: Array<string | number> = [];
+    if (normalizedThreadId) {
+      fallbackClauses.push("m.thread_id = ?");
+      fallbackParams.push(normalizedThreadId);
+    }
+    if (searchTerms.length > 0) {
+      for (const term of searchTerms) {
+        fallbackClauses.push("LOWER(m.content) LIKE ? ESCAPE '\\'");
+        fallbackParams.push(`%${escapeLikePattern(term)}%`);
+      }
+    } else {
+      fallbackClauses.push("LOWER(m.content) LIKE ? ESCAPE '\\'");
+      fallbackParams.push(`%${escapeLikePattern(normalizedQuery.toLowerCase())}%`);
+    }
 
-    const totalRow = db
+    const fallbackRows = db
       .prepare(
-        `SELECT COUNT(*) as total
-         FROM messages_fts
-         JOIN messages m ON messages_fts.rowid = m.rowid
-         WHERE ${whereSql}`
+        `SELECT m.thread_id, m.id, m.role, m.participant_id, m.content, m.timestamp, m.root_message_id
+         FROM messages m
+         WHERE ${fallbackClauses.join(" AND ")}
+         ORDER BY m.timestamp DESC`
       )
-      .get(...whereParams) as { total: number } | undefined;
+      .all(...fallbackParams) as Array<SearchRow & { content: string }>;
 
-    return {
-      results: rows.map((row) => ({
+    for (const row of fallbackRows) {
+      const key = `${row.thread_id}:${row.id}`;
+      if (merged.has(key)) continue;
+      merged.set(key, {
         threadId: row.thread_id,
         messageId: row.id,
         role: row.role,
         participantId: row.participant_id,
-        snippet: row.snippet,
+        snippet: buildSearchSnippet(row.content, searchTerms),
         timestamp: row.timestamp,
         rootMessageId: row.root_message_id,
+        sortRank: Number.POSITIVE_INFINITY,
+        matchedByFts: false,
+      });
+    }
+
+    const rows = Array.from(merged.values())
+      .sort((a, b) => {
+        if (a.matchedByFts !== b.matchedByFts) return a.matchedByFts ? -1 : 1;
+        if (a.sortRank !== b.sortRank) return a.sortRank - b.sortRank;
+        return b.timestamp - a.timestamp;
+      })
+      .slice(offset, offset + limit);
+
+    return {
+      results: rows.map((row) => ({
+        threadId: row.threadId,
+        messageId: row.messageId,
+        role: row.role,
+        participantId: row.participantId,
+        snippet: row.snippet,
+        timestamp: row.timestamp,
+        rootMessageId: row.rootMessageId,
       })),
-      total: totalRow?.total ?? 0,
+      total: merged.size,
     };
   });
 }