@loicngr/kobo 2.1.12 → 2.1.15

package/AGENTS.md

@@ -116,7 +116,8 @@ src/
 | `tasks` | workspace sub-items: title, status, `is_acceptance_criterion`, sort_order; CASCADE DELETE on workspace |
 | `agent_sessions` | agent-engine sessions: pid where applicable, engine session id, status, timestamps, model, and name |
 | `ws_events` | persisted WebSocket events for replay on reconnect: type, payload, session_id, created_at |
-| `pending_review_returns` | one-shot return from a review to its original session and LLM configuration (migration v44) |
+| `pending_review_returns` | durable review-to-source return, original LLM configuration and dispatch phase (v44, extended v52) |
+| `auto_loop_final_reviews` | configured final reviewer, review/correction cycle, scoped verdict and progress tracking (v52) |
 | `pending_wakeups` | one-row-per-workspace scheduler for the `schedule_wakeup` MCP tool: target_at (ISO UTC), prompt, reason; CASCADE DELETE on workspace |
 | `pending_quota_backoffs` | persisted quota retries and their attempt counts |
 | `pending_crons` | recurring workspace schedules and their next run |
@@ -276,6 +277,10 @@ not normal cleanup. The SDK still constructs its runtime command; Kōbō's
 `spawnClaudeCodeProcess` hook tracks actual child exit and forwards stderr.
 `EngineProcess.closed` waits for both that exit and iterator completion because
 the SDK's internal cleanup wait is bounded and can return before child exit.
+Liveness must also inspect non-empty SDK content deltas (text, thinking,
+input JSON, signature), not just mapped UI events: long reasoning/tool argument
+generation can otherwise be killed as idle. Do not count empty deltas or neutral
+metadata, or let child deltas cancel a settled parent's drain/grace.
 
 **OpenAI Codex** (`codex/`): uses the **`codex app-server` JSON-RPC protocol** (line-delimited JSON over stdio with a long-lived `codex` subprocess). The engine layers are:
 - `jsonrpc/transport.ts` + `jsonrpc/peer.ts`: generic JSON-RPC 2.0 stdio peer (request correlation, notifications, server-initiated requests)
@@ -363,11 +368,33 @@ Resume selection is scoped to the target engine; never pass a reviewer's native
 conversation id to the original engine, even after cancellation or restart.
 The report reassembles text deltas/final snapshots, is bounded to 24,000 characters,
 and links back to the complete review session through the conversation tool.
-The receiving agent is asked to summarize and await instructions before fixes.
-The intent is consumed before delivery, preventing repeated ends from sending twice.
-Errors restore settings without automatically resuming; explicit stop cancels the
-return. Startup restores interrupted-review settings without replaying a possibly
-already-delivered handoff. Preserve these guards and the auto-loop interception.
+For a manual review, the receiving agent summarizes and awaits instructions before fixes.
+The durable phase tracks `reviewing`, `ready`, `dispatching`, `unknown` and `blocked`.
+Client disconnect and server shutdown preserve the original session, configurations,
+review prompt and completed return prompt. Startup resumes an interrupted reviewer
+or a known-unsent return after admission and confirmed runtime closure. Claim the
+return before dispatch; confirm it only once the engine accepts the initial input.
+Claude's session initialization is insufficient: wait for a foreground acknowledgement
+correlated with the initial message UUID (`EngineProcess.initialPromptAccepted`).
+Codex's readiness follows the accepted `turn.start` response.
+An interrupted dispatch becomes `unknown`, with explicit retry/cancel controls;
+never automatically resend a possibly delivered summary. Explicit user stop cancels
+the continuation. Errors retain recoverable intent and restore original settings.
+
+`auto_loop_final_reviews` (migration v52) adds an optional final gate configured
+before execution. Each pass starts a separate Plan review session with its own
+engine/model/effort/instructions. Only the active reviewer capability may submit
+the structured `kobo__submit_final_review` verdict. Findings become work tasks,
+invalidate finalization, and return to the exact original working session for
+automatic corrections under its original permissions. Repeat verification and a
+fresh review until zero findings, then summarize in the source session before
+completion. The source must come from the actual loop controller/ending writer, including
+adoption of an already-running session; never infer it from UI selection. A
+reviewer resume failure invalidates only its own native conversation, preserving
+other source sessions. Confirmed capacity release wakes manual durable returns
+as well as auto-loops. Preserve the loop's admission, quota, stop and stagnation safeguards;
+prose alone cannot clear the gate. Persist this gate and manual review returns
+across restart without allowing a second writer.
 `workspace:configuration` is ephemeral and updates all four LLM settings across tabs.
 
 ### Delete confirmation

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.
 
+## 2.1.15
+
+- feat(auto-loop): add durable final reviews and correction cycles
+
+## 2.1.14
+
+- fix(auto-loop): correct banner visibility and allow dismissal
+
+## 2.1.13
+
+- fix(claude): count streaming generation as watchdog activity
+
 ## 2.1.12
 
 - fix(claude): close settled SDK sessions without false watchdogs

package/CONFIGURATION.md

@@ -615,9 +615,33 @@ receiving agent summarizes the findings and waits for your instructions before
 applying fixes. The complete review remains in its own session history.
 
 With the option off, subsequent conversation continues with the review LLM.
-When automatic return is enabled, stopping the review cancels it. If the review
-fails or Kobo restarts during it, the original settings are restored without launching the
-original agent automatically; review output already recorded remains available.
+Closing the browser or shutting down Kōbō preserves the automatic return. After a
+server restart, Kōbō resumes the interrupted review and returns its summary to the
+original conversation when capacity and quotas permit. A completed review waiting
+to return keeps its summary. Explicitly stopping the agent cancels the return.
+
+If the server stops during summary delivery and cannot confirm whether it arrived,
+the chat displays a pending return with **Retry** and **Cancel**. Inspect the original
+conversation before retrying: it may already contain that summary. A failed review
+also keeps a recoverable return instead of silently losing it.
+
+### Final review for auto-loop
+
+Enable **Final review** in the creation form or the workspace's Auto-loop panel.
+Configure the reviewer engine, model, reasoning effort and additional instructions
+in advance. Workspace templates and remembered creation preferences retain these
+settings. Each review uses a separate session in Plan mode and returns to the exact
+working session with its original LLM settings and permissions.
+
+After all work and final checks pass, Kōbō launches the reviewer. Its structured
+findings become tasks for the original agent to correct automatically. The agent
+verifies the corrections and completes final checks, then Kōbō launches a fresh
+review. This cycle continues until a review reports zero findings; the original
+session receives the result before auto-loop completes. Repeated unchanged findings
+trigger a diagnostic and bounded further attempts, then block for attention.
+Closing the client or restarting the server preserves this cycle as well as the
+return. A manual review outside auto-loop still summarizes and waits for your
+instructions before applying fixes.
 
 ## Workspace templates and duplication
 
@@ -1285,6 +1309,12 @@ agents, and 30 minutes for tools (including background Bash, workflow and MCP
 jobs). A compaction has a separate absolute 10-minute limit. Waiting for your
 answer or permission pauses the inactivity watchdog.
 
+Non-empty streaming text, reasoning, tool-argument JSON and signature fragments
+count as activity even when they are not displayed in chat. Empty deltas and
+neutral metadata do not reset inactivity, and child output cannot postpone a
+settled parent's closure. The inactivity limit measures silence, not total time
+spent generating a large plan or file.
+
 Watchdog notices remain in conversation history, but do not display a red error
 banner. Other failures retain their banners. Watchdog shutdown requests both
 cancellation and closure of the SDK transport. Kōbō still requires confirmed
@@ -1978,7 +2008,7 @@ and across Unicode normalization boundaries.
 
 ## Auto-loop completion and recovery
 
-Auto-loop remains enabled while work is unfinished. Its panel distinguishes grooming, execution and final verification from waiting, blocked, completed and stopped states. All todos and acceptance criteria must be complete, followed by a successful final verification. The final check runs again after task changes or new instructions. Empty custom finalization settings use the built-in final check.
+Auto-loop remains enabled while work is unfinished. Its panel distinguishes grooming, execution and final verification from waiting, blocked, completed and stopped states. All todos and acceptance criteria must be complete, followed by a successful final verification. The final check runs again after task changes or new instructions. Empty custom finalization settings use the built-in final check. With [Final review](#final-review-for-auto-loop) configured, completion also requires an independent review with zero findings and the summary returned to the original session. Review findings reopen work and final verification before another review.
 
 Completing an auto-loop task through MCP or HTTP requires structured verification: a non-empty `method`, `summary`, and `checks` array with named checks whose `status` is `passed`. A required test that could not run stays open (`not_run`); writing test source alone is insufficient. These are results reported by the agent, not independently executed by Kōbō.
 

package/README.md

@@ -19,7 +19,7 @@ Kōbō (工房, "workshop") turns *one agent, one terminal* into a real workflow
 |---|---|
 | **🗂️ Isolated worktrees, two engines** | Every workspace is its own git worktree and branch — parallel sessions never collide. Pick Claude Code or OpenAI Codex per workspace, and [continue in a fresh session](#fresh-sessions-and-llm-handoffs) with the same LLM or a different model/engine, preserving the worktree and mission history. |
 | **💬 Live chat, real diff review** | Streaming responses, inline Edit/Write diffs, a reasoning panel, and a Monaco diff viewer with **inline file editing**, conflict resolution, and one-click `Sync` / `Push` / `Open PR` / `Merge`. |
-| **🔁 Auto-loop, cron, wakeups** | Turn an agent loose on the task list: it works through tasks, retries on rate limits, and stops itself when there's nothing left, progress stalls, or it needs you. Cron schedules and one-shot wakeups keep workspaces moving on their own timeline. |
+| **🔁 Auto-loop, cron, wakeups** | Turn an agent loose on the task list: it works through tasks, retries on rate limits, and stops itself when there's nothing left, progress stalls, or it needs you. An optional [independent final review](CONFIGURATION.md#final-review-for-auto-loop) returns findings to the original session for automatic correction and repeats until none remain, with durable recovery after restart. Cron schedules and one-shot wakeups keep workspaces moving on their own timeline. |
 | **🔀 Create from a PR/MR, or from a ticket** | Pick an open pull/merge request from GitHub, GitLab, or Bitbucket and Kōbō resolves every local conflict for you before spinning up the workspace. Or start straight from a Notion page or a Sentry issue URL. |
 
 ## Quick start

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

@@ -8,6 +8,8 @@ import { WORKSPACE_DIALOGUE_TOOLS } from '../shared/workspace-dialogue-tools.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';
 import { callMemoryTool, isMemoryOutputSuppressed } from './memory-client.js';
 import { callWorkspaceDialogueTool } from './workspace-dialogue-client.js';
+const finalReviewToken = process.env.KOBO_FINAL_REVIEW_TOKEN;
+const finalReviewSessionId = process.env.KOBO_FINAL_REVIEW_SESSION_ID;
 const handoffId = process.env.KOBO_HANDOFF_ID;
 const handoffToken = process.env.KOBO_HANDOFF_TOKEN;
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
@@ -150,6 +152,33 @@ const TASK_ORDER_PROPERTIES = {
     },
 };
 const WORKSPACE_SCOPED_TOOLS = [
+    {
+        name: 'submit_final_review',
+        description: 'Submit the final structured verdict for this backend-owned auto-loop review, then end your turn. Include all actionable findings; use an empty findings array only when the entire mission is clear.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                summary: { type: 'string', minLength: 1, maxLength: 12000 },
+                findings: {
+                    type: 'array',
+                    maxItems: 100,
+                    items: {
+                        type: 'object',
+                        properties: {
+                            severity: { type: 'string', enum: ['critical', 'important', 'minor'] },
+                            file: { type: 'string', minLength: 1, maxLength: 1000 },
+                            line: { type: 'integer', minimum: 1 },
+                            description: { type: 'string', minLength: 1, maxLength: 4000 },
+                            recommendation: { type: 'string', minLength: 1, maxLength: 4000 },
+                        },
+                        required: ['severity', 'file', 'description', 'recommendation'],
+                    },
+                },
+            },
+            required: ['summary', 'findings'],
+        },
+        annotations: { destructiveHint: false, openWorldHint: false },
+    },
     {
         name: 'submit_session_handoff',
         description: 'Submit the final Markdown handoff requested by Kōbō for this generation turn, then end your turn. Only available during a backend-owned session transfer; does not launch or stop sessions.',
@@ -643,7 +672,9 @@ function availableTools() {
         : GLOBAL_TOOLS;
     return tools.filter((tool) => handoffId && handoffToken
         ? tool.name === 'submit_session_handoff' || tool.annotations?.readOnlyHint === true
-        : tool.name !== 'submit_session_handoff');
+        : finalReviewToken && finalReviewSessionId
+            ? tool.name === 'submit_final_review' || tool.annotations?.readOnlyHint === true
+            : tool.name !== 'submit_session_handoff' && tool.name !== 'submit_final_review');
 }
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: availableTools() }));
 /** Wrap a successful result as an MCP tool response with JSON text content. */
@@ -675,6 +706,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return fail(`Tool '${name}' requires a workspace-bound MCP session (KOBO_WORKSPACE_ID not set).`);
     }
     try {
+        if (finalReviewToken && finalReviewSessionId && !availableTools().some((tool) => tool.name === name))
+            return fail('This is a read-only final review. Only read tools and submit_final_review are available.');
+        if (name === 'submit_final_review') {
+            if (!workspaceId || !finalReviewToken || !finalReviewSessionId)
+                return fail('No final review is active for this MCP invocation.');
+            return ok(await backendRequest('POST', `/api/workspaces/${workspaceId}/auto-loop/final-review/report`, {
+                token: finalReviewToken,
+                sessionId: finalReviewSessionId,
+                report: a,
+            }));
+        }
         if (handoffId && handoffToken && !availableTools().some((tool) => tool.name === name))
             return fail('This turn is reserved for a handoff report. Only read tools and submit_session_handoff are available.');
         if (name === 'submit_session_handoff') {

package/dist/server/db/auto-loop-final-review-schema.js

@@ -0,0 +1,18 @@
+export function initAutoLoopFinalReviewSchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS auto_loop_final_reviews (
+    workspace_id TEXT PRIMARY KEY REFERENCES workspaces(id) ON DELETE CASCADE,
+    configuration TEXT NOT NULL,
+    state TEXT NOT NULL DEFAULT 'pending',
+    cycle INTEGER NOT NULL DEFAULT 0,
+    findings_count INTEGER,
+    reason TEXT,
+    review_session_id TEXT REFERENCES agent_sessions(id) ON DELETE SET NULL,
+    original_session_id TEXT REFERENCES agent_sessions(id) ON DELETE SET NULL,
+    token TEXT,
+    verdict TEXT,
+    previous_findings TEXT,
+    stagnant_cycles INTEGER NOT NULL DEFAULT 0,
+    return_prompt TEXT,
+    updated_at TEXT NOT NULL
+  )`);
+}

package/dist/server/db/migrations.js

@@ -1,7 +1,8 @@
+import { initAutoLoopFinalReviewSchema } from './auto-loop-final-review-schema.js';
 import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { migrateMemorySchema } from './memory-schema.js';
-import { initReviewReturnSchema } from './review-return-schema.js';
+import { initReviewReturnSchema, migrateDurableReviewReturns } from './review-return-schema.js';
 import { initSchema } from './schema.js';
 import { initSearchSchema } from './search-schema.js';
 import { initSessionHandoffSchema } from './session-handoff-schema.js';
@@ -799,6 +800,14 @@ export const migrations = [
         name: 'persistent-memory-schema',
         migrate: migrateMemorySchema,
     },
+    {
+        version: 52,
+        name: 'durable-final-reviews',
+        migrate(db) {
+            migrateDurableReviewReturns(db);
+            initAutoLoopFinalReviewSchema(db);
+        },
+    },
 ];
 /** 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/review-return-schema.js

@@ -5,6 +5,23 @@ export function initReviewReturnSchema(db) {
     original_session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
     original_configuration TEXT NOT NULL,
     review_configuration TEXT NOT NULL,
-    created_at TEXT NOT NULL
+    created_at TEXT NOT NULL,
+    phase TEXT NOT NULL DEFAULT 'reviewing',
+    review_prompt TEXT,
+    return_prompt TEXT,
+    last_error TEXT
   )`);
 }
+/** v52: retain the return intent and its dispatch boundary across server restarts. */
+export function migrateDurableReviewReturns(db) {
+    const columns = new Set(db.prepare('PRAGMA table_info(pending_review_returns)').all().map((row) => row.name));
+    for (const [name, declaration] of Object.entries({
+        phase: "TEXT NOT NULL DEFAULT 'reviewing'",
+        review_prompt: 'TEXT',
+        return_prompt: 'TEXT',
+        last_error: 'TEXT',
+    })) {
+        if (!columns.has(name))
+            db.exec(`ALTER TABLE pending_review_returns ADD COLUMN ${name} ${declaration}`);
+    }
+}

package/dist/server/db/schema.js

@@ -1,3 +1,4 @@
+import { initAutoLoopFinalReviewSchema } from './auto-loop-final-review-schema.js';
 import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { initMemorySchema } from './memory-schema.js';
@@ -236,6 +237,7 @@ export function initSchema(db) {
     initMcpMessageSchema(db);
     initReviewReturnSchema(db);
     initAutoLoopSchema(db);
+    initAutoLoopFinalReviewSchema(db);
     initSessionHandoffSchema(db);
     initMemorySchema(db);
 }

package/dist/server/index.js

@@ -34,7 +34,7 @@ import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.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';
@@ -240,6 +240,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();

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';
@@ -466,6 +468,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
@@ -821,6 +831,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 +1712,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 +2039,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

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;
             }
@@ -145,6 +172,24 @@ class ClaudeInputStream {
         return { type: 'user', uuid: randomUUID(), message: { role: 'user', content: text }, parent_tool_use_id: null };
     }
 }
+/** Generation can be active without any user-visible mapped event. */
+function hasStreamingContent(msg) {
+    if (msg.type !== 'stream_event' || msg.event.type !== 'content_block_delta')
+        return false;
+    const delta = msg.event.delta;
+    switch (delta.type) {
+        case 'text_delta':
+            return delta.text.length > 0;
+        case 'thinking_delta':
+            return delta.thinking.length > 0;
+        case 'input_json_delta':
+            return delta.partial_json.length > 0;
+        case 'signature_delta':
+            return delta.signature.length > 0;
+        default:
+            return false;
+    }
+}
 export function createClaudeCodeEngine() {
     return {
         id: 'claude-code',
@@ -211,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.',
@@ -659,13 +711,16 @@ 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);
                         const foregroundProgress = isForeground &&
-                            events.some((ev) => ev.kind === 'message:text' ||
-                                ev.kind === 'message:thinking' ||
-                                ev.kind === 'tool:call' ||
-                                ev.kind === 'tool:result');
+                            (streamingContent ||
+                                events.some((ev) => ev.kind === 'message:text' ||
+                                    ev.kind === 'message:thinking' ||
+                                    ev.kind === 'tool:call' ||
+                                    ev.kind === 'tool:result'));
                         // A parent continuation owns the foreground again. Background
                         // progress notifications alone do not end the between-turn wait.
                         if (foregroundProgress) {
@@ -847,6 +902,7 @@ export function createClaudeCodeEngine() {
             })();
             const engineProcess = {
                 ready,
+                initialPromptAccepted: inputStream.initialPromptAccepted,
                 closed: iteratorPromise.then(() => runtimeClosed),
                 get pid() {
                     return undefined;