@mndrk/agx 2.0.0 → 2.0.2

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/services/threadService.ts

@@ -1,21 +1,21 @@
-import { LocalWorkspaceAdapter } from "@/lib/storage";
-import type { SaveWorkspaceInput, Workspace } from "@/lib/storage";
+import { LocalThreadAdapter } from "@/lib/storage";
+import type { SaveThreadInput, Thread } from "@/lib/storage";
 import type { GroupMessage } from "@/lib/types";
 
-const adapter = new LocalWorkspaceAdapter();
+const adapter = new LocalThreadAdapter();
 
-const createWorkspaceId = (): string => {
+const createThreadId = (): string => {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     return crypto.randomUUID();
   }
-  return `workspace-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `thread-${Date.now()}-${Math.random().toString(16).slice(2)}`;
 };
 
-const sortByUpdatedAt = (workspaces: Workspace[]) =>
-  [...workspaces].sort((a, b) => b.updatedAt - a.updatedAt);
+const sortByUpdatedAt = (threads: Thread[]) =>
+  [...threads].sort((a, b) => b.updatedAt - a.updatedAt);
 
-function isArchivedWorkspace(workspace: Workspace): boolean {
-  const archived = (workspace.metadata as { archived?: unknown } | undefined)?.archived;
+function isArchivedThread(thread: Thread): boolean {
+  const archived = (thread.metadata as { archived?: unknown } | undefined)?.archived;
   return archived === true;
 }
 
@@ -44,19 +44,19 @@ function areMessagesEqual(a: GroupMessage[], b: GroupMessage[]): boolean {
   return true;
 }
 
-export const workspaceService = {
-  async listWorkspaces(): Promise<Workspace[]> {
-    const result = await adapter.listWorkspaces({ order: "desc" });
-    return sortByUpdatedAt(result.workspaces.filter((workspace) => !isArchivedWorkspace(workspace)));
+export const threadService = {
+  async listThreads(): Promise<Thread[]> {
+    const result = await adapter.listThreads({ order: "desc" });
+    return sortByUpdatedAt(result.threads.filter((thread) => !isArchivedThread(thread)));
   },
 
-  async createWorkspace(
-    input?: Partial<Pick<SaveWorkspaceInput, "id" | "title" | "messages" | "metadata">>
-  ): Promise<Workspace> {
+  async createThread(
+    input?: Partial<Pick<SaveThreadInput, "id" | "title" | "messages" | "metadata">>
+  ): Promise<Thread> {
     const requestedId = typeof input?.id === "string" ? input.id.trim() : "";
 
     if (requestedId) {
-      const existing = await adapter.loadWorkspace(requestedId);
+      const existing = await adapter.loadThread(requestedId);
       if (existing) {
         const metadata = {
           ...(existing.metadata ?? {}),
@@ -64,7 +64,7 @@ export const workspaceService = {
           archived: false,
           archivedAt: null,
         };
-        return adapter.saveWorkspace({
+        return adapter.saveThread({
           id: existing.id,
           title: input?.title ?? existing.title,
           messages: input?.messages?.length ? input.messages : existing.messages,
@@ -74,20 +74,20 @@ export const workspaceService = {
       }
     }
 
-    const payload: SaveWorkspaceInput = {
-      id: requestedId || createWorkspaceId(),
+    const payload: SaveThreadInput = {
+      id: requestedId || createThreadId(),
       messages: input?.messages?.length ? input.messages : [],
       title: input?.title,
       metadata: input?.metadata,
     };
-    return adapter.saveWorkspace(payload);
+    return adapter.saveThread(payload);
   },
 
-  async deleteWorkspace(workspaceId: string) {
-    const id = workspaceId.trim();
+  async deleteThread(threadId: string) {
+    const id = threadId.trim();
     if (!id) return;
 
-    const existing = await adapter.loadWorkspace(id);
+    const existing = await adapter.loadThread(id);
     if (!existing) return;
 
     const metadata = {
@@ -96,7 +96,7 @@ export const workspaceService = {
       archivedAt: Date.now(),
     };
 
-    await adapter.saveWorkspace({
+    await adapter.saveThread({
       id: existing.id,
       title: existing.title,
       messages: existing.messages,
@@ -105,19 +105,19 @@ export const workspaceService = {
     });
   },
 
-  async renameWorkspace(workspaceId: string, title: string) {
-    const id = workspaceId.trim();
+  async renameThread(threadId: string, title: string) {
+    const id = threadId.trim();
     const nextTitle = title.trim();
     if (!id || !nextTitle) return null;
 
-    const existing = await adapter.loadWorkspace(id);
+    const existing = await adapter.loadThread(id);
     if (!existing) return null;
 
     if ((existing.title?.trim() ?? "") === nextTitle) {
       return existing;
     }
 
-    return adapter.saveWorkspace({
+    return adapter.saveThread({
       id: existing.id,
       title: nextTitle,
       messages: existing.messages,
@@ -126,8 +126,8 @@ export const workspaceService = {
     });
   },
 
-  async saveWorkspaceMessages(workspaceId: string, messages: GroupMessage[]): Promise<Workspace | null> {
-    const existing = await adapter.loadWorkspace(workspaceId);
+  async saveThreadMessages(threadId: string, messages: GroupMessage[]): Promise<Thread | null> {
+    const existing = await adapter.loadThread(threadId);
     if (!existing) return null;
 
     const title = existing.title?.trim() || deriveTitleFromMessages(messages);
@@ -135,7 +135,7 @@ export const workspaceService = {
       return existing;
     }
 
-    return adapter.saveWorkspace({
+    return adapter.saveThread({
       id: existing.id,
       title,
       messages,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/db/backup.ts

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import fs from "fs";
 import path from "path";
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/db/checks.ts

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import fs from "fs";
 import os from "os";
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/db/init.ts

@@ -1,4 +1,4 @@
-import Database from "@/lib/sqlite";
+import Database from "better-sqlite3";
 import { checkVersion, checkExtensions, checkFilesystem } from "./checks";
 
 export interface InitOptions {

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/read-path.ts

@@ -45,9 +45,20 @@ function withDependsOnFallback(task: Task): TaskReadProjection {
   };
 }
 
+function inferBlockedReason(task: Task): string | null | undefined {
+  if (
+    task.status === "blocked" &&
+    !task.blocked_reason &&
+    (!task.stage || task.stage.toLowerCase() === "intake")
+  ) {
+    return "Awaiting approval";
+  }
+  return task.blocked_reason;
+}
+
 export async function projectTaskReadModel(task: Task): Promise<TaskReadProjection> {
   if (!isV2ReadPathEnabled()) {
-    return { ...withDependsOnFallback(task), read_path_source: "v1" };
+    return { ...withDependsOnFallback(task), blocked_reason: inferBlockedReason(task), read_path_source: "v1" };
   }
 
   try {
@@ -69,10 +80,10 @@ export async function projectTaskReadModel(task: Task): Promise<TaskReadProjecti
       graph,
     });
 
+    const projected = { ...withDependsOnFallback(task), status, stage };
     return {
-      ...withDependsOnFallback(task),
-      status,
-      stage,
+      ...projected,
+      blocked_reason: inferBlockedReason(projected),
       read_path_source: "v2",
     };
   } catch (error) {

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/store.ts

@@ -1,5 +1,5 @@
 import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
-import type Database from "@/lib/sqlite";
+import type Database from "better-sqlite3";
 
 import type {
   Edge,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/threadSelection.test.ts

@@ -1,16 +1,16 @@
-import type { Workspace } from "@/lib/storage";
+import type { Thread } from "@/lib/storage";
 import {
-  clearLastWorkspaceId,
-  loadLastWorkspaceId,
-  persistLastWorkspaceId,
-  resolveInitialWorkspaceSelection,
+  clearLastThreadId,
+  loadLastThreadId,
+  persistLastThreadId,
+  resolveInitialThreadSelection,
 } from "./threadSelection";
 
-type WorkspaceStorage = Record<string, string>;
+type ThreadStorage = Record<string, string>;
 
-function withFakeLocalStorage<T>(callback: (storage: WorkspaceStorage) => T): T {
+function withFakeLocalStorage<T>(callback: (storage: ThreadStorage) => T): T {
   const originalWindow = globalThis.window;
-  const storage: WorkspaceStorage = {};
+  const storage: ThreadStorage = {};
   const fakeLocalStorage = {
     getItem(key: string) {
       return storage[key] ?? null;
@@ -31,7 +31,7 @@ function withFakeLocalStorage<T>(callback: (storage: WorkspaceStorage) => T): T
   }
 }
 
-function createWorkspace(id: string, updatedAt: number): Workspace {
+function createThread(id: string, updatedAt: number): Thread {
   return {
     id,
     title: "",
@@ -41,39 +41,39 @@ function createWorkspace(id: string, updatedAt: number): Workspace {
   };
 }
 
-describe("workspaceSelection", () => {
-  test("persist/load/clear enjoy the last workspace id lifecycle", () => {
+describe("threadSelection", () => {
+  test("persist/load/clear enjoy the last thread id lifecycle", () => {
     withFakeLocalStorage(() => {
-      expect(loadLastWorkspaceId()).toBeNull();
-      persistLastWorkspaceId("workspace-abc");
-      expect(loadLastWorkspaceId()).toBe("workspace-abc");
-      persistLastWorkspaceId("workspace-def");
-      expect(loadLastWorkspaceId()).toBe("workspace-def");
-      clearLastWorkspaceId();
-      expect(loadLastWorkspaceId()).toBeNull();
+      expect(loadLastThreadId()).toBeNull();
+      persistLastThreadId("thread-abc");
+      expect(loadLastThreadId()).toBe("thread-abc");
+      persistLastThreadId("thread-def");
+      expect(loadLastThreadId()).toBe("thread-def");
+      clearLastThreadId();
+      expect(loadLastThreadId()).toBeNull();
     });
   });
 
-  test("resolveInitialWorkspaceSelection restores saved workspace when it exists", () => {
-    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
-    const result = resolveInitialWorkspaceSelection(workspaces, "workspace-2");
-    expect(result.workspaceId).toBe("workspace-2");
+  test("resolveInitialThreadSelection restores saved thread when it exists", () => {
+    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
+    const result = resolveInitialThreadSelection(threads, "thread-2");
+    expect(result.threadId).toBe("thread-2");
     expect(result.shouldClearSavedId).toBe(false);
     expect(result.restoredFromStorage).toBe(true);
   });
 
-  test("resolveInitialWorkspaceSelection falls back and clears missing saved id", () => {
-    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
-    const result = resolveInitialWorkspaceSelection(workspaces, "missing");
-    expect(result.workspaceId).toBe("workspace-1");
+  test("resolveInitialThreadSelection falls back and clears missing saved id", () => {
+    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
+    const result = resolveInitialThreadSelection(threads, "missing");
+    expect(result.threadId).toBe("thread-1");
     expect(result.shouldClearSavedId).toBe(true);
     expect(result.restoredFromStorage).toBe(false);
   });
 
-  test("resolveInitialWorkspaceSelection defaults to first workspace when no saved id exists", () => {
-    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
-    const result = resolveInitialWorkspaceSelection(workspaces, null);
-    expect(result.workspaceId).toBe("workspace-1");
+  test("resolveInitialThreadSelection defaults to first thread when no saved id exists", () => {
+    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
+    const result = resolveInitialThreadSelection(threads, null);
+    expect(result.threadId).toBe("thread-1");
     expect(result.shouldClearSavedId).toBe(false);
     expect(result.restoredFromStorage).toBe(false);
   });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/threadSelection.ts

@@ -1,67 +1,67 @@
-import type { Workspace } from "@/lib/storage";
+import type { Thread } from "@/lib/storage";
 
-const WORKSPACE_SELECTION_STORAGE_KEY = "agx-chat:last-thread";
+const THREAD_SELECTION_STORAGE_KEY = "agx-chat:last-thread";
 
 function isStorageAvailable(): boolean {
   return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
 }
 
-export function loadLastWorkspaceId(): string | null {
+export function loadLastThreadId(): string | null {
   if (!isStorageAvailable()) {
     return null;
   }
 
   try {
-    return window.localStorage.getItem(WORKSPACE_SELECTION_STORAGE_KEY);
+    return window.localStorage.getItem(THREAD_SELECTION_STORAGE_KEY);
   } catch {
     return null;
   }
 }
 
-export function persistLastWorkspaceId(workspaceId: string): void {
+export function persistLastThreadId(threadId: string): void {
   if (!isStorageAvailable()) {
     return;
   }
 
   try {
-    window.localStorage.setItem(WORKSPACE_SELECTION_STORAGE_KEY, workspaceId);
+    window.localStorage.setItem(THREAD_SELECTION_STORAGE_KEY, threadId);
   } catch {
     // ignore storage failures (e.g., quota exceeded)
   }
 }
 
-export function clearLastWorkspaceId(): void {
+export function clearLastThreadId(): void {
   if (!isStorageAvailable()) {
     return;
   }
 
   try {
-    window.localStorage.removeItem(WORKSPACE_SELECTION_STORAGE_KEY);
+    window.localStorage.removeItem(THREAD_SELECTION_STORAGE_KEY);
   } catch {
     // ignore storage failures (e.g., quota exceeded)
   }
 }
 
-export type InitialWorkspaceSelection = {
-  workspaceId: string | null;
+export type InitialThreadSelection = {
+  threadId: string | null;
   shouldClearSavedId: boolean;
   restoredFromStorage: boolean;
 };
 
-export function resolveInitialWorkspaceSelection(
-  workspaces: Workspace[],
-  savedWorkspaceId: string | null
-): InitialWorkspaceSelection {
-  const fallbackWorkspaceId = workspaces[0]?.id ?? null;
+export function resolveInitialThreadSelection(
+  threads: Thread[],
+  savedThreadId: string | null
+): InitialThreadSelection {
+  const fallbackThreadId = threads[0]?.id ?? null;
 
-  if (!savedWorkspaceId) {
-    return { workspaceId: fallbackWorkspaceId, shouldClearSavedId: false, restoredFromStorage: false };
+  if (!savedThreadId) {
+    return { threadId: fallbackThreadId, shouldClearSavedId: false, restoredFromStorage: false };
   }
 
-  const savedWorkspaceExists = workspaces.some((workspace) => workspace.id === savedWorkspaceId);
-  if (savedWorkspaceExists) {
-    return { workspaceId: savedWorkspaceId, shouldClearSavedId: false, restoredFromStorage: true };
+  const savedThreadExists = threads.some((thread) => thread.id === savedThreadId);
+  if (savedThreadExists) {
+    return { threadId: savedThreadId, shouldClearSavedId: false, restoredFromStorage: true };
   }
 
-  return { workspaceId: fallbackWorkspaceId, shouldClearSavedId: true, restoredFromStorage: false };
+  return { threadId: fallbackThreadId, shouldClearSavedId: true, restoredFromStorage: false };
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/uiSettings.ts

@@ -1,12 +1,12 @@
 export const UI_SETTINGS_STORAGE_KEY = "agx-chat:uiSettings";
-const DEFAULT_WORKSPACE_SIDEBAR_VISIBLE = false;
+const DEFAULT_THREAD_SIDEBAR_VISIBLE = false;
 
 export interface UiSettings {
-  workspaceSidebarVisible: boolean;
+  threadSidebarVisible: boolean;
 }
 
 const DEFAULT_UI_SETTINGS: UiSettings = {
-  workspaceSidebarVisible: DEFAULT_WORKSPACE_SIDEBAR_VISIBLE,
+  threadSidebarVisible: DEFAULT_THREAD_SIDEBAR_VISIBLE,
 };
 
 function isStorageAvailable(): boolean {
@@ -27,13 +27,10 @@ function readUiSettings(): UiSettings {
     const parsed = JSON.parse(raw) as Partial<UiSettings>;
     return {
       ...DEFAULT_UI_SETTINGS,
-      workspaceSidebarVisible:
-        typeof parsed.workspaceSidebarVisible === "boolean"
-          ? parsed.workspaceSidebarVisible
-          : // backwards compat: read old key
-            typeof (parsed as Record<string, unknown>).threadSidebarVisible === "boolean"
-            ? (parsed as Record<string, unknown>).threadSidebarVisible as boolean
-            : DEFAULT_WORKSPACE_SIDEBAR_VISIBLE,
+      threadSidebarVisible:
+        typeof parsed.threadSidebarVisible === "boolean"
+          ? parsed.threadSidebarVisible
+          : DEFAULT_THREAD_SIDEBAR_VISIBLE,
     };
   } catch {
     return { ...DEFAULT_UI_SETTINGS };
@@ -52,14 +49,14 @@ function writeUiSettings(settings: UiSettings): void {
   }
 }
 
-export function loadWorkspaceSidebarVisible(): boolean {
-  return readUiSettings().workspaceSidebarVisible;
+export function loadThreadSidebarVisible(): boolean {
+  return readUiSettings().threadSidebarVisible;
 }
 
-export function persistWorkspaceSidebarVisible(visible: boolean): void {
+export function persistThreadSidebarVisible(visible: boolean): void {
   const nextSettings: UiSettings = {
     ...readUiSettings(),
-    workspaceSidebarVisible: visible,
+    threadSidebarVisible: visible,
   };
   writeUiSettings(nextSettings);
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/styles/threadSidebar.css

@@ -51,7 +51,6 @@
   border-radius: 0.5rem;
   /* rounded-lg */
   border: 0;
-  background: #4f46e5;
   /* indigo-600 */
   color: #ffffff;
   display: inline-flex;
@@ -502,4 +501,4 @@
 .thread-sidebar__settings-button:hover {
   background: #f1f5f9;
   color: #0f172a;
-}
+}