opencode-enhancer 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,16 +1,17 @@
-import fs from 'node:fs';
-import { syncAuthFromOpenCode } from './auth-sync.js';
-import { createAuthorizationFlow, loginAccount, ensureValidToken } from './auth.js';
-import { extractRateLimitUpdate, getBlockingRateLimitResetAt, mergeRateLimits, parseRateLimitResetFromError, parseRetryAfterHeader } from './rate-limits.js';
-import { getNextAccount, markAuthInvalid, markModelUnsupported, markRateLimited, markWorkspaceDeactivated, getMinRemaining, selectBestAvailableAccount } from './rotation.js';
-import { getDefaultModels } from './models.js';
-import { getForceState, isForceActive } from './force-mode.js';
-import { getRuntimeSettings } from './settings.js';
-import { listAccounts, updateAccount, loadStore } from './store.js';
-import { DEFAULT_CONFIG } from './types.js';
-import { Errors } from './errors.js';
-import { decodeJwtPayload } from './jwt.js';
-import { PROVIDER_ID, CODEX_BASE_URL, URL_PATHS, OPENAI_HEADERS, OPENAI_HEADER_VALUES, JWT_CLAIM_PATH, TIMEOUTS, } from './constants.js';
+import fs from "node:fs";
+import { syncAuthFromOpenCode } from "./auth-sync.js";
+import { createAuthorizationFlow, loginAccount, ensureValidToken } from "./auth.js";
+import { extractRateLimitUpdate, getBlockingRateLimitResetAt, mergeRateLimits, parseRateLimitResetFromError, parseRetryAfterHeader, } from "./rate-limits.js";
+import { getNextAccount, markAuthInvalid, markModelUnsupported, markRateLimited, markWorkspaceDeactivated, getMinRemaining, selectBestAvailableAccount, } from "./rotation.js";
+import { compareAccountsByUsagePriority, getUsagePrioritySnapshot } from "./account-ranking.js";
+import { getDefaultModels } from "./models.js";
+import { getForceState, isForceActive } from "./force-mode.js";
+import { getRuntimeSettings, isNotificationEnabled } from "./settings.js";
+import { listAccounts, updateAccount, loadStore } from "./store.js";
+import { DEFAULT_CONFIG, } from "./types.js";
+import { Errors } from "./errors.js";
+import { decodeJwtPayload } from "./jwt.js";
+import { PROVIDER_ID, CODEX_BASE_URL, URL_PATHS, OPENAI_HEADERS, OPENAI_HEADER_VALUES, JWT_CLAIM_PATH, TIMEOUTS, } from "./constants.js";
 let pluginConfig = { ...DEFAULT_CONFIG };
 function readEnv(...keys) {
     for (const key of keys) {
@@ -21,37 +22,37 @@ function readEnv(...keys) {
     return undefined;
 }
 function isDebugEnabled() {
-    return readEnv('OPENCODE_ENHANCER_DEBUG', 'OPENCODE_MULTI_AUTH_DEBUG') === '1';
+    return readEnv("OPENCODE_ENHANCER_DEBUG", "OPENCODE_MULTI_AUTH_DEBUG") === "1";
 }
 function configure(config) {
     pluginConfig = { ...pluginConfig, ...config };
 }
 function formatUsageWindow(label, window) {
-    if (!window || typeof window.remaining !== 'number')
+    if (!window || typeof window.remaining !== "number")
         return undefined;
     if (window.limit === 100)
         return `${label}: ${window.remaining}%`;
-    if (typeof window.limit === 'number')
+    if (typeof window.limit === "number")
         return `${label}: ${window.remaining}/${window.limit}`;
     return `${label}: ${window.remaining}`;
 }
 function formatAccountUsageSummary(rateLimits) {
     const parts = [
-        formatUsageWindow('5h', rateLimits?.fiveHour),
-        formatUsageWindow('wk', rateLimits?.weekly)
+        formatUsageWindow("5h", rateLimits?.fiveHour),
+        formatUsageWindow("wk", rateLimits?.weekly),
     ].filter(Boolean);
-    return parts.join(' · ');
+    return parts.join(" · ");
 }
 function buildAccountSelectOption(account) {
     const label = account.email?.trim() || account.alias;
     return {
         label,
         value: account.alias,
-        hint: formatAccountUsageSummary(account.rateLimits)
+        hint: formatAccountUsageSummary(account.rateLimits),
     };
 }
 function extractRequestUrl(input) {
-    if (typeof input === 'string')
+    if (typeof input === "string")
         return input;
     if (input instanceof URL)
         return input.toString();
@@ -71,10 +72,10 @@ function extractPathAndSearch(url) {
     catch {
         // best-effort fallback
     }
-    const trimmed = String(url || '').trim();
-    if (trimmed.startsWith('/'))
+    const trimmed = String(url || "").trim();
+    if (trimmed.startsWith("/"))
         return trimmed;
-    const firstSlash = trimmed.indexOf('/');
+    const firstSlash = trimmed.indexOf("/");
     if (firstSlash >= 0)
         return trimmed.slice(firstSlash);
     return trimmed;
@@ -86,8 +87,8 @@ function toCodexBackendUrl(originalUrl) {
     if (mapped.includes(URL_PATHS.RESPONSES)) {
         mapped = mapped.replace(URL_PATHS.RESPONSES, URL_PATHS.CODEX_RESPONSES);
     }
-    else if (mapped.includes('/chat/completions')) {
-        mapped = mapped.replace('/chat/completions', '/codex/chat/completions');
+    else if (mapped.includes("/chat/completions")) {
+        mapped = mapped.replace("/chat/completions", "/codex/chat/completions");
     }
     return new URL(mapped, CODEX_BASE_URL).toString();
 }
@@ -95,9 +96,9 @@ function filterInput(input) {
     if (!Array.isArray(input))
         return input;
     return input
-        .filter((item) => item?.type !== 'item_reference')
+        .filter((item) => item?.type !== "item_reference")
         .map((item) => {
-        if (item && typeof item === 'object' && 'id' in item) {
+        if (item && typeof item === "object" && "id" in item) {
             const { id, ...rest } = item;
             return rest;
         }
@@ -106,18 +107,19 @@ function filterInput(input) {
 }
 function normalizeModel(model) {
     if (!model)
-        return 'gpt-5.1';
-    const modelId = model.includes('/') ? model.split('/').pop() : model;
-    const baseModel = modelId.replace(/-(?:fast|none|minimal|low|medium|high|xhigh)$/, '');
+        return "gpt-5.1";
+    const modelId = model.includes("/") ? model.split("/").pop() : model;
+    const baseModel = modelId.replace(/-(?:fast|none|minimal|low|medium|high|xhigh)$/, "");
     // OpenCode may lag behind the latest ChatGPT Codex model allowlist. Route known
     // older Codex selections to the latest backend model when enabled.
     // Codex model on the ChatGPT backend for users who want the newest model without
     // waiting for upstream registry updates.
-    const preferLatestRaw = readEnv('OPENCODE_ENHANCER_PREFER_CODEX_LATEST', 'OPENCODE_MULTI_AUTH_PREFER_CODEX_LATEST');
-    const preferLatest = preferLatestRaw === '1' || preferLatestRaw === 'true';
+    const preferLatestRaw = readEnv("OPENCODE_ENHANCER_PREFER_CODEX_LATEST", "OPENCODE_MULTI_AUTH_PREFER_CODEX_LATEST");
+    const preferLatest = preferLatestRaw === "1" || preferLatestRaw === "true";
     if (preferLatest &&
-        (baseModel === 'gpt-5.3-codex' || baseModel === 'gpt-5.2-codex' || baseModel === 'gpt-5-codex')) {
-        const latestModel = (readEnv('OPENCODE_ENHANCER_CODEX_LATEST_MODEL', 'OPENCODE_MULTI_AUTH_CODEX_LATEST_MODEL') || 'gpt-5.4').trim();
+        (baseModel === "gpt-5.3-codex" || baseModel === "gpt-5.2-codex" || baseModel === "gpt-5-codex")) {
+        const latestModel = (readEnv("OPENCODE_ENHANCER_CODEX_LATEST_MODEL", "OPENCODE_MULTI_AUTH_CODEX_LATEST_MODEL") ||
+            "gpt-5.4").trim();
         if (isDebugEnabled()) {
             console.log(`[enhancer] model map: ${baseModel} -> ${latestModel}`);
         }
@@ -127,43 +129,39 @@ function normalizeModel(model) {
 }
 function ensureContentType(headers) {
     const responseHeaders = new Headers(headers);
-    if (!responseHeaders.has('content-type')) {
-        responseHeaders.set('content-type', 'text/event-stream; charset=utf-8');
+    if (!responseHeaders.has("content-type")) {
+        responseHeaders.set("content-type", "text/event-stream; charset=utf-8");
     }
     return responseHeaders;
 }
-function extractErrorMessage(payload, fallbackText = '') {
-    if (!payload || typeof payload !== 'object') {
+function extractErrorMessage(payload, fallbackText = "") {
+    if (!payload || typeof payload !== "object") {
         return fallbackText;
     }
-    const detailMessage = typeof payload?.detail?.message === 'string'
+    const detailMessage = typeof payload?.detail?.message === "string"
         ? payload.detail.message
-        : typeof payload?.detail === 'string'
+        : typeof payload?.detail === "string"
             ? payload.detail
-            : '';
-    const errorMessage = typeof payload?.error?.message === 'string'
-        ? payload.error.message
-        : '';
-    const topLevelMessage = typeof payload?.message === 'string'
-        ? payload.message
-        : '';
+            : "";
+    const errorMessage = typeof payload?.error?.message === "string" ? payload.error.message : "";
+    const topLevelMessage = typeof payload?.message === "string" ? payload.message : "";
     return detailMessage || errorMessage || topLevelMessage || fallbackText;
 }
 function resolveRateLimitedUntil(rateLimits, headers, errorText, fallbackCooldownMs, now = Date.now()) {
-    const retryAfterUntil = parseRetryAfterHeader(headers.get('retry-after'), now) || 0;
+    const retryAfterUntil = parseRetryAfterHeader(headers.get("retry-after"), now) || 0;
     const windowResetUntil = getBlockingRateLimitResetAt(rateLimits, now) || 0;
     const messageResetUntil = parseRateLimitResetFromError(errorText, now) || 0;
     const fallbackUntil = now + fallbackCooldownMs;
     return Math.max(fallbackUntil, retryAfterUntil, windowResetUntil, messageResetUntil);
 }
 function parseSseStream(sseText) {
-    const lines = sseText.split('\n');
+    const lines = sseText.split("\n");
     for (const line of lines) {
-        if (!line.startsWith('data: '))
+        if (!line.startsWith("data: "))
             continue;
         try {
             const data = JSON.parse(line.substring(6));
-            if (data?.type === 'response.done' || data?.type === 'response.completed') {
+            if (data?.type === "response.done" || data?.type === "response.completed") {
                 return data.response;
             }
         }
@@ -175,11 +173,11 @@ function parseSseStream(sseText) {
 }
 async function convertSseToJson(response, headers) {
     if (!response.body) {
-        throw new Error('[enhancer] Response has no body');
+        throw new Error("[enhancer] Response has no body");
     }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
-    let fullText = '';
+    let fullText = "";
     while (true) {
         const { done, value } = await reader.read();
         if (done)
@@ -191,15 +189,15 @@ async function convertSseToJson(response, headers) {
         return new Response(fullText, {
             status: response.status,
             statusText: response.statusText,
-            headers
+            headers,
         });
     }
     const jsonHeaders = new Headers(headers);
-    jsonHeaders.set('content-type', 'application/json; charset=utf-8');
+    jsonHeaders.set("content-type", "application/json; charset=utf-8");
     return new Response(JSON.stringify(finalResponse), {
         status: response.status,
         statusText: response.statusText,
-        headers: jsonHeaders
+        headers: jsonHeaders,
     });
 }
 /**
@@ -207,12 +205,9 @@ async function convertSseToJson(response, headers) {
  *
  * Rotates between multiple ChatGPT Plus/Pro accounts for rate limit resilience.
  */
-const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) => {
+const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory, }) => {
     const terminalNotifierPath = (() => {
-        const candidates = [
-            '/opt/homebrew/bin/terminal-notifier',
-            '/usr/local/bin/terminal-notifier'
-        ];
+        const candidates = ["/opt/homebrew/bin/terminal-notifier", "/usr/local/bin/terminal-notifier"];
         for (const c of candidates) {
             try {
                 if (fs.existsSync(c))
@@ -224,26 +219,108 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
         }
         return null;
     })();
-    const notifyEnabledRaw = readEnv('OPENCODE_ENHANCER_NOTIFY', 'OPENCODE_MULTI_AUTH_NOTIFY');
-    const notifyEnabled = notifyEnabledRaw !== '0' && notifyEnabledRaw !== 'false';
-    const notifySound = (readEnv('OPENCODE_ENHANCER_NOTIFY_SOUND', 'OPENCODE_MULTI_AUTH_NOTIFY_SOUND') || '/System/Library/Sounds/Glass.aiff').trim();
+    const notifyEnabledRaw = readEnv("OPENCODE_ENHANCER_NOTIFY", "OPENCODE_MULTI_AUTH_NOTIFY");
+    const notifyEnabled = notifyEnabledRaw !== "0" && notifyEnabledRaw !== "false";
+    const notifyBackend = (() => {
+        const raw = (readEnv("OPENCODE_ENHANCER_NOTIFY_BACKEND", "OPENCODE_MULTI_AUTH_NOTIFY_BACKEND") || "auto")
+            .trim()
+            .toLowerCase();
+        if (raw === "terminal" || raw === "system")
+            return raw;
+        return "auto";
+    })();
+    const notifySound = (readEnv("OPENCODE_ENHANCER_NOTIFY_SOUND", "OPENCODE_MULTI_AUTH_NOTIFY_SOUND") ||
+        "/System/Library/Sounds/Glass.aiff").trim();
     const lastStatusBySession = new Map();
     const lastNotifiedAtByKey = new Map();
     const lastRetryAttemptBySession = new Map();
+    const sanitizeOscText = (value) => {
+        return String(value || "")
+            .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+    const truncateText = (value, maxLength) => {
+        if (value.length <= maxLength)
+            return value;
+        return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+    };
+    const formatOsc9Message = (title, body) => {
+        const safeTitle = sanitizeOscText(title);
+        const safeBody = sanitizeOscText(body);
+        const combined = [safeTitle, safeBody].filter(Boolean).join(" — ");
+        const prefixed = /^\d+;/.test(combined) ? `OpenCode ${combined}` : combined;
+        return truncateText(prefixed, 512);
+    };
+    const getTerminalNotificationSupport = () => {
+        if (process.env.ZELLIJ) {
+            return { supported: false, reason: "zellij-not-supported" };
+        }
+        if (process.env.TMUX) {
+            return { supported: false, reason: "tmux-requires-passthrough" };
+        }
+        if (process.env.STY) {
+            return { supported: false, reason: "screen-not-supported" };
+        }
+        const termProgram = (process.env.TERM_PROGRAM || "").trim().toLowerCase();
+        const term = (process.env.TERM || "").trim().toLowerCase();
+        if (termProgram === "ghostty" || term.includes("ghostty")) {
+            return { supported: true, terminal: "ghostty" };
+        }
+        if (termProgram === "iterm.app") {
+            return { supported: true, terminal: "iterm2" };
+        }
+        if (process.env.KITTY_WINDOW_ID || term.includes("kitty")) {
+            return { supported: true, terminal: "kitty" };
+        }
+        if (termProgram === "wezterm" || process.env.WEZTERM_PANE) {
+            return { supported: true, terminal: "wezterm" };
+        }
+        return { supported: false, reason: "terminal-unsupported" };
+    };
+    const writeTerminalSequence = (sequence) => {
+        try {
+            fs.appendFileSync("/dev/tty", sequence, { encoding: "utf8" });
+            return true;
+        }
+        catch {
+            // fall back to attached TTY streams below
+        }
+        for (const stream of [process.stderr, process.stdout]) {
+            if (!stream?.isTTY || typeof stream.write !== "function")
+                continue;
+            try {
+                stream.write(sequence);
+                return true;
+            }
+            catch {
+                // try next stream
+            }
+        }
+        return false;
+    };
+    const notifyTerminal = (title, body) => {
+        if (!notifyEnabled)
+            return false;
+        const message = formatOsc9Message(title, body);
+        if (!message)
+            return false;
+        return writeTerminalSequence(`\u001b]9;${message}\u001b\\`);
+    };
     const escapeAppleScriptString = (value) => {
         return String(value)
-            .replaceAll('\\', '\\\\')
+            .replaceAll("\\", "\\\\")
             .replaceAll('"', '\"')
-            .replaceAll(String.fromCharCode(10), '\n');
+            .replaceAll(String.fromCharCode(10), "\n");
     };
     let didWarnTerminalNotifier = false;
     const notifyMac = (title, message, clickUrl) => {
         if (!notifyEnabled)
-            return;
-        if (process.platform !== 'darwin')
-            return;
-        const macOpenRaw = readEnv('OPENCODE_ENHANCER_NOTIFY_MAC_OPEN', 'OPENCODE_MULTI_AUTH_NOTIFY_MAC_OPEN');
-        const macOpenEnabled = macOpenRaw !== '0' && macOpenRaw !== 'false';
+            return false;
+        if (process.platform !== "darwin")
+            return false;
+        const macOpenRaw = readEnv("OPENCODE_ENHANCER_NOTIFY_MAC_OPEN", "OPENCODE_MULTI_AUTH_NOTIFY_MAC_OPEN");
+        const macOpenEnabled = macOpenRaw !== "0" && macOpenRaw !== "false";
         // Best effort: clickable notifications require terminal-notifier.
         if (macOpenEnabled && clickUrl && terminalNotifierPath) {
             try {
@@ -259,11 +336,11 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
             if (macOpenEnabled && clickUrl && !terminalNotifierPath && !didWarnTerminalNotifier) {
                 didWarnTerminalNotifier = true;
                 if (isDebugEnabled()) {
-                    console.log('[enhancer] mac click-to-open requires terminal-notifier (brew install terminal-notifier)');
+                    console.log("[enhancer] mac click-to-open requires terminal-notifier (brew install terminal-notifier)");
                 }
             }
             try {
-                const osascript = '/usr/bin/osascript';
+                const osascript = "/usr/bin/osascript";
                 const safeTitle = escapeAppleScriptString(title);
                 const safeMessage = escapeAppleScriptString(message);
                 const script = `display notification "${safeMessage}" with title "${safeTitle}"`;
@@ -275,25 +352,26 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
             }
         }
         if (!notifySound)
-            return;
+            return true;
         try {
-            const afplay = '/usr/bin/afplay';
+            const afplay = "/usr/bin/afplay";
             $ `${afplay} ${notifySound}`.nothrow().catch(() => { });
         }
         catch {
             // ignore
         }
+        return true;
     };
-    const ntfyUrl = (readEnv('OPENCODE_ENHANCER_NOTIFY_NTFY_URL', 'OPENCODE_MULTI_AUTH_NOTIFY_NTFY_URL') || '').trim();
-    const ntfyToken = (readEnv('OPENCODE_ENHANCER_NOTIFY_NTFY_TOKEN', 'OPENCODE_MULTI_AUTH_NOTIFY_NTFY_TOKEN') || '').trim();
-    const notifyUiBaseUrl = (readEnv('OPENCODE_ENHANCER_NOTIFY_UI_BASE_URL', 'OPENCODE_MULTI_AUTH_NOTIFY_UI_BASE_URL') || '').trim();
+    const ntfyUrl = (readEnv("OPENCODE_ENHANCER_NOTIFY_NTFY_URL", "OPENCODE_MULTI_AUTH_NOTIFY_NTFY_URL") || "").trim();
+    const ntfyToken = (readEnv("OPENCODE_ENHANCER_NOTIFY_NTFY_TOKEN", "OPENCODE_MULTI_AUTH_NOTIFY_NTFY_TOKEN") || "").trim();
+    const notifyUiBaseUrl = (readEnv("OPENCODE_ENHANCER_NOTIFY_UI_BASE_URL", "OPENCODE_MULTI_AUTH_NOTIFY_UI_BASE_URL") || "").trim();
     const getSessionUrl = (sessionID) => {
-        const base = (notifyUiBaseUrl || serverUrl?.origin || '').replace(/\/$/, '');
+        const base = (notifyUiBaseUrl || serverUrl?.origin || "").replace(/\/$/, "");
         if (!base)
-            return '';
+            return "";
         return `${base}/session/${sessionID}`;
     };
-    const projectLabel = (project?.name || project?.id || '').trim() || 'OpenCode';
+    const projectLabel = (project?.name || project?.id || "").trim() || "OpenCode";
     const sessionMetaCache = new Map();
     const getSessionMeta = async (sessionID) => {
         const cached = sessionMetaCache.get(sessionID);
@@ -302,7 +380,7 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
         try {
             const res = await client.session.get({
                 path: { id: sessionID },
-                query: { directory }
+                query: { directory },
             });
             // @opencode-ai/sdk returns { data } shape.
             const data = res?.data;
@@ -316,50 +394,104 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
             return meta;
         }
     };
+    const isPrimarySession = async (sessionID) => {
+        try {
+            const res = await client.session.get({ path: { id: sessionID }, query: { directory } });
+            return !res.data?.parentID;
+        }
+        catch {
+            return true;
+        }
+    };
+    const shouldNotifyKind = (kind) => {
+        if (!notifyEnabled)
+            return false;
+        if (kind === "retry")
+            return true;
+        if (kind === "taskComplete")
+            return isNotificationEnabled("taskComplete");
+        if (kind === "error")
+            return isNotificationEnabled("error");
+        if (kind === "permissionRequest")
+            return isNotificationEnabled("permissionRequest");
+        return isNotificationEnabled("question");
+    };
     const formatTitle = (kind) => {
-        if (kind === 'error')
+        if (kind === "taskComplete")
+            return `OpenCode - ${projectLabel}`;
+        if (kind === "error")
             return `OpenCode - ${projectLabel} - Error`;
-        if (kind === 'retry')
+        if (kind === "retry")
             return `OpenCode - ${projectLabel} - Retrying`;
-        return `OpenCode - ${projectLabel}`;
+        if (kind === "permissionRequest")
+            return `OpenCode - ${projectLabel} - Permission`;
+        return `OpenCode - ${projectLabel} - Question`;
     };
-    const formatBody = async (kind, sessionID, detail) => {
+    const formatSessionBody = async (kind, sessionID, detail) => {
         const meta = await getSessionMeta(sessionID);
-        const titleLine = meta.title ? `Task: ${meta.title}` : '';
+        const titleLine = meta.title ? `Task: ${meta.title}` : "";
         const url = getSessionUrl(sessionID);
-        if (kind === 'idle') {
-            return [titleLine, `Session finished: ${sessionID}`, detail || '', url].filter(Boolean).join('\n');
+        if (kind === "taskComplete") {
+            return [titleLine, `Session finished: ${sessionID}`, detail || "", url]
+                .filter(Boolean)
+                .join("\n");
         }
-        if (kind === 'retry') {
-            return [titleLine, `Retrying: ${sessionID}`, detail || '', url].filter(Boolean).join('\n');
+        if (kind === "retry") {
+            return [titleLine, `Retrying: ${sessionID}`, detail || "", url].filter(Boolean).join("\n");
         }
-        return [titleLine, `Error: ${sessionID}`, detail || '', url].filter(Boolean).join('\n');
+        return [titleLine, `Error: ${sessionID}`, detail || "", url].filter(Boolean).join("\n");
     };
-    const notifyMacRich = async (kind, sessionID, detail) => {
-        const body = await formatBody(kind, sessionID, detail);
-        notifyMac(formatTitle(kind), body, getSessionUrl(sessionID) || undefined);
+    const formatContextBody = async (sessionID, lines) => {
+        const meta = sessionID ? await getSessionMeta(sessionID) : {};
+        const titleLine = meta.title ? `Task: ${meta.title}` : "";
+        const url = sessionID ? getSessionUrl(sessionID) : "";
+        return [titleLine, ...lines, url].filter(Boolean).join("\n");
     };
-    const notifyNtfyRich = async (kind, sessionID, detail) => {
+    const notifyNtfy = async (title, body, priority, clickUrl) => {
         if (!notifyEnabled)
             return;
         if (!ntfyUrl)
             return;
-        const sessionUrl = getSessionUrl(sessionID);
-        const title = formatTitle(kind);
-        const body = await formatBody(kind, sessionID, detail);
-        // ntfy priority: 1=min, 3=default, 5=max
-        const priority = kind === 'error' ? '5' : kind === 'retry' ? '4' : '3';
         const headers = {
-            'Content-Type': 'text/plain; charset=utf-8',
-            'Title': title,
-            'Priority': priority
+            "Content-Type": "text/plain; charset=utf-8",
+            Title: title,
+            Priority: priority,
         };
-        if (sessionUrl)
-            headers['Click'] = sessionUrl;
+        if (clickUrl)
+            headers["Click"] = clickUrl;
         if (ntfyToken)
-            headers['Authorization'] = `Bearer ${ntfyToken}`;
+            headers["Authorization"] = `Bearer ${ntfyToken}`;
+        try {
+            await fetch(ntfyUrl, { method: "POST", headers, body });
+        }
+        catch {
+            // ignore
+        }
+    };
+    const notifyTargets = async (title, body, priority, clickUrl) => {
+        let localDelivered = false;
+        const terminalSupport = getTerminalNotificationSupport();
+        if (notifyBackend === "terminal" || (notifyBackend === "auto" && terminalSupport.supported)) {
+            try {
+                localDelivered = notifyTerminal(title, body);
+            }
+            catch {
+                localDelivered = false;
+            }
+            if (!localDelivered && isDebugEnabled()) {
+                console.log(`[enhancer] terminal notification unavailable (${terminalSupport.reason || terminalSupport.terminal || "write-failed"})`);
+            }
+        }
+        if (!localDelivered && notifyBackend !== "terminal") {
+            try {
+                localDelivered = notifyMac(title, body, clickUrl);
+            }
+            catch {
+                // ignore
+            }
+        }
         try {
-            await fetch(ntfyUrl, { method: 'POST', headers, body });
+            await notifyNtfy(title, body, priority, clickUrl);
         }
         catch {
             // ignore
@@ -374,52 +506,108 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
         return false;
     };
     const formatRetryDetail = (status) => {
-        const attempt = typeof status?.attempt === 'number' ? status.attempt : undefined;
-        const message = typeof status?.message === 'string' ? status.message : '';
-        const next = typeof status?.next === 'number' ? status.next : undefined;
+        const attempt = typeof status?.attempt === "number" ? status.attempt : undefined;
+        const message = typeof status?.message === "string" ? status.message : "";
+        const next = typeof status?.next === "number" ? status.next : undefined;
         const parts = [];
-        if (typeof attempt === 'number')
+        if (typeof attempt === "number")
             parts.push(`Attempt: ${attempt}`);
         // OpenCode has emitted both "seconds-until-next" and "epoch ms" variants over time.
-        if (typeof next === 'number') {
-            const seconds = next > 1e12 ? Math.max(0, Math.round((next - Date.now()) / 1000)) : Math.max(0, Math.round(next));
+        if (typeof next === "number") {
+            const seconds = next > 1e12
+                ? Math.max(0, Math.round((next - Date.now()) / 1000))
+                : Math.max(0, Math.round(next));
             parts.push(`Next in: ${seconds}s`);
         }
         if (message)
             parts.push(message);
-        return parts.join(' | ');
+        return parts.join(" | ");
     };
     const formatErrorDetail = (err) => {
-        if (!err || typeof err !== 'object')
-            return '';
-        const name = typeof err.name === 'string' ? err.name : '';
-        const code = typeof err.code === 'string' ? err.code : '';
-        const message = (typeof err.message === 'string' && err.message) ||
-            (typeof err.error?.message === 'string' && err.error.message) ||
-            '';
-        return [name, code, message].filter(Boolean).join(': ');
+        if (!err || typeof err !== "object")
+            return "";
+        const name = typeof err.name === "string" ? err.name : "";
+        const code = typeof err.code === "string" ? err.code : "";
+        const message = (typeof err.message === "string" && err.message) ||
+            (typeof err.error?.message === "string" && err.error.message) ||
+            "";
+        return [name, code, message].filter(Boolean).join(": ");
     };
-    const notifyRich = async (kind, sessionID, detail) => {
-        try {
-            await notifyMacRich(kind, sessionID, detail);
-        }
-        catch {
-            // ignore
-        }
-        try {
-            await notifyNtfyRich(kind, sessionID, detail);
-        }
-        catch {
-            // ignore
-        }
+    const notifySessionEvent = async (kind, sessionID, detail) => {
+        if (!shouldNotifyKind(kind))
+            return;
+        const body = await formatSessionBody(kind, sessionID, detail);
+        const priority = kind === "error" ? "5" : kind === "retry" ? "4" : "3";
+        const clickUrl = getSessionUrl(sessionID) || undefined;
+        await notifyTargets(formatTitle(kind), body, priority, clickUrl);
+    };
+    const notifyPermissionRequested = async (request) => {
+        if (!shouldNotifyKind("permissionRequest"))
+            return;
+        const sessionID = typeof request?.sessionID === "string" ? request.sessionID : "";
+        const permissionLabel = (typeof request?.title === "string" && request.title) ||
+            (typeof request?.permission === "string" && request.permission) ||
+            (typeof request?.type === "string" && request.type) ||
+            "Permission request";
+        const patterns = [
+            ...(Array.isArray(request?.patterns) ? request.patterns : []),
+            ...(typeof request?.pattern === "string" ? [request.pattern] : []),
+        ].filter((value) => typeof value === "string" && value.trim().length > 0);
+        const body = await formatContextBody(sessionID || undefined, [
+            `Permission: ${permissionLabel}`,
+            patterns.length > 0 ? `Patterns: ${patterns.join(", ")}` : "",
+        ]);
+        await notifyTargets(formatTitle("permissionRequest"), body, "4", sessionID ? getSessionUrl(sessionID) || undefined : undefined);
+    };
+    const notifyQuestionRequested = async (request) => {
+        if (!shouldNotifyKind("question"))
+            return;
+        const sessionID = typeof request?.sessionID === "string" ? request.sessionID : "";
+        const questions = Array.isArray(request?.questions) ? request.questions : [];
+        const firstQuestion = questions[0];
+        const header = typeof firstQuestion?.header === "string" ? firstQuestion.header : "";
+        const prompt = typeof firstQuestion?.question === "string" ? firstQuestion.question : "";
+        const extraCount = questions.length > 1 ? ` (+${questions.length - 1} more)` : "";
+        const optionLabels = Array.isArray(firstQuestion?.options)
+            ? firstQuestion.options
+                .map((option) => (typeof option?.label === "string" ? option.label : ""))
+                .filter(Boolean)
+            : [];
+        const body = await formatContextBody(sessionID || undefined, [
+            `Question${header ? `: ${header}` : ""}${extraCount}`,
+            prompt,
+            optionLabels.length > 0 ? `Options: ${optionLabels.join(", ")}` : "",
+        ]);
+        await notifyTargets(formatTitle("question"), body, "4", sessionID ? getSessionUrl(sessionID) || undefined : undefined);
     };
     return {
         event: async ({ event }) => {
             if (!notifyEnabled)
                 return;
-            if (!event || !('type' in event))
+            if (!event || !("type" in event))
+                return;
+            const eventType = event.type;
+            if (!eventType)
+                return;
+            if (eventType === "permission.asked" || eventType === "permission.updated") {
+                const request = event.properties;
+                const requestID = (typeof request?.id === "string" && request.id) ||
+                    (typeof request?.permissionID === "string" && request.permissionID) ||
+                    "unknown";
+                if (shouldThrottle(`permission:${requestID}`, 2000))
+                    return;
+                await notifyPermissionRequested(request);
+                return;
+            }
+            if (eventType === "question.asked") {
+                const request = event.properties;
+                const requestID = typeof request?.id === "string" ? request.id : "unknown";
+                if (shouldThrottle(`question:${requestID}`, 2000))
+                    return;
+                await notifyQuestionRequested(request);
                 return;
-            if (event.type === 'session.created' || event.type === 'session.updated') {
+            }
+            if (eventType === "session.created" || eventType === "session.updated") {
                 const info = event.properties?.info;
                 const id = info?.id;
                 if (id) {
@@ -427,69 +615,85 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                 }
                 return;
             }
-            if (event.type === 'session.status') {
+            if (eventType === "session.status") {
                 const sessionID = event.properties?.sessionID;
                 const status = event.properties?.status;
                 const statusType = status?.type;
                 if (!sessionID || !statusType)
                     return;
                 lastStatusBySession.set(sessionID, statusType);
-                if (statusType === 'retry') {
-                    const attempt = typeof status?.attempt === 'number' ? status.attempt : undefined;
+                if (statusType === "retry") {
+                    const attempt = typeof status?.attempt === "number" ? status.attempt : undefined;
                     const prevAttempt = lastRetryAttemptBySession.get(sessionID);
-                    if (typeof attempt === 'number') {
+                    if (typeof attempt === "number") {
                         if (prevAttempt === attempt && shouldThrottle(`retry:${sessionID}:${attempt}`, 5000)) {
                             return;
                         }
                         lastRetryAttemptBySession.set(sessionID, attempt);
                     }
-                    const key = `retry:${sessionID}:${typeof attempt === 'number' ? attempt : 'na'}`;
+                    const key = `retry:${sessionID}:${typeof attempt === "number" ? attempt : "na"}`;
                     if (shouldThrottle(key, 2000))
                         return;
-                    await notifyRich('retry', sessionID, formatRetryDetail(status));
+                    await notifySessionEvent("retry", sessionID, formatRetryDetail(status));
                 }
                 return;
             }
-            if (event.type === 'session.error') {
+            if (eventType === "session.error") {
                 const sessionID = event.properties?.sessionID;
-                const id = sessionID || 'unknown';
+                const id = sessionID || "unknown";
                 const err = event.properties?.error;
                 const detail = formatErrorDetail(err);
                 const key = `error:${id}:${detail}`;
                 if (shouldThrottle(key, 2000))
                     return;
-                await notifyRich('error', id, detail);
+                if (sessionID) {
+                    lastStatusBySession.set(sessionID, "error");
+                }
+                await notifySessionEvent("error", id, detail);
                 return;
             }
-            if (event.type === 'session.idle') {
+            if (eventType === "session.idle") {
                 const sessionID = event.properties?.sessionID;
                 if (!sessionID)
                     return;
                 const prev = lastStatusBySession.get(sessionID);
-                if (prev === 'busy' || prev === 'retry') {
+                if (prev !== "error" && (await isPrimarySession(sessionID))) {
                     if (shouldThrottle(`idle:${sessionID}`, 2000))
                         return;
-                    await notifyRich('idle', sessionID);
+                    await notifySessionEvent("taskComplete", sessionID);
                 }
-                lastStatusBySession.set(sessionID, 'idle');
+                lastStatusBySession.set(sessionID, "idle");
             }
         },
+        "tool.execute.before": async (input) => {
+            if (input.tool !== "question")
+                return;
+            if (!(await isPrimarySession(input.sessionID)))
+                return;
+            if (shouldThrottle(`question-tool:${input.sessionID}`, 2000))
+                return;
+            const body = await formatContextBody(input.sessionID || undefined, [
+                "Question requires your input",
+            ]);
+            await notifyTargets(formatTitle("question"), body, "4", input.sessionID ? getSessionUrl(input.sessionID) || undefined : undefined);
+        },
         config: async (config) => {
-            const injectModelsRaw = readEnv('OPENCODE_ENHANCER_INJECT_MODELS', 'OPENCODE_MULTI_AUTH_INJECT_MODELS');
-            const injectModels = injectModelsRaw !== '0' && injectModelsRaw !== 'false';
+            const injectModelsRaw = readEnv("OPENCODE_ENHANCER_INJECT_MODELS", "OPENCODE_MULTI_AUTH_INJECT_MODELS");
+            const injectModels = injectModelsRaw !== "0" && injectModelsRaw !== "false";
             if (!injectModels)
                 return;
-            const latestModel = (readEnv('OPENCODE_ENHANCER_CODEX_LATEST_MODEL', 'OPENCODE_MULTI_AUTH_CODEX_LATEST_MODEL') || 'gpt-5.4').trim();
+            const latestModel = (readEnv("OPENCODE_ENHANCER_CODEX_LATEST_MODEL", "OPENCODE_MULTI_AUTH_CODEX_LATEST_MODEL") ||
+                "gpt-5.4").trim();
             try {
                 const openai = config.provider?.[PROVIDER_ID] || null;
-                if (!openai || typeof openai !== 'object')
+                if (!openai || typeof openai !== "object")
                     return;
                 openai.models ||= {};
                 openai.whitelist ||= [];
                 const defaultModels = getDefaultModels();
                 const injectedModelIds = [latestModel];
-                if (latestModel === 'gpt-5.4' && defaultModels['gpt-5.4-fast']) {
-                    injectedModelIds.push('gpt-5.4-fast');
+                if (latestModel === "gpt-5.4" && defaultModels["gpt-5.4-fast"]) {
+                    injectedModelIds.push("gpt-5.4-fast");
                 }
                 for (const modelID of injectedModelIds) {
                     const model = defaultModels[modelID];
@@ -503,12 +707,12 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                     }
                 }
                 if (isDebugEnabled()) {
-                    console.log(`[enhancer] injected runtime models: ${injectedModelIds.join(', ')}`);
+                    console.log(`[enhancer] injected runtime models: ${injectedModelIds.join(", ")}`);
                 }
             }
             catch (err) {
                 if (isDebugEnabled()) {
-                    console.log('[enhancer] config injection failed:', err);
+                    console.log("[enhancer] config injection failed:", err);
                 }
             }
         },
@@ -521,7 +725,7 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                 await syncAuthFromOpenCode(getAuth);
                 const accounts = listAccounts();
                 if (accounts.length === 0) {
-                    console.log('[enhancer] No accounts configured. Run: opencode-enhancer add <alias>');
+                    console.log("[enhancer] No accounts configured. Run: opencode-enhancer add <alias>");
                     return {};
                 }
                 const customFetch = async (input, init) => {
@@ -529,13 +733,13 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                     const store = loadStore();
                     const forceState = getForceState();
                     const forcePinned = isForceActive() && !!forceState.forcedAlias;
-                    const eligibleCount = Object.values(store.accounts).filter(acc => {
+                    const eligibleCount = Object.values(store.accounts).filter((acc) => {
                         const now = Date.now();
-                        return (!acc.rateLimitedUntil || acc.rateLimitedUntil < now) &&
+                        return ((!acc.rateLimitedUntil || acc.rateLimitedUntil < now) &&
                             (!acc.modelUnsupportedUntil || acc.modelUnsupportedUntil < now) &&
                             (!acc.workspaceDeactivatedUntil || acc.workspaceDeactivatedUntil < now) &&
                             !acc.authInvalid &&
-                            acc.enabled !== false;
+                            acc.enabled !== false);
                     }).length;
                     const maxAttempts = forcePinned ? 1 : Math.max(1, eligibleCount);
                     const triedAliases = new Set();
@@ -545,7 +749,7 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                         const settings = getRuntimeSettings();
                         const effectiveConfig = {
                             ...pluginConfig,
-                            rotationStrategy: settings.settings.rotationStrategy
+                            rotationStrategy: settings.settings.rotationStrategy,
                         };
                         const rotation = await getNextAccount(effectiveConfig);
                         if (!rotation) {
@@ -555,16 +759,16 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                 if (forced?.rateLimitedUntil && forced.rateLimitedUntil > now) {
                                     return new Response(JSON.stringify({
                                         error: {
-                                            code: 'RATE_LIMITED',
+                                            code: "RATE_LIMITED",
                                             message: `Forced account '${forced.alias}' is rate-limited until ${new Date(forced.rateLimitedUntil).toISOString()}`,
-                                            details: { alias: forced.alias, rateLimitedUntil: forced.rateLimitedUntil }
-                                        }
-                                    }), { status: 429, headers: { 'Content-Type': 'application/json' } });
+                                            details: { alias: forced.alias, rateLimitedUntil: forced.rateLimitedUntil },
+                                        },
+                                    }), { status: 429, headers: { "Content-Type": "application/json" } });
                                 }
                             }
                             return new Response(JSON.stringify({
-                                error: Errors.noEligibleAccounts('No available accounts after filtering')
-                            }), { status: 503, headers: { 'Content-Type': 'application/json' } });
+                                error: Errors.noEligibleAccounts("No available accounts after filtering"),
+                            }), { status: 503, headers: { "Content-Type": "application/json" } });
                         }
                         let { account, token } = rotation;
                         // Auto-switch: if current account has low remaining usage and
@@ -572,7 +776,9 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                         if (pluginConfig.autoSwitchOnLowUsage && !forcePinned) {
                             const currentRemaining = getMinRemaining(account.rateLimits);
                             const threshold = pluginConfig.autoSwitchThreshold;
-                            if (typeof currentRemaining === 'number' && currentRemaining !== Infinity && currentRemaining <= threshold) {
+                            if (typeof currentRemaining === "number" &&
+                                currentRemaining !== Infinity &&
+                                currentRemaining <= threshold) {
                                 const betterAlias = selectBestAvailableAccount(account.alias);
                                 if (betterAlias) {
                                     const betterToken = await ensureValidToken(betterAlias);
@@ -580,14 +786,15 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                         const betterStore = loadStore();
                                         const betterAccount = betterStore.accounts[betterAlias];
                                         if (betterAccount) {
-                                            const betterRemaining = getMinRemaining(betterAccount.rateLimits);
-                                            if (betterRemaining > currentRemaining) {
+                                            const currentUsage = getUsagePrioritySnapshot(account.rateLimits);
+                                            const betterUsage = getUsagePrioritySnapshot(betterAccount.rateLimits);
+                                            if (compareAccountsByUsagePriority(betterAccount, account) < 0) {
                                                 if (isDebugEnabled()) {
-                                                    console.log(`[enhancer] Auto-switching from ${account.alias} (${currentRemaining}% remaining) to ${betterAlias} (${betterRemaining}% remaining)`);
+                                                    console.log(`[enhancer] Auto-switching from ${account.alias} (5h=${currentUsage.fiveHourRemaining ?? "unknown"}%, weekly=${currentUsage.weeklyRemaining ?? "unknown"}%) to ${betterAlias} (5h=${betterUsage.fiveHourRemaining ?? "unknown"}%, weekly=${betterUsage.weeklyRemaining ?? "unknown"}%)`);
                                                 }
                                                 updateAccount(betterAlias, {
                                                     usageCount: (betterAccount.usageCount || 0) + 1,
-                                                    lastUsed: Date.now()
+                                                    lastUsed: Date.now(),
                                                 });
                                                 account = betterAccount;
                                                 token = betterToken;
@@ -609,10 +816,10 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                             }
                             return new Response(JSON.stringify({
                                 error: {
-                                    code: 'TOKEN_PARSE_ERROR',
-                                    message: '[enhancer] Failed to extract accountId from token or stored account metadata'
-                                }
-                            }), { status: 401, headers: { 'Content-Type': 'application/json' } });
+                                    code: "TOKEN_PARSE_ERROR",
+                                    message: "[enhancer] Failed to extract accountId from token or stored account metadata",
+                                },
+                            }), { status: 401, headers: { "Content-Type": "application/json" } });
                         }
                         const originalUrl = extractRequestUrl(input);
                         const url = toCodexBackendUrl(originalUrl);
@@ -625,17 +832,20 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                         }
                         const isStreaming = body?.stream === true;
                         const normalizedModel = normalizeModel(body.model);
-                        const fastMode = /-fast$/.test(body.model || '');
-                        const supportedFastMode = fastMode && normalizedModel === 'gpt-5.4';
+                        const fastMode = /-fast$/.test(body.model || "");
+                        const supportedFastMode = fastMode && normalizedModel === "gpt-5.4";
                         const reasoningMatch = body.model?.match(/-(none|low|medium|high|xhigh)$/);
                         const payload = {
                             ...body,
                             model: normalizedModel,
-                            store: false
+                            store: false,
                         };
                         if (payload.truncation === undefined) {
-                            const truncationRaw = (readEnv('OPENCODE_ENHANCER_TRUNCATION', 'OPENCODE_MULTI_AUTH_TRUNCATION') || '').trim();
-                            if (truncationRaw && truncationRaw !== 'disabled' && truncationRaw !== 'false' && truncationRaw !== '0') {
+                            const truncationRaw = (readEnv("OPENCODE_ENHANCER_TRUNCATION", "OPENCODE_MULTI_AUTH_TRUNCATION") || "").trim();
+                            if (truncationRaw &&
+                                truncationRaw !== "disabled" &&
+                                truncationRaw !== "false" &&
+                                truncationRaw !== "0") {
                                 payload.truncation = truncationRaw;
                             }
                         }
@@ -646,27 +856,27 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                             payload.reasoning = {
                                 ...(payload.reasoning || {}),
                                 effort: reasoningMatch[1],
-                                summary: payload.reasoning?.summary || 'auto'
+                                summary: payload.reasoning?.summary || "auto",
                             };
                         }
                         if (supportedFastMode) {
-                            payload.service_tier = payload.service_tier || 'priority';
+                            payload.service_tier = payload.service_tier || "priority";
                             if (isDebugEnabled()) {
-                                console.log('[enhancer] fast mode enabled: gpt-5.4 + service_tier=priority');
+                                console.log("[enhancer] fast mode enabled: gpt-5.4 + service_tier=priority");
                             }
                         }
                         else if (fastMode && isDebugEnabled()) {
                             console.log(`[enhancer] fast mode ignored for unsupported model: ${normalizedModel}`);
                         }
-                        if (isDebugEnabled() && payload.service_tier === 'priority') {
+                        if (isDebugEnabled() && payload.service_tier === "priority") {
                             console.log(`[enhancer] priority service tier requested for ${normalizedModel}`);
                         }
                         delete payload.reasoning_effort;
                         try {
                             const headers = new Headers(init?.headers || {});
-                            headers.delete('x-api-key');
-                            headers.set('Content-Type', 'application/json');
-                            headers.set('Authorization', `Bearer ${token}`);
+                            headers.delete("x-api-key");
+                            headers.set("Content-Type", "application/json");
+                            headers.set("Authorization", `Bearer ${token}`);
                             headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
                             headers.set(OPENAI_HEADERS.BETA, OPENAI_HEADER_VALUES.BETA_RESPONSES);
                             headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
@@ -679,14 +889,14 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                 headers.delete(OPENAI_HEADERS.CONVERSATION_ID);
                                 headers.delete(OPENAI_HEADERS.SESSION_ID);
                             }
-                            headers.set('accept', 'text/event-stream');
+                            headers.set("accept", "text/event-stream");
                             const upstreamTimeoutMs = (() => {
-                                const raw = readEnv('OPENCODE_ENHANCER_UPSTREAM_TIMEOUT_MS', 'OPENCODE_MULTI_AUTH_UPSTREAM_TIMEOUT_MS');
+                                const raw = readEnv("OPENCODE_ENHANCER_UPSTREAM_TIMEOUT_MS", "OPENCODE_MULTI_AUTH_UPSTREAM_TIMEOUT_MS");
                                 const parsed = raw ? Number(raw) : NaN;
                                 return Number.isFinite(parsed) && parsed > 0 ? parsed : TIMEOUTS.UPSTREAM_FETCH_MS;
                             })();
                             const res = await fetch(url, {
-                                method: init?.method || 'POST',
+                                method: init?.method || "POST",
                                 headers,
                                 body: JSON.stringify(payload),
                                 signal: AbortSignal.timeout(upstreamTimeoutMs),
@@ -697,24 +907,30 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                 : account.rateLimits;
                             if (limitUpdate) {
                                 updateAccount(account.alias, {
-                                    rateLimits: mergedRateLimits
+                                    rateLimits: mergedRateLimits,
                                 });
                             }
                             if (res.status === 401 || res.status === 403) {
-                                const errorData = await res.clone().json().catch(() => ({}));
-                                const message = errorData?.error?.message || '';
-                                if (message.toLowerCase().includes('invalidated') || res.status === 401) {
+                                const errorData = (await res
+                                    .clone()
+                                    .json()
+                                    .catch(() => ({})));
+                                const message = errorData?.error?.message || "";
+                                if (message.toLowerCase().includes("invalidated") || res.status === 401) {
                                     markAuthInvalid(account.alias);
                                 }
                                 if (attempt < maxAttempts) {
                                     continue;
                                 }
                                 return new Response(JSON.stringify({
-                                    error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases))
-                                }), { status: res.status, headers: { 'Content-Type': 'application/json' } });
+                                    error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases)),
+                                }), { status: res.status, headers: { "Content-Type": "application/json" } });
                             }
                             if (res.status === 429) {
-                                const errorData = await res.clone().json().catch(() => ({}));
+                                const errorData = (await res
+                                    .clone()
+                                    .json()
+                                    .catch(() => ({})));
                                 const errorText = extractErrorMessage(errorData);
                                 const rateLimitedUntil = resolveRateLimitedUntil(mergedRateLimits, res.headers, errorText, pluginConfig.rateLimitCooldownMs);
                                 markRateLimited(account.alias, rateLimitedUntil);
@@ -722,80 +938,92 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                     continue;
                                 }
                                 return new Response(JSON.stringify({
-                                    error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases))
-                                }), { status: 429, headers: { 'Content-Type': 'application/json' } });
+                                    error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases)),
+                                }), { status: 429, headers: { "Content-Type": "application/json" } });
                             }
                             if (res.status === 402) {
-                                const errorData = await res.clone().json().catch(() => null);
-                                const errorText = await res.clone().text().catch(() => '');
-                                const code = (typeof errorData?.detail?.code === 'string' && errorData.detail.code) ||
-                                    (typeof errorData?.error?.code === 'string' && errorData.error.code) ||
-                                    '';
-                                const message = (typeof errorData?.detail?.message === 'string' && errorData.detail.message) ||
-                                    (typeof errorData?.detail === 'string' && errorData.detail) ||
-                                    (typeof errorData?.error?.message === 'string' && errorData.error.message) ||
-                                    (typeof errorData?.message === 'string' && errorData.message) ||
+                                const errorData = (await res
+                                    .clone()
+                                    .json()
+                                    .catch(() => null));
+                                const errorText = await res
+                                    .clone()
+                                    .text()
+                                    .catch(() => "");
+                                const code = (typeof errorData?.detail?.code === "string" && errorData.detail.code) ||
+                                    (typeof errorData?.error?.code === "string" && errorData.error.code) ||
+                                    "";
+                                const message = (typeof errorData?.detail?.message === "string" && errorData.detail.message) ||
+                                    (typeof errorData?.detail === "string" && errorData.detail) ||
+                                    (typeof errorData?.error?.message === "string" && errorData.error.message) ||
+                                    (typeof errorData?.message === "string" && errorData.message) ||
                                     errorText ||
-                                    '';
-                                const isDeactivatedWorkspace = code === 'deactivated_workspace' ||
-                                    message.toLowerCase().includes('deactivated_workspace') ||
-                                    message.toLowerCase().includes('deactivated workspace');
+                                    "";
+                                const isDeactivatedWorkspace = code === "deactivated_workspace" ||
+                                    message.toLowerCase().includes("deactivated_workspace") ||
+                                    message.toLowerCase().includes("deactivated workspace");
                                 if (isDeactivatedWorkspace) {
                                     markWorkspaceDeactivated(account.alias, pluginConfig.workspaceDeactivatedCooldownMs, {
-                                        error: message || code
+                                        error: message || code,
                                     });
                                     if (attempt < maxAttempts) {
                                         continue;
                                     }
                                     return new Response(JSON.stringify({
-                                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases))
-                                    }), { status: 402, headers: { 'Content-Type': 'application/json' } });
+                                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases)),
+                                    }), { status: 402, headers: { "Content-Type": "application/json" } });
                                 }
                             }
                             if (res.status === 400) {
-                                const errorData = await res.clone().json().catch(() => ({}));
-                                const message = (typeof errorData?.detail === 'string' && errorData.detail) ||
-                                    (typeof errorData?.error?.message === 'string' && errorData.error.message) ||
-                                    (typeof errorData?.message === 'string' && errorData.message) ||
-                                    '';
-                                const isModelUnsupported = typeof message === 'string' &&
-                                    message.toLowerCase().includes('model is not supported') &&
-                                    message.toLowerCase().includes('chatgpt account');
+                                const errorData = (await res
+                                    .clone()
+                                    .json()
+                                    .catch(() => ({})));
+                                const message = (typeof errorData?.detail === "string" && errorData.detail) ||
+                                    (typeof errorData?.error?.message === "string" && errorData.error.message) ||
+                                    (typeof errorData?.message === "string" && errorData.message) ||
+                                    "";
+                                const isModelUnsupported = typeof message === "string" &&
+                                    message.toLowerCase().includes("model is not supported") &&
+                                    message.toLowerCase().includes("chatgpt account");
                                 if (isModelUnsupported) {
                                     markModelUnsupported(account.alias, pluginConfig.modelUnsupportedCooldownMs, {
                                         model: normalizedModel,
-                                        error: message
+                                        error: message,
                                     });
                                     if (attempt < maxAttempts) {
                                         continue;
                                     }
                                     return new Response(JSON.stringify({
-                                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases))
-                                    }), { status: 400, headers: { 'Content-Type': 'application/json' } });
+                                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases)),
+                                    }), { status: 400, headers: { "Content-Type": "application/json" } });
                                 }
                             }
                             if (!res.ok) {
                                 return res;
                             }
                             const responseHeaders = ensureContentType(res.headers);
-                            if (!isStreaming && responseHeaders.get('content-type')?.includes('text/event-stream')) {
+                            if (!isStreaming &&
+                                responseHeaders.get("content-type")?.includes("text/event-stream")) {
                                 return await convertSseToJson(res, responseHeaders);
                             }
                             return res;
                         }
                         catch (err) {
-                            return new Response(JSON.stringify({ error: { code: 'REQUEST_FAILED', message: `[enhancer] Request failed: ${err}` } }), { status: 500, headers: { 'Content-Type': 'application/json' } });
+                            return new Response(JSON.stringify({
+                                error: { code: "REQUEST_FAILED", message: `[enhancer] Request failed: ${err}` },
+                            }), { status: 500, headers: { "Content-Type": "application/json" } });
                         }
                     }
                     return new Response(JSON.stringify({
-                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases))
-                    }), { status: 503, headers: { 'Content-Type': 'application/json' } });
+                        error: Errors.maxRetriesExceeded(attempt, Array.from(triedAliases)),
+                    }), { status: 503, headers: { "Content-Type": "application/json" } });
                 };
                 // Return SDK configuration with custom fetch for rotation
                 return {
-                    apiKey: 'chatgpt-oauth',
+                    apiKey: "chatgpt-oauth",
                     baseURL: CODEX_BASE_URL,
-                    fetch: customFetch
+                    fetch: customFetch,
                 };
             },
             methods: (() => {
@@ -808,43 +1036,43 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                     // login needed.  The user picks an account and it's instant.
                     return [
                         {
-                            label: 'Use existing account',
-                            type: 'oauth',
+                            label: "Use existing account",
+                            type: "oauth",
                             prompts: [
                                 {
-                                    type: 'select',
-                                    key: 'alias',
-                                    message: 'Select account',
+                                    type: "select",
+                                    key: "alias",
+                                    message: "Select account",
                                     options: [
-                                        ...aliases.map(a => buildAccountSelectOption(store.accounts[a])),
-                                        { label: '+ Add new account', value: '__new__' }
-                                    ]
-                                }
+                                        ...aliases.map((a) => buildAccountSelectOption(store.accounts[a])),
+                                        { label: "+ Add new account", value: "__new__" },
+                                    ],
+                                },
                             ],
                             authorize: async (inputs) => {
                                 const selectedAlias = inputs?.alias;
                                 // "Add new account" — full OAuth browser flow
-                                if (!selectedAlias || selectedAlias === '__new__') {
+                                if (!selectedAlias || selectedAlias === "__new__") {
                                     const flow = await createAuthorizationFlow();
                                     return {
                                         url: flow.url,
-                                        method: 'auto',
-                                        instructions: 'Login with your ChatGPT Plus/Pro account',
+                                        method: "auto",
+                                        instructions: "Login with your ChatGPT Plus/Pro account",
                                         callback: async () => {
                                             try {
                                                 const account = await loginAccount(undefined, flow);
                                                 return {
-                                                    type: 'success',
+                                                    type: "success",
                                                     provider: PROVIDER_ID,
                                                     refresh: account.refreshToken,
                                                     access: account.accessToken,
-                                                    expires: account.expiresAt
+                                                    expires: account.expiresAt,
                                                 };
                                             }
                                             catch {
-                                                return { type: 'failed' };
+                                                return { type: "failed" };
                                             }
-                                        }
+                                        },
                                     };
                                 }
                                 // Selected an existing account — auto-resolve with stored tokens.
@@ -856,140 +1084,148 @@ const MultiAuthPlugin = async ({ client, $, serverUrl, project, directory }) =>
                                     const flow = await createAuthorizationFlow();
                                     return {
                                         url: flow.url,
-                                        method: 'auto',
-                                        instructions: 'Login with your ChatGPT Plus/Pro account',
+                                        method: "auto",
+                                        instructions: "Login with your ChatGPT Plus/Pro account",
                                         callback: async () => {
                                             try {
                                                 const acc = await loginAccount(undefined, flow);
-                                                return { type: 'success', provider: PROVIDER_ID, refresh: acc.refreshToken, access: acc.accessToken, expires: acc.expiresAt };
+                                                return {
+                                                    type: "success",
+                                                    provider: PROVIDER_ID,
+                                                    refresh: acc.refreshToken,
+                                                    access: acc.accessToken,
+                                                    expires: acc.expiresAt,
+                                                };
                                             }
                                             catch {
-                                                return { type: 'failed' };
+                                                return { type: "failed" };
                                             }
-                                        }
+                                        },
                                     };
                                 }
                                 return {
-                                    url: 'data:text/html,<html><body><h1>Already authenticated</h1><p>Using stored credentials for ' + (account.email || account.alias) + '. You can close this tab.</p></body></html>',
-                                    method: 'auto',
+                                    url: "data:text/html,<html><body><h1>Already authenticated</h1><p>Using stored credentials for " +
+                                        (account.email || account.alias) +
+                                        ". You can close this tab.</p></body></html>",
+                                    method: "auto",
                                     instructions: `Using stored account: ${account.email || account.alias}`,
                                     callback: async () => ({
-                                        type: 'success',
+                                        type: "success",
                                         provider: PROVIDER_ID,
                                         refresh: account.refreshToken,
                                         access: account.accessToken,
-                                        expires: account.expiresAt
-                                    })
+                                        expires: account.expiresAt,
+                                    }),
                                 };
-                            }
+                            },
                         },
                         {
-                            label: 'Add new ChatGPT account',
-                            type: 'oauth',
+                            label: "Add new ChatGPT account",
+                            type: "oauth",
                             authorize: async () => {
                                 const flow = await createAuthorizationFlow();
                                 return {
                                     url: flow.url,
-                                    method: 'auto',
-                                    instructions: 'Login with your ChatGPT Plus/Pro account',
+                                    method: "auto",
+                                    instructions: "Login with your ChatGPT Plus/Pro account",
                                     callback: async () => {
                                         try {
                                             const account = await loginAccount(undefined, flow);
                                             return {
-                                                type: 'success',
+                                                type: "success",
                                                 provider: PROVIDER_ID,
                                                 refresh: account.refreshToken,
                                                 access: account.accessToken,
-                                                expires: account.expiresAt
+                                                expires: account.expiresAt,
                                             };
                                         }
                                         catch {
-                                            return { type: 'failed' };
+                                            return { type: "failed" };
                                         }
-                                    }
+                                    },
                                 };
-                            }
+                            },
                         },
                         {
-                            label: 'Use API key',
-                            type: 'api',
+                            label: "Use API key",
+                            type: "api",
                             prompts: [
                                 {
-                                    type: 'text',
-                                    key: 'apiKey',
-                                    message: 'Enter your OpenAI API key (sk-...)',
-                                    placeholder: 'sk-...'
-                                }
+                                    type: "text",
+                                    key: "apiKey",
+                                    message: "Enter your OpenAI API key (sk-...)",
+                                    placeholder: "sk-...",
+                                },
                             ],
                             authorize: async (inputs) => {
                                 const apiKey = inputs?.apiKey?.trim();
                                 if (!apiKey) {
-                                    return { type: 'failed' };
+                                    return { type: "failed" };
                                 }
                                 return {
-                                    type: 'success',
+                                    type: "success",
                                     key: apiKey,
-                                    provider: PROVIDER_ID
+                                    provider: PROVIDER_ID,
                                 };
-                            }
-                        }
+                            },
+                        },
                     ];
                 }
                 // No accounts yet — must go through full OAuth flow or use API key
                 return [
                     {
-                        label: 'ChatGPT OAuth (Multi-Account)',
-                        type: 'oauth',
+                        label: "ChatGPT OAuth (Multi-Account)",
+                        type: "oauth",
                         authorize: async () => {
                             const flow = await createAuthorizationFlow();
                             return {
                                 url: flow.url,
-                                method: 'auto',
-                                instructions: 'Login with your ChatGPT Plus/Pro account',
+                                method: "auto",
+                                instructions: "Login with your ChatGPT Plus/Pro account",
                                 callback: async () => {
                                     try {
                                         const account = await loginAccount(undefined, flow);
                                         return {
-                                            type: 'success',
+                                            type: "success",
                                             provider: PROVIDER_ID,
                                             refresh: account.refreshToken,
                                             access: account.accessToken,
-                                            expires: account.expiresAt
+                                            expires: account.expiresAt,
                                         };
                                     }
                                     catch {
-                                        return { type: 'failed' };
+                                        return { type: "failed" };
                                     }
-                                }
+                                },
                             };
-                        }
+                        },
                     },
                     {
-                        label: 'Use API key',
-                        type: 'api',
+                        label: "Use API key",
+                        type: "api",
                         prompts: [
                             {
-                                type: 'text',
-                                key: 'apiKey',
-                                message: 'Enter your OpenAI API key (sk-...)',
-                                placeholder: 'sk-...'
-                            }
+                                type: "text",
+                                key: "apiKey",
+                                message: "Enter your OpenAI API key (sk-...)",
+                                placeholder: "sk-...",
+                            },
                         ],
                         authorize: async (inputs) => {
                             const apiKey = inputs?.apiKey?.trim();
                             if (!apiKey) {
-                                return { type: 'failed' };
+                                return { type: "failed" };
                             }
                             return {
-                                type: 'success',
+                                type: "success",
                                 key: apiKey,
-                                provider: PROVIDER_ID
+                                provider: PROVIDER_ID,
                             };
-                        }
-                    }
+                        },
+                    },
                 ];
-            })()
-        }
+            })(),
+        },
     };
 };
 export default MultiAuthPlugin;