@mndrk/agx 2.0.13 → 2.0.15

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/db/sqlite/001_agx_board_schema.sql

@@ -494,3 +494,44 @@ CREATE TABLE IF NOT EXISTS agent_memory (
 );
 CREATE INDEX IF NOT EXISTS idx_agent_memory_agent_id ON agent_memory(agent_id);
 CREATE INDEX IF NOT EXISTS idx_agent_memory_task_id  ON agent_memory(task_id);
+
+-- ── Teams (named agent groups with ordered routing) ─────────────────────────
+
+CREATE TABLE IF NOT EXISTS teams (
+    id TEXT NOT NULL PRIMARY KEY DEFAULT (lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)),2) || '-' || substr('89ab',abs(random()) % 4 + 1, 1) || substr(hex(randomblob(2)),2) || '-' || hex(randomblob(6)))),
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    is_default INTEGER NOT NULL DEFAULT 0,
+    thread_id 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'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_teams_user ON teams (user_id);
+CREATE INDEX IF NOT EXISTS idx_teams_thread ON teams (thread_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_teams_default ON teams (user_id) WHERE is_default = 1;
+
+CREATE TABLE IF NOT EXISTS team_agents (
+    team_id TEXT NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+    agent_id TEXT NOT NULL,
+    routing_order INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+    PRIMARY KEY (team_id, agent_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_team_agents_team ON team_agents (team_id, routing_order);
+
+CREATE TABLE IF NOT EXISTS team_workspaces (
+    team_id TEXT NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+    thread_id TEXT NOT NULL,
+    PRIMARY KEY (team_id, thread_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_team_workspaces_thread ON team_workspaces (thread_id);
+
+CREATE TRIGGER IF NOT EXISTS teams_updated_at
+    AFTER UPDATE ON teams
+    FOR EACH ROW
+    BEGIN
+        UPDATE teams SET updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE rowid = NEW.rowid;
+    END;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useGroupChat.ts

@@ -132,6 +132,9 @@ export function useGroupChat(threadId: string | null) {
       // For main chat messages (no explicit root), the user message itself is the root
       // and all agent replies are children of it.
       const agentRootId = rootMessageId || userMessageId;
+      // Streaming entries use the user message as root so the typing indicator
+      // renders inside the card that triggered it.
+      const streamingRootId = rootMessageId || userMessageId;
 
       // Register per-thread abort controller
       if (!threadAbortRefs.current.has(agentRootId)) {
@@ -187,14 +190,14 @@ export function useGroupChat(threadId: string | null) {
                 streamingPids.add(event.participantId);
                 setStreaming((prev) => ({
                   ...prev,
-                  [event.participantId]: { content: "", rootMessageId: agentRootId },
+                  [event.participantId]: { content: "", rootMessageId: streamingRootId },
                 }));
               } else if (event.type === "participant-error") {
                 setStreaming((prev) => ({
                   ...prev,
                   [event.participantId]: {
                     content: `[Error: ${event.error}]`,
-                    rootMessageId: agentRootId,
+                    rootMessageId: streamingRootId,
                   },
                 }));
               } else if (event.type === "log") {
@@ -310,6 +313,7 @@ export function useGroupChat(threadId: string | null) {
 
   return {
     messages,
+    setMessages,
     streaming,
     loading,
     logs,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useMentionAutocomplete.ts

@@ -2,6 +2,7 @@
 
 import { useState, useCallback, useMemo } from "react";
 import type { Participant } from "@/lib/types";
+import type { Team } from "@/hooks/useTeams";
 
 export type MentionMode = "sequential" | "parallel";
 
@@ -18,11 +19,17 @@ export interface MentionToken {
   isParallel: boolean;
 }
 
-export type MentionSuggestion = Participant;
+export type MentionItem =
+  | { kind: "agent"; participant: Participant; group: string }
+  | { kind: "team"; team: Team; group: string };
+
+export type MentionSuggestion = MentionItem;
 
 export interface UseMentionAutocompleteOptions {
   /** List of participants to filter */
   participants: Participant[];
+  /** Teams for the current workspace */
+  teams?: Team[];
   /** Maximum number of suggestions to show */
   maxSuggestions?: number;
 }
@@ -122,48 +129,95 @@ export const ALL_PARTICIPANT: Participant = {
   color: "#6B7280",
 };
 
+function scoreMatch(name: string, id: string, lowerQuery: string): number | null {
+  if (!lowerQuery) return 0;
+  if (name.startsWith(lowerQuery)) return 3;
+  if (id.startsWith(lowerQuery)) return 2;
+  if (name.includes(lowerQuery)) return 1;
+  return null;
+}
+
 export function filterSuggestions(
   participants: Participant[],
   query: string,
-  maxSuggestions: number
+  maxSuggestions: number,
+  teams: Team[] = []
 ): MentionSuggestion[] {
   const lowerQuery = query.toLowerCase();
-  const withAll = [ALL_PARTICIPANT, ...participants];
+  const participantById = new Map(participants.map((p) => [p.id, p]));
 
-  return withAll
-    .map((participant) => {
-      const name = participant.name.toLowerCase();
-      const id = participant.id.toLowerCase();
+  // Filter out "Default" team
+  const visibleTeams = teams.filter((t) => !t.is_default);
 
-      if (!lowerQuery) {
-        return { item: participant, score: 0, name };
-      }
+  // Build set of agents that belong to a team
+  const teamedAgentIds = new Set<string>();
+  for (const team of visibleTeams) {
+    for (const agent of team.agents) {
+      teamedAgentIds.add(agent.agent_id);
+    }
+  }
 
-      if (name.startsWith(lowerQuery)) {
-        return { item: participant, score: 3, name };
-      }
+  const result: MentionSuggestion[] = [];
 
-      if (id.startsWith(lowerQuery)) {
-        return { item: participant, score: 2, name };
-      }
+  // 1. @All always at the top
+  const allScore = scoreMatch("all", "all", lowerQuery);
+  if (allScore !== null) {
+    result.push({ kind: "agent", participant: ALL_PARTICIPANT, group: "" });
+  }
 
-      if (name.includes(lowerQuery)) {
-        return { item: participant, score: 1, name };
-      }
+  // 2. For each team: show team header then its member agents
+  for (const team of visibleTeams) {
+    const teamScore = scoreMatch(team.name.toLowerCase(), team.id.toLowerCase(), lowerQuery);
+
+    // Gather matching members
+    const matchingMembers: { participant: Participant; score: number }[] = [];
+    for (const agent of team.agents) {
+      const p = participantById.get(agent.agent_id);
+      if (!p) continue;
+      const s = scoreMatch(p.name.toLowerCase(), p.id.toLowerCase(), lowerQuery);
+      if (s !== null) matchingMembers.push({ participant: p, score: s });
+    }
+
+    // Show team + members if the team name matches OR any member matches
+    if (teamScore !== null || matchingMembers.length > 0) {
+      // Always show the team itself as mentionable
+      result.push({ kind: "team", team, group: team.name });
+
+      // Show members — if query matches team name, show all members; otherwise only matching ones
+      const membersToShow = teamScore !== null && lowerQuery
+        ? team.agents
+            .map((a) => participantById.get(a.agent_id))
+            .filter((p): p is Participant => !!p)
+            .map((p) => ({ participant: p, score: 0 }))
+        : matchingMembers;
+
+      membersToShow
+        .sort((a, b) => a.participant.name.localeCompare(b.participant.name))
+        .forEach(({ participant }) => {
+          result.push({ kind: "agent", participant, group: team.name });
+        });
+    }
+  }
+
+  // 3. Ungrouped agents (not in any visible team)
+  const ungrouped: { participant: Participant; score: number }[] = [];
+  for (const p of participants) {
+    if (teamedAgentIds.has(p.id)) continue;
+    const s = scoreMatch(p.name.toLowerCase(), p.id.toLowerCase(), lowerQuery);
+    if (s !== null) ungrouped.push({ participant: p, score: s });
+  }
+  ungrouped
+    .sort((a, b) => a.participant.name.localeCompare(b.participant.name))
+    .forEach(({ participant }) => {
+      result.push({ kind: "agent", participant, group: "" });
+    });
 
-      return null;
-    })
-    .filter((entry): entry is { item: Participant; score: number; name: string } => entry !== null)
-    .sort((a, b) => {
-      if (a.score !== b.score) return b.score - a.score;
-      return a.name.localeCompare(b.name);
-    })
-    .slice(0, maxSuggestions)
-    .map((entry) => entry.item);
+  return result.slice(0, maxSuggestions);
 }
 
 export function useMentionAutocomplete({
   participants,
+  teams = [],
   maxSuggestions = 6,
 }: UseMentionAutocompleteOptions): UseMentionAutocompleteReturn {
   const [token, setToken] = useState<MentionToken | null>(null);
@@ -174,8 +228,8 @@ export function useMentionAutocomplete({
   const query = token?.query ?? "";
 
   const filteredSuggestions = useMemo(() => {
-    return filterSuggestions(participants, query, maxSuggestions);
-  }, [participants, query, maxSuggestions]);
+    return filterSuggestions(participants, query, maxSuggestions, teams);
+  }, [participants, query, maxSuggestions, teams]);
 
   const updateTokenFromInput = useCallback((text: string, cursorPos: number) => {
     const newToken = detectMentionToken(text, cursorPos);
@@ -243,8 +297,9 @@ export function useMentionAutocomplete({
         return null;
       }
 
+      const name = suggestion.kind === "team" ? suggestion.team.name : suggestion.participant.name;
       const atPrefix = token.isParallel ? "@@" : "@";
-      const replacement = `${atPrefix}${suggestion.name} `;
+      const replacement = `${atPrefix}${name} `;
 
       return {
         text: replacement,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useTeams.ts

@@ -0,0 +1,171 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+export interface TeamAgent {
+  team_id: string;
+  agent_id: string;
+  routing_order: number;
+  created_at: string;
+}
+
+export interface Team {
+  id: string;
+  user_id: string;
+  name: string;
+  is_default?: number;
+  thread_id?: string | null;
+  workspace_ids: string[];
+  agents: TeamAgent[];
+  created_at: string;
+  updated_at: string;
+}
+
+export function useTeams() {
+  const [teams, setTeams] = useState<Team[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const fetchTeams = useCallback(async (threadId?: string) => {
+    try {
+      const url = threadId ? `/api/teams?threadId=${encodeURIComponent(threadId)}` : "/api/teams";
+      const res = await fetch(url);
+      if (!res.ok) return;
+      const data = await res.json();
+      setTeams(data.teams ?? []);
+    } catch {
+      // silent
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void fetchTeams();
+  }, [fetchTeams]);
+
+  const createTeam = useCallback(async (name: string, workspaceIds?: string | string[]): Promise<Team | null> => {
+    try {
+      const ids = Array.isArray(workspaceIds) ? workspaceIds : workspaceIds ? [workspaceIds] : [];
+      const res = await fetch("/api/teams", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name, workspaceIds: ids }),
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      const team = data.team as Team;
+      setTeams((prev) => [...prev, team].sort((a, b) => a.name.localeCompare(b.name)));
+      return team;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const renameTeam = useCallback(async (id: string, name: string) => {
+    try {
+      const res = await fetch(`/api/teams/${id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+      });
+      if (!res.ok) return;
+      setTeams((prev) =>
+        prev
+          .map((t) => (t.id === id ? { ...t, name } : t))
+          .sort((a, b) => a.name.localeCompare(b.name))
+      );
+    } catch {
+      // silent
+    }
+  }, []);
+
+  const deleteTeam = useCallback(async (id: string) => {
+    try {
+      const res = await fetch(`/api/teams/${id}`, { method: "DELETE" });
+      if (!res.ok) return;
+      setTeams((prev) => prev.filter((t) => t.id !== id));
+    } catch {
+      // silent
+    }
+  }, []);
+
+  const addAgent = useCallback(async (teamId: string, agentId: string) => {
+    try {
+      const res = await fetch(`/api/teams/${teamId}/agents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agentId }),
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      setTeams((prev) =>
+        prev.map((t) => (t.id === teamId ? { ...t, agents: data.agents } : t))
+      );
+    } catch {
+      // silent
+    }
+  }, []);
+
+  const removeAgent = useCallback(async (teamId: string, agentId: string) => {
+    try {
+      const res = await fetch(`/api/teams/${teamId}/agents?agentId=${agentId}`, {
+        method: "DELETE",
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      setTeams((prev) =>
+        prev.map((t) => (t.id === teamId ? { ...t, agents: data.agents } : t))
+      );
+    } catch {
+      // silent
+    }
+  }, []);
+
+  const reorderAgents = useCallback(async (teamId: string, orderedAgentIds: string[]) => {
+    try {
+      const res = await fetch(`/api/teams/${teamId}/agents`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ orderedAgentIds }),
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      setTeams((prev) =>
+        prev.map((t) => (t.id === teamId ? { ...t, agents: data.agents } : t))
+      );
+    } catch {
+      // silent
+    }
+  }, []);
+
+  const moveAgent = useCallback(async (agentId: string, fromTeamId: string, toTeamId: string) => {
+    try {
+      // Remove from old team
+      await fetch(`/api/teams/${fromTeamId}/agents?agentId=${agentId}`, { method: "DELETE" });
+      // Add to new team
+      const res = await fetch(`/api/teams/${toTeamId}/agents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agentId }),
+      });
+      if (!res.ok) return;
+      // Refresh to get consistent state
+      await fetchTeams();
+    } catch {
+      // silent
+    }
+  }, [fetchTeams]);
+
+  return {
+    teams,
+    isLoading,
+    createTeam,
+    renameTeam,
+    deleteTeam,
+    addAgent,
+    removeAgent,
+    reorderAgents,
+    moveAgent,
+    refresh: fetchTeams,
+  };
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useThreadState.ts

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { threadService } from "@/services/threadService";
-import type { SaveThreadInput, Thread } from "@/lib/storage";
+import type { SaveThreadInput, Thread, ThreadStatus } from "@/lib/storage";
 import type { GroupMessage } from "@/lib/types";
 import {
   clearLastThreadId,
@@ -9,8 +9,8 @@ import {
   resolveInitialThreadSelection,
 } from "@/state/threadSelection";
 
-const sortByUpdatedAt = (threads: Thread[]) =>
-  [...threads].sort((a, b) => b.updatedAt - a.updatedAt);
+const sortByCreatedAt = (threads: Thread[]) =>
+  [...threads].sort((a, b) => b.createdAt - a.createdAt);
 
 export function useThreadState() {
   const isMounted = useRef(true);
@@ -91,7 +91,7 @@ export function useThreadState() {
       try {
         const thread = await threadService.createThread(input);
         if (!isMounted.current) return thread;
-        setThreads((prev) => sortByUpdatedAt([...prev.filter((item) => item.id !== thread.id), thread]));
+        setThreads((prev) => sortByCreatedAt([...prev.filter((item) => item.id !== thread.id), thread]));
         setActiveThreadId(thread.id);
         return thread;
       } catch (error) {
@@ -112,7 +112,7 @@ export function useThreadState() {
       if (!isMounted.current) return;
       let nextThreads: Thread[] = [];
       setThreads((prev) => {
-        nextThreads = sortByUpdatedAt(prev.filter((thread) => thread.id !== threadId));
+        nextThreads = sortByCreatedAt(prev.filter((thread) => thread.id !== threadId));
         return nextThreads;
       });
       setActiveThreadId((current) =>
@@ -138,7 +138,7 @@ export function useThreadState() {
       const updated = await threadService.renameThread(id, nextTitle);
       if (!updated || !isMounted.current) return;
       setThreads((prev) =>
-        sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
       );
     } catch (error) {
       console.error("Failed to rename thread", error);
@@ -157,7 +157,7 @@ export function useThreadState() {
         const updated = await threadService.saveThreadMessages(threadId, messages);
         if (!updated || !isMounted.current) return;
         setThreads((prev) =>
-          sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+          sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
         );
       } catch (error) {
         console.error("Failed to update thread messages", error);
@@ -166,6 +166,70 @@ export function useThreadState() {
     []
   );
 
+  const updateThreadStatus = useCallback(
+    async (threadId: string, status: ThreadStatus) => {
+      if (!threadId) return;
+      try {
+        const updated = await threadService.updateThreadStatus(threadId, status);
+        if (!updated || !isMounted.current) return;
+        setThreads((prev) =>
+          sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        );
+      } catch (error) {
+        console.error("Failed to update thread status", error);
+      }
+    },
+    []
+  );
+
+  const updateThreadOutcomeNote = useCallback(
+    async (threadId: string, outcomeNote: string) => {
+      if (!threadId) return;
+      try {
+        const updated = await threadService.updateThreadOutcomeNote(threadId, outcomeNote);
+        if (!updated || !isMounted.current) return;
+        setThreads((prev) =>
+          sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        );
+      } catch (error) {
+        console.error("Failed to update thread outcome note", error);
+      }
+    },
+    []
+  );
+
+  const updateMessageThreadStatus = useCallback(
+    async (threadId: string, messageId: string, status: ThreadStatus) => {
+      if (!threadId || !messageId) return;
+      try {
+        const updated = await threadService.updateMessageThreadStatus(threadId, messageId, status);
+        if (!updated || !isMounted.current) return;
+        setThreads((prev) =>
+          sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        );
+      } catch (error) {
+        console.error("Failed to update message thread status", error);
+      }
+    },
+    []
+  );
+
+  const updateMessageOutcomeNote = useCallback(
+    async (threadId: string, messageId: string, note: string) => {
+      if (!threadId || !messageId) return;
+      try {
+        const updated = await threadService.updateMessageOutcomeNote(threadId, messageId, note);
+        if (!updated || !isMounted.current) return;
+        setThreads((prev) =>
+          sortByCreatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        );
+      } catch (error) {
+        console.error("Failed to update message outcome note", error);
+      }
+    },
+    []
+  );
+
   const isDeletingActiveThread = activeThreadId !== null && deletingThreadId === activeThreadId;
 
   return {
@@ -182,5 +246,9 @@ export function useThreadState() {
     isDeletingActiveThread,
     updateThreadMessages,
     renameThread,
+    updateThreadStatus,
+    updateThreadOutcomeNote,
+    updateMessageThreadStatus,
+    updateMessageOutcomeNote,
   };
 }

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

@@ -138,6 +138,17 @@ function migrateThreadReplyColumns(db: Database.Database): void {
   }
 }
 
+function migrateThreadStatusColumns(db: Database.Database): void {
+  const columns = db.prepare(`PRAGMA table_info(messages)`).all() as Array<{ name: string }>;
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has("thread_status")) {
+    db.exec(`
+      ALTER TABLE messages ADD COLUMN thread_status TEXT;
+      ALTER TABLE messages ADD COLUMN outcome_note TEXT;
+    `);
+  }
+}
+
 function migrateLegacyTables(db: Database.Database): void {
   if (!isThreadScopedTable(db, "messages")) {
     db.exec(`
@@ -240,6 +251,7 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
     `);
     migrateLegacyTables(db);
     migrateThreadReplyColumns(db);
+    migrateThreadStatusColumns(db);
     initializeMessageSearch(db);
     db.exec(`
       CREATE INDEX IF NOT EXISTS idx_messages_thread_ts ON messages(thread_id, timestamp ASC);
@@ -330,7 +342,7 @@ export async function loadHistory(threadId: string): Promise<GroupMessage[]> {
   return withDatabase((db) => {
     const rows = db
       .prepare(
-        `SELECT id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth
+        `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`
@@ -344,6 +356,8 @@ export async function loadHistory(threadId: string): Promise<GroupMessage[]> {
       root_message_id: string | null;
       parent_message_id: string | null;
       depth: number;
+      thread_status: string | null;
+      outcome_note: string | null;
     }>;
     const reactionMap = loadMessageReactions(db, normalizedThreadId);
     return rows.map((r) => ({
@@ -356,6 +370,8 @@ export async function loadHistory(threadId: string): Promise<GroupMessage[]> {
       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 } : {}),
     }));
   });
 }
@@ -365,18 +381,32 @@ export async function saveMessages(threadId: string, messages: GroupMessage[]):
   const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
   await withDatabase((db) => {
     const stmt = db.prepare(
-      `INSERT OR REPLACE INTO messages (thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      `INSERT OR REPLACE INTO messages (thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     );
     const insertMany = db.transaction((msgs: GroupMessage[]) => {
       for (const m of msgs) {
-        stmt.run(normalizedThreadId, m.id, m.role, m.participantId, m.content, m.timestamp, m.rootMessageId ?? null, m.parentMessageId ?? null, m.depth ?? 0);
+        stmt.run(normalizedThreadId, m.id, m.role, m.participantId, m.content, m.timestamp, m.rootMessageId ?? null, m.parentMessageId ?? null, m.depth ?? 0, m.threadStatus ?? null, m.outcomeNote ?? null);
       }
     });
     insertMany(messages);
   });
 }
 
+export async function updateMessageStatus(
+  threadId: string,
+  messageId: string,
+  threadStatus: string | null,
+  outcomeNote: string | null
+): Promise<void> {
+  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+  await withDatabase((db) => {
+    db.prepare(
+      `UPDATE messages SET thread_status = ?, outcome_note = ? WHERE thread_id = ? AND id = ?`
+    ).run(threadStatus, outcomeNote, normalizedThreadId, messageId);
+  });
+}
+
 export async function clearHistory(threadId: string): Promise<void> {
   const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
   await withDatabase((db) => {