scalemax 0.1.48 → 0.1.50

package/README.md

@@ -78,6 +78,7 @@ scalemax doctor       Run diagnostics
 scalemax models       List available ScaleMax models
 scalemax helper-bot   Open the ScaleMax-only support assistant
 scalemax claude-tools Install bounded GitHub skill tools for Claude
+scalemax fix-roo      Fix Roo Code stuck at "API Request…" on recent VS Code
 scalemax update       Reconfigure detected clients with the stored key
 scalemax remove       Remove ScaleMax-generated client configuration
 scalemax --help       Show help
@@ -150,11 +151,11 @@ For clients without a stable official config file, the installer writes a ScaleM
 
 ### Codex
 
-ScaleMax configures the official Codex custom-provider interface in `~/.codex/config.toml` with `wire_api = "responses"`, and stores the selected key in Codex's private `~/.codex/auth.json`. Detection is semantic: unrelated or ChatGPT-authenticated Codex files are not reported as ScaleMax-configured. Only authenticated Codex/OpenAI-family models are eligible, the generated files are private, and verification performs a minimal `/v1/responses` request before reporting success.
+ScaleMax configures the official Codex custom-provider interface in `~/.codex/config.toml` with `wire_api = "responses"`, and stores the selected key in Codex's private `~/.codex/auth.json`. Detection is semantic: unrelated or ChatGPT-authenticated Codex files are not reported as ScaleMax-configured. Only GPT models from the authenticated catalog are eligible (`gpt-5.6-terra` first, or `auto` on an Auto key); a key with no GPT model is told so and Codex is left unchanged. The generated files are private, and verification performs a minimal `/v1/responses` request before reporting success.
 
 ### Claude Code
 
-ScaleMax updates `~/.claude/settings.json` with `ANTHROPIC_BASE_URL=https://api.scalemax.pro`, gateway model discovery, and a cached `apiKeyHelper` that reads a private `~/.claude/scalemax.key` file. The raw key is not stored in the settings JSON. Because Claude Code's gateway discovery only accepts IDs beginning with `claude` or `anthropic`, catalogs that include Fable or Auto also receive a managed custom picker entry (`ANTHROPIC_CUSTOM_MODEL_OPTION=fable-5` or `auto`, with friendly names and descriptions), making `/model fable-5` and `/model auto` selectable; any prior custom picker values are restored when ScaleMax configuration is removed. The Anthropic base URL intentionally has no `/v1` suffix because Claude Code adds `/v1/messages` itself. The CLI preserves unrelated settings, selects a live main model from the authenticated catalog (preferring `claude-opus-5`), pins authenticated Haiku for lightweight background work when available, and sets `CLAUDE_CODE_DISABLE_THINKING=1` because third-party Anthropic-compatible providers do not support Claude Code's proprietary extended-thinking control envelope. The ScaleMax gateway separately locks native Claude requests to provider-side `low` effort. Fable uses its verified translated controls and supports `low`, `medium`, `high`, and `max`, with `low` as the default. Haiku 4.5 omits the unsupported effort field. It verifies a one-token Messages request and, if verification fails, removes only the ScaleMax-managed changes. Claude Code picker aliases such as `claude-opus-5[1m]` are normalized by the gateway.
+ScaleMax updates `~/.claude/settings.json` with `ANTHROPIC_BASE_URL=https://api.scalemax.pro`, gateway model discovery, and a cached `apiKeyHelper` that reads a private `~/.claude/scalemax.key` file. The raw key is not stored in the settings JSON. Because Claude Code's gateway discovery only accepts IDs beginning with `claude` or `anthropic`, catalogs that include Fable or Auto also receive a managed custom picker entry (`ANTHROPIC_CUSTOM_MODEL_OPTION=fable-5` or `auto`, with friendly names and descriptions), making `/model fable-5` and `/model auto` selectable; any prior custom picker values are restored when ScaleMax configuration is removed. The Anthropic base URL intentionally has no `/v1` suffix because Claude Code adds `/v1/messages` itself. The CLI preserves unrelated settings and selects the main model from the key's own Claude models (Opus 5.5, then Opus 5, Sonnet 5.5, Sonnet 5, older Claude; never the `claude-sonnet-4-6` Claude Desktop alias or another provider's model). The background model (`ANTHROPIC_DEFAULT_HAIKU_MODEL`) is Haiku when the key lists it, otherwise the cheapest Claude it lists, so Claude Code never falls back to a Haiku id the key cannot use. The picker entry prefers an image-capable model; Fable 5.1 is labelled text only. The CLI does not write `CLAUDE_CODE_DISABLE_THINKING`: the ScaleMax gateway strips Claude Code's `thinking` control itself and locks native Claude requests to provider-side `low` effort. Fable uses its verified translated controls and supports `low`, `medium`, `high`, and `max`, with `low` as the default. Haiku 4.5 omits the unsupported effort field. It verifies a one-token Messages request and, if verification fails, removes only the ScaleMax-managed changes. Claude Code picker aliases such as `claude-opus-5[1m]` are normalized by the gateway.
 
 ### OpenCode
 
@@ -170,7 +171,9 @@ ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and
 
 ### Roo Code (VS Code)
 
-Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex, Claude, and tool-capable DeepSeek profiles remain separate. DeepSeek is offered only when authenticated discovery reports `capabilities.tools=true`; otherwise Roo fails closed and points the user to Continue Chat/Edit. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex, Claude, and tool-capable DeepSeek profiles remain separate; the Codex profile is a GPT model on OpenAI keys and a strong Local model on Local Models keys, never the `claude-sonnet-4-6` alias, and every profile asks for at most 32,768 output tokens. DeepSeek is offered only when authenticated discovery reports `capabilities.tools=true`; otherwise Roo fails closed and points the user to Continue Chat/Edit. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+
+Roo Code 3.54 (its latest release) looks for ripgrep only in folders newer VS Code releases no longer use, so on recent VS Code versions every task hangs at "API Request…" with "Could not find ripgrep binary". Configuring Roo Code also patches the installed extension's `dist/extension.js` (in the editor's per-user extensions folder, never the VS Code app) so it tries `node_modules.asar.unpacked/@vscode/ripgrep-universal/bin/<platform>-<arch>/` first and then its original folders. The untouched file is kept once as `extension.js.scalemax-orig`. Run `npx scalemax@latest fix-roo` to apply only this fix (VS Code, Insiders, Cursor, Windsurf, VSCodium, Trae, Kiro, and remote servers), `scalemax fix-roo --undo` to restore the original, and reload VS Code afterwards. `scalemax doctor` flags installs that still need it.
 
 ### Cline (CLI and VS Code)
 

package/dist/commands/configure.d.ts

@@ -3,6 +3,8 @@ import { ClientId, ConfigureResult } from '../types/client.js';
 export declare function detectAll(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function printDetected(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function clientAllowedForModels(clientId: ClientId, models: ModelInfo[]): boolean;
+/** Why a detected client is not offered for this key, when the reason is worth saying. */
+export declare function clientUnavailableReason(clientId: ClientId, models: ModelInfo[]): string | undefined;
 export declare function rollbackAfterVerificationFailure(result: ConfigureResult, error: unknown): Promise<never>;
 export declare function configureCommand(opts?: {
     all?: boolean;

package/dist/commands/configure.js

@@ -4,9 +4,10 @@ import ora from 'ora';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
-import { validateApiKey, isAnthropicModel, isModelRouteAvailable, AUTO_MODEL_ID, probeWorkingModels, pinClaudeAliasBackend, claudeAliasBackendPinTarget } from '../utils/api.js';
+import { validateApiKey, isAnthropicModel, isChatModel, isModelRouteAvailable, AUTO_MODEL_ID, probeWorkingModels } from '../utils/api.js';
+import { saveModelCheck } from '../utils/modelCheck.js';
 import { homeDir } from '../utils/paths.js';
-import { isExactChatCompletionsModelId } from '../configure/models.js';
+import { CLAUDE_CODE_NEEDS_CLAUDE_MESSAGE, CODEX_NEEDS_GPT_MESSAGE, codexModelIds, defaultModelIdsFor, isExactChatCompletionsModelId, modelIdKey } from '../configure/models.js';
 import { isContinueEligibleModelId } from '../configure/continue.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
@@ -57,10 +58,12 @@ async function maybeLaunchCodex(chosen, successful, baseUrl = SCALEMAX_BASE_URL)
  * for "did Anthropic make this."
  */
 function reachableByClaudeCode(model) {
-    return isAnthropicModel(model) || model.id === AUTO_MODEL_ID;
+    return isAnthropicModel(model) || modelIdKey(model.id) === AUTO_MODEL_ID;
 }
 export function clientAllowedForModels(clientId, models) {
-    models = models.filter(isModelRouteAvailable);
+    // Image, video, embedding and voice rows share the catalog; an image model
+    // owned by `scalemax` must not make Codex look usable on a Claude-only key.
+    models = models.filter(model => isModelRouteAvailable(model) && isChatModel(model));
     if (!models.length)
         return false;
     // These clients use either a native family-specific adapter or the gateway's
@@ -72,8 +75,11 @@ export function clientAllowedForModels(clientId, models) {
         return models.some(model => isContinueEligibleModelId(model.id));
     if (clientId === 'claude')
         return models.some(reachableByClaudeCode);
+    // Codex runs on GPT models only (and on Auto for an Auto key). A Claude id,
+    // the `claude-sonnet-4-6` alias, DeepSeek or a free preview model failed
+    // every Codex request it was configured with.
     if (clientId === 'codex')
-        return models.some(model => !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id));
+        return codexModelIds({ models }).length > 0 || models.some(model => modelIdKey(model.id) === AUTO_MODEL_ID);
     if (clientId === 'hermes' && models.every(model => isExactChatCompletionsModelId(model.id)))
         return models.some(model => model.capabilities?.tools === true);
     // Roo is an agent, not a text-only chat surface. Its task loop depends on
@@ -85,6 +91,16 @@ export function clientAllowedForModels(clientId, models) {
         return true;
     return models.some(model => !isAnthropicModel(model));
 }
+/** Why a detected client is not offered for this key, when the reason is worth saying. */
+export function clientUnavailableReason(clientId, models) {
+    if (clientAllowedForModels(clientId, models))
+        return undefined;
+    if (clientId === 'codex')
+        return CODEX_NEEDS_GPT_MESSAGE.replace('was not set up', 'is not offered');
+    if (clientId === 'claude')
+        return CLAUDE_CODE_NEEDS_CLAUDE_MESSAGE.replace('was not set up', 'is not offered');
+    return undefined;
+}
 export async function rollbackAfterVerificationFailure(result, error) {
     if (!result.changed)
         throw error;
@@ -131,27 +147,17 @@ export async function configureCommand(opts = {}) {
         throw new Error(keyInfo.error || 'ScaleMax returned no models for this API key. No client configuration was changed.');
     const providerScope = keyInfo.key?.provider_scope || 'both';
     const selectedBaseUrl = keyInfo.baseUrl || SCALEMAX_BASE_URL;
-    // LIVE-PROBE the key's models with a small request and keep only the ones
-    // that actually answer, so a client is configured with working models and
-    // defaults to a working one. Bounded (concurrency + total time); if nothing
-    // probes clean we KEEP the entitlement-filtered list rather than fail — a
-    // slow/degraded upstream must not leave the user with zero models.
-    try {
-        const probeSpinner = ora('Checking which models respond').start();
-        const probe = await probeWorkingModels({ apiKey, baseUrl: selectedBaseUrl, models: keyInfo.models, providerScope });
-        if (probe.models.length && !probe.fallback) {
-            keyInfo.models = probe.models;
-            probeSpinner.succeed(`${probe.models.length}/${probe.probedCount} models responded`);
-        }
-        else {
-            probeSpinner.warn(probe.warning || 'No model answered the probe in time; using the full authenticated catalog');
-        }
-    }
-    catch { /* probing is best-effort; never blocks setup */ }
     const availableClients = clients.filter(c => clientAllowedForModels(c.id, keyInfo.models));
     console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Clients are filtered against the authenticated model catalog.`));
     const detections = await printDetected(home);
     const detectedIds = new Set(detections.filter(d => d.installed).map(d => d.id));
+    for (const client of clients) {
+        if (!detectedIds.has(client.id))
+            continue;
+        const reason = clientUnavailableReason(client.id, keyInfo.models);
+        if (reason)
+            console.log(chalk.yellow(`${client.name}: ${reason}`));
+    }
     let chosen;
     if (opts.all)
         chosen = availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id);
@@ -170,6 +176,35 @@ export async function configureCommand(opts = {}) {
         console.log(chalk.yellow('No detected clients to configure.'));
         return;
     }
+    // Check, with one small request each, the models setup is about to write
+    // as defaults for the chosen and detected clients. A default that fails is
+    // skipped (the next pick for that slot is checked instead); every entitled
+    // model stays in the lists written to clients. Bounded in count and time,
+    // and if nothing answers nothing is skipped: a slow upstream or an empty
+    // balance must not leave a client with no model.
+    let avoidModelIds = [];
+    const probeClients = [...new Set([...chosen, ...availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id)])];
+    try {
+        const probeSpinner = ora('Checking the default models (one small request each)').start();
+        const probe = await probeWorkingModels({
+            apiKey,
+            baseUrl: selectedBaseUrl,
+            models: keyInfo.models,
+            providerScope,
+            targets: models => defaultModelIdsFor({ models, providerScope }, probeClients),
+        });
+        if (probe.fallback)
+            probeSpinner.warn(probe.warning || 'No default model answered in time; nothing was skipped.');
+        else if (probe.failedIds.length) {
+            avoidModelIds = probe.failedIds;
+            probeSpinner.warn(`${probe.workingCount}/${probe.probedCount} default models answered; skipped ${probe.failedIds.join(', ')} for now`);
+        }
+        else
+            probeSpinner.succeed(`${probe.workingCount}/${probe.probedCount} default models answered`);
+        // doctor reads this so it expects the same defaults setup wrote.
+        await saveModelCheck(home, apiKey, avoidModelIds).catch(() => undefined);
+    }
+    catch { /* checking is best-effort; never blocks setup */ }
     const successful = new Set();
     const failures = [];
     for (const client of availableClients.filter(c => chosen.includes(c.id))) {
@@ -206,9 +241,11 @@ export async function configureCommand(opts = {}) {
         }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const ctx = { ...baseCtx, apiKey, baseUrl: selectedBaseUrl, providerScope, models: keyInfo.models, interactive: Boolean(process.stdin.isTTY), allowAppModification };
+            const ctx = { ...baseCtx, apiKey, baseUrl: selectedBaseUrl, providerScope, models: keyInfo.models, avoidModelIds, interactive: Boolean(process.stdin.isTTY), allowAppModification };
             const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
+            if (res.note)
+                console.log(chalk.dim(`  ${res.note}`));
             if (client.verify) {
                 const verify = ora(`Verifying ${client.name}`).start();
                 try {
@@ -231,21 +268,6 @@ export async function configureCommand(opts = {}) {
             failures.push(`${client.name}: ${message}`);
         }
     }
-    // Pin the working default as this key's `claude-sonnet-4-6` backend so Claude
-    // Desktop (which always sends that id) routes to a model this key can serve.
-    // Best-effort: an older gateway without the endpoint, or a scope that already
-    // has a fixed default, is skipped silently. Never fails the run.
-    if (successful.size > 0) {
-        const target = claudeAliasBackendPinTarget(keyInfo.models);
-        if (target) {
-            try {
-                const pin = await pinClaudeAliasBackend({ apiKey, baseUrl: selectedBaseUrl, model: target });
-                if (pin.ok && !pin.skipped)
-                    console.log(chalk.dim(`Claude Desktop's claude-sonnet-4-6 now routes to ${target} on this key.`));
-            }
-            catch { /* endpoint absent or transient; ignore */ }
-        }
-    }
     if (opts.promptLaunch !== false && !opts.all && process.stdin.isTTY)
         await maybeLaunchCodex(chosen, successful, selectedBaseUrl);
     if (failures.length)

package/dist/commands/doctor.d.ts

@@ -1 +1,8 @@
+/**
+ * Roo Code 3.54 cannot find newer VS Code's relocated ripgrep, so every task
+ * hangs at "API Request…". Read-only: reports installs that still need
+ * `scalemax fix-roo`. A warning, not a failure, because older VS Code builds
+ * still work unpatched.
+ */
+export declare function rooRipgrepDoctorLines(home: string): Promise<string[]>;
 export declare function doctorCommand(home?: string): Promise<void>;

package/dist/commands/doctor.js

@@ -3,13 +3,42 @@ import ora from 'ora';
 import { detectAll } from './configure.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey, testStreaming } from '../utils/api.js';
+import { claudeCodeBackgroundModel, fastChatCompletionsModel, preferredChatCompletionsModel } from '../configure/models.js';
+import { loadModelCheck } from '../utils/modelCheck.js';
 import { homeDir } from '../utils/paths.js';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
+import { repairRooRipgrep, rooInstallLabel } from '../repair/roo-ripgrep.js';
+/**
+ * Roo Code 3.54 cannot find newer VS Code's relocated ripgrep, so every task
+ * hangs at "API Request…". Read-only: reports installs that still need
+ * `scalemax fix-roo`. A warning, not a failure, because older VS Code builds
+ * still work unpatched.
+ */
+export async function rooRipgrepDoctorLines(home) {
+    const results = await repairRooRipgrep(home, { dryRun: true });
+    return results.map(result => {
+        const label = rooInstallLabel(result);
+        if (result.status === 'patched')
+            return `${chalk.yellow('!')} ${label} cannot find ripgrep on recent VS Code, so tasks hang at "API Request…". Run ${chalk.bold('npx scalemax@latest fix-roo')}, then Developer: Reload Window.`;
+        if (result.status === 'already_patched')
+            return `${chalk.green('✓')} ${label} ripgrep fix for newer VS Code applied`;
+        if (result.status === 'unsupported')
+            return `${chalk.dim('•')} ${label} ripgrep lookup not recognised; fix-roo not needed`;
+        return `${chalk.yellow('!')} ${label} could not be checked for the ripgrep fix: ${result.error}`;
+    });
+}
 export async function doctorCommand(home = homeDir()) {
     let failures = 0;
     const key = await loadApiKey(home);
     let models = [];
+    let baseUrl = SCALEMAX_BASE_URL;
+    // Setup passes the key's scope to every client (Roo writes its profiles by
+    // scope); without it doctor expected a different Roo profile set.
+    let providerScope;
+    // The models setup's live check skipped, so each client is checked against
+    // the same defaults setup wrote (configure/models.ts picks them).
+    const avoidModelIds = key ? await loadModelCheck(home, key) : [];
     if (!key) {
         console.log(`${chalk.red('✗')} API key missing`);
         failures++;
@@ -18,11 +47,24 @@ export async function doctorCommand(home = homeDir()) {
         const s = ora('Checking API key and models').start();
         const res = await validateApiKey(key);
         models = res.models;
+        baseUrl = res.baseUrl || SCALEMAX_BASE_URL;
+        providerScope = res.key?.provider_scope;
         if (res.ok && models.length) {
             s.succeed(`API reachable, key valid, ${models.length} models loaded`);
             console.log(`${chalk.green('✓')} Usage and key metadata accessible through the authenticated API`);
             const st = ora('Checking streaming (small billable request)').start();
-            const stream = await testStreaming(key, models.find(m => m.id === 'fable-5')?.id || models[0]?.id, res.baseUrl);
+            // Stream a cheap chat default: the catalog also lists image, video and
+            // embedding rows (which /chat/completions 404s) and lists the
+            // claude-sonnet-4-6 alias first.
+            const catalog = { models, avoidModelIds };
+            let streamModel;
+            try {
+                streamModel = fastChatCompletionsModel(catalog) || claudeCodeBackgroundModel(catalog) || preferredChatCompletionsModel(catalog);
+            }
+            catch {
+                streamModel = undefined;
+            }
+            const stream = await testStreaming(key, streamModel, baseUrl);
             if (stream.ok)
                 st.succeed('Streaming available');
             else {
@@ -49,8 +91,7 @@ export async function doctorCommand(home = homeDir()) {
         }
         if (client.verify && key && models.length) {
             try {
-                const checked = await validateApiKey(key);
-                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl: checked.baseUrl || SCALEMAX_BASE_URL, models });
+                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl, providerScope, models, avoidModelIds });
                 console.log(`${chalk.green('✓')} ${client.name} ${v.message}`);
             }
             catch (error) {
@@ -61,6 +102,8 @@ export async function doctorCommand(home = homeDir()) {
         else
             console.log(`${chalk.green('✓')} ${client.name} configured (${d.reason || 'detector confirmed'})`);
     }
+    for (const line of await rooRipgrepDoctorLines(home))
+        console.log(line);
     console.log('');
     if (failures === 0)
         console.log(chalk.green('Everything looks good!'));

package/dist/commands/fix-roo.d.ts

@@ -0,0 +1 @@
+export declare function fixRooCommand(args?: readonly string[], home?: string): Promise<void>;

package/dist/commands/fix-roo.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import { repairRooRipgrep, restoreRooRipgrep, rooInstallLabel } from '../repair/roo-ripgrep.js';
+import { homeDir } from '../utils/paths.js';
+const RELOAD_HINT = 'Reload VS Code (Developer: Reload Window) so Roo Code picks up the fix.';
+export async function fixRooCommand(args = [], home = homeDir()) {
+    if (args.includes('--undo'))
+        return undoFixRoo(home);
+    const results = await repairRooRipgrep(home);
+    if (!results.length) {
+        console.log(chalk.yellow('! Roo Code is not installed in VS Code or a VS Code-based editor on this computer. Nothing to fix.'));
+        return;
+    }
+    console.log(chalk.dim(`Found ${results.length} Roo Code installation${results.length === 1 ? '' : 's'}.`));
+    let failures = 0;
+    for (const result of results) {
+        const label = rooInstallLabel(result);
+        if (result.status === 'patched') {
+            console.log(chalk.green(`✓ ${label}: patched — it now finds newer VS Code's ripgrep.`));
+            console.log(chalk.dim(`  Original saved as ${result.backup}`));
+        }
+        else if (result.status === 'already_patched') {
+            console.log(chalk.green(`✓ ${label}: already patched.`));
+        }
+        else if (result.status === 'unsupported') {
+            console.log(chalk.yellow(`! ${label}: ripgrep lookup not recognised; left unchanged (this version may not need the fix).`));
+        }
+        else {
+            failures++;
+            console.log(chalk.red(`✗ ${label}: could not patch ${result.script}: ${result.error}`));
+        }
+    }
+    if (results.some(result => result.status === 'patched' || result.status === 'already_patched'))
+        console.log(`\n${RELOAD_HINT}`);
+    if (failures)
+        throw new Error(`${failures} Roo Code installation${failures === 1 ? '' : 's'} could not be patched. Close VS Code and run \`npx scalemax@latest fix-roo\` again.`);
+}
+async function undoFixRoo(home) {
+    const results = await restoreRooRipgrep(home);
+    if (!results.length) {
+        console.log(chalk.yellow('! Roo Code is not installed in VS Code or a VS Code-based editor on this computer. Nothing to undo.'));
+        return;
+    }
+    let failures = 0;
+    for (const result of results) {
+        const label = rooInstallLabel(result);
+        if (result.status === 'restored')
+            console.log(chalk.green(`✓ ${label}: original extension restored.`));
+        else if (result.status === 'not_patched')
+            console.log(chalk.dim(`• ${label}: not patched; nothing to undo.`));
+        else {
+            failures++;
+            const reason = result.status === 'no_backup'
+                ? `no ScaleMax backup found next to ${result.script}`
+                : result.status === 'mismatch'
+                    ? `the extension changed after it was patched, so the backup at ${result.backup} was not applied`
+                    : result.error;
+            console.log(chalk.red(`✗ ${label}: ${reason}. Reinstall Roo Code to get a clean copy.`));
+        }
+    }
+    if (results.some(result => result.status === 'restored'))
+        console.log('\nReload VS Code (Developer: Reload Window) so Roo Code loads the original files.');
+    if (failures)
+        throw new Error(`${failures} Roo Code installation${failures === 1 ? '' : 's'} could not be restored.`);
+}

package/dist/commands/helper-bot.js

@@ -4,15 +4,16 @@ import { createInterface } from 'node:readline/promises';
 import { execa } from 'execa';
 import { clients } from '../clients.js';
 import { helperDocsContext } from './helper-docs.js';
-import { rollbackAfterVerificationFailure } from './configure.js';
-import { createChatCompletion, filterModelsForScope, isAnthropicModel } from '../utils/api.js';
+import { clientAllowedForModels, rollbackAfterVerificationFailure } from './configure.js';
+import { loadModelCheck } from '../utils/modelCheck.js';
+import { createChatCompletion, filterModelsForScope, isAnthropicModel, isChatModel } from '../utils/api.js';
 import { redactApiKey } from '../utils/apiKey.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
 import { validateApiKey } from '../utils/api.js';
 import { commandExists } from '../utils/exec.js';
 import { installClaudeGithubTools } from '../configure/claude-tools.js';
-import { isExactChatCompletionsModelId } from '../configure/models.js';
+import { CODEX_NEEDS_GPT_MESSAGE, isExactChatCompletionsModelId, modelIdKey, sameModelId } from '../configure/models.js';
 import { isContinueEligibleModelId } from '../configure/continue.js';
 export const SCALEMAX_HELPER_REFUSAL = `I am the official ScaleMax Helper.
 
@@ -708,21 +709,25 @@ codex
     return undefined;
 }
 export function selectHelperModel(models, requested) {
+    // The helper talks over /chat/completions: never pick an image, video,
+    // embedding or voice row. Ids match in any `[1m]` spelling.
+    const chat = models.filter(isChatModel);
     if (requested) {
-        const exact = models.find(model => model.id.toLowerCase() === requested.toLowerCase());
+        const exact = chat.find(model => model.id.trim().toLowerCase() === requested.trim().toLowerCase())
+            || chat.find(model => sameModelId(model.id, requested));
         if (!exact)
             throw new Error(`Model "${requested}" is not available to this API key. Run \`scalemax models\` to see available models.`);
         return exact.id;
     }
     const preferred = ['gpt-5.6-luna', 'claude-haiku-4-5-20251001', 'fable-5', 'gpt-5.6-terra', 'gpt-5.6-sol'];
     for (const id of preferred) {
-        const match = models.find(model => model.id.toLowerCase() === id);
+        const match = chat.find(model => sameModelId(model.id, id));
         if (match)
             return match.id;
     }
-    if (!models[0])
+    if (!chat[0])
         throw new Error('No ScaleMax model is available to this API key.');
-    return models[0].id;
+    return chat[0].id;
 }
 export async function requestHelperReply(question, history, connection, complete = createChatCompletion) {
     const cleanQuestion = redactHelperSecrets(question.trim(), connection.apiKey);
@@ -832,6 +837,19 @@ function requestedProviderScope(question, target) {
         return 'openai';
     return undefined;
 }
+/**
+ * The GPT/Codex family. The live catalog publishes those models under the
+ * `scalemax` owner (not `openai`, which now labels only embedding rows), so
+ * the owner alone matched no chat model at all.
+ */
+function isOpenAiFamilyModel(model) {
+    const family = String(model.provider || model.owned_by || '').trim().toLowerCase();
+    if (family === 'openai')
+        return true;
+    if (family === 'scalemax')
+        return /^(gpt-|codex-)/i.test(modelIdKey(model.id));
+    return !family && !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id);
+}
 function actionModels(connection, requestedScope) {
     const rawCatalog = connection.modelCatalog?.length
         ? connection.modelCatalog
@@ -840,7 +858,9 @@ function actionModels(connection, requestedScope) {
     // The authenticated catalog already includes reseller and extra-family
     // grants. Validate the primary scope, then narrow only for explicit user
     // intent; never try to reconstruct effective entitlement client-side.
-    const catalog = filterModelsForScope(rawCatalog, entitlement);
+    // Client actions configure chat clients only; image, video, embedding and
+    // voice rows would otherwise be written into them as chat models.
+    const catalog = filterModelsForScope(rawCatalog, entitlement).filter(isChatModel);
     if (!requestedScope || requestedScope === 'reseller' || requestedScope === 'local')
         return catalog;
     const exactModelByScope = {
@@ -851,19 +871,14 @@ function actionModels(connection, requestedScope) {
     };
     const exactModel = exactModelByScope[requestedScope];
     if (exactModel)
-        return catalog.filter(model => model.id.trim().toLowerCase() === exactModel);
+        return catalog.filter(model => modelIdKey(model.id) === exactModel);
     if (requestedScope === 'both') {
-        return catalog.filter(model => isAnthropicModel(model)
-            || String(model.provider || model.owned_by || '').trim().toLowerCase() === 'openai');
+        return catalog.filter(model => isAnthropicModel(model) || isOpenAiFamilyModel(model));
     }
     if (requestedScope === 'anthropic')
         return catalog.filter(isAnthropicModel);
-    if (requestedScope === 'openai') {
-        return catalog.filter(model => {
-            const family = String(model.provider || model.owned_by || '').trim().toLowerCase();
-            return family ? family === 'openai' : !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id);
-        });
-    }
+    if (requestedScope === 'openai')
+        return catalog.filter(isOpenAiFamilyModel);
     return catalog.filter(model => String(model.provider || model.owned_by || '').trim().toLowerCase() === requestedScope);
 }
 function helperClientAllowedForModels(clientId, models) {
@@ -968,8 +983,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
     const models = actionModels(connection, requestedScope);
     if (!models.length)
         throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : requestedScope === 'deepseek-v4-flash' ? 'DeepSeek V4 Flash' : requestedScope === 'glm-5.2' ? 'GLM 5.2' : 'compatible'} models for ${client.name}. No configuration was changed.`);
-    if (client.id === 'codex' && models.every(model => isAnthropicModel(model) || isExactChatCompletionsModelId(model.id)))
-        throw new Error('Codex requires a Responses-capable model, but this key exposes only Claude or Chat-Completions-only models. No configuration was changed.');
+    if (client.id === 'codex' && !clientAllowedForModels('codex', models))
+        throw new Error(`${CODEX_NEEDS_GPT_MESSAGE} No configuration was changed.`);
     if (client.id === 'cursor' && connection.platform !== 'darwin')
         throw new Error(`Automatic Cursor configuration is currently verified on macOS only. ${helperPlatformName(connection.platform)} was not modified.`);
     const ctx = {
@@ -980,6 +995,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
         baseUrl: connection.baseUrl,
         providerScope: connection.providerScope || 'both',
         models,
+        // The same defaults setup and doctor use for this key.
+        avoidModelIds: await loadModelCheck(home, connection.apiKey).catch(() => []),
         interactive: false,
         allowAppModification: false
     };
@@ -1020,6 +1037,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
     write(`→ Configuring ${client.name} with the authenticated stored key…`);
     const configured = await client.configure(ctx);
     write(`✓ ${client.name} ${configured.message}`);
+    if (configured.note)
+        write(`  ${configured.note}`);
     if (client.verify) {
         write(`→ Verifying ${client.name} configuration…`);
         try {

package/dist/commands/helper-docs.js

@@ -23,6 +23,12 @@ export const HELPER_DOC_SECTIONS = [
         keywords: ['roo', 'roo code', 'vscode', 'vs code', 'extension', 'visual studio code', 'deepseek'],
         content: `For Roo Code, the ScaleMax CLI writes a private settings import file at ~/.scalemax/roo-code-import.json and sets roo-cline.autoImportSettingsPath in VS Code User settings. Roo imports that profile after VS Code is reloaded. A DeepSeek V4 Flash profile is offered only when the authenticated catalog reports capabilities.tools=true. If the active route is text-only, Roo fails closed because its task loop requires tools and the helper recommends Continue Chat/Edit instead. The CLI can install the official Roo Code extension with code --install-extension RooVeterinaryInc.roo-cline when VS Code is detected. On Windows, helper-bot may install VS Code first with winget using the fixed Microsoft.VisualStudioCode package id, then install Roo, write the import handoff, and verify the files.`
     },
+    {
+        id: 'roo-code-ripgrep',
+        title: 'Roo Code stuck at API Request on recent VS Code versions',
+        keywords: ['ripgrep', 'stuck', 'hang', 'hangs', 'hanging', 'frozen', 'fix-roo'],
+        content: `Roo Code 3.54, its latest release, looks for VS Code's bundled ripgrep only in folders newer VS Code releases moved to node_modules.asar.unpacked/@vscode/ripgrep-universal/bin/<platform>-<arch>/, so on recent VS Code versions every Roo task hangs at "API Request..." with "Could not find ripgrep binary", whatever the model or provider; the ScaleMax key is fine. Fix: run npx scalemax@latest fix-roo, then Developer: Reload Window. It patches only the installed Roo Code extension in the home folder, keeps the original as extension.js.scalemax-orig, never changes the VS Code app, and fix-roo --undo restores it. Configuring Roo Code with the CLI applies the same fix and scalemax doctor reports installs that still need it. Alternatives: copy rg from that folder to <VS Code app>/resources/app/node_modules/@vscode/ripgrep/bin/ (removed by every VS Code update), or use Cline or Kilo Code.`
+    },
     {
         id: 'continue-deepseek',
         title: 'Continue setup for DeepSeek V4 Flash',

package/dist/configure/api-code.js

@@ -4,12 +4,12 @@ import { jsonConfig } from './templates.js';
 const id = 'api-code';
 const name = 'API Code';
 export async function configure(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { environment: { SCALEMAX_API_KEY: 'your ScaleMax API key', SCALEMAX_BASE_URL: ctx.baseUrl }, node: `import OpenAI from 'openai';\nconst client = new OpenAI({ apiKey: process.env.SCALEMAX_API_KEY, baseURL: '${ctx.baseUrl}' });`, python: `from openai import OpenAI\nclient = OpenAI(api_key='...', base_url='${ctx.baseUrl}')` });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'API code examples written' };
 }
 export async function remove(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     return removeManagedConfig(ctx, id, name, file);
 }