@mndrk/agx 2.0.0 → 2.0.2

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

@@ -1,30 +1,30 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { workspaceService } from "@/services/threadService";
-import type { SaveWorkspaceInput, Workspace } from "@/lib/storage";
+import { threadService } from "@/services/threadService";
+import type { SaveThreadInput, Thread } from "@/lib/storage";
 import type { GroupMessage } from "@/lib/types";
 import {
-  clearLastWorkspaceId,
-  loadLastWorkspaceId,
-  persistLastWorkspaceId,
-  resolveInitialWorkspaceSelection,
+  clearLastThreadId,
+  loadLastThreadId,
+  persistLastThreadId,
+  resolveInitialThreadSelection,
 } from "@/state/threadSelection";
 
-const sortAlphabetically = (workspaces: Workspace[]) =>
-  [...workspaces].sort((a, b) => (a.title || "").localeCompare(b.title || ""));
+const sortByUpdatedAt = (threads: Thread[]) =>
+  [...threads].sort((a, b) => b.updatedAt - a.updatedAt);
 
-export function useWorkspaceState() {
+export function useThreadState() {
   const isMounted = useRef(true);
-  const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
-  const [activeWorkspaceId, setActiveWorkspaceId] = useState<string | null>(null);
+  const [threads, setThreads] = useState<Thread[]>([]);
+  const [activeThreadId, setActiveThreadId] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(true);
-  const [isRestoringActiveWorkspace, setIsRestoringActiveWorkspace] = useState(true);
+  const [isRestoringActiveThread, setIsRestoringActiveThread] = useState(true);
   const [isCreating, setIsCreating] = useState(false);
-  const [deletingWorkspaceId, setDeletingWorkspaceId] = useState<string | null>(null);
-  const [renamingWorkspaceId, setRenamingWorkspaceId] = useState<string | null>(null);
-  const hasHydratedActiveWorkspaceRef = useRef(false);
+  const [deletingThreadId, setDeletingThreadId] = useState<string | null>(null);
+  const [renamingThreadId, setRenamingThreadId] = useState<string | null>(null);
+  const hasHydratedActiveThreadRef = useRef(false);
 
-  const selectWorkspace = useCallback((workspaceId: string) => {
-    setActiveWorkspaceId(workspaceId);
+  const selectThread = useCallback((threadId: string) => {
+    setActiveThreadId(threadId);
   }, []);
 
   useEffect(() => {
@@ -39,31 +39,31 @@ export function useWorkspaceState() {
 
     (async () => {
       try {
-        const fetched = await workspaceService.listWorkspaces();
+        const fetched = await threadService.listThreads();
         if (cancelled || !isMounted.current) return;
-        setWorkspaces(sortAlphabetically(fetched));
-        const savedWorkspaceId = loadLastWorkspaceId();
-        const { workspaceId: initialWorkspaceId, shouldClearSavedId, restoredFromStorage } =
-          resolveInitialWorkspaceSelection(fetched, savedWorkspaceId);
+        setThreads(fetched);
+        const savedThreadId = loadLastThreadId();
+        const { threadId: initialThreadId, shouldClearSavedId, restoredFromStorage } =
+          resolveInitialThreadSelection(fetched, savedThreadId);
         if (shouldClearSavedId) {
-          clearLastWorkspaceId();
+          clearLastThreadId();
         }
-        if (!hasHydratedActiveWorkspaceRef.current) {
-          hasHydratedActiveWorkspaceRef.current = true;
+        if (!hasHydratedActiveThreadRef.current) {
+          hasHydratedActiveThreadRef.current = true;
         }
-        if (restoredFromStorage && initialWorkspaceId) {
-          selectWorkspace(initialWorkspaceId);
-        } else if (initialWorkspaceId) {
-          setActiveWorkspaceId((prev) => prev ?? initialWorkspaceId);
+        if (restoredFromStorage && initialThreadId) {
+          selectThread(initialThreadId);
+        } else if (initialThreadId) {
+          setActiveThreadId((prev) => prev ?? initialThreadId);
         } else {
-          setActiveWorkspaceId(null);
+          setActiveThreadId(null);
         }
       } catch (error) {
-        console.error("Failed to load workspaces", error);
+        console.error("Failed to load threads", error);
       } finally {
         if (isMounted.current) {
           setIsLoading(false);
-          setIsRestoringActiveWorkspace(false);
+          setIsRestoringActiveThread(false);
         }
       }
     })();
@@ -71,31 +71,31 @@ export function useWorkspaceState() {
     return () => {
       cancelled = true;
     };
-  }, [selectWorkspace]);
+  }, [selectThread]);
 
   useEffect(() => {
-    if (!hasHydratedActiveWorkspaceRef.current) {
+    if (!hasHydratedActiveThreadRef.current) {
       return;
     }
 
-    if (activeWorkspaceId) {
-      persistLastWorkspaceId(activeWorkspaceId);
+    if (activeThreadId) {
+      persistLastThreadId(activeThreadId);
     } else {
-      clearLastWorkspaceId();
+      clearLastThreadId();
     }
-  }, [activeWorkspaceId]);
+  }, [activeThreadId]);
 
-  const createWorkspace = useCallback(
-    async (input?: Partial<Pick<SaveWorkspaceInput, "id" | "title" | "messages" | "metadata">>) => {
+  const createThread = useCallback(
+    async (input?: Partial<Pick<SaveThreadInput, "id" | "title" | "messages" | "metadata">>) => {
       setIsCreating(true);
       try {
-        const workspace = await workspaceService.createWorkspace(input);
-        if (!isMounted.current) return workspace;
-        setWorkspaces((prev) => sortAlphabetically([...prev.filter((item) => item.id !== workspace.id), workspace]));
-        setActiveWorkspaceId(workspace.id);
-        return workspace;
+        const thread = await threadService.createThread(input);
+        if (!isMounted.current) return thread;
+        setThreads((prev) => sortByUpdatedAt([...prev.filter((item) => item.id !== thread.id), thread]));
+        setActiveThreadId(thread.id);
+        return thread;
       } catch (error) {
-        console.error("Failed to create workspace", error);
+        console.error("Failed to create thread", error);
         throw error;
       } finally {
         if (isMounted.current) {
@@ -104,83 +104,83 @@ export function useWorkspaceState() {
       }
     }, []);
 
-  const deleteWorkspace = useCallback(async (workspaceId: string) => {
-    if (!workspaceId) return;
-    setDeletingWorkspaceId(workspaceId);
+  const deleteThread = useCallback(async (threadId: string) => {
+    if (!threadId) return;
+    setDeletingThreadId(threadId);
     try {
-      await workspaceService.deleteWorkspace(workspaceId);
+      await threadService.deleteThread(threadId);
       if (!isMounted.current) return;
-      let nextWorkspaces: Workspace[] = [];
-      setWorkspaces((prev) => {
-        nextWorkspaces = sortAlphabetically(prev.filter((workspace) => workspace.id !== workspaceId));
-        return nextWorkspaces;
+      let nextThreads: Thread[] = [];
+      setThreads((prev) => {
+        nextThreads = sortByUpdatedAt(prev.filter((thread) => thread.id !== threadId));
+        return nextThreads;
       });
-      setActiveWorkspaceId((current) =>
-        current === workspaceId ? nextWorkspaces[0]?.id ?? null : current
+      setActiveThreadId((current) =>
+        current === threadId ? nextThreads[0]?.id ?? null : current
       );
     } catch (error) {
-      console.error("Failed to delete workspace", error);
+      console.error("Failed to delete thread", error);
       throw error;
     } finally {
       if (isMounted.current) {
-        setDeletingWorkspaceId(null);
+        setDeletingThreadId(null);
       }
     }
   }, []);
 
-  const renameWorkspace = useCallback(async (workspaceId: string, title: string) => {
-    const id = workspaceId.trim();
+  const renameThread = useCallback(async (threadId: string, title: string) => {
+    const id = threadId.trim();
     const nextTitle = title.trim();
     if (!id || !nextTitle) return;
 
-    setRenamingWorkspaceId(id);
+    setRenamingThreadId(id);
     try {
-      const updated = await workspaceService.renameWorkspace(id, nextTitle);
+      const updated = await threadService.renameThread(id, nextTitle);
       if (!updated || !isMounted.current) return;
-      setWorkspaces((prev) =>
-        sortAlphabetically(prev.map((workspace) => (workspace.id === updated.id ? updated : workspace)))
+      setThreads((prev) =>
+        sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
       );
     } catch (error) {
-      console.error("Failed to rename workspace", error);
+      console.error("Failed to rename thread", error);
       throw error;
     } finally {
       if (isMounted.current) {
-        setRenamingWorkspaceId((current) => (current === id ? null : current));
+        setRenamingThreadId((current) => (current === id ? null : current));
       }
     }
   }, []);
 
-  const updateWorkspaceMessages = useCallback(
-    async (workspaceId: string, messages: GroupMessage[]) => {
-      if (!workspaceId) return;
+  const updateThreadMessages = useCallback(
+    async (threadId: string, messages: GroupMessage[]) => {
+      if (!threadId) return;
       try {
-        const updated = await workspaceService.saveWorkspaceMessages(workspaceId, messages);
+        const updated = await threadService.saveThreadMessages(threadId, messages);
         if (!updated || !isMounted.current) return;
-        setWorkspaces((prev) =>
-          sortAlphabetically(prev.map((workspace) => (workspace.id === updated.id ? updated : workspace)))
+        setThreads((prev) =>
+          sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
         );
       } catch (error) {
-        console.error("Failed to update workspace messages", error);
+        console.error("Failed to update thread messages", error);
       }
     },
     []
   );
 
-  const isDeletingActiveWorkspace = activeWorkspaceId !== null && deletingWorkspaceId === activeWorkspaceId;
+  const isDeletingActiveThread = activeThreadId !== null && deletingThreadId === activeThreadId;
 
   return {
-    workspaces,
-    activeWorkspaceId,
-    selectWorkspace,
-    createWorkspace,
-    deleteWorkspace,
+    threads,
+    activeThreadId,
+    selectThread,
+    createThread,
+    deleteThread,
     isLoading,
-    isRestoringActiveWorkspace,
+    isRestoringActiveThread,
     isCreating,
-    deletingWorkspaceId,
-    renamingWorkspaceId,
-    isDeletingActiveWorkspace,
-    updateWorkspaceMessages,
-    renameWorkspace,
+    deletingThreadId,
+    renamingThreadId,
+    isDeletingActiveThread,
+    updateThreadMessages,
+    renameThread,
   };
 }

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

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/chat-utils.ts

@@ -0,0 +1,15 @@
+/**
+ * Strip internal protocol markers from message content before display.
+ * Covers: [agx:*], [reaction ...], [checkpoint], [criteria:*], [done], [blocked*], [SKIP]
+ */
+export function stripMarkers(content: string): string {
+  return content
+    .replace(/\[reaction\s+[^\]]*\]/gi, "")
+    .replace(/\[agx:[^\]]*\]/g, "")
+    .replace(/\[checkpoint\]/g, "")
+    .replace(/\[criteria:\s*[^\]]*\]/g, "")
+    .replace(/\[done\]/g, "")
+    .replace(/\[blocked[^\]]*\]/g, "")
+    .replace(/^\[SKIP\]$/gm, "")
+    .trim();
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/cli-runner.ts

@@ -25,13 +25,8 @@ type StreamParser = {
   flush: () => void;
 };
 
-const AGX_ACK_RE = /\[agx:(?:spawn|exit:\d+)\]\n?/g;
-
 const createRawParser = (onDelta: (chunk: string) => void): StreamParser => ({
-  push: (chunk: string) => {
-    const cleaned = chunk.replace(AGX_ACK_RE, "");
-    if (cleaned) onDelta(cleaned);
-  },
+  push: onDelta,
   flush: () => {},
 });
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/dependency-helpers.ts

@@ -5,6 +5,7 @@ interface DependencySummary {
   title?: string;
   slug?: string;
   status?: string;
+  stage?: string;
 }
 
 const MAX_DISPLAYED_DEPENDENCIES = 3;
@@ -17,6 +18,7 @@ function describeDependency(entry: DependencySummary): string {
 }
 
 function describeStatus(entry: DependencySummary): string | null {
+  if (entry.stage?.toLowerCase() === "intake") return " (awaiting approval)";
   return entry.status ? ` (${entry.status})` : null;
 }
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/dependency-manager.ts

@@ -90,7 +90,8 @@ function formatMissingDependencies(missing: TaskDependencySummary[]): string {
   const maxItems = 3;
   const entries = missing.slice(0, maxItems).map((dep) => {
     const label = describeDependency(dep);
-    const suffix = dep.status ? ` (${dep.status})` : "";
+    const statusLabel = dep.stage === "INTAKE" ? "awaiting approval" : (dep.status || "");
+    const suffix = statusLabel ? ` (${statusLabel})` : "";
     return `${label}${suffix}`;
   });
   let message = `Waiting on dependencies: ${entries.join(", ")}`;

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

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";

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

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import path from "path";
 import os from "os";
@@ -256,7 +256,6 @@ export function loadParticipants(): Participant[] {
             try {
               const parsed = JSON.parse(r.skills_json);
               if (!Array.isArray(parsed)) return [];
-              // Support both legacy string[] and new {file,condition}[] formats
               return parsed.map((item: unknown) =>
                 typeof item === "string"
                   ? { file: item, condition: "" }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/queue/sqlite-adapter.ts

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import { v4 as uuidv4 } from "uuid";
 import path from "path";
 import fs from "fs";

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

@@ -14,7 +14,7 @@
  *  - RETURNING          → supported in SQLite ≥ 3.35
  */
 
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import fs from "fs";
 import path from "path";
 import { LOCAL_USER } from "./auth-mode";

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

@@ -4,7 +4,7 @@
  * Handles type coercion from PG types to SQLite types and
  * writes batches inside transactions for performance.
  */
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as path from "path";
 

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

@@ -5,7 +5,7 @@
  * Import and call `validateSQLiteEnvironment(db)` before any query execution.
  */
 
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import fs from "fs";
 import os from "os";
 import path from "path";

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/storage/index.ts

@@ -1,2 +1,2 @@
 export * from "./thread-adapter";
-export { LocalWorkspaceAdapter } from "./local-thread-adapter";
+export { LocalThreadAdapter } from "./local-thread-adapter";

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/storage/local-thread-adapter.ts

@@ -1,22 +1,22 @@
-import type { ListWorkspacesResult, SaveWorkspaceInput, Workspace, WorkspaceAdapter, WorkspaceListOptions } from "./thread-adapter";
+import type { ListThreadsResult, SaveThreadInput, Thread, ThreadAdapter, ThreadListOptions } from "./thread-adapter";
 
 const STORAGE_KEY = "agx-chat:threads";
 
-interface LocalWorkspaceState {
-  threads: Record<string, Workspace>;
+interface LocalThreadState {
+  threads: Record<string, Thread>;
 }
 
 function getStorage(): Storage {
   const globalStorage = (globalThis as typeof globalThis & { localStorage?: Storage }).localStorage;
   if (!globalStorage) {
     throw new Error(
-      "LocalWorkspaceAdapter requires a browser-like environment with `localStorage`."
+      "LocalThreadAdapter requires a browser-like environment with `localStorage`."
     );
   }
   return globalStorage;
 }
 
-function readState(): LocalWorkspaceState {
+function readState(): LocalThreadState {
   const storage = getStorage();
   const raw = storage.getItem(STORAGE_KEY);
   if (!raw) {
@@ -29,7 +29,7 @@ function readState(): LocalWorkspaceState {
         threads: Object.fromEntries(
           Object.entries(parsed.threads).map(([id, value]) => [
             id,
-            sanitizeStoredWorkspace(id, value),
+            sanitizeStoredThread(id, value),
           ])
         ),
       };
@@ -40,38 +40,38 @@ function readState(): LocalWorkspaceState {
   return { threads: {} };
 }
 
-function writeState(state: LocalWorkspaceState): void {
+function writeState(state: LocalThreadState): void {
   getStorage().setItem(STORAGE_KEY, JSON.stringify(state));
 }
 
-function sanitizeStoredWorkspace(id: string, value: unknown): Workspace {
-  const base = value as Partial<Workspace> | undefined;
+function sanitizeStoredThread(id: string, value: unknown): Thread {
+  const base = value as Partial<Thread> | undefined;
   return {
     id,
     title: base?.title,
-    messages: Array.isArray(base?.messages) ? [...(base!.messages as Workspace["messages"])] : [],
+    messages: Array.isArray(base?.messages) ? [...(base!.messages as Thread["messages"])] : [],
     createdAt: typeof base?.createdAt === "number" ? base.createdAt : Date.now(),
     updatedAt: typeof base?.updatedAt === "number" ? base.updatedAt : Date.now(),
     metadata: base?.metadata,
   };
 }
 
-function cloneWorkspace(workspace: Workspace): Workspace {
+function cloneThread(thread: Thread): Thread {
   return {
-    ...workspace,
-    messages: workspace.messages.map((msg) => ({ ...msg })),
-    metadata: workspace.metadata ? { ...workspace.metadata } : undefined,
+    ...thread,
+    messages: thread.messages.map((msg) => ({ ...msg })),
+    metadata: thread.metadata ? { ...thread.metadata } : undefined,
   };
 }
 
-export class LocalWorkspaceAdapter implements WorkspaceAdapter {
-  async saveWorkspace(input: SaveWorkspaceInput): Promise<Workspace> {
+export class LocalThreadAdapter implements ThreadAdapter {
+  async saveThread(input: SaveThreadInput): Promise<Thread> {
     const now = Date.now();
     const state = readState();
     const existing = state.threads[input.id];
     const createdAt = existing?.createdAt ?? input.createdAt ?? now;
     const updatedAt = input.updatedAt ?? now;
-    const workspace: Workspace = {
+    const thread: Thread = {
       id: input.id,
       title: input.title,
       messages: input.messages.map((msg) => ({ ...msg })),
@@ -79,18 +79,18 @@ export class LocalWorkspaceAdapter implements WorkspaceAdapter {
       createdAt,
       updatedAt,
     };
-    state.threads[input.id] = workspace;
+    state.threads[input.id] = thread;
     writeState(state);
-    return cloneWorkspace(workspace);
+    return cloneThread(thread);
   }
 
-  async loadWorkspace(workspaceId: string): Promise<Workspace | null> {
+  async loadThread(threadId: string): Promise<Thread | null> {
     const state = readState();
-    const workspace = state.threads[workspaceId];
-    return workspace ? cloneWorkspace(workspace) : null;
+    const thread = state.threads[threadId];
+    return thread ? cloneThread(thread) : null;
   }
 
-  async listWorkspaces(options?: WorkspaceListOptions): Promise<ListWorkspacesResult> {
+  async listThreads(options?: ThreadListOptions): Promise<ListThreadsResult> {
     const state = readState();
     const all = Object.values(state.threads);
     const order = options?.order ?? "desc";
@@ -104,14 +104,14 @@ export class LocalWorkspaceAdapter implements WorkspaceAdapter {
       : sorted.slice(offset);
     return {
       total: all.length,
-      workspaces: page.map(cloneWorkspace),
+      threads: page.map(cloneThread),
     };
   }
 
-  async deleteWorkspace(workspaceId: string): Promise<void> {
+  async deleteThread(threadId: string): Promise<void> {
     const state = readState();
-    if (state.threads[workspaceId]) {
-      delete state.threads[workspaceId];
+    if (state.threads[threadId]) {
+      delete state.threads[threadId];
       writeState(state);
     }
   }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/storage/thread-adapter.ts

@@ -1,33 +1,33 @@
 import type { GroupMessage } from "../types";
 
 /**
- * Arbitrary metadata that can be stored alongside a workspace for sorting/filtering.
+ * Arbitrary metadata that can be stored alongside a thread for sorting/filtering.
  */
-export type WorkspaceMetadata = Record<string, unknown>;
+export type ThreadMetadata = Record<string, unknown>;
 
 /**
- * The canonical representation of a workspace in agx-chat.
+ * The canonical representation of a conversation thread in agx-chat.
  */
-export interface Workspace {
-  /** Unique identifier for the workspace. */
+export interface Thread {
+  /** Unique identifier for the thread. */
   id: string;
   /** Human-friendly title (optional). */
   title?: string;
-  /** Ordered messages that belong to the workspace. */
+  /** Ordered messages that belong to the thread. */
   messages: GroupMessage[];
-  /** Denotes when the workspace was created (epoch ms). */
+  /** Denotes when the thread was created (epoch ms). */
   createdAt: number;
-  /** Denotes the last time the workspace was updated (epoch ms). */
+  /** Denotes the last time the thread was updated (epoch ms). */
   updatedAt: number;
   /** Optional metadata bucket adapters can use for sorting/filtering. */
-  metadata?: WorkspaceMetadata;
+  metadata?: ThreadMetadata;
 }
 
 /**
- * Input data that is required when creating or updating a workspace.
+ * Input data that is required when creating or updating a thread.
  * Adapters may enrich this input with timestamps or derived metadata before persistence.
  */
-export interface SaveWorkspaceInput extends Omit<Workspace, "createdAt" | "updatedAt"> {
+export interface SaveThreadInput extends Omit<Thread, "createdAt" | "updatedAt"> {
   /** Allow callers to override the created timestamp when reconstructing archives. */
   createdAt?: number;
   /** Allow callers to override the updated timestamp when reconstructing archives. */
@@ -35,48 +35,48 @@ export interface SaveWorkspaceInput extends Omit<Workspace, "createdAt" | "updat
 }
 
 /**
- * Pagination and sort hints that adapters should honor when listing workspaces.
+ * Pagination and sort hints that adapters should honor when listing threads.
  */
-export interface WorkspaceListOptions {
-  /** Maximum number of workspaces to return. Defaults to all available workspaces. */
+export interface ThreadListOptions {
+  /** Maximum number of threads to return. Defaults to all available threads. */
   limit?: number;
-  /** Number of workspaces to skip before collecting results (offset-style cursor). */
+  /** Number of threads to skip before collecting results (offset-style cursor). */
   offset?: number;
-  /** Sort order for the workspaces based on `updatedAt`. Defaults to "desc" (newest first). */
+  /** Sort order for the threads based on `updatedAt`. Defaults to "desc" (newest first). */
   order?: "asc" | "desc";
 }
 
 /**
- * Result payload for `listWorkspaces` that includes the requested subset and the total size.
+ * Result payload for `listThreads` that includes the requested subset and the total size.
  */
-export interface ListWorkspacesResult {
-  /** Workspaces for the current page. */
-  workspaces: Workspace[];
-  /** Total number of available workspaces (before paging). */
+export interface ListThreadsResult {
+  /** Threads for the current page. */
+  threads: Thread[];
+  /** Total number of available threads (before paging). */
   total: number;
 }
 
 /**
- * Abstraction over storage mechanisms that persist workspaces.
+ * Abstraction over storage mechanisms that persist conversation threads.
  */
-export interface WorkspaceAdapter {
+export interface ThreadAdapter {
   /**
-   * Persist a workspace. Implementations should update timestamps and return the stored result.
+   * Persist a thread. Implementations should update timestamps and return the stored result.
    */
-  saveWorkspace(input: SaveWorkspaceInput): Promise<Workspace>;
+  saveThread(input: SaveThreadInput): Promise<Thread>;
 
   /**
-   * Load a workspace by its `id`. Return `null` when the workspace does not exist.
+   * Load a thread by its `id`. Return `null` when the thread does not exist.
    */
-  loadWorkspace(workspaceId: string): Promise<Workspace | null>;
+  loadThread(threadId: string): Promise<Thread | null>;
 
   /**
-   * List persisted workspaces with optional pagination/sorting hints.
+   * List persisted threads with optional pagination/sorting hints.
    */
-  listWorkspaces(options?: WorkspaceListOptions): Promise<ListWorkspacesResult>;
+  listThreads(options?: ThreadListOptions): Promise<ListThreadsResult>;
 
   /**
-   * Remove a persisted workspace. The method should be idempotent.
+   * Remove a persisted thread. The method should be idempotent.
    */
-  deleteWorkspace(workspaceId: string): Promise<void>;
+  deleteThread(threadId: string): Promise<void>;
 }