@loicngr/kobo 1.10.3 → 1.11.1

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

@@ -1,5 +1,7 @@
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { nanoid } from 'nanoid';
+import { isWorkspacePermissionAllowed } from '../../../workspace-permission-policy-service.js';
+import { createStreamingBatcher } from '../../streaming-batcher.js';
 import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
 import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from './event-mapper.js';
 import { buildClaudeOptions } from './options-builder.js';
@@ -100,10 +102,17 @@ export function createClaudeCodeEngine() {
                 if (toolName !== 'AskUserQuestion' && !isInteractive) {
                     return Promise.resolve({ behavior: 'allow', updatedInput: input });
                 }
+                if (toolName !== 'AskUserQuestion' &&
+                    isWorkspacePermissionAllowed(options.workspaceId, { engine: 'claude-code', toolName, payload: input })) {
+                    return Promise.resolve({ behavior: 'allow', updatedInput: input });
+                }
                 const requestKind = toolName === 'AskUserQuestion' ? 'question' : 'permission';
                 return new Promise((resolve, reject) => {
                     const resolver = { resolve, input, requestKind };
                     pendingResolvers.set(toolCallId, resolver);
+                    // A user decision is intentional inactivity. The text-only watchdog
+                    // must never end this session while the permission card is visible.
+                    clearTextIdleWatchdog();
                     const onAbort = () => {
                         if (pendingResolvers.get(toolCallId) === resolver) {
                             pendingResolvers.delete(toolCallId);
@@ -202,7 +211,7 @@ export function createClaudeCodeEngine() {
             let discoveredSessionId;
             // A throwing onEvent handler (e.g. DB query against a closed connection
             // during async test teardown) must not escape as an unhandled rejection.
-            const safeEmit = (ev) => {
+            const emitDirect = (ev) => {
                 try {
                     onEvent(ev);
                 }
@@ -210,6 +219,8 @@ export function createClaudeCodeEngine() {
                     console.error('[claude-engine] onEvent handler threw:', err);
                 }
             };
+            const streamingBatcher = createStreamingBatcher(emitDirect);
+            const safeEmit = (ev) => streamingBatcher.push(ev);
             let iteratorRunning = false;
             let userInterrupted = false;
             let completedResponses = 0;
@@ -240,6 +251,10 @@ export function createClaudeCodeEngine() {
             const armTextIdleWatchdog = () => {
                 clearTextIdleWatchdog();
                 textIdleTimer = setTimeout(() => {
+                    if (pendingResolvers.size > 0) {
+                        textIdleTimer = undefined;
+                        return;
+                    }
                     console.warn(`[claude-engine] SDK stream inactive ${TEXT_IDLE_TIMEOUT_MS}ms after a text-only response — forcing session:ended`);
                     const reason = userInterrupted ? 'killed' : mapperState.sawErrorResult ? 'error' : 'completed';
                     emitSessionEnded(reason, reason === 'completed' ? 0 : null);
@@ -322,6 +337,7 @@ export function createClaudeCodeEngine() {
                     }
                 }
                 finally {
+                    streamingBatcher.close();
                     // The post-result drain watchdog (if armed) is moot once the
                     // iterator has exited — clear it so a healthy run never triggers a
                     // stray abort after it already ended.

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

@@ -151,6 +151,33 @@ export function mapSdkMessage(msg, state) {
         }
         return events;
     }
+    if (type === 'stream_event') {
+        const event = parsed.event;
+        if (!event)
+            return events;
+        if (event.type === 'message_start') {
+            const streamedMessage = event.message;
+            const messageId = typeof streamedMessage?.id === 'string' ? streamedMessage.id : undefined;
+            if (messageId) {
+                state.streamingMessageId = messageId;
+                if (!state.openMessages.has(messageId))
+                    state.openMessages.set(messageId, { sawText: false });
+            }
+            return events;
+        }
+        if (event.type === 'content_block_delta') {
+            const delta = event.delta;
+            const text = delta?.type === 'text_delta' && typeof delta.text === 'string' ? delta.text : undefined;
+            if (text && state.streamingMessageId) {
+                const messageId = state.streamingMessageId;
+                const messageState = state.openMessages.get(messageId);
+                if (messageState)
+                    messageState.sawText = true;
+                events.push({ kind: 'message:text', messageId, text, streaming: true });
+            }
+        }
+        return events;
+    }
     if (type === 'system') {
         if (subtype === 'compact' || subtype === 'compact_boundary') {
             events.push({ kind: 'session:compacted' });
@@ -233,8 +260,10 @@ export function mapSdkMessage(msg, state) {
             const blockType = block.type;
             if (blockType === 'text' && typeof block.text === 'string') {
                 const text = block.text;
-                events.push({ kind: 'message:text', messageId, text, streaming: true });
-                msgState.sawText = true;
+                if (!msgState.sawText) {
+                    events.push({ kind: 'message:text', messageId, text, streaming: true });
+                    msgState.sawText = true;
+                }
                 if (text.includes('[BRAINSTORM_COMPLETE]')) {
                     events.push({ kind: 'session:brainstorm-complete' });
                 }

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

@@ -42,6 +42,9 @@ export function buildClaudeOptions(input) {
         // `~/.claude/settings.json` (where `skipDangerousModePermissionPrompt`
         // lives), breaking bypass for MCP tools.
         settingSources: ['user', 'project', 'local'],
+        // Relay the Anthropic API's raw message stream so Kōbō can display true
+        // text deltas instead of waiting for complete assistant content blocks.
+        includePartialMessages: true,
     };
     switch (input.agentPermissionMode) {
         case 'plan':

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

@@ -1,10 +1,25 @@
 import { getPackageVersion } from '../../../../utils/paths.js';
+import { isWorkspacePermissionAllowed } from '../../../workspace-permission-policy-service.js';
+import { createStreamingBatcher } from '../../streaming-batcher.js';
 import { CODEX_CAPABILITIES } from './capabilities.js';
 import { createAppServerClient } from './client.js';
 import { createMapperState, emitSessionStarted, handleAgentMessageDelta, handleItemCompleted, handleItemStarted, handleRateLimitsUpdated, handleTurnCompleted, QUOTA_PATTERN, tryEmitQuota, } from './event-mapper.js';
 import { buildCodexOptions } from './options-builder.js';
 import { buildResponseForResolve, handleServerRequest } from './server-requests.js';
 import { spawnAppServer } from './spawn.js';
+import { createTurnLiveness } from './turn-liveness.js';
+/** Long enough for normal tool work, short enough to recover a lost turn event. */
+export const CODEX_TURN_IDLE_TIMEOUT_MS = 120_000;
+export const CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS = 3_000;
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class CodexTurnTimeoutError extends Error {
+    constructor() {
+        super('Codex stopped reporting activity for this turn');
+        this.name = 'CodexTurnTimeoutError';
+    }
+}
 /**
  * Heuristic for detecting a stale/expired thread id on `thread/resume`.
  * Canonical wording isn't captured yet — when matched, the engine emits
@@ -34,7 +49,8 @@ export function createCodexEngine() {
             let discoveredSessionId = options.resumeFromEngineSessionId;
             let activeTurnId;
             let steerChain = Promise.resolve();
-            const safeEmit = (ev) => {
+            let gracefulInterruptPromise;
+            const emitDirect = (ev) => {
                 try {
                     onEvent(ev);
                 }
@@ -42,6 +58,8 @@ export function createCodexEngine() {
                     console.error('[codex-engine] onEvent handler threw:', err);
                 }
             };
+            const streamingBatcher = createStreamingBatcher(emitDirect);
+            const safeEmit = (ev) => streamingBatcher.push(ev);
             const child = spawnAppServer({ cwd: options.workingDir, signal: abortController.signal });
             if (child.stderr) {
                 child.stderr.setEncoding('utf8');
@@ -61,6 +79,14 @@ export function createCodexEngine() {
                 resolveTurnDone = resolve;
                 rejectTurnDone = reject;
             });
+            const turnLiveness = createTurnLiveness({
+                timeoutMs: CODEX_TURN_IDLE_TIMEOUT_MS,
+                onTimeout() {
+                    mapperState.sawErrorResult = true;
+                    safeEmit({ kind: 'error', category: 'other', message: 'Codex stopped reporting activity for this turn' });
+                    rejectTurnDone(new CodexTurnTimeoutError());
+                },
+            });
             abortController.signal.addEventListener('abort', () => {
                 const err = new Error('AbortError');
                 err.name = 'AbortError';
@@ -71,9 +97,23 @@ export function createCodexEngine() {
                 stdout: child.stdout,
                 clientInfo: { name: 'kobo', version: getPackageVersion() },
                 onNotification(method, params) {
+                    turnLiveness.activity();
                     // Ignored notifications — harmless bookkeeping by the server
-                    if (method === 'mcpServer/startupStatus/updated' ||
-                        method === 'thread/started' ||
+                    if (method === 'mcpServer/startupStatus/updated') {
+                        const status = (params ?? {});
+                        const rawStatus = String(status.status ?? status.state ?? 'starting').toLowerCase();
+                        const normalized = rawStatus.includes('error') || rawStatus.includes('fail')
+                            ? 'error'
+                            : rawStatus.includes('ready') || rawStatus.includes('running')
+                                ? 'ready'
+                                : 'starting';
+                        const serverName = String(status.serverName ?? status.name ?? status.id ?? 'MCP');
+                        const rawMessage = typeof status.message === 'string' ? status.message : undefined;
+                        const message = rawMessage?.replace(/(token|api[_-]?key|secret)\s*[:=]\s*\S+/gi, '$1=[redacted]');
+                        safeEmit({ kind: 'mcp:status', serverName, status: normalized, message });
+                        return;
+                    }
+                    if (method === 'thread/started' ||
                         method === 'thread/status/changed' ||
                         method === 'remoteControl/status/changed' ||
                         method === 'turn/started') {
@@ -144,8 +184,11 @@ export function createCodexEngine() {
                         emit: safeEmit,
                         register(callId, pending) {
                             pendingByCallId.set(callId, pending);
+                            turnLiveness.pause();
                         },
                         respondError: (reqId, code, message) => client.peer.respondError(reqId, code, message),
+                        respond: (reqId, result) => client.peer.respond(reqId, result),
+                        autoApprove: (toolName, payload) => isWorkspacePermissionAllowed(options.workspaceId, { engine: 'codex', toolName, payload }),
                     });
                 },
                 onError(err) {
@@ -185,7 +228,9 @@ export function createCodexEngine() {
                         collaborationMode,
                     });
                     activeTurnId = initialTurn.turnId;
+                    turnLiveness.start();
                     await turnDonePromise;
+                    turnLiveness.stop();
                     const reason = mapperState.sawErrorResult
                         ? 'error'
                         : mapperState.sawTurnInterrupted
@@ -198,6 +243,7 @@ export function createCodexEngine() {
                     });
                 }
                 catch (err) {
+                    turnLiveness.stop();
                     const error = err;
                     const message = error.message ?? String(err);
                     const isAbort = userInterrupted || error.name === 'AbortError' || abortController.signal.aborted;
@@ -205,6 +251,9 @@ export function createCodexEngine() {
                     if (isAbort) {
                         safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
                     }
+                    else if (error.name === 'CodexTurnTimeoutError') {
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
                     else if (QUOTA_PATTERN.test(message)) {
                         tryEmitQuota(mapperState, safeEmit, message);
                         safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
@@ -219,6 +268,8 @@ export function createCodexEngine() {
                     }
                 }
                 finally {
+                    turnLiveness.stop();
+                    streamingBatcher.close();
                     iteratorRunning = false;
                     client.close();
                     try {
@@ -257,13 +308,23 @@ export function createCodexEngine() {
                 },
                 interrupt() {
                     userInterrupted = true;
-                    abortController.abort();
-                    if (discoveredSessionId) {
-                        client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { });
-                    }
+                    if (gracefulInterruptPromise)
+                        return;
+                    gracefulInterruptPromise = (async () => {
+                        if (discoveredSessionId) {
+                            await Promise.race([
+                                client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { }),
+                                wait(CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS),
+                            ]);
+                        }
+                        await Promise.race([turnDonePromise.catch(() => { }), wait(CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS)]);
+                        if (iteratorRunning)
+                            abortController.abort();
+                    })();
                 },
                 async stop() {
-                    abortController.abort();
+                    engineProcess.interrupt();
+                    await gracefulInterruptPromise;
                     try {
                         await iteratorPromise;
                     }
@@ -282,6 +343,7 @@ export function createCodexEngine() {
                     if (!pending)
                         return false;
                     pendingByCallId.delete(callId);
+                    turnLiveness.resume();
                     const result = buildResponseForResolve(pending, response);
                     client.peer.respond(pending.requestId, result);
                     return true;

package/dist/server/services/agent/engines/codex/server-requests.js

@@ -1,5 +1,5 @@
 export function handleServerRequest(args) {
-    const { method, params, requestId, emit, register, respondError } = args;
+    const { method, params, requestId, emit, register, respondError, respond, autoApprove } = args;
     const p = (params ?? {});
     const callId = typeof p.callId === 'string' ? p.callId : `srv_${requestId}`;
     if (method === 'mcpServer/elicitation/request') {
@@ -13,24 +13,34 @@ export function handleServerRequest(args) {
     // (`execCommandApproval`, `applyPatchApproval`) are kept for compat with
     // older Codex CLI builds that haven't transitioned to the v2 namespace.
     if (method === 'item/commandExecution/requestApproval' || method === 'execCommandApproval') {
+        const payload = { command: p.command, cwd: p.cwd, reason: p.reason };
+        if (autoApprove?.('Bash', payload)) {
+            respond?.(requestId, { decision: 'accept' });
+            return true;
+        }
         register(callId, { requestId, kind: 'command', payload: p });
         emit({
             kind: 'session:user-input-requested',
             requestKind: 'permission',
             toolCallId: callId,
             toolName: 'Bash',
-            payload: { command: p.command, cwd: p.cwd, reason: p.reason },
+            payload,
         });
         return true;
     }
     if (method === 'item/fileChange/requestApproval' || method === 'applyPatchApproval') {
+        const payload = { changes: p.changes, reason: p.reason };
+        if (autoApprove?.('Edit', payload)) {
+            respond?.(requestId, { decision: 'accept' });
+            return true;
+        }
         register(callId, { requestId, kind: 'file_change', payload: p });
         emit({
             kind: 'session:user-input-requested',
             requestKind: 'permission',
             toolCallId: callId,
             toolName: 'Edit',
-            payload: { changes: p.changes, reason: p.reason },
+            payload,
         });
         return true;
     }

package/dist/server/services/agent/engines/codex/turn-liveness.js

@@ -0,0 +1,53 @@
+/**
+ * Tracks a single active Codex turn. A pending user decision deliberately
+ * pauses the deadline: the agent is waiting on a human, not stalled.
+ */
+export function createTurnLiveness(input) {
+    let timer;
+    let active = false;
+    let paused = false;
+    let timedOut = false;
+    const arm = () => {
+        if (!active || paused || timedOut)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (!active || paused || timedOut)
+                return;
+            timedOut = true;
+            input.onTimeout();
+        }, input.timeoutMs);
+    };
+    return {
+        start() {
+            active = true;
+            paused = false;
+            timedOut = false;
+            arm();
+        },
+        activity() {
+            arm();
+        },
+        pause() {
+            paused = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+        resume() {
+            if (!active || !paused)
+                return;
+            paused = false;
+            arm();
+        },
+        stop() {
+            active = false;
+            paused = false;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}

package/dist/server/services/agent/event-router.js

@@ -6,5 +6,9 @@ export function routeEvent(workspaceId, agentSessionId, event) {
         emitEphemeral(workspaceId, 'agent:event', event);
         return;
     }
+    if (event.kind === 'mcp:status' && event.status !== 'error') {
+        emitEphemeral(workspaceId, 'agent:event', event);
+        return;
+    }
     emit(workspaceId, 'agent:event', event, agentSessionId);
 }

package/dist/server/services/agent/orchestrator.js

@@ -11,6 +11,7 @@ import { getEffectiveSettings } from '../settings-service.js';
 import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emit, emitEphemeral } from '../websocket-service.js';
+import * as permissionPolicyService from '../workspace-permission-policy-service.js';
 import { getWorkspace as getWs, markWorkspaceUnread, updateWorkspaceStatus, } from '../workspace-service.js';
 import { resolveEngine } from './engines/registry.js';
 import { routeEvent } from './event-router.js';
@@ -554,6 +555,10 @@ function handleEvent(workspaceId, agentSessionId, ev) {
         tasksDoneSnapshot.delete(workspaceId);
         taskStateSnapshot.delete(workspaceId);
         clearPendingForSession(workspaceId, agentSessionId);
+        // A completed/failed SDK session cannot resolve canUseTool anymore. Drop
+        // its persisted prompts too, otherwise a reconnect resurrects a panel
+        // whose backend callback has already been discarded.
+        purgeAllPersistedUserInputRequests(workspaceId, agentSessionId);
         // Must run BEFORE autoLoopService.onSessionEnded → spawnNextIteration →
         // startAgent, otherwise startAgent throws "Agent already running" because
         // the just-ended controller is still in the map.
@@ -698,6 +703,8 @@ function onSessionEnded(workspaceId, agentSessionId, exitCode, reason, resumeFai
  * query the controller via `_getControllers()` for tests.
  */
 export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort) {
+    // "For this turn" never survives a new agent session.
+    permissionPolicyService.clearTurnPermissions(workspaceId);
     // Zombie detection: an SDK iterator hung on a never-resolved canUseTool
     // callback can leave its controller in the map after the workspace is
     // logically idle. Evict it instead of refusing the new session.
@@ -1019,6 +1026,16 @@ export async function answerPendingPermission(workspaceId, decision) {
     const response = decision.decision === 'allow'
         ? { kind: 'permission-allow' }
         : { kind: 'permission-deny', reason: decision.reason };
+    if (decision.decision === 'allow' && (decision.scope === 'operation' || decision.scope === 'tool')) {
+        permissionPolicyService.createWorkspacePermissionRule(workspaceId, { engine: ws.engine ?? 'claude-code', toolName: head.toolName, payload: head.toolInput }, decision.scope);
+    }
+    if (decision.decision === 'allow' && decision.scope === 'turn') {
+        permissionPolicyService.allowPermissionForTurn(workspaceId, {
+            engine: ws.engine ?? 'claude-code',
+            toolName: head.toolName,
+            payload: head.toolInput,
+        });
+    }
     const resolved = engineProcess.resolvePendingUserInput(decision.toolCallId, response);
     if (!resolved) {
         throw new Error(`No pending callback for toolCallId '${decision.toolCallId}'`);

package/dist/server/services/agent/streaming-batcher.js

@@ -0,0 +1,34 @@
+/** Coalesces token deltas before they reach WebSocket persistence. */
+export function createStreamingBatcher(emit, options = {}) {
+    const windowMs = options.windowMs ?? 40;
+    const pending = new Map();
+    const flush = (messageId) => {
+        const entry = pending.get(messageId);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        pending.delete(messageId);
+        emit({ kind: 'message:text', messageId, text: entry.text, streaming: true });
+    };
+    return {
+        push(event) {
+            if (event.kind === 'message:text' && event.streaming) {
+                const entry = pending.get(event.messageId);
+                if (entry) {
+                    entry.text += event.text;
+                    return;
+                }
+                const timer = setTimeout(() => flush(event.messageId), windowMs);
+                pending.set(event.messageId, { text: event.text, timer });
+                return;
+            }
+            if (event.kind === 'message:end')
+                flush(event.messageId);
+            emit(event);
+        },
+        close() {
+            for (const messageId of [...pending.keys()])
+                flush(messageId);
+        },
+    };
+}

package/dist/server/services/forge/github/provider.js

@@ -92,7 +92,7 @@ function availabilityFromError(err) {
 }
 export const githubProvider = {
     id: 'github',
-    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'PR' },
+    capabilities: { canCreatePr: true, canChangePrBase: true, canMergeRequest: true, requestTermShort: 'PR' },
     async isAvailable(repoPath) {
         try {
             await execFileAsync('gh', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
@@ -127,4 +127,7 @@ export const githubProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('gh', ['pr', 'edit', '--base', base], { cwd: repoPath, encoding: 'utf-8' });
     },
+    async mergeRequest(repoPath, number) {
+        await execFileAsync('gh', ['pr', 'merge', String(number), '--merge'], { cwd: repoPath, encoding: 'utf-8' });
+    },
 };

package/dist/server/services/forge/gitlab/provider.js

@@ -129,7 +129,7 @@ function availabilityFromError(err) {
 }
 export const gitlabProvider = {
     id: 'gitlab',
-    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'MR' },
+    capabilities: { canCreatePr: true, canChangePrBase: true, canMergeRequest: true, requestTermShort: 'MR' },
     async isAvailable(repoPath) {
         try {
             await execFileAsync('glab', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
@@ -179,4 +179,7 @@ export const gitlabProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('glab', ['mr', 'update', '--target-branch', base], { cwd: repoPath, encoding: 'utf-8' });
     },
+    async mergeRequest(repoPath, number) {
+        await execFileAsync('glab', ['mr', 'merge', String(number), '--yes'], { cwd: repoPath, encoding: 'utf-8' });
+    },
 };

package/dist/server/services/forge/none.js

@@ -7,7 +7,7 @@ import { ForgeUnavailableError } from './types.js';
  */
 export const noneProvider = {
     id: 'none',
-    capabilities: { canCreatePr: false, canChangePrBase: false, requestTermShort: 'PR' },
+    capabilities: { canCreatePr: false, canChangePrBase: false, canMergeRequest: false, requestTermShort: 'PR' },
     async isAvailable() {
         return { available: false };
     },
@@ -20,4 +20,7 @@ export const noneProvider = {
     async changePrBase() {
         throw new ForgeUnavailableError('This project has no supported forge configured');
     },
+    async mergeRequest() {
+        throw new ForgeUnavailableError('This project has no supported forge configured');
+    },
 };

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

@@ -269,6 +269,25 @@ export async function extractNotionPage(notionUrl) {
         mcpProcess.kill();
     }
 }
+/** Lightweight MCP/auth smoke test; does not read a user page or mutate Notion. */
+export async function testNotionConnection() {
+    const startedAt = Date.now();
+    const global = getGlobalSettings();
+    const mcpProcess = spawnNotionMcp(global.notionMcpKey);
+    try {
+        await initializeMcp(mcpProcess);
+        await callMcpTool(mcpProcess, 'API-get-users', { page_size: 1 });
+        return {
+            ok: true,
+            durationMs: Date.now() - startedAt,
+            detail: 'MCP connection and Notion authentication succeeded',
+        };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
 export async function listNotionUsers() {
     const global = getGlobalSettings();
     const mcpProcess = spawnNotionMcp(global.notionMcpKey);

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

@@ -61,7 +61,7 @@ export function searchEvents(query, options = {}) {
     // realistic datasets, without scanning the entire table.
     const dbLimit = Math.max(limit * 3, 100);
     const rows = db
-        .prepare(`SELECT e.workspace_id, e.type, e.created_at, e.payload,
+        .prepare(`SELECT e.id, e.workspace_id, e.session_id, e.type, e.created_at, e.payload,
               w.name AS workspace_name, w.archived_at
        FROM ws_events e
        JOIN workspaces w ON e.workspace_id = w.id
@@ -88,6 +88,8 @@ export function searchEvents(query, options = {}) {
         if (idx < 0)
             continue;
         results.push({
+            eventId: row.id,
+            sessionId: row.session_id,
             workspaceId: row.workspace_id,
             workspaceName: row.workspace_name,
             archived: row.archived_at !== null,

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

@@ -13,6 +13,26 @@ export function parseSentryUrl(url) {
     }
     return match[1];
 }
+/** Lightweight MCP/auth smoke test; does not access or mutate an issue. */
+export async function testSentryConnection() {
+    const startedAt = Date.now();
+    const global = getGlobalSettings();
+    const config = readSentryMcpConfig(global.sentryMcpKey);
+    const mcpProcess = spawnMcpProcess(config.command, config.args, config.env);
+    try {
+        await initializeMcp(mcpProcess);
+        await callMcpTool(mcpProcess, 'whoami', {});
+        return {
+            ok: true,
+            durationMs: Date.now() - startedAt,
+            detail: 'MCP connection and Sentry authentication succeeded',
+        };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
 const SENTRY_CONFIG_ERROR = "Sentry MCP server not configured in ~/.claude.json — add an enabled 'sentry' entry under mcpServers";
 /**
  * Return the first enabled (`disabled !== true`) MCP server entry from

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

@@ -750,6 +750,24 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 46,
+        name: 'add-integration-enabled-switches',
+        migrate: ({ global }) => {
+            if (typeof global.notionEnabled !== 'boolean')
+                global.notionEnabled = true;
+            if (typeof global.sentryEnabled !== 'boolean')
+                global.sentryEnabled = true;
+        },
+    },
+    {
+        version: 47,
+        name: 'add-thinking-block-visibility',
+        migrate: ({ global }) => {
+            if (typeof global.showThinkingBlocks !== 'boolean')
+                global.showThinkingBlocks = true;
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -837,6 +855,9 @@ function defaultSettings() {
             defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan' },
             notionMcpKey: '',
             sentryMcpKey: '',
+            notionEnabled: true,
+            sentryEnabled: true,
+            showThinkingBlocks: true,
             tags: [...DEFAULT_WORKSPACE_TAGS],
             branchPrefixes: [...DEFAULT_BRANCH_PREFIXES],
             worktreesPath: WORKTREES_PATH,
@@ -1219,6 +1240,9 @@ export function updateGlobalSettings(data) {
         'defaultPermissionModeByEngine',
         'notionMcpKey',
         'sentryMcpKey',
+        'notionEnabled',
+        'sentryEnabled',
+        'showThinkingBlocks',
         'tags',
         'branchPrefixes',
         'worktreesPath',