@loicngr/kobo 2.1.29 → 2.1.30

package/dist/server/services/review-service.js

@@ -9,6 +9,7 @@ import { listEngines } from './agent/engines/registry.js';
 import * as agentManager from './agent/orchestrator.js';
 import { bindReviewSession, getFinalReviewSourceSession } from './auto-loop-final-review-service.js';
 import { canStartAutomatically } from './auto-loop-service.js';
+import { preflightMistralConfiguration } from './mistral-options-service.js';
 import { beginReviewLaunch, finishReviewLaunch } from './review-launch-runtime.js';
 import { getReviewReturn, registerReviewReturn, restoreReviewConfiguration } from './review-return-service.js';
 import { getActiveReviewTemplate, renderReviewTemplate } from './review-template-service.js';
@@ -47,20 +48,28 @@ function resolveConfiguration(workspace, body, allowCustomModel = false) {
     const engine = listEngines().find((e) => e.id === engineId);
     if (!engine)
         throw new ReviewRequestError(`Unknown engine '${engineId}'`, 400);
+    if (!engine.capabilities.supportsReadOnly && engineId !== 'mistral-vibe')
+        throw new ReviewRequestError(`Engine '${engineId}' does not support read-only reviews`, 400);
     const changedEngine = engineId !== workspace.engine;
     const config = {
         engine: engineId,
         model: body.model ?? (changedEngine ? 'auto' : workspace.model),
         reasoningEffort: body.reasoningEffort ?? (changedEngine ? 'auto' : workspace.reasoningEffort),
-        // A review that hands its report back must end by itself: always read-only.
-        agentPermissionMode: body.returnToSession ? 'plan' : (body.agentPermissionMode ?? workspace.agentPermissionMode),
+        // Native reviews have independent permissions; other returning reviewers use Plan.
+        agentPermissionMode: engineId === 'mistral-vibe'
+            ? (body.agentPermissionMode ?? 'interactive')
+            : body.returnToSession
+                ? 'plan'
+                : (body.agentPermissionMode ?? workspace.agentPermissionMode),
     };
     // Preserve an existing custom model when unchanged; reject incompatible selections.
-    if (!allowCustomModel &&
+    if (engineId !== 'mistral-vibe' &&
+        !allowCustomModel &&
         (changedEngine || config.model !== workspace.model) &&
         !engine.capabilities.models.some((m) => m.id === config.model))
         throw new ReviewRequestError(`Model '${config.model}' is not supported by '${engineId}'`, 400);
-    if ((changedEngine || config.reasoningEffort !== workspace.reasoningEffort) &&
+    if (engineId !== 'mistral-vibe' &&
+        (changedEngine || config.reasoningEffort !== workspace.reasoningEffort) &&
         !engine.capabilities.effortLevels?.some((e) => e.id === config.reasoningEffort))
         throw new ReviewRequestError(`Reasoning effort '${config.reasoningEffort}' is not supported by '${engineId}'`, 400);
     if (!engine.capabilities.permissionModes.includes(config.agentPermissionMode))
@@ -81,6 +90,15 @@ export async function startWorkspaceReview(id, input, internal) {
             throw new ReviewRequestError(`Workspace '${id}' not found`, 404);
         const body = parseReviewRequest(input);
         const configuration = resolveConfiguration(workspace, body, internal?.autoLoopFinalReview);
+        const nativeReview = configuration.engine === 'mistral-vibe';
+        if (nativeReview && internal?.autoLoopFinalReview)
+            configuration.agentPermissionMode = 'interactive';
+        try {
+            await preflightMistralConfiguration(configuration.engine, { workspaceId: id }, configuration);
+        }
+        catch (error) {
+            throw new ReviewRequestError(error instanceof Error ? error.message : 'Invalid native review configuration', 400);
+        }
         assertWorkspaceLifecycleAvailable(id);
         if (workspace.archivedAt || workspace.worktreePurgedAt)
             throw new ReviewRequestError('Restore the workspace before starting a review', 409);
@@ -94,7 +112,7 @@ export async function startWorkspaceReview(id, input, internal) {
         const differsFromSession = !!originalSession &&
             ((!!originalSession.engine && originalSession.engine !== configuration.engine) ||
                 (configuration.model !== 'auto' && !!originalSession.model && originalSession.model !== configuration.model));
-        const newSession = body.newSession === true || changed || differsFromSession || body.returnToSession === true;
+        const newSession = nativeReview || body.newSession === true || changed || differsFromSession || body.returnToSession === true;
         if (body.returnToSession &&
             (!originalSession?.engineSessionId || (originalSession.engine && originalSession.engine !== workspace.engine)))
             throw new ReviewRequestError('The current session cannot be resumed; start it before requesting an automatic return', 400);
@@ -134,7 +152,10 @@ export async function startWorkspaceReview(id, input, internal) {
         });
         // The return fires only when the review session ends by itself: a reviewer
         // that starts fixing, or waits on a question, never hands back.
-        if (body.returnToSession)
+        if (nativeReview)
+            rendered +=
+                '\n\nThis is a report-only review under native Vibe permissions, without guaranteed filesystem read-only enforcement. These rules override any template or skill suggesting fixes: do not modify, create or delete files, commit, push, or mutate tasks, workspace state or memory. Report findings and recommended fixes only. Respect native approval requests; never bypass or auto-approve them. If approval is required, wait for the user. Finish with a standalone report including severity, file/line references and remaining uncertainty.';
+        else if (body.returnToSession)
             rendered +=
                 '\n\nThis is a read-only review session; these rules override any template instruction or skill that suggests fixing issues. Do not modify, create or delete files, and do not commit or push: the original agent session applies the fixes. Running read-only checks such as tests or linters is fine. Do not ask the user questions or wait for input: note any decision that needs the user in your summary instead.' +
                     '\n\nFinish with a standalone summary of your review findings, including severity, file/line references, recommended fixes and any remaining uncertainty. This final message will be handed back to the original agent session. Do not rely on earlier messages to explain your findings.';
@@ -177,7 +198,10 @@ export async function startWorkspaceReview(id, input, internal) {
                         original: {
                             engine: workspace.engine,
                             model: workspace.model,
-                            ...(originalSession.model ? { sessionModel: originalSession.model } : {}),
+                            ...((workspace.engine !== 'mistral-vibe' || workspace.model !== 'auto') && originalSession.model
+                                ? { sessionModel: originalSession.model }
+                                : {}),
+                            // Restore iteration intent separately; native review returns retain saved session thinking.
                             reasoningEffort: workspace.reasoningEffort,
                             agentPermissionMode: workspace.agentPermissionMode,
                         },
@@ -204,9 +228,9 @@ export async function startWorkspaceReview(id, input, internal) {
                     pendingSessionId,
                     configuration.reasoningEffort,
                 ];
-                if (reviewLaunch) {
+                if (nativeReview || reviewLaunch) {
                     startArgs[8] = undefined;
-                    startArgs[9] = { mcpEnv: reviewLaunch.mcpEnv };
+                    startArgs[9] = { mcpEnv: { ...reviewLaunch?.mcpEnv, ...(nativeReview ? { KOBO_REVIEW_ONLY: '1' } : {}) } };
                 }
                 const agent = agentManager.startAgent(...startArgs);
                 workspaceService.updateWorkspaceStatus(id, 'executing');

package/dist/server/services/session-handoff-service.js

@@ -6,9 +6,11 @@ import { getDb } from '../db/index.js';
 import { assertAgentStopped } from '../utils/agent-stop-result.js';
 import { ensureDirectoryInside } from '../utils/safe-path.js';
 import { reserveWorkspaceLifecycle } from '../utils/workspace-lifecycle-guard.js';
+import { assertEngineConfigurationSupported } from './agent/engines/configuration.js';
 import { listEngines } from './agent/engines/registry.js';
 import * as agents from './agent/orchestrator.js';
 import { buildEngineHandoff } from './engine-handoff-service.js';
+import { preflightMistralConfiguration } from './mistral-options-service.js';
 import { getReviewReturn } from './review-return-service.js';
 import { activateSession, deactivateSession } from './session-activity-service.js';
 import { registerHandoffStopHandler } from './session-handoff-runtime.js';
@@ -180,6 +182,15 @@ function parseRequest(input) {
         },
     };
 }
+export async function preflightSessionHandoff(workspaceId, input) {
+    const body = parseRequest(input);
+    // Existing requests are replayed by createSessionHandoff with fingerprint validation.
+    if (getDb()
+        .prepare('SELECT 1 FROM session_handoffs WHERE workspace_id = ? AND request_id = ?')
+        .get(workspaceId, body.requestId))
+        return;
+    await preflightMistralConfiguration(body.target.engine, { workspaceId }, body.target);
+}
 export function createSessionHandoff(workspaceId, input, suppliedReport) {
     if (agents.isShuttingDown())
         throw new SessionHandoffError('Kōbō is shutting down');
@@ -207,11 +218,22 @@ export function createSessionHandoff(workspaceId, input, suppliedReport) {
         throw new SessionHandoffError('The current session changed. Reopen the transfer dialog.');
     const engine = listEngines().find((item) => item.id === body.target.engine);
     if (!engine?.capabilities.permissionModes.includes(body.target.agentPermissionMode) ||
-        (!engine.capabilities.models.some((model) => model.id === body.target.model) &&
+        (engine.id !== 'mistral-vibe' &&
+            !engine.capabilities.models.some((model) => model.id === body.target.model) &&
             !(workspace.engine === body.target.engine && workspace.model === body.target.model)) ||
-        (body.target.reasoningEffort !== 'auto' &&
+        (engine.id !== 'mistral-vibe' &&
+            body.target.reasoningEffort !== 'auto' &&
             !engine.capabilities.effortLevels?.some((effort) => effort.id === body.target.reasoningEffort)))
         throw new SessionHandoffError('The target engine configuration is not supported', 400);
+    try {
+        assertEngineConfigurationSupported(engine, body.target);
+    }
+    catch (error) {
+        throw new SessionHandoffError(error instanceof Error ? error.message : 'Invalid engine configuration', 400);
+    }
+    if (body.generateSummary &&
+        !listEngines().find((item) => item.id === workspace.engine)?.capabilities.supportsReadOnly)
+        throw new SessionHandoffError('The source engine does not support read-only handoff summaries', 400);
     const id = nanoid();
     const runtime = reserve(workspaceId, id);
     try {
@@ -289,6 +311,10 @@ async function run(runtime) {
     runtime.running = true;
     const row = read(runtime.id);
     try {
+        const target = map(row).target;
+        await preflightMistralConfiguration(target.engine, { workspaceId: row.workspace_id }, target);
+        if (runtime.cancelled)
+            return;
         state(row.id, 'stopping');
         assertAgentStopped(await agents.stopAgentAndWait(row.workspace_id, undefined, 'handoff'));
         if (runtime.cancelled)

package/dist/server/services/settings-defaults.js

@@ -89,4 +89,5 @@ export const DEFAULT_MODEL_BY_ENGINE = {
 export const FRESH_MODEL_BY_ENGINE = {
     'claude-code': 'claude-sonnet-5-5',
     codex: 'auto',
+    'mistral-vibe': 'auto',
 };

package/dist/server/services/settings-service.js

@@ -1019,6 +1019,24 @@ const settingsMigrations = [
                 global.forceImmediateMessages = false;
         },
     },
+    {
+        version: 68,
+        name: 'mistral-native-defaults',
+        migrate: ({ global }) => {
+            for (const [key, value] of [
+                ['defaultModelByEngine', 'auto'],
+                ['defaultPermissionModeByEngine', 'interactive'],
+            ]) {
+                const map = global[key];
+                // Missing maps inherit the full fresh-install defaults when settings are read.
+                if (map && typeof map === 'object' && !Array.isArray(map)) {
+                    const defaults = map;
+                    if (typeof defaults['mistral-vibe'] !== 'string')
+                        defaults['mistral-vibe'] = value;
+                }
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -1127,7 +1145,7 @@ function defaultSettings() {
             notionInProgressStatus: '',
             notionAssigneeProperty: '',
             notionUserId: '',
-            defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan' },
+            defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan', 'mistral-vibe': 'interactive' },
             notionMcpKey: '',
             sentryMcpKey: '',
             notionEnabled: false,

package/dist/server/services/workspace-creation-mcp-service.js

@@ -1,8 +1,11 @@
 import { checkoutDecisionError, deriveSteps } from '../../shared/pr-checkout-steps.js';
 import { validateWorkspaceCreationArguments } from '../../shared/workspace-creation-tools.js';
-import { CLAUDE_CODE_CAPABILITIES } from './agent/engines/claude-code/capabilities.js';
-import { CODEX_CAPABILITIES } from './agent/engines/codex/capabilities.js';
+import { assertEngineConfigurationSupported } from './agent/engines/configuration.js';
+import { resolveEngine } from './agent/engines/registry.js';
+import { parseFinalReviewConfiguration } from './auto-loop-final-review-service.js';
+import { preflightMistralConfiguration } from './mistral-options-service.js';
 import { rollbackCreatedPrCheckout } from './pr-checkout-rollback-service.js';
+import { getGlobalSettings } from './settings-service.js';
 import { beginWorkspaceCreation } from './update-maintenance-service.js';
 export class WorkspaceCreationMcpError extends Error {
     status;
@@ -102,13 +105,52 @@ async function executeCreation(name, raw, dispatch) {
     catch (error) {
         throw new WorkspaceCreationMcpError(error instanceof Error ? error.message : 'Invalid arguments', 400, 'validate');
     }
-    const config = input.auto_loop_final_review;
-    if (config) {
-        const capabilities = config.engine === 'codex' ? CODEX_CAPABILITIES : CLAUDE_CODE_CAPABILITIES;
-        if (!capabilities.effortLevels?.some((effort) => effort.id === config.reasoning_effort))
-            throw new WorkspaceCreationMcpError('Unsupported review reasoning effort', 400, 'validate');
-    }
     const body = mapInput(input);
+    try {
+        if (name === 'create_workspace') {
+            const engine = resolveEngine(input.engine ?? 'claude-code');
+            const savedMode = engine.id === 'mistral-vibe' ? getGlobalSettings().defaultPermissionModeByEngine?.[engine.id] : undefined;
+            const defaultMode = savedMode === 'plan' || engine.capabilities.permissionModes.some((mode) => mode === savedMode)
+                ? savedMode
+                : undefined;
+            if (engine.id === 'mistral-vibe')
+                body.agentPermissionMode = input.agent_permission_mode ?? defaultMode ?? 'interactive';
+            assertEngineConfigurationSupported(engine, {
+                model: input.model,
+                reasoningEffort: input.reasoning_effort,
+                agentPermissionMode: body.agentPermissionMode,
+            });
+            await preflightMistralConfiguration(engine.id, { projectPath: input.project_path }, {
+                model: input.model,
+                reasoningEffort: input.reasoning_effort,
+                agentPermissionMode: body.agentPermissionMode,
+            });
+            assertEngineConfigurationSupported(engine, {
+                model: input.brainstorm_model,
+                reasoningEffort: input.brainstorm_reasoning_effort,
+            });
+            await preflightMistralConfiguration(engine.id, { projectPath: input.project_path }, {
+                model: input.brainstorm_model ?? input.model,
+                reasoningEffort: input.brainstorm_reasoning_effort ?? input.reasoning_effort,
+                agentPermissionMode: body.agentPermissionMode,
+            });
+        }
+    }
+    catch (error) {
+        throw new WorkspaceCreationMcpError(error instanceof Error ? error.message : 'Invalid engine configuration', 400, 'validate');
+    }
+    if (body.autoLoopFinalReview) {
+        try {
+            const config = parseFinalReviewConfiguration(body.autoLoopFinalReview);
+            await preflightMistralConfiguration(config.engine, { projectPath: input.project_path }, {
+                ...config,
+                agentPermissionMode: 'interactive',
+            });
+        }
+        catch (error) {
+            throw new WorkspaceCreationMcpError(error instanceof Error ? error.message : 'Invalid final review configuration', 400, 'validate');
+        }
+    }
     let resolvedCheckout;
     if (input.pr_url) {
         const supplied = prIdentity(input.pr_url);

package/dist/server/services/workspace-dialogue-service.js

@@ -1,4 +1,5 @@
 import { nanoid } from 'nanoid';
+import { parseQuestionSelections } from '../../shared/question-selections.js';
 import { validateDialogueArguments } from '../../shared/workspace-dialogue-tools.js';
 import { parseMessageSource } from '../../shared/workspace-message-types.js';
 import { getDb } from '../db/index.js';
@@ -79,6 +80,7 @@ export async function executeWorkspaceDialogueTool(name, input, source = createM
             throw new Error('The requested question is not the current pending question');
         await answerPendingQuestion(workspaceId, args.answers, args.tool_call_id, {
             source,
+            ...(args.selections !== undefined ? { selections: parseQuestionSelections(args.selections) } : {}),
         });
         return { accepted: true };
     }

package/dist/server/services/workspace-message-service.js

@@ -1,10 +1,13 @@
 import { validateMcpAttachments } from '../../shared/mcp-attachments.js';
 import { assertWorkspaceLifecycleAvailable, withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
-import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import { assertEngineConfigurationSupported } from './agent/engines/configuration.js';
+import { resolveEngine } from './agent/engines/registry.js';
+import { assertImmediateMessageSupported, isAgentUnavailableError, isShuttingDown, sendMessage, startAgent, } from './agent/orchestrator.js';
 import { attachmentReference, removeAttachments, saveAttachments } from './attachment-service.js';
 import { hasLoopMessage } from './auto-loop-message-service.js';
 import * as autoLoop from './auto-loop-service.js';
 import { createChatReceipt } from './chat-receipt-service.js';
+import { preflightMistralConfiguration } from './mistral-options-service.js';
 import { emitEphemeral } from './websocket-service.js';
 import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './workspace-service.js';
 /** Shared delivery for WebSocket chat and external MCP clients. */
@@ -67,6 +70,21 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             reason = 'awaiting-user';
             throw new Error('Answer the pending question or permission request before sending a chat message');
         }
+        if (workspace.engine === 'mistral-vibe') {
+            assertEngineConfigurationSupported(resolveEngine(workspace.engine), {
+                model: workspace.model,
+                reasoningEffort: workspace.reasoningEffort,
+                agentPermissionMode: message.agentPermissionModeOverride ?? workspace.agentPermissionMode,
+            });
+        }
+        assertImmediateMessageSupported(workspaceId);
+        if (workspace.engine === 'mistral-vibe') {
+            await preflightMistralConfiguration(workspace.engine, { workspaceId }, {
+                model: workspace.model,
+                reasoningEffort: workspace.reasoningEffort,
+                agentPermissionMode: message.agentPermissionModeOverride ?? workspace.agentPermissionMode,
+            }, true);
+        }
         if (attachments.length) {
             attachmentWorktree = workspace.worktreePath;
             await withWorkspaceLifecycleGuard(workspaceId, async () => {

package/dist/server/services/workspace-permission-policy-service.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { isAbsolute } from 'node:path';
 import { nanoid } from 'nanoid';
 import { getDb } from '../db/index.js';
 const turnRules = new Map();
@@ -29,6 +30,26 @@ export function permissionFingerprint(payload) {
 }
 const CODEX_EDIT_FINGERPRINT_PREFIX = 'codex-edit-v2:';
 function operationFingerprint(request) {
+    if (request.engine === 'mistral-vibe') {
+        const payload = request.payload;
+        const input = payload?.rawInput;
+        if (!input || typeof input !== 'object' || Array.isArray(input) || payload?.operationApprovalAvailable === false)
+            return null;
+        const shell = request.toolName === 'bash' &&
+            payload?.effectKind === 'shell' &&
+            payload.kind === 'execute' &&
+            typeof input.command === 'string' &&
+            input.command.trim().length > 0;
+        const write = request.toolName === 'write_file' &&
+            payload?.effectKind === 'file_write' &&
+            payload.kind === 'edit' &&
+            typeof input.filePath === 'string' &&
+            isAbsolute(input.filePath) &&
+            typeof input.content === 'string';
+        if (!shell && !write)
+            return null;
+        return `mistral-vibe-operation-v1:${permissionFingerprint({ rawInput: input, effectKind: payload?.effectKind, kind: payload?.kind })}`;
+    }
     if (request.engine !== 'codex' || request.toolName !== 'Edit')
         return permissionFingerprint(request.payload);
     const payload = request.payload;
@@ -48,6 +69,9 @@ function operationFingerprint(request) {
             grantRoot: payload.grantRoot ?? null,
         }));
 }
+export function isOperationApprovalAvailable(request) {
+    return operationFingerprint(request) !== null;
+}
 function toRule(row) {
     return {
         active: !(row.scope === 'operation' &&

package/dist/server/utils/bounded-process.js

@@ -2,7 +2,7 @@ import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 /** A zombie cannot mutate a checkout, even before its parent reaps it. */
-async function groupIsLive(pid) {
+export async function groupIsLive(pid) {
     try {
         process.kill(-pid, 0);
     }

package/dist/shared/launch-instructions.js

@@ -5,20 +5,29 @@ export function getKoboPromptCapabilities(env) {
         handoff: Boolean(env?.KOBO_HANDOFF_ID && env.KOBO_HANDOFF_TOKEN),
         finalReview: Boolean(env?.KOBO_FINAL_REVIEW_SESSION_ID && env.KOBO_FINAL_REVIEW_TOKEN),
         progressReporting: Boolean(env?.KOBO_PROGRESS_SESSION_TOKEN),
+        reviewOnly: env?.KOBO_REVIEW_ONLY === '1',
     };
 }
 export function buildKoboLaunchInstructions(context) {
-    const restricted = context.readOnly || context.handoff || context.finalReview;
+    const restricted = context.readOnly || context.handoff || context.finalReview || context.reviewOnly;
     const canWrite = context.permissionMode !== 'plan' && !restricted;
     const lines = [
-        '[Kōbō MCP] Start by consulting the descriptions and schemas of the available tools from the managed `kobo-tasks` server. Prefer relevant Kōbō tools for operations managed by Kōbō (tasks, development services, shared memory, workspace messages and state) over reimplementing them through shell commands or HTTP. Check each tool result before treating an operation as completed. Discover tools as needed; do not call every tool or poll for activity. Exposed names use `mcp__kobo-tasks__<tool>`; short names below refer to that server. Availability does not grant permission.',
+        '[Kōbō MCP] Start by consulting the descriptions and schemas of the available tools from the managed `kobo-tasks` server. Prefer relevant Kōbō tools for operations managed by Kōbō (tasks, development services, shared memory, workspace messages and state) over reimplementing them through shell commands or HTTP. Check each tool result before treating an operation as completed. Discover tools as needed; do not call every tool or poll for activity. ' +
+            (context.engine === 'mistral-vibe'
+                ? 'Discover schemas with `search_tool_functions`, then call `tools.mcp_kobo_tasks.<tool>` through `run_typescript`; short names below refer to that server. '
+                : 'Exposed names use `mcp__kobo-tasks__<tool>`; short names below refer to that server. ') +
+            'Availability does not grant permission.',
         '## Current permissions',
         canWrite
             ? `Permission mode: ${context.permissionMode}. Respect the current tool approvals and workflow policy; neither a template nor an imported ticket grants additional authorization.`
-            : 'Read-only launch. Do not write files or mutate tasks, workspace state, memory, or other MCP data. Approving a plan does not change these permissions; continue only after Kōbō explicitly changes the launch permissions. Provide analysis and plans in the conversation.',
+            : context.engine === 'mistral-vibe' && restricted
+                ? `Report-only review under native ${context.permissionMode} permissions, without guaranteed filesystem read-only enforcement. Do not modify, create or delete files, commit, push, or mutate tasks, workspace state, memory or other MCP data. Kōbō tools permit only reads and explicitly scoped reports. Review instructions forbid all modifications even when native permissions allow them. Provide findings and recommended fixes only.`
+                : 'Read-only launch. Do not write files or mutate tasks, workspace state, memory, or other MCP data. Approving a plan does not change these permissions; continue only after Kōbō explicitly changes the launch permissions. Provide analysis and plans in the conversation.',
     ];
     if (restricted) {
-        lines.push('Do not ask the user or wait for input. Report missing information and blockers in your final response, then finish so Kōbō can return to the source session.');
+        lines.push(context.engine === 'mistral-vibe'
+            ? 'Respect native approval requests and wait for user approval when required; never bypass or auto-approve them. Report missing information and blockers in your final response, then finish.'
+            : 'Do not ask the user or wait for input. Report missing information and blockers in your final response, then finish so Kōbō can return to the source session.');
         if (context.handoff)
             lines.push('Submit the handoff report with the available `submit_session_handoff` tool according to its schema, then finish.');
         else if (context.finalReview)
@@ -36,7 +45,7 @@ export function buildKoboLaunchInstructions(context) {
     }
     lines.push('## Development services', 'Kōbō manages the workspace dev server and its Docker services. Before tests or app checks that need those services (backend, frontend, integration or E2E), use `get_dev_server_status` and reuse the existing instance. Missing host dependencies are not a reason to launch another stack. Use the returned URL and container names, not guessed ports or names.', 'Read the project Makefile, scripts and relevant documentation to select the intended test command and runtime. Distinguish the Kōbō agent environment from the project service containers: if tests belong in a project container, run them there under current permissions. A PHP extension or other dependency missing in the agent environment alone is not evidence that the project is misconfigured, nor a reason to install global packages.', canWrite
         ? 'When an authorized task needs these services and their status is stopped, use `start_dev_server`. For an explicitly requested stop or a necessary authorized restart, use `stop_dev_server`. Do not run lifecycle commands such as `make dev-docker`, `sh/dev-docker.sh`, `docker compose up/down` or `npm run dev` directly; Kōbō runs the configured commands and tracks their processes.'
-        : 'This read-only launch must not start, stop or restart services. Inspect available status/logs and report any unavailable test environment in the final response.', 'Use `get_dev_server_logs` to diagnose startup/runtime failures. If the tools are unavailable, the server is not_configured, or startup fails, report the blocker; do not bypass Kōbō with a shell launch. Test commands inside an existing container remain subject to the current permissions.', 'A running process or container is not proof that the service is ready or that tests passed. Before dependent tests, use the documented health check or a non-mutating request to the appropriate service URL. Bound readiness checks with a timeout and limited retries; if readiness remains unconfirmed, inspect logs and report the blocker rather than restarting repeatedly. Missing application readiness does not invalidate independent unit tests.');
+        : 'This restricted launch must not start, stop or restart services. Inspect available status/logs and report any unavailable test environment in the final response.', 'Use `get_dev_server_logs` to diagnose startup/runtime failures. If the tools are unavailable, the server is not_configured, or startup fails, report the blocker; do not bypass Kōbō with a shell launch. Test commands inside an existing container remain subject to the current permissions.', 'A running process or container is not proof that the service is ready or that tests passed. Before dependent tests, use the documented health check or a non-mutating request to the appropriate service URL. Bound readiness checks with a timeout and limited retries; if readiness remains unconfirmed, inspect logs and report the blocker rather than restarting repeatedly. Missing application readiness does not invalidate independent unit tests.');
     lines.push('## Delegation and reporting', 'Only one agent edits the worktree at a time. Parallel read-only analysis is allowed; wait for an editing subagent to finish before editing or running tests yourself. Give each delegate its objective, exact worktree path, relevant user constraints, current permissions, intended test runtime and applicable Kōbō tools and reporting rules. Do not assume it inherits this context. A delegate without the required managed tools must ask its parent to coordinate the operation within the same permissions, not bypass Kōbō.');
     if (context.progressReporting)
         lines.push(PROGRESS_BAR_PROMPT);
@@ -53,9 +62,11 @@ export function buildKoboLaunchInstructions(context) {
     else {
         continuation.push('This launch cannot schedule follow-up work. Use available completion notifications for tracked work; report unfinished work or blockers honestly and finish the requested analysis/report.');
     }
+    if (context.engine === 'mistral-vibe')
+        continuation.push('Use native `tools.process` tracked jobs for long-running commands; do not use raw redirected Bash backgrounding to detach work from native ownership.');
     const continuationText = continuation.join('\n');
-    // Claude supports a durable application append; Codex receives the same rules in its input.
-    if (context.engine === 'codex')
+    // Claude supports a durable application append; other engines receive these rules in their input.
+    if (context.engine !== 'claude-code')
         lines.push(continuationText);
     return { promptPrefix: lines.join('\n\n'), systemAppend: context.engine === 'claude-code' ? continuationText : '' };
 }

package/dist/shared/memory.js

@@ -31,7 +31,7 @@ export function deriveMemoryActor(source, _callerActor) {
     if (source.kind === 'internal-agent') {
         if (!isNonEmptyString(source.workspaceId) ||
             !isNonEmptyString(source.sessionId) ||
-            (source.engine !== 'claude-code' && source.engine !== 'codex')) {
+            (source.engine !== 'claude-code' && source.engine !== 'codex' && source.engine !== 'mistral-vibe')) {
             throw new TypeError('Invalid internal memory actor source');
         }
         return Object.freeze({

package/dist/shared/mistral-models.js

@@ -0,0 +1,9 @@
+/** Static fallback only; contextual native ACP discovery supplies explicit aliases. */
+export const MISTRAL_MODELS = [
+    {
+        id: 'auto',
+        label: 'Auto',
+        i18nLabelKey: 'model.auto',
+        i18nDescriptionKey: 'model.mistralAutoDescription',
+    },
+];

package/dist/shared/mistral-options.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/question-selections.js

@@ -0,0 +1,16 @@
+/** Native multi-select values travel separately from legacy human-readable answers. */
+export function parseQuestionSelections(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('selections must be an object of string arrays');
+    const entries = Object.entries(value);
+    if (entries.length > 20 ||
+        entries.some(([key, values]) => !key ||
+            key.length > 200 ||
+            !Array.isArray(values) ||
+            values.length > 32 ||
+            values.some((item) => typeof item !== 'string' || item.length > 2000)))
+        throw new Error('selections exceed their field, choice or string limits');
+    return value;
+}

package/dist/shared/workspace-creation-tools.js

@@ -9,8 +9,8 @@ const object = (properties, required = []) => ({
     required,
     additionalProperties: false,
 });
-const effort = choice('auto', 'none', 'low', 'medium', 'high', 'xhigh', 'max');
-const engine = choice('claude-code', 'codex');
+const effort = choice('auto', 'off', 'none', 'low', 'medium', 'high', 'xhigh', 'max');
+const engine = choice('claude-code', 'codex', 'mistral-vibe');
 const path = string(4096);
 const url = string(4096);
 const titles = { type: 'array', items: string(20_000), maxItems: 500 };
@@ -144,6 +144,12 @@ export function validateWorkspaceCreationArguments(name, input) {
         }
     }
     if (name === 'create_workspace') {
+        if (value.engine !== 'mistral-vibe' &&
+            (value.reasoning_effort === 'off' || value.brainstorm_reasoning_effort === 'off'))
+            throw new Error('off is a native Mistral Vibe thinking value');
+        const review = value.auto_loop_final_review;
+        if (review && review.engine !== 'mistral-vibe' && review.reasoning_effort === 'off')
+            throw new Error('off is a native Mistral Vibe thinking value');
         const { attachments: _attachments, ...metadataFields } = value;
         // Keep room for multipart file headers within the downstream 1 MiB allowance.
         if (new TextEncoder().encode(JSON.stringify(metadataFields)).byteLength > 960 * 1024)

package/dist/shared/workspace-dialogue-tools.js

@@ -1,4 +1,5 @@
 import { MCP_ATTACHMENTS_SCHEMA, validateMcpAttachments } from './mcp-attachments.js';
+import { parseQuestionSelections } from './question-selections.js';
 const workspace = { type: 'string', minLength: 1, maxLength: 200, description: 'Workspace ID from list_workspaces.' };
 const session = {
     type: 'string',
@@ -41,10 +42,16 @@ export const WORKSPACE_DIALOGUE_TOOLS = [
         },
     }, ['workspace_id'], false),
     tool('get_workspace_questions', 'Read pending questions and whether a human tool approval is blocking the workspace.', { workspace_id: workspace }, ['workspace_id']),
-    tool('answer_workspace_question', 'Answer the current pending question using its exact tool_call_id. Answer keys are question IDs for Codex, question text for Claude. Tool permission requests require human approval in Kōbō.', {
+    tool('answer_workspace_question', 'Answer the current pending question using its exact tool_call_id. Answer keys are question IDs for Codex/Mistral Vibe, question text for Claude. Native multiple-choice arrays use selections; never split comma-joined display answers. Tool permission requests require human approval in Kōbō.', {
         workspace_id: workspace,
         tool_call_id: { type: 'string', minLength: 1, maxLength: 200 },
-        answers: { type: 'object', minProperties: 1, additionalProperties: { type: 'string' } },
+        answers: { type: 'object', additionalProperties: { type: 'string' } },
+        selections: {
+            type: 'object',
+            maxProperties: 20,
+            propertyNames: { minLength: 1, maxLength: 200 },
+            additionalProperties: { type: 'array', maxItems: 32, items: { type: 'string', maxLength: 2000 } },
+        },
     }, ['workspace_id', 'tool_call_id', 'answers'], false),
 ];
 export const EXTERNAL_MCP_TOOLS = [WORKSPACE_DISCOVERY_TOOL, ...WORKSPACE_DIALOGUE_TOOLS];
@@ -60,6 +67,8 @@ export function validateDialogueArguments(name, value) {
     for (const key of definition.inputSchema.required ?? [])
         if (!Object.hasOwn(args, key))
             throw new Error(`${key} is required`);
+    if (name === 'answer_workspace_question')
+        parseQuestionSelections(args.selections);
     for (const [key, input] of Object.entries(args)) {
         const property = properties[key];
         if (!Object.hasOwn(properties, key))
@@ -67,6 +76,9 @@ export function validateDialogueArguments(name, value) {
         if (key === 'attachments') {
             validateMcpAttachments(input);
         }
+        else if (key === 'selections') {
+            // Validated above; native forms may omit all optional fields.
+        }
         else if (property.type === 'string') {
             if (typeof input !== 'string' ||
                 (property.minLength !== 0 && !input.trim()) ||
@@ -87,9 +99,8 @@ export function validateDialogueArguments(name, value) {
         else if (!input ||
             typeof input !== 'object' ||
             Array.isArray(input) ||
-            Object.keys(input).length === 0 ||
             Object.values(input).some((answer) => typeof answer !== 'string' || answer.length > 100_000)) {
-            throw new Error(`${key} must be a non-empty object of string answers`);
+            throw new Error(`${key} must be an object of string answers`);
         }
     }
     if (name === 'send_workspace_message') {

package/docs/deployment-vps.md

@@ -97,7 +97,7 @@ these checks.
 
 After installation, continue with [opening Kōbō](#2-start-and-open-kōbō) and
 [authenticating agent engines](#3-authenticate-and-choose-a-project). The installer
-does not log you into Claude or Codex. Obtain the Kōbō browser token through the
+does not log you into Claude Code, Codex or Mistral Vibe. Obtain the Kōbō browser token through the
 existing startup-log command below. For installer-managed deployments, invoke the
 updater as `/opt/kobo/bin/kobo-update --directory /opt/kobo`; the `./kobo-update`
 examples later in this guide describe the manual installation layout.
@@ -312,6 +312,11 @@ and login requirements can vary; `claude auth login --help` and `codex login --h
 show the supported options. You can also configure your own provider API key.
 No paid agent turn is needed for these setup commands.
 
+For **Mistral Vibe**, install Vibe separately in the image/container and authenticate
+as the same agent user. The server must be able to run `vibe-acp`. Follow
+[Use Mistral Vibe inside the container](./vps-projects-and-skills.md#use-mistral-vibe-inside-the-container);
+an installation or login on the host is insufficient.
+
 For a personal GitHub account, complete the CLI's browser login flow from your PC,
 then connect Git HTTPS credentials to it:
 
@@ -337,7 +342,9 @@ In the first-run form, **Local project directory** means
 nor a folder on the PC running the browser. Then follow [your first mission](./getting-started.md#create-a-mission).
 
 The named `kobo-home` volume covers `/root`: it preserves Kōbō's database/settings,
-Claude/Codex state and Git/forge configuration across container replacement.
+Claude/Codex state, Vibe state stored under that home, and Git/forge configuration
+across container replacement. A custom `VIBE_HOME` outside the volume needs its own
+persistence.
 Do not run `docker compose down -v`. Authentication performed only on the host is
 not automatically available inside a container. See [Docker volume persistence](https://docs.docker.com/reference/compose-file/volumes/).
 
@@ -616,7 +623,7 @@ the reservation deliberately has no expiry that could reopen the race. Follow
 container and confirm its exit before restarting it. Restart clears the in-memory
 reservation. Never release it while a Docker stop could still be in progress.
 
-Claude/Codex configuration and credentials, skills/plugins, caches, browser
+Claude Code/Codex/Mistral Vibe configuration and credentials, skills/plugins, caches, browser
 downloads, repositories/worktrees, bind-mounted App keys/scripts and project
 database volumes are **not included** in `kobo.tar.gz`. Files outside the Kōbō
 directory remain in the existing volume; the updater neither archives nor deletes