@loicngr/kobo 2.1.28 → 2.1.30

package/README.md

@@ -1,6 +1,6 @@
 # Kōbō
 
-**Run a fleet of Claude Code and Codex agents in parallel — each in its own git worktree, all from one dashboard.**
+**Run a fleet of Claude Code, Codex and Mistral Vibe agents in parallel — each in its own git worktree, all from one dashboard.**
 
 [![npm](https://img.shields.io/npm/v/@loicngr/kobo.svg)](https://www.npmjs.com/package/@loicngr/kobo)
 [![license](https://img.shields.io/npm/l/@loicngr/kobo.svg)](./LICENSE)
@@ -17,7 +17,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. |
+| **🗂️ Isolated worktrees, three engines** | Every workspace is its own git worktree and branch — parallel sessions never collide. Pick Claude Code, OpenAI Codex or Mistral Vibe 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. 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. |
@@ -28,13 +28,13 @@ Use [group messages](CONFIGURATION.md#group-workspace-messages) to send one inst
 
 ## 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.
+Requires Node.js ≥ 26.12.1, Git, Bash and your own authentication for the chosen engine (Claude Code, Codex or Mistral Vibe). No skill plugin or ticket integration is required. Kōbō is a local, single-user tool; each user installs their own instance.
 
 ```bash
 npx @loicngr/kobo@latest
 ```
 
-Open <http://localhost:3000> and follow the first-run check. Use **Choose a folder** beside the project field to select a local Git repository; completing setup opens the mission form without launching an agent. New installs use the plugin-free **Standard** suite, **Plan** permissions, manual commit/push/publication preferences, and disabled optional integrations/audio. Existing preferences are preserved on upgrade.
+Open <http://localhost:3000> and follow the first-run check. Use **Choose a folder** beside the project field to select a local Git repository; completing setup opens the mission form without launching an agent. New installs use the plugin-free **Standard** suite, **Plan** permissions for Claude Code/Codex (**Interactive** for Mistral Vibe), manual commit/push/publication preferences, and disabled optional integrations/audio. Existing preferences are preserved on upgrade.
 
 Follow [your first mission](./docs/getting-started.md), [troubleshooting](./docs/troubleshooting.md), or the [security and privacy model](./SECURITY.md).
 
@@ -69,11 +69,11 @@ Kōbō's production build is an installable PWA — use your browser's **Install
 - **Disk-space purge**: reclaim a merged workspace's `node_modules`/`vendor` weight without losing its chat history — see [`CONFIGURATION.md`](./CONFIGURATION.md#auto-purge-worktree-on-pr-merged).
 - **Lifecycle scripts**: shell scripts run on setup, cleanup, archive, session end, PR merge, or auto-loop stop, with output streamed into the chat.
 - **Observability**: a per-session timeline (duration, tools, tokens, errors) and a downloadable redacted diagnostic JSON.
-- **Optional integrations**: Notion (import missions) and Sentry (fix from issue URL), usable by both agent engines through saved connections, each independently toggled with a **Test connection** action; local voice transcription via `whisper.cpp`.
+- **Optional integrations**: Notion (import missions) and Sentry (fix from issue URL), usable by all three agent engines through saved connections, each independently toggled with a **Test connection** action; local voice transcription via `whisper.cpp`.
 
 ### Persistent memory across engines
 
-Kōbō offers **Manual**, **Hybrid** (the default), and **Automatic** memory behavior in **Settings → Memory**. Global, project, and workspace scopes are shared by Claude Code and Codex but remain independently manageable. Hybrid applies workspace notes while asking for human approval before shared project/global changes. The workspace's right-hand **Memory** tab shows the current conversation's delivered context, pending proposals, and a provenance-aware operation journal. Memory has conservative per-response and per-conversation budgets; it cannot retract facts already transmitted into an agent or provider conversation. See the [persistent memory guide](./CONFIGURATION.md#persistent-memory) and [MCP memory tools](./src/mcp-server/README.md#persistent-memory-tools).
+Kōbō offers **Manual**, **Hybrid** (the default), and **Automatic** memory behavior in **Settings → Memory**. Global, project, and workspace scopes are shared by Claude Code, Codex and Mistral Vibe but remain independently manageable. Hybrid applies workspace notes while asking for human approval before shared project/global changes. The workspace's right-hand **Memory** tab shows the current conversation's delivered context, pending proposals, and a provenance-aware operation journal. Memory has conservative per-response and per-conversation budgets; it cannot retract facts already transmitted into an agent or provider conversation. See the [persistent memory guide](./CONFIGURATION.md#persistent-memory) and [MCP memory tools](./src/mcp-server/README.md#persistent-memory-tools).
 
 ## Fresh sessions and LLM handoffs
 
@@ -83,6 +83,8 @@ Long conversation getting crowded? Use **Continue in a fresh session** at the bo
 2. Leave **Generate a handoff with the current agent** enabled to have the current conversation summarize the objective, constraints, decisions, verified progress, failed approaches and next action. Disable it when the old provider has no quota left: Kōbō builds context from the mission, tasks, Git state and source history without calling that LLM.
 3. Start the transfer. Kōbō interrupts the current work immediately, waits for confirmed shutdown, prepares the handoff and opens a fresh native conversation that continues the mission automatically.
 
+Mistral Vibe can be a destination with a supported execution mode. When Vibe is the source, disable **Generate a handoff with the current agent**: its restricted summary launch is unsupported. Existing Plan selections are never silently promoted.
+
 The workspace, worktree, task list and conversation history remain available. The transfer links to its source session and a Markdown report in **Documents** (`.ai/handoffs/`, ignored by Git). Auto-loop keeps its intent and diagnostic budget; queued instructions retain their delivery state. Pending wakeups from the source conversation follow the fresh session once its startup is confirmed.
 
 If generation fails, choose **Retry**, **Continue without an LLM summary**, or **Cancel transfer**. Cancel and Stop leave the work stopped and restore the source conversation and LLM configuration, including when the destination failed to start. Failed attempts remain in history without being resumed automatically. If there was no source conversation, the next message starts a fresh one. A server restart preserves the transfer and report for an explicit recovery decision; it never automatically replays a potentially delivered prompt. Transfers are manual—conversation size does not trigger them automatically.
@@ -112,7 +114,7 @@ agents, while engine permissions remain a separate control.
 Notion and Sentry are optional. Save a **Direct connection** in the integration tab,
 enable it, save Settings, then use **Test connection**. Saved direct connections take
 priority over the Claude MCP selector, which is disabled while one exists. Enabled
-connections also reach Claude Code and Codex agents through `kobo-notion-*` and
+connections also reach Claude Code, Codex and Mistral Vibe agents through `kobo-notion-*` and
 `kobo-sentry-*` MCP servers. Stop and resume a running agent to apply a connection
 change. See [managed integration MCPs](./CONFIGURATION.md#managed-integration-mcps-in-agent-sessions)
 for credential priority and native-configuration scope.
@@ -131,8 +133,9 @@ Kōbō binds to `127.0.0.1` only by default. Enabling **Settings → General →
 
 - **Claude Code**: authenticate once with `claude /login`. Kōbō calls the embedded SDK directly — no separately installed Claude CLI is required at runtime; the SDK supplies its runtime.
 - **OpenAI Codex**: run `codex login` or export `OPENAI_API_KEY`. Kōbō spawns a long-lived `codex app-server` subprocess per workspace.
+- **Mistral Vibe** (experimental): install and authenticate native Vibe as the server user, with `vibe-acp` on that user's PATH. Kōbō uses ACP v1 and native model/thinking selection (Auto or discovered native values). [Setup, limits and compatibility evidence](./CONFIGURATION.md#mistral-vibe).
 
-Both engines share task tracking, permission modes, the sub-agent panel, and the quota footer. The mapping of Kōbō's four permission modes (`plan` / `bypass` / `strict` / `interactive`) to each engine's native sandbox semantics is in [`CONFIGURATION.md`](./CONFIGURATION.md#permission-modes).
+All three engines share task tracking, memory and managed MCP. Permissions and available controls depend on the engine; Mistral Vibe offers fresh reviews under native permissions (Interactive by default; no guaranteed filesystem read-only access) and excludes Plan, live steering, account/quota controls, managed skills and sub-agent cards. The mapping of Kōbō's four permission modes (`plan` / `bypass` / `strict` / `interactive`) to each engine's native permission semantics is in [`CONFIGURATION.md`](./CONFIGURATION.md#permission-modes).
 
 ## Skill suites
 
@@ -147,7 +150,7 @@ Hono backend, Vue 3 + Quasar PWA, SQLite (WAL) for persistence, WebSocket for li
 ```
 src/
 ├── server/         # Hono backend (routes, services, db, agent orchestrator)
-│   ├── services/agent/engines/  # claude-code/ + codex/ engines
+│   ├── services/agent/engines/  # claude-code/ + codex/ + mistral-vibe/ engines
 │   └── ...
 ├── client/         # Vue 3 + Quasar PWA
 ├── mcp-server/     # kobo-tasks MCP server, spawned per workspace

package/SECURITY.md

@@ -50,11 +50,16 @@ capabilities. This tool boundary does not sandbox arbitrary code executed by an
 agent or other integrations running as the same OS account.
 
 Git workflow preferences express which automatic actions are wanted. They are not
-a sandbox for arbitrary shell commands or external MCP tools. Claude and Codex
-permission modes have different enforcement mechanisms; unrestricted access can
+a sandbox for arbitrary shell commands or external MCP tools. Claude Code, Codex
+and Mistral Vibe permission modes have different enforcement mechanisms; unrestricted access can
 modify files outside a worktree. Provider authentication is separate from Kōbō's
 network token.
 
+Mistral Vibe uses native ACP execution modes and has no Plan/read-only mode.
+Review prompts forbid modifications, but native permissions do not guarantee
+filesystem read-only access. Kōbō-managed review tools and memory remain restricted
+to reads, scoped reports and progress. See [Mistral Vibe](./CONFIGURATION.md#mistral-vibe).
+
 ## Data and credentials
 
 KOBO_HOME stores conversations, workspaces, backups and settings. Direct integration

package/dist/server/db/memory-schema.js

@@ -44,7 +44,7 @@ export function initMemorySchema(db) {
       UNIQUE (scope_id, memory_key),
       CHECK (
         (actor_kind = 'human' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NULL AND transport IS NULL) OR
-        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex') AND client_name IS NULL AND transport IS NULL) OR
+        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex', 'mistral-vibe') AND client_name IS NULL AND transport IS NULL) OR
         (actor_kind = 'external-mcp' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NOT NULL AND transport IN ('http', 'stdio'))
       )
     );
@@ -73,7 +73,7 @@ export function initMemorySchema(db) {
       CHECK ((target_entry_id IS NULL AND base_revision IS NULL) OR (target_entry_id IS NOT NULL AND base_revision IS NOT NULL)),
       CHECK (
         (actor_kind = 'human' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NULL AND transport IS NULL) OR
-        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex') AND client_name IS NULL AND transport IS NULL) OR
+        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex', 'mistral-vibe') AND client_name IS NULL AND transport IS NULL) OR
         (actor_kind = 'external-mcp' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NOT NULL AND transport IN ('http', 'stdio'))
       )
     );
@@ -106,7 +106,7 @@ export function initMemorySchema(db) {
       CHECK (affected_proposals IS NULL OR affected_proposals >= 0),
       CHECK (
         (actor_kind = 'human' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NULL AND transport IS NULL) OR
-        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex') AND client_name IS NULL AND transport IS NULL) OR
+        (actor_kind = 'internal-agent' AND source_engine IN ('claude-code', 'codex', 'mistral-vibe') AND client_name IS NULL AND transport IS NULL) OR
         (actor_kind = 'external-mcp' AND source_workspace_id IS NULL AND source_session_id IS NULL AND source_engine IS NULL AND client_name IS NOT NULL AND transport IN ('http', 'stdio'))
       )
     );
@@ -122,7 +122,7 @@ export function initMemorySchema(db) {
       dispatch_id TEXT NOT NULL UNIQUE,
       budget_context_id TEXT REFERENCES memory_budget_contexts(id) ON DELETE SET NULL,
       budget_epoch INTEGER NOT NULL DEFAULT 0 CHECK (budget_epoch >= 0),
-      engine TEXT NOT NULL CHECK (engine IN ('claude-code', 'codex')),
+      engine TEXT NOT NULL CHECK (engine IN ('claude-code', 'codex', 'mistral-vibe')),
       state TEXT NOT NULL CHECK (state IN ('prepared', 'submitted', 'initialized', 'failed', 'unknown')),
       entry_revisions_json TEXT NOT NULL,
       scope_generations_json TEXT NOT NULL,
@@ -144,7 +144,7 @@ export function initMemorySchema(db) {
       id TEXT PRIMARY KEY,
       kind TEXT NOT NULL CHECK (kind IN ('internal', 'external')),
       session_id TEXT REFERENCES agent_sessions(id) ON DELETE CASCADE,
-      engine TEXT CHECK (engine IS NULL OR engine IN ('claude-code', 'codex')),
+      engine TEXT CHECK (engine IS NULL OR engine IN ('claude-code', 'codex', 'mistral-vibe')),
       conversation_key TEXT CHECK (conversation_key IS NULL OR length(trim(conversation_key)) > 0),
       native_conversation_id TEXT,
       external_context_id TEXT,

package/dist/server/db/migrations.js

@@ -2,6 +2,7 @@ import { initAutoLoopFinalReviewSchema } from './auto-loop-final-review-schema.j
 import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { migrateMemorySchema } from './memory-schema.js';
+import { migrateMistralMemoryEngine } from './mistral-memory-migration.js';
 import { initProgressBarSchema } from './progress-bar-schema.js';
 import { initReviewReturnSchema, migrateDurableReviewReturns } from './review-return-schema.js';
 import { initSchema } from './schema.js';
@@ -812,6 +813,7 @@ export const migrations = [
     },
     { version: 53, name: 'workspace-group-message-receipts', migrate: initWorkspaceMessageBatchSchema },
     { version: 54, name: 'session-progress-bars', migrate: initProgressBarSchema },
+    { version: 55, name: 'mistral-vibe-memory-engine', migrate: migrateMistralMemoryEngine },
 ];
 /** 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/mistral-memory-migration.js

@@ -0,0 +1,40 @@
+/** Rebuild only engine CHECK constraints; the migration runner owns the transaction. */
+export function migrateMistralMemoryEngine(db) {
+    // Parents precede children so replacement FKs never point at tables being dropped.
+    const tables = [
+        'memory_entries',
+        'memory_budget_contexts',
+        'memory_proposals',
+        'memory_operations',
+        'memory_contexts',
+    ];
+    const definitions = tables.map((name) => ({
+        name,
+        sql: db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get(name)
+            .sql,
+    }));
+    if (definitions.every(({ sql }) => sql.includes("'mistral-vibe'")))
+        return;
+    const indexes = tables.flatMap((name) => db
+        .prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ? AND sql IS NOT NULL")
+        .all(name));
+    const sequence = db
+        .prepare("SELECT seq FROM sqlite_sequence WHERE name = 'memory_operations'")
+        .safeIntegers()
+        .get();
+    for (const { name, sql } of definitions) {
+        let replacement = sql.replaceAll("'claude-code', 'codex'", "'claude-code', 'codex', 'mistral-vibe'");
+        for (const table of tables)
+            replacement = replacement.replaceAll(new RegExp(`\\b${table}\\b`, 'g'), `${table}_mistral`);
+        db.exec(replacement);
+        db.exec(`INSERT INTO ${name}_mistral SELECT * FROM ${name}`);
+    }
+    for (const name of [...tables].reverse())
+        db.exec(`DROP TABLE ${name}`);
+    for (const name of tables)
+        db.exec(`ALTER TABLE ${name}_mistral RENAME TO ${name}`);
+    for (const { sql } of indexes)
+        db.exec(sql);
+    if (sequence)
+        db.prepare("UPDATE sqlite_sequence SET seq = ? WHERE name = 'memory_operations'").run(sequence.seq);
+}

package/dist/server/routes/engines.js

@@ -1,5 +1,6 @@
 import { Hono } from 'hono';
 import { listEngines } from '../services/agent/engines/registry.js';
+import { getMistralOptions } from '../services/mistral-options-service.js';
 /** Hono sub-router exposing `GET /` — the list of registered agent engines with capabilities. */
 export const enginesRouter = new Hono();
 enginesRouter.get('/', (c) => c.json(listEngines().map((e) => ({
@@ -7,3 +8,16 @@ enginesRouter.get('/', (c) => c.json(listEngines().map((e) => ({
     displayName: e.displayName,
     capabilities: e.capabilities,
 }))));
+enginesRouter.get('/mistral-vibe/options', async (c) => {
+    try {
+        return c.json(await getMistralOptions({
+            workspaceId: c.req.query('workspaceId'),
+            projectPath: c.req.query('projectPath'),
+            model: c.req.query('model'),
+            agentPermissionMode: c.req.query('agentPermissionMode'),
+        }));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Native Vibe options unavailable' }, 400);
+    }
+});

package/dist/server/routes/environment.js

@@ -4,7 +4,7 @@ const app = new Hono();
 app.get('/', async (c) => {
     const engine = c.req.query('engine') ?? 'claude-code';
     const projectPath = c.req.query('projectPath')?.trim();
-    if (!['claude-code', 'codex'].includes(engine) ||
+    if (!['claude-code', 'codex', 'mistral-vibe'].includes(engine) ||
         (projectPath && (projectPath.length > 4096 || projectPath.includes('\0')))) {
         return c.json({ error: 'Invalid environment check request' }, 400);
     }

package/dist/server/routes/health.js

@@ -23,7 +23,11 @@ function integrationConfigured(integration, key) {
 }
 async function checkCli(binary) {
     try {
-        const { stdout } = await execFileAsync(binary, ['--version'], { encoding: 'utf-8', timeout: 2_000 });
+        const { stdout } = await execFileAsync(binary, ['--version'], {
+            encoding: 'utf-8',
+            timeout: 2_000,
+            maxBuffer: 64 * 1024,
+        });
         return { available: true, version: stdout.trim() || null };
     }
     catch {
@@ -78,7 +82,13 @@ app.get('/report', async (c) => {
     const db = getDb();
     const dbPath = getDbPath();
     const home = getKoboHome();
-    const cliChecks = Promise.all([checkClaudeCli(), checkCodexCli(), checkCli('gh'), checkCli('glab')]);
+    const cliChecks = Promise.all([
+        checkClaudeCli(),
+        checkCodexCli(),
+        checkCli('vibe-acp'),
+        checkCli('gh'),
+        checkCli('glab'),
+    ]);
     // DB schema version
     const row = db.prepare('SELECT MAX(version) as v FROM schema_migrations').get();
     const dbSchemaVersion = row?.v ?? 0;
@@ -170,7 +180,7 @@ app.get('/report', async (c) => {
         .all();
     const settingsRow = db.prepare('SELECT COUNT(*) as n FROM workspaces').get();
     const archivedRow = db.prepare('SELECT COUNT(*) as n FROM workspaces WHERE archived_at IS NOT NULL').get();
-    const [claudeCli, codexCli, ghCli, glabCli] = await cliChecks;
+    const [claudeCli, codexCli, mistralCli, ghCli, glabCli] = await cliChecks;
     const report = {
         version: getPackageVersion(),
         koboHome: home,
@@ -183,6 +193,7 @@ app.get('/report', async (c) => {
         settings: { schemaVersion: SETTINGS_SCHEMA_VERSION },
         claudeCli,
         codexCli,
+        mistralCli,
         forgeCli: { gh: ghCli, glab: glabCli },
         workspaces: {
             total: settingsRow.n,

package/dist/server/routes/settings.js

@@ -3,7 +3,7 @@ import { isMemoryMode } from '../../shared/memory.js';
 import { isValidSkillSuite } from '../../shared/skill-suite-prompts.js';
 import { isWorkflowPolicy } from '../../shared/workflow-policy.js';
 import { getDb } from '../db/index.js';
-import { getBackendPort } from '../services/agent/orchestrator.js';
+import { getBackendPort, notifyCapacityAvailable } from '../services/agent/orchestrator.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
 import { getMcpConnectionInfo } from '../services/mcp-connection-info-service.js';
 import { generateToken, getLanUrls } from '../services/network-access-service.js';
@@ -167,7 +167,13 @@ app.put('/global', async (c) => {
             return c.json({ error: 'Invalid workflowPolicy' }, 400);
         if (body.memoryMode !== undefined && !isMemoryMode(body.memoryMode))
             return c.json({ error: 'Invalid memoryMode' }, 400);
+        if ('maxConcurrentAgents' in body &&
+            (!Number.isSafeInteger(body.maxConcurrentAgents) || body.maxConcurrentAgents < 0))
+            return c.json({ error: 'maxConcurrentAgents must be a non-negative safe integer' }, 400);
+        const previousLimit = 'maxConcurrentAgents' in body ? settingsService.getGlobalSettings().maxConcurrentAgents : undefined;
         const updated = settingsService.updateGlobalSettings(body);
+        if (previousLimit && (updated.maxConcurrentAgents === 0 || updated.maxConcurrentAgents > previousLimit))
+            notifyCapacityAvailable();
         // The client assigns this response straight into its store, so echoing the
         // real credentials back would undo the masking on GET the first time
         // anyone saves anything.

package/dist/server/routes/workspaces.js

@@ -4,9 +4,10 @@ import { nanoid } from 'nanoid';
 import { isMergeMethod } from '../../shared/forge-merge.js';
 import { isWorkflowPolicy, resolveWorkflowPolicy, WORKFLOW_ACTIONS, } from '../../shared/workflow-policy.js';
 import * as finalReviewService from '../services/auto-loop-final-review-service.js';
+import { preflightMistralConfiguration } from '../services/mistral-options-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 { createSessionHandoff, decideSessionHandoff, getCurrentSessionHandoff, preflightSessionHandoff, SessionHandoffError, submitSessionHandoff, waitForSessionHandoff, } from '../services/session-handoff-service.js';
 import { AgentStopError, assertAgentStopped } from '../utils/agent-stop-result.js';
 import { withGitRepoLock } from '../utils/git-repo-lock.js';
 import { assertWorkspaceLifecycleAvailable, isWorkspaceLifecycleBusy, workspaceLifecycleReason, } from '../utils/workspace-lifecycle-guard.js';
@@ -18,9 +19,11 @@ import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { MAX_ATTACHMENT_REQUEST_BYTES } from '../../shared/attachments.js';
 import { AUTO_LOOP_HARD_RULES, buildAutoLoopGroomingSteps, buildGroomingIntro } from '../../shared/auto-loop-prompts.js';
+import { parseQuestionSelections } from '../../shared/question-selections.js';
 import { getDb } from '../db/index.js';
 import { migrationGuard } from '../middleware/migration-guard.js';
 import { workspaceCreationMaintenance } from '../middleware/workspace-creation-maintenance.js';
+import { assertEngineConfigurationSupported } from '../services/agent/engines/configuration.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as archiveScriptService from '../services/archive-script-service.js';
@@ -316,7 +319,7 @@ function resolveCreateAgentPermissionMode(bodyValue, _projectPath, globalSetting
     const global = globalSettings.defaultPermissionModeByEngine?.[engineId];
     if (isAgentPermissionMode(global))
         return global;
-    return 'bypass';
+    return engineId === 'mistral-vibe' ? 'interactive' : 'bypass';
 }
 /**
  * Extract the numeric PR/MR number from a forge URL.
@@ -357,7 +360,9 @@ function handoffError(c, error) {
 }
 app.post('/:id/session-handoffs', migrationGuard, async (c) => {
     try {
-        return c.json({ handoff: createSessionHandoff(c.req.param('id'), await c.req.json()) }, 202);
+        const input = await c.req.json();
+        await preflightSessionHandoff(c.req.param('id'), input);
+        return c.json({ handoff: createSessionHandoff(c.req.param('id'), input) }, 202);
     }
     catch (error) {
         return handoffError(c, error);
@@ -418,7 +423,8 @@ app.post('/:id/switch-engine', migrationGuard, async (c) => {
         const engine = listEngines().find((item) => item.id === body.engine);
         if (!engine)
             return c.json({ error: `Unknown engine '${body.engine}'` }, 400);
-        const model = typeof body.model === 'string' && engine.capabilities.models.some((item) => item.id === body.model)
+        const model = typeof body.model === 'string' &&
+            (engine.id === 'mistral-vibe' || engine.capabilities.models.some((item) => item.id === body.model))
             ? body.model
             : engine.capabilities.models[0]?.id;
         if (!model)
@@ -428,6 +434,21 @@ app.post('/:id/switch-engine', migrationGuard, async (c) => {
             return c.json({ error: `Engine '${body.engine}' does not support the selected permission mode` }, 400);
         }
         const effort = typeof body.reasoningEffort === 'string' ? body.reasoningEffort : 'auto';
+        try {
+            assertEngineConfigurationSupported(engine, {
+                model: body.model,
+                reasoningEffort: body.reasoningEffort,
+                agentPermissionMode: body.agentPermissionMode,
+            });
+            await preflightMistralConfiguration(engine.id, { workspaceId: workspace.id }, {
+                model: body.model,
+                reasoningEffort: body.reasoningEffort,
+                agentPermissionMode: body.agentPermissionMode,
+            });
+        }
+        catch (error) {
+            return c.json({ error: error instanceof Error ? error.message : 'Invalid engine configuration' }, 400);
+        }
         const handoff = typeof body.handoff === 'string' && body.handoff.trim()
             ? body.handoff.trim().slice(0, 30_000)
             : await buildEngineHandoff(workspace, workspace.engine, body.engine);
@@ -544,6 +565,48 @@ app.post('/', workspaceCreationMaintenance, migrationGuard, creationBodyLimit, a
                 }
             }
         }
+        if (body.engine === 'mistral-vibe' &&
+            body.agentPermissionMode !== undefined &&
+            !isAgentPermissionMode(body.agentPermissionMode))
+            return c.json({ error: 'Invalid agentPermissionMode', step: 'validate' }, 400);
+        const selectedEngine = listEngines().find((engine) => engine.id === (body.engine ?? 'claude-code'));
+        if (selectedEngine) {
+            try {
+                const mode = resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, settingsService.getGlobalSettings(), selectedEngine.id);
+                assertEngineConfigurationSupported(selectedEngine, {
+                    model: body.model,
+                    reasoningEffort: body.reasoningEffort,
+                    agentPermissionMode: mode,
+                });
+                await preflightMistralConfiguration(selectedEngine.id, { projectPath: body.worktreePath ?? body.projectPath }, {
+                    model: body.model,
+                    reasoningEffort: body.reasoningEffort,
+                    agentPermissionMode: mode,
+                });
+                assertEngineConfigurationSupported(selectedEngine, {
+                    model: body.brainstormModel,
+                    reasoningEffort: body.brainstormReasoningEffort,
+                });
+                await preflightMistralConfiguration(selectedEngine.id, { projectPath: body.worktreePath ?? body.projectPath }, {
+                    model: body.brainstormModel ?? body.model,
+                    reasoningEffort: body.brainstormReasoningEffort ?? body.reasoningEffort,
+                    agentPermissionMode: mode,
+                });
+                if (body.autoLoopFinalReview) {
+                    const review = finalReviewService.parseFinalReviewConfiguration(body.autoLoopFinalReview);
+                    await preflightMistralConfiguration(review.engine, { projectPath: body.worktreePath ?? body.projectPath }, {
+                        ...review,
+                        agentPermissionMode: 'interactive',
+                    });
+                }
+                body.agentPermissionMode = mode;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Invalid engine configuration';
+                emitCreateFailed(creationId, 'validate', message);
+                return c.json({ error: message, step: 'validate' }, 400);
+            }
+        }
         // Fetch the source branch from origin first. On failure this is non-fatal:
         // fall back to the local source branch if it exists (offline / no remote),
         // and only hard-block (422) when neither origin nor a local branch is usable.
@@ -1745,7 +1808,10 @@ app.get('/:id/auto-loop/final-review', (c) => {
 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));
+        const config = finalReviewService.parseFinalReviewConfiguration(body?.configuration);
+        if (config)
+            await preflightMistralConfiguration(config.engine, { workspaceId: c.req.param('id') }, { ...config, agentPermissionMode: 'interactive' });
+        return c.json(finalReviewService.configureFinalReview(c.req.param('id'), config));
     }
     catch (error) {
         return c.json({ error: error instanceof Error ? error.message : 'Invalid request' }, error instanceof ReviewRequestError ? error.status : 400);
@@ -2080,6 +2146,7 @@ app.post('/:id/deferred-tool-use/answer', async (c) => {
         await agentManager.answerPendingQuestion(id, body.answers, body.toolCallId, {
             awaitingFreeForm: body.awaitingFreeForm === true,
             ...(typeof body.response === 'string' ? { response: body.response } : {}),
+            ...(body.selections !== undefined ? { selections: parseQuestionSelections(body.selections) } : {}),
         });
         return c.json({ ok: true });
     }
@@ -2871,6 +2938,25 @@ app.patch('/:id', migrationGuard, async (c) => {
                 }, 400);
             }
         }
+        const selectedEngine = listEngines().find((engine) => engine.id === workspace.engine);
+        if (selectedEngine &&
+            (body.model !== undefined || body.reasoningEffort !== undefined || body.agentPermissionMode !== undefined)) {
+            try {
+                assertEngineConfigurationSupported(selectedEngine, {
+                    model: body.model ?? workspace.model,
+                    reasoningEffort: body.reasoningEffort ?? workspace.reasoningEffort,
+                    agentPermissionMode: body.agentPermissionMode ?? workspace.agentPermissionMode,
+                });
+                await preflightMistralConfiguration(selectedEngine.id, { workspaceId: workspace.id }, {
+                    model: body.model ?? workspace.model,
+                    reasoningEffort: body.reasoningEffort ?? workspace.reasoningEffort,
+                    agentPermissionMode: body.agentPermissionMode ?? workspace.agentPermissionMode,
+                });
+            }
+            catch (error) {
+                return c.json({ error: error instanceof Error ? error.message : 'Invalid engine configuration' }, 400);
+            }
+        }
         if (body.status !== undefined) {
             if (!isWorkspaceStatus(body.status)) {
                 return c.json({ error: `Invalid status. Must be one of: ${VALID_WORKSPACE_STATUSES.join(', ')}` }, 400);
@@ -3415,6 +3501,24 @@ app.post('/:id/start', migrationGuard, async (c) => {
                 error: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
             }, 409);
         }
+        const selectedEngine = listEngines().find((engine) => engine.id === workspaceEngine);
+        if (selectedEngine) {
+            try {
+                assertEngineConfigurationSupported(selectedEngine, {
+                    model: workspace.model,
+                    reasoningEffort: workspace.reasoningEffort,
+                    agentPermissionMode: workspace.agentPermissionMode,
+                });
+                await preflightMistralConfiguration(selectedEngine.id, { workspaceId: workspace.id }, {
+                    model: workspace.model,
+                    reasoningEffort: workspace.reasoningEffort,
+                    agentPermissionMode: workspace.agentPermissionMode,
+                }, resume);
+            }
+            catch (error) {
+                return c.json({ error: error instanceof Error ? error.message : 'Invalid engine configuration' }, 400);
+            }
+        }
         // A manual start supersedes any scheduled retry (quota or transient
         // watchdog recovery). Leaving its timer armed could spawn a second agent
         // after the user has already resumed the workspace.
@@ -4258,7 +4362,8 @@ app.post('/:id/merge-pr', async (c) => {
                 code: `forge_${availability.reason ?? 'unavailable'}`,
             }, 409);
         }
-        const snapshot = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        // Record OPEN before merging, even if the watcher has not run since startup.
+        const snapshot = await refreshPrSnapshot(id);
         if (snapshot?.state !== 'OPEN') {
             return c.json({ error: 'No open PR found for this workspace', code: 'pr_not_open' }, 409);
         }
@@ -4302,13 +4407,15 @@ app.post('/:id/delete-remote-branch', async (c) => {
         if (!provider.capabilities.canDeleteRemoteBranch) {
             return c.json({ error: 'This project cannot delete remote branches', code: 'forge_unsupported' }, 409);
         }
-        const availability = await provider.isAvailable(workspace.worktreePath);
+        // The merge watcher may have already archived and purged this worktree.
+        const repoPath = workspace.projectPath;
+        const availability = await provider.isAvailable(repoPath);
         if (!availability.available)
             return c.json({ error: 'Forge CLI unavailable', code: 'forge_unavailable' }, 409);
-        const snapshot = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        const snapshot = await provider.getPrStatus(repoPath, workspace.workingBranch);
         if (snapshot?.state !== 'MERGED')
             return c.json({ error: 'The PR is not merged yet', code: 'pr_not_merged' }, 409);
-        await provider.deleteRemoteBranch(workspace.worktreePath, workspace.workingBranch);
+        await provider.deleteRemoteBranch(repoPath, workspace.workingBranch);
         return c.json({ success: true });
     }
     catch (err) {

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

@@ -18,6 +18,8 @@ export const CLAUDE_CODE_CAPABILITIES = {
     permissionModes: ['plan', 'bypass', 'strict', 'interactive'],
     supportsResume: true,
     supportsMcp: true,
+    supportsLiveSteering: true,
+    supportsReadOnly: true,
     supportsSkills: true,
     supportsSubagents: true,
     supportsQuotaStatus: true,

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

@@ -1049,6 +1049,9 @@ export function createClaudeCodeEngine() {
                         // swallow — best effort
                     }
                 },
+                hasPendingUserInput(toolCallId) {
+                    return pendingResolvers.has(toolCallId);
+                },
                 resolvePendingUserInput(toolCallId, response) {
                     const resolver = pendingResolvers.get(toolCallId);
                     if (!resolver)

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

@@ -3,7 +3,7 @@ const localRequire = createRequire(import.meta.url);
 /**
  * Detect the live host's platform/arch/libc from `process`. `glibcVersionRuntime`
  * lives in the diagnostic report header on glibc systems and is absent on musl.
- * Available since Node 12; Kōbō requires Node ≥ 20 (see AGENTS.md).
+ * Available since Node 12; Kōbō requires Node ≥ 26.12.1 (see AGENTS.md).
  */
 export function detectPlatform() {
     const report = process.report;

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

@@ -13,6 +13,8 @@ export const CODEX_CAPABILITIES = {
     permissionModes: ['plan', 'bypass', 'strict', 'interactive'],
     supportsResume: true,
     supportsMcp: true,
+    supportsLiveSteering: true,
+    supportsReadOnly: true,
     supportsSkills: false,
     supportsSubagents: true,
     supportsQuotaStatus: true,

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

@@ -692,6 +692,9 @@ export function createCodexEngine() {
                     }
                     await terminateChild();
                 },
+                hasPendingUserInput(callId) {
+                    return pendingByCallId.has(callId);
+                },
                 resolvePendingUserInput(callId, response) {
                     const pending = pendingByCallId.get(callId);
                     if (!pending)

package/dist/server/services/agent/engines/configuration.js

@@ -0,0 +1,14 @@
+import { assertMistralSelection } from './mistral-vibe/configuration.js';
+/** Validate native selections before creating or replacing launch state. */
+export function assertEngineConfigurationSupported(engine, selection) {
+    if (selection.readOnly && !engine.capabilities.supportsReadOnly)
+        throw new Error(`Engine '${engine.id}' does not support read-only launches`);
+    // Native membership is checked contextually and again on the actual ACP session.
+    if (engine.id !== 'mistral-vibe')
+        return;
+    const mode = selection.agentPermissionMode ?? 'interactive';
+    if (!engine.capabilities.permissionModes.some((item) => item === mode))
+        throw new Error(`Engine '${engine.id}' does not support agentPermissionMode '${String(mode)}'`);
+    assertMistralSelection(selection.model, 'model');
+    assertMistralSelection(selection.reasoningEffort, 'thinking');
+}

package/dist/server/services/agent/engines/mistral-vibe/capabilities.js

@@ -0,0 +1,13 @@
+import { MISTRAL_MODELS } from '../../../../../shared/mistral-models.js';
+export const MISTRAL_CAPABILITIES = {
+    models: MISTRAL_MODELS.map((model) => ({ id: model.id, label: model.label })),
+    effortLevels: [{ id: 'auto', label: 'Auto' }],
+    permissionModes: ['interactive', 'strict', 'bypass'],
+    supportsResume: true,
+    supportsMcp: true,
+    supportsLiveSteering: false,
+    supportsReadOnly: false,
+    supportsSkills: false,
+    supportsSubagents: false,
+    supportsQuotaStatus: false,
+};