@mndrk/agx 2.0.0-next.8 → 2.0.0

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

@@ -0,0 +1,76 @@
+import type { GroupMessage, Participant } from "@/lib/types";
+
+export const DEMO_PARTICIPANTS: Participant[] = [
+  { id: "jane", name: "Jane", provider: "claude", model: "claude-opus-4-6", color: "#6366f1" },
+  { id: "cody", name: "Cody", provider: "claude", model: "gpt-5.3", color: "#f59e0b" },
+  { id: "flint", name: "Flint", provider: "ollama", model: "gemini-3.1-pro", color: "#10b981" },
+  { id: "jewel", name: "Jewel", provider: "claude", model: "glm-5", color: "#ec4899" },
+];
+
+const now = Date.now();
+
+export const DEMO_MESSAGES: GroupMessage[] = [
+  {
+    id: "demo-0",
+    role: "user",
+    participantId: null,
+    content: "We're losing 40% of users at the onboarding config screen. How should we fix this?",
+    timestamp: now - 9000,
+  },
+  {
+    id: "demo-1",
+    role: "assistant",
+    participantId: "jane",
+    content: "The core problem is we're asking for setup before showing value. Users don't know *why* they need an API key yet. Flip the order — let them see the product working first, then ask for config when they actually need it.",
+    timestamp: now - 8000,
+  },
+  {
+    id: "demo-2",
+    role: "assistant",
+    participantId: "cody",
+    content: "We can prove that with a zero-config starter task: detect `package.json` or `.git` on load, run a local project analysis. No API key needed, instant result. That alone should cut the drop-off significantly.",
+    timestamp: now - 7000,
+  },
+  {
+    id: "demo-3",
+    role: "assistant",
+    participantId: "flint",
+    content: "Risk: if we defer config entirely, the *second* interaction fails when there's no provider configured. We'd just move the drop-off from step 1 to step 2. Need to handle that transition carefully.",
+    timestamp: now - 6000,
+  },
+  {
+    id: "demo-4",
+    role: "assistant",
+    participantId: "jewel",
+    content: "Graduated fidelity solves this. First task is local-only and always succeeds. When they trigger something that needs an LLM, prompt for the key *inline* — right where they need it, not on a separate page. Context-sensitive setup.",
+    timestamp: now - 5000,
+  },
+  {
+    id: "demo-5",
+    role: "assistant",
+    participantId: "jane",
+    content: "Exactly. Setup instructions are only useful at the moment you need them. Front-loading them is just anxiety. I'd also suggest we track `welcome_view → first_action → first_result` to measure the actual impact.",
+    timestamp: now - 4000,
+  },
+  {
+    id: "demo-6",
+    role: "assistant",
+    participantId: "cody",
+    content: "Here's a concrete implementation plan:\n1. Add framework detection on page load\n2. Show \"Map this project\" as default starter task\n3. Run it client-side with zero dependencies\n4. Persist the result so they land in a live session, not a blank page",
+    timestamp: now - 3000,
+  },
+  {
+    id: "demo-7",
+    role: "assistant",
+    participantId: "flint",
+    content: "One more thing — keep state from that first task. When they transition to the real workspace, they should land mid-session. Starting over after the demo kills momentum and trust.",
+    timestamp: now - 2000,
+  },
+  {
+    id: "demo-8",
+    role: "assistant",
+    participantId: "jewel",
+    content: "Summary: land → see agents working → join with one click → first task runs instantly → setup happens only when needed. Every step earns the next. Shall I draft the implementation spec?",
+    timestamp: now - 1000,
+  },
+];

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/jobs/pruneNotifications.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * lib/jobs/pruneNotifications.js
+ *
+ * Scheduled job that prunes old notifications from the read-model table.
+ *
+ * Retention policy:
+ *   - Read notifications older than TTL_DAYS_MIN (60 days) are deleted.
+ *   - All notifications older than TTL_DAYS_MAX (90 days) are deleted.
+ *
+ * Usage:
+ *   const pruneJob = require('./pruneNotifications');
+ *   pruneJob.start();   // begin scheduled runs
+ *   pruneJob.stop();    // cancel scheduled runs
+ *   pruneJob.runOnce(); // run immediately (useful in tests / CLI)
+ */
+
+const { pruneOldNotifications } = require('../db/notifications');
+
+// ── Configuration ────────────────────────────────────────────────────────────
+
+const TTL_DAYS_MIN = 60;  // delete read notifications older than this
+const TTL_DAYS_MAX = 90;  // delete all notifications older than this
+const DEFAULT_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+
+// ── Job implementation ───────────────────────────────────────────────────────
+
+/**
+ * Run the prune job once and log the outcome.
+ *
+ * @returns {{ deleted: number }}
+ */
+function runOnce() {
+  try {
+    const { deleted } = pruneOldNotifications({ minDays: TTL_DAYS_MIN, maxDays: TTL_DAYS_MAX });
+    if (deleted > 0) {
+      console.log(`[pruneNotifications] deleted ${deleted} notifications (min=${TTL_DAYS_MIN}d, max=${TTL_DAYS_MAX}d)`);
+    } else {
+      console.debug('[pruneNotifications] nothing to prune');
+    }
+    return { deleted };
+  } catch (err) {
+    console.error('[pruneNotifications] error during prune run', err);
+    return { deleted: 0 };
+  }
+}
+
+// ── Scheduler ────────────────────────────────────────────────────────────────
+
+let _timer = null;
+
+/**
+ * Start the scheduled prune job.
+ * Safe to call multiple times — subsequent calls are no-ops.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.intervalMs] - override the default 6-hour interval
+ */
+function start({ intervalMs = DEFAULT_INTERVAL_MS } = {}) {
+  if (_timer) return;
+
+  // Run once immediately on start, then on interval
+  runOnce();
+
+  _timer = setInterval(() => {
+    runOnce();
+  }, intervalMs);
+
+  // Allow the process to exit even if this timer is still active
+  if (_timer.unref) _timer.unref();
+
+  console.log(`[pruneNotifications] scheduler started (interval=${intervalMs}ms)`);
+}
+
+/**
+ * Stop the scheduled prune job.
+ */
+function stop() {
+  if (_timer) {
+    clearInterval(_timer);
+    _timer = null;
+    console.log('[pruneNotifications] scheduler stopped');
+  }
+}
+
+module.exports = { start, stop, runOnce, TTL_DAYS_MIN, TTL_DAYS_MAX };

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

@@ -255,9 +255,13 @@ export function loadParticipants(): Participant[] {
           skills: (() => {
             try {
               const parsed = JSON.parse(r.skills_json);
-              return Array.isArray(parsed)
-                ? parsed.filter((item): item is string => typeof item === "string")
-                : [];
+              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: "" }
+                  : (item as { file: string; condition: string })
+              );
             } catch {
               return [];
             }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/projectors/notificationProjector.js

@@ -0,0 +1,351 @@
+/**
+ * lib/projectors/notificationProjector.js
+ *
+ * Notification projector — consumes the task_audit_log event stream and
+ * materialises rows into the notifications + notification_outbox tables.
+ *
+ * Design goals:
+ *  - Durable per-consumer cursor (restarts from last position after crash)
+ *  - Idempotent via UNIQUE (event_id, user_id, type) → INSERT OR IGNORE
+ *  - 5-second debounce for blocked↔running state flapping
+ *  - Notification + outbox written in a single SQLite transaction
+ *  - TTL prune job (60-90 days retention) callable on demand or on a schedule
+ *  - At-least-once from event stream; exactly-once effect via DB unique key
+ *
+ * Event source: task_audit_log (rowid used as sequence number / cursor position)
+ *
+ * Usage:
+ *   const projector = require('./notificationProjector');
+ *   projector.start();          // begin polling loop
+ *   projector.stop();           // graceful shutdown
+ *   projector.runOnce();        // process pending events once (testing / CLI)
+ *   projector.pruneOld();       // delete notifications older than TTL
+ */
+
+'use strict';
+
+const { getSQLiteDb } = require('../sqlite-query-adapter');
+const { readCursor, advanceCursorInTxn } = require('../db/cursors');
+const { shouldNotify } = require('../db/preferences');
+const { pruneOldNotifications } = require('../db/notifications');
+const pruneJob = require('../jobs/pruneNotifications');
+
+// ── Constants ───────────────────────────────────────────────────────────────
+
+const CONSUMER_ID = 'notification_projector';
+const POLL_INTERVAL_MS = 2000;         // how often to poll for new events
+const BATCH_SIZE = 100;                // events per poll cycle
+const DEBOUNCE_MS = 5000;             // 5 s debounce for blocked↔running flap
+const TTL_DAYS_MIN = 60;
+const TTL_DAYS_MAX = 90;
+const MAX_UNREAD_PER_USER = 500;       // cap on unread notifications per user
+
+// Mapping from task_audit_log.action → notification type + tier + title template
+const ACTION_MAP = {
+  complete: { type: 'task.completed', tier: 'success', titleFn: (t) => `Task completed: ${t.title || t.id}` },
+  fail:     { type: 'task.failed',    tier: 'error',   titleFn: (t) => `Task failed: ${t.title || t.id}` },
+  reject:   { type: 'task.rejected',  tier: 'warning', titleFn: (t) => `Task rejected: ${t.title || t.id}` },
+  dispatch: { type: 'task.created',   tier: 'info',    titleFn: (t) => `Task created: ${t.title || t.id}` },
+  execute:  { type: 'task.started',   tier: 'info',    titleFn: (t) => `Task started: ${t.title || t.id}` },
+};
+
+// Actions that are subject to debounce (blocked↔running flapping)
+const DEBOUNCE_ACTIONS = new Set(['execute']);    // running state
+const DEBOUNCE_PAIR   = new Set(['execute']);     // keep symmetric for future blocked action
+
+// ── Debounce state machine ──────────────────────────────────────────────────
+// In-memory map: taskId → { lastAction, lastTs }
+// Scoped to this module; reset on process restart (safe — DB unique key is the guard)
+
+const _debounceState = new Map(); // taskId → { action, ts }
+
+/**
+ * Check if an event should be suppressed by the debounce window.
+ * We suppress a `blocked` event that follows a `running` event (or vice versa)
+ * within DEBOUNCE_MS of the previous one.
+ *
+ * For simplicity, we track the last emitted action per task and suppress if
+ * the new action is in {blocked, running} and the previous was too, within 5s.
+ *
+ * @param {string} taskId
+ * @param {string} action  - audit log action
+ * @param {number} eventTs - epoch ms of the event
+ * @returns {boolean} true if this event should be dropped (debounced)
+ */
+function isDebounced(taskId, action, eventTs) {
+  const FLAP_ACTIONS = new Set(['execute']); // 'blocked' is not in audit_log; extend here when added
+  if (!FLAP_ACTIONS.has(action)) return false;
+
+  const prev = _debounceState.get(taskId);
+  if (!prev) {
+    _debounceState.set(taskId, { action, ts: eventTs });
+    return false;
+  }
+
+  const elapsed = eventTs - prev.ts;
+  if (FLAP_ACTIONS.has(prev.action) && elapsed < DEBOUNCE_MS) {
+    // Same class of flapping event within window — suppress
+    return true;
+  }
+
+  _debounceState.set(taskId, { action, ts: eventTs });
+  return false;
+}
+
+// ── Core projection logic ───────────────────────────────────────────────────
+
+/**
+ * Fetch up to BATCH_SIZE unprocessed events from task_audit_log after cursor.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {number} afterRowid
+ * @returns {Array<{rowid, id, task_id, user_id, action, payload, dispatched_at}>}
+ */
+function fetchEvents(db, afterRowid) {
+  return db.prepare(`
+    SELECT
+      rowid,
+      id,
+      task_id,
+      user_id,
+      action,
+      payload,
+      dispatched_at
+    FROM task_audit_log
+    WHERE rowid > ?
+    ORDER BY rowid ASC
+    LIMIT ?
+  `).all(afterRowid, BATCH_SIZE);
+}
+
+/**
+ * Fetch task metadata needed for notification title/body.
+ * Returns null if the task no longer exists.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} taskId
+ * @returns {{id, title, slug, user_id}|null}
+ */
+function getTask(db, taskId) {
+  return db.prepare(
+    'SELECT id, title, slug, user_id FROM tasks WHERE id = ?'
+  ).get(taskId) || null;
+}
+
+// shouldNotify is imported from ../db/preferences — see that module for resolution order:
+//   1. Task-level (tasks.stage_decisions.notifications[type])
+//   2. User-level (user_settings.notification_prefs[type])
+//   3. Global default → true
+
+/**
+ * Write one notification + its outbox row atomically.
+ * Uses INSERT OR IGNORE so duplicate event_id+user_id+type is a no-op.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {{ eventId, userId, taskId, type, tier, title, body, payload }} row
+ */
+function insertNotificationAndOutbox(db, { eventId, userId, taskId, type, tier, title, body, payload }) {
+  // INSERT OR IGNORE — idempotent via UNIQUE(event_id, user_id, type)
+  const result = db.prepare(`
+    INSERT OR IGNORE INTO notifications (user_id, task_id, event_id, type, tier, title, body)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(userId, taskId, eventId, type, tier, title, body ?? null);
+
+  // Only write outbox if a row was actually inserted (changes = 1)
+  if (result.changes > 0) {
+    const notifRow = db.prepare(
+      'SELECT id FROM notifications WHERE event_id = ? AND user_id = ? AND type = ?'
+    ).get(eventId, userId, type);
+
+    if (notifRow) {
+      db.prepare(`
+        INSERT INTO notification_outbox (notification_id, payload)
+        VALUES (?, ?)
+      `).run(notifRow.id, JSON.stringify(payload));
+    }
+  }
+}
+
+/**
+ * Cap unread notifications per user to MAX_UNREAD_PER_USER by marking
+ * the oldest ones as read. Runs inside the same transaction.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} userId
+ */
+function capUnread(db, userId) {
+  const count = db.prepare(
+    'SELECT COUNT(*) AS n FROM notifications WHERE user_id = ? AND read_at IS NULL'
+  ).get(userId)?.n ?? 0;
+
+  if (count > MAX_UNREAD_PER_USER) {
+    const excess = count - MAX_UNREAD_PER_USER;
+    db.prepare(`
+      UPDATE notifications SET read_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
+      WHERE id IN (
+        SELECT id FROM notifications
+        WHERE user_id = ? AND read_at IS NULL
+        ORDER BY created_at ASC
+        LIMIT ?
+      )
+    `).run(userId, excess);
+  }
+}
+
+/**
+ * Process one batch of events. Returns the number of events processed.
+ *
+ * @returns {number}
+ */
+function processBatch() {
+  const db = getSQLiteDb();
+  const cursor = readCursor(CONSUMER_ID);
+  const events = fetchEvents(db, cursor);
+
+  if (events.length === 0) return 0;
+
+  let lastRowid = cursor;
+  const affectedUsers = new Set();
+
+  // Use a single transaction for the entire batch
+  const runBatch = db.transaction(() => {
+    for (const event of events) {
+      lastRowid = event.rowid;
+
+      const mapping = ACTION_MAP[event.action];
+      if (!mapping) continue; // unrecognised action — skip but advance cursor
+
+      const taskId = event.task_id;
+      const userId = event.user_id;
+      if (!taskId || !userId) continue;
+
+      const task = getTask(db, taskId);
+      if (!task) continue; // task deleted — skip
+
+      const eventTs = event.dispatched_at
+        ? new Date(event.dispatched_at).getTime()
+        : Date.now();
+
+      // Debounce check for flapping states
+      if (isDebounced(taskId, event.action, eventTs)) continue;
+
+      // Task-level / user-level preference check (lib/db/preferences.js)
+      if (!shouldNotify(db, taskId, userId, mapping.type)) continue;
+
+      const title = mapping.titleFn(task);
+      let payload;
+      try {
+        payload = typeof event.payload === 'string' ? JSON.parse(event.payload) : (event.payload || {});
+      } catch {
+        payload = {};
+      }
+
+      const outboxPayload = {
+        eventType: mapping.type,
+        taskId,
+        userId,
+        title,
+        slug: task.slug || null,
+        timestamp: event.dispatched_at || new Date().toISOString(),
+        details: payload,
+      };
+
+      insertNotificationAndOutbox(db, {
+        eventId: event.id,           // audit log UUID — stable dedup key
+        userId,
+        taskId,
+        type: mapping.type,
+        tier: mapping.tier,
+        title,
+        body: payload.error || payload.reason || null,
+        payload: outboxPayload,
+      });
+
+      affectedUsers.add(userId);
+    }
+
+    // Cap unread per user after batch
+    for (const uid of affectedUsers) {
+      capUnread(db, uid);
+    }
+
+    // Advance cursor atomically with the inserts
+    advanceCursorInTxn(db, CONSUMER_ID, lastRowid);
+  });
+
+  runBatch();
+  return events.length;
+}
+
+// ── TTL / prune job ─────────────────────────────────────────────────────────
+
+/**
+ * Delete notifications older than TTL_DAYS_MIN (60) days.
+ * Runs a second pass to also prune read notifications older than TTL_DAYS_MAX (90) days.
+ * Safe to call at any time — does not interact with the cursor.
+ *
+ * @returns {{ deleted: number }}
+ */
+function pruneOld() {
+  const { deleted } = pruneOldNotifications({ minDays: TTL_DAYS_MIN, maxDays: TTL_DAYS_MAX });
+  if (deleted > 0) {
+    console.log(`[notificationProjector] pruned ${deleted} old notifications`);
+  }
+  return { deleted };
+}
+
+// ── Polling loop ────────────────────────────────────────────────────────────
+
+let _timer = null;
+let _running = false;
+
+/**
+ * Start the projector polling loop.
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+function start() {
+  if (_running) return;
+  _running = true;
+  console.log(`[notificationProjector] starting (consumer=${CONSUMER_ID}, poll=${POLL_INTERVAL_MS}ms)`);
+  pruneJob.start();
+
+  const tick = () => {
+    if (!_running) return;
+    try {
+      const n = processBatch();
+      if (n > 0) {
+        console.debug(`[notificationProjector] processed ${n} events`);
+      }
+    } catch (err) {
+      console.error('[notificationProjector] error in batch', err);
+    }
+    if (_running) {
+      _timer = setTimeout(tick, POLL_INTERVAL_MS);
+    }
+  };
+
+  _timer = setTimeout(tick, 0);
+}
+
+/**
+ * Stop the projector polling loop gracefully.
+ */
+function stop() {
+  _running = false;
+  if (_timer) {
+    clearTimeout(_timer);
+    _timer = null;
+  }
+  pruneJob.stop();
+  console.log('[notificationProjector] stopped');
+}
+
+/**
+ * Run a single batch synchronously (useful for tests and CLI replay).
+ * @returns {number} number of events processed
+ */
+function runOnce() {
+  return processBatch();
+}
+
+module.exports = { start, stop, runOnce, pruneOld, CONSUMER_ID };

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

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

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

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