@meetopenbot/openbot 1.8.0 → 1.10.0

package/dist/build-tools.js

@@ -2,16 +2,27 @@ import { memoryTools } from "./tools/memory.js";
 import { todoTools } from "./tools/todo.js";
 import { storageTools } from "./tools/storage.js";
 import { startThreadTools } from "./tools/start-thread.js";
+import { tasksTools } from "./tools/tasks.js";
 import { askAgentTools } from "./tools/ask-agent.js";
 import { askUserTools } from "./tools/ask-user.js";
 import { installAgentTools } from "./tools/install-agent.js";
-import { threadStatusTools } from "./tools/thread-status.js";
 import { threadTitleTools } from "./tools/thread-title.js";
 import { previewTools } from "./tools/preview.js";
 import { variablesRequestTools } from "./tools/variables-request.js";
 import { renderWidgetTools } from "./tools/render-widget.js";
 import { wrapToolsWithApproval } from "./tools/approval.js";
+import { isConversationThread } from "./conversation.js";
 export const DEFAULT_APPROVAL_ACTIONS = ["update_channel_spec", "start_thread"];
+/**
+ * A Space conversation answers inline or starts tasks; specialist work, todos,
+ * and job title/status belong to the task.
+ */
+export const CONVERSATION_EXCLUDED_TOOLS = [
+    "ask_agent",
+    "todo_write",
+    "todo_read",
+    "set_thread_title",
+];
 /**
  * Merge first-party OpenBot coordinator tools and wrap configured actions
  * with approval.
@@ -22,10 +33,10 @@ export function buildOpenbotTools(args) {
         ...todoTools,
         ...storageTools,
         ...startThreadTools,
+        ...tasksTools,
         ...askAgentTools,
         ...askUserTools,
         ...installAgentTools,
-        ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
         ...variablesRequestTools,
@@ -33,5 +44,12 @@ export function buildOpenbotTools(args) {
         ...args.context.tools,
     };
     const approvalConfig = args.context.config?.approval;
-    return wrapToolsWithApproval(tools, approvalConfig?.actions ?? DEFAULT_APPROVAL_ACTIONS, args.context);
+    const conversation = isConversationThread(args.threadId);
+    if (conversation) {
+        for (const name of CONVERSATION_EXCLUDED_TOOLS)
+            delete tools[name];
+    }
+    // Starting tasks is what a Space conversation is for, so it does not ask first.
+    const actions = (approvalConfig?.actions ?? DEFAULT_APPROVAL_ACTIONS).filter((action) => !(action === "start_thread" && conversation));
+    return wrapToolsWithApproval(tools, actions, args.context);
 }

package/dist/context.js

@@ -2,6 +2,8 @@ import { formatGitIdentity, readGitIdentity, } from "@meetopenbot/plugin-sdk";
 import { formatAvailableAgentsSection, formatInstalledAgentsSection, loadAgentModelCatalogs, availableMarketplaceAgents, } from "./agent-models.js";
 import { todoService } from "./tools/todo-service.js";
 import { readInvokeSurface, surfaceSection } from "./surface.js";
+import { CONVERSATION_INSTRUCTIONS, isConversationThread } from "./conversation.js";
+import { buildTasksSection } from "./tasks.js";
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -63,23 +65,8 @@ export async function buildContext(state, storage, host) {
         env += `- Thread: ${threadDetails?.name || threadId}\n`;
     }
     sections.push(env);
-    if (threadId) {
-        const threadState = threadDetails?.state && typeof threadDetails.state === "object"
-            ? threadDetails.state
-            : undefined;
-        const threadStatus = typeof threadState?.status === "string" && threadState.status.trim()
-            ? threadState.status.trim()
-            : "completed";
-        const threadStatusReason = typeof threadState?.statusReason === "string" && threadState.statusReason.trim()
-            ? threadState.statusReason.trim()
-            : undefined;
-        let statusSection = `## THREAD STATUS\n- Status: ${threadStatus}`;
-        if (threadStatusReason) {
-            statusSection += `\n- Reason: ${threadStatusReason}`;
-        }
-        statusSection +=
-            "\nUse `set_thread_status` to update this. needs_input when blocked on the human; ready_for_review when you believe the job is done; working when the job is still in progress. Never set completed or archived.";
-        sections.push(statusSection);
+    if (isConversationThread(threadId)) {
+        sections.push(CONVERSATION_INSTRUCTIONS);
     }
     const invokeData = state.triggerEvent?.type === "agent:invoke"
         ? state.triggerEvent.data
@@ -111,6 +98,17 @@ export async function buildContext(state, storage, host) {
             console.warn("[context] Failed to fetch todos:", error);
         }
     }
+    // 2.55 Tasks this thread started
+    if (!surface && channelId && threadId) {
+        try {
+            const tasks = await buildTasksSection(storage, host, { channelId, threadId });
+            if (tasks)
+                sections.push(tasks);
+        }
+        catch (error) {
+            console.warn("[context] Failed to fetch tasks:", error);
+        }
+    }
     // 2.6 Installed Agents
     const otherAgents = allAgents.filter((agent) => agent.id !== agentId);
     if (otherAgents.length > 0) {

package/dist/conversation.js

@@ -0,0 +1,79 @@
+/**
+ * Reserved thread that holds a Space's own conversation with OpenBot. The
+ * runtime keeps the same id; task listings skip it.
+ */
+export const CONVERSATION_THREAD_ID = 'conversation';
+export function isConversationThread(threadId) {
+    return threadId === CONVERSATION_THREAD_ID;
+}
+/** Added to a Space conversation's context: it is a chat, not a task. */
+export const CONVERSATION_INSTRUCTIONS = [
+    '## CONVERSATION',
+    "This is the Space's main conversation with the human, not a task. It has no title and keeps going across many requests. The JOB TITLE rules do not apply here.",
+    '- **Answer inline** when the reply needs no specialist and takes no lasting work: questions, explanations, advice, short drafts, status of Spaces or tasks, quick lookups, and setup questions.',
+    '- **Task status**: when the human asks how a task went, answer from `## TASKS`; call `get_task` for its full last reply, or `list_tasks` when it is not listed. Never say you cannot see a task before checking.',
+    '- **Start a task** with `start_thread` when the request needs a specialist (build, code, files, design, research, ops), runs long, or should be tracked on its own. Pick the Space it belongs to from `## SPACES`; the current Space is a valid target. You cannot ask specialists from here — the task does that.',
+    '- One request, one task. Several independent requests become several tasks. Follow-ups to an existing task belong in that task; tell the human to continue there instead of starting a duplicate.',
+    '- After `start_thread`, reply in one short sentence. The human sees a live card for the task; do not restate the request or promise progress updates.',
+    '- If you are unsure whether the human wants a task, ask in one line instead of starting one.',
+].join('\n');
+/** Human turns kept verbatim when a Space conversation is replayed to the model. */
+export const CONVERSATION_KEPT_TURNS = 20;
+const DIGEST_MESSAGE_LIMIT = 30;
+const DIGEST_TEXT_LIMIT = 200;
+function isHumanTurn(event) {
+    if (event.type !== 'agent:invoke' || event.meta?.parentToolCallId)
+        return false;
+    return event.data?.role === 'user';
+}
+function clip(text) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > DIGEST_TEXT_LIMIT ? `${flat.slice(0, DIGEST_TEXT_LIMIT)}…` : flat;
+}
+function startedTask(event) {
+    if (event.type !== 'client:ui:widget')
+        return null;
+    const data = event.data;
+    if (data?.metadata?.type !== 'thread_started' || data.state !== 'submitted')
+        return null;
+    const { channelId, threadId, title } = data.metadata;
+    if (typeof channelId !== 'string' || typeof threadId !== 'string')
+        return null;
+    return { channelId, threadId, ...(typeof title === 'string' && title ? { title } : {}) };
+}
+/**
+ * Keeps the last {@link CONVERSATION_KEPT_TURNS} human turns (and everything
+ * after the first of them) and folds older history into a plain-text digest:
+ * what the human asked and which tasks were started. No model call.
+ */
+export function compactConversation(events, keptTurns = CONVERSATION_KEPT_TURNS) {
+    const turnStarts = [];
+    events.forEach((event, index) => {
+        if (isHumanTurn(event))
+            turnStarts.push(index);
+    });
+    if (turnStarts.length <= keptTurns)
+        return { events, digest: '' };
+    const cut = turnStarts[turnStarts.length - keptTurns];
+    const dropped = events.slice(0, cut);
+    const asked = dropped
+        .filter(isHumanTurn)
+        .map((event) => clip(String(event.data.content ?? '')))
+        .filter(Boolean)
+        .slice(-DIGEST_MESSAGE_LIMIT);
+    const tasks = dropped
+        .map(startedTask)
+        .filter((task) => task !== null)
+        .slice(-DIGEST_MESSAGE_LIMIT);
+    const lines = [
+        '## EARLIER IN THIS CONVERSATION',
+        'Older messages were compacted. This is what remains of them; ask the human if you need more.',
+    ];
+    if (asked.length > 0) {
+        lines.push('Human asked:', ...asked.map((text) => `- ${text}`));
+    }
+    if (tasks.length > 0) {
+        lines.push('Tasks started:', ...tasks.map((task) => `- ${task.title ?? 'Untitled'} — #${task.channelId}, thread ${task.threadId}`));
+    }
+    return { events: events.slice(cut), digest: lines.join('\n') };
+}

package/dist/fast-forward.js

@@ -14,8 +14,8 @@ const SELF_ANSWER_QUESTION = 'openbot_should_answer';
 export const FAST_FORWARD_CLOSE_HINT = [
     '## THIS TURN',
     'You already asked the specialist. Do not call ask_agent again.',
-    'If they finished, close in one or two sentences and set ready_for_review.',
-    'If they are blocked on the human, set needs_input.',
+    'If they finished, close in one or two sentences.',
+    'If they are blocked on the human, ask with `ask_user`.',
     'If they failed, say what blocked them.',
     'Do not restate a successful reply.',
 ].join('\n');

package/dist/index.js

@@ -8,7 +8,6 @@ import { todoTools } from './tools/todo.js';
 import { storageTools } from './tools/storage.js';
 import { askAgentTools } from './tools/ask-agent.js';
 import { installAgentTools } from './tools/install-agent.js';
-import { threadStatusTools } from './tools/thread-status.js';
 import { threadTitleTools } from './tools/thread-title.js';
 import { previewTools } from './tools/preview.js';
 import { variablesRequestTools } from './tools/variables-request.js';
@@ -50,7 +49,6 @@ export const openbotPlugin = defineOpenbotPlugin({
         ...storageTools,
         ...askAgentTools,
         ...installAgentTools,
-        ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
         ...variablesRequestTools,
@@ -61,7 +59,7 @@ export const openbotPlugin = defineOpenbotPlugin({
         const authMode = context.host.isCloudSystemAgent(context.agentId)
             ? context.host.parseOpenbotAuthMode(context.config?.authMode)
             : 'byok';
-        const toolDefinitions = buildOpenbotTools({ context });
+        const toolDefinitions = buildOpenbotTools({ context, threadId: args.threadId });
         yield* runOpenbotTurn(args, {
             model: context.config?.model || AUTO_MODEL_ID,
             authMode,

package/dist/runtime.js

@@ -12,6 +12,7 @@ import { reasoningForModel, resolveModel } from './model.js';
 import { errorFromStreamPart } from './stream-error.js';
 import { createAgentOutputBuffer, isOutputBoundaryPart } from './output-buffer.js';
 import { threadNamingHint } from './thread-naming.js';
+import { compactConversation, isConversationThread } from './conversation.js';
 import { readInvokeSurface, RESPOND_TOOL, surfaceTools } from './surface.js';
 async function buildSystemPrompt(state, storage, instructions, host) {
     const context = await buildContext(state, storage, host);
@@ -20,7 +21,8 @@ async function buildSystemPrompt(state, storage, instructions, host) {
         '',
         context,
     ];
-    if (!readInvokeSurface(state.triggerEvent)) {
+    // A Space conversation is a chat, not a job: it never gets a title.
+    if (!readInvokeSurface(state.triggerEvent) && !isConversationThread(state.threadId)) {
         const threadState = state.threadDetails?.state;
         sections.push(...threadNamingHint(threadState));
     }
@@ -202,7 +204,6 @@ async function* attemptFastForward(args, options) {
         data: { content: `Asking ${candidate.agentName}.` },
         meta: { agentId: args.context.agentId, threadId: args.threadId },
     };
-    await executeCoordinatorTool(args, options.tools, 'set_thread_status', { status: 'working' });
     const titleTask = (async () => {
         const threadState = args.state.threadDetails?.state;
         if (!threadNeedsGeneratedTitle(threadState))
@@ -239,12 +240,21 @@ export async function* runOpenbotTurn(args, options) {
     state.model = configuredModelString;
     const threadId = args.threadId || state.threadId;
     let systemPrompt = await buildSystemPrompt(state, storage, instructions, host);
+    // A Space conversation runs indefinitely; replay only its recent turns plus a digest.
+    const compactHistory = (loaded) => {
+        if (surface || !isConversationThread(threadId))
+            return loaded;
+        const compacted = compactConversation(loaded);
+        if (compacted.digest)
+            systemPrompt = `${systemPrompt}\n\n${compacted.digest}`;
+        return compacted.events;
+    };
     let events = surface
         ? [args.event]
-        : await storage.getEvents({
+        : compactHistory(await storage.getEvents({
             channelId: state.channelId ?? '',
             threadId,
-        });
+        }));
     const hasAttachments = eventsHaveAttachments(events);
     const candidates = chooseTurnCandidates({ model: configuredModelString, events, authMode });
     const readImage = async (name) => {
@@ -293,11 +303,11 @@ export async function* runOpenbotTurn(args, options) {
         if (abortSignal?.aborted)
             return;
         if (forwarded) {
-            events = await storage.getEvents({
+            systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
+            events = compactHistory(await storage.getEvents({
                 channelId: state.channelId ?? '',
                 threadId,
-            });
-            systemPrompt = `${await buildSystemPrompt(state, storage, instructions, host)}\n\n${FAST_FORWARD_CLOSE_HINT}`;
+            }));
         }
         // Messages the human sent while this run is going. They join the conversation
         // before the next model step, like a reply typed between tool calls, and stay in

package/dist/system-prompt.js

@@ -15,7 +15,7 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "# THE AGENT LOOP",
     "You operate in an iterative loop:",
     "1. **Analyze Events**: Understand the human, mentioned people, the current Space, and `## SPACES`.",
-    "2. **Right Space**: Every Space, `#general` included, is a place to do work. Do it in the current Space by default. Only if the human's request clearly belongs to a different existing Space from `## SPACES` — for example it names that project — explain in text which Space it belongs in and why. Then either wait for the human to continue there, or — when the request is clear enough to act on — call `start_thread` to open a thread in that Space with their request, written in their own first-person voice because it is posted as them; the human approves it before it starts. Never start a thread in the Space you are already in. Otherwise continue here with `ask_agent`. Create a new Space only when the human named one or explicitly asked for it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`).",
+    "2. **Right Space**: Every Space, `#general` included, is a place to do work. Do it in the current Space by default. Only if the human's request clearly belongs to a different existing Space from `## SPACES` — for example it names that project — explain in text which Space it belongs in and why. Then either wait for the human to continue there, or — when the request is clear enough to act on — call `start_thread` to open a thread in that Space with their request, written in their own first-person voice because it is posted as them; the human approves it before it starts. Inside a task, never start a thread in the Space you are already in; otherwise continue there with `ask_agent`. In a Space conversation (`## CONVERSATION`), follow its rules instead: answer inline or start a task with `start_thread`. Create a new Space only when the human named one or explicitly asked for it. Never invent placeholder ids (`noop`, `temp`, `misc`, `untitled`).",
     "3. **Ask people**: Use `ask_agent` to send a message to a specialist. Write it as a request to a colleague, not as a tool invocation.",
     "4. **Wait**: Let the asked agent run in its own harness. Read their reply, then continue or ask someone else.",
     "5. **Close**: Write one short final message when the task is done or blocked. The human already saw the specialist speak in this thread. Do not restate, re-bullet, or paraphrase their findings. Name who you asked, then add only what is new — a decision, a conflict, a next step, or a caveat. If nothing is new, close in one or two sentences. Never post progress recaps between steps; the todo list shows progress.",
@@ -47,13 +47,6 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "- Call `set_thread_title` again only if the topic clearly changes.",
     "- Never re-title a job the user renamed.",
     "",
-    "# JOB STATUS",
-    "- Every thread is a job. Status is `working` (in progress), `needs_input`, `ready_for_review`, `completed`, or `archived`.",
-    "- Status is the job's workflow state, not whether an agent is currently executing.",
-    "- `ask_user`, `request_variables`, and connect cards set `needs_input` while they wait; do not set it yourself for those.",
-    "- When you believe the job is done, set `ready_for_review`. Never set `completed` or `archived` — only the human can.",
-    "- The current status is injected each turn as `## THREAD STATUS`.",
-    "",
     "# OPERATIONAL GUIDELINES",
     '- **Spaces**: Work lives in Spaces (product name for channels). `#general` is the default Space and works like any other. Prefer existing Spaces. When the request clearly belongs to another existing Space, explain the appropriate Space in text, then let them continue there or hand it over with `start_thread`. Never auto-move threads or messages; `start_thread` opens a new thread and leaves this one in place. Create a new Space only when the human asked for one, or they agreed after you suggested it.',
     "- **Asking**: You ask specialists with `ask_agent`. If `## MENTIONED AGENTS` is present, you MUST ask those people. You may also ask others if needed. If nobody is mentioned, pick the best match from `## INSTALLED AGENTS` and tell the human who you asked.",

package/dist/tasks.js

@@ -0,0 +1,169 @@
+/** Tasks listed in `## TASKS`; older ones are a `list_tasks` call away. */
+export const TASKS_SECTION_LIMIT = 10;
+const SECTION_RESULT_CHARS = 200;
+function clip(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max).trimEnd()}…` : flat;
+}
+export function withRunning(thread, host) {
+    const running = host?.isThreadRunning?.({
+        channelId: thread.channelId,
+        threadId: thread.id,
+    });
+    return typeof running === "boolean" ? { ...thread, running } : thread;
+}
+/**
+ * Where the task stands, in words. A task stays `working` after its run ends
+ * until someone moves it on, so the last run's outcome decides what that means.
+ */
+export function describeTaskState(task) {
+    const reason = task.statusReason ? `: ${task.statusReason}` : "";
+    // A run waiting on the human's answer is still "running"; the wait matters more.
+    if (task.status === "needs_input")
+        return `waiting for the human${reason}`;
+    if (task.running)
+        return "running now";
+    switch (task.status) {
+        case "ready_for_review":
+            return `ready for review${reason}`;
+        case "completed":
+            return "completed";
+        case "archived":
+            return "archived";
+    }
+    if (task.running === undefined)
+        return "working";
+    const result = task.result;
+    if (!result)
+        return "not running, no result recorded";
+    if (result.error)
+        return `last run failed: ${clip(result.error, SECTION_RESULT_CHARS)}`;
+    if (result.stopped)
+        return "stopped by the human";
+    return "last run finished";
+}
+function formatTaskLine(task) {
+    const title = task.name && task.name !== task.id ? task.name : "Untitled";
+    const lines = [
+        `- ${title} — #${task.channelId}, thread ${task.id} — ${describeTaskState(task)}`,
+    ];
+    const summary = task.result?.summary;
+    if (summary && !task.running) {
+        lines.push(`  Last reply: ${clip(summary, SECTION_RESULT_CHARS)}`);
+    }
+    return lines.join("\n");
+}
+export function formatTasksSection(tasks) {
+    if (tasks.length === 0)
+        return "";
+    return [
+        "## TASKS",
+        "Tasks started from this conversation, most recently active first. Answer questions about them from this list. Call `get_task` for a task's full last reply, and `list_tasks` for older tasks or tasks in other Spaces.",
+        ...tasks.map(formatTaskLine),
+    ].join("\n");
+}
+export function isFromOrigin(task, origin) {
+    return task.origin?.channelId === origin.channelId && task.origin?.threadId === origin.threadId;
+}
+export async function listTasks(storage, host, args) {
+    const page = await storage.getThreads({ sort: "updatedAt", order: "desc", ...args });
+    return { tasks: page.items.map((thread) => withRunning(thread, host)), total: page.total };
+}
+/** The `## TASKS` section for a thread, or "" when it started none. */
+export async function buildTasksSection(storage, host, origin) {
+    if (!storage?.getThreads)
+        return "";
+    const { tasks } = await listTasks(storage, host, {
+        origin,
+        limit: TASKS_SECTION_LIMIT,
+    });
+    // Older runtimes ignore the origin filter and list every thread.
+    return formatTasksSection(tasks.filter((task) => isFromOrigin(task, origin)));
+}
+const STATUSES = [
+    "working",
+    "needs_input",
+    "ready_for_review",
+    "completed",
+    "archived",
+];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+/** Reads a task from its thread `state.json`, as `getThreadDetails` returns it. */
+export function taskFromState(channelId, threadId, rawState) {
+    const state = isRecord(rawState) ? rawState : {};
+    const status = STATUSES.find((value) => value === state.status) ?? "completed";
+    const statusReason = text(state.statusReason);
+    const origin = isRecord(state.origin) ? state.origin : undefined;
+    const originChannelId = text(origin?.channelId);
+    const originThreadId = text(origin?.threadId);
+    const result = isRecord(state.result) ? state.result : undefined;
+    const endedAt = text(result?.endedAt);
+    const error = text(result?.error);
+    const preview = isRecord(state.preview) ? state.preview : undefined;
+    const firstMessage = text(preview?.content);
+    const latestAgentOutput = text(preview?.latestAgentOutput);
+    const updatedAt = text(state.statusUpdatedAt);
+    return {
+        id: threadId,
+        name: text(state.name) ?? threadId,
+        channelId,
+        createdAt: new Date(0),
+        updatedAt: updatedAt ? new Date(updatedAt) : new Date(0),
+        status,
+        ...(statusReason ? { statusReason } : {}),
+        ...(originChannelId && originThreadId
+            ? { origin: { channelId: originChannelId, threadId: originThreadId } }
+            : {}),
+        ...(result && endedAt
+            ? {
+                result: {
+                    summary: text(result.summary) ?? "",
+                    endedAt,
+                    ...(error ? { error } : {}),
+                    ...(result.stopped === true ? { stopped: true } : {}),
+                },
+            }
+            : {}),
+        ...(firstMessage
+            ? {
+                preview: {
+                    content: firstMessage,
+                    ...(latestAgentOutput ? { latestAgentOutput } : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function formatTaskList(tasks, total) {
+    if (tasks.length === 0)
+        return "No tasks match.";
+    const more = total > tasks.length ? `\n(${total - tasks.length} more not shown.)` : "";
+    return `${tasks.map(formatTaskLine).join("\n")}${more}`;
+}
+/** Everything `get_task` reports: state, the request, the last run's reply, and todos. */
+export function formatTaskDetail(task, todos = []) {
+    const title = task.name && task.name !== task.id ? task.name : "Untitled";
+    const lines = [
+        `Task: ${title} — #${task.channelId}, thread ${task.id}`,
+        `State: ${describeTaskState(task)}`,
+    ];
+    if (task.preview?.content)
+        lines.push(`Request: ${clip(task.preview.content, 600)}`);
+    if (task.result) {
+        lines.push(`Last run ended: ${task.result.endedAt}`);
+        if (task.result.summary)
+            lines.push(`Last reply:\n${task.result.summary}`);
+    }
+    else if (task.preview?.latestAgentOutput) {
+        lines.push(`Latest reply so far:\n${task.preview.latestAgentOutput}`);
+    }
+    if (todos.length > 0) {
+        lines.push("Todos:", ...todos.map((todo) => `- [${todo.status}] ${todo.content}`));
+    }
+    return lines.join("\n");
+}

package/dist/tools/start-thread.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import z from 'zod';
 import { isPlaceholderSpaceId } from '../space-id.js';
 import { normalizeChannelId } from './storage.js';
+import { isConversationThread } from '../conversation.js';
 async function emitStartThreadWidget(ctx, args) {
     const actions = args.state === 'submitted' && args.threadUrl
         ? [
@@ -24,7 +25,13 @@ async function emitStartThreadWidget(ctx, args) {
             display: args.state === 'submitted' ? 'expanded' : 'collapsed',
             state: args.state,
             ...(actions ? { actions } : {}),
-            metadata: { type: 'thread_started', channelId: args.channelId || undefined },
+            metadata: {
+                type: 'thread_started',
+                channelId: args.channelId || undefined,
+                // The task card follows this thread's live status.
+                ...(args.threadId ? { threadId: args.threadId } : {}),
+                ...(args.title ? { title: args.title } : {}),
+            },
         },
         meta: {
             agentId: ctx.agentId,
@@ -35,7 +42,7 @@ async function emitStartThreadWidget(ctx, args) {
 }
 export const startThreadTools = {
     start_thread: {
-        description: "Start a new thread in another existing Space and hand the human's request to that Space's agent. Use when work asked here clearly belongs in a different Space from `## SPACES`. The new thread runs on its own; the human follows it there. Never use it for the Space you are already in.",
+        description: "Start a new thread (task) in an existing Space and hand the human's request to that Space's agent. From a Space conversation (`## CONVERSATION`), use it for every real piece of work, in the current Space or another one. From inside a task, use it only when work clearly belongs in a different Space from `## SPACES`. The new thread runs on its own; the human follows it there.",
         inputSchema: z.object({
             channelId: z.string().describe('Existing Space id from `## SPACES` (e.g. backend-platform).'),
             prompt: z
@@ -69,7 +76,8 @@ export const startThreadTools = {
             if (isPlaceholderSpaceId(targetChannelId)) {
                 return fail(`Refused to start a thread in #${targetChannelId}: that is not a real Space.`);
             }
-            if (targetChannelId === (ctx.channelId ?? ctx.state.channelId)) {
+            const fromConversation = isConversationThread(ctx.threadId ?? ctx.state.threadId);
+            if (!fromConversation && targetChannelId === (ctx.channelId ?? ctx.state.channelId)) {
                 return fail(`You are already in #${targetChannelId}. Continue here instead of starting a thread.`);
             }
             if (!ctx.host.startThreadRun) {
@@ -84,16 +92,22 @@ export const startThreadTools = {
             await emitStartThreadWidget(ctx, {
                 widgetId,
                 channelId: targetChannelId,
+                threadId,
                 title: threadTitle,
                 body: 'Starting…',
                 state: 'open',
             });
+            const originChannelId = ctx.channelId ?? ctx.state.channelId;
+            const originThreadId = ctx.threadId ?? ctx.state.threadId;
             try {
                 await ctx.storage.createThread({
                     channelId: targetChannelId,
                     threadId,
                     ...(threadTitle ? { threadTitle } : {}),
-                    initialState: {},
+                    // Lets the thread that started it list it under `## TASKS`.
+                    initialState: originChannelId && originThreadId
+                        ? { origin: { channelId: originChannelId, threadId: originThreadId } }
+                        : {},
                 });
                 const { agentId } = await ctx.host.startThreadRun({
                     channelId: targetChannelId,
@@ -103,6 +117,7 @@ export const startThreadTools = {
                 await emitStartThreadWidget(ctx, {
                     widgetId,
                     channelId: targetChannelId,
+                    threadId,
                     title: threadTitle,
                     body: `Started a thread in #${targetChannelId}.`,
                     state: 'submitted',

package/dist/tools/tasks.js

@@ -0,0 +1,89 @@
+import z from "zod";
+import { normalizeChannelId } from "./storage.js";
+import { todoService } from "./todo-service.js";
+import { formatTaskDetail, formatTaskList, listTasks, taskFromState, withRunning, } from "../tasks.js";
+const LIST_DEFAULT_LIMIT = 20;
+const LIST_MAX_LIMIT = 50;
+const STATUS_VALUES = [
+    "working",
+    "needs_input",
+    "ready_for_review",
+    "completed",
+    "archived",
+];
+export const tasksTools = {
+    list_tasks: {
+        description: "List tasks (threads) with their state and last reply, most recently active first. Use it when a task the human asks about is not in `## TASKS`, or to see tasks in a Space. Read-only.",
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .optional()
+                .describe("Space id from `## SPACES`. Omit to list tasks in every Space."),
+            fromThisThread: z
+                .boolean()
+                .optional()
+                .describe("Only tasks started from the current thread with `start_thread`."),
+            status: z
+                .array(z.enum(STATUS_VALUES))
+                .optional()
+                .describe("Only these statuses. Archived tasks are left out unless listed here."),
+            limit: z.number().int().min(1).max(LIST_MAX_LIMIT).optional(),
+        }),
+        execute: async (raw, ctx) => {
+            const args = (raw ?? {});
+            try {
+                const channelId = args.channelId ? normalizeChannelId(args.channelId) : undefined;
+                const currentChannelId = ctx.channelId ?? ctx.state.channelId;
+                const currentThreadId = ctx.threadId ?? ctx.state.threadId;
+                const origin = args.fromThisThread && currentChannelId && currentThreadId
+                    ? { channelId: currentChannelId, threadId: currentThreadId }
+                    : undefined;
+                const { tasks, total } = await listTasks(ctx.storage, ctx.host, {
+                    ...(channelId ? { channelId } : {}),
+                    ...(origin ? { origin } : {}),
+                    ...(args.status?.length ? { status: args.status, excludeStatus: [] } : {}),
+                    limit: Math.min(args.limit ?? LIST_DEFAULT_LIMIT, LIST_MAX_LIMIT),
+                });
+                return { success: true, total, output: formatTaskList(tasks, total) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                return { success: false, error: message, output: `Failed to list tasks: ${message}` };
+            }
+        },
+    },
+    get_task: {
+        description: "Read one task: its state, the request, the full last reply, and its todos. Use it to answer how a task went. Read-only.",
+        inputSchema: z.object({
+            channelId: z.string().describe("The task's Space id."),
+            threadId: z.string().describe("The task's thread id."),
+        }),
+        execute: async (raw, ctx) => {
+            const args = (raw ?? {});
+            const channelId = normalizeChannelId(args.channelId ?? "");
+            const threadId = typeof args.threadId === "string" ? args.threadId.trim() : "";
+            if (!channelId || !threadId) {
+                const error = "channelId and threadId are required";
+                return { success: false, error, output: error };
+            }
+            try {
+                const details = await ctx.storage.getThreadDetails({ channelId, threadId });
+                const state = details.state;
+                if (!state || typeof state !== "object" || Object.keys(state).length === 0) {
+                    const error = `No task ${threadId} in #${channelId}.`;
+                    return { success: false, error, output: error };
+                }
+                const task = withRunning(taskFromState(channelId, threadId, state), ctx.host);
+                const todos = await todoService
+                    .getTodos({ channelId, threadId })
+                    .then((list) => list.items)
+                    .catch(() => []);
+                return { success: true, output: formatTaskDetail(task, todos) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                return { success: false, error: message, output: `Failed to read task: ${message}` };
+            }
+        },
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "OpenBot coordinator runtime: ask specialists, route work into Spaces, and track todos.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@ai-sdk/openai": "^4.0.72",
     "ai": "^7.0.111",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^2.4.0"
+    "@meetopenbot/plugin-sdk": "^2.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",

package/dist/tools/thread-status.js

@@ -1,75 +0,0 @@
-import z from "zod";
-const AGENT_THREAD_STATUSES = [
-    "working",
-    "needs_input",
-    "ready_for_review",
-];
-function formatStatusOutput(args) {
-    const reason = args.reason?.trim();
-    return reason
-        ? `Job status set to ${args.status}: ${reason}`
-        : `Job status set to ${args.status}.`;
-}
-export const toolDefinitions = {
-    set_thread_status: {
-        description: "Set this job's workflow status. Use needs_input when blocked on the human, ready_for_review when you believe the work is done, working when the job is still in progress. Do not use working to mean you are currently executing — that is tracked automatically. Never mark completed or archived — only the human can.",
-        inputSchema: z.object({
-            status: z
-                .enum(AGENT_THREAD_STATUSES)
-                .describe("working — job is in progress; needs_input — blocked on the human; ready_for_review — you believe the job is done."),
-            reason: z
-                .string()
-                .optional()
-                .describe("Short reason shown in the job list, e.g. what you need from the human."),
-        }),
-    },
-};
-export const tools = {
-    set_thread_status: {
-        ...toolDefinitions.set_thread_status,
-        execute: async (rawArgs, ctx) => {
-            try {
-                const channelId = ctx.channelId ?? ctx.state.channelId ?? '';
-                const threadId = ctx.threadId ?? ctx.state.threadId;
-                if (!channelId || !threadId) {
-                    throw new Error("Missing channelId or threadId for set_thread_status");
-                }
-                const data = (rawArgs ?? {});
-                const status = data.status;
-                if (status !== "working" &&
-                    status !== "needs_input" &&
-                    status !== "ready_for_review") {
-                    throw new Error("Agents may only set working, needs_input, or ready_for_review. The human marks completed and archived.");
-                }
-                const reason = typeof data.reason === "string" && data.reason.trim()
-                    ? data.reason.trim()
-                    : "";
-                await ctx.storage.patchThreadState({
-                    channelId,
-                    threadId,
-                    state: {
-                        status,
-                        statusUpdatedAt: new Date().toISOString(),
-                        statusReason: reason,
-                    },
-                });
-                ctx.state.threadDetails = await ctx.storage.getThreadDetails({
-                    channelId,
-                    threadId,
-                });
-                const output = formatStatusOutput({ status, reason });
-                return {
-                    success: true,
-                    status,
-                    ...(reason ? { reason } : {}),
-                    output,
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "Unknown error";
-                return { success: false, error: message, output: message };
-            }
-        },
-    },
-};
-export const threadStatusTools = tools;