@meetopenbot/openbot 1.7.0 → 1.9.0

package/dist/build-tools.js

@@ -3,14 +3,25 @@ import { todoTools } from "./tools/todo.js";
 import { storageTools } from "./tools/storage.js";
 import { startThreadTools } from "./tools/start-thread.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,8 +33,8 @@ export function buildOpenbotTools(args) {
         ...storageTools,
         ...startThreadTools,
         ...askAgentTools,
+        ...askUserTools,
         ...installAgentTools,
-        ...threadStatusTools,
         ...threadTitleTools,
         ...previewTools,
         ...variablesRequestTools,
@@ -31,5 +42,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,7 @@ 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";
 export const DEFAULT_CONTEXT_BUDGET = 8000;
 export const MAX_CONTEXT_FILES = 50;
 /**
@@ -63,23 +64,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

package/dist/conversation.js

@@ -0,0 +1,78 @@
+/**
+ * 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.',
+    '- **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,12 +303,27 @@ 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
+        // it for every later step (and a retry on another model).
+        const steered = [];
+        const takeSteering = !surface && !args.event?.meta?.parentToolCallId ? host.takeSteeringMessages : undefined;
+        const prepareStep = takeSteering
+            ? ({ messages }) => {
+                const known = new Set([...events, ...steered].map((event) => event.id).filter(Boolean));
+                const fresh = takeSteering().filter((event) => !event.id || !known.has(event.id));
+                if (fresh.length === 0)
+                    return undefined;
+                steered.push(...fresh);
+                return { messages: [...messages, ...eventsToModelMessages(fresh)] };
+            }
+            : undefined;
         let lastError;
         let started = false;
         for (let i = 0; i < candidates.length; i++) {
@@ -311,7 +336,7 @@ export async function* runOpenbotTurn(args, options) {
             };
             const tools = toAiTools(toolDefinitions, args, flushPendingOutput);
             try {
-                let messages = eventsToModelMessages(events);
+                let messages = eventsToModelMessages([...events, ...steered]);
                 if (hasAttachments) {
                     const includeImages = modelSupportsImages(candidate, { authMode });
                     messages = await addAttachmentParts(messages, events, {
@@ -330,6 +355,7 @@ export async function* runOpenbotTurn(args, options) {
                     reasoning: reasoningForModel(candidate),
                     stopWhen: surface ? [stepCountIs(8), hasToolCall(RESPOND_TOOL)] : stepCountIs(20),
                     allowSystemInMessages: true,
+                    ...(prepareStep ? { prepareStep } : {}),
                 });
                 for await (const part of result.fullStream) {
                     if (abortSignal?.aborted)

package/dist/system-prompt.js

@@ -4,32 +4,40 @@ export const OPENBOT_SYSTEM_PROMPT = [
     "",
     "# SECURITY POLICY",
     "- **CRITICAL**: Never ask for API keys, passwords, or sensitive credentials in chat or through form widgets; values must never enter your context.",
-    "- **Credential Guidance**: Only ask for a variable after a specialist or tool actually reports it missing. Then call `request_variables` once with every exact name it reported (backend and build-time `VITE_*` alike), each with a short hint. The human fills them in an inline card that saves straight to Space variables and resumes this thread — do not also link to Settings or list the names as links. Never guess, invent, or name an API key or provider that no agent or tool reported.",
+    "- **Credential Guidance**: Only ask for a variable after a specialist or tool actually reports it missing. Then call `request_variables` once with every exact name it reported (backend and build-time `VITE_*` alike), each with a short hint. The human fills them in an inline card that saves straight to Space variables; your run waits on the card and continues once they are saved — do not also link to Settings or list the names as links. Never guess, invent, or name an API key or provider that no agent or tool reported.",
     "",
     "# CORE MISSION",
     "You are a high-level manager. Not every message is project work.",
     "- Answer questions, listings, setup, and status directly from `## SPACES`, `## INSTALLED AGENTS`, and `## AVAILABLE AGENTS`. Do not create a Space to look anything up.",
     "- For real project work (build, code, design, ops) you decide **who** (which installed agent), then ask that agent in the current Space, close without restating their work, and keep todos current.",
+    "- A quick question gets a plain answer and no todo list. A task gets a todo list first; the human follows progress there, not in your messages.",
     "",
     "# 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**: 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.",
+    "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.",
     "6. **Enter Standby**: Idle until the next human message.",
+    "- The human can write while you work. Their message shows up in the conversation between your steps: read it, adjust the plan or the next ask to fit, and keep going. If they ask you to stop or change course, do that first.",
     "",
     "# TASK TRACKING (TODOS)",
     "- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.",
     "- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).",
-    "- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.",
+    "- Mark an item `in_progress` while it is being worked on; when you ask several agents at once, each of their items is `in_progress`. Mark items `completed` immediately after finishing them.",
+    "- Each item is usually one `ask_agent` call. Mark it `in_progress` before you ask, and keep the same list across turns — update it, never start a second one.",
     "- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).",
     "- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.",
     "- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.",
     "",
+    "# ASKING THE HUMAN",
+    "- One way to ask: when a step needs a decision or answer from the human, call `ask_user`. It shows a card, pauses your run, and returns their answer, so you continue the same step. Never ask a blocking question in prose and never continue past it.",
+    "- Missing variables go through `request_variables`, which also waits. Missing agent accounts are the host's job: the host shows the connect card and the asked agent waits for it. Do not ask the human to connect or to paste keys for an agent that is already connected.",
+    "- Ask once. If an answer or card is already pending, wait for it instead of asking again.",
+    "",
     "# WIDGETS",
-    "- Call `render_widget` when your own answer is structured: 3+ similar records (Spaces, agents, options, statuses), a side-by-side comparison, a decision with fixed choices, or a few fields you need from the human. Use plain text for everything else.",
+    "- Call `render_widget` when your own answer is structured: 3+ similar records (Spaces, agents, options, statuses) or a side-by-side comparison. Use plain text for everything else. Decisions go through `ask_user`, not `render_widget`.",
     "- Never use it to restate or re-format what a specialist already said in this thread; that rule from Close still applies.",
     "- Do not repeat the widget's contents in text. A click or form submission arrives as the human's next message, quoting what they picked.",
     "- Forms never ask for secrets; use `request_variables` for those.",
@@ -39,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.",
-    "- When you need a blocking answer from the human, call `set_thread_status` with `needs_input` and a short `reason`.",
-    "- 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/tools/ask-agent.js

@@ -21,16 +21,24 @@ export const toolDefinitions = {
         }),
     },
 };
-/** The host's connect card: the asked agent has no account yet and did not run. */
-function connectionRequestName(event) {
+/**
+ * The host's connect card: the asked agent has no account yet. Newer runtimes
+ * wait on the card and close it once connected; `open` is false from then on.
+ */
+function connectionCard(event) {
     if (event.type !== "client:ui:widget")
         return undefined;
-    const metadata = event.data?.metadata;
+    const data = event.data;
+    const metadata = data?.metadata;
     if (metadata?.type !== "connection_request")
         return undefined;
     // `pluginName` is what runtimes before scoped connections send.
     const name = metadata.name ?? metadata.pluginName;
-    return typeof name === "string" ? name : "This agent";
+    return {
+        widgetId: data?.widgetId ?? "",
+        name: typeof name === "string" ? name : "This agent",
+        open: !data?.state || data.state === "open",
+    };
 }
 async function runAskedAgent(ctx, args) {
     if (ctx.agentId !== ctx.host.orchestratorAgentId) {
@@ -61,7 +69,8 @@ async function runAskedAgent(ctx, args) {
     }
     const runId = `ask_${randomUUID()}`;
     let lastAgentOutput = "";
-    let needsConnection;
+    // Latest state of each connect card the asked agent showed, by widgetId.
+    const connectCards = new Map();
     const eventQueue = [];
     let resolveNext = null;
     let isFinished = false;
@@ -99,7 +108,9 @@ async function runAskedAgent(ctx, args) {
             if (outEvent.type === "agent:output") {
                 lastAgentOutput = outEvent.data.content;
             }
-            needsConnection ?? (needsConnection = connectionRequestName(outEvent));
+            const card = connectionCard(outEvent);
+            if (card)
+                connectCards.set(card.widgetId, card);
             if (resolveNext) {
                 resolveNext();
                 resolveNext = null;
@@ -128,8 +139,10 @@ async function runAskedAgent(ctx, args) {
         }
     }
     await runPromise;
+    // A card still open when the run ended means the agent never got its account.
+    const needsConnection = [...connectCards.values()].find((card) => card.open)?.name;
     if (needsConnection) {
-        const output = `${needsConnection} is not connected yet, so it did not run. The human now sees a ` +
+        const output = `${needsConnection} is not connected yet, so it did not run. The human sees a ` +
             "card to connect it; once they do, the conversation continues on its own. " +
             "Do not ask them for keys or retry; say in one short line that it needs connecting.";
         return { success: false, needsConnection: true, error: output, output };

package/dist/tools/ask-user.js

@@ -0,0 +1,77 @@
+import z from 'zod';
+import { requestQuestion } from '@meetopenbot/plugin-sdk';
+/**
+ * `ask_user` — OpenBot asks the human one question and waits for the answer.
+ * The run pauses on the card (thread status `needs_input`) and the answer is
+ * the tool result, so the plan continues from the same step.
+ */
+const MAX_OPTIONS = 6;
+export const toolDefinitions = {
+    ask_user: {
+        description: 'Ask the human one question and wait for their answer before continuing. Use it for a decision the next step depends on (e.g. test or live mode, which option to pick). Give 2-6 short options for a choice; omit options for a free-text answer. Never ask the same question in prose.',
+        inputSchema: z.object({
+            question: z.string().min(1).describe('The question, one short sentence.'),
+            description: z.string().optional().describe('Optional one-line context under the question.'),
+            options: z
+                .array(z.string().min(1).max(40))
+                .max(MAX_OPTIONS)
+                .optional()
+                .describe('Button labels, recommended option first. Omit for a free-text answer.'),
+        }),
+    },
+};
+async function askUser(rawArgs, ctx) {
+    const args = (rawArgs ?? {});
+    const question = args.question?.trim();
+    if (!question) {
+        const message = 'Pass the question to ask.';
+        return { success: false, error: message, output: message };
+    }
+    const options = [...new Set((args.options ?? []).map((option) => option.trim()).filter(Boolean))].slice(0, MAX_OPTIONS);
+    const description = args.description?.trim() || undefined;
+    const hitl = {
+        emit: ctx.emit,
+        host: ctx.host,
+        abortSignal: ctx.abortSignal,
+        agentId: ctx.agentId,
+        threadId: ctx.threadId ?? ctx.state.threadId,
+        channelId: ctx.channelId ?? ctx.state.channelId,
+        storage: ctx.storage,
+    };
+    try {
+        const response = options.length > 0
+            ? await requestQuestion({
+                ...hitl,
+                title: question,
+                description,
+                actions: options.map((label, index) => ({
+                    id: label,
+                    label,
+                    variant: index === 0 ? 'primary' : 'secondary',
+                })),
+            })
+            : await requestQuestion({
+                ...hitl,
+                title: question,
+                description,
+                fields: [{ id: 'answer', label: question, type: 'textarea', required: true }],
+            });
+        const answer = options.length > 0 ? response.actionId : String(response.values?.answer ?? '').trim();
+        if (!answer || response.actionId === 'deny') {
+            const output = 'The human dismissed the question without answering.';
+            return { success: false, error: output, output };
+        }
+        return { success: true, answer, output: `The human answered: ${answer}` };
+    }
+    catch {
+        const output = 'The run stopped before the human answered.';
+        return { success: false, error: output, output };
+    }
+}
+export const tools = {
+    ask_user: {
+        ...toolDefinitions.ask_user,
+        execute: askUser,
+    },
+};
+export const askUserTools = tools;

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,6 +92,7 @@ export const startThreadTools = {
             await emitStartThreadWidget(ctx, {
                 widgetId,
                 channelId: targetChannelId,
+                threadId,
                 title: threadTitle,
                 body: 'Starting…',
                 state: 'open',
@@ -103,6 +112,7 @@ export const startThreadTools = {
                 await emitStartThreadWidget(ctx, {
                     widgetId,
                     channelId: targetChannelId,
+                    threadId,
                     title: threadTitle,
                     body: `Started a thread in #${targetChannelId}.`,
                     state: 'submitted',

package/dist/tools/todo-items.js

@@ -0,0 +1,43 @@
+/** Todo list shape and validation; no I/O, so it loads without the build. */
+export const MAX_TODO_ITEMS = 20;
+const TODO_STATUSES = new Set([
+    'pending',
+    'in_progress',
+    'completed',
+    'cancelled',
+]);
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size.
+ * Several items may be `in_progress`: steps asked in parallel run together.
+ */
+export function validateTodoItems(items) {
+    if (!Array.isArray(items)) {
+        throw new Error('todos must be an array');
+    }
+    if (items.length > MAX_TODO_ITEMS) {
+        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('Each todo must be an object');
+        }
+        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
+        const status = raw.status;
+        if (!id)
+            throw new Error('Each todo requires a non-empty id');
+        if (!content)
+            throw new Error(`Todo "${id}" requires non-empty content`);
+        if (!TODO_STATUSES.has(status)) {
+            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
+        }
+        if (seen.has(id))
+            throw new Error(`Duplicate todo id "${id}"`);
+        seen.add(id);
+        normalized.push({ id, content, status: status });
+    }
+    return normalized;
+}

package/dist/tools/todo-service.js

@@ -1,13 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { DEFAULT_CHANNELS_DIR, getBaseDir, resolvePath } from '../utils/paths.js';
-export const MAX_TODO_ITEMS = 20;
-const TODO_STATUSES = new Set([
-    'pending',
-    'in_progress',
-    'completed',
-    'cancelled',
-]);
+import { MAX_TODO_ITEMS, validateTodoItems } from './todo-items.js';
+export { MAX_TODO_ITEMS, validateTodoItems };
 const getThreadDir = (channelId, threadId) => {
     const base = resolvePath(path.join(getBaseDir(), DEFAULT_CHANNELS_DIR, channelId));
     return path.join(base, 'threads', threadId);
@@ -17,47 +12,6 @@ const emptyList = () => ({
     items: [],
     updatedAt: new Date().toISOString(),
 });
-/**
- * Validate and normalize a todo list write. Throws on invalid input.
- * Enforces: non-empty content, known statuses, unique ids, max size,
- * and at most one `in_progress` item.
- */
-export function validateTodoItems(items) {
-    if (!Array.isArray(items)) {
-        throw new Error('todos must be an array');
-    }
-    if (items.length > MAX_TODO_ITEMS) {
-        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
-    }
-    const seen = new Set();
-    let inProgressCount = 0;
-    const normalized = [];
-    for (const raw of items) {
-        if (!raw || typeof raw !== 'object') {
-            throw new Error('Each todo must be an object');
-        }
-        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
-        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
-        const status = raw.status;
-        if (!id)
-            throw new Error('Each todo requires a non-empty id');
-        if (!content)
-            throw new Error(`Todo "${id}" requires non-empty content`);
-        if (!TODO_STATUSES.has(status)) {
-            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
-        }
-        if (seen.has(id))
-            throw new Error(`Duplicate todo id "${id}"`);
-        seen.add(id);
-        if (status === 'in_progress')
-            inProgressCount += 1;
-        normalized.push({ id, content, status: status });
-    }
-    if (inProgressCount > 1) {
-        throw new Error('At most one todo may be in_progress');
-    }
-    return normalized;
-}
 export const todoService = {
     getTodos: async (args) => {
         const filePath = getTodosPath(args.channelId, args.threadId);

package/dist/tools/todo.js

@@ -35,8 +35,8 @@ function todoListWidget(args) {
     return {
         type: 'client:ui:widget',
         data: {
-            // One widget per agent run — repeated todo_write calls update in place.
-            widgetId: `todos:${args.runId}`,
+            // One plan per thread — every todo_write, in any run, updates it in place.
+            widgetId: `todos:${args.threadId}`,
             kind: 'list',
             layout: 'checklist',
             title: 'Todos',
@@ -51,11 +51,11 @@ const todoItemSchema = z.object({
     content: z.string().min(1).describe('Short imperative description of the step.'),
     status: z
         .enum(['pending', 'in_progress', 'completed', 'cancelled'])
-        .describe('Todo status. At most one item may be in_progress.'),
+        .describe('Todo status. Every step being worked on is in_progress, including steps run in parallel.'),
 });
 export const toolDefinitions = {
     todo_write: {
-        description: 'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, keep exactly one item in_progress while working, mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
+        description: 'Replace the current thread todo list with the provided items. Use for multi-step tasks: write the plan first, mark each step in_progress while it is being worked on (several when they run in parallel), mark items completed immediately after finishing, and when done leave all items as completed (do not clear the list). Pass the full intended list each call (not a partial patch).',
         inputSchema: z.object({
             items: z
                 .array(todoItemSchema)
@@ -81,16 +81,13 @@ export const tools = {
                 const items = (rawArgs ?? {}).items;
                 const list = await todoService.writeTodos({ channelId, threadId, items });
                 const runId = ctx.runId ?? ctx.state.runId;
-                if (!runId) {
-                    throw new Error('Missing runId for todo_write widget');
-                }
                 await ctx.emit(todoListWidget({
-                    runId,
+                    threadId,
                     list,
                     meta: {
                         agentId: ctx.agentId,
                         threadId,
-                        runId,
+                        ...(runId ? { runId } : {}),
                         toolCallId: ctx.toolCallId,
                     },
                 }));

package/dist/tools/variables-request.js

@@ -1,4 +1,5 @@
 import z from 'zod';
+import { markThreadNeedsInput, restoreThreadWorking } from '@meetopenbot/plugin-sdk';
 /** `metadata.type` of the card the host shows to collect missing variables. */
 export const VARIABLES_REQUEST_TYPE = 'variables_request';
 const ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -63,22 +64,70 @@ async function requestVariables(rawArgs, ctx) {
         const message = 'Pass at least one variable name such as FIREBASE_PROJECT_ID.';
         return { success: false, error: message, output: message };
     }
-    await ctx.emit(variablesRequestEvent({
+    const card = variablesRequestEvent({
         variables,
         reason: typeof data.reason === 'string' ? data.reason : undefined,
         agentId: ctx.agentId,
         threadId,
-    }));
+    });
+    await ctx.emit(card);
+    const names = variables.map((variable) => variable.key).join(', ');
+    if (ctx.host?.resumesCardsInPlace)
+        return waitForVariables(ctx, card, names);
     return {
         success: true,
         output: 'Shown a card asking the human for ' +
-            variables.map((variable) => variable.key).join(', ') +
+            names +
             '. They save the values there; you will get a message when they do. Do not ask them to paste values in chat.',
     };
 }
+/**
+ * Hold the run on the card until the human saves every key. The runtime's
+ * variables route resolves the wait and sends the closed card's body back.
+ * If the run stops first the card stays open: saving later resumes the thread
+ * with a message, also after a restart.
+ */
+async function waitForVariables(ctx, card, names) {
+    const data = card.data;
+    const hitl = {
+        emit: ctx.emit,
+        host: ctx.host,
+        agentId: ctx.agentId,
+        channelId: ctx.channelId ?? ctx.state.channelId,
+        threadId: ctx.threadId ?? ctx.state.threadId,
+        storage: ctx.storage,
+    };
+    const paused = await markThreadNeedsInput(hitl, `Add ${names}`);
+    let response;
+    try {
+        response = await ctx.host.awaitWidgetResponse(data.widgetId, ctx.abortSignal, { resumable: true });
+    }
+    catch {
+        // The card stays open and the thread stays `needs_input`; saving later resumes it.
+        const output = `The run stopped before ${names} were saved. The card stays open; saving it continues the thread.`;
+        return { success: false, error: output, output };
+    }
+    const body = typeof response.metadata?.body === 'string' ? response.metadata.body : `Saved ${names}.`;
+    const scope = response.metadata?.scope;
+    await ctx.emit({
+        ...card,
+        data: {
+            ...data,
+            state: 'submitted',
+            body,
+            metadata: { ...data.metadata, ...(scope ? { scope } : {}) },
+        },
+    });
+    if (paused)
+        await restoreThreadWorking(hitl);
+    return {
+        success: true,
+        output: `${body} They are in the environment now; ask the specialist to restart whatever needed them.`,
+    };
+}
 export const toolDefinitions = {
     request_variables: {
-        description: 'Ask the human for missing environment variables with an inline card in the thread. Values are saved as Space variables by default (or for all spaces if they choose) and never appear in chat. Pass every missing name at once, including build-time ones like VITE_*.',
+        description: 'Ask the human for missing environment variables with an inline card in the thread, and wait until they are saved. Values are saved as Space variables by default (or for all spaces if they choose) and never appear in chat. Pass every missing name at once, including build-time ones like VITE_*.',
         inputSchema: z.object({
             variables: z
                 .array(z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/openbot",
-  "version": "1.7.0",
+  "version": "1.9.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.3.0"
+    "@meetopenbot/plugin-sdk": "^2.4.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;