scalemax 0.1.45 → 0.1.48

package/dist/commands/configure.js

@@ -221,6 +221,9 @@ export async function configureCommand(opts = {}) {
                 }
             }
             successful.add(client.id);
+            // Only after verification: a rolled-back client gets no usage advice.
+            if (res.tip)
+                console.log(chalk.cyan(`  Tip: ${res.tip}`));
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

package/dist/commands/helper-bot.js

@@ -714,7 +714,7 @@ export function selectHelperModel(models, requested) {
             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.4', 'gpt-5.4-mini', 'claude-haiku-4-5-20251001', 'fable-5', 'gpt-5.6-terra', 'gpt-5.6-sol'];
+    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);
         if (match)
@@ -1049,7 +1049,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
         : client.id === 'cline'
             ? ' Restart Cline; reload VS Code too when using the extension.'
             : client.id === 'continue' ? ' Reload VS Code once so Continue loads the verified ScaleMax profile.' : '';
-    return `✅ Successfully completed: ${client.name} is configured and locally verified.${activation}`;
+    const tip = configured.tip ? ` Tip: ${configured.tip}` : '';
+    return `✅ Successfully completed: ${client.name} is configured and locally verified.${activation}${tip}`;
 }
 /** Execute only narrowly allowlisted ScaleMax client actions; never model-generated shell commands. */
 export async function executeHelperAction(question, connection, home, clientCatalog = clients, write = message => console.log(message)) {

package/dist/configure/cline.d.ts

@@ -1,4 +1,10 @@
 import { ConfigureContext, ConfigureResult, DetectContext, InstallContext, RemoveContext } from '../types/client.js';
+/**
+ * Printed after every successful configure. Cline only edits files and carries
+ * out a task in Act mode; Plan mode explores and plans, which customers read as
+ * a broken key. Same advice as the docs' Cline guide and troubleshooting page.
+ */
+export declare const CLINE_MODE_TIP = "Switch Cline to Act mode to let it edit files and run the task. Plan mode only reads and plans; nothing is wrong with your key.";
 export interface ClineExtensionSurface {
     path: string;
     version?: string;

package/dist/configure/cline.js

@@ -16,6 +16,12 @@ const extensionId = 'saoudrizwan.claude-dev';
 const cliProviderId = 'openai-native';
 const legacyProviderId = 'scalemax';
 const extensionCredentialHashKey = 'scalemaxManagedOpenAiApiKeySha256';
+/**
+ * Printed after every successful configure. Cline only edits files and carries
+ * out a task in Act mode; Plan mode explores and plans, which customers read as
+ * a broken key. Same advice as the docs' Cline guide and troubleshooting page.
+ */
+export const CLINE_MODE_TIP = 'Switch Cline to Act mode to let it edit files and run the task. Plan mode only reads and plans; nothing is wrong with your key.';
 function credentialSha256(value) {
     return crypto.createHash('sha256').update(value, 'utf8').digest('hex');
 }
@@ -518,6 +524,7 @@ export async function configure(ctx) {
             changed: false,
             path: configuredPaths[0],
             message: 'verified Cline configuration is already current',
+            tip: CLINE_MODE_TIP,
         };
     }
     let snapshots;
@@ -541,6 +548,7 @@ export async function configure(ctx) {
         changed: true,
         path: configuredPaths[0],
         message: `configured ${surfaces.cliSupported ? `CLI ${cliVersion}` : ''}${surfaces.cliSupported && surfaces.extensionSupported ? ' and ' : ''}${surfaces.extensionSupported ? `VS Code extension ${extensionVersion}` : ''} with one raw ScaleMax credential; restart Cline to activate`,
+        tip: CLINE_MODE_TIP,
         rollback,
     };
 }

package/dist/configure/codex.d.ts

@@ -6,7 +6,23 @@ export interface CodexVerificationResult {
     configPath: string;
     authPath: string;
 }
-export declare function mergeCodexConfig(existing: string, baseUrl: string, model?: string, authHash?: string): string;
+export declare function mergeCodexConfig(existing: string, baseUrl: string, model?: string, authHash?: string, keyHash?: string): string;
+/**
+ * Take ScaleMax OUT of a config.toml, keeping everything else the user has --
+ * including what Codex or the user added after setup (trusted projects,
+ * notices, other providers).
+ *
+ * Ownership is read from the CONTENT, not only from the generated header: a
+ * Codex rewrite that drops comments still leaves `model_provider = "scalemax"`
+ * and the `[model_providers.scalemax]` table, and those must go. The three
+ * top-level keys are removed only while ScaleMax is still the provider; if the
+ * user switched provider after setup they are the user's.
+ */
+export declare function stripScaleMaxCodexConfig(existing: string): {
+    text: string;
+    found: boolean;
+    strippedTopLevel: boolean;
+};
 export declare function verifyCodexConfiguration(ctx: ConfigureContext): Promise<CodexVerificationResult>;
 export declare function install(ctx: InstallContext): Promise<ConfigureResult>;
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/codex.js

@@ -10,17 +10,29 @@ import { AUTO_MODEL_ID, preferredOpenAiResponsesModel } from './models.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
-const fallbackModel = 'gpt-5.5';
+const fallbackModel = 'gpt-5.6-luna'; // gpt-5.5 retired 2026-09-30; same price
 const reasoningEffort = 'medium';
 const managedAuthHashPrefix = '# ScaleMax managed auth.json SHA-256: ';
+// Fingerprint of the API key setup wrote into auth.json. Unlike the auth.json
+// hash above it survives Codex rewriting auth.json (a token refresh, its own
+// serialisation), so remove() can still tell OUR key from one the user put
+// there later.
+const managedKeyHashPrefix = '# ScaleMax managed API key SHA-256: ';
+const modelsComment = '# ScaleMax models are loaded from the authenticated live model catalog.';
+// The top-level keys setup owns while ScaleMax is the provider. remove() puts
+// the user's pre-ScaleMax values for exactly these back from the backup.
+const managedTopLevelKey = /^(model|model_provider|model_reasoning_effort)\s*=/;
 function contentSha256(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
-function managedAuthHash(config) {
-    const marker = config.split(/\r?\n/).find(line => line.startsWith(managedAuthHashPrefix));
-    const hash = marker?.slice(managedAuthHashPrefix.length).trim();
+function markerHash(config, prefix) {
+    const marker = config.split(/\r?\n/).find(line => line.startsWith(prefix));
+    const hash = marker?.slice(prefix.length).trim();
     return hash && /^[a-f0-9]{64}$/.test(hash) ? hash : undefined;
 }
+function managedAuthHash(config) {
+    return markerHash(config, managedAuthHashPrefix);
+}
 function selectedModel(ctx) {
     if (!ctx.models) {
         // An auto-api key's ONLY model is `auto`; gpt-5.5 (the generic fallback
@@ -30,11 +42,22 @@ function selectedModel(ctx) {
     }
     return preferredOpenAiResponsesModel(ctx);
 }
-function scalemaxCodexBlock(baseUrl, model = fallbackModel, authHash) {
+function scalemaxCodexBlock(baseUrl, model = fallbackModel, authHash, keyHash) {
     const authMarker = authHash ? `${managedAuthHashPrefix}${authHash}\n` : '';
-    return `# ${GENERATED_HEADER}\n${authMarker}model = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n# ScaleMax models are loaded from the authenticated live model catalog.\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+    const keyMarker = keyHash ? `${managedKeyHashPrefix}${keyHash}\n` : '';
+    return `# ${GENERATED_HEADER}\n${authMarker}${keyMarker}model = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n${modelsComment}\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+}
+/** A line setup writes as a comment. Never user content, and never preserved. */
+function isManagedCommentLine(line) {
+    return line === `# ${GENERATED_HEADER}`
+        || line === modelsComment
+        || line.startsWith(managedAuthHashPrefix)
+        || line.startsWith(managedKeyHashPrefix);
 }
-export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authHash) {
+function isScaleMaxProviderSection(section) {
+    return section === `model_providers.${provider}` || section.startsWith(`model_providers.${provider}.`);
+}
+export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authHash, keyHash) {
     const preserved = [];
     let section = '';
     let skipScaleMaxProvider = false;
@@ -43,20 +66,94 @@ export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authH
         const sectionMatch = line.match(/^\[([^\]]+)\]$/);
         if (sectionMatch) {
             section = sectionMatch[1];
-            skipScaleMaxProvider = section === `model_providers.${provider}`;
+            skipScaleMaxProvider = isScaleMaxProviderSection(section);
             if (skipScaleMaxProvider)
                 continue;
         }
         if (skipScaleMaxProvider)
             continue;
-        if (!section && /^(model|model_provider|model_reasoning_effort)\s*=/.test(line))
+        if (!section && managedTopLevelKey.test(line))
             continue;
-        if (line === `# ${GENERATED_HEADER}` || line.startsWith(managedAuthHashPrefix))
+        // Includes the models comment: it used to be kept here, so every re-run of
+        // setup stacked one more copy of it into the preserved tail.
+        if (isManagedCommentLine(line))
             continue;
         preserved.push(raw);
     }
     const tail = preserved.join('\n').trim();
-    return `${scalemaxCodexBlock(baseUrl, model, authHash)}${tail ? `\n${tail}\n` : ''}`;
+    return `${scalemaxCodexBlock(baseUrl, model, authHash, keyHash)}${tail ? `\n${tail}\n` : ''}`;
+}
+/**
+ * Take ScaleMax OUT of a config.toml, keeping everything else the user has --
+ * including what Codex or the user added after setup (trusted projects,
+ * notices, other providers).
+ *
+ * Ownership is read from the CONTENT, not only from the generated header: a
+ * Codex rewrite that drops comments still leaves `model_provider = "scalemax"`
+ * and the `[model_providers.scalemax]` table, and those must go. The three
+ * top-level keys are removed only while ScaleMax is still the provider; if the
+ * user switched provider after setup they are the user's.
+ */
+export function stripScaleMaxCodexConfig(existing) {
+    const lines = existing.split(/\r?\n/);
+    let section = '';
+    let topProvider;
+    let found = false;
+    for (const raw of lines) {
+        const line = raw.trim();
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            if (isScaleMaxProviderSection(section))
+                found = true;
+            continue;
+        }
+        if (isManagedCommentLine(line))
+            found = true;
+        if (!section) {
+            const providerMatch = line.match(/^model_provider\s*=\s*"([^"]*)"/);
+            if (providerMatch)
+                topProvider = providerMatch[1];
+        }
+    }
+    const strippedTopLevel = topProvider === provider;
+    if (strippedTopLevel)
+        found = true;
+    if (!found)
+        return { text: existing, found: false, strippedTopLevel: false };
+    const kept = [];
+    section = '';
+    let skip = false;
+    for (const raw of lines) {
+        const line = raw.trim();
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            skip = isScaleMaxProviderSection(section);
+            if (skip)
+                continue;
+        }
+        if (skip)
+            continue;
+        if (!section && strippedTopLevel && managedTopLevelKey.test(line))
+            continue;
+        if (isManagedCommentLine(line))
+            continue;
+        kept.push(raw);
+    }
+    return { text: kept.join('\n').trim(), found: true, strippedTopLevel };
+}
+/** The pre-ScaleMax top-level model / model_provider / model_reasoning_effort lines of a backup. */
+function originalTopLevelLines(backup) {
+    const out = [];
+    for (const raw of backup.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (/^\[[^\]]+\]$/.test(line))
+            break;
+        if (managedTopLevelKey.test(line))
+            out.push(line);
+    }
+    return out;
 }
 function codexAuth(apiKey, existing = {}) {
     return JSON.stringify({ ...existing, auth_mode: 'apikey', OPENAI_API_KEY: apiKey }, null, 2) + '\n';
@@ -111,22 +208,99 @@ async function latestRestorableBackup(file, home) {
     }
     return undefined;
 }
-async function restoreOrRemove(file, ctx, managedOverride) {
+async function removeCodexConfig(file, ctx) {
     if (!(await fs.pathExists(file)))
         return { changed: false, message: 'no ScaleMax configuration found' };
     const current = await fs.readFile(file, 'utf8').catch(() => '');
-    const structurallyManaged = current.includes(GENERATED_HEADER)
-        || (file.endsWith('auth.json') && isManagedCodexAuth(current));
-    const managed = managedOverride ?? structurallyManaged;
-    if (!managed)
+    const stripped = stripScaleMaxCodexConfig(current);
+    if (!stripped.found)
+        return { changed: false, message: 'left unmanaged configuration unchanged' };
+    // Put back the user's own model settings from before setup (the first
+    // pre-ScaleMax backup) -- only when ScaleMax's were actually taken out.
+    let restoredTop = [];
+    if (stripped.strippedTopLevel) {
+        const backup = await latestRestorableBackup(file, ctx.home);
+        if (backup)
+            restoredTop = originalTopLevelLines(await fs.readFile(backup, 'utf8').catch(() => ''));
+    }
+    const next = [restoredTop.join('\n'), stripped.text].filter(Boolean).join('\n\n');
+    if (!next.trim()) {
+        await fs.remove(file);
+        return { changed: true, message: 'removed ScaleMax configuration' };
+    }
+    await atomicWrite(file, `${next}\n`, 0o600, ctx.platform);
+    return {
+        changed: true,
+        message: restoredTop.length
+            ? 'removed ScaleMax settings and restored your previous model settings'
+            : 'removed ScaleMax settings; your other settings were kept',
+    };
+}
+/**
+ * Take the ScaleMax credential OUT of auth.json.
+ *
+ * Owned when ANY of: the file is byte-identical to what setup wrote (auth
+ * hash marker); its key is the key the CLI has saved; its key matches the
+ * key fingerprint setup wrote into config.toml. The last two survive Codex
+ * rewriting the file -- a ChatGPT token refresh or its own serialisation --
+ * which the exact hash alone did not, and which left the ScaleMax key in
+ * place after "remove". A DIFFERENT key the user put there after setup is
+ * none of these, and is left alone.
+ *
+ * Only the two fields setup sets are touched: auth_mode and OPENAI_API_KEY go
+ * back to their pre-setup values from the backup, or away if there were none.
+ * Tokens and refresh times stay as Codex last wrote them (they are fresher
+ * than the backup). A file left with nothing in it is deleted.
+ */
+async function removeCodexAuth(file, ctx, ownership) {
+    if (!(await fs.pathExists(file)))
+        return { changed: false, message: 'no ScaleMax configuration found' };
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    let current;
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('not an object');
+        current = parsed;
+    }
+    catch {
         return { changed: false, message: 'left unmanaged configuration unchanged' };
-    const restore = await latestRestorableBackup(file, ctx.home);
-    if (restore) {
-        await atomicWrite(file, await fs.readFile(restore, 'utf8'), 0o600, ctx.platform);
-        return { changed: true, message: `restored backup ${restore}` };
     }
-    await fs.remove(file);
-    return { changed: true, message: 'removed ScaleMax configuration' };
+    const key = typeof current.OPENAI_API_KEY === 'string' ? current.OPENAI_API_KEY : undefined;
+    const owned = (ownership.authHash !== undefined && contentSha256(text) === ownership.authHash)
+        || (key !== undefined && typeof ctx.apiKey === 'string' && ctx.apiKey.length > 0 && key === ctx.apiKey)
+        || (key !== undefined && ownership.keyHash !== undefined && contentSha256(key) === ownership.keyHash)
+        || (ownership.authHash === undefined && ownership.keyHash === undefined && ownership.legacyStructural && isManagedCodexAuth(text));
+    if (!owned)
+        return { changed: false, message: 'left unmanaged configuration unchanged' };
+    let original;
+    const backup = await latestRestorableBackup(file, ctx.home);
+    if (backup) {
+        try {
+            const parsed = JSON.parse(await fs.readFile(backup, 'utf8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                original = parsed;
+        }
+        catch { /* an unreadable backup restores nothing */ }
+    }
+    const next = { ...current };
+    for (const field of ['auth_mode', 'OPENAI_API_KEY']) {
+        if (original && Object.prototype.hasOwnProperty.call(original, field))
+            next[field] = original[field];
+        else
+            delete next[field];
+    }
+    const meaningful = Object.values(next).some(value => value !== null && value !== undefined
+        && !(typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0));
+    if (!original && !meaningful) {
+        await fs.remove(file);
+        return { changed: true, message: 'removed ScaleMax configuration' };
+    }
+    await atomicWrite(file, JSON.stringify(next, null, 2) + '\n', 0o600, ctx.platform);
+    return {
+        changed: true,
+        message: original ? 'removed the ScaleMax key and restored your previous sign-in' : 'removed the ScaleMax key',
+    };
 }
 export async function verifyCodexConfiguration(ctx) {
     const configPath = codexConfigPath(ctx.home);
@@ -261,7 +435,7 @@ export async function configure(ctx) {
     }
     catch { }
     const nextAuth = codexAuth(ctx.apiKey, existingAuth);
-    const nextConfig = mergeCodexConfig(originalConfig, ctx.baseUrl, selectedModel(ctx), contentSha256(nextAuth));
+    const nextConfig = mergeCodexConfig(originalConfig, ctx.baseUrl, selectedModel(ctx), contentSha256(nextAuth), contentSha256(ctx.apiKey));
     const changed = originalConfig !== nextConfig || originalAuth !== nextAuth;
     const alreadyManaged = originalConfig.includes(GENERATED_HEADER);
     let verification;
@@ -312,24 +486,18 @@ export async function configure(ctx) {
 export async function remove(ctx) {
     const configPath = codexConfigPath(ctx.home);
     const authPath = codexAuthPath(ctx.home);
-    const [configText, authText] = await Promise.all([
-        fs.readFile(configPath, 'utf8').catch(() => ''),
-        fs.readFile(authPath, 'utf8').catch(() => ''),
-    ]);
-    const expectedAuthHash = managedAuthHash(configText);
-    // New generated configs bind ownership to the exact auth content. A hash
-    // mismatch means the user signed in or edited auth.json after setup, so
-    // removal must leave that current authentication state untouched. Legacy
-    // configs without the marker retain the conservative structural fallback.
-    const authManagedOverride = expectedAuthHash
-        ? contentSha256(authText) === expectedAuthHash
-        : configText.includes(GENERATED_HEADER)
-            ? undefined
-            : false;
+    // Read the ownership markers BEFORE config.toml is rewritten below.
+    const configText = await fs.readFile(configPath, 'utf8').catch(() => '');
+    const ownership = {
+        authHash: managedAuthHash(configText),
+        keyHash: markerHash(configText, managedKeyHashPrefix),
+        // Configs written before either marker existed: the original structural rule.
+        legacyStructural: configText.includes(GENERATED_HEADER),
+    };
     const snapshots = await captureFileSnapshots([configPath, authPath]);
     try {
-        const config = await restoreOrRemove(configPath, ctx);
-        const auth = await restoreOrRemove(authPath, ctx, authManagedOverride);
+        const config = await removeCodexConfig(configPath, ctx);
+        const auth = await removeCodexAuth(authPath, ctx, ownership);
         return {
             id,
             name,

package/dist/configure/models.js

@@ -1,6 +1,9 @@
 import { isAnthropicModel, isModelRouteAvailable, isRetiredModelId } from '../utils/api.js';
 const preferredAnthropic = [
     'claude-opus-5',
+    // Opus 5.5 ranks right after Opus 5, so claude-opus-5 stays the default
+    // for new installs; promoting 5.5 to the default is a separate decision.
+    'claude-opus-5-5',
     'claude-opus-4-8',
     'claude-sonnet-5',
     'claude-opus-4-7',
@@ -12,9 +15,8 @@ const preferredOpenAi = [
     'gpt-5.6-sol',
     'gpt-6-sol',
     'gpt-6-luna',
-    'gpt-5.5',
-    'gpt-5.4',
-    'gpt-5.4-mini',
+    // gpt-5.5 / gpt-5.4 / gpt-5.4-mini retired 2026-09-30.
+    'gpt-5.6-luna',
     'gpt-5.3-codex',
     'codex-auto-review',
     // Gemini / Grok / Qwen ride the same OpenAI-compatible route, so they are
@@ -123,7 +125,8 @@ export function fastModel(ctx) {
 }
 export function fastOpenAiModel(ctx) {
     const ids = openAiModelIds(ctx);
-    return ids.find(id => id === 'gpt-5.4-mini')
+    return ids.find(id => id === 'gpt-5.6-luna')
+        || ids.find(id => id === 'gpt-6-luna')
         || ids.find(id => /(^|[-.])(mini|nano)([-.]|$)/i.test(id));
 }
 /** The lightweight model for an OpenAI-compatible chat client, if one exists. */

package/dist/configure/openclaw.js

@@ -42,7 +42,7 @@ function entries(ctx, ids, family) {
             id: modelId,
             name: modelName(ctx, modelId),
             input: family === 'anthropic' ? ['text', 'image'] : ['text'],
-            maxTokens: modelId === 'claude-opus-5'
+            maxTokens: (modelId === 'claude-opus-5' || modelId === 'claude-opus-5-5')
                 ? Math.min(metadata?.max_output_tokens || 128000, 128000)
                 : Math.min(metadata?.max_output_tokens || 4096, 4096)
         };

package/dist/configure/opencode.js

@@ -24,7 +24,7 @@ function providerConfig(ctx) {
                 tool_call: modelSupportsTools(ctx, modelId),
                 limit: {
                     context: metadata?.context_window || (modelId.startsWith('claude-') ? 200000 : 128000),
-                    output: modelId === 'claude-opus-5'
+                    output: (modelId === 'claude-opus-5' || modelId === 'claude-opus-5-5')
                         ? Math.min(metadata?.max_output_tokens || 128000, 128000)
                         : Math.min(metadata?.max_output_tokens || 4096, 4096)
                 }

package/dist/configure/roo-code.d.ts

@@ -1,4 +1,11 @@
 import { ConfigureContext, ConfigureResult, RemoveContext } from '../types/client.js';
+/**
+ * Printed after every successful configure. Roo's built-in Ask and Architect
+ * modes carry no `command` tool group, so the model truthfully answers that
+ * terminal tools are not available and nothing runs -- customers read that as
+ * a broken key. Same advice as the docs' Roo Code guide and troubleshooting page.
+ */
+export declare const ROO_CODE_MODE_TIP = "Run tasks in Code or Debug mode. Ask and Architect modes cannot run terminal commands, so Roo says \"terminal tools are not available\" there. Switch modes; nothing is wrong with your key.";
 export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function remove(ctx: RemoveContext): Promise<ConfigureResult>;

package/dist/configure/roo-code.js

@@ -18,6 +18,13 @@ const claudeProfileId = 'scalemax-claude';
 const deepSeekProfileId = 'scalemax-deepseek';
 const glmProfileId = 'scalemax-glm-5-2';
 const rooMaximumOutputTokens = 384_000;
+/**
+ * Printed after every successful configure. Roo's built-in Ask and Architect
+ * modes carry no `command` tool group, so the model truthfully answers that
+ * terminal tools are not available and nothing runs -- customers read that as
+ * a broken key. Same advice as the docs' Roo Code guide and troubleshooting page.
+ */
+export const ROO_CODE_MODE_TIP = 'Run tasks in Code or Debug mode. Ask and Architect modes cannot run terminal commands, so Roo says "terminal tools are not available" there. Switch modes; nothing is wrong with your key.';
 function exactChatProfile(ctx, model) {
     if (model.trim().toLowerCase() === 'glm-5.2')
         return { name: glmProfileName, id: glmProfileId, model };
@@ -152,7 +159,7 @@ export async function configure(ctx) {
     const nextProfile = handoff(ctx);
     if (originalSettings === nextSettings && originalProfile === nextProfile) {
         await fs.chmod(profileFile, 0o600).catch(() => undefined);
-        return { id, name, changed: false, path: profileFile, message: 'supported Roo Code auto-import handoff is already current; reload VS Code to consume it' };
+        return { id, name, changed: false, path: profileFile, message: 'supported Roo Code auto-import handoff is already current; reload VS Code to consume it', tip: ROO_CODE_MODE_TIP };
     }
     await backupFile(settingsFile, ctx.home);
     await backupFile(profileFile, ctx.home);
@@ -175,6 +182,7 @@ export async function configure(ctx) {
         changed: true,
         path: profileFile,
         message: 'created a private, supported auto-import handoff; reload VS Code so Roo Code imports the profile into SecretStorage',
+        tip: ROO_CODE_MODE_TIP,
         rollback: snapshotRollback(snapshots, ctx.platform),
     };
 }

package/dist/configure/templates.js

@@ -11,7 +11,7 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
-    const models = ['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
+    const models = ['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
     return JSON.stringify({
         models: models.map(model => ({
             title: model === 'deepseek-v4-flash' ? 'ScaleMax DeepSeek V4 Flash' : `ScaleMax ${model}`,
@@ -21,7 +21,7 @@ export function continueConfig(apiKey, baseUrl) {
             apiKey,
             ...(model === 'deepseek-v4-flash' ? { useResponsesApi: false } : {})
         })),
-        tabAutocompleteModel: { title: 'ScaleMax gpt-5.4-mini', provider: 'openai', model: 'gpt-5.4-mini', apiBase: baseUrl, apiKey },
+        tabAutocompleteModel: { title: 'ScaleMax gpt-5.6-luna', provider: 'openai', model: 'gpt-5.6-luna', apiBase: baseUrl, apiKey },
         contextProviders: [{ name: 'code' }, { name: 'docs' }, { name: 'diff' }, { name: 'terminal' }]
     }, null, 2) + '\n';
 }

package/dist/types/client.d.ts

@@ -73,6 +73,8 @@ export interface ConfigureResult {
     changed: boolean;
     path?: string;
     message: string;
+    /** One-line usage advice printed after a successful configure (e.g. which agent mode can run tools). */
+    tip?: string;
     /** Restore the exact state captured immediately before this configure call. */
     rollback?: () => Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.45",
+  "version": "0.1.48",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {