spiracha 2.1.0 → 2.2.0

package/apps/ui/src/lib/cursor-transcript-events.ts

@@ -1,6 +1,8 @@
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 import type { CursorBubble, CursorThreadTranscript, CursorToolCall } from '@spiracha/lib/cursor-exporter-types';
+import { getCursorTextBubblePhase, getFinalCursorAssistantTextBubbleIds } from '@spiracha/lib/cursor-transcript-phase';
 import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
 
 const toTimestamp = (value: number | null): string | null => {
     if (value === null || !Number.isFinite(value)) {
@@ -110,36 +112,10 @@ const buildToolOutputEvent = (bubble: CursorBubble, sequence: number, toolCall:
     };
 };
 
-const getAssistantFinalTextIndexes = (bubbles: CursorBubble[]) => {
-    const finalTextIndexes = new Set<number>();
-    let currentAssistantTextIndex: number | null = null;
-
-    const flushAssistantRun = () => {
-        if (currentAssistantTextIndex !== null) {
-            finalTextIndexes.add(currentAssistantTextIndex);
-            currentAssistantTextIndex = null;
-        }
-    };
-
-    bubbles.forEach((bubble, index) => {
-        if (bubble.kind !== 'assistant') {
-            flushAssistantRun();
-            return;
-        }
-
-        if (bubble.text.trim()) {
-            currentAssistantTextIndex = index;
-        }
-    });
-
-    flushAssistantRun();
-    return finalTextIndexes;
-};
-
 const cursorBubbleToThreadEvents = (
     bubble: CursorBubble,
     bubbleIndex: number,
-    finalTextIndexes: Set<number>,
+    finalAssistantTextBubbleIds: Set<string>,
 ): ThreadEvent[] => {
     if (bubble.kind !== 'assistant' && bubble.kind !== 'user') {
         return [];
@@ -152,9 +128,8 @@ const cursorBubbleToThreadEvents = (
     }
 
     if (bubble.text.trim()) {
-        const phase =
-            bubble.kind === 'assistant' ? (finalTextIndexes.has(bubbleIndex) ? 'final_answer' : 'commentary') : null;
-        events.push(buildMessageEvent(bubble, baseSequence + 1, bubble.kind, bubble.text, phase));
+        const phase = getCursorTextBubblePhase(bubble, finalAssistantTextBubbleIds);
+        events.push(buildMessageEvent(bubble, baseSequence + 1, bubble.kind, bubble.text.trim(), phase));
     }
 
     if (bubble.kind === 'assistant' && bubble.toolCall) {
@@ -169,61 +144,11 @@ const cursorBubbleToThreadEvents = (
 };
 
 export const cursorTranscriptToThreadEvents = (transcript: CursorThreadTranscript): ThreadEvent[] => {
-    const finalTextIndexes = getAssistantFinalTextIndexes(transcript.bubbles);
-    return transcript.bubbles.flatMap((bubble, index) => cursorBubbleToThreadEvents(bubble, index, finalTextIndexes));
-};
-
-const updateMessageStats = (stats: ThreadTranscriptStats, event: Extract<ThreadEvent, { kind: 'message' }>) => {
-    stats.messageCount += 1;
-    if (event.role === 'assistant') {
-        stats.assistantMessageCount += 1;
-    }
-    if (event.role === 'user') {
-        stats.userMessageCount += 1;
-    }
-    if (event.phase === 'commentary') {
-        stats.commentaryCount += 1;
-    }
-    if (event.phase === 'final_answer') {
-        stats.finalAnswerCount += 1;
-    }
-};
-
-const updateCursorStats = (stats: ThreadTranscriptStats, event: ThreadEvent) => {
-    switch (event.kind) {
-        case 'message':
-            updateMessageStats(stats, event);
-            break;
-        case 'tool_call':
-            stats.toolCallCount += 1;
-            break;
-        case 'tool_output':
-            stats.toolOutputCount += 1;
-            break;
-        case 'web_search':
-            stats.webSearchEventCount += 1;
-            break;
-        default:
-            break;
-    }
+    const finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds(transcript.bubbles);
+    return transcript.bubbles.flatMap((bubble, index) =>
+        cursorBubbleToThreadEvents(bubble, index, finalAssistantTextBubbleIds),
+    );
 };
 
-export const getCursorThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
-    const stats: ThreadTranscriptStats = {
-        assistantMessageCount: 0,
-        commentaryCount: 0,
-        execCommandCount: 0,
-        finalAnswerCount: 0,
-        messageCount: 0,
-        toolCallCount: 0,
-        toolOutputCount: 0,
-        userMessageCount: 0,
-        webSearchEventCount: 0,
-    };
-
-    for (const event of events) {
-        updateCursorStats(stats, event);
-    }
-
-    return stats;
-};
+export const getCursorThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats =>
+    getThreadTranscriptStats(events);

package/apps/ui/src/lib/delete-batch.ts

@@ -0,0 +1,52 @@
+export class DeleteBatchError<TId, TResult> extends AggregateError {
+    readonly failedIds: TId[];
+    readonly successfulIds: TId[];
+    readonly successfulResults: TResult[];
+
+    constructor(
+        failures: Array<{ id: TId; reason: unknown }>,
+        successes: Array<{ id: TId; result: TResult }>,
+        totalCount: number,
+    ) {
+        const visibleFailedIds = failures.slice(0, 5).map((failure) => String(failure.id));
+        const omittedFailedIdCount = failures.length - visibleFailedIds.length;
+        const failedIdSummary = `${visibleFailedIds.join(', ')}${omittedFailedIdCount > 0 ? ` (+${omittedFailedIdCount} more)` : ''}`;
+        super(
+            failures.map((failure) => failure.reason),
+            `${failures.length} of ${totalCount} deletions failed: ${failedIdSummary}`,
+        );
+        this.name = 'DeleteBatchError';
+        this.failedIds = failures.map((failure) => failure.id);
+        this.successfulIds = successes.map((success) => success.id);
+        this.successfulResults = successes.map((success) => success.result);
+    }
+}
+
+export const runDeleteBatch = async <TId, TResult>(
+    ids: TId[],
+    deleteOne: (id: TId) => Promise<TResult>,
+): Promise<TResult[]> => {
+    const settled = await Promise.allSettled(ids.map((id) => deleteOne(id)));
+    const failures: Array<{ id: TId; reason: unknown }> = [];
+    const successes: Array<{ id: TId; result: TResult }> = [];
+    for (const [index, result] of settled.entries()) {
+        const id = ids[index]!;
+        if (result.status === 'rejected') {
+            failures.push({ id, reason: result.reason });
+        } else {
+            successes.push({ id, result: result.value });
+        }
+    }
+    if (failures.length > 0) {
+        throw new DeleteBatchError(failures, successes, ids.length);
+    }
+
+    return successes.map((success) => success.result);
+};
+
+export const requireDeletedItems = <T>(deletedIds: T[], label: string, id: string): T[] => {
+    if (deletedIds.length === 0) {
+        throw new Error(`${label} not found: ${id}`);
+    }
+    return deletedIds;
+};

package/apps/ui/src/lib/error-presentation.ts

@@ -0,0 +1,43 @@
+import { isSqliteDatabaseError } from '@spiracha/lib/sqlite-error';
+
+export type ErrorPresentation = {
+    description: string;
+    isDatabaseError: boolean;
+    title: string;
+};
+
+type ErrorPresentationOptions = {
+    fallbackTitle: string;
+};
+
+const DATABASE_ERROR_DESCRIPTION =
+    'Spiracha could not open a local conversation database. The source application may have an exclusive lock on the file, or the database may not exist yet. Close the relevant application or wait a moment, then reload.';
+
+const redactLocalPaths = (message: string): string => {
+    return message
+        .split(/(https?:\/\/[^\s]+)/gu)
+        .map((part, index) =>
+            index % 2 === 1
+                ? part
+                : part
+                      .replace(/\/(?:[^/\s]+\/)+[^/\s]+/gu, '[local path]')
+                      .replace(/[A-Z]:\\(?:[^\\\s]+\\)+[^\\\s]+/gu, '[local path]'),
+        )
+        .join('');
+};
+
+export const getErrorPresentation = (error: Error, options: ErrorPresentationOptions): ErrorPresentation => {
+    if (isSqliteDatabaseError(error)) {
+        return {
+            description: DATABASE_ERROR_DESCRIPTION,
+            isDatabaseError: true,
+            title: 'Database unavailable',
+        };
+    }
+
+    return {
+        description: redactLocalPaths(error.message),
+        isDatabaseError: false,
+        title: options.fallbackTitle,
+    };
+};

package/apps/ui/src/lib/export-mutation.ts

@@ -0,0 +1,20 @@
+import type { ExportDialogOptions } from '#/lib/export-options';
+
+export type ExportSelectionMutationInput = Readonly<{
+    ids: readonly string[];
+    options: Readonly<ExportDialogOptions>;
+}>;
+
+export const createExportSelectionMutationInput = (
+    ids: readonly string[],
+    options: ExportDialogOptions,
+): ExportSelectionMutationInput => {
+    if (ids.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    return {
+        ids: [...ids],
+        options: { ...options },
+    };
+};

package/apps/ui/src/lib/export-options.ts

@@ -0,0 +1,15 @@
+export type ExportDialogOptions = {
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    outputFormat: 'md' | 'txt';
+    zipArchive: boolean;
+};
+
+export const DEFAULT_EXPORT_DIALOG_OPTIONS: ExportDialogOptions = {
+    includeCommentary: false,
+    includeMetadata: true,
+    includeTools: true,
+    outputFormat: 'md',
+    zipArchive: false,
+};

package/apps/ui/src/lib/grok-server.ts

@@ -1,5 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { runDeleteBatch } from './delete-batch';
 import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
@@ -154,9 +155,7 @@ export const deleteGrokSessionsFn = createServerFn({ method: 'POST' })
     .handler(async ({ data }) => {
         const { deleteGrokSession, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
         const sessionsDir = resolveGrokSessionsDir();
-        const results = await Promise.all(
-            data.sessionIds.map((sessionId) => deleteGrokSession(sessionsDir, sessionId)),
-        );
+        const results = await runDeleteBatch(data.sessionIds, (sessionId) => deleteGrokSession(sessionsDir, sessionId));
         const deletedSessionIds = results.flatMap((result) => result.deletedSessionIds);
         if (deletedSessionIds.length === 0) {
             throw new Error('No Grok sessions were deleted');

package/apps/ui/src/lib/kiro-server.ts

@@ -1,5 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { requireDeletedItems, runDeleteBatch } from './delete-batch';
 import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
@@ -139,7 +140,9 @@ export const deleteKiroSessionFn = createServerFn({ method: 'POST' })
     .validator(sessionSchema)
     .handler(async ({ data }) => {
         const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
-        return deleteKiroSession(resolveKiroWorkspaceSessionsDir(), data.sessionId);
+        const result = await deleteKiroSession(resolveKiroWorkspaceSessionsDir(), data.sessionId);
+        requireDeletedItems(result.deletedSessionIds, 'Kiro session', data.sessionId);
+        return result;
     });
 
 export const deleteKiroSessionsFn = createServerFn({ method: 'POST' })
@@ -147,5 +150,14 @@ export const deleteKiroSessionsFn = createServerFn({ method: 'POST' })
     .handler(async ({ data }) => {
         const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
         const sessionsDir = resolveKiroWorkspaceSessionsDir();
-        return Promise.all(data.sessionIds.map((sessionId) => deleteKiroSession(sessionsDir, sessionId)));
+        const results = await runDeleteBatch(data.sessionIds, (sessionId) => deleteKiroSession(sessionsDir, sessionId));
+        requireDeletedItems(
+            results.flatMap((result) => result.deletedSessionIds),
+            'Kiro sessions',
+            'batch',
+        );
+        return {
+            deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],
+            deletedSessionIds: [...new Set(results.flatMap((result) => result.deletedSessionIds))],
+        };
     });

package/apps/ui/src/lib/mutation-error.ts

@@ -0,0 +1,15 @@
+export const getMutationErrorMessage = (error: unknown, fallback: string): string | null => {
+    if (!error) {
+        return null;
+    }
+
+    if (error instanceof Error) {
+        return error.message;
+    }
+
+    if (typeof error === 'object' && 'message' in error && typeof error.message === 'string' && error.message.trim()) {
+        return error.message;
+    }
+
+    return fallback;
+};

package/apps/ui/src/lib/opencode-server.ts

@@ -1,5 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { requireDeletedItems, runDeleteBatch } from './delete-batch';
 import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
@@ -139,7 +140,9 @@ export const deleteOpenCodeSessionFn = createServerFn({ method: 'POST' })
     .validator(sessionSchema)
     .handler(async ({ data }) => {
         const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
-        return deleteOpenCodeSession(resolveOpenCodeDbPath(), data.sessionId);
+        const result = await deleteOpenCodeSession(resolveOpenCodeDbPath(), data.sessionId);
+        requireDeletedItems(result.deletedSessionIds, 'OpenCode session', data.sessionId);
+        return result;
     });
 
 export const deleteOpenCodeSessionsFn = createServerFn({ method: 'POST' })
@@ -147,5 +150,13 @@ export const deleteOpenCodeSessionsFn = createServerFn({ method: 'POST' })
     .handler(async ({ data }) => {
         const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
         const dbPath = resolveOpenCodeDbPath();
-        return Promise.all(data.sessionIds.map((sessionId) => deleteOpenCodeSession(dbPath, sessionId)));
+        const results = await runDeleteBatch(data.sessionIds, (sessionId) => deleteOpenCodeSession(dbPath, sessionId));
+        requireDeletedItems(
+            results.flatMap((result) => result.deletedSessionIds),
+            'OpenCode sessions',
+            'batch',
+        );
+        return {
+            deletedSessionIds: [...new Set(results.flatMap((result) => result.deletedSessionIds))],
+        };
     });

package/apps/ui/src/lib/path-utils.ts

@@ -1,5 +1,5 @@
 import { applyPathTransforms as applySharedPathTransforms } from '@spiracha/lib/path-transforms';
-import type { Settings } from './settings-store';
+import type { Settings } from './settings';
 
 export const applyPathTransforms = (
     text: string,

package/apps/ui/src/lib/qoder-queries.ts

@@ -1,10 +1,21 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
 import { queryOptions } from '@tanstack/react-query';
 import { getQoderSessionDetailFn, listQoderSessionsFn, listQoderWorkspacesFn } from './qoder-server';
 
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
 export const qoderWorkspacesQueryOptions = () =>
     queryOptions({
         queryFn: () => listQoderWorkspacesFn(),
         queryKey: ['qoder-workspaces'],
+        retry: retrySqliteQuery,
+        retryDelay,
     });
 
 export const qoderSessionsQueryOptions = (workspaceKey: string | null) =>
@@ -12,6 +23,8 @@ export const qoderSessionsQueryOptions = (workspaceKey: string | null) =>
         enabled: workspaceKey !== null,
         queryFn: () => listQoderSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
         queryKey: ['qoder-sessions', workspaceKey ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
     });
 
 export const qoderSessionDetailQueryOptions = (sessionId: string | null) =>
@@ -19,4 +32,6 @@ export const qoderSessionDetailQueryOptions = (sessionId: string | null) =>
         enabled: sessionId !== null,
         queryFn: () => getQoderSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
         queryKey: ['qoder-session', sessionId ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
     });

package/apps/ui/src/lib/qoder-transcript-events.ts

@@ -57,7 +57,7 @@ const buildToolCallEvent = (
 ): ThreadEvent => ({
     argumentsParseFailed: false,
     argumentsText: command,
-    callId: entry.entryId,
+    callId: getPartString(part, 'toolCallId') ?? entry.entryId,
     command,
     kind: 'tool_call',
     name: getPartString(part, 'toolName') ?? 'qoder_file_operation',

package/apps/ui/src/lib/route-state-reset.tsx

@@ -0,0 +1,10 @@
+import { Fragment, type ReactNode } from 'react';
+
+type RouteStateResetBoundaryProps = {
+    children: ReactNode;
+    routeKey: string;
+};
+
+export const RouteStateResetBoundary = ({ children, routeKey }: RouteStateResetBoundaryProps) => {
+    return <Fragment key={routeKey}>{children}</Fragment>;
+};

package/apps/ui/src/lib/settings-server.ts

@@ -0,0 +1,33 @@
+import { createServerFn } from '@tanstack/react-start';
+import { getCookie, setCookie } from '@tanstack/react-start/server';
+import { z } from 'zod';
+import { parseSerializedSettings, SETTINGS_COOKIE_NAME, serializeSettings } from '#/lib/settings';
+
+const exportDefaultsSchema = z.object({
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    zipArchive: z.boolean(),
+});
+
+const settingsSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    exportDefaults: exportDefaultsSchema,
+    redactUsername: z.boolean(),
+});
+
+export const getInitialSettingsFn = createServerFn({ method: 'GET' }).handler(async () =>
+    parseSerializedSettings(getCookie(SETTINGS_COOKIE_NAME)),
+);
+
+export const saveSettingsFn = createServerFn({ method: 'POST' })
+    .validator(settingsSchema)
+    .handler(async ({ data }) => {
+        setCookie(SETTINGS_COOKIE_NAME, serializeSettings(data), {
+            httpOnly: true,
+            maxAge: 60 * 60 * 24 * 365,
+            path: '/',
+            sameSite: 'lax',
+        });
+    });

package/apps/ui/src/lib/settings-store.tsx

@@ -1,59 +1,103 @@
-import type { ReactNode } from 'react';
-import { createContext, useContext, useEffect, useState } from 'react';
-
-export type Settings = {
-    convertToProjectRoot: boolean;
-    redactUsername: boolean;
-};
+import { createContext, type ReactNode, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { DEFAULT_SETTINGS, normalizeSettings, type Settings } from '#/lib/settings';
+import { getInitialSettingsFn, saveSettingsFn } from '#/lib/settings-server';
 
 type SettingsContextValue = {
     settings: Settings;
     updateSetting: <K extends keyof Settings>(key: K, value: Settings[K]) => void;
 };
 
-const STORAGE_KEY = 'spiracha-settings';
-
-const defaultSettings: Settings = {
-    convertToProjectRoot: false,
-    redactUsername: false,
-};
+const SETTINGS_CHANNEL_NAME = 'spiracha-settings';
 
 const SettingsContext = createContext<SettingsContextValue>({
-    settings: defaultSettings,
+    settings: DEFAULT_SETTINGS,
     updateSetting: () => {},
 });
 
-const loadSettings = (): Settings => {
-    if (typeof window === 'undefined') {
-        return defaultSettings;
-    }
-    try {
-        const stored = window.localStorage.getItem(STORAGE_KEY);
-        return stored ? { ...defaultSettings, ...(JSON.parse(stored) as Partial<Settings>) } : defaultSettings;
-    } catch {
-        return defaultSettings;
-    }
-};
-
-export function SettingsProvider({ children }: { children: ReactNode }) {
-    const [settings, setSettings] = useState<Settings>(defaultSettings);
+export function SettingsProvider({
+    children,
+    initialSettings = DEFAULT_SETTINGS,
+}: {
+    children: ReactNode;
+    initialSettings?: Settings;
+}) {
+    const [settings, setSettings] = useState(initialSettings);
+    const channelRef = useRef<BroadcastChannel | null>(null);
+    const pendingSaveCountRef = useRef(0);
+    const settingsRef = useRef(initialSettings);
+    const settingsRevisionRef = useRef(0);
+    const synchronizationRequestRef = useRef(0);
+    const persistenceQueueRef = useRef(Promise.resolve());
 
-    // Load from localStorage on mount (client only — avoids SSR hydration mismatch)
     useEffect(() => {
-        setSettings(loadSettings());
+        const synchronizeFromCookie = () => {
+            const hadPendingSave = pendingSaveCountRef.current > 0;
+            const requestId = synchronizationRequestRef.current + 1;
+            const revision = settingsRevisionRef.current;
+            synchronizationRequestRef.current = requestId;
+            void getInitialSettingsFn()
+                .then((savedSettings) => {
+                    if (
+                        hadPendingSave ||
+                        pendingSaveCountRef.current > 0 ||
+                        requestId !== synchronizationRequestRef.current ||
+                        revision !== settingsRevisionRef.current
+                    ) {
+                        return;
+                    }
+                    settingsRef.current = savedSettings;
+                    setSettings(savedSettings);
+                })
+                .catch((error: unknown) => {
+                    console.error('[spiracha:settings] synchronization failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+        };
+        const channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(SETTINGS_CHANNEL_NAME);
+        if (channel) {
+            channel.onmessage = (event: MessageEvent<unknown>) => {
+                if (pendingSaveCountRef.current > 0) {
+                    return;
+                }
+                const synchronizedSettings = normalizeSettings(event.data);
+                settingsRevisionRef.current += 1;
+                settingsRef.current = synchronizedSettings;
+                setSettings(synchronizedSettings);
+            };
+            channelRef.current = channel;
+        }
+        window.addEventListener('focus', synchronizeFromCookie);
+
+        return () => {
+            window.removeEventListener('focus', synchronizeFromCookie);
+            channel?.close();
+            channelRef.current = null;
+        };
     }, []);
 
-    const updateSetting = <K extends keyof Settings>(key: K, value: Settings[K]) => {
-        setSettings((prev) => {
-            const next = { ...prev, [key]: value };
+    const updateSetting = useCallback(<K extends keyof Settings>(key: K, value: Settings[K]) => {
+        const nextSettings = { ...settingsRef.current, [key]: value };
+        pendingSaveCountRef.current += 1;
+        settingsRevisionRef.current += 1;
+        settingsRef.current = nextSettings;
+        setSettings(nextSettings);
+        persistenceQueueRef.current = persistenceQueueRef.current.then(async () => {
             try {
-                localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
-            } catch {}
-            return next;
+                await saveSettingsFn({ data: nextSettings });
+                channelRef.current?.postMessage(nextSettings);
+            } catch (error) {
+                console.error('[spiracha:settings] persistence failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            } finally {
+                pendingSaveCountRef.current -= 1;
+            }
         });
-    };
+    }, []);
+    const contextValue = useMemo(() => ({ settings, updateSetting }), [settings, updateSetting]);
 
-    return <SettingsContext.Provider value={{ settings, updateSetting }}>{children}</SettingsContext.Provider>;
+    return <SettingsContext.Provider value={contextValue}>{children}</SettingsContext.Provider>;
 }
 
 export const useSettings = () => useContext(SettingsContext);