openbot 0.3.0 → 0.3.2

package/src/plugins/ai-sdk/system-prompt.ts

@@ -1,4 +1,18 @@
-export const AI_SDK_SYSTEM_PROMPT =
-  'You are a helpful AI assistant on the OpenBot platform. ' +
-  'Use the tools available to you to help the user. ' +
-  'Be concise unless the user asks for depth.';
+export const AI_SDK_SYSTEM_PROMPT = [
+  'You are a helpful AI assistant on the OpenBot platform.',
+  'Use the tools available to you to help the user.',
+  'Be concise unless the user asks for depth.',
+  '',
+  '## Planning with todos',
+  'The current thread has a shared todo list (visible under "Shared todo plan" in context).',
+  'It is the single source of truth for multi-step work and is shared across every agent in the thread.',
+  '',
+  'When planning:',
+  '- For any task that needs more than one step, call `todo_write` ONCE with the full ordered plan, then stop. Do not call any other tool in the same turn.',
+  '- The platform dispatches assignees automatically and completes their todo when their run ends. You do NOT need to call `handoff` to start the plan or `todo_update` to finish items.',
+  '- Each item must be concrete and atomic (one verb, one outcome). Skip the list entirely for trivial single-step requests.',
+  '',
+  'When you are an assignee (you have an `in_progress` todo addressed to you):',
+  '- Just do the work and reply. The platform will mark your todo done and dispatch the next one.',
+  '- If you genuinely cannot complete it, call `todo_update(id, status: "cancelled")` with a brief reason in your reply.',
+].join('\n');

package/src/plugins/delegation/index.ts

@@ -3,26 +3,18 @@ import z from 'zod';
 import type { Plugin } from '../../bus/plugin.js';
 import { OpenBotEvent, OpenBotState } from '../../app/types.js';
 
-const delegationToolDefinitions = {
+const handoffToolDefinitions = {
   handoff: {
     description:
-      'Transfer control to another agent. The target agent continues the task and you do not wait for a tool result.',
+      'Transfer control to another agent. The target agent continues the task in this thread.',
     inputSchema: z.object({
       agentId: z.string().describe('The ID of the target agent.'),
       content: z.string().describe('The message or task to hand off.'),
     }),
   },
-  delegate: {
-    description:
-      'Delegate a subtask to another agent and wait for its result so you can continue.',
-    inputSchema: z.object({
-      agentId: z.string().describe('The ID of the target agent.'),
-      content: z.string().describe('The subtask you want the target agent to execute.'),
-    }),
-  },
 };
 
-const delegationPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
+const handoffPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> => (builder) => {
   builder.on('action:handoff', async function* (event, context) {
     const { agentId, content } = event.data;
 
@@ -46,49 +38,14 @@ const delegationPluginRuntime = (): MelonyPlugin<OpenBotState, OpenBotEvent> =>
       };
     }
   });
-
-  builder.on('action:delegate', async function* (event, context) {
-    const { agentId, content } = event.data;
-    const widgetId = event.meta?.toolCallId
-      ? `delegate_${event.meta.toolCallId}`
-      : `delegate_${Date.now()}`;
-
-    yield {
-      type: 'client:ui:widget',
-      data: {
-        kind: 'message',
-        widgetId,
-        title: `Delegation started: ${agentId}`,
-        body: `Running delegated task in background.\n\n${content}`,
-        state: 'open',
-        metadata: {
-          type: 'delegation:status',
-          phase: 'started',
-          delegatedAgentId: agentId,
-        },
-      },
-      meta: { ...(event.meta || {}), agentId: context.state.agentId },
-    };
-
-    yield {
-      type: 'delegation:request',
-      data: { agentId, content },
-      meta: {
-        ...(event.meta || {}),
-        parentAgentId: context.state.agentId,
-        delegationWidgetId: widgetId,
-        agentId: context.state.agentId,
-      },
-    };
-  });
 };
 
 export const delegationPlugin: Plugin = {
   id: 'delegation',
-  name: 'Delegation',
-  description: 'Hand off or delegate sub-tasks to other agents on the bus.',
-  toolDefinitions: delegationToolDefinitions,
-  factory: () => delegationPluginRuntime(),
+  name: 'Handoff',
+  description: 'Hand off tasks to other agents on the bus.',
+  toolDefinitions: handoffToolDefinitions,
+  factory: () => handoffPluginRuntime(),
 };
 
 export default delegationPlugin;

package/src/plugins/memory/index.ts

@@ -0,0 +1,85 @@
+import z from 'zod';
+import type { Plugin } from '../../bus/plugin.js';
+
+/**
+ * `memory` — exposes the global memory store as agent tools.
+ *
+ * The actual handlers live in `bus/services.ts` because memory is platform
+ * infrastructure (shared across every agent on the bus); this plugin only
+ * contributes the tool definitions so a runtime plugin (e.g. `ai-sdk`) can
+ * surface them to the LLM.
+ *
+ * Scopes
+ * ------
+ * - `global`  (default) — visible to every agent and channel.
+ * - `agent`   — visible only to the agent that wrote it.
+ * - `channel` — visible only inside the active channel.
+ */
+const memoryToolDefinitions = {
+  remember: {
+    description:
+      'Persist a durable fact, preference, or note to long-term memory so it can be recalled in future turns and runs. Use for stable information (user preferences, project conventions, contact details, decisions); avoid using it for transient chatter or per-step scratch state — that belongs in thread state. Keep entries short and self-contained.',
+    inputSchema: z.object({
+      content: z
+        .string()
+        .min(1)
+        .describe(
+          'The fact to remember, written so it makes sense out of context (e.g. "User prefers TypeScript over JavaScript.").',
+        ),
+      scope: z
+        .enum(['global', 'agent', 'channel'])
+        .optional()
+        .describe(
+          'Visibility: `global` (default, all agents everywhere), `agent` (only this agent), `channel` (only this channel).',
+        ),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe('Optional tags for filtering with `recall`.'),
+    }),
+  },
+  recall: {
+    description:
+      'Search long-term memory for facts you previously stored with `remember`. Returns up to `limit` matching records with their ids so you can `forget` stale ones.',
+    inputSchema: z.object({
+      query: z
+        .string()
+        .optional()
+        .describe('Case-insensitive substring filter against memory content.'),
+      tag: z.string().optional().describe('Only return memories that include this tag.'),
+      scope: z
+        .enum(['global', 'agent', 'channel', 'all'])
+        .optional()
+        .describe(
+          'Restrict the search to a single scope. Default `all` returns global + this agent + this channel.',
+        ),
+      limit: z
+        .number()
+        .int()
+        .positive()
+        .max(50)
+        .optional()
+        .describe('Maximum records to return (default 20, max 50).'),
+    }),
+  },
+  forget: {
+    description:
+      'Delete a memory by id. Use after the user asks to forget something or when a previously remembered fact is now wrong. Get ids from `recall`.',
+    inputSchema: z.object({
+      id: z.string().describe('The memory record id (returned by `recall`/`remember`).'),
+    }),
+  },
+};
+
+export const memoryPlugin: Plugin = {
+  id: 'memory',
+  name: 'Memory',
+  description:
+    'Global long-term memory: remember/recall/forget facts across runs and agents.',
+  toolDefinitions: memoryToolDefinitions,
+  factory: () => () => {
+    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+  },
+};
+
+export default memoryPlugin;

package/src/plugins/storage-tools/index.ts

@@ -52,25 +52,14 @@ const storageToolDefinitions = {
       ),
   },
   patch_thread_details: {
-    description: 'Patch current thread details (state and/or spec).',
-    inputSchema: z
-      .object({
-        state: z
-          .record(z.string(), z.unknown())
-          .optional()
-          .describe(
-            'JSON state object for the thread. Use for structured data like `todos` or progress.',
-          ),
-        spec: z
-          .string()
-          .optional()
-          .describe(
-            'Markdown content for the thread specification (SPEC.md). Use for plans and goals.',
-          ),
-      })
-      .refine((value) => value.state !== undefined || value.spec !== undefined, {
-        message: 'Provide at least one of state or spec.',
-      }),
+    description: 'Patch current thread details (state).',
+    inputSchema: z.object({
+      state: z
+        .record(z.string(), z.unknown())
+        .describe(
+          'JSON state object for the thread. Use for structured data like `todos` or progress.',
+        ),
+    }),
   },
   create_variable: {
     description: 'Create or update a variable in the workspace storage.',

package/src/plugins/todo/index.ts

@@ -0,0 +1,64 @@
+import z from 'zod';
+import type { Plugin } from '../../bus/plugin.js';
+
+/**
+ * `todo` — shared, per-thread task list for autonomous multi-agent flows.
+ *
+ * Todos live in `threadDetails.state.todos` and are owned by the system
+ * (handlers in `bus/services.ts`). Any agent in the thread can read the
+ * list via context, and propose mutations through these tools. Each item
+ * may carry an `assignee` agent id; combine with `handoff` to drive an
+ * autonomous, multi-step plan across agents.
+ *
+ * Keep the surface minimal: two tools (replace-all, patch-one) cover plan
+ * authoring, status transitions, and reassignment.
+ */
+const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
+
+const todoToolDefinitions = {
+  todo_write: {
+    description:
+      'Author or rewrite the shared todo plan for the current thread. Pass the full ordered list — missing items are removed. Use at the start of multi-step work, or whenever the plan changes shape. For status flips, prefer `todo_update`.',
+    inputSchema: z.object({
+      todos: z
+        .array(
+          z.object({
+            id: z
+              .string()
+              .optional()
+              .describe('Stable id. Reuse existing ids to preserve history; omit to create.'),
+            content: z.string().min(1).describe('What needs to be done. One concrete step.'),
+            status: todoStatus.optional().describe('Defaults to `pending`.'),
+            assignee: z
+              .string()
+              .optional()
+              .describe('Agent id responsible for this step. Pair with `handoff` to delegate.'),
+          }),
+        )
+        .describe('The complete, ordered plan.'),
+    }),
+  },
+  todo_update: {
+    description:
+      'Patch a single todo by id. Use to mark progress (`in_progress`, `done`, `cancelled`), rephrase, or reassign without rewriting the whole list.',
+    inputSchema: z.object({
+      id: z.string().describe('Todo id from `todo_write` or the rendered list.'),
+      status: todoStatus.optional(),
+      content: z.string().min(1).optional(),
+      assignee: z.string().optional().describe('Use empty string to clear.'),
+    }),
+  },
+};
+
+export const todoPlugin: Plugin = {
+  id: 'todo',
+  name: 'Todo',
+  description:
+    'Shared per-thread task list for coordinating multi-step, multi-agent work.',
+  toolDefinitions: todoToolDefinitions,
+  factory: () => () => {
+    // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+  },
+};
+
+export default todoPlugin;

package/src/registry/plugins.ts

@@ -9,6 +9,8 @@ import { delegationPlugin } from '../plugins/delegation/index.js';
 import { storageToolsPlugin } from '../plugins/storage-tools/index.js';
 import { uiPlugin } from '../plugins/ui/index.js';
 import { approvalPlugin } from '../plugins/approval/index.js';
+import { memoryPlugin } from '../plugins/memory/index.js';
+import { todoPlugin } from '../plugins/todo/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 
 let pluginsDir: string | null = null;
@@ -23,6 +25,8 @@ const BUILT_IN: Record<string, Plugin> = {
   [storageToolsPlugin.id]: storageToolsPlugin,
   [uiPlugin.id]: uiPlugin,
   [approvalPlugin.id]: approvalPlugin,
+  [memoryPlugin.id]: memoryPlugin,
+  [todoPlugin.id]: todoPlugin,
 };
 
 /**
@@ -48,8 +52,6 @@ export function parsePluginModule(
   const name = typeof raw.name === 'string' ? raw.name : '';
   const description = typeof raw.description === 'string' ? raw.description : '';
   const image = typeof raw.image === 'string' ? raw.image : undefined;
-  const defaultInstructions =
-    typeof raw.defaultInstructions === 'string' ? raw.defaultInstructions : undefined;
   const configSchema = raw.configSchema as Plugin['configSchema'];
   const toolDefinitions = raw.toolDefinitions as Plugin['toolDefinitions'];
 
@@ -57,7 +59,6 @@ export function parsePluginModule(
     name,
     description,
     image,
-    defaultInstructions,
     configSchema,
     toolDefinitions,
     factory: factory as Plugin['factory'],

package/src/services/memory.ts

@@ -0,0 +1,213 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
+
+/**
+ * Global memory service.
+ *
+ * Persistent, agent-shared knowledge store that lives outside of any single
+ * channel/thread conversation. Designed as a stable foundation we can extend
+ * later with embeddings, retrieval ranking, TTLs, etc.
+ *
+ * Storage format
+ * --------------
+ * `~/.openbot/memory/log.jsonl` — append-only log. Each line is one of:
+ *
+ *   { "op": "add", "record": MemoryRecord }
+ *   { "op": "delete", "id": string, "at": ISO }
+ *   { "op": "update", "id": string, "patch": Partial<MemoryRecord>, "at": ISO }
+ *
+ * Reads replay the log into an in-memory map. The log is append-only so
+ * concurrent writers are line-atomic on every POSIX filesystem we target.
+ *
+ * Scopes
+ * ------
+ * `global`            — visible to every agent everywhere.
+ * `agent:<agentId>`   — visible only when that agent is running.
+ * `channel:<channelId>` — visible only inside that channel.
+ *
+ * Scope strings are opaque to the store; new scopes can be introduced without
+ * a migration.
+ */
+export interface MemoryRecord {
+  id: string;
+  scope: string;
+  content: string;
+  tags?: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ListMemoriesArgs {
+  /** Exact scope match (e.g. `global`, `agent:foo`, `channel:bar`). */
+  scope?: string;
+  /** Multiple scopes — OR'd together. Useful for "global + agent:X + channel:Y". */
+  scopes?: string[];
+  /** Substring match (case-insensitive) against `content`. */
+  query?: string;
+  /** Match if any of these tags is present. */
+  tag?: string;
+  /** Default 50, hard cap 500. */
+  limit?: number;
+}
+
+interface AddEntry { op: 'add'; record: MemoryRecord }
+interface DeleteEntry { op: 'delete'; id: string; at: string }
+interface UpdateEntry { op: 'update'; id: string; patch: Partial<MemoryRecord>; at: string }
+type LogEntry = AddEntry | DeleteEntry | UpdateEntry;
+
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 500;
+
+const getMemoryDir = (): string => {
+  const config = loadConfig();
+  return path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), 'memory');
+};
+
+const getLogPath = (): string => path.join(getMemoryDir(), 'log.jsonl');
+
+const ensureDir = async (): Promise<void> => {
+  await fs.mkdir(getMemoryDir(), { recursive: true });
+};
+
+const readLog = async (): Promise<LogEntry[]> => {
+  try {
+    const raw = await fs.readFile(getLogPath(), 'utf-8');
+    return raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line) as LogEntry;
+        } catch {
+          return null;
+        }
+      })
+      .filter((e): e is LogEntry => !!e);
+  } catch (e: unknown) {
+    if ((e as { code?: string })?.code === 'ENOENT') return [];
+    throw e;
+  }
+};
+
+const replay = (entries: LogEntry[]): Map<string, MemoryRecord> => {
+  const out = new Map<string, MemoryRecord>();
+  for (const entry of entries) {
+    if (entry.op === 'add') {
+      out.set(entry.record.id, entry.record);
+    } else if (entry.op === 'delete') {
+      out.delete(entry.id);
+    } else if (entry.op === 'update') {
+      const existing = out.get(entry.id);
+      if (!existing) continue;
+      out.set(entry.id, {
+        ...existing,
+        ...entry.patch,
+        id: existing.id,
+        updatedAt: entry.at,
+      });
+    }
+  }
+  return out;
+};
+
+const appendEntry = async (entry: LogEntry): Promise<void> => {
+  await ensureDir();
+  await fs.appendFile(getLogPath(), `${JSON.stringify(entry)}\n`, 'utf-8');
+};
+
+const matchesQuery = (record: MemoryRecord, query?: string, tag?: string): boolean => {
+  if (tag) {
+    if (!record.tags || !record.tags.includes(tag)) return false;
+  }
+  if (query) {
+    const q = query.toLowerCase();
+    if (!record.content.toLowerCase().includes(q)) return false;
+  }
+  return true;
+};
+
+export const memoryService = {
+  appendMemory: async (args: {
+    scope: string;
+    content: string;
+    tags?: string[];
+  }): Promise<MemoryRecord> => {
+    const now = new Date().toISOString();
+    const record: MemoryRecord = {
+      id: crypto.randomUUID(),
+      scope: args.scope,
+      content: args.content,
+      tags: args.tags?.length ? args.tags : undefined,
+      createdAt: now,
+      updatedAt: now,
+    };
+    await appendEntry({ op: 'add', record });
+    return record;
+  },
+
+  updateMemory: async (args: {
+    id: string;
+    content?: string;
+    tags?: string[];
+  }): Promise<boolean> => {
+    const entries = await readLog();
+    const map = replay(entries);
+    if (!map.has(args.id)) return false;
+    const at = new Date().toISOString();
+    const patch: Partial<MemoryRecord> = {};
+    if (args.content !== undefined) patch.content = args.content;
+    if (args.tags !== undefined) patch.tags = args.tags.length ? args.tags : undefined;
+    if (Object.keys(patch).length === 0) return true;
+    await appendEntry({ op: 'update', id: args.id, patch, at });
+    return true;
+  },
+
+  deleteMemory: async (args: { id: string }): Promise<boolean> => {
+    const entries = await readLog();
+    const map = replay(entries);
+    if (!map.has(args.id)) return false;
+    await appendEntry({ op: 'delete', id: args.id, at: new Date().toISOString() });
+    return true;
+  },
+
+  listMemories: async (args: ListMemoriesArgs = {}): Promise<MemoryRecord[]> => {
+    const entries = await readLog();
+    const map = replay(entries);
+    const limit = Math.min(Math.max(args.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+
+    const scopeSet = (() => {
+      if (args.scope) return new Set([args.scope]);
+      if (args.scopes && args.scopes.length > 0) return new Set(args.scopes);
+      return null;
+    })();
+
+    const filtered: MemoryRecord[] = [];
+    for (const record of map.values()) {
+      if (scopeSet && !scopeSet.has(record.scope)) continue;
+      if (!matchesQuery(record, args.query, args.tag)) continue;
+      filtered.push(record);
+    }
+
+    filtered.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+    return filtered.slice(0, limit);
+  },
+
+  /**
+   * Compact the log into a single `add` per surviving record. Cheap to call
+   * occasionally; not required for correctness.
+   */
+  compact: async (): Promise<number> => {
+    const entries = await readLog();
+    const map = replay(entries);
+    const surviving = Array.from(map.values());
+    await ensureDir();
+    const tmp = `${getLogPath()}.tmp`;
+    const body = surviving.map((record) => JSON.stringify({ op: 'add', record })).join('\n');
+    await fs.writeFile(tmp, body ? `${body}\n` : '', 'utf-8');
+    await fs.rename(tmp, getLogPath());
+    return surviving.length;
+  },
+};

package/src/services/storage.ts

@@ -27,6 +27,7 @@ import { AI_SDK_SYSTEM_PROMPT } from '../plugins/ai-sdk/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../registry/plugins.js';
 import { OpenBotEvent, OpenBotState } from '../app/types.js';
 import { processService } from '../harness/process.js';
+import { memoryService } from './memory.js';
 import { pathToFileURL } from 'node:url';
 
 const resolveBaseDir = () => {
@@ -90,9 +91,10 @@ const SYSTEM_DEFAULT_PLUGINS: PluginRef[] = [
   { id: 'storage-tools' },
   // { id: 'mcp' },
   { id: 'shell' },
-  { id: 'delegation' },
+  { id: 'todo' },
   // { id: 'ui' },
   { id: 'approval' },
+  { id: 'memory' },
 ];
 
 function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails {
@@ -101,7 +103,7 @@ function getSystemAgentDetails(overrides?: Partial<AgentDetails>): AgentDetails
     name: 'OpenBot',
     image: undefined,
     description:
-      'First-party orchestration agent for OpenBot. Coordinates other agents via handoff and delegation.',
+      'First-party orchestration agent for OpenBot. Coordinates other agents via handoff.',
     instructions: AI_SDK_SYSTEM_PROMPT,
     plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
     pluginRefs: SYSTEM_DEFAULT_PLUGINS,
@@ -209,7 +211,6 @@ const listBuiltInPluginDescriptors = async (): Promise<PluginDescriptor[]> => {
     description: plugin.description,
     builtIn: true,
     image: plugin.image,
-    defaultInstructions: plugin.defaultInstructions,
     configSchema: plugin.configSchema,
     createdAt: new Date(),
     updatedAt: new Date(),
@@ -279,7 +280,6 @@ const listPluginsFromDisk = async (): Promise<PluginDescriptor[]> => {
           description: parsed.description || '',
           builtIn: false,
           image: parsed.image || image,
-          defaultInstructions: parsed.defaultInstructions,
           configSchema: parsed.configSchema,
           createdAt: new Date(),
           updatedAt: new Date(),
@@ -448,13 +448,11 @@ export const storageService = {
     channelId,
     threadId,
     threadTitle,
-    spec,
     initialState,
   }: {
     channelId: string;
     threadId: string;
     threadTitle?: string;
-    spec?: string;
     initialState?: Record<string, unknown>;
   }): Promise<void> => {
     const normalizedChannelId = channelId.trim();
@@ -464,7 +462,6 @@ export const storageService = {
     if (!normalizedThreadId) throw new Error('threadId is required');
 
     const threadDir = getConversationDir(normalizedChannelId, normalizedThreadId);
-    const specPath = `${threadDir}/SPEC.md`;
     const statePath = `${threadDir}/state.json`;
 
     try {
@@ -485,11 +482,6 @@ export const storageService = {
     }
 
     await fs.mkdir(threadDir, { recursive: true });
-    await fs.writeFile(
-      specPath,
-      spec?.trim() ||
-        `# ${normalizedThreadId}\n\nDefine the goals and plan for this thread here.\n`,
-    );
     await fs.writeFile(statePath, JSON.stringify(baseState, null, 2));
   },
   getThreads: async ({ channelId }: { channelId: string }): Promise<Thread[]> => {
@@ -548,21 +540,8 @@ export const storageService = {
     threadId: string;
   }): Promise<ThreadDetails> => {
     const threadDir = getConversationDir(channelId, threadId);
-    const specPath = `${threadDir}/SPEC.md`;
     const statePath = `${threadDir}/state.json`;
 
-    let spec = '';
-    try {
-      spec = await fs.readFile(specPath, 'utf-8');
-    } catch (error: unknown) {
-      if ((error as NodeJS.ErrnoException)?.code !== 'ENOENT') {
-        console.error(
-          `Failed to read thread spec for channel ${channelId} thread ${threadId}`,
-          error,
-        );
-      }
-    }
-
     let state: unknown = {};
     try {
       const stateContent = await fs.readFile(statePath, 'utf-8');
@@ -585,7 +564,6 @@ export const storageService = {
       id: threadId,
       name: generatedName || threadId,
       channelId,
-      spec,
       state,
     };
   },
@@ -702,29 +680,6 @@ export const storageService = {
       throw error;
     }
   },
-  patchThreadSpec: async ({
-    channelId,
-    threadId,
-    spec,
-  }: {
-    channelId: string;
-    threadId: string;
-    spec: string;
-  }): Promise<void> => {
-    const threadDir = getConversationDir(channelId, threadId);
-    const specPath = `${threadDir}/SPEC.md`;
-
-    try {
-      await fs.mkdir(threadDir, { recursive: true });
-      await fs.writeFile(specPath, spec);
-    } catch (error) {
-      console.error(
-        `Failed to patch thread spec for channel ${channelId} thread ${threadId}`,
-        error,
-      );
-      throw error;
-    }
-  },
   getAgents: async (): Promise<Agent[]> => {
     const agentsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_AGENTS_DIR);
     try {
@@ -1220,6 +1175,11 @@ export const storageService = {
     return fs.readFile(targetFile, 'utf-8');
   },
 
+  appendMemory: memoryService.appendMemory,
+  listMemories: memoryService.listMemories,
+  deleteMemory: memoryService.deleteMemory,
+  updateMemory: memoryService.updateMemory,
+
   /**
    * Hydrates the full OpenBot state from disk/storage before a run.
    */