@loicngr/kobo 2.1.13 → 2.1.16

package/dist/server/index.js

@@ -32,9 +32,10 @@ import soundsRouter from './routes/sounds.js';
 import templatesRouter from './routes/templates.js';
 import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.js';
+import workspaceMessagesRouter from './routes/workspace-messages.js';
 import workspaceTemplatesRouter from './routes/workspace-templates.js';
 import workspacesRouter from './routes/workspaces.js';
-import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, setBackendPort, startAgent, startWatchdog, stopAgentAndWait, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
+import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, resumePendingReviewReturns, setBackendPort, startAgent, startWatchdog, stopAgentAndWait, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
 import * as autoLoopService from './services/auto-loop-service.js';
 import { startAwaitingUserReminder, stopAwaitingUserReminder } from './services/awaiting-user-reminder-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
@@ -57,6 +58,7 @@ import { startUpdateChecker, stopUpdateChecker } from './services/update-check-s
 import { startUsagePoller, stopUsagePoller } from './services/usage/index.js';
 import * as wakeupService from './services/wakeup-service.js';
 import { handleConnection, setMessageHandler } from './services/websocket-service.js';
+import { reconcileGroupMessageBatches, stopGroupMessageBatches } from './services/workspace-group-message-service.js';
 import { deliverWorkspaceMessage } from './services/workspace-message-service.js';
 import { getWorkspace } from './services/workspace-service.js';
 import { resolveRetentionConfig } from './services/ws-events-retention-service.js';
@@ -84,6 +86,7 @@ catch (err) {
 }
 runMigrations(db);
 reconcileMessageRequests(db);
+reconcileGroupMessageBatches(db);
 reconcileMemoryContextsOnStartup();
 startSearchIndex();
 // Event retention. OPT-IN: disabled by default, so this is a no-op until the
@@ -155,6 +158,7 @@ app.use('/api/*', networkAuthMiddleware);
 app.get('/api/health', (c) => c.json({ status: 'ok', version: getPackageVersion() }));
 // Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
+app.route('/api/workspace-messages', workspaceMessagesRouter);
 app.route('/api/mcp', mcpRouter);
 app.route('/api/memory', memoryRouter);
 app.route('/api/pull-requests', pullRequestsRouter);
@@ -240,6 +244,7 @@ const server = serve({
     // ephemeral or SERVER_PORT-selected port. Quota ownership comes first.
     restoreRetryCountsFromDb();
     quotaBackoffService.restoreOnBoot((workspaceId, pending) => autoLoopService.onQuotaBackoffExpired(workspaceId, pending));
+    resumePendingReviewReturns();
     autoLoopService.rehydrate();
     wakeupService.rehydrate();
     cronService.restoreOnBoot();
@@ -412,6 +417,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
         return;
     isShuttingDown = true;
     stopUpdateChecker();
+    const groupMessagesStopped = stopGroupMessageBatches();
     console.log(`\n[kobo] Received ${signal}, shutting down gracefully…`);
     const forceExitTimer = setTimeout(() => {
         console.error('[kobo] Graceful shutdown timed out; forcing exit');
@@ -478,6 +484,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
     finally {
         try {
             const stopped = await Promise.allSettled([
+                groupMessagesStopped,
                 stopWsEventsRetention(),
                 stopSearchIndex(),
                 dailyBackupScheduler.stop(),

package/dist/server/routes/mcp.js

@@ -4,21 +4,73 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName } from '../../shared/memory-tools.js';
+import { isWorkspaceCreationTool, MAX_MCP_CREATION_REQUEST_BYTES, WORKSPACE_CREATION_TOOLS, } from '../../shared/workspace-creation-tools.js';
 import { EXTERNAL_MCP_TOOLS } from '../../shared/workspace-dialogue-tools.js';
+import { isWorkspaceGroupMessageTool, WORKSPACE_GROUP_MESSAGE_TOOLS, } from '../../shared/workspace-group-message-tools.js';
+import { isWorkspaceLifecycleTool, WORKSPACE_LIFECYCLE_TOOLS } from '../../shared/workspace-lifecycle-tools.js';
 import { createMcpClientContext } from '../services/mcp-client-context.js';
 import { executeMemoryMcpTool } from '../services/memory-mcp-service.js';
+import { executeWorkspaceCreationTool, WorkspaceCreationMcpError } from '../services/workspace-creation-mcp-service.js';
 import { executeWorkspaceDialogueTool } from '../services/workspace-dialogue-service.js';
+import { executeWorkspaceGroupMessageTool, WorkspaceGroupMessageMcpError, } from '../services/workspace-group-message-mcp-service.js';
+import { executeWorkspaceLifecycleTool, WorkspaceLifecycleMcpError, } from '../services/workspace-lifecycle-mcp-service.js';
 import { prepareMemoryToolEnvelope } from '../utils/memory-token-budget.js';
 const app = new Hono();
-app.use('*', bodyLimit({ maxSize: 1024 * 1024 }));
+// Only creation envelopes may carry the larger, base64 attachment payload.
+// Other tools retain their existing 1 MiB limit, including malformed envelopes.
+app.use('*', bodyLimit({ maxSize: MAX_MCP_CREATION_REQUEST_BYTES }));
+app.use('*', async (c, next) => {
+    if (c.req.raw.body) {
+        const body = await c.req.raw.clone().arrayBuffer();
+        if (body.byteLength > 1024 * 1024) {
+            let creation = false;
+            try {
+                const envelope = JSON.parse(new TextDecoder().decode(body));
+                creation = envelope?.method === 'tools/call' && envelope?.params?.name === 'create_workspace';
+            }
+            catch {
+                /* Preserve the normal body-size rejection for malformed input. */
+            }
+            if (!creation)
+                return c.json({ error: 'MCP request is too large' }, 413);
+        }
+    }
+    return next();
+});
+/** Dispatch only the supported MCP operations through the existing UI handlers. */
+async function dispatchWorkspaceRequest(pathname, init) {
+    if (pathname === '/api/workspaces/archived')
+        throw new Error('Bulk operations are not supported by workspace MCP tools');
+    const isWorkspaceOperation = (init.method === 'POST' &&
+        (pathname === '/api/workspaces' ||
+            /^\/api\/workspaces\/[^/]+\/(unarchive|archive|purge-worktree|restore-worktree)$/.test(pathname))) ||
+        ((init.method === 'GET' || init.method === 'DELETE') && /^\/api\/workspaces\/[^/]+$/.test(pathname));
+    if (isWorkspaceOperation) {
+        const { default: routes } = await import('./workspaces.js');
+        return routes.request(`http://kobo.internal${pathname.slice('/api/workspaces'.length) || '/'}`, init);
+    }
+    if (init.method === 'POST' &&
+        (pathname === '/api/pull-requests/diagnose' || pathname === '/api/pull-requests/resolve')) {
+        const { default: routes } = await import('./pull-requests.js');
+        return routes.request(`http://kobo.internal${pathname.slice('/api/pull-requests'.length)}`, init);
+    }
+    throw new Error('Unsupported workspace operation');
+}
 app.all('/', async (c) => {
     const server = new Server({ name: 'kobo-workspaces', version: '1.0.0' }, { capabilities: { tools: {} } });
     const transport = new WebStandardStreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
         enableJsonResponse: true,
+        maxRequestBodySize: MAX_MCP_CREATION_REQUEST_BYTES,
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...EXTERNAL_MCP_TOOLS, ...EXTERNAL_MEMORY_TOOL_DEFINITIONS],
+        tools: [
+            ...EXTERNAL_MCP_TOOLS,
+            ...WORKSPACE_CREATION_TOOLS,
+            ...WORKSPACE_LIFECYCLE_TOOLS,
+            ...WORKSPACE_GROUP_MESSAGE_TOOLS,
+            ...EXTERNAL_MEMORY_TOOL_DEFINITIONS,
+        ],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const isMemory = isMemoryToolName(request.params.name);
@@ -26,7 +78,13 @@ app.all('/', async (c) => {
             const source = createMcpClientContext(c.req.header('X-Kobo-Client-Name'), c.req.header('X-Kobo-Client-Transport') === 'stdio' ? 'stdio' : 'http', c.req.header('X-Kobo-Client-Name-Encoding'));
             const data = isMemory
                 ? executeMemoryMcpTool(request.params.name, request.params.arguments ?? {}, source)
-                : await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
+                : isWorkspaceCreationTool(request.params.name)
+                    ? await executeWorkspaceCreationTool(request.params.name, request.params.arguments ?? {}, dispatchWorkspaceRequest)
+                    : isWorkspaceLifecycleTool(request.params.name)
+                        ? await executeWorkspaceLifecycleTool(request.params.name, request.params.arguments ?? {}, dispatchWorkspaceRequest)
+                        : isWorkspaceGroupMessageTool(request.params.name)
+                            ? executeWorkspaceGroupMessageTool(request.params.name, request.params.arguments ?? {}, source)
+                            : await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
             if (isMemory) {
                 const bounded = prepareMemoryToolEnvelope(data, { targetTokens: 1_000, transport: 'external' });
                 if (bounded.data.memoryOutputSuppressed === true)
@@ -46,6 +104,14 @@ app.all('/', async (c) => {
             };
         }
         catch (error) {
+            if (error instanceof WorkspaceGroupMessageMcpError) {
+                const data = { error: error.message, status: error.status };
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+            }
+            if (error instanceof WorkspaceCreationMcpError || error instanceof WorkspaceLifecycleMcpError) {
+                const data = { error: error.message, status: error.status, stage: error.stage, details: error.details };
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+            }
             if (isMemory) {
                 const bounded = prepareMemoryToolEnvelope({
                     error: error instanceof Error ? error.message : String(error),

package/dist/server/routes/workspace-messages.js

@@ -0,0 +1,22 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { MAX_GROUP_MESSAGE_REQUEST_BYTES } from '../../shared/workspace-group-messages.js';
+import { GroupMessageError, getGroupMessageBatch, startGroupMessageBatch, } from '../services/workspace-group-message-service.js';
+const app = new Hono();
+app.use('*', bodyLimit({ maxSize: MAX_GROUP_MESSAGE_REQUEST_BYTES }));
+app.post('/', async (c) => {
+    const body = await c.req.json().catch(() => null);
+    try {
+        return c.json(startGroupMessageBatch(body), 202);
+    }
+    catch (error) {
+        if (error instanceof GroupMessageError)
+            return c.json({ error: error.message }, error.status);
+        throw error;
+    }
+});
+app.get('/:id', (c) => {
+    const batch = getGroupMessageBatch(c.req.param('id'));
+    return batch ? c.json(batch) : c.json({ error: 'Group message not found' }, 404);
+});
+export default app;

package/dist/server/routes/workspaces.js

@@ -2,6 +2,8 @@ import { execFile as execFileCb, execFileSync, spawn } from 'node:child_process'
 import { promisify } from 'node:util';
 import { nanoid } from 'nanoid';
 import { isWorkflowPolicy, resolveWorkflowPolicy, WORKFLOW_ACTIONS, } from '../../shared/workflow-policy.js';
+import * as finalReviewService from '../services/auto-loop-final-review-service.js';
+import { getReviewReturnStatus } from '../services/review-return-service.js';
 import { getSearchIndexStatus, searchEvents } from '../services/search-service.js';
 import { createSessionHandoff, decideSessionHandoff, getCurrentSessionHandoff, SessionHandoffError, submitSessionHandoff, waitForSessionHandoff, } from '../services/session-handoff-service.js';
 import { AgentStopError, assertAgentStopped } from '../utils/agent-stop-result.js';
@@ -103,8 +105,16 @@ app.use('/:id/*', async (c, next) => {
     }
     await next();
 });
-// These handlers own teardown across awaits; purge/delete/restore own their guard in the service.
-for (const route of ['/:id/archive', '/:id/run-setup-script', '/:id/cancel-source-change', '/:id/rollback-file']) {
+// Branch/path mutations must also exclude teardown across awaits.
+// Purge/delete/restore own their guard in the service.
+for (const route of [
+    '/:id/archive',
+    '/:id/run-setup-script',
+    '/:id/cancel-source-change',
+    '/:id/rollback-file',
+    '/:id/rename-branch',
+    '/:id/resync-branch',
+]) {
     app.use(route, async (c, next) => {
         try {
             await withWorkspaceLifecycleGuard(c.req.param('id'), next);
@@ -466,6 +476,14 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
     let setupScriptConfigured = false;
     try {
         const { body, attachments } = await readWorkspaceCreationRequest(c.req.raw);
+        if (body.autoLoopFinalReview !== undefined) {
+            try {
+                finalReviewService.parseFinalReviewConfiguration(body.autoLoopFinalReview);
+            }
+            catch (error) {
+                return c.json({ error: error instanceof Error ? error.message : 'Invalid final review configuration' }, 400);
+            }
+        }
         if (body.workflowPolicy !== undefined && !isWorkflowPolicy(body.workflowPolicy))
             return c.json({ error: 'Invalid workflowPolicy' }, 400);
         // workingBranch is derived from git when worktreePath is provided, so
@@ -560,6 +578,7 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
         // the working branch from git itself — the body.workingBranch is ignored.
         let useReusedWorktree = false;
         let reusedDerivedBranch = null;
+        let reusedIdentity = null;
         if (body.worktreePath) {
             currentStep = 'inspect-worktree';
             emitCreateProgress(creationId, currentStep);
@@ -588,6 +607,14 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
                     return c.json({ error: failure, step: 'inspect-worktree' }, 422);
                 }
                 reusedDerivedBranch = branch;
+                const directory = fs.statSync(body.worktreePath);
+                const gitEntry = fs.statSync(path.join(body.worktreePath, '.git'));
+                reusedIdentity = {
+                    device: directory.dev,
+                    inode: directory.ino,
+                    gitDevice: gitEntry.dev,
+                    gitInode: gitEntry.ino,
+                };
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -771,6 +798,36 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
         const creation = await withGitRepoLock(body.projectPath, async () => {
             let prospectiveWorktreePath;
             if (useReusedWorktree) {
+                // Imports above may yield long enough for a failed PR creation to remove
+                // its checkout. Recheck the exact directory and branch under the same
+                // repository lock as compensation before any record/context files exist.
+                try {
+                    const worktreePath = body.worktreePath;
+                    const directory = fs.statSync(worktreePath);
+                    const gitEntry = fs.statSync(path.join(worktreePath, '.git'));
+                    const commonDir = execFileSync('git', ['-C', worktreePath, 'rev-parse', '--path-format=absolute', '--git-common-dir'], {
+                        encoding: 'utf-8',
+                        timeout: 30_000,
+                    }).trim();
+                    const branch = execFileSync('git', ['-C', worktreePath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+                        encoding: 'utf-8',
+                        timeout: 30_000,
+                    }).trim();
+                    if (!reusedIdentity ||
+                        !directory.isDirectory() ||
+                        directory.dev !== reusedIdentity.device ||
+                        directory.ino !== reusedIdentity.inode ||
+                        gitEntry.dev !== reusedIdentity.gitDevice ||
+                        gitEntry.ino !== reusedIdentity.gitInode ||
+                        realPathOrResolved(commonDir) !== realPathOrResolved(path.join(body.projectPath, '.git')) ||
+                        branch !== reusedDerivedBranch)
+                        throw new Error('The worktree directory, repository or branch changed during creation; retry from a fresh diagnosis');
+                }
+                catch (err) {
+                    const failure = `Failed to revalidate worktree: ${err instanceof Error ? err.message : String(err)}`;
+                    emitCreateFailed(creationId, 'inspect-worktree', failure);
+                    return c.json({ error: failure, step: 'inspect-worktree' }, 422);
+                }
                 // Another attachment may have completed while this request waited for the lock.
                 const existing = getDb().prepare('SELECT id FROM workspaces WHERE worktree_path = ?').get(body.worktreePath);
                 if (existing) {
@@ -821,6 +878,8 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
                 ...(useReusedWorktree ? {} : { worktreesPath: globalSettings.worktreesPath }),
             });
             createdWorkspace = workspace;
+            if (body.autoLoopFinalReview !== undefined)
+                finalReviewService.configureFinalReview(workspace.id, body.autoLoopFinalReview);
             // 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) {
@@ -1700,6 +1759,54 @@ app.get('/auto-loop-states', (c) => {
     }
 });
 app.route('/', autoLoopMessagesRoutes);
+app.get('/:id/auto-loop/final-review', (c) => {
+    const id = c.req.param('id');
+    if (!workspaceService.getWorkspace(id))
+        return c.json({ error: 'Workspace not found' }, 404);
+    return c.json(finalReviewService.getFinalReviewStatus(id));
+});
+app.patch('/:id/auto-loop/final-review', migrationGuard, async (c) => {
+    try {
+        const body = await c.req.json();
+        return c.json(finalReviewService.configureFinalReview(c.req.param('id'), body?.configuration));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Invalid request' }, error instanceof ReviewRequestError ? error.status : 400);
+    }
+});
+app.post('/:id/auto-loop/final-review/report', migrationGuard, async (c) => {
+    try {
+        const body = await c.req.json();
+        return c.json(finalReviewService.submitFinalReviewReport(c.req.param('id'), body.sessionId, body.token, body.report));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Invalid review report' }, error instanceof ReviewRequestError ? error.status : 400);
+    }
+});
+app.get('/:id/review-return', (c) => {
+    const id = c.req.param('id');
+    if (!workspaceService.getWorkspace(id))
+        return c.json({ error: 'Workspace not found' }, 404);
+    return c.json(getReviewReturnStatus(id));
+});
+app.post('/:id/review-return/retry', migrationGuard, (c) => {
+    try {
+        agentManager.retryReviewReturn(c.req.param('id'));
+        return c.json(getReviewReturnStatus(c.req.param('id')));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Review recovery failed' }, 409);
+    }
+});
+app.post('/:id/review-return/cancel', migrationGuard, (c) => {
+    try {
+        agentManager.cancelReviewReturn(c.req.param('id'));
+        return c.json({ ok: true });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Review cancellation failed' }, 409);
+    }
+});
 // GET /api/workspaces/:id/auto-loop — current auto-loop status for one workspace.
 // Admission inspection never changes deadlines, pending schedules or lifecycle state.
 app.get('/:id/automatic-admission', (c) => {
@@ -1979,7 +2086,7 @@ app.delete('/:id/sessions/:sessionId', migrationGuard, (c) => {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ error: message }, message.includes('active session') ? 409 : 500);
+        return c.json({ error: message }, message.includes('active session') || err instanceof workspaceService.ReviewSessionInUseError ? 409 : 500);
     }
 });
 // POST /api/workspaces/:id/deferred-tool-use/answer — resume a deferred
@@ -3120,6 +3227,12 @@ app.post('/:id/unarchive', migrationGuard, (c) => {
         return c.json({ error: message }, workspaceErrorStatus(err));
     }
 });
+class WorkspaceBranchConfirmationError extends Error {
+    code = 'branch-confirmation-mismatch';
+    constructor() {
+        super('The workspace branch changed or does not match confirmationBranch. Confirm its current branch before deleting.');
+    }
+}
 // Shared teardown for a single workspace: stops the agent, destroys the
 // terminal, removes the owned worktree, optionally deletes local/remote
 // branches, then deletes the DB row (cascades to tasks/sessions/events).
@@ -3131,6 +3244,8 @@ async function deleteWorkspaceWithSideEffects(workspace, opts) {
         const current = workspaceService.getWorkspace(workspace.id);
         if (!current)
             throw new Error(`Workspace '${workspace.id}' not found`);
+        if (opts.confirmationBranch !== undefined && opts.confirmationBranch !== current.workingBranch)
+            throw new WorkspaceBranchConfirmationError();
         // A bulk deletion may have captured the list before restoration completed.
         if (workspace.archivedAt && !current.archivedAt) {
             throw new Error('Workspace was unarchived while deletion was pending. Retry from its current state.');
@@ -3275,7 +3390,7 @@ app.delete('/:id', migrationGuard, async (c) => {
         return c.json({ ok: true, warnings }, 200);
     }
     catch (err) {
-        if (err instanceof WorkspaceLifecycleBusyError)
+        if (err instanceof WorkspaceLifecycleBusyError || err instanceof WorkspaceBranchConfirmationError)
             return c.json({ code: err.code, error: err.message }, 409);
         const message = err instanceof Error ? err.message : String(err);
         return c.json({ error: message }, workspaceErrorStatus(err));

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

@@ -75,8 +75,19 @@ class ClaudeInputStream {
     closed = false;
     queuedForcedMessages = 0;
     unansweredMessages = new Set();
+    initialUuid;
+    initialYielded = false;
+    acceptInitial;
+    rejectInitial;
+    initialPromptAccepted = new Promise((resolve, reject) => {
+        this.acceptInitial = resolve;
+        this.rejectInitial = reject;
+    });
     constructor(initialPrompt) {
-        this.messages = [{ message: this.toUserMessage(initialPrompt), forced: false }];
+        const initial = this.toUserMessage(initialPrompt);
+        this.initialUuid = initial.uuid;
+        this.messages = [{ message: initial, forced: false }];
+        void this.initialPromptAccepted.catch(() => { });
     }
     send(text) {
         if (this.closed)
@@ -91,6 +102,7 @@ class ClaudeInputStream {
         wake?.();
     }
     close() {
+        this.rejectInitial(new Error('Claude ended before confirming consumption of the initial prompt'));
         this.closed = true;
         const wake = this.waiting;
         this.waiting = undefined;
@@ -99,6 +111,19 @@ class ClaudeInputStream {
     hasUnansweredInput() {
         return this.queuedForcedMessages > 0 || this.unansweredMessages.size > 0;
     }
+    /** Only provider-correlated foreground frames acknowledge this new prompt, never init/history/children. */
+    acknowledgeInitialInput(message) {
+        if (!this.initialYielded || ('parent_tool_use_id' in message && message.parent_tool_use_id != null))
+            return;
+        if (!['assistant', 'stream_event', 'result', 'user'].includes(message.type))
+            return;
+        const frame = message;
+        const ids = [...(frame.user_message_uuids ?? []), ...(frame.user_message_uuid ? [frame.user_message_uuid] : [])];
+        if (frame.type === 'user' && frame.uuid)
+            ids.push(frame.uuid);
+        if (ids.includes(this.initialUuid))
+            this.acceptInitial();
+    }
     acknowledgeResult(result) {
         // One Claude turn can consume several queued prompts. A result counts
         // turns, not messages: only retire the sends explicitly covered by it.
@@ -133,6 +158,8 @@ class ClaudeInputStream {
                 if (next.forced)
                     this.queuedForcedMessages--;
                 this.unansweredMessages.add(next.message.uuid);
+                if (next.message.uuid === this.initialUuid)
+                    this.initialYielded = true;
                 yield next.message;
                 continue;
             }
@@ -229,6 +256,13 @@ export function createClaudeCodeEngine() {
                 // would approve ExitPlanMode and then every edit. Anything that needs a
                 // permission, a question included, is refused outright instead.
                 if (options.readOnly) {
+                    // This capability-scoped report changes orchestration metadata only.
+                    // The backend validates its token and current reviewer session again.
+                    if (toolName === 'mcp__kobo-tasks__submit_final_review' &&
+                        options.mcpServers?.some((server) => server.name === 'kobo-tasks' &&
+                            server.env.KOBO_FINAL_REVIEW_TOKEN &&
+                            server.env.KOBO_FINAL_REVIEW_SESSION_ID))
+                        return Promise.resolve({ behavior: 'allow', updatedInput: input });
                     return Promise.resolve({
                         behavior: 'deny',
                         message: 'This is a read-only review session: do not modify anything or ask the user. Put the finding in your final report instead.',
@@ -677,6 +711,7 @@ export function createClaudeCodeEngine() {
                 turnLiveness.start();
                 try {
                     for await (const msg of q) {
+                        inputStream.acknowledgeInitialInput(msg);
                         const events = mapSdkMessage(msg, mapperState);
                         const isForeground = !('parent_tool_use_id' in msg && msg.parent_tool_use_id != null);
                         const streamingContent = hasStreamingContent(msg);
@@ -867,6 +902,7 @@ export function createClaudeCodeEngine() {
             })();
             const engineProcess = {
                 ready,
+                initialPromptAccepted: inputStream.initialPromptAccepted,
                 closed: iteratorPromise.then(() => runtimeClosed),
                 get pid() {
                     return undefined;