thaddeus 1.0.26 → 1.0.28

package/src/utils/errors.js

@@ -0,0 +1,207 @@
+import { APIUserAbortError } from '@anthropic-ai/sdk';
+export class ClaudeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+export class MalformedCommandError extends Error {
+}
+export class AbortError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AbortError';
+    }
+}
+/**
+ * True iff `e` is any of the abort-shaped errors the codebase encounters:
+ * our AbortError class, a DOMException from AbortController.abort()
+ * (.name === 'AbortError'), or the SDK's APIUserAbortError. The SDK class
+ * is checked via instanceof because minified builds mangle class names —
+ * constructor.name becomes something like 'nJT' and the SDK never sets
+ * this.name, so string matching silently fails in production.
+ */
+export function isAbortError(e) {
+    return (e instanceof AbortError ||
+        e instanceof APIUserAbortError ||
+        (e instanceof Error && e.name === 'AbortError'));
+}
+/**
+ * Custom error class for configuration file parsing errors
+ * Includes the file path and the default configuration that should be used
+ */
+export class ConfigParseError extends Error {
+    filePath;
+    defaultConfig;
+    constructor(message, filePath, defaultConfig) {
+        super(message);
+        this.name = 'ConfigParseError';
+        this.filePath = filePath;
+        this.defaultConfig = defaultConfig;
+    }
+}
+export class ShellError extends Error {
+    stdout;
+    stderr;
+    code;
+    interrupted;
+    constructor(stdout, stderr, code, interrupted) {
+        super('Shell command failed');
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.code = code;
+        this.interrupted = interrupted;
+        this.name = 'ShellError';
+    }
+}
+export class TeleportOperationError extends Error {
+    formattedMessage;
+    constructor(message, formattedMessage) {
+        super(message);
+        this.formattedMessage = formattedMessage;
+        this.name = 'TeleportOperationError';
+    }
+}
+/**
+ * Error with a message that is safe to log to telemetry.
+ * Use the long name to confirm you've verified the message contains no
+ * sensitive data (file paths, URLs, code snippets).
+ *
+ * Single-arg: same message for user and telemetry
+ * Two-arg: different messages (e.g., full message has file path, telemetry doesn't)
+ *
+ * @example
+ * // Same message for both
+ * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
+ *   'MCP server "slack" connection timed out'
+ * )
+ *
+ * // Different messages
+ * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
+ *   `MCP tool timed out after ${ms}ms`,  // Full message for logs/user
+ *   'MCP tool timed out'                  // Telemetry message
+ * )
+ */
+export class TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends Error {
+    telemetryMessage;
+    constructor(message, telemetryMessage) {
+        super(message);
+        this.name = 'TelemetrySafeError';
+        this.telemetryMessage = telemetryMessage ?? message;
+    }
+}
+export function hasExactErrorMessage(error, message) {
+    return error instanceof Error && error.message === message;
+}
+/**
+ * Normalize an unknown value into an Error.
+ * Use at catch-site boundaries when you need an Error instance.
+ */
+export function toError(e) {
+    return e instanceof Error ? e : new Error(String(e));
+}
+/**
+ * Extract a string message from an unknown error-like value.
+ * Use when you only need the message (e.g., for logging or display).
+ */
+export function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/**
+ * Extract the errno code (e.g., 'ENOENT', 'EACCES') from a caught error.
+ * Returns undefined if the error has no code or is not an ErrnoException.
+ * Replaces the `(e as NodeJS.ErrnoException).code` cast pattern.
+ */
+export function getErrnoCode(e) {
+    if (e && typeof e === 'object' && 'code' in e && typeof e.code === 'string') {
+        return e.code;
+    }
+    return undefined;
+}
+/**
+ * True if the error is ENOENT (file or directory does not exist).
+ * Replaces `(e as NodeJS.ErrnoException).code === 'ENOENT'`.
+ */
+export function isENOENT(e) {
+    return getErrnoCode(e) === 'ENOENT';
+}
+/**
+ * Extract the errno path (the filesystem path that triggered the error)
+ * from a caught error. Returns undefined if the error has no path.
+ * Replaces the `(e as NodeJS.ErrnoException).path` cast pattern.
+ */
+export function getErrnoPath(e) {
+    if (e && typeof e === 'object' && 'path' in e && typeof e.path === 'string') {
+        return e.path;
+    }
+    return undefined;
+}
+/**
+ * Extract error message + top N stack frames from an unknown error.
+ * Use when the error flows to the model as a tool_result — full stack
+ * traces are ~500-2000 chars of mostly-irrelevant internal frames and
+ * waste context tokens. Keep the full stack in debug logs instead.
+ */
+export function shortErrorStack(e, maxFrames = 5) {
+    if (!(e instanceof Error))
+        return String(e);
+    if (!e.stack)
+        return e.message;
+    // V8/Bun stack format: "Name: message\n    at frame1\n    at frame2..."
+    // First line is the message; subsequent "    at " lines are frames.
+    const lines = e.stack.split('\n');
+    const header = lines[0] ?? e.message;
+    const frames = lines.slice(1).filter(l => l.trim().startsWith('at '));
+    if (frames.length <= maxFrames)
+        return e.stack;
+    return [header, ...frames.slice(0, maxFrames)].join('\n');
+}
+/**
+ * True if the error means the path is missing, inaccessible, or
+ * structurally unreachable — use in catch blocks after fs operations to
+ * distinguish expected "nothing there / no access" from unexpected errors.
+ *
+ * Covers:
+ *  ENOENT    — path does not exist
+ *  EACCES    — permission denied
+ *  EPERM     — operation not permitted
+ *  ENOTDIR   — a path component is not a directory (e.g. a file named
+ *              `.claude` exists where a directory is expected)
+ *  ELOOP     — too many symlink levels (circular symlinks)
+ */
+export function isFsInaccessible(e) {
+    const code = getErrnoCode(e);
+    return (code === 'ENOENT' ||
+        code === 'EACCES' ||
+        code === 'EPERM' ||
+        code === 'ENOTDIR' ||
+        code === 'ELOOP');
+}
+/**
+ * Classify a caught error from an axios request into one of a few buckets.
+ * Replaces the ~20-line isAxiosError → 401/403 → ECONNABORTED → ECONNREFUSED
+ * chain duplicated across sync-style services (settingsSync, policyLimits,
+ * remoteManagedSettings, teamMemorySync).
+ *
+ * Checks the `.isAxiosError` marker property directly (same as
+ * axios.isAxiosError()) to keep this module dependency-free.
+ */
+export function classifyAxiosError(e) {
+    const message = errorMessage(e);
+    if (!e ||
+        typeof e !== 'object' ||
+        !('isAxiosError' in e) ||
+        !e.isAxiosError) {
+        return { kind: 'other', message };
+    }
+    const err = e;
+    const status = err.response?.status;
+    if (status === 401 || status === 403)
+        return { kind: 'auth', status, message };
+    if (err.code === 'ECONNABORTED')
+        return { kind: 'timeout', status, message };
+    if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+        return { kind: 'network', status, message };
+    }
+    return { kind: 'http', status, message };
+}

package/src/utils/exampleCommands.js

@@ -0,0 +1,165 @@
+import memoize from 'lodash-es/memoize.js';
+import sample from 'lodash-es/sample.js';
+import { getCwd } from '../utils/cwd.js';
+import { getCurrentProjectConfig, saveCurrentProjectConfig } from './config.js';
+import { env } from './env.js';
+import { execFileNoThrowWithCwd } from './execFileNoThrow.js';
+import { getIsGit, gitExe } from './git.js';
+import { logError } from './log.js';
+import { getGitEmail } from './user.js';
+// Patterns that mark a file as non-core (auto-generated, dependency, or config).
+// Used to filter example-command filename suggestions deterministically
+// instead of shelling out to Haiku.
+const NON_CORE_PATTERNS = [
+    // lock / dependency manifests
+    /(?:^|\/)(?:package-lock\.json|yarn\.lock|bun\.lock|bun\.lockb|pnpm-lock\.yaml|Pipfile\.lock|poetry\.lock|Cargo\.lock|Gemfile\.lock|go\.sum|composer\.lock|uv\.lock)$/,
+    // generated / build artifacts
+    /\.generated\./,
+    /(?:^|\/)(?:dist|build|out|target|node_modules|\.next|__pycache__)\//,
+    /\.(?:min\.js|min\.css|map|pyc|pyo)$/,
+    // data / docs / config extensions (not "write a test for" material)
+    /\.(?:json|ya?ml|toml|xml|ini|cfg|conf|env|lock|txt|md|mdx|rst|csv|log|svg)$/i,
+    // configuration / metadata
+    /(?:^|\/)\.?(?:eslintrc|prettierrc|babelrc|editorconfig|gitignore|gitattributes|dockerignore|npmrc)/,
+    /(?:^|\/)(?:tsconfig|jsconfig|biome|vitest\.config|jest\.config|webpack\.config|vite\.config|rollup\.config)\.[a-z]+$/,
+    /(?:^|\/)\.(?:github|vscode|idea|claude)\//,
+    // docs / changelogs (not "how does X work" material)
+    /(?:^|\/)(?:CHANGELOG|LICENSE|CONTRIBUTING|CODEOWNERS|README)(?:\.[a-z]+)?$/i,
+];
+function isCoreFile(path) {
+    return !NON_CORE_PATTERNS.some(p => p.test(path));
+}
+/**
+ * Counts occurrences of items in an array and returns the top N items
+ * sorted by count in descending order, formatted as a string.
+ */
+export function countAndSortItems(items, topN = 20) {
+    const counts = new Map();
+    for (const item of items) {
+        counts.set(item, (counts.get(item) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN)
+        .map(([item, count]) => `${count.toString().padStart(6)} ${item}`)
+        .join('\n');
+}
+/**
+ * Picks up to `want` basenames from a frequency-sorted list of paths,
+ * skipping non-core files and spreading across different directories.
+ * Returns empty array if fewer than `want` core files are available.
+ */
+export function pickDiverseCoreFiles(sortedPaths, want) {
+    const picked = [];
+    const seenBasenames = new Set();
+    const dirTally = new Map();
+    // Greedy: on each pass allow +1 file per directory. Keeps the
+    // top-5 from collapsing into a single hot folder while still
+    // letting a dominant folder contribute multiple files if the
+    // repo is narrow.
+    for (let cap = 1; picked.length < want && cap <= want; cap++) {
+        for (const p of sortedPaths) {
+            if (picked.length >= want)
+                break;
+            if (!isCoreFile(p))
+                continue;
+            const lastSep = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+            const base = lastSep >= 0 ? p.slice(lastSep + 1) : p;
+            if (!base || seenBasenames.has(base))
+                continue;
+            const dir = lastSep >= 0 ? p.slice(0, lastSep) : '.';
+            if ((dirTally.get(dir) ?? 0) >= cap)
+                continue;
+            picked.push(base);
+            seenBasenames.add(base);
+            dirTally.set(dir, (dirTally.get(dir) ?? 0) + 1);
+        }
+    }
+    return picked.length >= want ? picked : [];
+}
+async function getFrequentlyModifiedFiles() {
+    if (process.env.NODE_ENV === 'test')
+        return [];
+    if (env.platform === 'win32')
+        return [];
+    if (!(await getIsGit()))
+        return [];
+    try {
+        // Collect frequently-modified files, preferring the user's own commits.
+        const userEmail = await getGitEmail();
+        const logArgs = [
+            'log',
+            '-n',
+            '1000',
+            '--pretty=format:',
+            '--name-only',
+            '--diff-filter=M',
+        ];
+        const counts = new Map();
+        const tallyInto = (stdout) => {
+            for (const line of stdout.split('\n')) {
+                const f = line.trim();
+                if (f)
+                    counts.set(f, (counts.get(f) ?? 0) + 1);
+            }
+        };
+        if (userEmail) {
+            const { stdout } = await execFileNoThrowWithCwd('git', [...logArgs, `--author=${userEmail}`], { cwd: getCwd() });
+            tallyInto(stdout);
+        }
+        // Fall back to all authors if the user's own history is thin.
+        if (counts.size < 10) {
+            const { stdout } = await execFileNoThrowWithCwd(gitExe(), logArgs, {
+                cwd: getCwd(),
+            });
+            tallyInto(stdout);
+        }
+        const sorted = Array.from(counts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .map(([p]) => p);
+        return pickDiverseCoreFiles(sorted, 5);
+    }
+    catch (err) {
+        logError(err);
+        return [];
+    }
+}
+const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
+export const getExampleCommandFromCache = memoize(() => {
+    const projectConfig = getCurrentProjectConfig();
+    const frequentFile = projectConfig.exampleFiles?.length
+        ? sample(projectConfig.exampleFiles)
+        : '<filepath>';
+    const commands = [
+        'fix lint errors',
+        'fix typecheck errors',
+        `how does ${frequentFile} work?`,
+        `refactor ${frequentFile}`,
+        'how do I log an error?',
+        `edit ${frequentFile} to...`,
+        `write a test for ${frequentFile}`,
+        'create a util logging.py that...',
+    ];
+    return `Try "${sample(commands)}"`;
+});
+export const refreshExampleCommands = memoize(async () => {
+    const projectConfig = getCurrentProjectConfig();
+    const now = Date.now();
+    const lastGenerated = projectConfig.exampleFilesGeneratedAt ?? 0;
+    // Regenerate examples if they're over a week old
+    if (now - lastGenerated > ONE_WEEK_IN_MS) {
+        projectConfig.exampleFiles = [];
+    }
+    // If no example files cached, kickstart fetch in background
+    if (!projectConfig.exampleFiles?.length) {
+        void getFrequentlyModifiedFiles().then(files => {
+            if (files.length) {
+                saveCurrentProjectConfig(current => ({
+                    ...current,
+                    exampleFiles: files,
+                    exampleFilesGeneratedAt: Date.now(),
+                }));
+            }
+        });
+    }
+});

package/src/utils/execFileNoThrow.js

@@ -0,0 +1,93 @@
+// This file represents useful wrappers over node:child_process
+// These wrappers ease error handling and cross-platform compatbility
+// By using execa, Windows automatically gets shell escaping + BAT / CMD handling
+import { execa } from 'execa';
+import { getCwd } from '../utils/cwd.js';
+import { logError } from './log.js';
+export { execSyncWithDefaults_DEPRECATED } from './execFileNoThrowPortable.js';
+const MS_IN_SECOND = 1000;
+const SECONDS_IN_MINUTE = 60;
+export function execFileNoThrow(file, args, options = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    useCwd: true,
+}) {
+    return execFileNoThrowWithCwd(file, args, {
+        abortSignal: options.abortSignal,
+        timeout: options.timeout,
+        preserveOutputOnError: options.preserveOutputOnError,
+        cwd: options.useCwd ? getCwd() : undefined,
+        env: options.env,
+        stdin: options.stdin,
+        input: options.input,
+    });
+}
+/**
+ * Extracts a human-readable error message from an execa result.
+ *
+ * Priority order:
+ * 1. shortMessage - execa's human-readable error (e.g., "Command failed with exit code 1: ...")
+ *    This is preferred because it already includes signal info when a process is killed,
+ *    making it more informative than just the signal name.
+ * 2. signal - the signal that killed the process (e.g., "SIGTERM")
+ * 3. errorCode - fallback to just the numeric exit code
+ */
+function getErrorMessage(result, errorCode) {
+    if (result.shortMessage) {
+        return result.shortMessage;
+    }
+    if (typeof result.signal === 'string') {
+        return result.signal;
+    }
+    return String(errorCode);
+}
+/**
+ * execFile, but always resolves (never throws)
+ */
+export function execFileNoThrowWithCwd(file, args, { abortSignal, timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, preserveOutputOnError: finalPreserveOutput = true, cwd: finalCwd, env: finalEnv, maxBuffer, shell, stdin: finalStdin, input: finalInput, } = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    maxBuffer: 1_000_000,
+}) {
+    return new Promise(resolve => {
+        // Use execa for cross-platform .bat/.cmd compatibility on Windows
+        execa(file, args, {
+            maxBuffer,
+            signal: abortSignal,
+            timeout: finalTimeout,
+            cwd: finalCwd,
+            env: finalEnv,
+            shell,
+            stdin: finalStdin,
+            input: finalInput,
+            reject: false, // Don't throw on non-zero exit codes
+        })
+            .then(result => {
+            if (result.failed) {
+                if (finalPreserveOutput) {
+                    const errorCode = result.exitCode ?? 1;
+                    void resolve({
+                        stdout: result.stdout || '',
+                        stderr: result.stderr || '',
+                        code: errorCode,
+                        error: getErrorMessage(result, errorCode),
+                    });
+                }
+                else {
+                    void resolve({ stdout: '', stderr: '', code: result.exitCode ?? 1 });
+                }
+            }
+            else {
+                void resolve({
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    code: 0,
+                });
+            }
+        })
+            .catch((error) => {
+            logError(error);
+            void resolve({ stdout: '', stderr: '', code: 1 });
+        });
+    });
+}

package/src/utils/execFileNoThrowPortable.js

@@ -0,0 +1,49 @@
+import { execaSync } from 'execa';
+import { getCwd } from '../utils/cwd.js';
+import { slowLogging } from './slowOperations.js';
+const MS_IN_SECOND = 1000;
+const SECONDS_IN_MINUTE = 60;
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(command, optionsOrAbortSignal, timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND) {
+    let options;
+    if (optionsOrAbortSignal === undefined) {
+        // No second argument - use defaults
+        options = {};
+    }
+    else if (optionsOrAbortSignal instanceof AbortSignal) {
+        // Old signature - second argument is AbortSignal
+        options = {
+            abortSignal: optionsOrAbortSignal,
+            timeout,
+        };
+    }
+    else {
+        // New signature - second argument is options object
+        options = optionsOrAbortSignal;
+    }
+    const { abortSignal, timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, input, stdio = ['ignore', 'pipe', 'pipe'], } = options;
+    abortSignal?.throwIfAborted();
+    using _ = slowLogging `exec: ${command.slice(0, 200)}`;
+    try {
+        const result = execaSync(command, {
+            env: process.env,
+            maxBuffer: 1_000_000,
+            timeout: finalTimeout,
+            cwd: getCwd(),
+            stdio,
+            shell: true, // execSync typically runs shell commands
+            reject: false, // Don't throw on non-zero exit codes
+            input,
+        });
+        if (!result.stdout) {
+            return null;
+        }
+        return result.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/src/utils/execSyncWrapper.js

@@ -0,0 +1,6 @@
+import { execSync as nodeExecSync, } from 'child_process';
+import { slowLogging } from './slowOperations.js';
+export function execSync_DEPRECATED(command, options) {
+    using _ = slowLogging `execSync: ${command.slice(0, 100)}`;
+    return nodeExecSync(command, options);
+}

package/src/utils/exportRenderer.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useRef } from 'react';
+import stripAnsi from 'strip-ansi';
+import { Messages } from '../components/Messages.js';
+import { KeybindingProvider } from '../keybindings/KeybindingContext.js';
+import { loadKeybindingsSyncWithWarnings } from '../keybindings/loadUserBindings.js';
+import { AppStateProvider } from '../state/AppState.js';
+import { renderToAnsiString } from './staticRender.js';
+/**
+ * Minimal keybinding provider for static/headless renders.
+ * Provides keybinding context without the ChordInterceptor (which uses useInput
+ * and would hang in headless renders with no stdin).
+ */
+function StaticKeybindingProvider({ children }) {
+    const { bindings } = loadKeybindingsSyncWithWarnings();
+    const pendingChordRef = useRef(null);
+    const handlerRegistryRef = useRef(new Map());
+    const activeContexts = useRef(new Set()).current;
+    return _jsx(KeybindingProvider, { bindings: bindings, pendingChordRef: pendingChordRef, pendingChord: null, setPendingChord: () => { }, activeContexts: activeContexts, registerActiveContext: () => { }, unregisterActiveContext: () => { }, handlerRegistryRef: handlerRegistryRef, children: children });
+}
+// Upper-bound how many NormalizedMessages a Message can produce.
+// normalizeMessages splits one Message with N content blocks into N
+// NormalizedMessages — 1:1 with block count. String content = 1 block.
+// AttachmentMessage etc. have no .message and normalize to ≤1.
+function normalizedUpperBound(m) {
+    if (!('message' in m))
+        return 1;
+    const c = m.message.content;
+    return Array.isArray(c) ? c.length : 1;
+}
+/**
+ * Streams rendered messages in chunks, ANSI codes preserved. Each chunk is a
+ * fresh renderToAnsiString — yoga layout tree + Ink's screen buffer are sized
+ * to the tallest CHUNK instead of the full session. Measured (Mar 2026,
+ * 538-msg session): −55% plateau RSS vs a single full render. The sink owns
+ * the output — write to stdout for `[` dump-to-scrollback, appendFile for `v`.
+ *
+ * Messages.renderRange slices AFTER normalize→group→collapse, so tool-call
+ * grouping stays correct across chunk seams; buildMessageLookups runs on
+ * the full normalized array so tool_use↔tool_result resolves regardless of
+ * which chunk each landed in.
+ */
+export async function streamRenderedMessages(messages, tools, sink, { columns, verbose = false, chunkSize = 40, onProgress } = {}) {
+    const renderChunk = (range) => renderToAnsiString(_jsx(AppStateProvider, { children: _jsx(StaticKeybindingProvider, { children: _jsx(Messages, { messages: messages, tools: tools, commands: [], verbose: verbose, toolJSX: null, toolUseConfirmQueue: [], inProgressToolUseIDs: new Set(), isMessageSelectorVisible: false, conversationId: "export", screen: "prompt", streamingToolUses: [], showAllInTranscript: true, isLoading: false, renderRange: range }) }) }), columns);
+    // renderRange indexes into the post-collapse array whose length we can't
+    // see from here — normalize splits each Message into one NormalizedMessage
+    // per content block (unbounded per message), collapse merges some back.
+    // Ceiling is the exact normalize output count + chunkSize so the loop
+    // always reaches the empty slice where break fires (collapse only shrinks).
+    let ceiling = chunkSize;
+    for (const m of messages)
+        ceiling += normalizedUpperBound(m);
+    for (let offset = 0; offset < ceiling; offset += chunkSize) {
+        const ansi = await renderChunk([offset, offset + chunkSize]);
+        if (stripAnsi(ansi).trim() === '')
+            break;
+        await sink(ansi);
+        onProgress?.(offset + chunkSize);
+    }
+}
+/**
+ * Renders messages to a plain text string suitable for export.
+ * Uses the same React rendering logic as the interactive UI.
+ */
+export async function renderMessagesToPlainText(messages, tools = [], columns) {
+    const parts = [];
+    await streamRenderedMessages(messages, tools, chunk => void parts.push(stripAnsi(chunk)), {
+        columns
+    });
+    return parts.join('');
+}

package/src/utils/extraUsage.js

@@ -0,0 +1,19 @@
+import { isClaudeAISubscriber } from './auth.js';
+import { has1mContext } from './context.js';
+export function isBilledAsExtraUsage(model, isFastMode, isOpus1mMerged) {
+    if (!isClaudeAISubscriber())
+        return false;
+    if (isFastMode)
+        return true;
+    if (model === null || !has1mContext(model))
+        return false;
+    const m = model
+        .toLowerCase()
+        .replace(/\[1m\]$/, '')
+        .trim();
+    const isOpus46 = m === 'opus' || m.includes('opus-4-6');
+    const isSonnet46 = m === 'sonnet' || m.includes('sonnet-4-6');
+    if (isOpus46 && isOpus1mMerged)
+        return false;
+    return isOpus46 || isSonnet46;
+}