thaddeus 1.0.26 → 1.0.28

package/src/commands/torch.js

@@ -0,0 +1,122 @@
+// Torch command — context health dashboard.
+// Shows context window usage (tokens used/remaining), message count,
+// active tools, MCP servers, and model info. Wires to the same
+// analyzeContext infrastructure used by /context but in a compact format.
+const torch = {
+    type: 'local-jsx',
+    name: 'torch',
+    aliases: [],
+    description: 'Illuminate the current context — quick summary of state',
+    immediate: true,
+    load: () => Promise.all([
+        import('../bootstrap/state.js'),
+        import('../utils/context.js'),
+        import('../utils/cwd.js'),
+    ]).then(([stateMod, contextMod, cwdMod]) => ({
+        async call(onDone, context, _args) {
+            try {
+                const sessionId = stateMod.getSessionId();
+                const model = context.options.mainLoopModel;
+                const contextWindow = contextMod.getContextWindowForModel(model, stateMod.getSdkBetas());
+                // Count messages from the tool use context
+                const messages = context.messages ?? [];
+                const messageCount = messages.length;
+                const userMessages = messages.filter((m) => m.type === 'user').length;
+                const assistantMessages = messages.filter((m) => m.type === 'assistant').length;
+                // Rough token estimation from message count
+                // (Full token counting requires analyzeContextUsage which is expensive;
+                // torch is meant to be fast. Use /context for detailed breakdown.)
+                const roughTokensPerMessage = 500; // conservative average
+                const estimatedTokens = messageCount * roughTokensPerMessage;
+                const contextUsedPct = Math.min(100, Math.round((estimatedTokens / contextWindow) * 100));
+                const remainingTokens = Math.max(0, contextWindow - estimatedTokens);
+                // Active tools count
+                const tools = context.options.tools;
+                const toolNames = [];
+                if (tools && typeof tools[Symbol.iterator] === 'function') {
+                    for (const tool of tools) {
+                        if (tool && typeof tool === 'object' && 'name' in tool) {
+                            toolNames.push(tool.name);
+                        }
+                    }
+                }
+                // MCP servers
+                const mcpClients = context.options.mcpClients ?? [];
+                const mcpCount = mcpClients.length;
+                const mcpNames = mcpClients
+                    .map((c) => c.name ?? 'unnamed')
+                    .filter(Boolean);
+                // Cost tracking
+                const totalCost = stateMod.getTotalCostUSD?.() ?? 0;
+                const cwd = cwdMod.getCwd();
+                // Build the dashboard
+                const sections = [];
+                sections.push('CONTEXT HEALTH DASHBOARD');
+                sections.push('='.repeat(40));
+                sections.push('');
+                // Context window
+                const bar = buildProgressBar(contextUsedPct, 30);
+                sections.push(`Context Window: ${formatTokens(contextWindow)}`);
+                sections.push(`  ${bar} ~${contextUsedPct}%`);
+                sections.push(`  Estimated used: ~${formatTokens(estimatedTokens)}`);
+                sections.push(`  Remaining:      ~${formatTokens(remainingTokens)}`);
+                sections.push(`  (Use /context for precise token counts)`);
+                sections.push('');
+                // Messages
+                sections.push(`Messages: ${messageCount} total`);
+                sections.push(`  User:      ${userMessages}`);
+                sections.push(`  Assistant: ${assistantMessages}`);
+                sections.push(`  Other:     ${messageCount - userMessages - assistantMessages}`);
+                sections.push('');
+                // Model & session
+                sections.push(`Model:   ${model}`);
+                sections.push(`Session: ${sessionId}`);
+                sections.push(`CWD:     ${cwd}`);
+                if (totalCost > 0) {
+                    sections.push(`Cost:    $${totalCost.toFixed(4)}`);
+                }
+                sections.push('');
+                // Tools
+                sections.push(`Tools: ${toolNames.length} active`);
+                if (toolNames.length > 0 && toolNames.length <= 20) {
+                    sections.push(`  ${toolNames.join(', ')}`);
+                }
+                else if (toolNames.length > 20) {
+                    sections.push(`  ${toolNames.slice(0, 20).join(', ')}...`);
+                    sections.push(`  (+${toolNames.length - 20} more)`);
+                }
+                sections.push('');
+                // MCP
+                if (mcpCount > 0) {
+                    sections.push(`MCP Servers: ${mcpCount} connected`);
+                    sections.push(`  ${mcpNames.join(', ')}`);
+                }
+                else {
+                    sections.push('MCP Servers: none');
+                }
+                onDone(sections.join('\n'), { display: 'system' });
+                return null;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                onDone(`Torch failed: ${msg}`);
+                return null;
+            }
+        },
+    })),
+};
+/** Format token count for display (e.g., 200000 -> "200k") */
+function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(0)}k`;
+    return String(n);
+}
+/** Build a simple ASCII progress bar */
+function buildProgressBar(pct, width) {
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    return '[' + '#'.repeat(filled) + '-'.repeat(empty) + ']';
+}
+export default torch;

package/src/commands/ultraplan.js

@@ -0,0 +1,416 @@
+import { readFileSync } from 'fs';
+import { REMOTE_CONTROL_DISCONNECTED_MSG } from '../bridge/types.js';
+import { DIAMOND_OPEN } from '../constants/figures.js';
+import { getRemoteSessionUrl } from '../constants/product.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
+import { logEvent } from '../services/analytics/index.js';
+import { checkRemoteAgentEligibility, formatPreconditionError, RemoteAgentTask, registerRemoteAgentTask } from '../tasks/RemoteAgentTask/RemoteAgentTask.js';
+import { logForDebugging } from '../utils/debug.js';
+import { errorMessage } from '../utils/errors.js';
+import { logError } from '../utils/log.js';
+import { enqueuePendingNotification } from '../utils/messageQueueManager.js';
+import { ALL_MODEL_CONFIGS } from '../utils/model/configs.js';
+import { updateTaskState } from '../utils/task/framework.js';
+import { archiveRemoteSession, teleportToRemote } from '../utils/teleport.js';
+import { pollForApprovedExitPlanMode, UltraplanPollError } from '../utils/ultraplan/ccrSession.js';
+// TODO(prod-hardening): OAuth token may go stale over the 30min poll;
+// consider refresh.
+// Multi-agent exploration is slow; 30min timeout.
+const ULTRAPLAN_TIMEOUT_MS = 30 * 60 * 1000;
+export const CCR_TERMS_URL = 'https://delphilabsinc.com/thaddeus/docs/en/thaddeus-on-the-web';
+// CCR runs against the first-party API — use the canonical ID, not the
+// provider-specific string getModelStrings() would return (which may be a
+// Bedrock ARN or Vertex ID on the local CLI). Read at call time, not module
+// load: the GrowthBook cache is empty at import and `/config` Gates can flip
+// it between invocations.
+function getUltraplanModel() {
+    return getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_ultraplan_model', ALL_MODEL_CONFIGS.opus46.firstParty);
+}
+// prompt.txt is wrapped in <system-reminder> so the CCR browser hides
+// scaffolding (CLI_BLOCK_TAGS dropped by stripSystemNotifications)
+// while the model still sees full text.
+// Phrasing deliberately avoids the feature name because
+// the remote CCR CLI runs keyword detection on raw input before
+// any tag stripping, and a bare "ultraplan" in the prompt would self-trigger as
+// /ultraplan, which is filtered out of headless mode as "Unknown skill"
+//
+// Bundler inlines .txt as a string; the test runner wraps it as {default}.
+/* eslint-disable @typescript-eslint/no-require-imports */
+const _rawPrompt = require('../utils/ultraplan/prompt.txt');
+/* eslint-enable @typescript-eslint/no-require-imports */
+const DEFAULT_INSTRUCTIONS = (typeof _rawPrompt === 'string' ? _rawPrompt : _rawPrompt.default).trimEnd();
+// Dev-only prompt override resolved eagerly at module load.
+// Gated to ant builds (USER_TYPE is a build-time define,
+// so the override path is DCE'd from external builds).
+// Shell-set env only, so top-level process.env read is fine
+// — settings.env never injects this.
+/* eslint-disable custom-rules/no-process-env-top-level, custom-rules/no-sync-fs -- ant-only dev override; eager top-level read is the point (crash at startup, not silently inside the slash-command try/catch) */
+const ULTRAPLAN_INSTRUCTIONS = "external" === 'ant' && process.env.ULTRAPLAN_PROMPT_FILE ? readFileSync(process.env.ULTRAPLAN_PROMPT_FILE, 'utf8').trimEnd() : DEFAULT_INSTRUCTIONS;
+/* eslint-enable custom-rules/no-process-env-top-level, custom-rules/no-sync-fs */
+/**
+ * Assemble the initial CCR user message. seedPlan and blurb stay outside the
+ * system-reminder so the browser renders them; scaffolding is hidden.
+ */
+export function buildUltraplanPrompt(blurb, seedPlan) {
+    const parts = [];
+    if (seedPlan) {
+        parts.push('Here is a draft plan to refine:', '', seedPlan, '');
+    }
+    parts.push(ULTRAPLAN_INSTRUCTIONS);
+    if (blurb) {
+        parts.push('', blurb);
+    }
+    return parts.join('\n');
+}
+function startDetachedPoll(taskId, sessionId, url, getAppState, setAppState) {
+    const started = Date.now();
+    let failed = false;
+    void (async () => {
+        try {
+            const { plan, rejectCount, executionTarget } = await pollForApprovedExitPlanMode(sessionId, ULTRAPLAN_TIMEOUT_MS, phase => {
+                if (phase === 'needs_input')
+                    logEvent('thaddeus_ultraplan_awaiting_input', {});
+                updateTaskState(taskId, setAppState, t => {
+                    if (t.status !== 'running')
+                        return t;
+                    const next = phase === 'running' ? undefined : phase;
+                    return t.ultraplanPhase === next ? t : {
+                        ...t,
+                        ultraplanPhase: next
+                    };
+                });
+            }, () => getAppState().tasks?.[taskId]?.status !== 'running');
+            logEvent('thaddeus_ultraplan_approved', {
+                duration_ms: Date.now() - started,
+                plan_length: plan.length,
+                reject_count: rejectCount,
+                execution_target: executionTarget
+            });
+            if (executionTarget === 'remote') {
+                // User chose "execute in CCR" in the browser PlanModal — the remote
+                // session is now coding. Skip archive (ARCHIVE has no running-check,
+                // would kill mid-execution) and skip the choice dialog (already chose).
+                // Guard on task status so a poll that resolves after stopUltraplan
+                // doesn't notify for a killed session.
+                const task = getAppState().tasks?.[taskId];
+                if (task?.status !== 'running')
+                    return;
+                updateTaskState(taskId, setAppState, t => t.status !== 'running' ? t : {
+                    ...t,
+                    status: 'completed',
+                    endTime: Date.now()
+                });
+                setAppState(prev => prev.ultraplanSessionUrl === url ? {
+                    ...prev,
+                    ultraplanSessionUrl: undefined
+                } : prev);
+                enqueuePendingNotification({
+                    value: [`Ultraplan approved — executing in Thaddeus on the web. Follow along at: ${url}`, '', 'Results will land as a pull request when the remote session finishes. There is nothing to do here.'].join('\n'),
+                    mode: 'task-notification'
+                });
+            }
+            else {
+                // Teleport: set pendingChoice so REPL mounts UltraplanChoiceDialog.
+                // The dialog owns archive + URL clear on choice. Guard on task status
+                // so a poll that resolves after stopUltraplan doesn't resurrect the
+                // dialog for a killed session.
+                setAppState(prev => {
+                    const task = prev.tasks?.[taskId];
+                    if (!task || task.status !== 'running')
+                        return prev;
+                    return {
+                        ...prev,
+                        ultraplanPendingChoice: {
+                            plan,
+                            sessionId,
+                            taskId
+                        }
+                    };
+                });
+            }
+        }
+        catch (e) {
+            // If the task was stopped (stopUltraplan sets status=killed), the poll
+            // erroring is expected — skip the failure notification and cleanup
+            // (kill() already archived; stopUltraplan cleared the URL).
+            const task = getAppState().tasks?.[taskId];
+            if (task?.status !== 'running')
+                return;
+            failed = true;
+            logEvent('thaddeus_ultraplan_failed', {
+                duration_ms: Date.now() - started,
+                reason: (e instanceof UltraplanPollError ? e.reason : 'network_or_unknown'),
+                reject_count: e instanceof UltraplanPollError ? e.rejectCount : undefined
+            });
+            enqueuePendingNotification({
+                value: `Ultraplan failed: ${errorMessage(e)}\n\nSession: ${url}`,
+                mode: 'task-notification'
+            });
+            // Error path owns cleanup; teleport path defers to the dialog; remote
+            // path handled its own cleanup above.
+            void archiveRemoteSession(sessionId).catch(e => logForDebugging(`ultraplan archive failed: ${String(e)}`));
+            setAppState(prev => 
+            // Compare against this poll's URL so a newer relaunched session's
+            // URL isn't cleared by a stale poll erroring out.
+            prev.ultraplanSessionUrl === url ? {
+                ...prev,
+                ultraplanSessionUrl: undefined
+            } : prev);
+        }
+        finally {
+            // Remote path already set status=completed above; teleport path
+            // leaves status=running so the pill shows the ultraplanPhase state
+            // until UltraplanChoiceDialog completes the task after the user's
+            // choice. Setting completed here would filter the task out of
+            // isBackgroundTask before the pill can render the phase state.
+            // Failure path has no dialog, so it owns the status transition here.
+            if (failed) {
+                updateTaskState(taskId, setAppState, t => t.status !== 'running' ? t : {
+                    ...t,
+                    status: 'failed',
+                    endTime: Date.now()
+                });
+            }
+        }
+    })();
+}
+// Renders immediately so the terminal doesn't appear hung during the
+// multi-second teleportToRemote round-trip.
+function buildLaunchMessage(disconnectedBridge) {
+    const prefix = disconnectedBridge ? `${REMOTE_CONTROL_DISCONNECTED_MSG} ` : '';
+    return `${DIAMOND_OPEN} ultraplan\n${prefix}Starting Thaddeus on the web…`;
+}
+function buildSessionReadyMessage(url) {
+    return `${DIAMOND_OPEN} ultraplan · Monitor progress in Thaddeus on the web ${url}\nYou can continue working — when the ${DIAMOND_OPEN} fills, press Shift+↓ to view results`;
+}
+function buildAlreadyActiveMessage(url) {
+    return url ? `ultraplan: already polling. Open ${url} to check status, or wait for the plan to land here.` : 'ultraplan: already launching. Please wait for the session to start.';
+}
+/**
+ * Stop a running ultraplan: archive the remote session (halts it but keeps the
+ * URL viewable), kill the local task entry (clears the pill), and clear
+ * ultraplanSessionUrl (re-arms the keyword trigger). startDetachedPoll's
+ * shouldStop callback sees the killed status on its next tick and throws;
+ * the catch block early-returns when status !== 'running'.
+ */
+export async function stopUltraplan(taskId, sessionId, setAppState) {
+    // RemoteAgentTask.kill archives the session (with .catch) — no separate
+    // archive call needed here.
+    await RemoteAgentTask.kill(taskId, setAppState);
+    setAppState(prev => prev.ultraplanSessionUrl || prev.ultraplanPendingChoice || prev.ultraplanLaunching ? {
+        ...prev,
+        ultraplanSessionUrl: undefined,
+        ultraplanPendingChoice: undefined,
+        ultraplanLaunching: undefined
+    } : prev);
+    const url = getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL);
+    enqueuePendingNotification({
+        value: `Ultraplan stopped.\n\nSession: ${url}`,
+        mode: 'task-notification'
+    });
+    enqueuePendingNotification({
+        value: 'The user stopped the ultraplan session above. Do not respond to the stop notification — wait for their next message.',
+        mode: 'task-notification',
+        isMeta: true
+    });
+}
+/**
+ * Shared entry for the slash command, keyword trigger, and the plan-approval
+ * dialog's "Ultraplan" button. When seedPlan is present (dialog path), it is
+ * prepended as a draft to refine; blurb may be empty in that case.
+ *
+ * Resolves immediately with the user-facing message. Eligibility check,
+ * session creation, and task registration run detached and failures surface via
+ * enqueuePendingNotification.
+ */
+export async function launchUltraplan(opts) {
+    const { blurb, seedPlan, getAppState, setAppState, signal, disconnectedBridge, onSessionReady } = opts;
+    const { ultraplanSessionUrl: active, ultraplanLaunching } = getAppState();
+    if (active || ultraplanLaunching) {
+        logEvent('thaddeus_ultraplan_create_failed', {
+            reason: (active ? 'already_polling' : 'already_launching')
+        });
+        return buildAlreadyActiveMessage(active);
+    }
+    if (!blurb && !seedPlan) {
+        // No event — bare /ultraplan is a usage query, not an attempt.
+        return [
+            // Rendered via <Markdown>; raw <message> is tokenized as HTML
+            // and dropped. Backslash-escape the brackets.
+            'Usage: /ultraplan \\<prompt\\>, or include "ultraplan" anywhere', 'in your prompt', '', 'Advanced multi-agent plan mode with AGI Model 7.', 'Runs in Thaddeus on the web. When the plan is ready,', 'you can execute it in the web session or send it back here.', 'Terminal stays free while the remote plans.', 'Requires /login.', '', `Terms: ${CCR_TERMS_URL}`
+        ].join('\n');
+    }
+    // Set synchronously before the detached flow to prevent duplicate launches
+    // during the teleportToRemote window.
+    setAppState(prev => prev.ultraplanLaunching ? prev : {
+        ...prev,
+        ultraplanLaunching: true
+    });
+    void launchDetached({
+        blurb,
+        seedPlan,
+        getAppState,
+        setAppState,
+        signal,
+        onSessionReady
+    });
+    return buildLaunchMessage(disconnectedBridge);
+}
+async function launchDetached(opts) {
+    const { blurb, seedPlan, getAppState, setAppState, signal, onSessionReady } = opts;
+    // Hoisted so the catch block can archive the remote session if an error
+    // occurs after teleportToRemote succeeds (avoids 30min orphan).
+    let sessionId;
+    try {
+        const model = getUltraplanModel();
+        const eligibility = await checkRemoteAgentEligibility();
+        if (!eligibility.eligible) {
+            logEvent('thaddeus_ultraplan_create_failed', {
+                reason: 'precondition',
+                precondition_errors: eligibility.errors.map(e => e.type).join(',')
+            });
+            const reasons = eligibility.errors.map(formatPreconditionError).join('\n');
+            enqueuePendingNotification({
+                value: `ultraplan: cannot launch remote session —\n${reasons}`,
+                mode: 'task-notification'
+            });
+            return;
+        }
+        const prompt = buildUltraplanPrompt(blurb, seedPlan);
+        let bundleFailMsg;
+        const session = await teleportToRemote({
+            initialMessage: prompt,
+            description: blurb || 'Refine local plan',
+            model,
+            permissionMode: 'plan',
+            ultraplan: true,
+            signal,
+            useDefaultEnvironment: true,
+            onBundleFail: msg => {
+                bundleFailMsg = msg;
+            }
+        });
+        if (!session) {
+            logEvent('thaddeus_ultraplan_create_failed', {
+                reason: (bundleFailMsg ? 'bundle_fail' : 'teleport_null')
+            });
+            enqueuePendingNotification({
+                value: `ultraplan: session creation failed${bundleFailMsg ? ` — ${bundleFailMsg}` : ''}. See --debug for details.`,
+                mode: 'task-notification'
+            });
+            return;
+        }
+        sessionId = session.id;
+        const url = getRemoteSessionUrl(session.id, process.env.SESSION_INGRESS_URL);
+        setAppState(prev => ({
+            ...prev,
+            ultraplanSessionUrl: url,
+            ultraplanLaunching: undefined
+        }));
+        onSessionReady?.(buildSessionReadyMessage(url));
+        logEvent('thaddeus_ultraplan_launched', {
+            has_seed_plan: Boolean(seedPlan),
+            model: model
+        });
+        // TODO(#23985): replace registerRemoteAgentTask + startDetachedPoll with
+        // ExitPlanModeScanner inside startRemoteSessionPolling.
+        const { taskId } = registerRemoteAgentTask({
+            remoteTaskType: 'ultraplan',
+            session: {
+                id: session.id,
+                title: blurb || 'Ultraplan'
+            },
+            command: blurb,
+            context: {
+                abortController: new AbortController(),
+                getAppState,
+                setAppState
+            },
+            isUltraplan: true
+        });
+        startDetachedPoll(taskId, session.id, url, getAppState, setAppState);
+    }
+    catch (e) {
+        logError(e);
+        logEvent('thaddeus_ultraplan_create_failed', {
+            reason: 'unexpected_error'
+        });
+        enqueuePendingNotification({
+            value: `ultraplan: unexpected error — ${errorMessage(e)}`,
+            mode: 'task-notification'
+        });
+        if (sessionId) {
+            // Error after teleport succeeded — archive so the remote doesn't sit
+            // running for 30min with nobody polling it.
+            void archiveRemoteSession(sessionId).catch(err => logForDebugging('ultraplan: failed to archive orphaned session', err));
+            // ultraplanSessionUrl may have been set before the throw; clear it so
+            // the "already polling" guard doesn't block future launches.
+            setAppState(prev => prev.ultraplanSessionUrl ? {
+                ...prev,
+                ultraplanSessionUrl: undefined
+            } : prev);
+        }
+    }
+    finally {
+        // No-op on success: the url-setting setAppState already cleared this.
+        setAppState(prev => prev.ultraplanLaunching ? {
+            ...prev,
+            ultraplanLaunching: undefined
+        } : prev);
+    }
+}
+const call = async (onDone, context, args) => {
+    const blurb = args.trim();
+    // Bare /ultraplan (no args, no seed plan) just shows usage — no dialog.
+    if (!blurb) {
+        const msg = await launchUltraplan({
+            blurb,
+            getAppState: context.getAppState,
+            setAppState: context.setAppState,
+            signal: context.abortController.signal
+        });
+        onDone(msg, {
+            display: 'system'
+        });
+        return null;
+    }
+    // Guard matches launchUltraplan's own check — showing the dialog when a
+    // session is already active or launching would waste the user's click and set
+    // hasSeenUltraplanTerms before the launch fails.
+    const { ultraplanSessionUrl: active, ultraplanLaunching } = context.getAppState();
+    if (active || ultraplanLaunching) {
+        logEvent('thaddeus_ultraplan_create_failed', {
+            reason: (active ? 'already_polling' : 'already_launching')
+        });
+        onDone(buildAlreadyActiveMessage(active), {
+            display: 'system'
+        });
+        return null;
+    }
+    // Mount the pre-launch dialog via focusedInputDialog (bottom region, like
+    // permission dialogs) rather than returning JSX (transcript area, anchors
+    // at top of scrollback). REPL.tsx handles launch/clear/cancel on choice.
+    context.setAppState(prev => ({
+        ...prev,
+        ultraplanLaunchPending: {
+            blurb
+        }
+    }));
+    // 'skip' suppresses the (no content) echo — the dialog's choice handler
+    // adds the real /ultraplan echo + launch confirmation.
+    onDone(undefined, {
+        display: 'skip'
+    });
+    return null;
+};
+export default {
+    type: 'local-jsx',
+    name: 'ultraplan',
+    description: `~10–30 min · Thaddeus on the web drafts an advanced plan you can edit and approve. See ${CCR_TERMS_URL}`,
+    argumentHint: '<prompt>',
+    isEnabled: () => "external" === 'ant',
+    load: () => Promise.resolve({
+        call
+    })
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["readFileSync","REMOTE_CONTROL_DISCONNECTED_MSG","Command","DIAMOND_OPEN","getRemoteSessionUrl","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","AppState","checkRemoteAgentEligibility","formatPreconditionError","RemoteAgentTask","RemoteAgentTaskState","registerRemoteAgentTask","LocalJSXCommandCall","logForDebugging","errorMessage","logError","enqueuePendingNotification","ALL_MODEL_CONFIGS","updateTaskState","archiveRemoteSession","teleportToRemote","pollForApprovedExitPlanMode","UltraplanPollError","ULTRAPLAN_TIMEOUT_MS","CCR_TERMS_URL","getUltraplanModel","opus46","firstParty","_rawPrompt","require","DEFAULT_INSTRUCTIONS","default","trimEnd","ULTRAPLAN_INSTRUCTIONS","process","env","ULTRAPLAN_PROMPT_FILE","buildUltraplanPrompt","blurb","seedPlan","parts","push","join","startDetachedPoll","taskId","sessionId","url","getAppState","setAppState","f","prev","started","Date","now","failed","plan","rejectCount","executionTarget","phase","t","status","next","undefined","ultraplanPhase","tasks","duration_ms","plan_length","length","reject_count","execution_target","task","endTime","ultraplanSessionUrl","value","mode","ultraplanPendingChoice","e","reason","catch","String","buildLaunchMessage","disconnectedBridge","prefix","buildSessionReadyMessage","buildAlreadyActiveMessage","stopUltraplan","Promise","kill","ultraplanLaunching","SESSION_INGRESS_URL","isMeta","launchUltraplan","opts","signal","AbortSignal","onSessionReady","msg","active","launchDetached","model","eligibility","eligible","precondition_errors","errors","map","type","reasons","prompt","bundleFailMsg","session","initialMessage","description","permissionMode","ultraplan","useDefaultEnvironment","onBundleFail","id","has_seed_plan","Boolean","remoteTaskType","title","command","context","abortController","AbortController","isUltraplan","err","call","onDone","args","trim","display","ultraplanLaunchPending","name","argumentHint","isEnabled","load","resolve"],"sources":["ultraplan.tsx"],"sourcesContent":["import { readFileSync } from 'fs'\nimport { REMOTE_CONTROL_DISCONNECTED_MSG } from '../bridge/types.js'\nimport type { Command } from '../commands.js'\nimport { DIAMOND_OPEN } from '../constants/figures.js'\nimport { getRemoteSessionUrl } from '../constants/product.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../services/analytics/index.js'\nimport type { AppState } from '../state/AppStateStore.js'\nimport {\n  checkRemoteAgentEligibility,\n  formatPreconditionError,\n  RemoteAgentTask,\n  type RemoteAgentTaskState,\n  registerRemoteAgentTask,\n} from '../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport type { LocalJSXCommandCall } from '../types/command.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { errorMessage } from '../utils/errors.js'\nimport { logError } from '../utils/log.js'\nimport { enqueuePendingNotification } from '../utils/messageQueueManager.js'\nimport { ALL_MODEL_CONFIGS } from '../utils/model/configs.js'\nimport { updateTaskState } from '../utils/task/framework.js'\nimport { archiveRemoteSession, teleportToRemote } from '../utils/teleport.js'\nimport {\n  pollForApprovedExitPlanMode,\n  UltraplanPollError,\n} from '../utils/ultraplan/ccrSession.js'\n\n// TODO(prod-hardening): OAuth token may go stale over the 30min poll;\n// consider refresh.\n\n// Multi-agent exploration is slow; 30min timeout.\nconst ULTRAPLAN_TIMEOUT_MS = 30 * 60 * 1000\n\nexport const CCR_TERMS_URL =\n  'https://code.claude.com/docs/en/claude-code-on-the-web'\n\n// CCR runs against the first-party API — use the canonical ID, not the\n// provider-specific string getModelStrings() would return (which may be a\n// Bedrock ARN or Vertex ID on the local CLI). Read at call time, not module\n// load: the GrowthBook cache is empty at import and `/config` Gates can flip\n// it between invocations.\nfunction getUltraplanModel(): string {\n  return getFeatureValue_CACHED_MAY_BE_STALE(\n    'tengu_ultraplan_model',\n    ALL_MODEL_CONFIGS.opus46.firstParty,\n  )\n}\n\n// prompt.txt is wrapped in <system-reminder> so the CCR browser hides\n// scaffolding (CLI_BLOCK_TAGS dropped by stripSystemNotifications)\n// while the model still sees full text.\n// Phrasing deliberately avoids the feature name because\n// the remote CCR CLI runs keyword detection on raw input before\n// any tag stripping, and a bare \"ultraplan\" in the prompt would self-trigger as\n// /ultraplan, which is filtered out of headless mode as \"Unknown skill\"\n//\n// Bundler inlines .txt as a string; the test runner wraps it as {default}.\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst _rawPrompt = require('../utils/ultraplan/prompt.txt')\n/* eslint-enable @typescript-eslint/no-require-imports */\nconst DEFAULT_INSTRUCTIONS: string = (\n  typeof _rawPrompt === 'string' ? _rawPrompt : _rawPrompt.default\n).trimEnd()\n\n// Dev-only prompt override resolved eagerly at module load.\n// Gated to ant builds (USER_TYPE is a build-time define,\n// so the override path is DCE'd from external builds).\n// Shell-set env only, so top-level process.env read is fine\n// — settings.env never injects this.\n/* eslint-disable custom-rules/no-process-env-top-level, custom-rules/no-sync-fs -- ant-only dev override; eager top-level read is the point (crash at startup, not silently inside the slash-command try/catch) */\nconst ULTRAPLAN_INSTRUCTIONS: string =\n  \"external\" === 'ant' && process.env.ULTRAPLAN_PROMPT_FILE\n    ? readFileSync(process.env.ULTRAPLAN_PROMPT_FILE, 'utf8').trimEnd()\n    : DEFAULT_INSTRUCTIONS\n/* eslint-enable custom-rules/no-process-env-top-level, custom-rules/no-sync-fs */\n\n/**\n * Assemble the initial CCR user message. seedPlan and blurb stay outside the\n * system-reminder so the browser renders them; scaffolding is hidden.\n */\nexport function buildUltraplanPrompt(blurb: string, seedPlan?: string): string {\n  const parts: string[] = []\n  if (seedPlan) {\n    parts.push('Here is a draft plan to refine:', '', seedPlan, '')\n  }\n  parts.push(ULTRAPLAN_INSTRUCTIONS)\n  if (blurb) {\n    parts.push('', blurb)\n  }\n  return parts.join('\\n')\n}\n\nfunction startDetachedPoll(\n  taskId: string,\n  sessionId: string,\n  url: string,\n  getAppState: () => AppState,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): void {\n  const started = Date.now()\n  let failed = false\n  void (async () => {\n    try {\n      const { plan, rejectCount, executionTarget } =\n        await pollForApprovedExitPlanMode(\n          sessionId,\n          ULTRAPLAN_TIMEOUT_MS,\n          phase => {\n            if (phase === 'needs_input')\n              logEvent('tengu_ultraplan_awaiting_input', {})\n            updateTaskState<RemoteAgentTaskState>(taskId, setAppState, t => {\n              if (t.status !== 'running') return t\n              const next = phase === 'running' ? undefined : phase\n              return t.ultraplanPhase === next\n                ? t\n                : { ...t, ultraplanPhase: next }\n            })\n          },\n          () => getAppState().tasks?.[taskId]?.status !== 'running',\n        )\n      logEvent('tengu_ultraplan_approved', {\n        duration_ms: Date.now() - started,\n        plan_length: plan.length,\n        reject_count: rejectCount,\n        execution_target:\n          executionTarget as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      if (executionTarget === 'remote') {\n        // User chose \"execute in CCR\" in the browser PlanModal — the remote\n        // session is now coding. Skip archive (ARCHIVE has no running-check,\n        // would kill mid-execution) and skip the choice dialog (already chose).\n        // Guard on task status so a poll that resolves after stopUltraplan\n        // doesn't notify for a killed session.\n        const task = getAppState().tasks?.[taskId]\n        if (task?.status !== 'running') return\n        updateTaskState<RemoteAgentTaskState>(taskId, setAppState, t =>\n          t.status !== 'running'\n            ? t\n            : { ...t, status: 'completed', endTime: Date.now() },\n        )\n        setAppState(prev =>\n          prev.ultraplanSessionUrl === url\n            ? { ...prev, ultraplanSessionUrl: undefined }\n            : prev,\n        )\n        enqueuePendingNotification({\n          value: [\n            `Ultraplan approved — executing in Claude Code on the web. Follow along at: ${url}`,\n            '',\n            'Results will land as a pull request when the remote session finishes. There is nothing to do here.',\n          ].join('\\n'),\n          mode: 'task-notification',\n        })\n      } else {\n        // Teleport: set pendingChoice so REPL mounts UltraplanChoiceDialog.\n        // The dialog owns archive + URL clear on choice. Guard on task status\n        // so a poll that resolves after stopUltraplan doesn't resurrect the\n        // dialog for a killed session.\n        setAppState(prev => {\n          const task = prev.tasks?.[taskId]\n          if (!task || task.status !== 'running') return prev\n          return {\n            ...prev,\n            ultraplanPendingChoice: { plan, sessionId, taskId },\n          }\n        })\n      }\n    } catch (e) {\n      // If the task was stopped (stopUltraplan sets status=killed), the poll\n      // erroring is expected — skip the failure notification and cleanup\n      // (kill() already archived; stopUltraplan cleared the URL).\n      const task = getAppState().tasks?.[taskId]\n      if (task?.status !== 'running') return\n      failed = true\n      logEvent('tengu_ultraplan_failed', {\n        duration_ms: Date.now() - started,\n        reason: (e instanceof UltraplanPollError\n          ? e.reason\n          : 'network_or_unknown') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        reject_count:\n          e instanceof UltraplanPollError ? e.rejectCount : undefined,\n      })\n      enqueuePendingNotification({\n        value: `Ultraplan failed: ${errorMessage(e)}\\n\\nSession: ${url}`,\n        mode: 'task-notification',\n      })\n      // Error path owns cleanup; teleport path defers to the dialog; remote\n      // path handled its own cleanup above.\n      void archiveRemoteSession(sessionId).catch(e =>\n        logForDebugging(`ultraplan archive failed: ${String(e)}`),\n      )\n      setAppState(prev =>\n        // Compare against this poll's URL so a newer relaunched session's\n        // URL isn't cleared by a stale poll erroring out.\n        prev.ultraplanSessionUrl === url\n          ? { ...prev, ultraplanSessionUrl: undefined }\n          : prev,\n      )\n    } finally {\n      // Remote path already set status=completed above; teleport path\n      // leaves status=running so the pill shows the ultraplanPhase state\n      // until UltraplanChoiceDialog completes the task after the user's\n      // choice. Setting completed here would filter the task out of\n      // isBackgroundTask before the pill can render the phase state.\n      // Failure path has no dialog, so it owns the status transition here.\n      if (failed) {\n        updateTaskState<RemoteAgentTaskState>(taskId, setAppState, t =>\n          t.status !== 'running'\n            ? t\n            : { ...t, status: 'failed', endTime: Date.now() },\n        )\n      }\n    }\n  })()\n}\n\n// Renders immediately so the terminal doesn't appear hung during the\n// multi-second teleportToRemote round-trip.\nfunction buildLaunchMessage(disconnectedBridge?: boolean): string {\n  const prefix = disconnectedBridge ? `${REMOTE_CONTROL_DISCONNECTED_MSG} ` : ''\n  return `${DIAMOND_OPEN} ultraplan\\n${prefix}Starting Claude Code on the web…`\n}\n\nfunction buildSessionReadyMessage(url: string): string {\n  return `${DIAMOND_OPEN} ultraplan · Monitor progress in Claude Code on the web ${url}\\nYou can continue working — when the ${DIAMOND_OPEN} fills, press ↓ to view results`\n}\n\nfunction buildAlreadyActiveMessage(url: string | undefined): string {\n  return url\n    ? `ultraplan: already polling. Open ${url} to check status, or wait for the plan to land here.`\n    : 'ultraplan: already launching. Please wait for the session to start.'\n}\n\n/**\n * Stop a running ultraplan: archive the remote session (halts it but keeps the\n * URL viewable), kill the local task entry (clears the pill), and clear\n * ultraplanSessionUrl (re-arms the keyword trigger). startDetachedPoll's\n * shouldStop callback sees the killed status on its next tick and throws;\n * the catch block early-returns when status !== 'running'.\n */\nexport async function stopUltraplan(\n  taskId: string,\n  sessionId: string,\n  setAppState: (f: (prev: AppState) => AppState) => void,\n): Promise<void> {\n  // RemoteAgentTask.kill archives the session (with .catch) — no separate\n  // archive call needed here.\n  await RemoteAgentTask.kill(taskId, setAppState)\n  setAppState(prev =>\n    prev.ultraplanSessionUrl ||\n    prev.ultraplanPendingChoice ||\n    prev.ultraplanLaunching\n      ? {\n          ...prev,\n          ultraplanSessionUrl: undefined,\n          ultraplanPendingChoice: undefined,\n          ultraplanLaunching: undefined,\n        }\n      : prev,\n  )\n  const url = getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL)\n  enqueuePendingNotification({\n    value: `Ultraplan stopped.\\n\\nSession: ${url}`,\n    mode: 'task-notification',\n  })\n  enqueuePendingNotification({\n    value:\n      'The user stopped the ultraplan session above. Do not respond to the stop notification — wait for their next message.',\n    mode: 'task-notification',\n    isMeta: true,\n  })\n}\n\n/**\n * Shared entry for the slash command, keyword trigger, and the plan-approval\n * dialog's \"Ultraplan\" button. When seedPlan is present (dialog path), it is\n * prepended as a draft to refine; blurb may be empty in that case.\n *\n * Resolves immediately with the user-facing message. Eligibility check,\n * session creation, and task registration run detached and failures surface via\n * enqueuePendingNotification.\n */\nexport async function launchUltraplan(opts: {\n  blurb: string\n  seedPlan?: string\n  getAppState: () => AppState\n  setAppState: (f: (prev: AppState) => AppState) => void\n  signal: AbortSignal\n  /** True if the caller disconnected Remote Control before launching. */\n  disconnectedBridge?: boolean\n  /**\n   * Called once teleportToRemote resolves with a session URL. Callers that\n   * have setMessages (REPL) append this as a second transcript message so the\n   * URL is visible without opening the ↓ detail view. Callers without\n   * transcript access (ExitPlanModePermissionRequest) omit this — the pill\n   * still shows live status.\n   */\n  onSessionReady?: (msg: string) => void\n}): Promise<string> {\n  const {\n    blurb,\n    seedPlan,\n    getAppState,\n    setAppState,\n    signal,\n    disconnectedBridge,\n    onSessionReady,\n  } = opts\n\n  const { ultraplanSessionUrl: active, ultraplanLaunching } = getAppState()\n  if (active || ultraplanLaunching) {\n    logEvent('tengu_ultraplan_create_failed', {\n      reason: (active\n        ? 'already_polling'\n        : 'already_launching') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    return buildAlreadyActiveMessage(active)\n  }\n\n  if (!blurb && !seedPlan) {\n    // No event — bare /ultraplan is a usage query, not an attempt.\n    return [\n      // Rendered via <Markdown>; raw <message> is tokenized as HTML\n      // and dropped. Backslash-escape the brackets.\n      'Usage: /ultraplan \\\\<prompt\\\\>, or include \"ultraplan\" anywhere',\n      'in your prompt',\n      '',\n      'Advanced multi-agent plan mode with our most powerful model',\n      '(Opus). Runs in Claude Code on the web. When the plan is ready,',\n      'you can execute it in the web session or send it back here.',\n      'Terminal stays free while the remote plans.',\n      'Requires /login.',\n      '',\n      `Terms: ${CCR_TERMS_URL}`,\n    ].join('\\n')\n  }\n\n  // Set synchronously before the detached flow to prevent duplicate launches\n  // during the teleportToRemote window.\n  setAppState(prev =>\n    prev.ultraplanLaunching ? prev : { ...prev, ultraplanLaunching: true },\n  )\n  void launchDetached({\n    blurb,\n    seedPlan,\n    getAppState,\n    setAppState,\n    signal,\n    onSessionReady,\n  })\n  return buildLaunchMessage(disconnectedBridge)\n}\n\nasync function launchDetached(opts: {\n  blurb: string\n  seedPlan?: string\n  getAppState: () => AppState\n  setAppState: (f: (prev: AppState) => AppState) => void\n  signal: AbortSignal\n  onSessionReady?: (msg: string) => void\n}): Promise<void> {\n  const { blurb, seedPlan, getAppState, setAppState, signal, onSessionReady } =\n    opts\n  // Hoisted so the catch block can archive the remote session if an error\n  // occurs after teleportToRemote succeeds (avoids 30min orphan).\n  let sessionId: string | undefined\n  try {\n    const model = getUltraplanModel()\n\n    const eligibility = await checkRemoteAgentEligibility()\n    if (!eligibility.eligible) {\n      logEvent('tengu_ultraplan_create_failed', {\n        reason:\n          'precondition' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        precondition_errors: eligibility.errors\n          .map(e => e.type)\n          .join(\n            ',',\n          ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      const reasons = eligibility.errors.map(formatPreconditionError).join('\\n')\n      enqueuePendingNotification({\n        value: `ultraplan: cannot launch remote session —\\n${reasons}`,\n        mode: 'task-notification',\n      })\n      return\n    }\n\n    const prompt = buildUltraplanPrompt(blurb, seedPlan)\n    let bundleFailMsg: string | undefined\n    const session = await teleportToRemote({\n      initialMessage: prompt,\n      description: blurb || 'Refine local plan',\n      model,\n      permissionMode: 'plan',\n      ultraplan: true,\n      signal,\n      useDefaultEnvironment: true,\n      onBundleFail: msg => {\n        bundleFailMsg = msg\n      },\n    })\n    if (!session) {\n      logEvent('tengu_ultraplan_create_failed', {\n        reason: (bundleFailMsg\n          ? 'bundle_fail'\n          : 'teleport_null') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      enqueuePendingNotification({\n        value: `ultraplan: session creation failed${bundleFailMsg ? ` — ${bundleFailMsg}` : ''}. See --debug for details.`,\n        mode: 'task-notification',\n      })\n      return\n    }\n    sessionId = session.id\n\n    const url = getRemoteSessionUrl(session.id, process.env.SESSION_INGRESS_URL)\n    setAppState(prev => ({\n      ...prev,\n      ultraplanSessionUrl: url,\n      ultraplanLaunching: undefined,\n    }))\n    onSessionReady?.(buildSessionReadyMessage(url))\n    logEvent('tengu_ultraplan_launched', {\n      has_seed_plan: Boolean(seedPlan),\n      model:\n        model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    // TODO(#23985): replace registerRemoteAgentTask + startDetachedPoll with\n    // ExitPlanModeScanner inside startRemoteSessionPolling.\n    const { taskId } = registerRemoteAgentTask({\n      remoteTaskType: 'ultraplan',\n      session: { id: session.id, title: blurb || 'Ultraplan' },\n      command: blurb,\n      context: {\n        abortController: new AbortController(),\n        getAppState,\n        setAppState,\n      },\n      isUltraplan: true,\n    })\n    startDetachedPoll(taskId, session.id, url, getAppState, setAppState)\n  } catch (e) {\n    logError(e)\n    logEvent('tengu_ultraplan_create_failed', {\n      reason:\n        'unexpected_error' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    enqueuePendingNotification({\n      value: `ultraplan: unexpected error — ${errorMessage(e)}`,\n      mode: 'task-notification',\n    })\n    if (sessionId) {\n      // Error after teleport succeeded — archive so the remote doesn't sit\n      // running for 30min with nobody polling it.\n      void archiveRemoteSession(sessionId).catch(err =>\n        logForDebugging('ultraplan: failed to archive orphaned session', err),\n      )\n      // ultraplanSessionUrl may have been set before the throw; clear it so\n      // the \"already polling\" guard doesn't block future launches.\n      setAppState(prev =>\n        prev.ultraplanSessionUrl\n          ? { ...prev, ultraplanSessionUrl: undefined }\n          : prev,\n      )\n    }\n  } finally {\n    // No-op on success: the url-setting setAppState already cleared this.\n    setAppState(prev =>\n      prev.ultraplanLaunching\n        ? { ...prev, ultraplanLaunching: undefined }\n        : prev,\n    )\n  }\n}\n\nconst call: LocalJSXCommandCall = async (onDone, context, args) => {\n  const blurb = args.trim()\n\n  // Bare /ultraplan (no args, no seed plan) just shows usage — no dialog.\n  if (!blurb) {\n    const msg = await launchUltraplan({\n      blurb,\n      getAppState: context.getAppState,\n      setAppState: context.setAppState,\n      signal: context.abortController.signal,\n    })\n    onDone(msg, { display: 'system' })\n    return null\n  }\n\n  // Guard matches launchUltraplan's own check — showing the dialog when a\n  // session is already active or launching would waste the user's click and set\n  // hasSeenUltraplanTerms before the launch fails.\n  const { ultraplanSessionUrl: active, ultraplanLaunching } =\n    context.getAppState()\n  if (active || ultraplanLaunching) {\n    logEvent('tengu_ultraplan_create_failed', {\n      reason: (active\n        ? 'already_polling'\n        : 'already_launching') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n    onDone(buildAlreadyActiveMessage(active), { display: 'system' })\n    return null\n  }\n\n  // Mount the pre-launch dialog via focusedInputDialog (bottom region, like\n  // permission dialogs) rather than returning JSX (transcript area, anchors\n  // at top of scrollback). REPL.tsx handles launch/clear/cancel on choice.\n  context.setAppState(prev => ({ ...prev, ultraplanLaunchPending: { blurb } }))\n  // 'skip' suppresses the (no content) echo — the dialog's choice handler\n  // adds the real /ultraplan echo + launch confirmation.\n  onDone(undefined, { display: 'skip' })\n  return null\n}\n\nexport default {\n  type: 'local-jsx',\n  name: 'ultraplan',\n  description: `~10–30 min · Claude Code on the web drafts an advanced plan you can edit and approve. See ${CCR_TERMS_URL}`,\n  argumentHint: '<prompt>',\n  isEnabled: () => \"external\" === 'ant',\n  load: () => Promise.resolve({ call }),\n} satisfies Command\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,IAAI;AACjC,SAASC,+BAA+B,QAAQ,oBAAoB;AACpE,cAAcC,OAAO,QAAQ,gBAAgB;AAC7C,SAASC,YAAY,QAAQ,yBAAyB;AACtD,SAASC,mBAAmB,QAAQ,yBAAyB;AAC7D,SAASC,mCAAmC,QAAQ,qCAAqC;AACzF,SACE,KAAKC,0DAA0D,EAC/DC,QAAQ,QACH,gCAAgC;AACvC,cAAcC,QAAQ,QAAQ,2BAA2B;AACzD,SACEC,2BAA2B,EAC3BC,uBAAuB,EACvBC,eAAe,EACf,KAAKC,oBAAoB,EACzBC,uBAAuB,QAClB,6CAA6C;AACpD,cAAcC,mBAAmB,QAAQ,qBAAqB;AAC9D,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,YAAY,QAAQ,oBAAoB;AACjD,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SAASC,0BAA0B,QAAQ,iCAAiC;AAC5E,SAASC,iBAAiB,QAAQ,2BAA2B;AAC7D,SAASC,eAAe,QAAQ,4BAA4B;AAC5D,SAASC,oBAAoB,EAAEC,gBAAgB,QAAQ,sBAAsB;AAC7E,SACEC,2BAA2B,EAC3BC,kBAAkB,QACb,kCAAkC;;AAEzC;AACA;;AAEA;AACA,MAAMC,oBAAoB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI;AAE3C,OAAO,MAAMC,aAAa,GACxB,wDAAwD;;AAE1D;AACA;AACA;AACA;AACA;AACA,SAASC,iBAAiBA,CAAA,CAAE,EAAE,MAAM,CAAC;EACnC,OAAOtB,mCAAmC,CACxC,uBAAuB,EACvBc,iBAAiB,CAACS,MAAM,CAACC,UAC3B,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,UAAU,GAAGC,OAAO,CAAC,+BAA+B,CAAC;AAC3D;AACA,MAAMC,oBAAoB,EAAE,MAAM,GAAG,CACnC,OAAOF,UAAU,KAAK,QAAQ,GAAGA,UAAU,GAAGA,UAAU,CAACG,OAAO,EAChEC,OAAO,CAAC,CAAC;;AAEX;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,sBAAsB,EAAE,MAAM,GAClC,UAAU,KAAK,KAAK,IAAIC,OAAO,CAACC,GAAG,CAACC,qBAAqB,GACrDtC,YAAY,CAACoC,OAAO,CAACC,GAAG,CAACC,qBAAqB,EAAE,MAAM,CAAC,CAACJ,OAAO,CAAC,CAAC,GACjEF,oBAAoB;AAC1B;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASO,oBAAoBA,CAACC,KAAK,EAAE,MAAM,EAAEC,QAAiB,CAAR,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;EAC7E,MAAMC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;EAC1B,IAAID,QAAQ,EAAE;IACZC,KAAK,CAACC,IAAI,CAAC,iCAAiC,EAAE,EAAE,EAAEF,QAAQ,EAAE,EAAE,CAAC;EACjE;EACAC,KAAK,CAACC,IAAI,CAACR,sBAAsB,CAAC;EAClC,IAAIK,KAAK,EAAE;IACTE,KAAK,CAACC,IAAI,CAAC,EAAE,EAAEH,KAAK,CAAC;EACvB;EACA,OAAOE,KAAK,CAACE,IAAI,CAAC,IAAI,CAAC;AACzB;AAEA,SAASC,iBAAiBA,CACxBC,MAAM,EAAE,MAAM,EACdC,SAAS,EAAE,MAAM,EACjBC,GAAG,EAAE,MAAM,EACXC,WAAW,EAAE,GAAG,GAAGzC,QAAQ,EAC3B0C,WAAW,EAAE,CAACC,CAAC,EAAE,CAACC,IAAI,EAAE5C,QAAQ,EAAE,GAAGA,QAAQ,EAAE,GAAG,IAAI,CACvD,EAAE,IAAI,CAAC;EACN,MAAM6C,OAAO,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;EAC1B,IAAIC,MAAM,GAAG,KAAK;EAClB,KAAK,CAAC,YAAY;IAChB,IAAI;MACF,MAAM;QAAEC,IAAI;QAAEC,WAAW;QAAEC;MAAgB,CAAC,GAC1C,MAAMpC,2BAA2B,CAC/BwB,SAAS,EACTtB,oBAAoB,EACpBmC,KAAK,IAAI;QACP,IAAIA,KAAK,KAAK,aAAa,EACzBrD,QAAQ,CAAC,gCAAgC,EAAE,CAAC,CAAC,CAAC;QAChDa,eAAe,CAACR,oBAAoB,CAAC,CAACkC,MAAM,EAAEI,WAAW,EAAEW,CAAC,IAAI;UAC9D,IAAIA,CAAC,CAACC,MAAM,KAAK,SAAS,EAAE,OAAOD,CAAC;UACpC,MAAME,IAAI,GAAGH,KAAK,KAAK,SAAS,GAAGI,SAAS,GAAGJ,KAAK;UACpD,OAAOC,CAAC,CAACI,cAAc,KAAKF,IAAI,GAC5BF,CAAC,GACD;YAAE,GAAGA,CAAC;YAAEI,cAAc,EAAEF;UAAK,CAAC;QACpC,CAAC,CAAC;MACJ,CAAC,EACD,MAAMd,WAAW,CAAC,CAAC,CAACiB,KAAK,GAAGpB,MAAM,CAAC,EAAEgB,MAAM,KAAK,SAClD,CAAC;MACHvD,QAAQ,CAAC,0BAA0B,EAAE;QACnC4D,WAAW,EAAEb,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF,OAAO;QACjCe,WAAW,EAAEX,IAAI,CAACY,MAAM;QACxBC,YAAY,EAAEZ,WAAW;QACzBa,gBAAgB,EACdZ,eAAe,IAAIrD;MACvB,CAAC,CAAC;MACF,IAAIqD,eAAe,KAAK,QAAQ,EAAE;QAChC;QACA;QACA;QACA;QACA;QACA,MAAMa,IAAI,GAAGvB,WAAW,CAAC,CAAC,CAACiB,KAAK,GAAGpB,MAAM,CAAC;QAC1C,IAAI0B,IAAI,EAAEV,MAAM,KAAK,SAAS,EAAE;QAChC1C,eAAe,CAACR,oBAAoB,CAAC,CAACkC,MAAM,EAAEI,WAAW,EAAEW,CAAC,IAC1DA,CAAC,CAACC,MAAM,KAAK,SAAS,GAClBD,CAAC,GACD;UAAE,GAAGA,CAAC;UAAEC,MAAM,EAAE,WAAW;UAAEW,OAAO,EAAEnB,IAAI,CAACC,GAAG,CAAC;QAAE,CACvD,CAAC;QACDL,WAAW,CAACE,IAAI,IACdA,IAAI,CAACsB,mBAAmB,KAAK1B,GAAG,GAC5B;UAAE,GAAGI,IAAI;UAAEsB,mBAAmB,EAAEV;QAAU,CAAC,GAC3CZ,IACN,CAAC;QACDlC,0BAA0B,CAAC;UACzByD,KAAK,EAAE,CACL,8EAA8E3B,GAAG,EAAE,EACnF,EAAE,EACF,oGAAoG,CACrG,CAACJ,IAAI,CAAC,IAAI,CAAC;UACZgC,IAAI,EAAE;QACR,CAAC,CAAC;MACJ,CAAC,MAAM;QACL;QACA;QACA;QACA;QACA1B,WAAW,CAACE,IAAI,IAAI;UAClB,MAAMoB,IAAI,GAAGpB,IAAI,CAACc,KAAK,GAAGpB,MAAM,CAAC;UACjC,IAAI,CAAC0B,IAAI,IAAIA,IAAI,CAACV,MAAM,KAAK,SAAS,EAAE,OAAOV,IAAI;UACnD,OAAO;YACL,GAAGA,IAAI;YACPyB,sBAAsB,EAAE;cAAEpB,IAAI;cAAEV,SAAS;cAAED;YAAO;UACpD,CAAC;QACH,CAAC,CAAC;MACJ;IACF,CAAC,CAAC,OAAOgC,CAAC,EAAE;MACV;MACA;MACA;MACA,MAAMN,IAAI,GAAGvB,WAAW,CAAC,CAAC,CAACiB,KAAK,GAAGpB,MAAM,CAAC;MAC1C,IAAI0B,IAAI,EAAEV,MAAM,KAAK,SAAS,EAAE;MAChCN,MAAM,GAAG,IAAI;MACbjD,QAAQ,CAAC,wBAAwB,EAAE;QACjC4D,WAAW,EAAEb,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF,OAAO;QACjC0B,MAAM,EAAE,CAACD,CAAC,YAAYtD,kBAAkB,GACpCsD,CAAC,CAACC,MAAM,GACR,oBAAoB,KAAKzE,0DAA0D;QACvFgE,YAAY,EACVQ,CAAC,YAAYtD,kBAAkB,GAAGsD,CAAC,CAACpB,WAAW,GAAGM;MACtD,CAAC,CAAC;MACF9C,0BAA0B,CAAC;QACzByD,KAAK,EAAE,qBAAqB3D,YAAY,CAAC8D,CAAC,CAAC,gBAAgB9B,GAAG,EAAE;QAChE4B,IAAI,EAAE;MACR,CAAC,CAAC;MACF;MACA;MACA,KAAKvD,oBAAoB,CAAC0B,SAAS,CAAC,CAACiC,KAAK,CAACF,CAAC,IAC1C/D,eAAe,CAAC,6BAA6BkE,MAAM,CAACH,CAAC,CAAC,EAAE,CAC1D,CAAC;MACD5B,WAAW,CAACE,IAAI;MACd;MACA;MACAA,IAAI,CAACsB,mBAAmB,KAAK1B,GAAG,GAC5B;QAAE,GAAGI,IAAI;QAAEsB,mBAAmB,EAAEV;MAAU,CAAC,GAC3CZ,IACN,CAAC;IACH,CAAC,SAAS;MACR;MACA;MACA;MACA;MACA;MACA;MACA,IAAII,MAAM,EAAE;QACVpC,eAAe,CAACR,oBAAoB,CAAC,CAACkC,MAAM,EAAEI,WAAW,EAAEW,CAAC,IAC1DA,CAAC,CAACC,MAAM,KAAK,SAAS,GAClBD,CAAC,GACD;UAAE,GAAGA,CAAC;UAAEC,MAAM,EAAE,QAAQ;UAAEW,OAAO,EAAEnB,IAAI,CAACC,GAAG,CAAC;QAAE,CACpD,CAAC;MACH;IACF;EACF,CAAC,EAAE,CAAC;AACN;;AAEA;AACA;AACA,SAAS2B,kBAAkBA,CAACC,kBAA4B,CAAT,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC;EAChE,MAAMC,MAAM,GAAGD,kBAAkB,GAAG,GAAGlF,+BAA+B,GAAG,GAAG,EAAE;EAC9E,OAAO,GAAGE,YAAY,eAAeiF,MAAM,kCAAkC;AAC/E;AAEA,SAASC,wBAAwBA,CAACrC,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;EACrD,OAAO,GAAG7C,YAAY,2DAA2D6C,GAAG,yCAAyC7C,YAAY,iCAAiC;AAC5K;AAEA,SAASmF,yBAAyBA,CAACtC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,EAAE,MAAM,CAAC;EAClE,OAAOA,GAAG,GACN,oCAAoCA,GAAG,sDAAsD,GAC7F,qEAAqE;AAC3E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeuC,aAAaA,CACjCzC,MAAM,EAAE,MAAM,EACdC,SAAS,EAAE,MAAM,EACjBG,WAAW,EAAE,CAACC,CAAC,EAAE,CAACC,IAAI,EAAE5C,QAAQ,EAAE,GAAGA,QAAQ,EAAE,GAAG,IAAI,CACvD,EAAEgF,OAAO,CAAC,IAAI,CAAC,CAAC;EACf;EACA;EACA,MAAM7E,eAAe,CAAC8E,IAAI,CAAC3C,MAAM,EAAEI,WAAW,CAAC;EAC/CA,WAAW,CAACE,IAAI,IACdA,IAAI,CAACsB,mBAAmB,IACxBtB,IAAI,CAACyB,sBAAsB,IAC3BzB,IAAI,CAACsC,kBAAkB,GACnB;IACE,GAAGtC,IAAI;IACPsB,mBAAmB,EAAEV,SAAS;IAC9Ba,sBAAsB,EAAEb,SAAS;IACjC0B,kBAAkB,EAAE1B;EACtB,CAAC,GACDZ,IACN,CAAC;EACD,MAAMJ,GAAG,GAAG5C,mBAAmB,CAAC2C,SAAS,EAAEX,OAAO,CAACC,GAAG,CAACsD,mBAAmB,CAAC;EAC3EzE,0BAA0B,CAAC;IACzByD,KAAK,EAAE,kCAAkC3B,GAAG,EAAE;IAC9C4B,IAAI,EAAE;EACR,CAAC,CAAC;EACF1D,0BAA0B,CAAC;IACzByD,KAAK,EACH,sHAAsH;IACxHC,IAAI,EAAE,mBAAmB;IACzBgB,MAAM,EAAE;EACV,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,eAAeA,CAACC,IAAI,EAAE;EAC1CtD,KAAK,EAAE,MAAM;EACbC,QAAQ,CAAC,EAAE,MAAM;EACjBQ,WAAW,EAAE,GAAG,GAAGzC,QAAQ;EAC3B0C,WAAW,EAAE,CAACC,CAAC,EAAE,CAACC,IAAI,EAAE5C,QAAQ,EAAE,GAAGA,QAAQ,EAAE,GAAG,IAAI;EACtDuF,MAAM,EAAEC,WAAW;EACnB;EACAb,kBAAkB,CAAC,EAAE,OAAO;EAC5B;AACF;AACA;AACA;AACA;AACA;AACA;EACEc,cAAc,CAAC,EAAE,CAACC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;AACxC,CAAC,CAAC,EAAEV,OAAO,CAAC,MAAM,CAAC,CAAC;EAClB,MAAM;IACJhD,KAAK;IACLC,QAAQ;IACRQ,WAAW;IACXC,WAAW;IACX6C,MAAM;IACNZ,kBAAkB;IAClBc;EACF,CAAC,GAAGH,IAAI;EAER,MAAM;IAAEpB,mBAAmB,EAAEyB,MAAM;IAAET;EAAmB,CAAC,GAAGzC,WAAW,CAAC,CAAC;EACzE,IAAIkD,MAAM,IAAIT,kBAAkB,EAAE;IAChCnF,QAAQ,CAAC,+BAA+B,EAAE;MACxCwE,MAAM,EAAE,CAACoB,MAAM,GACX,iBAAiB,GACjB,mBAAmB,KAAK7F;IAC9B,CAAC,CAAC;IACF,OAAOgF,yBAAyB,CAACa,MAAM,CAAC;EAC1C;EAEA,IAAI,CAAC3D,KAAK,IAAI,CAACC,QAAQ,EAAE;IACvB;IACA,OAAO;IACL;IACA;IACA,iEAAiE,EACjE,gBAAgB,EAChB,EAAE,EACF,6DAA6D,EAC7D,iEAAiE,EACjE,6DAA6D,EAC7D,6CAA6C,EAC7C,kBAAkB,EAClB,EAAE,EACF,UAAUf,aAAa,EAAE,CAC1B,CAACkB,IAAI,CAAC,IAAI,CAAC;EACd;;EAEA;EACA;EACAM,WAAW,CAACE,IAAI,IACdA,IAAI,CAACsC,kBAAkB,GAAGtC,IAAI,GAAG;IAAE,GAAGA,IAAI;IAAEsC,kBAAkB,EAAE;EAAK,CACvE,CAAC;EACD,KAAKU,cAAc,CAAC;IAClB5D,KAAK;IACLC,QAAQ;IACRQ,WAAW;IACXC,WAAW;IACX6C,MAAM;IACNE;EACF,CAAC,CAAC;EACF,OAAOf,kBAAkB,CAACC,kBAAkB,CAAC;AAC/C;AAEA,eAAeiB,cAAcA,CAACN,IAAI,EAAE;EAClCtD,KAAK,EAAE,MAAM;EACbC,QAAQ,CAAC,EAAE,MAAM;EACjBQ,WAAW,EAAE,GAAG,GAAGzC,QAAQ;EAC3B0C,WAAW,EAAE,CAACC,CAAC,EAAE,CAACC,IAAI,EAAE5C,QAAQ,EAAE,GAAGA,QAAQ,EAAE,GAAG,IAAI;EACtDuF,MAAM,EAAEC,WAAW;EACnBC,cAAc,CAAC,EAAE,CAACC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;AACxC,CAAC,CAAC,EAAEV,OAAO,CAAC,IAAI,CAAC,CAAC;EAChB,MAAM;IAAEhD,KAAK;IAAEC,QAAQ;IAAEQ,WAAW;IAAEC,WAAW;IAAE6C,MAAM;IAAEE;EAAe,CAAC,GACzEH,IAAI;EACN;EACA;EACA,IAAI/C,SAAS,EAAE,MAAM,GAAG,SAAS;EACjC,IAAI;IACF,MAAMsD,KAAK,GAAG1E,iBAAiB,CAAC,CAAC;IAEjC,MAAM2E,WAAW,GAAG,MAAM7F,2BAA2B,CAAC,CAAC;IACvD,IAAI,CAAC6F,WAAW,CAACC,QAAQ,EAAE;MACzBhG,QAAQ,CAAC,+BAA+B,EAAE;QACxCwE,MAAM,EACJ,cAAc,IAAIzE,0DAA0D;QAC9EkG,mBAAmB,EAAEF,WAAW,CAACG,MAAM,CACpCC,GAAG,CAAC5B,CAAC,IAAIA,CAAC,CAAC6B,IAAI,CAAC,CAChB/D,IAAI,CACH,GACF,CAAC,IAAItC;MACT,CAAC,CAAC;MACF,MAAMsG,OAAO,GAAGN,WAAW,CAACG,MAAM,CAACC,GAAG,CAAChG,uBAAuB,CAAC,CAACkC,IAAI,CAAC,IAAI,CAAC;MAC1E1B,0BAA0B,CAAC;QACzByD,KAAK,EAAE,8CAA8CiC,OAAO,EAAE;QAC9DhC,IAAI,EAAE;MACR,CAAC,CAAC;MACF;IACF;IAEA,MAAMiC,MAAM,GAAGtE,oBAAoB,CAACC,KAAK,EAAEC,QAAQ,CAAC;IACpD,IAAIqE,aAAa,EAAE,MAAM,GAAG,SAAS;IACrC,MAAMC,OAAO,GAAG,MAAMzF,gBAAgB,CAAC;MACrC0F,cAAc,EAAEH,MAAM;MACtBI,WAAW,EAAEzE,KAAK,IAAI,mBAAmB;MACzC6D,KAAK;MACLa,cAAc,EAAE,MAAM;MACtBC,SAAS,EAAE,IAAI;MACfpB,MAAM;MACNqB,qBAAqB,EAAE,IAAI;MAC3BC,YAAY,EAAEnB,GAAG,IAAI;QACnBY,aAAa,GAAGZ,GAAG;MACrB;IACF,CAAC,CAAC;IACF,IAAI,CAACa,OAAO,EAAE;MACZxG,QAAQ,CAAC,+BAA+B,EAAE;QACxCwE,MAAM,EAAE,CAAC+B,aAAa,GAClB,aAAa,GACb,eAAe,KAAKxG;MAC1B,CAAC,CAAC;MACFY,0BAA0B,CAAC;QACzByD,KAAK,EAAE,qCAAqCmC,aAAa,GAAG,MAAMA,aAAa,EAAE,GAAG,EAAE,4BAA4B;QAClHlC,IAAI,EAAE;MACR,CAAC,CAAC;MACF;IACF;IACA7B,SAAS,GAAGgE,OAAO,CAACO,EAAE;IAEtB,MAAMtE,GAAG,GAAG5C,mBAAmB,CAAC2G,OAAO,CAACO,EAAE,EAAElF,OAAO,CAACC,GAAG,CAACsD,mBAAmB,CAAC;IAC5EzC,WAAW,CAACE,IAAI,KAAK;MACnB,GAAGA,IAAI;MACPsB,mBAAmB,EAAE1B,GAAG;MACxB0C,kBAAkB,EAAE1B;IACtB,CAAC,CAAC,CAAC;IACHiC,cAAc,GAAGZ,wBAAwB,CAACrC,GAAG,CAAC,CAAC;IAC/CzC,QAAQ,CAAC,0BAA0B,EAAE;MACnCgH,aAAa,EAAEC,OAAO,CAAC/E,QAAQ,CAAC;MAChC4D,KAAK,EACHA,KAAK,IAAI/F;IACb,CAAC,CAAC;IACF;IACA;IACA,MAAM;MAAEwC;IAAO,CAAC,GAAGjC,uBAAuB,CAAC;MACzC4G,cAAc,EAAE,WAAW;MAC3BV,OAAO,EAAE;QAAEO,EAAE,EAAEP,OAAO,CAACO,EAAE;QAAEI,KAAK,EAAElF,KAAK,IAAI;MAAY,CAAC;MACxDmF,OAAO,EAAEnF,KAAK;MACdoF,OAAO,EAAE;QACPC,eAAe,EAAE,IAAIC,eAAe,CAAC,CAAC;QACtC7E,WAAW;QACXC;MACF,CAAC;MACD6E,WAAW,EAAE;IACf,CAAC,CAAC;IACFlF,iBAAiB,CAACC,MAAM,EAAEiE,OAAO,CAACO,EAAE,EAAEtE,GAAG,EAAEC,WAAW,EAAEC,WAAW,CAAC;EACtE,CAAC,CAAC,OAAO4B,CAAC,EAAE;IACV7D,QAAQ,CAAC6D,CAAC,CAAC;IACXvE,QAAQ,CAAC,+BAA+B,EAAE;MACxCwE,MAAM,EACJ,kBAAkB,IAAIzE;IAC1B,CAAC,CAAC;IACFY,0BAA0B,CAAC;MACzByD,KAAK,EAAE,iCAAiC3D,YAAY,CAAC8D,CAAC,CAAC,EAAE;MACzDF,IAAI,EAAE;IACR,CAAC,CAAC;IACF,IAAI7B,SAAS,EAAE;MACb;MACA;MACA,KAAK1B,oBAAoB,CAAC0B,SAAS,CAAC,CAACiC,KAAK,CAACgD,GAAG,IAC5CjH,eAAe,CAAC,+CAA+C,EAAEiH,GAAG,CACtE,CAAC;MACD;MACA;MACA9E,WAAW,CAACE,IAAI,IACdA,IAAI,CAACsB,mBAAmB,GACpB;QAAE,GAAGtB,IAAI;QAAEsB,mBAAmB,EAAEV;MAAU,CAAC,GAC3CZ,IACN,CAAC;IACH;EACF,CAAC,SAAS;IACR;IACAF,WAAW,CAACE,IAAI,IACdA,IAAI,CAACsC,kBAAkB,GACnB;MAAE,GAAGtC,IAAI;MAAEsC,kBAAkB,EAAE1B;IAAU,CAAC,GAC1CZ,IACN,CAAC;EACH;AACF;AAEA,MAAM6E,IAAI,EAAEnH,mBAAmB,GAAG,MAAAmH,CAAOC,MAAM,EAAEN,OAAO,EAAEO,IAAI,KAAK;EACjE,MAAM3F,KAAK,GAAG2F,IAAI,CAACC,IAAI,CAAC,CAAC;;EAEzB;EACA,IAAI,CAAC5F,KAAK,EAAE;IACV,MAAM0D,GAAG,GAAG,MAAML,eAAe,CAAC;MAChCrD,KAAK;MACLS,WAAW,EAAE2E,OAAO,CAAC3E,WAAW;MAChCC,WAAW,EAAE0E,OAAO,CAAC1E,WAAW;MAChC6C,MAAM,EAAE6B,OAAO,CAACC,eAAe,CAAC9B;IAClC,CAAC,CAAC;IACFmC,MAAM,CAAChC,GAAG,EAAE;MAAEmC,OAAO,EAAE;IAAS,CAAC,CAAC;IAClC,OAAO,IAAI;EACb;;EAEA;EACA;EACA;EACA,MAAM;IAAE3D,mBAAmB,EAAEyB,MAAM;IAAET;EAAmB,CAAC,GACvDkC,OAAO,CAAC3E,WAAW,CAAC,CAAC;EACvB,IAAIkD,MAAM,IAAIT,kBAAkB,EAAE;IAChCnF,QAAQ,CAAC,+BAA+B,EAAE;MACxCwE,MAAM,EAAE,CAACoB,MAAM,GACX,iBAAiB,GACjB,mBAAmB,KAAK7F;IAC9B,CAAC,CAAC;IACF4H,MAAM,CAAC5C,yBAAyB,CAACa,MAAM,CAAC,EAAE;MAAEkC,OAAO,EAAE;IAAS,CAAC,CAAC;IAChE,OAAO,IAAI;EACb;;EAEA;EACA;EACA;EACAT,OAAO,CAAC1E,WAAW,CAACE,IAAI,KAAK;IAAE,GAAGA,IAAI;IAAEkF,sBAAsB,EAAE;MAAE9F;IAAM;EAAE,CAAC,CAAC,CAAC;EAC7E;EACA;EACA0F,MAAM,CAAClE,SAAS,EAAE;IAAEqE,OAAO,EAAE;EAAO,CAAC,CAAC;EACtC,OAAO,IAAI;AACb,CAAC;AAED,eAAe;EACb1B,IAAI,EAAE,WAAW;EACjB4B,IAAI,EAAE,WAAW;EACjBtB,WAAW,EAAE,6FAA6FvF,aAAa,EAAE;EACzH8G,YAAY,EAAE,UAAU;EACxBC,SAAS,EAAEA,CAAA,KAAM,UAAU,KAAK,KAAK;EACrCC,IAAI,EAAEA,CAAA,KAAMlD,OAAO,CAACmD,OAAO,CAAC;IAAEV;EAAK,CAAC;AACtC,CAAC,WAAW/H,OAAO","ignoreList":[]}

package/src/commands/upgrade/index.js

@@ -0,0 +1,12 @@
+import { getSubscriptionType } from '../../utils/auth.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+const upgrade = {
+    type: 'local-jsx',
+    name: 'upgrade',
+    description: 'Upgrade for higher rate limits and more AGI Model 7',
+    availability: ['claude-ai'],
+    isEnabled: () => !isEnvTruthy(process.env.DISABLE_UPGRADE_COMMAND) &&
+        getSubscriptionType() !== 'enterprise',
+    load: () => import('./upgrade.js'),
+};
+export default upgrade;