openbot 0.3.0 → 0.3.2

package/dist/harness/context.js

@@ -1,6 +1,15 @@
 /**
- * The core engine that orchestrates context building.
+ * Cheap, dependency-free token estimator. Roughly char/4 — fine for budget
+ * enforcement; can be swapped for a tokenizer-backed implementation later
+ * without touching providers.
  */
+export const estimateTokens = (text) => Math.ceil((text?.length ?? 0) / 4);
+/**
+ * Hard cap (in characters) on a single context item. Keeps any one provider
+ * — typically the recent-events feed — from monopolising the prompt budget.
+ */
+const ITEM_HARD_CHAR_CAP = 6000;
+const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars)}\n…[truncated]`;
 export class ContextEngine {
     constructor() {
         this.providers = [];
@@ -13,18 +22,18 @@ export class ContextEngine {
         this.processors.push(processor);
     }
     async buildContext(state, storage) {
-        // 1. Collect context from all providers
         let items = [];
         for (const provider of this.providers) {
             try {
                 const providedItems = await provider.provide(state, storage);
-                items.push(...providedItems);
+                for (const item of providedItems) {
+                    items.push({ ...item, content: truncate(item.content, ITEM_HARD_CHAR_CAP) });
+                }
             }
             catch (error) {
                 console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
             }
         }
-        // 2. Run through processors
         for (const processor of this.processors) {
             try {
                 items = await processor.process(items, state);
@@ -33,23 +42,26 @@ export class ContextEngine {
                 console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
             }
         }
-        // 3. Format items into a single string
         return items
             .sort((a, b) => b.priority - a.priority)
-            .map(item => item.content)
+            .map((item) => item.content)
             .join('\n\n');
     }
 }
 /**
- * Default implementation of a Context Engine with basic providers.
+ * Default context engine. Order of providers is by emit order; final ordering
+ * in the prompt is determined by `priority`. The token-budget processor runs
+ * last so dropping happens after every provider has contributed.
  */
 export function createDefaultContextEngine() {
     const engine = new ContextEngine();
-    // Basic Providers
     engine.registerProvider(new AgentDetailsProvider());
     engine.registerProvider(new ChannelDetailsProvider());
     engine.registerProvider(new ThreadDetailsProvider());
+    engine.registerProvider(new TodoProvider());
+    engine.registerProvider(new MemoryProvider());
     engine.registerProvider(new RecentEventsProvider());
+    engine.registerProcessor(new TokenBudgetProcessor());
     return engine;
 }
 class AgentDetailsProvider {
@@ -59,11 +71,14 @@ class AgentDetailsProvider {
     async provide(state) {
         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}`,
             }];
     }
 }
@@ -74,11 +89,14 @@ class ChannelDetailsProvider {
     async provide(state) {
         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}`,
             }];
     }
 }
@@ -89,14 +107,142 @@ class ThreadDetailsProvider {
     async provide(state) {
         if (!state.threadDetails)
             return [];
-        return [{
+        // 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 NAME\n${state.threadDetails.name}\n\n## THREAD SPECIFICATION\n${state.threadDetails.spec}`
-            }];
+                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 {
+    constructor() {
+        this.name = 'todos';
+    }
+    async provide(state) {
+        const raw = state.threadDetails?.state?.todos;
+        const todos = Array.isArray(raw) ? raw : [];
+        if (todos.length === 0)
+            return [];
+        const DISPLAY_RESULT_CAP = 2500;
+        const marker = {
+            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}`,
+            },
+        ];
     }
 }
+/**
+ * Fetches relevant memories (global + active agent + active channel) and
+ * surfaces them at high priority so the LLM treats them as ground truth
+ * rather than chat history.
+ */
+class MemoryProvider {
+    constructor() {
+        this.name = 'memory';
+    }
+    async provide(state, storage) {
+        if (!storage?.listMemories)
+            return [];
+        try {
+            const scopes = ['global', `agent:${state.agentId}`];
+            if (state.channelId)
+                scopes.push(`channel:${state.channelId}`);
+            const records = await storage.listMemories({ scopes, limit: 50 });
+            if (records.length === 0)
+                return [];
+            const formatted = records
+                .map((r) => {
+                const tags = r.tags?.length ? ` [${r.tags.join(', ')}]` : '';
+                const scopeLabel = r.scope === 'global' ? 'global' : r.scope;
+                return `- (${scopeLabel}${tags}) ${r.content}`;
+            })
+                .join('\n');
+            return [
+                {
+                    id: 'memory',
+                    type: 'memory',
+                    priority: 95,
+                    content: `## Remembered facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
+                },
+            ];
+        }
+        catch (error) {
+            console.warn('[ContextEngine] MemoryProvider failed:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Event types we omit from the recent-events context block. They duplicate
+ * information already in the conversation history, are infrastructural
+ * noise, or are too large to be useful as a tail summary.
+ */
+const NOISY_EVENT_PREFIXES = [
+    'agent:invoke',
+    'agent:output',
+    'agent:run',
+    'agent:active-runs',
+    'client:ui',
+    'stream:',
+    'action:storage:get-',
+    'action:storage:patch-',
+];
+const MAX_RECENT_EVENTS = 20;
+const MAX_EVENT_DATA_CHARS = 300;
+const isNoisyEvent = (event) => NOISY_EVENT_PREFIXES.some((prefix) => event.type.startsWith(prefix));
+const summarizeEvent = (event) => {
+    const data = event.data;
+    if (data === undefined)
+        return `- ${event.type}`;
+    let payload;
+    try {
+        payload = typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    catch {
+        payload = '[unserialisable]';
+    }
+    if (payload.length > MAX_EVENT_DATA_CHARS) {
+        payload = `${payload.slice(0, MAX_EVENT_DATA_CHARS)}…`;
+    }
+    return `- ${event.type}: ${payload}`;
+};
 class RecentEventsProvider {
     constructor() {
         this.name = 'recent-events';
@@ -104,28 +250,61 @@ class RecentEventsProvider {
     async provide(state, storage) {
         if (!storage)
             return [];
-        const items = [];
-        // Fetch channel events if no thread, otherwise fetch thread events
         const channelId = state.channelId;
         const threadId = state.threadId;
         try {
             const events = await storage.getEvents({ channelId, threadId });
-            if (events.length > 0) {
-                const formattedEvents = events
-                    .slice(-20)
-                    .map((e) => `- ${e.type}: ${JSON.stringify(e.data || {})}`)
-                    .join('\n');
-                items.push({
+            const filtered = events.filter((e) => !isNoisyEvent(e));
+            if (filtered.length === 0)
+                return [];
+            const formatted = filtered.slice(-MAX_RECENT_EVENTS).map(summarizeEvent).join('\n');
+            return [
+                {
                     id: threadId ? 'thread-events' : 'channel-events',
                     type: 'events',
                     priority: 70,
-                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formattedEvents}`
-                });
-            }
+                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formatted}`,
+                },
+            ];
         }
         catch (error) {
-            console.warn(`[ContextEngine] Failed to fetch events:`, error);
+            console.warn('[ContextEngine] Failed to fetch events:', error);
+            return [];
+        }
+    }
+}
+/**
+ * Drops the lowest-priority items until the assembled prompt fits within the
+ * token budget. The first item with priority >= `keepFloor` is always kept,
+ * so the agent's own instructions can never be evicted. Stable on ties:
+ * later-emitted items go first.
+ */
+export class TokenBudgetProcessor {
+    constructor(budget = TokenBudgetProcessor.DEFAULT_BUDGET, keepFloor = TokenBudgetProcessor.KEEP_FLOOR) {
+        this.budget = budget;
+        this.keepFloor = keepFloor;
+        this.name = 'token-budget';
+    }
+    async process(items) {
+        const sorted = [...items].sort((a, b) => b.priority - a.priority);
+        const out = [];
+        let used = 0;
+        for (const item of sorted) {
+            const cost = estimateTokens(item.content);
+            if (item.priority >= this.keepFloor) {
+                out.push(item);
+                used += cost;
+                continue;
+            }
+            if (used + cost <= this.budget) {
+                out.push(item);
+                used += cost;
+            }
         }
-        return items;
+        return out;
     }
 }
+/** Soft prompt budget in tokens (matches gpt-4o-mini's reasonable system slice). */
+TokenBudgetProcessor.DEFAULT_BUDGET = 8000;
+/** Items at or above this priority are never dropped. */
+TokenBudgetProcessor.KEEP_FLOOR = 100;

package/dist/harness/queue-processor.js

@@ -1,5 +1,6 @@
 import { ensureEventId } from '../app/utils.js';
 import { storageService } from '../services/storage.js';
+import { advanceAfterRun } from './todo-advance.js';
 export class QueueProcessor {
     constructor(options) {
         this.options = options;
@@ -26,33 +27,34 @@ export class QueueProcessor {
             await Promise.all(Array.from(groups.entries()).map(async ([agentId, items]) => {
                 // Run items for the SAME agent sequentially to preserve event order and state consistency.
                 for (const item of items) {
-                    const { event: currentEvent, delegationContext } = item;
-                    // Track delegation/handoff requests queued in this step to avoid accidental duplicates.
+                    const { event: currentEvent } = item;
+                    // Track handoff requests queued in this step to avoid accidental duplicates.
                     const queuedRequestKeys = new Set();
                     const queuedItems = [];
-                    const runOutputs = [];
+                    let lastAgentOutput;
                     const runOnEvent = async (chunk, state) => {
                         // 0. Filter out echoed input events to prevent duplication in the UI/storage
                         if (chunk.type === currentEvent.type && chunk.id === currentEvent.id) {
                             return false;
                         }
+                        if (chunk.type === 'agent:output') {
+                            const outMeta = chunk.meta;
+                            if (outMeta?.agentId === agentId) {
+                                const content = chunk.data?.content;
+                                if (typeof content === 'string' && content.trim()) {
+                                    lastAgentOutput = content.trim();
+                                }
+                            }
+                        }
                         // 1. Detect if a new thread was created and update the context for the rest of the loop
                         if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
                             this.currentThreadId = chunk.data.threadId || this.currentThreadId;
                         }
-                        // 2. Internal routing (handoff/delegation requests are internal — not forwarded)
-                        if (chunk.type === 'handoff:request' || chunk.type === 'delegation:request') {
-                            const isHandoff = chunk.type === 'handoff:request';
-                            const request = isHandoff
-                                ? chunk
-                                : chunk;
+                        // 2. Internal routing (handoff requests are internal — not forwarded)
+                        if (chunk.type === 'handoff:request') {
+                            const request = chunk;
                             const targetAgentId = request.data?.agentId;
-                            const toolCallId = typeof request.meta?.toolCallId === 'string'
-                                ? request.meta.toolCallId
-                                : undefined;
-                            const requestKey = isHandoff
-                                ? `handoff:${targetAgentId}:${request.data?.content ?? ''}`
-                                : `delegate:${toolCallId ?? 'missing'}:${targetAgentId}:${request.data?.content ?? ''}`;
+                            const requestKey = `handoff:${targetAgentId}`;
                             if (targetAgentId &&
                                 targetAgentId !== agentId &&
                                 !queuedRequestKeys.has(requestKey)) {
@@ -68,54 +70,10 @@ export class QueueProcessor {
                                         threadId: this.currentThreadId,
                                     },
                                 });
-                                if (isHandoff) {
-                                    queuedItems.push({ agentId: targetAgentId, event: targetEvent });
-                                }
-                                else {
-                                    if (!toolCallId) {
-                                        // Emit error output (this triggers run start if not already started)
-                                        await runOnEvent(ensureEventId({
-                                            type: 'agent:output',
-                                            data: {
-                                                content: 'Delegation request ignored: missing toolCallId. Please retry delegation.',
-                                            },
-                                            meta: {
-                                                agentId,
-                                                threadId: this.currentThreadId,
-                                            },
-                                        }), state);
-                                        return true;
-                                    }
-                                    const parentAgentId = typeof request.meta?.parentAgentId === 'string'
-                                        ? request.meta.parentAgentId
-                                        : agentId;
-                                    const delegationWidgetId = typeof request.meta?.delegationWidgetId === 'string'
-                                        ? request.meta.delegationWidgetId
-                                        : undefined;
-                                    queuedItems.push({
-                                        agentId: targetAgentId,
-                                        event: targetEvent,
-                                        delegationContext: {
-                                            parentAgentId,
-                                            toolCallId,
-                                            delegationWidgetId,
-                                        },
-                                    });
-                                }
+                                queuedItems.push({ agentId: targetAgentId, event: targetEvent });
                             }
                             return false;
                         }
-                        if (chunk.type === 'agent:output') {
-                            const content = chunk.data?.content;
-                            if (typeof content === 'string' && content.trim().length > 0) {
-                                runOutputs.push(content.trim());
-                            }
-                        }
-                        // For delegate mode, child agent execution is internal:
-                        // capture outputs for parent tool result, but don't stream child events to clients/storage.
-                        if (delegationContext) {
-                            return false;
-                        }
                         // If we get here, the event is accepted and should be emitted.
                         await this.options.onEvent(chunk, state);
                         return true;
@@ -133,7 +91,7 @@ export class QueueProcessor {
                             runId: this.options.runId,
                             agentId,
                             channelId: this.options.channelId,
-                            threadId: this.currentThreadId
+                            threadId: this.currentThreadId,
                         },
                     }, startState);
                     try {
@@ -160,60 +118,36 @@ export class QueueProcessor {
                                 runId: this.options.runId,
                                 agentId,
                                 channelId: this.options.channelId,
-                                threadId: this.currentThreadId
-                            },
-                        }, endState);
-                    }
-                    if (delegationContext) {
-                        const summary = runOutputs.length > 0
-                            ? runOutputs.join('\n\n').slice(0, 4000)
-                            : `Delegated agent "${agentId}" completed with no textual output.`;
-                        const delegateResultEvent = ensureEventId({
-                            type: 'action:delegate:result',
-                            data: {
-                                success: true,
-                                agentId,
-                                summary,
-                            },
-                            meta: {
-                                toolCallId: delegationContext.toolCallId,
-                                agentId: delegationContext.parentAgentId,
                                 threadId: this.currentThreadId,
                             },
-                        });
-                        if (delegationContext.delegationWidgetId) {
-                            await this.options.onEvent(ensureEventId({
-                                type: 'client:ui:widget',
-                                data: {
-                                    kind: 'message',
-                                    widgetId: delegationContext.delegationWidgetId,
-                                    title: `Delegation complete: ${agentId}`,
-                                    body: runOutputs.length > 0
-                                        ? 'Delegated task finished. Parent agent is preparing final response.'
-                                        : 'Delegated task finished with no textual output. Parent agent will continue.',
-                                    state: 'submitted',
-                                    metadata: {
-                                        type: 'delegation:status',
-                                        phase: 'completed',
-                                        delegatedAgentId: agentId,
-                                    },
-                                },
-                                meta: {
-                                    agentId: delegationContext.parentAgentId,
-                                    threadId: this.currentThreadId,
-                                },
-                            }), await storageService.getOpenBotState({
-                                runId: this.options.runId,
-                                agentId: delegationContext.parentAgentId,
+                        }, endState);
+                        // Autonomous todo advance: mark this agent's in_progress todo done
+                        // and dispatch the next assignee, if any. Single trigger point,
+                        // no reliance on the LLM remembering to call `todo_update`.
+                        try {
+                            const handoff = await advanceAfterRun({
+                                storage: storageService,
                                 channelId: this.options.channelId,
                                 threadId: this.currentThreadId,
-                                event: delegateResultEvent,
-                            }));
+                                endedAgentId: agentId,
+                                lastAgentOutput,
+                            });
+                            if (handoff) {
+                                const requestKey = `handoff:${handoff.agentId}`;
+                                if (!queuedRequestKeys.has(requestKey)) {
+                                    queuedRequestKeys.add(requestKey);
+                                    const targetEvent = ensureEventId({
+                                        type: 'agent:invoke',
+                                        data: { role: 'user', content: handoff.content },
+                                        meta: { threadId: this.currentThreadId },
+                                    });
+                                    queuedItems.push({ agentId: handoff.agentId, event: targetEvent });
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[queue] todo advance failed', error);
                         }
-                        nextQueue.push({
-                            agentId: delegationContext.parentAgentId,
-                            event: delegateResultEvent,
-                        });
                     }
                     nextQueue.push(...queuedItems);
                 }

package/dist/harness/runtime-factory.js

@@ -4,8 +4,8 @@ import { storageService } from '../services/storage.js';
 import { busServicesPlugin } from '../bus/services.js';
 /**
  * Enhances the agent's instructions with a list of other available agents the
- * orchestrator can hand off / delegate to. Agents that include the
- * `delegation` plugin will surface peers; agents without it can ignore this.
+ * orchestrator can hand off to. Agents that include the `delegation` plugin
+ * will surface peers; agents without it can ignore this.
  */
 export async function enhanceInstructions(state) {
     const { agentId, agentDetails } = state;
@@ -19,12 +19,16 @@ export async function enhanceInstructions(state) {
         const agentsList = otherAgents
             .map((a) => `- **${a.id}**${a.description ? `: ${a.description}` : ''}`)
             .join('\n');
-        const header = '### Available Agents for Handoff/Delegation:';
+        const header = '### Available Agents:';
         if (!agentDetails.instructions.includes(header)) {
-            agentDetails.instructions +=
-                `\n\n${header}\n${agentsList}\n\n` +
-                    'Use `handoff` to transfer control to another agent. ' +
-                    'Use `delegate` when you need a sub-result from another agent and want to continue after it returns.';
+            const hasHandoff = (agentDetails.pluginRefs || []).some((r) => r.id === 'delegation');
+            const hasTodo = (agentDetails.pluginRefs || []).some((r) => r.id === 'todo');
+            const usage = hasTodo
+                ? 'Use these ids as `assignee` when calling `todo_write` to plan multi-agent work.'
+                : hasHandoff
+                    ? 'Use `handoff` to transfer control to another agent in this thread.'
+                    : '';
+            agentDetails.instructions += `\n\n${header}\n${agentsList}${usage ? `\n\n${usage}` : ''}`;
         }
     }
     catch (error) {

package/dist/harness/todo-advance.js

@@ -0,0 +1,93 @@
+/** Stored on each todo and inlined into the next assignee's invoke payload. */
+const RESULT_MAX_CHARS = 12000;
+/**
+ * Shared helpers that drive the autonomous todo loop. The queue processor
+ * calls `advanceAfterRun` once per `agent:run:end`; that is the only place
+ * todos are completed and dispatched, which keeps the autonomous flow
+ * single-threaded and easy to reason about.
+ */
+export const readTodosFromState = (state) => {
+    const raw = state?.todos;
+    return Array.isArray(raw) ? raw : [];
+};
+export function truncateTodoResult(text, maxChars = RESULT_MAX_CHARS) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
+}
+/**
+ * Apply a single advance step:
+ *  1. If a todo is `in_progress` and `assignee` matches the agent whose run
+ *     just ended, mark it `done` and attach `result` from `lastOutput` when present.
+ *  2. Pick the next `pending` todo with an `assignee` and flip it to
+ *     `in_progress`. That assignee gets handed off to; `invoke content` includes
+ *     the previous step output when available so agents without short-term
+ *     history still see prior work.
+ *
+ * If a todo is already `in_progress` and the just-ended agent wasn't its
+ * assignee, leave it alone — someone else is working.
+ */
+export function advanceTodos(todos, endedAgentId, lastOutput) {
+    const now = Date.now();
+    const truncated = truncateTodoResult(lastOutput ?? '');
+    let completedOutput;
+    let working = todos.map((t) => {
+        if (t.status === 'in_progress' && t.assignee === endedAgentId) {
+            completedOutput = truncated;
+            return {
+                ...t,
+                status: 'done',
+                updatedAt: now,
+                ...(truncated !== undefined ? { result: truncated } : {}),
+            };
+        }
+        return t;
+    });
+    if (working.some((t) => t.status === 'in_progress')) {
+        return { todos: working, handoff: null };
+    }
+    const idx = working.findIndex((t) => t.status === 'pending' && t.assignee);
+    if (idx === -1)
+        return { todos: working, handoff: null };
+    const picked = working[idx];
+    working = working.map((t, i) => i === idx ? { ...t, status: 'in_progress', updatedAt: now } : t);
+    const invokeContent = completedOutput !== undefined && completedOutput !== ''
+        ? `${picked.content}\n\n--- Output from previous step ---\n${completedOutput}`
+        : picked.content;
+    return {
+        todos: working,
+        handoff: {
+            agentId: picked.assignee,
+            content: invokeContent,
+            todoId: picked.id,
+        },
+    };
+}
+export async function advanceAfterRun(options) {
+    const { storage, channelId, threadId, endedAgentId, lastAgentOutput } = options;
+    if (!threadId)
+        return null;
+    const details = await storage.getThreadDetails({ channelId, threadId });
+    const todos = readTodosFromState(details?.state);
+    if (todos.length === 0)
+        return null;
+    const { todos: nextList, handoff } = advanceTodos(todos, endedAgentId, lastAgentOutput);
+    const changed = nextList.length !== todos.length ||
+        nextList.some((t, i) => {
+            const u = todos[i];
+            if (!u)
+                return true;
+            return (t.status !== u.status ||
+                t.updatedAt !== u.updatedAt ||
+                t.result !== u.result ||
+                t.assignee !== u.assignee ||
+                t.content !== u.content);
+        });
+    if (changed) {
+        await storage.patchThreadState({ channelId, threadId, state: { todos: nextList } });
+    }
+    return handoff;
+}