@loicngr/kobo 1.10.2 → 1.11.0

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/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/pr-watcher-service.js

@@ -168,6 +168,12 @@ export async function checkPrStatuses() {
             // Archive on a transition FROM OPEN to CLOSED/MERGED. Skips the
             // base-change detection below — archiving wins.
             if (prev?.state === 'OPEN' && (pr.state === 'MERGED' || pr.state === 'CLOSED')) {
+                if (pr.state === 'MERGED') {
+                    emitEphemeral(ws.id, 'pr:merged', {
+                        prNumber: pr.number,
+                        prUrl: pr.url,
+                    });
+                }
                 if (['extracting', 'brainstorming', 'executing'].includes(ws.status)) {
                     // Agent is working — update the cache but skip auto-archive.
                     // (The defensive base preservation from the no-base branch doesn't apply here
@@ -213,33 +219,32 @@ export async function checkPrStatuses() {
                 }
                 continue; // do not run base-change detection on a workspace we just archived
             }
-            // Review-decision and CI transitions (only on OPEN PRs; first-sight is
-            // silent). Reuses the baseline rule from base-change detection: act only
-            // on an actual transition between two known states. Each notable
-            // transition (changes-requested newly raised, CI newly failing) flips
-            // `hasUnread` so the workspace card stands out as "something new to
-            // look at" in the drawer — the unread bit persists until the user opens
-            // the workspace, matching the existing read/unread UX.
+            // Review, CI, mergeability, and readiness transitions (only on OPEN PRs;
+            // first-sight is silent). Each check is independent so simultaneous
+            // state changes emit every applicable event.
             if (pr.state === 'OPEN' && prev) {
+                const payload = { prNumber: pr.number, prUrl: pr.url };
                 if (prev.reviewDecision !== 'CHANGES_REQUESTED' && pr.reviewDecision === 'CHANGES_REQUESTED') {
-                    emitEphemeral(ws.id, 'pr:changes-requested', {
-                        prNumber: pr.number,
-                        prUrl: pr.url,
-                    });
+                    emitEphemeral(ws.id, 'pr:changes-requested', payload);
                     markUnread(ws.id);
                 }
-                else if (prev.reviewDecision === 'CHANGES_REQUESTED' && pr.reviewDecision === 'APPROVED') {
-                    emitEphemeral(ws.id, 'pr:approved', {
-                        prNumber: pr.number,
-                        prUrl: pr.url,
-                    });
+                if (prev.reviewDecision !== 'APPROVED' && pr.reviewDecision === 'APPROVED') {
+                    emitEphemeral(ws.id, 'pr:approved', payload);
                 }
                 if (prev.ci.rollup !== 'FAILURE' && pr.ci.rollup === 'FAILURE') {
+                    emitEphemeral(ws.id, 'pr:ci-failed', payload);
+                    markUnread(ws.id);
+                }
+                if (prev.ci.rollup === 'FAILURE' && pr.ci.rollup === 'SUCCESS') {
+                    emitEphemeral(ws.id, 'pr:ci-recovered', payload);
+                }
+                if (prev.mergeable !== 'CONFLICTING' && pr.mergeable === 'CONFLICTING') {
+                    emitEphemeral(ws.id, 'pr:merge-conflict', payload);
                     markUnread(ws.id);
                 }
                 const notBusy = !['extracting', 'brainstorming', 'executing'].includes(ws.status);
                 if (notBusy && !prev.readyToMerge && pr.readyToMerge) {
-                    emitEphemeral(ws.id, 'pr:ready-to-merge', { prNumber: pr.number, prUrl: pr.url });
+                    emitEphemeral(ws.id, 'pr:ready-to-merge', payload);
                     markUnread(ws.id);
                 }
             }

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

@@ -698,6 +698,76 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 44,
+        name: 'add-pr-notification-sounds',
+        migrate: ({ global }) => {
+            const keys = [
+                'audioPrCiFailedSound',
+                'audioPrCiRecoveredSound',
+                'audioPrChangesRequestedSound',
+                'audioPrApprovedSound',
+                'audioPrMergeConflictSound',
+                'audioPrReadyToMergeSound',
+                'audioPrMergedSound',
+            ];
+            for (const key of keys) {
+                if (typeof global[key] !== 'string' || global[key].length === 0) {
+                    global[key] = 'inherit';
+                }
+            }
+        },
+    },
+    {
+        version: 45,
+        name: 'add-pr-notification-audio-controls',
+        migrate: ({ global }) => {
+            const legacyVolume = global.audioNotificationVolume;
+            const volume = typeof legacyVolume === 'number' && Number.isFinite(legacyVolume) && legacyVolume >= 0 && legacyVolume <= 1
+                ? legacyVolume
+                : 1;
+            const events = [
+                'CiFailed',
+                'CiRecovered',
+                'ChangesRequested',
+                'Approved',
+                'MergeConflict',
+                'ReadyToMerge',
+                'Merged',
+            ];
+            for (const event of events) {
+                const soundKey = `audioPr${event}Sound`;
+                const enabledKey = `audioPr${event}Enabled`;
+                const volumeKey = `audioPr${event}Volume`;
+                const muted = global[soundKey] === 'none';
+                if (muted)
+                    global[soundKey] = 'inherit';
+                if (typeof global[enabledKey] !== 'boolean')
+                    global[enabledKey] = !muted;
+                if (typeof global[volumeKey] !== 'number' || !Number.isFinite(global[volumeKey])) {
+                    global[volumeKey] = volume;
+                }
+            }
+        },
+    },
+    {
+        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;
@@ -754,6 +824,27 @@ function defaultSettings() {
             audioNotificationSound: 'hey.mp3',
             audioQuestionSound: 'hey.mp3',
             audioWorkspaceCreatedSound: 'warcraft-3-humain-travail.mp3',
+            audioPrCiFailedSound: 'inherit',
+            audioPrCiFailedEnabled: true,
+            audioPrCiFailedVolume: 1,
+            audioPrCiRecoveredSound: 'inherit',
+            audioPrCiRecoveredEnabled: true,
+            audioPrCiRecoveredVolume: 1,
+            audioPrChangesRequestedSound: 'inherit',
+            audioPrChangesRequestedEnabled: true,
+            audioPrChangesRequestedVolume: 1,
+            audioPrApprovedSound: 'inherit',
+            audioPrApprovedEnabled: true,
+            audioPrApprovedVolume: 1,
+            audioPrMergeConflictSound: 'inherit',
+            audioPrMergeConflictEnabled: true,
+            audioPrMergeConflictVolume: 1,
+            audioPrReadyToMergeSound: 'inherit',
+            audioPrReadyToMergeEnabled: true,
+            audioPrReadyToMergeVolume: 1,
+            audioPrMergedSound: 'inherit',
+            audioPrMergedEnabled: true,
+            audioPrMergedVolume: 1,
             audioNotificationVolume: 1,
             audioQuestionVolume: 1,
             audioWorkspaceCreatedVolume: 1,
@@ -764,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,
@@ -1115,6 +1209,27 @@ export function updateGlobalSettings(data) {
         'audioNotificationSound',
         'audioQuestionSound',
         'audioWorkspaceCreatedSound',
+        'audioPrCiFailedSound',
+        'audioPrCiFailedEnabled',
+        'audioPrCiFailedVolume',
+        'audioPrCiRecoveredSound',
+        'audioPrCiRecoveredEnabled',
+        'audioPrCiRecoveredVolume',
+        'audioPrChangesRequestedSound',
+        'audioPrChangesRequestedEnabled',
+        'audioPrChangesRequestedVolume',
+        'audioPrApprovedSound',
+        'audioPrApprovedEnabled',
+        'audioPrApprovedVolume',
+        'audioPrMergeConflictSound',
+        'audioPrMergeConflictEnabled',
+        'audioPrMergeConflictVolume',
+        'audioPrReadyToMergeSound',
+        'audioPrReadyToMergeEnabled',
+        'audioPrReadyToMergeVolume',
+        'audioPrMergedSound',
+        'audioPrMergedEnabled',
+        'audioPrMergedVolume',
         'audioNotificationVolume',
         'audioQuestionVolume',
         'audioWorkspaceCreatedVolume',
@@ -1125,6 +1240,9 @@ export function updateGlobalSettings(data) {
         'defaultPermissionModeByEngine',
         'notionMcpKey',
         'sentryMcpKey',
+        'notionEnabled',
+        'sentryEnabled',
+        'showThinkingBlocks',
         'tags',
         'branchPrefixes',
         'worktreesPath',
@@ -1161,7 +1279,18 @@ export function updateGlobalSettings(data) {
         const sanitized = sanitizeBranchPrefixes(filtered.branchPrefixes);
         filtered.branchPrefixes = sanitized.length > 0 ? sanitized : settings.global.branchPrefixes;
     }
-    for (const key of ['audioNotificationVolume', 'audioQuestionVolume', 'audioWorkspaceCreatedVolume']) {
+    for (const key of [
+        'audioNotificationVolume',
+        'audioQuestionVolume',
+        'audioWorkspaceCreatedVolume',
+        'audioPrCiFailedVolume',
+        'audioPrCiRecoveredVolume',
+        'audioPrChangesRequestedVolume',
+        'audioPrApprovedVolume',
+        'audioPrMergeConflictVolume',
+        'audioPrReadyToMergeVolume',
+        'audioPrMergedVolume',
+    ]) {
         if (filtered[key] !== undefined) {
             const v = Number(filtered[key]);
             filtered[key] = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 1;