@lelouchhe/webagent 0.1.3 → 0.1.5

package/dist/js/{events.mmjvjb37.js → events.mmlj0xfy.js}

@@ -4,12 +4,35 @@ import {
   state, dom, setBusy, setConfigValue, getConfigOption, updateConfigOptions,
   updateModeUI, resetSessionUI, requestNewSession, setHashSessionId, updateSessionInfo,
   setConnectionStatus, clearCancelTimer,
-} from './state.mmjvjb37.js';
+} from './state.mmlj0xfy.js';
 import {
   addMessage, addSystem, finishAssistant, finishThinking, hideWaiting,
   scrollToBottom, renderMd, escHtml, renderPatchDiff, addBashBlock, finishBash, appendMessageElement,
   formatLocalTime,
-} from './render.mmjvjb37.js';
+} from './render.mmlj0xfy.js';
+
+const NOTIFY_TIP_KEY = 'webagent_notify_tip_shown';
+const NOTIFY_TIP_DENIED_KEY = 'webagent_notify_tip_denied_shown';
+
+function showNotifyTip() {
+  if (typeof Notification === 'undefined') return;
+  if (state.replayInProgress) return;
+
+  const perm = Notification.permission;
+  if (perm === 'granted') return; // already enabled
+
+  if (perm === 'denied') {
+    if (localStorage.getItem(NOTIFY_TIP_DENIED_KEY)) return;
+    localStorage.setItem(NOTIFY_TIP_DENIED_KEY, '1');
+    addSystem('tip: notifications are blocked — allow in browser site settings to enable');
+    return;
+  }
+
+  // permission === 'default'
+  if (localStorage.getItem(NOTIFY_TIP_KEY)) return;
+  localStorage.setItem(NOTIFY_TIP_KEY, '1');
+  addSystem('tip: use /notify to enable background notifications');
+}
 
 function finishPromptIfIdle() {
   if (!state.pendingPromptDone) return;
@@ -18,8 +41,8 @@ function finishPromptIfIdle() {
   finishThinking();
   finishAssistant();
   setBusy(false);
-  dom.input.focus();
   state.pendingPromptDone = false;
+  showNotifyTip();
 }
 
 function cancelPendingTurnUI() {
@@ -32,7 +55,7 @@ function cancelPendingTurnUI() {
   }
   for (const requestId of state.pendingPermissionRequestIds) {
     const permEl = document.querySelector(`.permission[data-request-id="${requestId}"]`);
-    if (!permEl) continue;
+    if (!permEl || !permEl.querySelector('button')) continue;
     const titleEl = permEl.querySelector('.title');
     const title = titleEl?.textContent || '⚿';
     permEl.innerHTML = `<span style="opacity:0.5">${escHtml(title)} — cancelled</span>`;
@@ -118,6 +141,36 @@ export async function loadNewEvents(sid) {
   }
 }
 
+/**
+ * Resend permission responses that were sent optimistically but never confirmed
+ * by the server (e.g. WS dropped before delivery). Call after loadNewEvents/loadHistory
+ * on reconnect.
+ */
+export function retryUnconfirmedPermissions() {
+  for (const [requestId, response] of state.unconfirmedPermissions) {
+    const el = document.querySelector(`.permission[data-request-id="${requestId}"]`);
+    if (!el || !el.querySelector('button')) {
+      // Element gone or already resolved — clean up
+      state.unconfirmedPermissions.delete(requestId);
+      continue;
+    }
+    // Still pending in DOM — resend and optimistically resolve
+    if (state.ws && state.ws.readyState === 1) {
+      state.ws.send(JSON.stringify({
+        type: 'permission_response',
+        sessionId: response.sessionId,
+        requestId,
+        optionId: response.optionId,
+        optionName: response.optionName,
+        denied: response.denied,
+      }));
+    }
+    const title = el.dataset.title ? `⚿ ${escHtml(el.dataset.title)}` : '⚿';
+    el.innerHTML = `<span style="opacity:0.5">${title} — ${escHtml(response.optionName)}</span>`;
+    state.unconfirmedPermissions.delete(requestId);
+  }
+}
+
 export function replayEvent(type, data, events, idx) {
   switch (type) {
     case 'user_message': {
@@ -236,7 +289,7 @@ export function replayEvent(type, data, events, idx) {
       const el = document.querySelector(`.permission[data-request-id="${data.requestId}"]`);
       if (el) {
         const title = el.dataset.title ? `⚿ ${el.dataset.title}` : '⚿';
-        const action = data.denied ? 'denied' : data.optionName || 'allowed';
+        const action = data.optionName || (data.denied ? 'denied' : 'allowed');
         el.innerHTML = `<span style="opacity:0.5">${escHtml(title)} — ${escHtml(action)}</span>`;
       }
       break;
@@ -468,6 +521,8 @@ export function handleEvent(msg) {
 
     case 'permission_request': {
       if (state.turnEnded) break;
+      // Dedup: skip if a permission element with this requestId already exists (e.g. bridge restore)
+      if (document.querySelector(`.permission[data-request-id="${msg.requestId}"]`)) break;
       state.pendingPermissionRequestIds.add(msg.requestId);
       setBusy(true);
       finishThinking();
@@ -494,6 +549,13 @@ export function handleEvent(msg) {
             }));
           } catch { /* connection may be broken; cleanup still runs */ }
           state.pendingPermissionRequestIds.delete(msg.requestId);
+          // Track for retry on reconnect (cleared when server confirms via permission_resolved)
+          state.unconfirmedPermissions.set(msg.requestId, {
+            sessionId: state.sessionId,
+            optionId: opt.optionId,
+            optionName: opt.name,
+            denied: isDeny,
+          });
           permEl.innerHTML = `<span style="opacity:0.5">⚿ ${escHtml(msg.title)} — ${escHtml(opt.name)}</span>`;
           finishPromptIfIdle();
         };
@@ -505,10 +567,11 @@ export function handleEvent(msg) {
 
     case 'permission_resolved': {
       state.pendingPermissionRequestIds.delete(msg.requestId);
+      state.unconfirmedPermissions.delete(msg.requestId);
       const permTarget = document.querySelector(`.permission[data-request-id="${msg.requestId}"]`);
       if (msg.sessionId === state.sessionId && permTarget) {
         const title = permTarget.dataset.title ? `⚿ ${permTarget.dataset.title}` : '⚿';
-        const action = msg.denied ? 'denied' : msg.optionName || 'allowed';
+        const action = msg.optionName || (msg.denied ? 'denied' : 'allowed');
         permTarget.innerHTML = `<span style="opacity:0.5">${escHtml(title)} — ${escHtml(action)}</span>`;
       }
       finishPromptIfIdle();
@@ -547,7 +610,6 @@ export function handleEvent(msg) {
       finishBash(state.currentBashEl, msg.code, msg.signal);
       if (msg.error) addSystem(`err: ${msg.error}`);
       setBusy(false);
-      dom.input.focus();
       break;
     }
 

package/dist/js/{images.mmjvjb37.js → images.mmlj0xfy.js}

@@ -1,6 +1,6 @@
 // Image attach, preview, and paste handling
 
-import { state, dom } from './state.mmjvjb37.js';
+import { state, dom } from './state.mmlj0xfy.js';
 
 function readFileAsBase64(file) {
   return new Promise((resolve) => {

package/dist/js/{input.mmjvjb37.js → input.mmlj0xfy.js}

@@ -3,10 +3,14 @@
 import {
   state, dom, setBusy, sendCancel,
   getConfigOption, getConfigValue, updateNewBtnVisibility,
-} from './state.mmjvjb37.js';
-import { addMessage, addSystem, addBashBlock, showWaiting } from './render.mmjvjb37.js';
-import { handleSlashCommand, hideSlashMenu, handleSlashMenuKey, updateSlashMenu } from './commands.mmjvjb37.js';
-import { renderAttachPreview } from './images.mmjvjb37.js';
+} from './state.mmlj0xfy.js';
+import { addMessage, addSystem, addBashBlock, showWaiting } from './render.mmlj0xfy.js';
+import { handleSlashCommand, hideSlashMenu, handleSlashMenuKey, updateSlashMenu } from './commands.mmlj0xfy.js';
+import { renderAttachPreview } from './images.mmlj0xfy.js';
+
+function wsReady() {
+  return state.ws && state.ws.readyState === 1;
+}
 
 // Wire up cancel-timeout feedback (state.js cannot import render.js directly)
 state._onCancelTimeout = () => addSystem('warn: Agent not responding to cancel');
@@ -32,6 +36,10 @@ function sendMessage() {
       addSystem('warn: Session not ready yet, please wait…');
       return;
     }
+    if (!wsReady()) {
+      addSystem('warn: Not connected, please retry');
+      return;
+    }
     dom.input.value = '';
     dom.input.style.height = 'auto';
     dom.inputArea.classList.remove('bash-mode');
@@ -55,6 +63,11 @@ function sendMessage() {
     return;
   }
 
+  if (!wsReady()) {
+    addSystem('warn: Not connected, please retry');
+    return;
+  }
+
   // Show user message with image thumbnails
   const msgEl = addMessage('user', text || '(image)');
   for (const img of state.pendingImages) {
@@ -77,6 +90,12 @@ function sendMessage() {
         body: JSON.stringify({ data: img.data, mimeType: img.mimeType }),
       }).then(r => r.json()).then(j => ({ data: img.data, mimeType: img.mimeType, path: j.path }))
     )).then(uploaded => {
+      if (!wsReady()) {
+        msgEl.remove();
+        addSystem('warn: Not connected, please retry');
+        setBusy(false);
+        return;
+      }
       state.ws.send(JSON.stringify({ type: 'prompt', sessionId: state.sessionId, text: text || 'What is in this image?', images: uploaded }));
     });
   } else {

package/dist/js/{render.mmjvjb37.js → render.mmlj0xfy.js}

@@ -1,6 +1,6 @@
 // Rendering functions, theme, markdown, bash UI
 
-import { dom, state } from './state.mmjvjb37.js';
+import { dom, state } from './state.mmlj0xfy.js';
 
 // --- Markdown ---
 marked.setOptions({ breaks: true, gfm: true });

package/dist/js/{state.mmjvjb37.js → state.mmlj0xfy.js}

@@ -43,6 +43,7 @@ export const state = {
   lastEventSeq: 0,
   replayInProgress: false,
   replayQueue: [],
+  unconfirmedPermissions: new Map(),
 };
 
 const CONNECTION_STATUS_CLASSES = {
@@ -112,6 +113,7 @@ export function resetSessionUI() {
   state.followMessages = true;
   state.pendingToolCallIds.clear();
   state.pendingPermissionRequestIds.clear();
+  state.unconfirmedPermissions.clear();
   state.pendingPromptDone = false;
   state.turnEnded = false;
   state._cancelTimerId = null;

package/dist/sw.js

@@ -1,5 +1,51 @@
-// Minimal service worker for PWA installability.
+// Minimal service worker for PWA installability + push notifications.
 // No offline caching — app requires WebSocket connection.
 
 self.addEventListener('install', () => self.skipWaiting());
 self.addEventListener('activate', (e) => e.waitUntil(self.clients.claim()));
+
+// --- Push notifications ---
+
+self.addEventListener('push', (e) => {
+  if (!e.data) return;
+
+  let payload;
+  try {
+    payload = e.data.json();
+  } catch {
+    return;
+  }
+
+  const { title, body, data } = payload;
+  e.waitUntil(
+    self.registration.showNotification(title || 'WebAgent', {
+      body: body || '',
+      icon: '/icon-192.png',
+      badge: '/icon-192.png',
+      tag: data?.sessionId || 'default',
+      data: data || {},
+    })
+  );
+});
+
+self.addEventListener('notificationclick', (e) => {
+  e.notification.close();
+
+  const sessionId = e.notification.data?.sessionId;
+  const urlHash = sessionId ? `/#${sessionId}` : '/';
+
+  e.waitUntil(
+    self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then((clients) => {
+      // Focus existing window if open
+      for (const client of clients) {
+        if (client.url.includes(self.location.origin)) {
+          client.focus();
+          client.postMessage({ type: 'navigate', sessionId });
+          return;
+        }
+      }
+      // Otherwise open a new window
+      return self.clients.openWindow(urlHash);
+    })
+  );
+});

package/lib/config.js

@@ -16,6 +16,11 @@ const ConfigSchema = z.object({
         image_upload: 10_485_760,
         cancel_timeout: 10_000,
     }),
+    push: z.object({
+        vapid_subject: z.string().default("mailto:webagent@localhost"),
+    }).default({
+        vapid_subject: "mailto:webagent@localhost",
+    }),
 });
 let _config = null;
 function parseArgs() {

package/lib/daemon.js

@@ -0,0 +1,278 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const PID_FILE = "webagent.pid";
+const LOG_FILE = "webagent.log";
+const RESTART_DELAY_INITIAL = 1_000;
+const RESTART_DELAY_MAX = 30_000;
+const STABLE_THRESHOLD_MS = 60_000;
+const KILL_GRACE_MS = 5_000;
+const SUBCOMMANDS = ["start", "stop", "status", "restart"];
+/** Read and validate the PID file at `filePath`. Returns null if missing or stale. */
+export function readPidInfo(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const info = JSON.parse(readFileSync(filePath, "utf8"));
+        if (typeof info.pid !== "number" || !Number.isFinite(info.pid))
+            return null;
+        process.kill(info.pid, 0); // existence check — throws if dead
+        return info;
+    }
+    catch {
+        // Process is dead or file corrupt — clean up
+        try {
+            unlinkSync(filePath);
+        }
+        catch { /* ignore */ }
+        return null;
+    }
+}
+/** Write PID info to `filePath`. */
+export function writePidInfo(filePath, info) {
+    writeFileSync(filePath, JSON.stringify(info) + "\n");
+}
+// ---------------------------------------------------------------------------
+// Arg helpers
+// ---------------------------------------------------------------------------
+export function isSubcommand(arg) {
+    return SUBCOMMANDS.includes(arg);
+}
+/** Resolve relative `--config` values to absolute paths (based on cwd). */
+export function resolveArgs(args) {
+    const result = [...args];
+    for (let i = 0; i < result.length; i++) {
+        if (result[i] === "--config" && i + 1 < result.length && !isAbsolute(result[i + 1])) {
+            result[i + 1] = resolve(result[i + 1]);
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Command dispatch
+// ---------------------------------------------------------------------------
+export async function run(command, args) {
+    const pidFile = join(process.cwd(), PID_FILE);
+    const logFile = join(process.cwd(), LOG_FILE);
+    switch (command) {
+        case "start": return cmdStart(pidFile, logFile, args);
+        case "stop": return cmdStop(pidFile);
+        case "status": return cmdStatus(pidFile, logFile);
+        case "restart": return cmdRestart(pidFile, logFile);
+    }
+}
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+async function cmdStart(pidFile, logFile, args) {
+    const existing = readPidInfo(pidFile);
+    if (existing) {
+        console.log(`webagent is already running (pid ${existing.pid})`);
+        process.exitCode = 1;
+        return;
+    }
+    const serverJs = join(__dirname, "server.js");
+    if (!existsSync(serverJs)) {
+        console.error(`server not found: ${serverJs}`);
+        console.error('run "npx tsc -p tsconfig.build.json" first if developing from source');
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveArgs(args);
+    const daemonJs = join(__dirname, "daemon.js");
+    const log = openSync(logFile, "a");
+    const child = spawn(process.execPath, [daemonJs, "__supervisor", ...resolved], { detached: true, stdio: ["ignore", log, log], cwd: process.cwd() });
+    child.unref();
+    closeSync(log);
+    // Poll for PID file (supervisor writes it on startup)
+    for (let i = 0; i < 6; i++) {
+        await sleep(500);
+        const info = readPidInfo(pidFile);
+        if (info) {
+            console.log(`webagent started (pid ${info.pid})`);
+            console.log(`log: ${logFile}`);
+            return;
+        }
+    }
+    console.error("webagent failed to start");
+    console.error(`check log: ${logFile}`);
+    process.exitCode = 1;
+}
+async function cmdStop(pidFile) {
+    const info = readPidInfo(pidFile);
+    if (!info) {
+        console.log("webagent is not running");
+        return;
+    }
+    try {
+        process.kill(info.pid, "SIGTERM");
+    }
+    catch {
+        console.log("webagent is not running (stale pid file removed)");
+        try {
+            unlinkSync(pidFile);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    // Wait for exit
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        await sleep(300);
+        try {
+            process.kill(info.pid, 0);
+        }
+        catch {
+            // Gone — supervisor cleans up PID file, but be safe
+            try {
+                unlinkSync(pidFile);
+            }
+            catch { /* ignore */ }
+            console.log("webagent stopped");
+            return;
+        }
+    }
+    console.error(`webagent (pid ${info.pid}) did not stop within 10s`);
+    console.error(`try: kill -9 ${info.pid}`);
+    process.exitCode = 1;
+}
+async function cmdStatus(pidFile, logFile) {
+    const info = readPidInfo(pidFile);
+    if (!info) {
+        console.log("webagent is not running");
+        return;
+    }
+    const uptimeMs = Date.now() - new Date(info.started).getTime();
+    const h = Math.floor(uptimeMs / 3_600_000);
+    const m = Math.floor((uptimeMs % 3_600_000) / 60_000);
+    console.log(`webagent is running (pid ${info.pid})`);
+    console.log(`  started: ${info.started}`);
+    console.log(`  uptime:  ${h}h ${m}m`);
+    console.log(`  args:    ${info.args.join(" ") || "(none)"}`);
+    console.log(`  log:     ${logFile}`);
+}
+async function cmdRestart(pidFile, logFile) {
+    const info = readPidInfo(pidFile);
+    if (!info) {
+        console.log("webagent is not running");
+        process.exitCode = 1;
+        return;
+    }
+    if (process.platform === "win32") {
+        // No SIGHUP on Windows — fall back to stop + start (non-atomic)
+        await cmdStop(pidFile);
+        await cmdStart(pidFile, logFile, info.args);
+        return;
+    }
+    // Unix: atomic restart via SIGHUP to supervisor
+    try {
+        process.kill(info.pid, "SIGHUP");
+    }
+    catch {
+        console.error(`failed to signal webagent (pid ${info.pid})`);
+        process.exitCode = 1;
+        return;
+    }
+    // Wait briefly and verify
+    await sleep(2000);
+    const newInfo = readPidInfo(pidFile);
+    if (newInfo) {
+        console.log(`webagent restarted (pid ${newInfo.pid})`);
+    }
+    else {
+        console.error("webagent may have failed to restart");
+        console.error(`check log: ${logFile}`);
+        process.exitCode = 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Supervisor (internal — launched by `start` as a detached process)
+// ---------------------------------------------------------------------------
+function runSupervisor(serverArgs) {
+    const serverJs = join(__dirname, "server.js");
+    const pidFile = join(process.cwd(), PID_FILE);
+    writePidInfo(pidFile, { pid: process.pid, args: serverArgs, started: new Date().toISOString() });
+    let child = null;
+    let stopping = false;
+    let lastStart = 0;
+    let delay = RESTART_DELAY_INITIAL;
+    let timer = null;
+    function spawnServer() {
+        lastStart = Date.now();
+        child = spawn(process.execPath, [serverJs, ...serverArgs], { stdio: "inherit" });
+        child.on("exit", onChildExit);
+    }
+    function onChildExit(code, signal) {
+        child = null;
+        if (stopping)
+            return;
+        if (Date.now() - lastStart > STABLE_THRESHOLD_MS) {
+            delay = RESTART_DELAY_INITIAL;
+        }
+        else {
+            delay = Math.min(delay * 2, RESTART_DELAY_MAX);
+        }
+        console.log(`[supervisor] server exited (code=${code} signal=${signal}), restarting in ${delay}ms`);
+        timer = setTimeout(spawnServer, delay);
+    }
+    function killChild() {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        return new Promise((resolve) => {
+            if (!child) {
+                resolve();
+                return;
+            }
+            const c = child;
+            c.once("exit", () => resolve());
+            c.kill("SIGTERM");
+            setTimeout(() => { try {
+                c.kill("SIGKILL");
+            }
+            catch { /* ignore */ } }, KILL_GRACE_MS);
+        });
+    }
+    async function shutdown() {
+        if (stopping)
+            return;
+        stopping = true;
+        await killChild();
+        try {
+            unlinkSync(pidFile);
+        }
+        catch { /* ignore */ }
+        process.exit(0);
+    }
+    process.on("SIGTERM", () => { shutdown(); });
+    process.on("SIGINT", () => { shutdown(); });
+    if (process.platform !== "win32") {
+        process.on("SIGHUP", async () => {
+            console.log("[supervisor] SIGHUP received, restarting server");
+            delay = RESTART_DELAY_INITIAL;
+            await killChild();
+            if (!stopping)
+                spawnServer();
+        });
+    }
+    console.log(`[supervisor] started (pid ${process.pid})`);
+    spawnServer();
+}
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+// ---------------------------------------------------------------------------
+// Direct execution: node daemon.js __supervisor [server args...]
+// ---------------------------------------------------------------------------
+if (process.argv[2] === "__supervisor") {
+    runSupervisor(process.argv.slice(3));
+}

package/lib/event-handler.js

@@ -0,0 +1,95 @@
+import { broadcast } from "./ws-handler.js";
+export function handleAgentEvent(event, sessions, store, wss, bridge, config, pushService) {
+    if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
+        return;
+    switch (event.type) {
+        case "connected":
+            event.cancelTimeout = config.cancelTimeout;
+            break;
+        case "session_created":
+            if (event.configOptions?.length)
+                sessions.cachedConfigOptions = event.configOptions;
+            for (const opt of event.configOptions ?? []) {
+                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
+            }
+            break;
+        case "config_option_update":
+            if (event.configOptions?.length)
+                sessions.cachedConfigOptions = event.configOptions;
+            for (const opt of event.configOptions ?? []) {
+                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
+            }
+            break;
+        case "message_chunk":
+            sessions.flushThinkingBuffer(event.sessionId);
+            sessions.appendAssistant(event.sessionId, event.text);
+            break;
+        case "thought_chunk":
+            sessions.flushAssistantBuffer(event.sessionId);
+            sessions.appendThinking(event.sessionId, event.text);
+            break;
+        case "tool_call":
+            sessions.flushBuffers(event.sessionId);
+            store.saveEvent(event.sessionId, event.type, { id: event.id, title: event.title, kind: event.kind, rawInput: event.rawInput });
+            break;
+        case "tool_call_update":
+            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content });
+            break;
+        case "plan":
+            sessions.flushBuffers(event.sessionId);
+            store.saveEvent(event.sessionId, event.type, { entries: event.entries });
+            break;
+        case "permission_request": {
+            sessions.flushBuffers(event.sessionId);
+            store.saveEvent(event.sessionId, event.type, {
+                requestId: event.requestId, title: event.title, options: event.options,
+            });
+            // Auto-approve permissions in autopilot mode (allow_once only to avoid persisting across mode switches)
+            const mode = store.getSession(event.sessionId)?.mode ?? "";
+            if (mode.includes("#autopilot")) {
+                const opt = event.options.find((o) => o.kind === "allow_once");
+                if (opt) {
+                    bridge.resolvePermission(event.requestId, opt.optionId);
+                    const optionName = opt.label ?? opt.optionId;
+                    store.saveEvent(event.sessionId, "permission_response", {
+                        requestId: event.requestId, optionName, denied: false,
+                    });
+                    broadcast(wss, {
+                        type: "permission_resolved",
+                        sessionId: event.sessionId,
+                        requestId: event.requestId,
+                        optionName,
+                        denied: false,
+                    });
+                    return;
+                }
+            }
+            break;
+        }
+        case "prompt_done":
+            sessions.activePrompts.delete(event.sessionId);
+            sessions.flushBuffers(event.sessionId);
+            store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason });
+            break;
+        case "error":
+            if (event.sessionId) {
+                sessions.activePrompts.delete(event.sessionId);
+            }
+            break;
+    }
+    broadcast(wss, event);
+    // Push notification check (after broadcast so WS clients get the event first)
+    if (pushService && "sessionId" in event && event.sessionId) {
+        const session = store.getSession(event.sessionId);
+        const eventData = {};
+        if (event.type === "permission_request") {
+            eventData.description = event.title;
+        }
+        if (pushService.maybeNotify(event.sessionId, session?.title ?? null, event.type, eventData)) {
+            const notification = pushService.formatNotification(event.sessionId, session?.title ?? null, event.type, eventData);
+            pushService.sendToAll(notification).catch((err) => {
+                console.error("[push] failed to send:", err);
+            });
+        }
+    }
+}