@loicngr/kobo 2.1.28 → 2.1.30

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

@@ -1,5 +1,7 @@
 import { execFile, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { stripVTControlCharacters } from 'node:util';
 import { resolveInstance, sanitizeBranchName } from '../utils/dev-server-instance.js';
 import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
 import { getProjectSettings } from './settings-service.js';
@@ -25,6 +27,7 @@ function runCommand(command, args, options = {}) {
 // ── State ──────────────────────────────────────────────────────────────────────
 /** workspaceId -> spawned dev-server process */
 const trackedProcesses = new Map();
+const directServerStatuses = new Map();
 const stoppingProcesses = new Map();
 const generations = new Map();
 let shuttingDown = false;
@@ -34,6 +37,7 @@ export function beginDevServerShutdown() {
 /** Test-only: clear the tracked-processes map between tests. */
 export function _resetTrackedProcessesForTests() {
     trackedProcesses.clear();
+    directServerStatuses.clear();
     stoppingProcesses.clear();
     generations.clear();
     shuttingDown = false;
@@ -74,14 +78,18 @@ export async function listRunningContainers(projectName) {
  * still running (e.g. `docker compose up -d` is pulling/building images), the
  * status is reported as `'starting'` even if no matching container is visible
  * in `docker ps` yet. This prevents the UI from flashing to `'stopped'` during
- * long build phases.
+ * long build phases. Direct processes report running and their URL after a
+ * recognized local readiness announcement on stdout or stderr.
  */
 export async function getStatus(projectPath, workingBranch, workspaceId) {
     const config = resolveInstance(projectPath, workingBranch);
+    const directStatus = workspaceId ? directServerStatuses.get(workspaceId) : undefined;
+    if (workspaceId && directStatus && trackedProcesses.has(workspaceId))
+        return { ...directStatus };
     if (!config) {
         return {
-            status: 'unknown',
-            instanceName: '',
+            status: workspaceId && trackedProcesses.has(workspaceId) ? 'starting' : 'unknown',
+            instanceName: workspaceId && trackedProcesses.has(workspaceId) ? sanitizeBranchName(workingBranch) : '',
             projectName: '',
             httpPort: '',
             url: '',
@@ -163,12 +171,64 @@ export function startDevServer(workspaceId) {
     const generation = (generations.get(workspaceId) ?? 0) + 1;
     generations.set(workspaceId, generation);
     trackedProcesses.set(workspaceId, proc);
-    // Log stdout/stderr for debugging
+    // Parse complete lines separately per stream: CLI output and ANSI sequences
+    // can span arbitrary pipe chunks. Bound the unfinished line retained in memory.
+    const observeOutput = () => {
+        const decoder = new StringDecoder('utf8');
+        let pending = '';
+        return (data) => {
+            if (shuttingDown ||
+                trackedProcesses.get(workspaceId) !== proc ||
+                generations.get(workspaceId) !== generation ||
+                stoppingProcesses.has(workspaceId) ||
+                directServerStatuses.has(workspaceId))
+                return;
+            pending += decoder.write(data);
+            const lines = pending.split(/[\r\n]/);
+            pending = lines.pop().slice(-8192);
+            for (const line of lines) {
+                // Quasar's "App URL....." and Vite/Next's "Local:" are explicit
+                // readiness announcements; unrelated links in build output are not.
+                const match = stripVTControlCharacters(line).match(/^\s*(?:[»➜-]\s*)?(?:App URL[.\s]*|Local:\s*)(https?:\/\/\S+)\s*$/i);
+                if (!match)
+                    continue;
+                let url;
+                try {
+                    url = new URL(match[1]);
+                }
+                catch {
+                    continue;
+                }
+                if (url.username ||
+                    url.password ||
+                    !['localhost', '127.0.0.1', '[::1]', '0.0.0.0', '[::]'].includes(url.hostname))
+                    continue;
+                if (url.hostname === '0.0.0.0' || url.hostname === '[::]')
+                    url.hostname = 'localhost';
+                const status = {
+                    status: 'running',
+                    instanceName,
+                    projectName: '',
+                    httpPort: url.port || (url.protocol === 'https:' ? '443' : '80'),
+                    url: url.href,
+                    containers: [],
+                };
+                directServerStatuses.set(workspaceId, status);
+                updateDevServerStatus(workspaceId, 'running');
+                emitEphemeral(workspaceId, 'devserver:status', status);
+                break;
+            }
+        };
+    };
+    const observeStdout = observeOutput();
+    const observeStderr = observeOutput();
     proc.stdout?.on('data', (data) => {
         console.log(`[dev-server:${instanceName}] ${data.toString().trim()}`);
+        observeStdout(data);
     });
     proc.stderr?.on('data', (data) => {
         console.error(`[dev-server:${instanceName}] ${data.toString().trim()}`);
+        observeStderr(data);
     });
     proc.on('exit', (code) => {
         // Shell exit does not imply that its background children have stopped.
@@ -181,6 +241,7 @@ export function startDevServer(workspaceId) {
                 if (trackedProcesses.get(workspaceId) !== proc || stoppingProcesses.has(workspaceId))
                     return;
                 trackedProcesses.delete(workspaceId);
+                directServerStatuses.delete(workspaceId);
                 const currentStatus = await getStatus(workspace.projectPath, workspace.workingBranch);
                 if (shuttingDown || generations.get(workspaceId) !== generation || stoppingProcesses.has(workspaceId))
                     return;
@@ -200,6 +261,7 @@ export function startDevServer(workspaceId) {
         // A signal failure is also an 'error' event; it does not prove process exit.
         if (!proc.pid)
             trackedProcesses.delete(workspaceId);
+        directServerStatuses.delete(workspaceId);
         updateDevServerStatus(workspaceId, 'error');
         console.error(`[dev-server] Process error for workspace ${workspaceId}:`, err);
         emitEphemeral(workspaceId, 'devserver:status', {
@@ -233,6 +295,7 @@ export async function stopDevServer(workspaceId) {
     if (pending)
         return pending;
     generations.set(workspaceId, (generations.get(workspaceId) ?? 0) + 1);
+    directServerStatuses.delete(workspaceId);
     const stopping = stopDevServerOwned(workspaceId);
     stoppingProcesses.set(workspaceId, stopping);
     try {
@@ -333,6 +396,7 @@ async function stopTrackedProcess(workspaceId) {
         throw new Error('Dev server stop is not confirmed; retry after the process exits');
     if (trackedProcesses.get(workspaceId) === tracked)
         trackedProcesses.delete(workspaceId);
+    directServerStatuses.delete(workspaceId);
 }
 async function stopDevServerOwned(workspaceId) {
     const workspace = getWorkspace(workspaceId);

package/dist/server/services/environment-check-service.js

@@ -66,13 +66,15 @@ function liveProbe() {
         },
         worktreesDirectory: (project) => resolveWorktreesRoot(project, getGlobalSettings().worktreesPath),
         codexBinary: resolveCodexBinary,
+        mistralBinary: () => 'vibe-acp',
     };
 }
 /** No credential files, provider calls, generated prompts, or raw process errors in this report. */
 export async function checkEnvironment(request, probe = liveProbe()) {
-    const [major, minor] = probe.nodeVersion.split('.').map(Number);
+    const [major, minor, patch] = probe.nodeVersion.split('.').map(Number);
+    const supportedNode = major > 26 || (major === 26 && (minor > 12 || (minor === 12 && patch >= 1)));
     const checks = [
-        { code: 'node', status: major > 24 || (major === 24 && minor >= 15) ? 'ok' : 'error' },
+        { code: 'node', status: supportedNode ? 'ok' : 'error' },
         { code: 'platform', status: ['linux', 'darwin'].includes(probe.platform) ? 'ok' : 'error' },
     ];
     const commandAvailable = async (command, args) => {
@@ -84,7 +86,11 @@ export async function checkEnvironment(request, probe = liveProbe()) {
             return error.code === 'ENOENT' ? 'missing' : 'error';
         }
     };
-    const binary = request.engine === 'codex' ? probe.codexBinary() : probe.claudeBinary();
+    const binary = request.engine === 'mistral-vibe'
+        ? probe.mistralBinary()
+        : request.engine === 'codex'
+            ? probe.codexBinary()
+            : probe.claudeBinary();
     const [git, shell, storage, runtime] = await Promise.all([
         commandAvailable('git', ['--version']),
         commandAvailable('bash', ['--version']),

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

@@ -154,7 +154,7 @@ function assertInternalActorCanAccessScope(actor, scope) {
     if (!source || source.workspace_id !== actor.workspaceId) {
         throw new MemoryNotFoundError('Agent session is not bound to the stated workspace');
     }
-    if (source.engine !== 'claude-code' && source.engine !== 'codex') {
+    if (source.engine !== 'claude-code' && source.engine !== 'codex' && source.engine !== 'mistral-vibe') {
         throw new MemoryNotFoundError('Bound agent session has no valid engine');
     }
     if (source.engine !== actor.engine)

package/dist/server/services/mistral-options-service.js

@@ -0,0 +1,145 @@
+import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import * as acp from '@agentclientprotocol/sdk';
+import { closeVibeAcpSession, connectVibeAcp, requestVibeAcp, } from './agent/engines/mistral-vibe/client.js';
+import { assertMistralSelection, MISTRAL_MODES, readMistralSelect, requireMistralOption, } from './agent/engines/mistral-vibe/configuration.js';
+import { spawnVibeAcp } from './agent/engines/mistral-vibe/spawn.js';
+import { getWorkspace } from './workspace-service.js';
+const pending = new Map();
+const cache = new Map();
+let owned = 0;
+export async function getMistralOptions(input) {
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined &&
+            (typeof value !== 'string' ||
+                !value.trim() ||
+                value.length > (key === 'projectPath' ? 4096 : 256) ||
+                value.includes('\0')))
+            throw new Error(`Invalid Mistral Vibe ${key}`);
+    }
+    if (input.workspaceId && input.projectPath)
+        throw new Error('Choose workspaceId or projectPath, not both');
+    const permission = input.agentPermissionMode ?? 'interactive';
+    if (!Object.hasOwn(MISTRAL_MODES, permission))
+        throw new Error('Mistral Vibe requires a supported native permission mode');
+    assertMistralSelection(input.model, 'model');
+    const workspace = input.workspaceId ? getWorkspace(input.workspaceId) : undefined;
+    if (input.workspaceId && !workspace)
+        throw new Error('Workspace not found');
+    if (workspace &&
+        (typeof workspace.worktreePath !== 'string' || !workspace.worktreePath || workspace.worktreePurgedAt))
+        throw new Error('Restore the workspace context before discovering Vibe options');
+    const cwd = resolve(workspace?.worktreePath ?? input.projectPath ?? homedir());
+    if (!(await stat(cwd).catch(() => undefined))?.isDirectory())
+        throw new Error('Mistral Vibe context directory does not exist');
+    const mode = MISTRAL_MODES[permission];
+    const model = input.model && input.model !== 'auto' ? input.model : undefined;
+    const key = JSON.stringify([cwd, mode, model]);
+    const cached = cache.get(key);
+    if (cached && cached.expires > Date.now())
+        return cached.options;
+    const existing = pending.get(key);
+    if (existing)
+        return existing;
+    if (owned >= 4)
+        throw new Error('Mistral Vibe discovery is busy or awaiting native closure; try again after closure');
+    owned++;
+    const probe = (async () => {
+        let runtime;
+        try {
+            const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !/^KOBO_.*TOKEN$/.test(name)));
+            runtime = spawnVibeAcp({
+                cwd,
+                env: { ...env, VIBE_DEFAULT_AGENT: mode, ...(model ? { VIBE_ACTIVE_MODEL: model } : {}) },
+            });
+        }
+        catch {
+            owned--;
+            throw new Error('Cannot start native Vibe discovery; check vibe-acp on PATH');
+        }
+        let connection;
+        let sessionId;
+        let canClose = false;
+        // Failed shutdown never releases a slot while native ownership remains unresolved.
+        void runtime.closed.then(() => {
+            owned--;
+            connection?.close();
+        });
+        try {
+            connection = connectVibeAcp(runtime.child, {
+                requestPermission: () => ({ outcome: { outcome: 'cancelled' } }),
+                createElicitation: () => ({ action: 'cancel' }),
+            });
+            const initialized = await requestVibeAcp(connection, acp.methods.agent.initialize, {
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientCapabilities: {},
+            });
+            const capabilities = initialized.agentCapabilities;
+            if (!capabilities || typeof capabilities !== 'object' || Array.isArray(capabilities))
+                throw new Error('Invalid Vibe ACP capabilities');
+            if (capabilities.sessionCapabilities != null &&
+                (typeof capabilities.sessionCapabilities !== 'object' || Array.isArray(capabilities.sessionCapabilities)))
+                throw new Error('Invalid Vibe ACP session capabilities');
+            const close = capabilities.sessionCapabilities?.close;
+            if (close != null && (typeof close !== 'object' || Array.isArray(close)))
+                throw new Error('Invalid Vibe ACP close capability');
+            canClose = close != null;
+            const session = await requestVibeAcp(connection, acp.methods.agent.session.new, { cwd, mcpServers: [] });
+            sessionId = session.sessionId;
+            if (sessionId.length > 256 || sessionId.includes('\0'))
+                throw new Error('Invalid Vibe ACP identity');
+            requireMistralOption(session, 'mode', mode, true);
+            if (model)
+                requireMistralOption(session, 'model', model, true);
+            const options = { model: readMistralSelect(session, 'model'), thinking: readMistralSelect(session, 'thinking') };
+            await runtime.stop(() => closeVibeAcpSession(connection, { sessionId: sessionId, active: false, canClose }));
+            await runtime.closed;
+            if (cache.size >= 32)
+                cache.delete(cache.keys().next().value);
+            cache.set(key, { options, expires: Date.now() + 30_000 });
+            return options;
+        }
+        catch {
+            throw new Error('Native Vibe options unavailable; check the executable, authentication, project/profile and selected model, then retry');
+        }
+        finally {
+            await runtime
+                .stop(connection && sessionId
+                ? () => closeVibeAcpSession(connection, { sessionId: sessionId, active: false, canClose })
+                : undefined)
+                .catch(() => {
+                throw new Error('Native Vibe discovery shutdown unconfirmed; ownership retained until confirmed closure or server restart');
+            });
+        }
+    })();
+    pending.set(key, probe);
+    try {
+        return await probe;
+    }
+    finally {
+        pending.delete(key);
+    }
+}
+/** External mutation preflight; the actual new/load session is still authoritative. */
+export async function preflightMistralConfiguration(engine, context, selection, resume = false) {
+    if (engine !== 'mistral-vibe')
+        return;
+    assertMistralSelection(selection.model, 'model');
+    assertMistralSelection(selection.reasoningEffort, 'thinking');
+    // New-session defaults cannot validate thinking for an Auto model pinned in a saved session.
+    if (resume && (selection.model === undefined || selection.model === 'auto'))
+        return;
+    if ((selection.model === undefined || selection.model === 'auto') &&
+        (selection.reasoningEffort === undefined || selection.reasoningEffort === 'auto'))
+        return;
+    const options = await getMistralOptions({
+        ...context,
+        model: selection.model,
+        agentPermissionMode: selection.agentPermissionMode,
+    });
+    if (selection.reasoningEffort !== undefined &&
+        selection.reasoningEffort !== 'auto' &&
+        !options.thinking.options.some((option) => option.value === selection.reasoningEffort))
+        throw new Error('Mistral Vibe thinking selection is unavailable for this model; refresh native options');
+}

package/dist/server/services/pr-watcher-service.js

@@ -6,6 +6,7 @@ import { hasController } from './agent/orchestrator.js';
 import { stopDevServer } from './dev-server-service.js';
 import { getForgeProvider } from './forge/registry.js';
 import { resolveForge } from './forge/resolve.js';
+import { deriveReadyToMerge } from './forge/types.js';
 import { computeGitStats } from './git-stats-service.js';
 import * as lifecycleHookService from './lifecycle-hook-service.js';
 import { getGlobalSettings } from './settings-service.js';
@@ -38,15 +39,31 @@ async function runBounded(items, concurrency, worker) {
     });
     await Promise.all(workers);
 }
-/** Tracks the last known PR snapshot per workspace, used to detect transitions
- *  (state, base, reviewDecision). */
+/** Latest snapshot for the UI, including explicit refreshes. */
 const lastKnownPr = new Map();
+/** Only the watcher consumes transitions; refreshing the UI must not consume a merge. */
+const lastProcessedPr = new Map();
+function recordProcessedPr(workspaceId, snapshot, displayedAtStart) {
+    const previous = lastProcessedPr.get(workspaceId);
+    // A refresh completed during this tick's Git work may already have newer data.
+    if (lastKnownPr.get(workspaceId) === displayedAtStart)
+        lastKnownPr.set(workspaceId, snapshot);
+    // Keep notification history through a recalculation, while the public snapshot
+    // still blocks merging until the forge has actually confirmed mergeability.
+    const keepReadiness = previous?.number === snapshot.number &&
+        previous.url === snapshot.url &&
+        previous.readyToMerge &&
+        snapshot.mergeable === 'UNKNOWN' &&
+        deriveReadyToMerge({ ...snapshot, mergeable: 'MERGEABLE' });
+    lastProcessedPr.set(workspaceId, keepReadiness ? { ...snapshot, readyToMerge: true } : snapshot);
+}
 /** Latest git-stats snapshot per workspace, refreshed each watcher tick. */
 const lastKnownGitStats = new Map();
 const activeChecks = new Map();
 /** Also cancels stale results from checks that started before restoration. */
 export function invalidateWorkspacePrCaches(workspaceId) {
     lastKnownPr.delete(workspaceId);
+    lastProcessedPr.delete(workspaceId);
     lastKnownGitStats.delete(workspaceId);
     for (const check of activeChecks.get(workspaceId) ?? [])
         check.invalidated = true;
@@ -77,6 +94,9 @@ export function getAllGitStats() {
  *  workspace's entry, so this must be done explicitly by the caller). */
 export function clearPrSnapshotCache(workspaceId) {
     lastKnownPr.delete(workspaceId);
+    lastProcessedPr.delete(workspaceId);
+    for (const check of activeChecks.get(workspaceId) ?? [])
+        check.invalidated = true;
 }
 /**
  * Test-only escape hatch — drops the in-memory cache so each test starts
@@ -84,6 +104,7 @@ export function clearPrSnapshotCache(workspaceId) {
  */
 export function _resetForTest() {
     lastKnownPr.clear();
+    lastProcessedPr.clear();
     lastKnownGitStats.clear();
 }
 /**
@@ -127,9 +148,10 @@ export async function checkPrStatuses() {
     await autoRestoreManuallyRecreatedWorktrees();
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
-    for (const id of lastKnownPr.keys()) {
+    for (const id of new Set([...lastKnownPr.keys(), ...lastProcessedPr.keys()])) {
         if (!workspaces.some((ws) => ws.id === id)) {
             lastKnownPr.delete(id);
+            lastProcessedPr.delete(id);
         }
     }
     for (const id of lastKnownGitStats.keys()) {
@@ -142,6 +164,7 @@ export async function checkPrStatuses() {
         // floods the logs when a worktree was deleted externally.
         if (isWorkspaceLifecycleBusy(ws.id) || !fs.existsSync(ws.worktreePath))
             return;
+        const displayedAtStart = lastKnownPr.get(ws.id);
         const check = { invalidated: false };
         const checks = activeChecks.get(ws.id) ?? new Set();
         checks.add(check);
@@ -172,7 +195,7 @@ export async function checkPrStatuses() {
             // `gh pr edit --base …`, the lag was painful and confusing.
             let baseTransitionedFrom = null;
             if (pr?.state === 'OPEN' && pr.base) {
-                const prevBase = lastKnownPr.get(ws.id)?.base ?? ws.sourceBranch;
+                const prevBase = ws.sourceBranch;
                 if (prevBase !== pr.base) {
                     try {
                         updateWorkspaceSourceBranch(ws.id, pr.base);
@@ -211,7 +234,8 @@ export async function checkPrStatuses() {
             }
             if (stale() || !pr)
                 return;
-            const prev = lastKnownPr.get(ws.id);
+            const processed = lastProcessedPr.get(ws.id);
+            const prev = processed?.number === pr.number && processed.url === pr.url ? processed : undefined;
             // We delay updating `lastKnownPr` until after the actions succeed.
             // Setting it eagerly would poison the cache: if updateWorkspaceSourceBranch
             // throws (transient DB issue, race with workspace deletion), the cache
@@ -242,7 +266,7 @@ export async function checkPrStatuses() {
                     // manual archive route and purge-worktree, this path never stops the
                     // agent, so archiving under one orphans its pending question and
                     // leaves it writing into a workspace the UI now shows as archived.
-                    lastKnownPr.set(ws.id, pr);
+                    recordProcessedPr(ws.id, pr, displayedAtStart);
                     return;
                 }
                 console.log(`[pr-watcher] PR ${pr.state.toLowerCase()} for workspace '${ws.name}' — archiving`);
@@ -275,6 +299,7 @@ export async function checkPrStatuses() {
                 if (!archived)
                     return;
                 lastKnownPr.delete(ws.id);
+                lastProcessedPr.delete(ws.id);
                 emitEphemeral(ws.id, 'workspace:archived', {
                     reason: `PR ${pr.state.toLowerCase()}`,
                     prUrl: pr.url,
@@ -344,10 +369,10 @@ export async function checkPrStatuses() {
             // missing one — keeps the OPEN→CLOSED/MERGED archiving logic stable.
             if (pr.state !== 'OPEN' || !pr.base) {
                 const next = pr.base ? pr : { ...pr, base: prev?.base ?? pr.base };
-                lastKnownPr.set(ws.id, next);
+                recordProcessedPr(ws.id, next, displayedAtStart);
                 return;
             }
-            lastKnownPr.set(ws.id, pr);
+            recordProcessedPr(ws.id, pr, displayedAtStart);
             // Emit the base-change event AFTER the snapshot is committed so a
             // sync:response replay on reconnect sees a consistent state. The
             // DB update + ws.sourceBranch mutation already happened above
@@ -372,9 +397,8 @@ export async function checkPrStatuses() {
 }
 /**
  * On-demand refresh of a single workspace's PR snapshot. Bypasses the 30s tick.
- * No side effects beyond cache update — no archive, no transition emits. The
- * user is watching the UI; we don't replay events for state they're already
- * looking at.
+ * Publishes the snapshot and synchronizes the PR base. Lifecycle transitions
+ * remain pending for the watcher, including OPEN → MERGED after a UI merge.
  *
  * Returns the fresh snapshot, or null if the workspace has no PR (cache entry
  * cleared in that case). Throws if the workspace doesn't exist.
@@ -421,6 +445,11 @@ export async function refreshPrSnapshot(workspaceId) {
             }
         }
         lastKnownPr.set(workspaceId, snap);
+        const processed = lastProcessedPr.get(workspaceId);
+        if (!ws.prWatchDisabledAt &&
+            !current.prWatchDisabledAt &&
+            (processed?.number !== snap.number || processed.url !== snap.url))
+            lastProcessedPr.set(workspaceId, snap);
         return snap;
     }
     finally {

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',
 };