@loicngr/kobo 1.9.5 → 1.10.0

package/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.10.0
+
+- fix(agent): make Claude sessions recover cleanly from a stuck post-result
+  stream, prevent native wakeups from leaving orphaned questions, and keep
+  live sessions out of the `idle` state
+- feat(chat): keep queued messages scoped to the selected workspace session,
+  restore them after a rejected send, and confirm delivery only after the
+  engine accepts it
+- feat(chat): send a queued message immediately to an active Claude session
+  or steer an active Codex turn; serialise concurrent Codex steer requests
+  against the current turn id
+- feat(questions): support inline free-form answers for **Other**, option
+  previews, structured Codex question ids, missing option arrays, secret
+  answers, and stale-question-panel recovery
+- fix(codex): map `request_user_input` and its auto-resolution metadata to the
+  shared question UI, and document that structured Codex questions require
+  `plan` mode
+- docs: document live steering, interactive-question limitations, and the
+  updated Q&A experience in README and CONFIGURATION
+
+## 1.9.6
+
+- feat(chat): inject a queued message into a running Claude session, with a
+  session-scoped queue and explicit server acceptance
+- feat(sessions): persist the model used by each agent session and display it
+  when it differs from the workspace default
+- fix(auto-loop): apply the brainstorming model before the initial session
+  starts; add a separate brainstorming reasoning-effort selector
+- feat(mcp): let agents read paginated user/agent conversation history across
+  workspace sessions as CSV, with optional session filtering
+- fix(chat): start a fresh session automatically when a historical session
+  cannot be resumed
+- ui(create): clarify auto-loop, session-mode, brainstorming, model and
+  reasoning-effort controls; remember reasoning effort per model locally
+- docs: document the Claude queued-message behavior
+
 ## 1.9.5
 
 - fix(tests): make macOS tests portable (#16)

package/README.md

@@ -17,7 +17,7 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
 
 - **Isolated worktrees**: each workspace is a dedicated git worktree on its own branch, so parallel sessions never collide.
 - **Two agent engines**: Claude Code (via `@anthropic-ai/claude-agent-sdk`) and OpenAI Codex (via `codex app-server`), chosen per workspace.
-- **Live chat**: streaming text, reasoning blocks, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and you can export any workspace's session events to CSV.
+- **Live chat**: streaming text, reasoning blocks, inline Edit/Write diffs, per-turn cards, a compaction-in-progress indicator, infinite scrollback. `/` autocompletes skills and commands, `@` fuzzy-autocompletes worktree file paths, and you can export any workspace's session events to CSV. Messages queued while an agent is busy stay scoped to their workspace and session. **Send now** delivers a queued message to an active Claude Code stream or steers the active Codex turn; it remains queued until the engine confirms acceptance.
 - **Full MCP toolset (`kobo-tasks`)**: a per-workspace MCP server the agent uses for far more than tasks — task/acceptance-criteria CRUD, starting/stopping the dev server and reading its logs, a unified `get_ticket` (Notion or Sentry), searching past conversations across every workspace, per-session token/cost usage, and a `.ai/thoughts` decision log. Native Claude Code Task tools complement it for lightweight sub-agent coordination. See [`AGENTS.md`](./AGENTS.md) for the full tool list.
 
   ![Sub-agents panel showing parallel tool calls](docs/assets/images/sub-agents-panel.png)
@@ -26,7 +26,7 @@ Kōbō runs multiple coding agents in parallel, each isolated in its own git wor
   ![Diff viewer with side-by-side changes](docs/assets/images/diff-viewer.png)
 - **Dev server panel**: start, stop, and tail logs for a workspace's dev server (Docker or npm) straight from the Tools panel — no need to leave the UI.
 - **Attention indicators**: workspace cards surface CI failures, review-requested changes, and a conflict-aware **ready-to-merge** badge, plus a one-click **Fix CI** button that spawns a fix workspace automatically.
-- **Interactive Q&A**: an agent can pause mid-session to ask a clarifying question through the UI; the workspace surfaces under "Needs Attention" until you answer.
+- **Interactive Q&A**: an agent can pause mid-session to ask a clarifying question through the UI; the workspace surfaces under "Needs Attention" until you answer. Choosing **Other** opens an inline free-form field, and option previews are available on hover. Codex native interactive questions require its `plan` permission mode.
 
   ![Agent asking a clarifying question, awaiting the user's answer](docs/assets/images/agent-question.png)
 - **Auto-loop**: an opt-in mode that walks the task list, spawning a fresh session per task and stopping once there's nothing left to do, progress stalls, an error occurs, or the agent needs input from you. Optionally run the initial brainstorming session on a stronger model and every task after that on a cheaper one, without leaving the engine you picked.

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -441,6 +441,34 @@ export function getSessionUsageHandler(db, workspaceId) {
         currentSession: { sessionId: currentSessionId, ...current },
     };
 }
+function csvCell(value) {
+    return /[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+/** Read the user/agent conversation history as paginated CSV. */
+export function readWorkspaceEventsCsvHandler(db, workspaceId, options = {}) {
+    const safeLimit = Math.min(Math.max(Math.floor(options.limit ?? 100), 1), 500);
+    const safeOffset = Math.max(Math.floor(options.offset ?? 0), 0);
+    const sessionFilter = options.sessionId ? ' AND session_id = ?' : '';
+    const params = options.sessionId ? [workspaceId, options.sessionId] : [workspaceId];
+    const conversationFilter = " AND (type = 'user:message' OR (type = 'agent:event' AND json_extract(payload, '$.kind') = 'message:text'))";
+    const rows = db
+        .prepare(`SELECT session_id, type, payload, created_at FROM ws_events WHERE workspace_id = ?${sessionFilter}${conversationFilter} ORDER BY rowid ASC LIMIT ? OFFSET ?`)
+        .all(...params, safeLimit, safeOffset);
+    const total = db
+        .prepare(`SELECT COUNT(*) AS count FROM ws_events WHERE workspace_id = ?${sessionFilter}${conversationFilter}`)
+        .get(...params).count;
+    const lines = [
+        ['created_at', 'session_id', 'type', 'payload'],
+        ...rows.map((r) => [r.created_at, r.session_id ?? '', r.type, r.payload]),
+    ];
+    return {
+        csv: lines.map((row) => row.map(csvCell).join(',')).join('\n'),
+        eventCount: rows.length,
+        totalEvents: total,
+        offset: safeOffset,
+        nextOffset: safeOffset + rows.length < total ? safeOffset + rows.length : null,
+    };
+}
 // ── Crons ────────────────────────────────────────────────────────────────────
 /**
  * List every cron currently armed for a workspace.

package/dist/mcp-server/kobo-tasks-server.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getDb } from '../server/db/index.js';
 import { runMigrations } from '../server/db/migrations.js';
-import { createTaskHandler, cronListHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getTicketSourcesHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, listWorkspacesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
+import { createTaskHandler, cronListHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getTicketSourcesHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, listWorkspacesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, readWorkspaceEventsCsvHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -276,7 +276,7 @@ const WORKSPACE_SCOPED_TOOLS = [
     },
     {
         name: 'set_workspace_status',
-        description: 'CALL WHEN you believe the mission is done (`completed`), blocked beyond recovery (`error`), or explicitly idle awaiting user input (`idle`). Transitions are validated by the backend — invalid ones are rejected.',
+        description: 'CALL WHEN you believe the mission is done (`completed`) or blocked beyond recovery (`error`). Do NOT set `idle` while this agent session is active: ask the user with AskUserQuestion or end the turn instead. Transitions are validated by the backend — invalid or unsafe ones are rejected.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -414,6 +414,20 @@ const WORKSPACE_SCOPED_TOOLS = [
         inputSchema: { type: 'object', properties: {}, required: [] },
         annotations: { readOnlyHint: true, openWorldHint: false },
     },
+    {
+        name: 'read_workspace_events_csv',
+        description: 'Read the user/agent conversation history for THIS workspace as paginated CSV. Use it to recover context from prior sessions without loading the whole history at once. Optionally filter to one session_id. Read-only; cannot access another workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Optional Kōbō session id to restrict the history.' },
+                offset: { type: 'number', description: 'Zero-based offset for pagination, default 0.' },
+                limit: { type: 'number', description: 'Messages to return, default 100, max 500.' },
+            },
+            required: [],
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    },
     {
         name: 'schedule_wakeup',
         description: 'WHEN: use this whenever you would otherwise WAIT for or POLL a long-running task (test suite, CI, build, deploy, or external state) — never block your turn with sleep/poll loops, and never end a turn merely "waiting" on a background job, because the session goes idle and will not resume on its own. CALL to schedule a follow-up turn on THIS workspace after a delay. End the current turn normally; once it finishes and the workspace is idle, Kōbō waits `delaySeconds`, then resumes the same conversation by injecting `prompt` as the next user message. The wakeup is scoped to the current workspace and resumes its latest session — you cannot target another workspace or another session. If a turn is still active when the timer fires, the wakeup is skipped (status: `session-active`). Replaces any previously pending wakeup on this workspace. Delay is clamped to [60, 21600] seconds (1min to 6h). Prefer this over the built-in `ScheduleWakeup` tool — it is the SDK-supported entry point.',
@@ -761,6 +775,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (name === 'get_session_usage') {
             return ok(getSessionUsageHandler(db, workspaceId));
         }
+        if (name === 'read_workspace_events_csv') {
+            return ok(readWorkspaceEventsCsvHandler(db, workspaceId, {
+                sessionId: typeof a.session_id === 'string' ? a.session_id : undefined,
+                offset: typeof a.offset === 'number' ? a.offset : undefined,
+                limit: typeof a.limit === 'number' ? a.limit : undefined,
+            }));
+        }
         if (name === 'schedule_wakeup') {
             const delaySeconds = a.delaySeconds;
             const prompt = a.prompt;

package/dist/server/db/migrations.js

@@ -407,6 +407,19 @@ export const migrations = [
             }
         },
     },
+    {
+        version: 31,
+        name: 'add-agent-session-model',
+        migrate: (db) => {
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agent_sessions'").get();
+            if (!table)
+                return;
+            const cols = db.prepare('PRAGMA table_info(agent_sessions)').all();
+            if (!cols.some((c) => c.name === 'model')) {
+                db.prepare('ALTER TABLE agent_sessions ADD COLUMN model TEXT').run();
+            }
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -58,6 +58,7 @@ export function initSchema(db) {
       pid INTEGER,
       engine_session_id TEXT,
       status TEXT NOT NULL DEFAULT 'running',
+      model TEXT,
       started_at TEXT NOT NULL,
       ended_at TEXT,
       name TEXT

package/dist/server/index.js

@@ -291,7 +291,7 @@ terminalWss.on('connection', (ws, workspaceId) => {
     });
 });
 // Wire websocket-service message handler to the agent orchestrator
-setMessageHandler((type, payload) => {
+setMessageHandler(async (type, payload) => {
     const p = payload;
     if (type === 'chat:message' && p?.workspaceId && p?.content) {
         // Auto-loop owns the agent's turns. A user message means the user wants
@@ -312,6 +312,8 @@ setMessageHandler((type, payload) => {
         if (wsRow?.status === 'awaiting-user') {
             emitEphemeral(p.workspaceId, 'chat:rejected', {
                 reason: 'awaiting-user',
+                sessionId: p.sessionId,
+                content: p.content,
                 message: 'Answer via the question panel — typing in chat would orphan the pending callback',
             });
             return;
@@ -321,10 +323,11 @@ setMessageHandler((type, payload) => {
         // never steal the tagging.
         const activeSession = getActiveSession(p.workspaceId);
         const sessionTag = p.sessionId ?? activeSession?.id ?? undefined;
-        // Persist user message so it survives page refresh
-        emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, sessionTag);
         try {
-            sendMessage(p.workspaceId, p.content);
+            await sendMessage(p.workspaceId, p.content, p.sessionId);
+            emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, sessionTag);
+            if (p.force)
+                emitEphemeral(p.workspaceId, 'chat:accepted', { sessionId: p.sessionId });
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -332,6 +335,7 @@ setMessageHandler((type, payload) => {
             // (stdin closed, process dead mid-write, etc.) should surface to the
             // logs instead of silently respawning a fresh agent.
             if (!msg.includes('No agent running')) {
+                emitEphemeral(p.workspaceId, 'chat:rejected', { sessionId: p.sessionId, content: p.content, message: msg });
                 console.error(`[ws] chat:message failed for workspace ${p.workspaceId}:`, err);
                 return;
             }
@@ -345,12 +349,25 @@ setMessageHandler((type, payload) => {
                     // requires them (e.g. grooming), it sets the override to bypass the
                     // workspace default for this spawn only.
                     const effectiveMode = p.agentPermissionModeOverride ?? workspace.agentPermissionMode;
-                    startAgent(p.workspaceId, worktreePath, p.content, workspace.model, true, effectiveMode, p.sessionId, workspace.reasoningEffort);
+                    const started = startAgent(p.workspaceId, worktreePath, p.content, workspace.model, true, effectiveMode, p.sessionId, workspace.reasoningEffort);
                     updateWorkspaceStatus(p.workspaceId, 'executing');
+                    const resumedSessionId = p.sessionId ?? started.agentSessionId;
+                    emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, resumedSessionId);
+                    if (p.force)
+                        emitEphemeral(p.workspaceId, 'chat:accepted', { sessionId: resumedSessionId });
+                }
+                else {
+                    emitEphemeral(p.workspaceId, 'chat:rejected', {
+                        sessionId: p.sessionId,
+                        content: p.content,
+                        message: `Workspace '${p.workspaceId}' not found`,
+                    });
                 }
             }
             catch (restartErr) {
-                console.error('[ws] Failed to resume agent:', restartErr instanceof Error ? restartErr.message : restartErr);
+                const message = restartErr instanceof Error ? restartErr.message : String(restartErr);
+                emitEphemeral(p.workspaceId, 'chat:rejected', { sessionId: p.sessionId, content: p.content, message });
+                console.error('[ws] Failed to resume agent:', message);
             }
         }
     }

package/dist/server/routes/workspaces.js

@@ -311,6 +311,23 @@ app.post('/', migrationGuard, async (c) => {
             engine: body.engine,
             ...(useReusedWorktree ? {} : { worktreesPath: globalSettings.worktreesPath }),
         });
+        // Enable auto-loop before starting the initial brainstorming session so
+        // its model override is available when selecting that session's model.
+        if (body.autoLoop === true) {
+            const notionProducedTasks = body.notionUrl !== undefined &&
+                notionContent != null &&
+                notionContent.todos.length > 0 &&
+                notionContent.gherkinFeatures.length > 0;
+            const sessionMode = body.autoLoopSessionMode === 'continuous' ? 'continuous' : 'per_task';
+            const db = getDb();
+            db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ?, auto_loop_session_mode = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, sessionMode, workspace.id);
+            workspace = workspaceService.getWorkspace(workspace.id) ?? workspace;
+            // Emit events so the frontend refreshes autoLoopStates without F5.
+            wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
+            if (notionProducedTasks) {
+                wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
+            }
+        }
         // Auto-tag the workspace based on its creation source — `notion` when
         // imported from a Notion page, `sentry` when bootstrapped from a Sentry
         // issue URL. Pre-seeded in the global tag catalogue via migration v9.
@@ -784,7 +801,10 @@ Once the brainstorming + planning steps above are complete and you have a saved
                     // (see auto-loop-service.ts's spawnNextIteration) — brainstormModel
                     // is consumed exactly once, here.
                     const initialSessionModel = workspace.autoLoop && workspace.brainstormModel ? workspace.brainstormModel : workspace.model;
-                    const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, initialSessionModel, false, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                    const initialSessionEffort = body.autoLoop === true && body.brainstormReasoningEffort
+                        ? body.brainstormReasoningEffort
+                        : workspace.reasoningEffort;
+                    const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, initialSessionModel, false, workspace.agentPermissionMode, undefined, initialSessionEffort);
                     // Persist the initial prompt in the feed so it's visible in the chat,
                     // tagged with the freshly created session id so the strict session filter shows it.
                     wsService.emit(workspace.id, 'user:message', { content: brainstormPrompt, sender: 'system-prompt' }, agent.agentSessionId);
@@ -809,23 +829,6 @@ Once the brainstorming + planning steps above are complete and you have a saved
                 }
             }
         }
-        // Apply the auto-loop checkbox from CreatePage. Notion-imported workspaces
-        // with both todos AND gherkin features auto-unlock `auto_loop_ready=1` —
-        // they're considered good enough to drive the loop without grooming.
-        if (body.autoLoop === true) {
-            const notionProducedTasks = body.notionUrl !== undefined &&
-                notionContent != null &&
-                notionContent.todos.length > 0 &&
-                notionContent.gherkinFeatures.length > 0;
-            const sessionMode = body.autoLoopSessionMode === 'continuous' ? 'continuous' : 'per_task';
-            const db = getDb();
-            db.prepare('UPDATE workspaces SET auto_loop = 1, auto_loop_ready = ?, auto_loop_session_mode = ? WHERE id = ?').run(notionProducedTasks ? 1 : 0, sessionMode, workspace.id);
-            // Emit events so the frontend refreshes autoLoopStates without F5.
-            wsService.emitEphemeral(workspace.id, 'autoloop:enabled', {});
-            if (notionProducedTasks) {
-                wsService.emitEphemeral(workspace.id, 'autoloop:ready-flipped', {});
-            }
-        }
         // Return created workspace with tasks
         const workspaceWithTasks = workspaceService.getWorkspaceWithTasks(workspace.id);
         if (workingBranchAdjusted) {
@@ -1227,6 +1230,7 @@ app.post('/:id/deferred-tool-use/answer', async (c) => {
         }
         await agentManager.answerPendingQuestion(id, body.answers, body.toolCallId, {
             awaitingFreeForm: body.awaitingFreeForm === true,
+            ...(typeof body.response === 'string' ? { response: body.response } : {}),
         });
         return c.json({ ok: true });
     }
@@ -1792,6 +1796,9 @@ app.patch('/:id', migrationGuard, async (c) => {
             updated = workspaceService.updateAgentPermissionMode(id, body.agentPermissionMode);
         }
         if (body.status) {
+            if (body.status === 'idle' && agentManager.hasController(id)) {
+                return c.json({ error: 'Cannot mark an active agent workspace idle; end or stop the agent session first' }, 409);
+            }
             updated = workspaceService.updateWorkspaceStatus(id, body.status);
         }
         if (body.name !== undefined) {

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -14,6 +14,7 @@ import { buildStopHookOutput } from './stop-hook.js';
  * and auto-loop are not frozen forever.
  */
 const RESULT_DRAIN_TIMEOUT_MS = 15_000;
+const MAX_PENDING_USER_MESSAGES = 20;
 function toMcpServersMap(specs) {
     if (!specs || specs.length === 0)
         return undefined;
@@ -27,6 +28,55 @@ function toMcpServersMap(specs) {
     }
     return map;
 }
+class ClaudeInputStream {
+    messages;
+    waiting;
+    closed = false;
+    queuedForcedMessages = 0;
+    yieldedMessages = 0;
+    constructor(initialPrompt) {
+        this.messages = [{ message: this.toUserMessage(initialPrompt), forced: false }];
+    }
+    send(text) {
+        if (this.closed)
+            throw new Error('Claude input stream is closed');
+        if (this.queuedForcedMessages >= MAX_PENDING_USER_MESSAGES) {
+            throw new Error(`Claude input queue is full (max ${MAX_PENDING_USER_MESSAGES} messages)`);
+        }
+        this.messages.push({ message: this.toUserMessage(text), forced: true });
+        this.queuedForcedMessages++;
+        const wake = this.waiting;
+        this.waiting = undefined;
+        wake?.();
+    }
+    close() {
+        this.closed = true;
+        const wake = this.waiting;
+        this.waiting = undefined;
+        wake?.();
+    }
+    hasUnansweredInput(completedResponses) {
+        return this.queuedForcedMessages > 0 || this.yieldedMessages > completedResponses;
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this.closed || this.messages.length > 0) {
+            const next = this.messages.shift();
+            if (next) {
+                if (next.forced)
+                    this.queuedForcedMessages--;
+                this.yieldedMessages++;
+                yield next.message;
+                continue;
+            }
+            await new Promise((resolve) => {
+                this.waiting = resolve;
+            });
+        }
+    }
+    toUserMessage(text) {
+        return { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null };
+    }
+}
 export function createClaudeCodeEngine() {
     return {
         id: 'claude-code',
@@ -143,7 +193,8 @@ export function createClaudeCodeEngine() {
             const explicitBinary = resolveClaudeBinaryPath();
             if (explicitBinary)
                 sdkOptions.pathToClaudeCodeExecutable = explicitBinary;
-            const q = query({ prompt: effectivePrompt, options: sdkOptions });
+            const inputStream = new ClaudeInputStream(effectivePrompt);
+            const q = query({ prompt: inputStream, options: sdkOptions });
             let discoveredSessionId;
             // A throwing onEvent handler (e.g. DB query against a closed connection
             // during async test teardown) must not escape as an unhandled rejection.
@@ -157,6 +208,7 @@ export function createClaudeCodeEngine() {
             };
             let iteratorRunning = false;
             let userInterrupted = false;
+            let completedResponses = 0;
             // Guard so the post-result drain watchdog and the natural loop exit (or
             // catch block) never both emit `session:ended` for the same run.
             let sessionEndedEmitted = false;
@@ -181,29 +233,12 @@ export function createClaudeCodeEngine() {
                     console.warn(`[claude-engine] SDK generator still open ${RESULT_DRAIN_TIMEOUT_MS}ms after 'result' — forcing session:ended`);
                     const reason = userInterrupted ? 'killed' : mapperState.sawErrorResult ? 'error' : 'completed';
                     emitSessionEnded(reason, reason === 'completed' ? 0 : null);
-                    // Normally we abort here to unstick the SDK so its subprocesses / MCP
-                    // children tear down. BUT if a wakeup is scheduled for this workspace,
-                    // the agent intentionally left background work running for the wakeup
-                    // to resume and check — aborting would kill that work. Skip the abort
-                    // in that case so the background tasks survive. `session:ended` was
-                    // already emitted (so the orchestrator/auto-loop proceed and the
-                    // controller is removed, letting the wakeup fire later); the parked
-                    // generator drains on its own once the background work finishes.
-                    //
-                    // The wakeup check is a dynamic import: a static `import` of
-                    // wakeup-service here would form an engine → wakeup-service →
-                    // orchestrator → engine cycle that breaks module init under the test
-                    // SSR transform. Resolving it at call-time (once, 15s after result)
-                    // sidesteps the cycle with no hot-path cost.
-                    void (async () => {
-                        const { isWakeupScheduled } = await import('../../../wakeup-service.js');
-                        if (isWakeupScheduled(options.workspaceId)) {
-                            console.warn(`[claude-engine] generator still open ${RESULT_DRAIN_TIMEOUT_MS}ms after 'result' but a wakeup is scheduled for ${options.workspaceId} — leaving background work alive (no abort)`);
-                        }
-                        else {
-                            abortController.abort();
-                        }
-                    })();
+                    // A wakeup starts a new turn later; it cannot safely keep this SDK
+                    // stream alive after Kōbō has emitted session:ended and detached its
+                    // controller. Leaving it alive lets late hooks issue AskUserQuestion
+                    // calls against a closed input stream, producing an unanswerable UI
+                    // card followed by "Stream closed". Abort deterministically instead.
+                    abortController.abort();
                 }, RESULT_DRAIN_TIMEOUT_MS);
                 resultDrainTimer.unref?.();
             };
@@ -217,8 +252,14 @@ export function createClaudeCodeEngine() {
                                 discoveredSessionId = ev.engineSessionId;
                             safeEmit(ev);
                         }
-                        if (msg.type === 'result')
-                            armResultDrainWatchdog();
+                        if (msg.type === 'result') {
+                            completedResponses++;
+                            // A queued forced message starts the next response on this same SDK stream.
+                            if (!inputStream.hasUnansweredInput(completedResponses)) {
+                                inputStream.close();
+                                armResultDrainWatchdog();
+                            }
+                        }
                     }
                     // If the SDK ended with a `result.subtype === 'error_*'`, the
                     // event-mapper already surfaced an `error` event but the iterator
@@ -272,6 +313,7 @@ export function createClaudeCodeEngine() {
                     }
                     pendingResolvers.clear();
                     iteratorRunning = false;
+                    inputStream.close();
                 }
             })();
             const engineProcess = {
@@ -284,8 +326,10 @@ export function createClaudeCodeEngine() {
                 isAlive() {
                     return iteratorRunning;
                 },
-                sendMessage() {
-                    throw new Error('sendMessage not supported in single-shot SDK mode');
+                sendMessage(text) {
+                    if (!iteratorRunning)
+                        throw new Error('Claude agent is no longer running');
+                    inputStream.send(text);
                 },
                 interrupt() {
                     userInterrupted = true;
@@ -336,6 +380,7 @@ export function createClaudeCodeEngine() {
                             updatedInput: {
                                 ...(typeof questions !== 'undefined' ? { questions } : {}),
                                 answers: response.answers,
+                                ...(response.response !== undefined ? { response: response.response } : {}),
                             },
                         });
                         return true;

package/dist/server/services/agent/engines/claude-code/options-builder.js

@@ -8,8 +8,9 @@ const KOBO_MCP_BRIEF = [
     '• `kobo__list_documents` / `kobo__read_document` to discover existing plans and specs under docs/ and .ai/thoughts/ before writing new ones.',
     '• `kobo__log_thought` to persist notable decisions to `.ai/thoughts/logs/<date>-<slug>.md`.',
     '• `kobo__search_codebase` to recall prior chat history (conversations, not source — use Grep for source).',
+    '• `kobo__read_workspace_events_csv` to read paginated user/agent history from this workspace across sessions when prior context is useful. Use `limit` + `offset` (and optional `session_id`) instead of loading everything.',
     '• `kobo__get_workspace_info` / `kobo__get_git_info` / `kobo__get_ticket` for context.',
-    '• `kobo__set_workspace_status` when the mission is done / blocked / idle.',
+    '• `kobo__set_workspace_status` when the mission is done or irrecoverably blocked. Never set `idle` while this session is active; use AskUserQuestion for clarification, or end the turn.',
     '• `kobo__schedule_wakeup` / `kobo__cancel_wakeup` to schedule (or cancel) a follow-up session — prefer these over the built-in `ScheduleWakeup` tool.',
     'Each tool carries its own "WHEN to use" guidance in its description — follow it.',
 ].join('\n');
@@ -27,6 +28,10 @@ export function buildClaudeOptions(input) {
     const options = {
         cwd: input.workingDir,
         systemPrompt: { type: 'preset', preset: 'claude_code', append: KOBO_SYSTEM_APPEND },
+        // Kōbō persists wakeups independently of the SDK and creates a fresh
+        // controller when they fire. The native wakeup is bound to one SDK stream,
+        // so it can outlive Kōbō's controller and produce unanswerable questions.
+        disallowedTools: ['ScheduleWakeup'],
         // Leave `tools` undefined: the `claude_code` preset EXCLUDES MCP tools, so
         // under bypassPermissions MCP tools surface as "haven't granted it yet"
         // even when the user chose bypass. Undefined → full toolbox (built-ins +

package/dist/server/services/agent/engines/codex/client.js

@@ -26,6 +26,9 @@ export function createAppServerClient(opts) {
         startTurn(params) {
             return peer.request('turn/start', params);
         },
+        steerTurn(params) {
+            return peer.request('turn/steer', params);
+        },
         async interruptTurn(params) {
             await peer.request('turn/interrupt', params);
         },

package/dist/server/services/agent/engines/codex/engine.js

@@ -32,6 +32,8 @@ export function createCodexEngine() {
             let iteratorRunning = false;
             let userInterrupted = false;
             let discoveredSessionId = options.resumeFromEngineSessionId;
+            let activeTurnId;
+            let steerChain = Promise.resolve();
             const safeEmit = (ev) => {
                 try {
                     onEvent(ev);
@@ -99,7 +101,8 @@ export function createCodexEngine() {
                         const n = params;
                         for (const ev of handleTurnCompleted(n, mapperState))
                             safeEmit(ev);
-                        resolveTurnDone();
+                        if (!activeTurnId || !n.turn?.id || n.turn.id === activeTurnId)
+                            resolveTurnDone();
                         return;
                     }
                     if (method === 'thread/tokenUsage/updated') {
@@ -176,11 +179,12 @@ export function createCodexEngine() {
                         safeEmit(ev);
                     // collaborationMode is sticky server-side — always send it explicitly,
                     // never omit (would leave a Bypass turn stuck in a previous Plan mode).
-                    await client.startTurn({
+                    const initialTurn = await client.startTurn({
                         threadId: discoveredSessionId,
                         input,
                         collaborationMode,
                     });
+                    activeTurnId = initialTurn.turnId;
                     await turnDonePromise;
                     const reason = mapperState.sawErrorResult
                         ? 'error'
@@ -235,8 +239,21 @@ export function createCodexEngine() {
                 isAlive() {
                     return iteratorRunning;
                 },
-                sendMessage() {
-                    throw new Error('sendMessage not supported in Codex app-server single-shot mode');
+                sendMessage(text) {
+                    const steer = async () => {
+                        if (!discoveredSessionId || !activeTurnId) {
+                            throw new Error('Codex session is not ready to receive a message');
+                        }
+                        const response = await client.steerTurn({
+                            threadId: discoveredSessionId,
+                            expectedTurnId: activeTurnId,
+                            input: [{ type: 'text', text, text_elements: [] }],
+                        });
+                        activeTurnId = response.turnId;
+                    };
+                    const queued = steerChain.then(steer);
+                    steerChain = queued.catch(() => { });
+                    return queued;
                 },
                 interrupt() {
                     userInterrupted = true;

package/dist/server/services/agent/engines/codex/options-builder.js

@@ -7,7 +7,7 @@ const CODEX_KOBO_MCP_BRIEF = [
     '• `mcp__kobo-tasks__log_thought` to persist notable decisions to `.ai/thoughts/logs/<date>-<slug>.md`.',
     '• `mcp__kobo-tasks__search_codebase` to recall prior chat history (conversations, not source — use shell tools for source).',
     '• `mcp__kobo-tasks__get_workspace_info` / `mcp__kobo-tasks__get_git_info` / `mcp__kobo-tasks__get_ticket` for context.',
-    '• `mcp__kobo-tasks__set_workspace_status` when the mission is done / blocked / idle.',
+    '• `mcp__kobo-tasks__set_workspace_status` when the mission is done or irrecoverably blocked. Never set `idle` while this session is active; ask the user or end the turn instead.',
     '• `mcp__kobo-tasks__schedule_wakeup` / `mcp__kobo-tasks__cancel_wakeup` to schedule (or cancel) a follow-up session.',
     'Each tool carries its own "WHEN to use" guidance in its description — follow it.',
 ].join('\n');

package/dist/server/services/agent/engines/codex/server-requests.js

@@ -36,12 +36,23 @@ export function handleServerRequest(args) {
     }
     if (method === 'item/tool/requestUserInput') {
         register(callId, { requestId, kind: 'user_input', payload: p });
+        // Codex allows a free-form question to omit `options` (or send null),
+        // while the shared question panel always renders an array. Keep Codex's
+        // `id` so the UI can return the protocol key instead of the display text.
+        const questions = Array.isArray(p.questions)
+            ? p.questions.map((question) => {
+                if (!question || typeof question !== 'object')
+                    return question;
+                const raw = question;
+                return { ...raw, options: Array.isArray(raw.options) ? raw.options : [] };
+            })
+            : [];
         emit({
             kind: 'session:user-input-requested',
             requestKind: 'question',
             toolCallId: callId,
             toolName: 'AskUserQuestion',
-            payload: { questions: p.questions },
+            payload: { questions, autoResolutionMs: p.autoResolutionMs },
         });
         return true;
     }