@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/history-store.ts

@@ -53,6 +53,8 @@ interface SetReactionInput {
   type: ReactionType;
   reason?: string | null;
   blockerCode?: string | null;
+  hostPid?: number | null;
+  responseMessageId?: string | null;
 }
 
 interface SetReactionResult {
@@ -76,6 +78,60 @@ interface SearchMessagesResult {
   total: number;
 }
 
+interface MessageRow {
+  id: string;
+  role: string;
+  participant_id: string | null;
+  content: string;
+  timestamp: number;
+  root_message_id: string | null;
+  parent_message_id: string | null;
+  depth: number;
+  thread_status: string | null;
+  outcome_note: string | null;
+}
+
+export type ThreadProcessStatus = "running" | "done" | "failed";
+
+export interface ThreadStatusProcess {
+  processId: number | null;
+  datetime: number;
+  agent: string;
+  responseTo: string;
+  responseToMessageId: string;
+  responseToSenderName: string;
+  responseToSenderRole: GroupMessage["role"];
+  responseMessageId: string | null;
+  responseContent: string | null;
+  status: ThreadProcessStatus;
+}
+
+export interface ThreadMessage {
+  id: string;
+  role: "user" | "assistant";
+  participantId: string | null;
+  content: string;
+  timestamp: number;
+  parentMessageId: string | null;
+  // For assistant messages only:
+  processId: number | null;
+  status: ThreadProcessStatus | null;
+}
+
+interface GetThreadStatusSnapshotInput {
+  rootMessageId?: string;
+  threadId?: string;
+  messageLimit?: number;
+  processLimit?: number;
+}
+
+export interface ThreadStatusSnapshot {
+  rootMessage: GroupMessage | null;
+  processes: ThreadStatusProcess[];
+  messages: ThreadMessage[];
+  lastUpdatedAt: number | null;
+}
+
 function hasSqliteObject(db: Database.Database, type: "table" | "trigger", name: string): boolean {
   const row = db
     .prepare(`SELECT 1 FROM sqlite_master WHERE type = ? AND name = ? LIMIT 1`)
@@ -149,6 +205,63 @@ function migrateThreadStatusColumns(db: Database.Database): void {
   }
 }
 
+function migrateReactionHostPidColumn(db: Database.Database): void {
+  const columns = db.prepare(`PRAGMA table_info(message_reactions)`).all() as Array<{ name: string }>;
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has("host_pid")) {
+    db.exec(`ALTER TABLE message_reactions ADD COLUMN host_pid INTEGER`);
+  }
+  if (!colNames.has("response_message_id")) {
+    db.exec(`ALTER TABLE message_reactions ADD COLUMN response_message_id TEXT`);
+  }
+}
+
+function migrateLogsToAgentProcessId(db: Database.Database): void {
+  const columns = db.prepare(`PRAGMA table_info(logs)`).all() as Array<{ name: string }>;
+  const colNames = new Set(columns.map((c) => c.name));
+  // Already migrated if agent_process_id exists
+  if (colNames.has("agent_process_id")) return;
+  // Old schema had thread_id + participant_id — drop and recreate
+  // (logs are ephemeral, losing old data is acceptable)
+  db.exec(`
+    DROP TABLE IF EXISTS logs;
+    CREATE TABLE logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_process_id INTEGER NOT NULL,
+      stream TEXT NOT NULL,
+      line TEXT NOT NULL,
+      timestamp INTEGER NOT NULL
+    );
+  `);
+}
+
+function migrateAgentProcessesAddId(db: Database.Database): void {
+  const columns = db.prepare(`PRAGMA table_info(agent_processes)`).all() as Array<{ name: string }>;
+  if (columns.length === 0) return; // table doesn't exist yet, DDL will create it
+  const colNames = new Set(columns.map((c) => c.name));
+  if (colNames.has("id")) return; // already has id column
+  // Recreate with id column (data is ephemeral, safe to drop)
+  db.exec(`
+    DROP TABLE IF EXISTS agent_processes;
+    CREATE TABLE agent_processes (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      thread_id    TEXT NOT NULL DEFAULT '',
+      agent_id     TEXT NOT NULL,
+      pid          INTEGER NOT NULL DEFAULT 0,
+      state        TEXT NOT NULL DEFAULT 'spawning',
+      since_message_id TEXT NOT NULL DEFAULT '',
+      started_at   INTEGER NOT NULL DEFAULT 0,
+      last_activity INTEGER NOT NULL DEFAULT 0,
+      project_slug TEXT NOT NULL DEFAULT '',
+      UNIQUE (workspace_id, agent_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_state ON agent_processes (state);
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_thread ON agent_processes (thread_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_workspace ON agent_processes (workspace_id);
+  `);
+}
+
 function migrateLegacyTables(db: Database.Database): void {
   if (!isThreadScopedTable(db, "messages")) {
     db.exec(`
@@ -179,33 +292,20 @@ function migrateLegacyTables(db: Database.Database): void {
         type TEXT NOT NULL,
         reason TEXT,
         blocker_code TEXT,
+        host_pid INTEGER,
+        response_message_id TEXT,
         updated_at INTEGER NOT NULL,
         PRIMARY KEY (thread_id, message_id, participant_id)
       );
-      INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, updated_at)
-      SELECT '${LEGACY_THREAD_ID}', message_id, participant_id, type, reason, blocker_code, updated_at
+      INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, host_pid, updated_at)
+      SELECT '${LEGACY_THREAD_ID}', message_id, participant_id, type, reason, blocker_code, NULL, updated_at
       FROM message_reactions_legacy;
       DROP TABLE message_reactions_legacy;
     `);
   }
 
-  if (!isThreadScopedTable(db, "logs")) {
-    db.exec(`
-      ALTER TABLE logs RENAME TO logs_legacy;
-      CREATE TABLE logs (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id TEXT NOT NULL,
-        participant_id TEXT NOT NULL,
-        stream TEXT NOT NULL,
-        line TEXT NOT NULL,
-        timestamp INTEGER NOT NULL
-      );
-      INSERT INTO logs (thread_id, participant_id, stream, line, timestamp)
-      SELECT '${LEGACY_THREAD_ID}', participant_id, stream, line, timestamp
-      FROM logs_legacy;
-      DROP TABLE logs_legacy;
-    `);
-  }
+  // Migrate logs to agent_process_id schema
+  migrateLogsToAgentProcessId(db);
 }
 
 const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> => {
@@ -230,13 +330,27 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
         type TEXT NOT NULL,
         reason TEXT,
         blocker_code TEXT,
+        host_pid INTEGER,
+        response_message_id TEXT,
         updated_at INTEGER NOT NULL,
         PRIMARY KEY (thread_id, message_id, participant_id)
       );
+      CREATE TABLE IF NOT EXISTS agent_processes (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        thread_id    TEXT NOT NULL DEFAULT '',
+        agent_id     TEXT NOT NULL,
+        pid          INTEGER NOT NULL DEFAULT 0,
+        state        TEXT NOT NULL DEFAULT 'spawning',
+        since_message_id TEXT NOT NULL DEFAULT '',
+        started_at   INTEGER NOT NULL DEFAULT 0,
+        last_activity INTEGER NOT NULL DEFAULT 0,
+        project_slug TEXT NOT NULL DEFAULT '',
+        UNIQUE (workspace_id, agent_id)
+      );
       CREATE TABLE IF NOT EXISTS logs (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        thread_id TEXT NOT NULL,
-        participant_id TEXT NOT NULL,
+        agent_process_id INTEGER NOT NULL,
         stream TEXT NOT NULL,
         line TEXT NOT NULL,
         timestamp INTEGER NOT NULL
@@ -252,11 +366,15 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
     migrateLegacyTables(db);
     migrateThreadReplyColumns(db);
     migrateThreadStatusColumns(db);
+    migrateReactionHostPidColumn(db);
+    // Rename thread_status "parked" → "in-review"
+    db.exec("UPDATE messages SET thread_status = 'in-review' WHERE thread_status = 'parked'");
+    migrateAgentProcessesAddId(db);
     initializeMessageSearch(db);
     db.exec(`
       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_thread_ts ON logs(thread_id, timestamp ASC);
+      CREATE INDEX IF NOT EXISTS idx_logs_process_ts ON logs(agent_process_id, timestamp ASC);
     `);
     return run(db);
   } finally {
@@ -332,47 +450,403 @@ function normalizeOptionalText(value: string | null | undefined): string | null
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function normalizeOptionalHostPid(value: number | null | undefined): number | null {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
+  return value;
+}
+
 function isAllowedTransition(from: ReactionType | null, to: ReactionType): boolean {
   if (!from) return true;
   return ALLOWED_TRANSITIONS[from].has(to);
 }
 
-export async function loadHistory(threadId: string): Promise<GroupMessage[]> {
-  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+function clampPositiveInt(value: number | undefined, fallback: number, max: number = 100): number {
+  const normalized = Number.isFinite(value) ? Number(value) : fallback;
+  return Math.min(Math.max(Math.trunc(normalized), 1), max);
+}
+
+function toGroupMessage(row: MessageRow, reactionMap: Map<string, MessageReaction[]>): GroupMessage {
+  return {
+    id: row.id,
+    role: row.role as "user" | "assistant",
+    participantId: row.participant_id,
+    content: row.content,
+    timestamp: row.timestamp,
+    reactions: reactionMap.get(row.id),
+    rootMessageId: row.root_message_id,
+    parentMessageId: row.parent_message_id,
+    depth: row.depth,
+    ...(row.thread_status ? { threadStatus: row.thread_status as GroupMessage["threadStatus"] } : {}),
+    ...(row.outcome_note ? { outcomeNote: row.outcome_note } : {}),
+  };
+}
+
+function stripAgxMarkers(content: string): string {
+  return content
+    .replace(/\[agx:spawn\]\s*/g, "")
+    .replace(/\s*\[agx:exit:\d+\]\s*/g, "")
+    .replace(/^\[SKIP\]\s*$/gm, "")
+    .trim();
+}
+
+function mapReactionTypeToProcessStatus(type: ReactionType): ThreadProcessStatus | null {
+  if (type === "working") return "running";
+  if (type === "done") return "done";
+  if (type === "blocked" || type === "clarify") return "failed";
+  return null;
+}
+
+export interface RootMessageRow {
+  thread_id: string;
+  id: string;
+  content: string;
+  timestamp: number;
+  thread_status: string | null;
+  outcome_note: string | null;
+  reply_count: number;
+  last_activity: number;
+}
+
+export async function listRootMessages(options?: {
+  status?: string;
+  limit?: number;
+  offset?: number;
+}): Promise<{ rows: RootMessageRow[]; total: number }> {
+  const { status, limit = 20, offset = 0 } = options ?? {};
   return withDatabase((db) => {
+    const where = [
+      "m.root_message_id IS NULL",
+      "m.depth = 0",
+    ];
+    const params: unknown[] = [];
+    if (status) {
+      where.push("COALESCE(m.thread_status, 'thinking') = ?");
+      params.push(status);
+    }
+    const whereClause = where.join(" AND ");
+
+    const countRow = db
+      .prepare(`SELECT COUNT(*) as cnt FROM messages m WHERE ${whereClause}`)
+      .get(...(params.length ? [params] : []).flat()) as { cnt: number };
+
     const rows = db
       .prepare(
-        `SELECT id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+        `SELECT m.thread_id, m.id, m.content, m.timestamp,
+                m.thread_status, m.outcome_note,
+                (SELECT COUNT(*) FROM messages r WHERE r.root_message_id = m.id AND r.thread_id = m.thread_id) as reply_count,
+                COALESCE((SELECT MAX(r.timestamp) FROM messages r WHERE r.root_message_id = m.id AND r.thread_id = m.thread_id), m.timestamp) as last_activity
+         FROM messages m
+         WHERE ${whereClause}
+         ORDER BY last_activity DESC
+         LIMIT ? OFFSET ?`
+      )
+      .all(...params, limit, offset) as RootMessageRow[];
+
+    return { rows, total: countRow.cnt };
+  });
+}
+
+export async function getWorkspaceNames(threadIds: string[]): Promise<Record<string, string>> {
+  if (threadIds.length === 0) return {};
+  // Team names live in the board DB, not the history DB.
+  // Import lazily to avoid circular deps.
+  const { getSQLiteDb } = await import("@/lib/sqlite-query-adapter");
+  const db = getSQLiteDb();
+  const placeholders = threadIds.map(() => "?").join(", ");
+  const rows = db
+    .prepare(
+      `SELECT tw.thread_id, t.name FROM team_workspaces tw
+       JOIN teams t ON t.id = tw.team_id
+       WHERE tw.thread_id IN (${placeholders})`
+    )
+    .all(...threadIds) as { thread_id: string; name: string }[];
+  const names: Record<string, string> = {};
+  for (const r of rows) {
+    if (!names[r.thread_id]) {
+      names[r.thread_id] = r.name;
+    }
+  }
+  return names;
+}
+
+export async function loadHistory(threadId: string, since?: number): Promise<GroupMessage[]> {
+  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+  return withDatabase((db) => {
+    const query = since != null
+      ? `SELECT id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
          FROM messages
-         WHERE thread_id = ?
+         WHERE thread_id = ? AND timestamp > ?
          ORDER BY timestamp ASC`
+      : `SELECT id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+         FROM messages
+         WHERE thread_id = ?
+         ORDER BY timestamp ASC`;
+    const rows = (since != null
+      ? db.prepare(query).all(normalizedThreadId, since)
+      : db.prepare(query).all(normalizedThreadId)) as MessageRow[];
+    const reactionMap = loadMessageReactions(
+      db,
+      normalizedThreadId,
+      rows.map((r) => r.id)
+    );
+    return rows.map((row) => toGroupMessage(row, reactionMap));
+  });
+}
+
+export async function getThreadStatusSnapshot(
+  input: GetThreadStatusSnapshotInput
+): Promise<ThreadStatusSnapshot> {
+  const normalizedRootMessageId = normalizeOptionalText(input.rootMessageId);
+  const requestedThreadId = input.threadId?.trim() || null;
+
+  const processLimit = input.processLimit != null ? clampPositiveInt(input.processLimit, 10) : null;
+
+  return withDatabase((db) => {
+    if (!normalizedRootMessageId && !requestedThreadId) {
+      return {
+        rootMessage: null,
+        processes: [],
+        messages: [],
+        lastUpdatedAt: null,
+      };
+    }
+
+    const messageScopeRow =
+      requestedThreadId && normalizedRootMessageId
+        ? (db
+            .prepare(
+              `SELECT thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+               FROM messages
+               WHERE thread_id = ? AND id = ?
+               LIMIT 1`
+            )
+            .get(requestedThreadId, normalizedRootMessageId) as
+            | (MessageRow & { thread_id: string })
+            | undefined)
+        : requestedThreadId
+          ? (db
+              .prepare(
+                `SELECT thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+                 FROM messages
+                 WHERE thread_id = ?
+                 ORDER BY CASE WHEN root_message_id IS NULL THEN 0 ELSE 1 END, timestamp ASC, id ASC
+                 LIMIT 1`
+              )
+              .get(requestedThreadId) as (MessageRow & { thread_id: string }) | undefined)
+          : (db
+              .prepare(
+                `SELECT thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+                 FROM messages
+                 WHERE id = ?
+                 ORDER BY timestamp ASC, thread_id ASC
+                 LIMIT 1`
+              )
+              .get(normalizedRootMessageId!) as (MessageRow & { thread_id: string }) | undefined);
+
+    if (!messageScopeRow) {
+      return {
+        rootMessage: null,
+        processes: [],
+        messages: [],
+        lastUpdatedAt: null,
+      };
+    }
+
+    const scopedThreadId = messageScopeRow.thread_id;
+    const scopedRootMessageId = messageScopeRow.root_message_id ?? messageScopeRow.id;
+
+    const rootCandidate = db
+      .prepare(
+        `SELECT id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note
+         FROM messages
+         WHERE thread_id = ? AND id = ?
+         LIMIT 1`
       )
-      .all(normalizedThreadId) as Array<{
+      .get(scopedThreadId, scopedRootMessageId) as MessageRow | undefined;
+
+    if (!rootCandidate) {
+      return {
+        rootMessage: null,
+        processes: [],
+        messages: [],
+        lastUpdatedAt: null,
+      };
+    }
+
+    const reactionMap = loadMessageReactions(db, scopedThreadId, [scopedRootMessageId]);
+
+    // Primary source: message_reactions — each reaction represents an agent process.
+    // Join to the message being responded to, and use response_message_id to find response content.
+    const processRows = db
+      .prepare(
+        `SELECT
+            r.updated_at as datetime,
+            r.participant_id as participant_id,
+            r.type as type,
+            r.host_pid as host_pid,
+            r.message_id as response_to_message_id,
+            m.content as response_to,
+            m.role as response_to_role,
+            m.participant_id as response_to_participant_id,
+            r.response_message_id as response_message_id,
+            resp.content as response_content
+         FROM message_reactions r
+         JOIN messages m
+           ON m.id = r.message_id AND m.thread_id = r.thread_id
+         LEFT JOIN messages resp
+           ON resp.id = r.response_message_id AND resp.thread_id = r.thread_id
+         WHERE r.thread_id = ?
+           AND r.type IN ('working', 'done', 'clarify', 'blocked')
+           AND (m.root_message_id = ? OR m.id = ?)
+         ORDER BY r.updated_at DESC
+         ${processLimit != null ? 'LIMIT ?' : ''}`
+      )
+      .all(...[scopedThreadId, scopedRootMessageId, scopedRootMessageId, ...(processLimit != null ? [processLimit] : [])]) as Array<{
+      datetime: number;
+      participant_id: string;
+      type: ReactionType;
+      host_pid: number | null;
+      response_to_message_id: string | null;
+      response_to: string | null;
+      response_to_role: GroupMessage["role"] | null;
+      response_to_participant_id: string | null;
+      response_message_id: string | null;
+      response_content: string | null;
+    }>;
+
+    const rootMessage = toGroupMessage(rootCandidate, reactionMap);
+    const processes = processRows
+      .map((row) => {
+        const status = mapReactionTypeToProcessStatus(row.type);
+        if (!status) return null;
+        return {
+          processId: normalizeOptionalHostPid(row.host_pid),
+          datetime: row.datetime,
+          agent: row.participant_id,
+          responseTo: row.response_to ?? "",
+          responseToMessageId: row.response_to_message_id ?? "",
+          responseToSenderName:
+            normalizeOptionalText(row.response_to_participant_id) ?? row.response_to_role ?? "",
+          responseToSenderRole: row.response_to_role ?? "user",
+          responseMessageId: normalizeOptionalText(row.response_message_id),
+          responseContent: row.response_content,
+          status,
+        } satisfies ThreadStatusProcess;
+      })
+      .filter((row): row is ThreadStatusProcess => row !== null);
+
+    // Also pull running/spawning processes from agent_processes table.
+    // 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,
+                m.content as response_to,
+                m.role as response_to_role,
+                m.participant_id as response_to_participant_id
+         FROM agent_processes ap
+         LEFT JOIN messages m
+           ON m.id = ap.since_message_id AND m.thread_id = ap.workspace_id
+         WHERE ap.thread_id = ?
+           AND ap.state IN ('running', 'spawning')`
+      )
+      .all(scopedRootMessageId) as Array<{
+      agent_id: string;
+      pid: number;
+      state: string;
+      since_message_id: string;
+      started_at: number;
+      last_activity: number;
+      response_to: string | null;
+      response_to_role: string | null;
+      response_to_participant_id: string | null;
+    }>;
+
+    // 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 (existingPids.has(ap.pid) || existingAgents.has(ap.agent_id)) continue;
+      processes.push({
+        processId: ap.pid || null,
+        datetime: ap.started_at,
+        agent: ap.agent_id,
+        responseTo: ap.response_to ?? "",
+        responseToMessageId: ap.since_message_id ?? "",
+        responseToSenderName:
+          normalizeOptionalText(ap.response_to_participant_id) ?? ap.response_to_role ?? "user",
+        responseToSenderRole: (ap.response_to_role ?? "user") as "user" | "assistant",
+        responseMessageId: null,
+        responseContent: null,
+        status: "running",
+      } satisfies ThreadStatusProcess);
+    }
+
+    // Fetch ALL messages in thread (user + assistant) for the threaded view
+    const allMessageRows = db
+      .prepare(
+        `SELECT m.id, m.role, m.participant_id, m.content, m.timestamp,
+                m.parent_message_id,
+                r.host_pid, r.type as reaction_type
+         FROM messages m
+         LEFT JOIN message_reactions r
+           ON r.thread_id = m.thread_id
+          AND r.message_id = m.parent_message_id
+          AND r.participant_id = m.participant_id
+          AND r.type IN ('working', 'done', 'clarify', 'blocked')
+         WHERE m.thread_id = ?
+           AND (m.root_message_id = ? OR m.id = ?)
+         ORDER BY m.timestamp ASC`
+      )
+      .all(scopedThreadId, scopedRootMessageId, scopedRootMessageId) as Array<{
       id: string;
       role: string;
       participant_id: string | null;
       content: string;
       timestamp: number;
-      root_message_id: string | null;
       parent_message_id: string | null;
-      depth: number;
-      thread_status: string | null;
-      outcome_note: string | null;
+      host_pid: number | null;
+      reaction_type: ReactionType | null;
     }>;
-    const reactionMap = loadMessageReactions(db, normalizedThreadId);
-    return rows.map((r) => ({
-      id: r.id,
-      role: r.role as "user" | "assistant",
-      participantId: r.participant_id,
-      content: r.content,
-      timestamp: r.timestamp,
-      reactions: reactionMap.get(r.id),
-      rootMessageId: r.root_message_id,
-      parentMessageId: r.parent_message_id,
-      depth: r.depth,
-      ...(r.thread_status ? { threadStatus: r.thread_status as GroupMessage["threadStatus"] } : {}),
-      ...(r.outcome_note ? { outcomeNote: r.outcome_note } : {}),
-    }));
+
+    const threadMessages: ThreadMessage[] = allMessageRows
+      .filter((row) => {
+        // Filter out [SKIP] messages
+        const stripped = stripAgxMarkers(row.content);
+        return stripped.trim().length > 0;
+      })
+      .map((row) => {
+        let status: ThreadProcessStatus | null = null;
+        if (row.role === "assistant") {
+          if (row.reaction_type) {
+            status = mapReactionTypeToProcessStatus(row.reaction_type);
+          } else {
+            status = "done"; // default for assistant messages with content
+          }
+        }
+        return {
+          id: row.id,
+          role: row.role as "user" | "assistant",
+          participantId: row.participant_id,
+          content: stripAgxMarkers(row.content),
+          timestamp: row.timestamp,
+          parentMessageId: row.parent_message_id,
+          processId: row.role === "assistant" ? normalizeOptionalHostPid(row.host_pid) : null,
+          status,
+        };
+      });
+
+    const timestamps: number[] = [];
+    if (rootMessage) timestamps.push(rootMessage.timestamp);
+    for (const process of processes) timestamps.push(process.datetime);
+    for (const msg of threadMessages) timestamps.push(msg.timestamp);
+    const lastUpdatedAt = timestamps.length > 0 ? Math.max(...timestamps) : null;
+
+    return {
+      rootMessage,
+      processes,
+      messages: threadMessages,
+      lastUpdatedAt,
+    };
   });
 }
 
@@ -407,6 +881,13 @@ export async function updateMessageStatus(
   });
 }
 
+export async function getMessageThread(messageId: string): Promise<{ threadId: string } | null> {
+  return withDatabase((db) => {
+    const row = db.prepare(`SELECT thread_id FROM messages WHERE id = ?`).get(messageId.trim()) as { thread_id: string } | undefined;
+    return row ? { threadId: row.thread_id } : null;
+  });
+}
+
 export async function clearHistory(threadId: string): Promise<void> {
   const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
   await withDatabase((db) => {
@@ -533,6 +1014,8 @@ export async function setReaction(input: SetReactionInput): Promise<SetReactionR
 
   const incomingReason = normalizeOptionalText(input.reason);
   const incomingBlockerCode = normalizeOptionalText(input.blockerCode);
+  const hostPid = normalizeOptionalHostPid(input.hostPid);
+  const responseMessageId = normalizeOptionalText(input.responseMessageId);
   const needsReason = type === "clarify" || type === "blocked";
 
   if (needsReason && !incomingReason) {
@@ -551,12 +1034,12 @@ export async function setReaction(input: SetReactionInput): Promise<SetReactionR
 
     const existing = db
       .prepare(
-        `SELECT type, reason, blocker_code
+        `SELECT type, reason, blocker_code, host_pid
          FROM message_reactions
          WHERE thread_id = ? AND message_id = ? AND participant_id = ?`
       )
       .get(threadId, messageId, participantId) as
-      | { type: ReactionType; reason: string | null; blocker_code: string | null }
+      | { type: ReactionType; reason: string | null; blocker_code: string | null; host_pid: number | null }
       | undefined;
 
     if (!isAllowedTransition(existing?.type ?? null, type)) {
@@ -570,7 +1053,8 @@ export async function setReaction(input: SetReactionInput): Promise<SetReactionR
       existing &&
       existing.type === type &&
       normalizeOptionalText(existing.reason) === reason &&
-      normalizeOptionalText(existing.blocker_code) === blockerCode;
+      normalizeOptionalText(existing.blocker_code) === blockerCode &&
+      normalizeOptionalHostPid(existing.host_pid) === hostPid;
 
     if (unchanged) {
       return {
@@ -581,15 +1065,17 @@ export async function setReaction(input: SetReactionInput): Promise<SetReactionR
 
     const now = Date.now();
     db.prepare(
-      `INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+      `INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, host_pid, response_message_id, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(thread_id, message_id, participant_id)
        DO UPDATE SET
          type = excluded.type,
          reason = excluded.reason,
          blocker_code = excluded.blocker_code,
+         host_pid = excluded.host_pid,
+         response_message_id = COALESCE(excluded.response_message_id, message_reactions.response_message_id),
          updated_at = excluded.updated_at`
-    ).run(threadId, messageId, participantId, type, reason, blockerCode, now);
+    ).run(threadId, messageId, participantId, type, reason, blockerCode, hostPid, responseMessageId, now);
 
     return {
       updated: true,
@@ -639,6 +1125,7 @@ export async function getThreadInfos(threadId: string): Promise<ThreadInfo[]> {
 
 export interface LogRow {
   id: number;
+  agent_process_id: number;
   participant_id: string;
   stream: "stdout" | "stderr";
   line: string;
@@ -646,42 +1133,90 @@ export interface LogRow {
 }
 
 export async function saveLogs(
-  threadId: string,
-  entries: Array<{ participantId: string; stream: "stdout" | "stderr"; line: string; timestamp: number }>
+  agentProcessId: number,
+  entries: Array<{ stream: "stdout" | "stderr"; line: string; timestamp: number }>
 ): Promise<void> {
-  if (entries.length === 0) return;
-  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+  if (entries.length === 0 || !agentProcessId) return;
   return withDatabase((db) => {
     const stmt = db.prepare(
-      "INSERT INTO logs (thread_id, participant_id, stream, line, timestamp) VALUES (?, ?, ?, ?, ?)"
+      "INSERT INTO logs (agent_process_id, stream, line, timestamp) VALUES (?, ?, ?, ?)"
     );
     const tx = db.transaction(() => {
       for (const e of entries) {
-        stmt.run(normalizedThreadId, e.participantId, e.stream, e.line, e.timestamp);
+        stmt.run(agentProcessId, e.stream, e.line, e.timestamp);
       }
     });
     tx();
   });
 }
 
-export async function loadLogs(threadId: string): Promise<LogRow[]> {
-  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+export async function loadLogs(workspaceId: string): Promise<LogRow[]> {
+  const normalized = workspaceId.trim();
+  if (!normalized) return [];
   return withDatabase((db) => {
-    return db
+    const rows = db
       .prepare(
-        `SELECT id, participant_id, stream, line, timestamp
-         FROM logs
-         WHERE thread_id = ?
-         ORDER BY timestamp ASC, id ASC`
+        `SELECT l.id, l.agent_process_id, ap.agent_id as participant_id, l.stream, l.line, l.timestamp
+         FROM logs l
+         JOIN agent_processes ap ON ap.id = l.agent_process_id
+         WHERE ap.workspace_id = ?
+         ORDER BY l.timestamp DESC, l.id DESC
+         LIMIT 100`
       )
-      .all(normalizedThreadId) as LogRow[];
+      .all(normalized) as LogRow[];
+    return rows.reverse();
   });
 }
 
-export async function clearLogs(threadId: string): Promise<void> {
-  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+export interface ProcessLogEntry {
+  processId: number;
+  agent: string;
+  stream: "stdout" | "stderr";
+  line: string;
+  timestamp: number;
+}
+
+export async function loadLogsByProcessPids(
+  pids: number[]
+): Promise<ProcessLogEntry[]> {
+  if (pids.length === 0) return [];
   return withDatabase((db) => {
-    db.prepare("DELETE FROM logs WHERE thread_id = ?").run(normalizedThreadId);
+    const placeholders = pids.map(() => "?").join(", ");
+    const rows = db
+      .prepare(
+        `SELECT ap.pid as process_pid, ap.agent_id as agent, l.stream, l.line, l.timestamp
+         FROM logs l
+         JOIN agent_processes ap ON ap.id = l.agent_process_id
+         WHERE ap.pid IN (${placeholders})
+         ORDER BY l.timestamp ASC, l.id ASC
+         LIMIT 200`
+      )
+      .all(...pids) as Array<{
+      process_pid: number;
+      agent: string;
+      stream: "stdout" | "stderr";
+      line: string;
+      timestamp: number;
+    }>;
+    return rows.map((r) => ({
+      processId: r.process_pid,
+      agent: r.agent,
+      stream: r.stream,
+      line: r.line,
+      timestamp: r.timestamp,
+    }));
+  });
+}
+
+export async function clearLogs(workspaceId: string): Promise<void> {
+  const normalized = workspaceId.trim();
+  if (!normalized) return;
+  return withDatabase((db) => {
+    db.prepare(
+      `DELETE FROM logs WHERE agent_process_id IN (
+         SELECT id FROM agent_processes WHERE workspace_id = ?
+       )`
+    ).run(normalized);
   });
 }