openbot 0.3.1 → 0.3.3

package/src/app/types.ts

@@ -290,7 +290,6 @@ export type PatchThreadDetailsEvent = BaseEvent & {
   type: 'action:patch_thread_details';
   data: {
     state?: Record<string, unknown>;
-    spec?: string;
   };
 };
 
@@ -298,7 +297,7 @@ export type PatchThreadDetailsResultEvent = BaseEvent & {
   type: 'action:patch_thread_details:result';
   data: {
     success: boolean;
-    updatedFields: ('state' | 'spec')[];
+    updatedFields: ('state')[];
   };
 };
 
@@ -381,7 +380,6 @@ export type CreateThreadEvent = BaseEvent & {
   type: 'action:create_thread';
   data: {
     threadTitle: string;
-    spec?: string;
     initialState?: Record<string, unknown>;
   };
   meta: {
@@ -570,34 +568,7 @@ export type HandoffResultEvent = BaseEvent & {
   };
 };
 
-export type DelegateEvent = BaseEvent & {
-  type: 'action:delegate';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: {
-    toolCallId?: string;
-    [key: string]: any;
-  };
-};
-
-export type DelegateResultEvent = BaseEvent & {
-  type: 'action:delegate:result';
-  data: {
-    success: boolean;
-    agentId: string;
-    summary: string;
-  };
-  meta: {
-    toolCallId: string;
-    agentId: string;
-    threadId?: string;
-    [key: string]: any;
-  };
-};
-
-/** Internal routing: delegation plugin → orchestrator only (not stored or broadcast). */
+/** Internal routing: handoff plugin → orchestrator only (not stored or broadcast). */
 export type HandoffRequestEvent = BaseEvent & {
   type: 'handoff:request';
   data: {
@@ -607,16 +578,6 @@ export type HandoffRequestEvent = BaseEvent & {
   meta?: Record<string, unknown>;
 };
 
-/** Internal routing: delegation plugin → orchestrator only (not stored or broadcast). */
-export type DelegationRequestEvent = BaseEvent & {
-  type: 'delegation:request';
-  data: {
-    agentId: string;
-    content: string;
-  };
-  meta?: Record<string, unknown>;
-};
-
 export type MCPListToolsEvent = BaseEvent & {
   type: 'action:mcp_list_tools';
   data: {
@@ -820,6 +781,79 @@ export type ForgetResultEvent = BaseEvent & {
   };
 };
 
+export type TodoStatus = 'pending' | 'in_progress' | 'done' | 'cancelled';
+
+/**
+ * A single unit of work tracked in thread state. Todos are owned by the
+ * system (bus services); agents can only mutate them by calling the
+ * `todo_write` / `todo_update` tools so every change is observable on the
+ * event stream and audit-friendly.
+ */
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: TodoStatus;
+  /** Optional agent id responsible for this item — drives autonomous handoffs. */
+  assignee?: string;
+  /** Agent id that created the todo (or "system"). */
+  createdBy: string;
+  createdAt: number;
+  updatedAt: number;
+  /**
+   * Captured final reply when this item reaches `done` (last `agent:output`
+   * from the assignee for that run). Lets downstream agents rely on thread
+   * state instead of merged short-term messages.
+   */
+  result?: string;
+}
+
+export type TodoWriteInput = {
+  id?: string;
+  content: string;
+  status?: TodoStatus;
+  assignee?: string;
+};
+
+export type TodoWriteEvent = BaseEvent & {
+  type: 'action:todo_write';
+  data: {
+    todos: TodoWriteInput[];
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoWriteResultEvent = BaseEvent & {
+  type: 'action:todo_write:result';
+  data: {
+    success: boolean;
+    todos: TodoItem[];
+    error?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoUpdateEvent = BaseEvent & {
+  type: 'action:todo_update';
+  data: {
+    id: string;
+    status?: TodoStatus;
+    content?: string;
+    assignee?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
+export type TodoUpdateResultEvent = BaseEvent & {
+  type: 'action:todo_update:result';
+  data: {
+    success: boolean;
+    todo?: TodoItem;
+    todos: TodoItem[];
+    error?: string;
+  };
+  meta?: { toolCallId?: string; agentId?: string; threadId?: string };
+};
+
 export type OpenBotEvent =
   | UserInputEvent
   | AgentInvokeEvent
@@ -879,10 +913,7 @@ export type OpenBotEvent =
   | UIWidgetResponseEvent
   | HandoffEvent
   | HandoffResultEvent
-  | DelegateEvent
-  | DelegateResultEvent
   | HandoffRequestEvent
-  | DelegationRequestEvent
   | MCPListToolsEvent
   | MCPListToolsResultEvent
   | MCPCallEvent
@@ -902,4 +933,8 @@ export type OpenBotEvent =
   | RecallEvent
   | RecallResultEvent
   | ForgetEvent
-  | ForgetResultEvent;
+  | ForgetResultEvent
+  | TodoWriteEvent
+  | TodoWriteResultEvent
+  | TodoUpdateEvent
+  | TodoUpdateResultEvent;

package/src/bus/plugin.ts

@@ -56,8 +56,6 @@ export interface Plugin {
   name: string;
   description: string;
   image?: string;
-  /** Optional system-prompt body suggested when this plugin is used as the runtime. */
-  defaultInstructions?: string;
   /** JSON-schema-like description of `config` accepted in AGENT.md `plugins[].config`. */
   configSchema?: ConfigSchema;
   /** Tool definitions contributed to any runtime plugin attached to the same agent. */

package/src/bus/services.ts

@@ -1,11 +1,45 @@
 import { MelonyPlugin } from 'melony';
 import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig } from '../app/config.js';
-import { OpenBotEvent, OpenBotState, MemoryScopeAlias } from '../app/types.js';
+import {
+  OpenBotEvent,
+  OpenBotState,
+  MemoryScopeAlias,
+  TodoItem,
+  TodoStatus,
+  TodoWriteInput,
+} from '../app/types.js';
 import type { PluginRef } from './plugin.js';
 import { Storage } from './types.js';
 import { storageService } from '../services/storage.js';
 import { pluginService } from '../services/plugins.js';
 
+const readTodos = (state: OpenBotState): TodoItem[] => {
+  const raw = (state.threadDetails?.state as Record<string, unknown> | undefined)?.todos;
+  return Array.isArray(raw) ? (raw as TodoItem[]) : [];
+};
+
+let todoCounter = 0;
+const newTodoId = (now: number, idx: number): string =>
+  `todo_${now.toString(36)}_${(todoCounter++).toString(36)}_${idx}`;
+
+async function persistTodos(
+  storage: Storage,
+  state: OpenBotState,
+  todos: TodoItem[],
+): Promise<void> {
+  if (!state.threadId) throw new Error('No active thread');
+  await storage.patchThreadState({
+    channelId: state.channelId,
+    threadId: state.threadId,
+    state: { todos },
+  });
+  state.threadDetails = await storage.getThreadDetails({
+    channelId: state.channelId,
+    threadId: state.threadId,
+  });
+}
+
+
 /**
  * Resolve a scope alias to a concrete scope string. Aliases let tools accept
  * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
@@ -154,7 +188,7 @@ export const busServicesPlugin =
       builder.on('action:create_thread', async function* (event, context) {
         const threadId = event.meta?.threadId;
         const channelId = context.state.channelId;
-        const { threadTitle, spec, initialState } = (event as any).data;
+        const { threadTitle, initialState } = (event as any).data;
 
         if (!threadId) {
           console.warn('[bus] Cannot create thread: meta.threadId is missing');
@@ -169,7 +203,6 @@ export const busServicesPlugin =
               channelId,
               threadId,
               threadTitle,
-              spec,
               initialState: (initialState as Record<string, unknown>) || {},
             });
 
@@ -334,7 +367,7 @@ export const busServicesPlugin =
       });
 
       builder.on('action:patch_thread_details', async function* (event, context) {
-        const updatedFields: ('state' | 'spec')[] = [];
+        const updatedFields: ('state')[] = [];
         const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
         try {
           if (!context.state.threadId) {
@@ -348,14 +381,6 @@ export const busServicesPlugin =
             });
             updatedFields.push('state');
           }
-          if (typeof (event.data as any).spec === 'string') {
-            await storage.patchThreadSpec({
-              channelId: context.state.channelId,
-              threadId: context.state.threadId,
-              spec: (event.data as any).spec,
-            });
-            updatedFields.push('spec');
-          }
 
           context.state.threadDetails = await storage.getThreadDetails({
             channelId: context.state.channelId,
@@ -376,6 +401,102 @@ export const busServicesPlugin =
         }
       });
 
+      builder.on('action:todo_write', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        try {
+          if (!context.state.threadId) {
+            throw new Error('todo_write requires an active thread');
+          }
+          const existing = readTodos(context.state);
+          const byId = new Map(existing.map((t) => [t.id, t]));
+          const now = Date.now();
+          const author = context.state.agentId || 'system';
+
+          const inputs = (event.data as { todos: TodoWriteInput[] }).todos || [];
+          const next: TodoItem[] = inputs.map((raw, idx) => {
+            const prior = raw.id ? byId.get(raw.id) : undefined;
+            return {
+              id: prior?.id || raw.id || newTodoId(now, idx),
+              content: raw.content,
+              status: raw.status || prior?.status || 'pending',
+              assignee: raw.assignee ?? prior?.assignee,
+              createdBy: prior?.createdBy || author,
+              createdAt: prior?.createdAt || now,
+              updatedAt: now,
+              ...(prior?.result !== undefined ? { result: prior.result } : {}),
+            };
+          });
+
+          await persistTodos(storage, context.state, next);
+
+          yield {
+            type: 'action:todo_write:result',
+            data: { success: true, todos: next },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:todo_write:result',
+            data: {
+              success: false,
+              todos: readTodos(context.state),
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
+      builder.on('action:todo_update', async function* (event, context) {
+        const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+        const patch = event.data as {
+          id: string;
+          status?: TodoStatus;
+          content?: string;
+          assignee?: string;
+        };
+        try {
+          if (!context.state.threadId) {
+            throw new Error('todo_update requires an active thread');
+          }
+          const existing = readTodos(context.state);
+          const idx = existing.findIndex((t) => t.id === patch.id);
+          if (idx === -1) {
+            throw new Error(`Todo "${patch.id}" not found`);
+          }
+          const now = Date.now();
+          const updated: TodoItem = {
+            ...existing[idx],
+            ...(patch.content !== undefined ? { content: patch.content } : {}),
+            ...(patch.status !== undefined ? { status: patch.status } : {}),
+            ...(patch.assignee !== undefined
+              ? { assignee: patch.assignee === '' ? undefined : patch.assignee }
+              : {}),
+            updatedAt: now,
+          };
+          const next = [...existing];
+          next[idx] = updated;
+
+          await persistTodos(storage, context.state, next);
+
+          yield {
+            type: 'action:todo_update:result',
+            data: { success: true, todo: updated, todos: next },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        } catch (error) {
+          yield {
+            type: 'action:todo_update:result',
+            data: {
+              success: false,
+              todos: readTodos(context.state),
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+            meta: resultMeta,
+          } as OpenBotEvent;
+        }
+      });
+
       builder.on('action:storage:get-channels', async function* () {
         const channels = await storage.getChannels();
         yield { type: 'action:storage:get-channels-result', data: { channels } };

package/src/bus/types.ts

@@ -34,7 +34,6 @@ export type PluginDescriptor = {
   /** True when bundled with the core server (`src/registry/plugins`); false for ~/.openbot/plugins installs. */
   builtIn: boolean;
   image?: string;
-  defaultInstructions?: string;
   configSchema?: ConfigSchema;
   createdAt: Date;
   updatedAt: Date;
@@ -79,7 +78,6 @@ export type ThreadDetails = {
   id: string;
   name: string;
   channelId: string;
-  spec: string;
   state: unknown;
 };
 
@@ -104,7 +102,6 @@ export interface Storage {
     channelId: string;
     threadId: string;
     threadTitle?: string;
-    spec?: string;
     initialState?: Record<string, unknown>;
   }) => Promise<void>;
   getThreads: (args: { channelId: string }) => Promise<Thread[]>;
@@ -136,7 +133,6 @@ export interface Storage {
     state: unknown;
   }) => Promise<void>;
   patchChannelSpec: (args: { channelId: string; spec: string }) => Promise<void>;
-  patchThreadSpec: (args: { channelId: string; threadId: string; spec: string }) => Promise<void>;
   getVariables: () => Promise<Record<string, string | { value: string; secret: boolean }>>;
   createVariable: (args: { key: string; value: string; secret?: boolean }) => Promise<void>;
   deleteVariable: (args: { key: string }) => Promise<void>;

package/src/harness/context.ts

@@ -1,4 +1,4 @@
-import { OpenBotEvent, OpenBotState } from '../app/types.js';
+import { OpenBotEvent, OpenBotState, TodoItem } from '../app/types.js';
 import { Storage } from '../bus/types.js';
 
 /**
@@ -98,6 +98,7 @@ export function createDefaultContextEngine(): ContextEngine {
   engine.registerProvider(new AgentDetailsProvider());
   engine.registerProvider(new ChannelDetailsProvider());
   engine.registerProvider(new ThreadDetailsProvider());
+  engine.registerProvider(new TodoProvider());
   engine.registerProvider(new MemoryProvider());
   engine.registerProvider(new RecentEventsProvider());
 
@@ -110,11 +111,14 @@ class AgentDetailsProvider implements ContextProvider {
   name = 'agent-details';
   async provide(state: OpenBotState): Promise<ContextItem[]> {
     if (!state.agentDetails) return [];
+    const instructions = state.agentDetails.instructions?.trim();
+    if (!instructions) return [];
+
     return [{
       id: 'agent-details',
       type: 'agent',
       priority: 100,
-      content: `## AGENT NAME\n${state.agentDetails.name}\n\n## AGENT SPECIFICATION\n${state.agentDetails.instructions}`
+      content: `# ${state.agentDetails.name}\n\n${instructions}`,
     }];
   }
 }
@@ -123,11 +127,14 @@ class ChannelDetailsProvider implements ContextProvider {
   name = 'channel-details';
   async provide(state: OpenBotState): Promise<ContextItem[]> {
     if (!state.channelDetails) return [];
+    const spec = state.channelDetails.spec?.trim();
+    if (!spec) return [];
+
     return [{
       id: 'channel-details',
       type: 'channel',
       priority: 80,
-      content: `## CHANNEL NAME\n${state.channelDetails.name}\n\n## CHANNEL SPECIFICATION\n${state.channelDetails.spec}`
+      content: `# Channel you are in: ${state.channelDetails.name}\n\n Channel Specification: ${spec}`,
     }];
   }
 }
@@ -136,12 +143,68 @@ class ThreadDetailsProvider implements ContextProvider {
   name = 'thread-details';
   async provide(state: OpenBotState): Promise<ContextItem[]> {
     if (!state.threadDetails) return [];
-    return [{
-      id: 'thread-details',
-      type: 'thread',
-      priority: 90,
-      content: `## THREAD NAME\n${state.threadDetails.name}\n\n## THREAD SPECIFICATION\n${state.threadDetails.spec}`
-    }];
+
+    // For now, this provider is a placeholder for future state-based assembly.
+    // It currently only surfaces the thread name to provide basic context.
+    return [
+      {
+        id: 'thread-details',
+        type: 'thread',
+        priority: 90,
+        content: `# Thread you are in: ${state.threadDetails.name}`,
+      },
+    ];
+  }
+}
+
+/**
+ * Surfaces the shared per-thread todo list. The list lives in
+ * `threadDetails.state.todos` and is owned by bus services — every agent in
+ * the thread reads from the same canonical source, which is how multi-agent
+ * autonomous flows stay coordinated.
+ */
+class TodoProvider implements ContextProvider {
+  name = 'todos';
+  async provide(state: OpenBotState): Promise<ContextItem[]> {
+    const raw = (state.threadDetails?.state as Record<string, unknown> | undefined)?.todos;
+    const todos: TodoItem[] = Array.isArray(raw) ? (raw as TodoItem[]) : [];
+    if (todos.length === 0) return [];
+
+    const DISPLAY_RESULT_CAP = 2500;
+
+    const marker: Record<TodoItem['status'], string> = {
+      pending: '[ ]',
+      in_progress: '[~]',
+      done: '[x]',
+      cancelled: '[-]',
+    };
+    const formatted = todos
+      .map((t) => {
+        const assignee = t.assignee ? ` @${t.assignee}` : '';
+        let line = `- ${marker[t.status]} (${t.id})${assignee} ${t.content}`;
+        if (t.status === 'done' && t.result?.trim()) {
+          let snippet = t.result.trim();
+          if (snippet.length > DISPLAY_RESULT_CAP) {
+            snippet = `${snippet.slice(0, DISPLAY_RESULT_CAP)}…[truncated]`;
+          }
+          line += `\n  Result: ${snippet}`;
+        }
+        return line;
+      })
+      .join('\n');
+
+    return [
+      {
+        id: 'todos',
+        type: 'todos',
+        priority: 92,
+        content:
+          `## Shared todo plan (thread state)\n` +
+          `Orchestrator authors with \`todo_write\`; assignees run one step at a time. ` +
+          `When an item is \`done\`, its captured output appears below so every agent can see prior steps without relying on merged chat history.\n\n` +
+          `${formatted}`,
+      },
+    ];
   }
 }
 
@@ -175,7 +238,7 @@ class MemoryProvider implements ContextProvider {
           id: 'memory',
           type: 'memory',
           priority: 95,
-          content: `## REMEMBERED FACTS\nThese are durable facts you previously stored with the \`remember\` tool. Trust them unless contradicted by the user. Use \`forget\` to remove ones that are stale.\n\n${formatted}`,
+          content: `## Remembered facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
         },
       ];
     } catch (error) {