@loicngr/kobo 2.1.13 → 2.1.16

package/AGENTS.md

@@ -116,13 +116,15 @@ 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 |
 | `session_event_metrics` / `usage_snapshots` | session event counters and provider usage snapshots |
 | `workspace_activity` | significant lifecycle/PR events for the absence digest |
 | `search_*` | derived logical-message search index and indexing progress; see `search-schema.ts` |
+| `workspace_message_batches` | immutable recipient snapshots, request fingerprint and per-recipient delivery outcomes (v53); no stored message body |
 | `mcp_message_requests` | durable external-message idempotency ledger; independent of event retention |
 | `schema_migrations` | applied migration versions, names and timestamps |
 | `workspace_chat_history` | chat-input history per workspace: message text + `created_at`, ordered by autoincrement id, capped at 200 entries by the service; CASCADE DELETE on workspace |
@@ -210,6 +212,8 @@ Claude SDK `task_*` messages cover agents **and** background jobs. Preserve `tas
 
 ### External MCP dialogue and update checks
 
+Workspace-bound stdio, global stdio and HTTP expose shared `create_workspace` / `diagnose_workspace_pr` definitions in `src/shared/workspace-creation-tools.ts`. Stdio forwards them to the backend. `workspace-creation-mcp-service.ts` validates inputs and dispatches through the existing workspace and PR routes in process; preserve UI validation, checkout fingerprints, lifecycle guards and rollback. Inputs use snake_case except the existing camelCase PR checkout decisions. Attachments are inline base64, bounded to the shared 10-file/50 MiB decoded limit before checkout mutations. Keep SDK HTTP/stdio limits aligned with the shared creation envelope budget. Only creation envelopes get the larger base64 HTTP body budget; ordinary MCP requests remain 1 MiB. After a known PR creation failure, rollback only a checkout proven newly created, unchanged, clean (including ignored files) and unowned, under the Git repository lock; retain other checkouts and expose recovery details. Do not retry uncertain creation automatically or treat `creation_id` as an idempotency key. Restricted review/handoff launches cannot create workspaces or invoke lifecycle mutations. Shared lifecycle tools (`workspace-lifecycle-tools.ts` / `workspace-lifecycle-mcp-service.ts`) also expose archive, purge, delete, unarchive and restore through the same transports. Reject reserved/bulk/path-like IDs, require explicit purge/delete flags, and preserve warnings. Single-workspace DELETE accepts optional `confirmationBranch`, rechecked under its lifecycle guard before stopping processes; MCP always supplies it. Branch rename/resync share this guard so the confirmed branch and checkout path cannot change during teardown. Recovery uses `restore-worktree` before unarchive and never starts an agent.
+
 `POST /api/mcp` exposes stateless Streamable HTTP discovery/dialogue tools, behind the existing Host/Origin and network-token gates. The global stdio server forwards dialogue calls through this backend so agent runtime ownership remains centralized. `workspace-message-service.ts` shares delivery with WebSocket chat.
 
 Optional `send_workspace_message.idempotency_key` uses `mcp_message_requests` (migration v43). Reserve before dispatch, preserve fingerprints and terminal outcomes, and never automatically resend an unfinished request after restart. The user event and accepted receipt commit in one SQLite transaction; broadcast follows commit. Dispatch may precede persistence, so interrupted requests are explicitly `delivery_unknown`, not an exactly-once execution promise. The backend alone calls `reconcileMessageRequests` on startup. History retention does not delete the ledger; workspace deletion cascades it.
@@ -367,11 +371,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
@@ -504,6 +530,12 @@ unread events or deleting history; re-enabling resumes from the saved checkpoint
 
 `src/client/src/utils/workspace-attention.ts` derives a small set of badges (CI failure, changes-requested) from the PR snapshot + git stats stored on each workspace. `WorkspaceAttentionLabels.vue` renders them inline on the workspace cards in the left drawer. The derivation is a pure function, easy to unit-test and free of IO. Drawer cards therefore stay reactive to whatever the pr-watcher / bulk-info refresh writes back into the store.
 
+### Group workspace messages
+
+`workspace-group-message-service.ts` owns durable group receipts and a server-wide queue capped at three simultaneous delivery attempts. `/api/workspace-messages` creates a batch (202); `/:id` reads its receipt. Requests contain explicit unique workspace IDs, one content body and a stable request ID. A repeated ID is observation only; different content/recipients/source conflicts. Tags/status filters are preview helpers (OR within each group, AND across groups); archived/purged workspaces cannot receive messages. The optional `devServerRunning` preview filter (`dev_server_running` in MCP) requires exact dev-server status `running` and intersects tags/statuses. The dialog prefers the live dev-server store status over the workspace snapshot. Both UI tag filters union the global settings catalogue with assigned tags via `collectTags`; unused catalogue tags have count zero. Wait for settings and archived workspaces to load before pruning a remembered sidebar selection.
+
+Snapshot each target and its delivery mode before scheduling: auto-loop uses `next_iteration`, other workspaces normal chat. Preserve common lifecycle, human-input and compaction guards; a mode change rejects instead of silently changing behavior. For an existing controller, run `beforeDispatch` after its startup promise settles and immediately before engine delivery, so a mode change during startup is still rejected. Receipt completion means accepted/queued, not an agent reply. Persist chat event and accepted outcome transactionally; failed notification cannot undo acceptance. Startup marks pending targets `not_sent` and in-flight ones `unknown`, never replays them. Shutdown stops scheduling before draining active attempts and closing SQLite. Migration v53 and fresh schema share `initWorkspaceMessageBatchSchema`. The dialog stores its immutable request in per-tab sessionStorage for reload recovery and never POSTs automatically on reload. Keep all MCP transports on the same backend owner, launch read-only restrictions and own-workspace exclusion.
+
 ### Bulk workspace info refresh
 
 `GET /api/workspaces/info` returns `{ workspaces, prSnapshots, gitStats }` in one shot. The client polls this endpoint every 15 s so every non-archived workspace stays ≤ 15 s fresh without a per-card stats request. The poll is skipped while the browser tab is hidden and fires once immediately when the tab becomes visible again. The server-side pr-watcher feeds the same caches (`lastKnownGitStats` map, PR snapshots) so the work is shared between the polling client and the watchdog loop.

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.16
+
+- feat(workspaces): add group messaging and expand mcp lifecycle tools
+
+## 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

package/CONFIGURATION.md

@@ -502,6 +502,18 @@ Two consequences worth knowing:
 - However far behind the loop falls (a laptop waking from sleep, say), it sends
   **one** reminder per pass, not one per missed interval.
 
+## Group workspace messages
+
+Use **Group message** in the workspace drawer to send the same instruction to several workspaces. Combine tags and workspace statuses, review the named recipient list, and deselect individual workspaces before sending. Selected tags match any tag; selected statuses match any status; both filter groups must match. Enable **Only workspaces with a running development server** to further restrict the list to server status `running`; starting, stopping, stopped, unknown and failed servers are excluded. This filter updates with received server status changes. Empty filters include all non-archived, non-purged workspaces. Both the group-message tag selector and the sidebar tag filter include the saved global tag catalogue plus tags already assigned to workspaces. Unused catalogue tags remain visible (with a zero count in the sidebar); assign a tag through a workspace menu before using it to target that workspace.
+
+Auto-loop recipients receive a durable instruction for their next iteration, without stopping the loop. Other recipients use normal chat delivery, which can resume an inactive agent. Normal chat restrictions still apply: pending human questions, compaction and lifecycle operations are not bypassed. The delivery mode is fixed when submitted; a subsequent auto-loop mode change rejects that recipient rather than silently switching modes.
+
+Each batch accepts up to 200 recipients and 100,000 characters of plain text. Delivery runs on the server with at most three attempts in flight. Results distinguish sent, queued for auto-loop, rejected, not sent and uncertain delivery. **Queued** means saved for an upcoming iteration, not already processed by the agent. Failures do not stop delivery to the other recipients.
+
+Closing the dialog or disconnecting the browser does not cancel an accepted batch. The browser tab retains the request ID and original payload across reloads to recover its receipt, independently of other tabs. **Check this delivery** reuses that request and cannot duplicate accepted deliveries. After a server restart, unstarted recipients become **Not sent**, and interrupted attempts become **Delivery uncertain**; they are never resent automatically. Inspect the affected workspace's chat before creating a new message for an uncertain result.
+
+The same feature is available through internal/global stdio and external HTTP MCP; see the [MCP guide](src/mcp-server/README.md). Batch receipts retain recipient names, IDs, modes and outcomes independently of workspace deletion. The batch table stores a content fingerprint, not the message body; accepted messages retain normal workspace chat history.
+
 ## Attachments in the creation description
 
 On the create page, paste or drop files into the mission description, or use
@@ -615,9 +627,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
 
@@ -803,7 +839,7 @@ The setting lives in `settings.json` under `global` and has no UI control yet:
 
 ## External LLM access through MCP
 
-An external MCP client can connect to `http://127.0.0.1:3000/api/mcp` using Streamable HTTP (use your backend's configured port). It can discover workspaces, read their conversations, send messages to their agents and answer pending questions. The existing global stdio MCP server exposes these conversation tools too.
+An external MCP client can connect to `http://127.0.0.1:3000/api/mcp` using Streamable HTTP (use your backend's configured port). It can create workspaces with the same options as the form, diagnose and check out existing PRs, discover workspaces, read their conversations, send messages and answer pending questions. Workspace-bound stdio, global stdio and HTTP share the creation contract, including brainstorm settings, final auto-loop review, workflow policy, imports, existing worktrees, comparison grouping and inline attachments. All three transports also expose archive, disk-space purge, permanent deletion with explicit branch confirmation, unarchive and recovery of purged worktrees. See the [creation and PR guide](src/mcp-server/README.md#create_workspace) for fields, explicit checkout decisions and timeout/retry behavior.
 
 Remote HTTP clients follow the [network access](#network-access) settings and supply the Kōbō token as `Authorization: Bearer <token>` or `X-Kobo-Token`. The endpoint uses the same Host/Origin and reverse-proxy policy as the rest of the backend. No network setting is changed automatically.
 
@@ -1984,7 +2020,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,9 +19,11 @@ 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. |
 
+Use [group messages](CONFIGURATION.md#group-workspace-messages) to send one instruction to selected workspaces, filtered by tags and status, from the interface or MCP. Auto-loops receive it on their next iteration; each recipient has a durable delivery result.
+
 ## Quick start
 
 Requires Node.js ≥ 24.15, Git, Bash and your own Claude Code **or** Codex authentication. No skill plugin or ticket integration is required. Kōbō is a local, single-user tool; each user installs their own instance.
@@ -51,7 +53,7 @@ Kōbō's production build is an installable PWA — use your browser's **Install
 - **Attachments from the first prompt**: paste, drop or attach screenshots, Markdown, text files or PDFs to the creation description or workspace chat. Kōbō copies them into the worktree for the agent. See [creation attachments](./CONFIGURATION.md#attachments-in-the-creation-description) and [chat attachments](./CONFIGURATION.md#attachments-in-workspace-chat).
 
 - **Command palette & search**: `/` autocompletes skills and commands, `@` fuzzy-completes worktree file paths, `Ctrl+F` searches readable messages, `Ctrl+K` opens a command palette. The global search page deep-links to the same spot.
-- **MCP toolset (`kobo-tasks`)**: task/acceptance-criteria CRUD, dev server control, a unified `get_ticket` (Notion or Sentry), cross-workspace conversation search, per-session usage, and a `.ai/thoughts` decision log — see the [MCP guide](./src/mcp-server/README.md#tools). External MCP clients can also discover workspaces, read conversations, send messages, and answer questions through HTTP or global stdio.
+- **MCP toolset (`kobo-tasks`)**: task/acceptance-criteria CRUD, dev server control, a unified `get_ticket` (Notion or Sentry), cross-workspace conversation search, per-session usage, and a `.ai/thoughts` decision log — see the [MCP guide](./src/mcp-server/README.md#tools). Internal and external MCP clients can create fully configured workspaces, including final auto-loop review, attachments and checkout of an existing PR. HTTP and stdio clients can also archive, purge, delete or restore workspaces, read conversations, send messages, and answer questions.
 
   ![Sub-agents panel showing parallel tool calls](docs/assets/images/sub-agents-panel.png)
 - **Multi-forge Git panel**: GitHub (`gh`), GitLab (`glab`), or Bitbucket Community (`bkt`), auto-detected from the remote — `Open PR`, `Merge ready PR`, `Change PR base`, `Change source branch`, all from the UI.

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

@@ -4,10 +4,15 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getDb } from '../server/db/index.js';
 import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName, MEMORY_TOOL_DEFINITIONS } from '../shared/memory-tools.js';
+import { isWorkspaceCreationTool, MAX_MCP_CREATION_REQUEST_BYTES, WORKSPACE_CREATION_TOOLS, } from '../shared/workspace-creation-tools.js';
 import { WORKSPACE_DIALOGUE_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 { 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 +155,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.',
@@ -537,6 +569,9 @@ const WORKSPACE_SCOPED_TOOLS = [
 ];
 const GLOBAL_TOOLS = [
     ...WORKSPACE_DIALOGUE_TOOLS,
+    ...WORKSPACE_CREATION_TOOLS,
+    ...WORKSPACE_LIFECYCLE_TOOLS,
+    ...WORKSPACE_GROUP_MESSAGE_TOOLS,
     ...EXTERNAL_MEMORY_TOOL_DEFINITIONS,
     {
         name: 'list_workspaces',
@@ -558,63 +593,6 @@ const GLOBAL_TOOLS = [
         },
         annotations: { readOnlyHint: true, openWorldHint: false },
     },
-    {
-        name: 'create_workspace',
-        description: 'Create a new Kōbō workspace (git worktree + agent session), like the "Créer" button on the Create page. Requires the Kōbō backend server to be running and reachable at KOBO_BACKEND_URL. name/project_path/source_branch/working_branch are mandatory — unlike the UI, this API does not auto-derive a branch name from the workspace name.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Workspace display name.' },
-                project_path: { type: 'string', description: 'Absolute path to the project on disk.' },
-                source_branch: { type: 'string', description: 'Branch to base the new worktree on (e.g. "develop").' },
-                working_branch: {
-                    type: 'string',
-                    description: 'New branch name for the worktree (e.g. "feature/my-thing").',
-                },
-                model: { type: 'string', description: 'Model id override (optional, defaults to project/global setting).' },
-                reasoning_effort: { type: 'string', description: 'Reasoning effort override (optional).' },
-                engine: { type: 'string', description: 'Agent engine id, e.g. "claude-code" or "codex" (optional).' },
-                description: { type: 'string', description: 'Task description / initial brainstorming prompt (optional).' },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Workspace tags to assign at creation (optional).',
-                },
-                tasks: { type: 'array', items: { type: 'string' }, description: 'Initial manual task titles (optional).' },
-                acceptance_criteria: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Initial manual acceptance criteria (optional).',
-                },
-                agent_permission_mode: {
-                    type: 'string',
-                    enum: ['plan', 'bypass', 'strict', 'interactive'],
-                    description: 'Permission mode for the new session (optional).',
-                },
-                auto_loop: { type: 'boolean', description: 'Start the workspace in auto-loop mode (optional).' },
-                auto_loop_session_mode: {
-                    type: 'string',
-                    enum: ['per_task', 'continuous'],
-                    description: "Auto-loop session mode when auto_loop is true (optional, default 'per_task').",
-                },
-                skip_setup_script: { type: 'boolean', description: "Skip the project's setup script (optional)." },
-            },
-            required: ['name', 'project_path', 'source_branch', 'working_branch'],
-        },
-        annotations: { destructiveHint: false, openWorldHint: false },
-    },
-    {
-        name: 'archive_workspace',
-        description: 'Archive a workspace by id, like the "Archiver" action in the workspace context menu. Requires the Kōbō backend server to be running.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                workspace_id: { type: 'string', description: 'Workspace id, from list_workspaces.' },
-            },
-            required: ['workspace_id'],
-        },
-        annotations: { destructiveHint: false, openWorldHint: false },
-    },
     {
         name: 'stop_workspace',
         description: 'Force-stop the currently running agent session on a workspace, like the red "Arrêter" button in the chat header. Requires the Kōbō backend server to be running. Safe to call when nothing is running.',
@@ -643,7 +621,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 +655,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') {
@@ -709,8 +700,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     : {}),
             };
         }
-        if (WORKSPACE_DIALOGUE_TOOLS.some((tool) => tool.name === name)) {
-            if (workspaceId && a.workspace_id === workspaceId && name === 'send_workspace_message')
+        if (isWorkspaceCreationTool(name) ||
+            isWorkspaceLifecycleTool(name) ||
+            isWorkspaceGroupMessageTool(name) ||
+            WORKSPACE_DIALOGUE_TOOLS.some((tool) => tool.name === name)) {
+            if (workspaceId &&
+                ((a.workspace_id === workspaceId && name === 'send_workspace_message') ||
+                    (name === 'send_workspace_group_message' &&
+                        Array.isArray(a.workspace_ids) &&
+                        a.workspace_ids.includes(workspaceId))))
                 return fail('Use the normal conversation to communicate in your own workspace.');
             return await callWorkspaceDialogueTool(backendUrl, name, a, process.env.KOBO_NETWORK_TOKEN, process.env.KOBO_MCP_CLIENT_NAME ?? server.getClientVersion()?.name);
         }
@@ -983,50 +981,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const tag = typeof a.tag === 'string' ? a.tag : undefined;
             return ok(listWorkspacesHandler(db, { includeArchived, tag }));
         }
-        if (name === 'create_workspace') {
-            const workspaceName = a.name;
-            const projectPath = a.project_path;
-            const sourceBranch = a.source_branch;
-            const workingBranch = a.working_branch;
-            if (!workspaceName || !projectPath || !sourceBranch || !workingBranch) {
-                return fail('name, project_path, source_branch, and working_branch parameters are required');
-            }
-            try {
-                const created = await backendRequest('POST', '/api/workspaces', {
-                    name: workspaceName,
-                    projectPath,
-                    sourceBranch,
-                    workingBranch,
-                    model: a.model,
-                    reasoningEffort: a.reasoning_effort,
-                    engine: a.engine,
-                    description: a.description,
-                    tags: a.tags,
-                    tasks: a.tasks,
-                    acceptanceCriteria: a.acceptance_criteria,
-                    agentPermissionMode: a.agent_permission_mode,
-                    autoLoop: a.auto_loop,
-                    autoLoopSessionMode: a.auto_loop_session_mode,
-                    skipSetupScript: a.skip_setup_script,
-                });
-                return ok(created);
-            }
-            catch (err) {
-                return fail(backendErrorMessage(err));
-            }
-        }
-        if (name === 'archive_workspace') {
-            const targetId = a.workspace_id;
-            if (!targetId)
-                return fail('workspace_id parameter is required');
-            try {
-                const result = await backendRequest('POST', `/api/workspaces/${targetId}/archive`);
-                return ok(result);
-            }
-            catch (err) {
-                return fail(backendErrorMessage(err));
-            }
-        }
         if (name === 'stop_workspace') {
             const targetId = a.workspace_id;
             if (!targetId)
@@ -1045,7 +999,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return fail(err instanceof Error ? err.message : String(err));
     }
 });
-const transport = new StdioServerTransport();
+const transport = new StdioServerTransport(process.stdin, process.stdout, {
+    // Include the JSON-lines delimiter in addition to the HTTP envelope budget.
+    maxBufferSize: MAX_MCP_CREATION_REQUEST_BYTES + 1,
+});
 server.connect(transport).catch((err) => {
     console.error('[kobo-tasks-server] Fatal:', err);
     process.exit(1);

package/dist/mcp-server/workspace-dialogue-client.js

@@ -1,15 +1,27 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { isMemoryToolName, validateMemoryToolArguments } from '../shared/memory-tools.js';
+import { isWorkspaceCreationTool, validateWorkspaceCreationArguments } from '../shared/workspace-creation-tools.js';
 import { validateDialogueArguments } from '../shared/workspace-dialogue-tools.js';
+import { isWorkspaceGroupMessageTool, validateWorkspaceGroupMessageArguments, } from '../shared/workspace-group-message-tools.js';
+import { isWorkspaceLifecycleTool, validateWorkspaceLifecycleArguments } from '../shared/workspace-lifecycle-tools.js';
 import { normalizeClientName } from '../shared/workspace-message-types.js';
 /** Stateless HTTP bridge: external stdio clients never own agent runtime state. */
 export async function callWorkspaceDialogueTool(backendUrl, name, args, token, clientName) {
     const arguments_ = isMemoryToolName(name)
         ? validateMemoryToolArguments(name, args, true)
-        : validateDialogueArguments(name, args);
+        : isWorkspaceCreationTool(name)
+            ? validateWorkspaceCreationArguments(name, args)
+            : isWorkspaceLifecycleTool(name)
+                ? validateWorkspaceLifecycleArguments(name, args)
+                : isWorkspaceGroupMessageTool(name)
+                    ? validateWorkspaceGroupMessageArguments(name, args)
+                    : validateDialogueArguments(name, args);
     const client = new Client({ name: 'kobo-stdio-bridge', version: '1.0.0' });
-    const signal = AbortSignal.timeout(30_000);
+    // Creation can include forge reads, worktree setup and user setup scripts.
+    // A timed-out creation is ambiguous and must never be retried automatically.
+    const timeout = isWorkspaceCreationTool(name) || isWorkspaceLifecycleTool(name) ? 15 * 60_000 : 30_000;
+    const signal = AbortSignal.timeout(timeout);
     const transport = new StreamableHTTPClientTransport(new URL(`${backendUrl.replace(/\/$/, '')}/api/mcp`), {
         requestInit: {
             signal,
@@ -23,7 +35,7 @@ export async function callWorkspaceDialogueTool(backendUrl, name, args, token, c
     });
     try {
         await client.connect(transport, { signal });
-        return await client.callTool({ name, arguments: arguments_ }, undefined, { signal });
+        return await client.callTool({ name, arguments: arguments_ }, undefined, { signal, timeout });
     }
     finally {
         await client.close();

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,10 +1,12 @@
+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';
+import { initWorkspaceMessageBatchSchema } from './workspace-message-batch-schema.js';
 /** Ordered registry of all schema migrations. Append new entries at the end. */
 export const migrations = [
     {
@@ -799,6 +801,15 @@ export const migrations = [
         name: 'persistent-memory-schema',
         migrate: migrateMemorySchema,
     },
+    {
+        version: 52,
+        name: 'durable-final-reviews',
+        migrate(db) {
+            migrateDurableReviewReturns(db);
+            initAutoLoopFinalReviewSchema(db);
+        },
+    },
+    { version: 53, name: 'workspace-group-message-receipts', migrate: initWorkspaceMessageBatchSchema },
 ];
 /** 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,9 +1,11 @@
+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';
 import { initReviewReturnSchema } from './review-return-schema.js';
 import { initSearchSchema } from './search-schema.js';
 import { initSessionHandoffSchema } from './session-handoff-schema.js';
+import { initWorkspaceMessageBatchSchema } from './workspace-message-batch-schema.js';
 /** Create all tables and indexes for a fresh install. Not used for upgrades -- see migrations.ts. */
 export function initSchema(db) {
     db.exec(`
@@ -236,6 +238,8 @@ export function initSchema(db) {
     initMcpMessageSchema(db);
     initReviewReturnSchema(db);
     initAutoLoopSchema(db);
+    initAutoLoopFinalReviewSchema(db);
     initSessionHandoffSchema(db);
     initMemorySchema(db);
+    initWorkspaceMessageBatchSchema(db);
 }

package/dist/server/db/workspace-message-batch-schema.js

@@ -0,0 +1,9 @@
+/** Receipts survive workspace deletion; message bodies live only in normal chat/loop storage. */
+export function initWorkspaceMessageBatchSchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS workspace_message_batches (
+    id TEXT PRIMARY KEY,
+    fingerprint TEXT NOT NULL,
+    receipt_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )`);
+}