@kortix/sdk 0.9.98

package/dist/react/use-opencode-config.js

@@ -0,0 +1,79 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../opencode/client.js';
+import { useOpenCodeRuntimeReady } from './use-opencode-sessions/keys.js';
+export const configKeys = {
+    all: ['opencode', 'config'],
+};
+function unwrap(result) {
+    if (result.error) {
+        // `error`'s shape varies per endpoint's typed error union — duck-type
+        // defensively via `unknown` rather than assume a shape.
+        const err = result.error;
+        const errRec = err && typeof err === 'object' ? err : undefined;
+        const dataRec = errRec?.data && typeof errRec.data === 'object' ? errRec.data : undefined;
+        const message = dataRec?.message ?? errRec?.message;
+        throw new Error(typeof message === 'string' ? message : 'Request failed');
+    }
+    return result.data;
+}
+export function useOpenCodeConfig() {
+    const runtimeReady = useOpenCodeRuntimeReady();
+    return useQuery({
+        queryKey: configKeys.all,
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.global.config.get();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export function useUpdateOpenCodeConfig() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (config) => {
+            const client = getClient();
+            // The SDK's `update` param type wants a full `Config`, but the server
+            // accepts (and this hook always sends) a partial merge patch.
+            const result = await client.global.config.update({ config: config });
+            return unwrap(result);
+        },
+        onMutate: async (config) => {
+            // Cancel in-flight refetches so they don't overwrite optimistic update
+            await queryClient.cancelQueries({ queryKey: configKeys.all });
+            const previous = queryClient.getQueryData(configKeys.all);
+            if (previous) {
+                // Optimistically merge the draft into the cached config
+                queryClient.setQueryData(configKeys.all, {
+                    ...previous,
+                    ...config,
+                    permission: typeof config.permission !== 'undefined'
+                        ? config.permission
+                        : previous.permission,
+                });
+            }
+            return { previous };
+        },
+        onError: (_err, _config, context) => {
+            // Roll back to previous cache on failure
+            if (context?.previous) {
+                queryClient.setQueryData(configKeys.all, context.previous);
+            }
+        },
+        onSettled: () => {
+            // Refetch to get the authoritative server state — only if mounted
+            queryClient.refetchQueries({ queryKey: configKeys.all, type: 'active' });
+        },
+    });
+}
+/**
+ * @deprecated No longer needed — server persists config correctly.
+ * Kept as no-op for existing call sites.
+ */
+export function clearConfigOverrides() {
+    // no-op — localStorage overrides removed
+}
+//# sourceMappingURL=use-opencode-config.js.map

package/dist/react/use-opencode-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-opencode-config.js","sourceRoot":"","sources":["../../src/react/use-opencode-config.ts"],"names":[],"mappings":"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"}

package/dist/react/use-opencode-events/diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { Part } from '@opencode-ai/sdk/v2/client';
+import type { RefObject } from 'react';
+import type { NormalizeDiagnosticPaths } from './types.js';
+/**
+ * Extract diagnostics carried by a `message.part.updated` part — both the
+ * primary tool-output text path and the legacy `metadata.diagnostics` fallback —
+ * and push them into the diagnostics store. Paths are normalized from absolute
+ * sandbox paths to project-relative via the supplied ref.
+ */
+export declare function applyPartDiagnostics(part: Part, normalizeDiagnosticPaths: RefObject<NormalizeDiagnosticPaths>): void;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/react/use-opencode-events/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/react/use-opencode-events/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAMvC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,EACV,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,CAAC,GAC5D,IAAI,CAmDN"}

package/dist/react/use-opencode-events/diagnostics.js

@@ -0,0 +1,58 @@
+import { parseDiagnosticsFromToolOutput, useDiagnosticsStore, } from '../../state/diagnostics-store.js';
+/**
+ * Extract diagnostics carried by a `message.part.updated` part — both the
+ * primary tool-output text path and the legacy `metadata.diagnostics` fallback —
+ * and push them into the diagnostics store. Paths are normalized from absolute
+ * sandbox paths to project-relative via the supplied ref.
+ */
+export function applyPartDiagnostics(part, normalizeDiagnosticPaths) {
+    // Only `ToolPart` carries `.state` — every other `Part` variant doesn't.
+    const partState = part.type === 'tool' ? part.state : undefined;
+    // --- Primary path: parse diagnostics from tool output text ---
+    // The OpenCode backend embeds diagnostics as plain text inside
+    // <file_diagnostics> / <project_diagnostics> XML tags in the
+    // tool's text output (e.g. after write, edit, diagnostics tools).
+    if (partState?.status === 'completed' && partState.output) {
+        const output = partState.output;
+        if (output.includes('<file_diagnostics>') || output.includes('<project_diagnostics>')) {
+            const parsed = parseDiagnosticsFromToolOutput(output);
+            const fileCount = Object.keys(parsed).length;
+            if (fileCount > 0) {
+                // Normalize absolute sandbox paths to project-relative
+                const normalized = normalizeDiagnosticPaths.current(parsed);
+                // Convert LspDiagnostic[] to RawDiagnostic[] format for the store
+                const asRaw = {};
+                for (const [file, diags] of Object.entries(normalized)) {
+                    asRaw[file] = diags.map((d) => ({
+                        range: {
+                            start: { line: d.line, character: d.column },
+                        },
+                        severity: d.severity,
+                        message: d.message,
+                        source: d.source,
+                    }));
+                }
+                useDiagnosticsStore.getState().setFromLspEvent(asRaw);
+            }
+        }
+    }
+    // --- Fallback: check metadata.diagnostics (legacy / fork path) ---
+    // `metadata` isn't on `ToolStatePending` — narrow it away first.
+    const partMeta = partState && partState.status !== 'pending' ? partState.metadata : undefined;
+    if (partMeta?.diagnostics && typeof partMeta.diagnostics === 'object') {
+        const diagsByFile = partMeta.diagnostics;
+        const validEntries = {};
+        let hasValid = false;
+        for (const [file, diags] of Object.entries(diagsByFile)) {
+            if (Array.isArray(diags) && diags.length > 0) {
+                validEntries[file] = diags;
+                hasValid = true;
+            }
+        }
+        if (hasValid) {
+            const normalized = normalizeDiagnosticPaths.current(validEntries);
+            useDiagnosticsStore.getState().setFromLspEvent(normalized);
+        }
+    }
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/react/use-opencode-events/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../../../src/react/use-opencode-events/diagnostics.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,8BAA8B,EAC9B,mBAAmB,GAEpB,MAAM,+BAA+B,CAAC;AAGvC;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAU,EACV,wBAA6D;IAE7D,yEAAyE;IACzE,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAEhE,gEAAgE;IAChE,+DAA+D;IAC/D,6DAA6D;IAC7D,kEAAkE;IAClE,IAAI,SAAS,EAAE,MAAM,KAAK,WAAW,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC;QAC1D,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;QAChC,IAAI,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,CAAC;YACtF,MAAM,MAAM,GAAG,8BAA8B,CAAC,MAAM,CAAC,CAAC;YACtD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC;YAC7C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;gBAClB,uDAAuD;gBACvD,MAAM,UAAU,GAAG,wBAAwB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAC5D,kEAAkE;gBAClE,MAAM,KAAK,GAAoC,EAAE,CAAC;gBAClD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;oBACvD,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;wBAC9B,KAAK,EAAE;4BACL,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;yBAC7C;wBACD,QAAQ,EAAE,CAAC,CAAC,QAAQ;wBACpB,OAAO,EAAE,CAAC,CAAC,OAAO;wBAClB,MAAM,EAAE,CAAC,CAAC,MAAM;qBACjB,CAAC,CAAC,CAAC;gBACN,CAAC;gBACD,mBAAmB,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;IACH,CAAC;IAED,oEAAoE;IACpE,iEAAiE;IACjE,MAAM,QAAQ,GAAG,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9F,IAAI,QAAQ,EAAE,WAAW,IAAI,OAAO,QAAQ,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;QACtE,MAAM,WAAW,GAAG,QAAQ,CAAC,WAA8C,CAAC;QAC5E,MAAM,YAAY,GAAoC,EAAE,CAAC;QACzD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YACxD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7C,YAAY,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;gBAC3B,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,UAAU,GAAG,wBAAwB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAClE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/react/use-opencode-events/handle-event.d.ts

@@ -0,0 +1,20 @@
+import { type QueryClient } from '@tanstack/react-query';
+import type { Event as OpenCodeSdkEvent, PermissionRequest, QuestionRequest } from '@opencode-ai/sdk/v2/client';
+import type { RefObject } from 'react';
+import { getClient } from '../../opencode/client.js';
+import type { NormalizeDiagnosticPaths, OpenCodeEvent } from './types.js';
+/** Builds the SSE event handler; all closure dependencies are injected. */
+export declare function createEventHandler(deps: {
+    queryClient: QueryClient;
+    client: ReturnType<typeof getClient>;
+    applySyncEvent: (event: OpenCodeSdkEvent) => void;
+    stopCompaction: (sessionID: string) => void;
+    addPermission: (req: PermissionRequest) => void;
+    removePermission: (requestId: string) => void;
+    addQuestion: (req: QuestionRequest) => void;
+    removeQuestion: (requestId: string) => void;
+    normalizeDiagnosticPaths: RefObject<NormalizeDiagnosticPaths>;
+    markSessionAbortedLocally: RefObject<(sessionID: string, message?: string) => void>;
+    fetchLspDiagnosticsDebounced: RefObject<() => void>;
+}): (event: OpenCodeEvent) => void;
+//# sourceMappingURL=handle-event.d.ts.map

package/dist/react/use-opencode-events/handle-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-event.d.ts","sourceRoot":"","sources":["../../../src/react/use-opencode-events/handle-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EACV,KAAK,IAAI,gBAAgB,EACzB,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAUvC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAYlD,OAAO,KAAK,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEvE,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;IACrC,cAAc,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClD,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,aAAa,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAChD,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,WAAW,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;IAC5C,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAC9D,yBAAyB,EAAE,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC;IACpF,4BAA4B,EAAE,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;CACrD,WA0B6B,aAAa,UA8b1C"}

package/dist/react/use-opencode-events/handle-event.js

@@ -0,0 +1,450 @@
+import { infoToast, notifyPermissionRequest, notifyQuestion, notifySessionError, notifyTaskComplete, } from '../../platform/ui.js';
+import { deleteSessionFromIDB, saveSessionToIDB } from '../../state/idb-sync-cache.js';
+import { useSyncStore } from '../../state/sync-store.js';
+import { getClient } from '../../opencode/client.js';
+import { fileContentKeys, fileListKeys, gitStatusKeys } from '../file-keys.js';
+import { ptyKeys } from '../use-opencode-pty.js';
+import { opencodeKeys } from '../use-opencode-sessions/index.js';
+import { applyPartDiagnostics } from './diagnostics.js';
+import { asStringOrUndefined, looksLikeAbortError, readSessionInfo, refetchKortixSessionMirrors, scheduleProjectMetadataRefetch, } from './helpers.js';
+/** Builds the SSE event handler; all closure dependencies are injected. */
+export function createEventHandler(deps) {
+    const { queryClient, client, applySyncEvent, stopCompaction, addPermission, removePermission, addQuestion, removeQuestion, normalizeDiagnosticPaths, markSessionAbortedLocally, fetchLspDiagnosticsDebounced, } = deps;
+    // Helper: look up a session title from the React Query cache for notifications
+    function getSessionTitle(sessionID) {
+        const sessions = queryClient.getQueryData(opencodeKeys.sessions());
+        if (sessions) {
+            const s = sessions.find((s) => s.id === sessionID);
+            if (s?.title)
+                return s.title;
+        }
+        const session = queryClient.getQueryData(opencodeKeys.session(sessionID));
+        return session?.title || undefined;
+    }
+    function handleEvent(event) {
+        // Sync store is the SINGLE source of truth for messages & parts.
+        // This matches OpenCode's architecture where the SolidJS store is
+        // the only place message/part data lives.
+        //
+        // `event` also carries the frontend-synthesized `lsp.client.diagnostics`
+        // member (see `OpenCodeEvent`), which isn't a real wire event and doesn't
+        // match any `applyEvent` case (falls through to its `default`) — the
+        // assertion below just widens past that one extra union member.
+        applySyncEvent(event);
+        switch (event.type) {
+            // ---- Message events — handled by sync store only ----
+            case 'message.updated':
+            case 'message.removed':
+                break;
+            case 'message.part.updated': {
+                // Extract diagnostics from tool output and/or metadata
+                applyPartDiagnostics(event.properties.part, normalizeDiagnosticPaths);
+                break;
+            }
+            case 'message.part.removed':
+                break;
+            // ---- Session lifecycle — surgical cache mutations (zero HTTP) ----
+            //
+            // IMPORTANT: Return the old array reference when nothing changed.
+            // Creating new arrays on every SSE event causes cascading re-renders
+            // in all session list consumers, which triggers a Radix UI compose-refs
+            // infinite loop (Maximum update depth exceeded).
+            case 'session.created': {
+                const info = readSessionInfo(event);
+                if (info) {
+                    queryClient.setQueryData(opencodeKeys.sessions(), (old) => {
+                        if (!old)
+                            return [info];
+                        const exists = old.findIndex((s) => s.id === info.id);
+                        if (exists >= 0) {
+                            // Already exists — check if actually changed
+                            if (old[exists].time.updated === info.time.updated)
+                                return old;
+                            const next = [...old];
+                            next[exists] = info;
+                            return next.sort((a, b) => b.time.updated - a.time.updated);
+                        }
+                        return [info, ...old].sort((a, b) => b.time.updated - a.time.updated);
+                    });
+                    queryClient.setQueryData(opencodeKeys.session(info.id), info);
+                    refetchKortixSessionMirrors(queryClient);
+                }
+                break;
+            }
+            case 'session.updated': {
+                const info = readSessionInfo(event);
+                if (info) {
+                    // OpenCode auto-titles after the first message via session.updated.
+                    // Capture the previous title before local cache mutation so we only
+                    // force the server-owned mirror read when the title actually changed.
+                    const prevTitle = queryClient
+                        .getQueryData(opencodeKeys.sessions())
+                        ?.find((s) => s.id === info.id)?.title ??
+                        queryClient.getQueryData(opencodeKeys.session(info.id))?.title ??
+                        null;
+                    const titleChanged = !!info.title && info.title !== prevTitle;
+                    // Only update individual session cache (cheap, targeted)
+                    queryClient.setQueryData(opencodeKeys.session(info.id), info);
+                    // Update session list only if the session actually changed
+                    queryClient.setQueryData(opencodeKeys.sessions(), (old) => {
+                        if (!old)
+                            return old;
+                        const idx = old.findIndex((s) => s.id === info.id);
+                        if (idx < 0)
+                            return old;
+                        // Shallow check: skip only if BOTH the timestamp and the title are
+                        // unchanged. Title alone can flip (opencode auto-titles) without a
+                        // perceptible time bump, and dropping that would keep the tab stale.
+                        if (old[idx].time.updated === info.time.updated &&
+                            old[idx].title === info.title)
+                            return old;
+                        const next = [...old];
+                        next[idx] = info;
+                        return next.sort((a, b) => b.time.updated - a.time.updated);
+                    });
+                    if (titleChanged)
+                        refetchKortixSessionMirrors(queryClient);
+                }
+                break;
+            }
+            case 'session.deleted': {
+                const info = readSessionInfo(event);
+                if (info) {
+                    queryClient.setQueryData(opencodeKeys.sessions(), (old) => {
+                        if (!old)
+                            return old;
+                        const found = old.some((s) => s.id === info.id);
+                        if (!found)
+                            return old;
+                        return old.filter((s) => s.id !== info.id);
+                    });
+                    queryClient.removeQueries({ queryKey: opencodeKeys.session(info.id) });
+                    queryClient.removeQueries({ queryKey: opencodeKeys.messages(info.id) });
+                    deleteSessionFromIDB(info.id);
+                }
+                break;
+            }
+            case 'session.compacted': {
+                const sessionID = event.properties.sessionID;
+                if (sessionID) {
+                    stopCompaction(sessionID);
+                    const client = getClient();
+                    client.session
+                        .messages({ sessionID })
+                        .then((res) => {
+                        if (res.data) {
+                            useSyncStore.getState().hydrate(sessionID, res.data);
+                            const s = useSyncStore.getState();
+                            const msgs = s.messages[sessionID] ?? [];
+                            if (msgs.length > 0)
+                                saveSessionToIDB(sessionID, msgs, s.parts);
+                        }
+                    })
+                        .catch(() => { });
+                    // Refetch the individual session to clear time.compacting
+                    // (targeted refetch, not full session list invalidation)
+                    client.session
+                        .get({ sessionID })
+                        .then((res) => {
+                        if (res.data) {
+                            const session = res.data;
+                            queryClient.setQueryData(opencodeKeys.session(sessionID), session);
+                            // Also update in session list
+                            queryClient.setQueryData(opencodeKeys.sessions(), (old) => {
+                                if (!old)
+                                    return old;
+                                const idx = old.findIndex((s) => s.id === sessionID);
+                                if (idx < 0)
+                                    return old;
+                                const next = [...old];
+                                next[idx] = session;
+                                return next;
+                            });
+                        }
+                    })
+                        .catch(() => { });
+                }
+                break;
+            }
+            // ---- Session status ----
+            case 'session.status': {
+                const { sessionID, status } = event.properties;
+                if (sessionID && status) {
+                    // Detect busy/retry → idle transition BEFORE updating the store
+                    // (coalescing can drop intermediate busy events, so we check here)
+                    const prevStatus = useSyncStore.getState().sessionStatus[sessionID];
+                    if (status.type === 'idle' && prevStatus && prevStatus.type !== 'idle') {
+                        notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                        // Agent finished editing files — refresh the Changes panel.
+                        // Nothing else invalidates git status for agent-driven edits,
+                        // so without this the panel shows stale diff state.
+                        queryClient.invalidateQueries({ queryKey: gitStatusKeys.all, type: 'active' });
+                        queryClient.invalidateQueries({ queryKey: fileListKeys.all, type: 'active' });
+                    }
+                }
+                break;
+            }
+            case 'session.idle': {
+                const sessionID = event.properties.sessionID;
+                if (sessionID) {
+                    const prevStatus = useSyncStore.getState().sessionStatus[sessionID];
+                    if (prevStatus && prevStatus.type !== 'idle') {
+                        notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                        // Agent finished editing files — refresh the Changes panel.
+                        // Nothing else invalidates git status for agent-driven edits,
+                        // so without this the panel shows stale diff state.
+                        queryClient.invalidateQueries({ queryKey: gitStatusKeys.all, type: 'active' });
+                        queryClient.invalidateQueries({ queryKey: fileListKeys.all, type: 'active' });
+                        // Persist final session state to IDB when streaming completes
+                        const s = useSyncStore.getState();
+                        const msgs = s.messages[sessionID] ?? [];
+                        if (msgs.length > 0)
+                            saveSessionToIDB(sessionID, msgs, s.parts);
+                    }
+                }
+                break;
+            }
+            // ---- Session errors ----
+            case 'session.error': {
+                const props = event.properties;
+                if (props.sessionID && props.error) {
+                    const sessionID = props.sessionID;
+                    const error = props.error;
+                    stopCompaction(sessionID);
+                    // Fire browser notification
+                    const rawMessage = error.data.message;
+                    const errorTitle = error.name ||
+                        (typeof rawMessage === 'string' ? rawMessage : undefined) ||
+                        'An error occurred';
+                    notifySessionError(sessionID, errorTitle, getSessionTitle(sessionID));
+                    // Patch the error onto the last assistant message in cache.
+                    // This is critical because:
+                    // 1. session.error arrives BEFORE message.updated with .error
+                    // 2. Some error paths (model-not-found, agent-not-found) never
+                    //    emit message.updated with .error at all
+                    // 3. Polling can race and overwrite the error from message.updated
+                    const key = opencodeKeys.messages(sessionID);
+                    queryClient.cancelQueries({ queryKey: key });
+                    queryClient.setQueryData(key, (old) => {
+                        if (!old || old.length === 0)
+                            return old;
+                        // Find the last assistant message and patch error onto it
+                        for (let i = old.length - 1; i >= 0; i--) {
+                            const info = old[i].info;
+                            if (info.role === 'assistant') {
+                                if (info.error)
+                                    return old; // already has error
+                                const updated = [...old];
+                                updated[i] = {
+                                    ...old[i],
+                                    info: { ...info, error },
+                                };
+                                return updated;
+                            }
+                        }
+                        return old;
+                    });
+                    // Fetch real messages from the server to bring in
+                    // authoritative data. In error paths the server may never
+                    // send message.updated for the user message, leaving the
+                    // optimistic duplicate. After hydrating server data,
+                    // clear any optimistic messages (now superseded by real
+                    // ones) to prevent double user bubbles.
+                    //
+                    // EXCEPTION: On abort, skip the fetch+hydrate — the server
+                    // may not have persisted the partial assistant response yet,
+                    // so hydrating would wipe the streamed content the user saw.
+                    // The error is already patched onto the message above.
+                    const isAbortError = looksLikeAbortError(error);
+                    if (!isAbortError) {
+                        client.session
+                            .messages({ sessionID })
+                            .then((res) => {
+                            if (!res.data)
+                                return;
+                            useSyncStore.getState().hydrate(sessionID, res.data);
+                            useSyncStore.getState().clearOptimisticMessages(sessionID);
+                            const s = useSyncStore.getState();
+                            const msgs = s.messages[sessionID] ?? [];
+                            if (msgs.length > 0)
+                                saveSessionToIDB(sessionID, msgs, s.parts);
+                        })
+                            .catch(() => { });
+                    }
+                    else {
+                        // Still clear optimistic messages on abort — the real
+                        // user message should have arrived via SSE by now.
+                        useSyncStore.getState().clearOptimisticMessages(sessionID);
+                    }
+                }
+                break;
+            }
+            // ---- Permissions ----
+            case 'permission.asked': {
+                const props = event.properties;
+                if (props.id && props.sessionID) {
+                    addPermission(props);
+                    // Fire browser notification for permission requests. `tool` (when
+                    // present) is `{messageID, callID}`, not a name — some historical
+                    // wire shapes carried a bare string `type` field instead, which the
+                    // current SDK types no longer declare. Duck-type both defensively
+                    // rather than assume either is a string.
+                    const rawProps = props;
+                    const toolName = asStringOrUndefined(rawProps.tool) ?? asStringOrUndefined(rawProps.type) ?? 'a tool';
+                    notifyPermissionRequest(props.sessionID, toolName, getSessionTitle(props.sessionID));
+                }
+                break;
+            }
+            case 'permission.replied': {
+                const requestID = event.properties.requestID;
+                if (requestID)
+                    removePermission(requestID);
+                break;
+            }
+            // ---- Questions ----
+            case 'question.asked': {
+                const props = event.properties;
+                if (props.id && props.sessionID) {
+                    addQuestion(props);
+                    // Fire browser notification for questions needing user input
+                    const questionText = props.questions[0]?.question ||
+                        props.questions[0]?.header ||
+                        'Kortix needs your input';
+                    notifyQuestion(props.sessionID, questionText, getSessionTitle(props.sessionID));
+                }
+                break;
+            }
+            case 'question.replied':
+            case 'question.rejected': {
+                const requestID = event.properties.requestID;
+                if (requestID)
+                    removeQuestion(requestID);
+                break;
+            }
+            // ---- Session diff ----
+            case 'session.diff': {
+                const props = event.properties;
+                if (props.sessionID) {
+                    queryClient.setQueryData(['opencode', 'session-diff', props.sessionID], props.diff);
+                }
+                break;
+            }
+            // ---- Todo updated ----
+            case 'todo.updated': {
+                const props = event.properties;
+                if (props.sessionID) {
+                    queryClient.setQueryData(['opencode', 'session-todo', props.sessionID], props.todos);
+                }
+                break;
+            }
+            // ---- VCS branch ----
+            case 'vcs.branch.updated': {
+                const props = event.properties;
+                queryClient.setQueryData(['opencode', 'vcs'], {
+                    branch: props.branch,
+                });
+                break;
+            }
+            // ---- Server disposed ----
+            case 'server.instance.disposed': {
+                for (const [sessionID, status] of Object.entries(useSyncStore.getState().sessionStatus)) {
+                    if (status?.type !== 'idle') {
+                        markSessionAbortedLocally.current(sessionID, 'The operation was aborted because the server instance was disposed.');
+                    }
+                }
+                // Instance dispose means the server rescanned skills, agents,
+                // tools, and commands. Invalidate all cached app metadata so
+                // the UI picks up newly installed marketplace components or
+                // agent-created skills/agents immediately.
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.sessions(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.mcpStatus(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.skills(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.agents(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.toolIds(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.commands(), type: 'active' });
+                break;
+            }
+            // ---- LSP updated ----
+            case 'lsp.updated': {
+                queryClient.invalidateQueries({ queryKey: ['opencode', 'lsp'], type: 'active' });
+                // A new LSP client connected — fetch diagnostics after a short
+                // delay to give the language server time to produce initial results.
+                fetchLspDiagnosticsDebounced.current();
+                break;
+            }
+            // ---- LSP client diagnostics (per-file notification) ----
+            case 'lsp.client.diagnostics': {
+                // This event signals diagnostics changed for a specific file.
+                // The event only carries { serverID, path } — actual diagnostic
+                // data must be fetched from the /lsp/diagnostics endpoint.
+                fetchLspDiagnosticsDebounced.current();
+                break;
+            }
+            // ---- MCP tools changed ----
+            case 'mcp.tools.changed': {
+                // MCP server tools were added/removed/changed — refresh status + tool lists.
+                // Only refetch if queries are actively mounted (type: 'active').
+                queryClient.refetchQueries({ queryKey: opencodeKeys.mcpStatus(), type: 'active' });
+                queryClient.refetchQueries({ queryKey: opencodeKeys.toolIds(), type: 'active' });
+                break;
+            }
+            // ---- PTY events ----
+            case 'pty.created':
+            case 'pty.updated':
+            case 'pty.exited':
+            case 'pty.deleted': {
+                queryClient.invalidateQueries({ queryKey: ptyKeys.listPrefix(), type: 'active' });
+                break;
+            }
+            // ---- Worktree events — disabled for now ----
+            case 'worktree.ready': {
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.worktrees(), type: 'active' });
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.projects(), type: 'active' });
+                break;
+            }
+            case 'worktree.failed': {
+                queryClient.invalidateQueries({ queryKey: opencodeKeys.worktrees(), type: 'active' });
+                break;
+            }
+            // ---- Project updated ----
+            case 'project.updated': {
+                // Targeted refetch — project data is small and changes rarely,
+                // but OpenCode can emit bursts while tools are running. Coalesce
+                // these so a burst cannot spam /project/current.
+                scheduleProjectMetadataRefetch(queryClient);
+                break;
+            }
+            // ---- File edited (outside agent, e.g. user edits in editor) ----
+            case 'file.edited': {
+                const fileProps = event.properties;
+                queryClient.invalidateQueries({ queryKey: fileListKeys.all, type: 'active' });
+                queryClient.invalidateQueries({ queryKey: gitStatusKeys.all, type: 'active' });
+                if (fileProps.file) {
+                    queryClient.invalidateQueries({ queryKey: fileContentKeys.all, type: 'active' });
+                }
+                break;
+            }
+            // ---- Installation events ----
+            case 'installation.updated': {
+                const installProps = event.properties;
+                const versionStr = installProps.version ? ` (v${installProps.version})` : '';
+                infoToast(`Installation updated${versionStr}. Restart to apply changes.`, {
+                    duration: 10_000,
+                });
+                break;
+            }
+            case 'installation.update-available': {
+                const updateProps = event.properties;
+                const versionLabel = updateProps.version ? `v${updateProps.version}` : 'A new version';
+                infoToast(`${versionLabel} is available. Update when you're ready.`, {
+                    duration: 15_000,
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return handleEvent;
+}
+//# sourceMappingURL=handle-event.js.map