@bytevion/cli 0.2.0 → 0.4.0

package/dist/base.js

@@ -6,6 +6,7 @@ const api_1 = require("./lib/api");
 const config_1 = require("./lib/config");
 const credentials_1 = require("./lib/credentials");
 const errors_1 = require("./lib/errors");
+const friendly_1 = require("./lib/friendly");
 class BaseCommand extends core_1.Command {
     static enableJsonFlag = true;
     static baseFlags = {
@@ -41,7 +42,13 @@ class BaseCommand extends core_1.Command {
     }
     async catch(err) {
         if (err instanceof errors_1.ByteError) {
-            return this.error(err.message, { code: err.code, exit: err.exit });
+            // --json callers want the machine-readable oclif error; humans get a panel that
+            // says what broke, why, and the exact next command — then we exit with the code.
+            if (this.jsonEnabled()) {
+                return this.error(err.message, { code: err.code, exit: err.exit });
+            }
+            this.logToStderr((0, friendly_1.renderErrorPanel)((0, friendly_1.friendlyError)(err)));
+            return this.exit(err.exit);
         }
         return super.catch(err);
     }

package/dist/commands/opt/preset.js

@@ -2,21 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
+const presets_1 = require("../../lib/presets");
 class OptPreset extends base_1.BaseCommand {
-    static description = 'Apply an optimization preset for the whole org.';
+    static description = 'Apply an optimization mode for the whole org (maximum, balanced, max_savings, lowest_latency, reliability_first).';
     static args = {
         preset: core_1.Args.string({
-            description: 'Preset to apply',
+            description: 'Mode to apply',
             required: true,
-            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+            options: presets_1.PRESET_VALUES,
         }),
     };
     async run() {
         const { args, flags } = await this.parse(OptPreset);
         this.requireToken(flags);
         const res = await this.api(flags).optPatch({ default_mode: args.preset });
-        if (!this.jsonEnabled())
-            this.log(`Optimization preset set to "${args.preset}".`);
+        if (!this.jsonEnabled()) {
+            const card = (0, presets_1.presetCard)(args.preset);
+            this.log(`Optimization mode set to "${args.preset}".${card ? ` ${card.blurb}` : ''}`);
+        }
         return res;
     }
 }

package/dist/commands/opt/show.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const picocolors_1 = __importDefault(require("picocolors"));
 const base_1 = require("../../base");
+const presets_1 = require("../../lib/presets");
 class OptShow extends base_1.BaseCommand {
-    static description = 'Show the current optimization preset and layer states for the org.';
+    static description = 'Show the current optimization mode and every layer running on your requests.';
     async run() {
         const { flags } = await this.parse(OptShow);
         this.requireToken(flags);
@@ -10,14 +15,23 @@ class OptShow extends base_1.BaseCommand {
         if (this.jsonEnabled())
             return res;
         const settings = res.settings ?? res;
-        this.log(`Preset (default_mode): ${settings.default_mode ?? '-'}`);
-        this.log(`Cache mode:            ${settings.cache_mode ?? '-'}`);
+        const mode = settings.default_mode ?? '-';
+        const card = (0, presets_1.presetCard)(mode);
+        this.log('');
+        this.log(`  ${picocolors_1.default.bold('Optimization mode')}  ${picocolors_1.default.cyan(mode)}${card ? picocolors_1.default.dim(`  ${card.hint}`) : ''}`);
+        this.log(`  ${picocolors_1.default.bold('Cache mode')}         ${picocolors_1.default.cyan(settings.cache_mode ?? '-')}`);
         const layers = Array.isArray(res.layers) ? res.layers : [];
         if (layers.length) {
-            const enabled = layers.filter((l) => l.enabled).length;
-            this.log(`Layers enabled:        ${enabled}/${layers.length}`);
+            const on = layers.filter((l) => l.enabled).length;
+            this.log(`  ${picocolors_1.default.bold('Active layers')}      ${picocolors_1.default.green(String(on))}${picocolors_1.default.dim(`/${layers.length}`)} running on every request`);
+            this.log('');
+            for (const l of layers) {
+                const name = String(l.title ?? l.plain_label ?? l.key ?? 'layer');
+                this.log(l.enabled ? `  ${picocolors_1.default.green('●')} ${name}` : `  ${picocolors_1.default.dim('○')} ${picocolors_1.default.dim(name)}`);
+            }
         }
-        this.log('Run with --json for the full settings object.');
+        this.log('');
+        this.log(picocolors_1.default.dim('  Run with --json for the full settings object.'));
         return res;
     }
 }

package/dist/commands/providers/add.js

@@ -106,16 +106,24 @@ class ProvidersAdd extends base_1.BaseCommand {
                     message: 'Model id to use in your tools',
                     options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
                 });
-                await ui.note(alias, 'Model id (use this everywhere)');
+                // Enable the chosen model so the gateway can serve it immediately.
+                const picked = models.find((m) => m.byte_alias === alias);
+                if (picked?.id)
+                    await api.modelEnable(picked.id).catch(() => undefined);
+                await ui.note(`${alias}\n\n${ui.theme.muted('Enabled and ready — use this id in your tools.')}`, 'Model id');
             }
             return res;
         }
         const res = await api.providersAdd(body);
+        // Enable the first imported model so the gateway is usable right away.
+        const firstModel = (res.fetch_result?.models ?? res.models ?? [])[0];
+        if (firstModel?.id)
+            await api.modelEnable(firstModel.id).catch(() => undefined);
         if (this.jsonEnabled())
             return res;
         const id = res.id ?? res.connection?.id;
         const imported = res.fetch_result?.imported ?? res.imported ?? 0;
-        this.log(`Provider connection added (id ${id}). Models imported: ${imported}.`);
+        this.log(`Provider connection added (id ${id}). Models imported: ${imported}.${firstModel?.byte_alias ? ` Enabled ${firstModel.byte_alias}.` : ''}`);
         return res;
     }
 }

package/dist/commands/run.js

@@ -9,7 +9,7 @@ class Run extends base_1.BaseCommand {
         prompt: core_1.Args.string({ description: 'The prompt to send', required: true }),
     };
     static flags = {
-        model: core_1.Flags.string({ description: 'Model or Byte alias', default: 'byte-default' }),
+        model: core_1.Flags.string({ description: 'Model or Byte alias (default: auto — routes to your enabled model)', default: 'auto' }),
         'max-tokens': core_1.Flags.integer({ description: 'Maximum output tokens' }),
     };
     async run() {

package/dist/commands/setup.d.ts

@@ -14,6 +14,7 @@ export default class Setup extends BaseCommand {
         connect: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<unknown>;
+    private buildWizardPorts;
     private connectProvider;
     private runNonInteractive;
 }

package/dist/commands/setup.js

@@ -37,6 +37,7 @@ const core_1 = require("@oclif/core");
 const base_1 = require("../base");
 const auth_1 = require("../lib/auth");
 const credentials_1 = require("../lib/credentials");
+const presets_1 = require("../lib/presets");
 const providers_1 = require("../lib/providers");
 const tty_1 = require("../lib/tty");
 const ui = __importStar(require("../lib/ui"));
@@ -50,9 +51,9 @@ class Setup extends base_1.BaseCommand {
         'provider-base-url': core_1.Flags.string({ description: 'Custom provider base URL (for --provider custom)' }),
         mode: core_1.Flags.string({ description: 'Gateway mode override (byte_compatible/byte_messages/byte_generative)' }),
         preset: core_1.Flags.string({
-            description: 'Optimization preset',
-            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
-            default: 'balanced',
+            description: 'Optimization mode',
+            options: ['maximum', 'balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+            default: 'maximum',
         }),
         'key-name': core_1.Flags.string({ description: 'Name for the Byte key', default: 'cli' }),
         'skip-provider': core_1.Flags.boolean({ description: 'Skip connecting a provider' }),
@@ -65,6 +66,35 @@ class Setup extends base_1.BaseCommand {
         if (this.jsonEnabled() || !(0, tty_1.interactive)()) {
             return this.runNonInteractive(flags, profile, base);
         }
+        // Full-screen Ink wizard when the terminal supports it. Any failure inside the island
+        // returns {status:'fallback'} and we drop through to the clack flow below — no regression.
+        const tui = require('../lib/tui');
+        if (tui.useInk({ json: this.jsonEnabled() })) {
+            const ports = this.buildWizardPorts(flags, profile, base);
+            const res = await tui.renderWizardIsland({
+                plainColor: Boolean(process.env.NO_COLOR),
+                ascii: tui.computeAscii(),
+                version: this.config.version,
+                initial: { signedIn: Boolean((0, credentials_1.getToken)(profile)), email: undefined, byteKey: (0, credentials_1.getByteKey)(profile) },
+                ports,
+                providerPresets: providers_1.PROVIDER_PRESETS,
+                presetCards: presets_1.PRESET_CARDS,
+            });
+            if (res.status === 'cancelled')
+                return this.exit(130);
+            if (res.status === 'done') {
+                if (res.summary.connect) {
+                    await this.config.runCommand('integrate', [
+                        res.summary.connect,
+                        '--write',
+                        '--yes',
+                        ...(res.summary.model ? ['--model', res.summary.model] : []),
+                    ]);
+                }
+                return res.summary;
+            }
+            // status === 'fallback' → continue to the clack flow.
+        }
         await ui.intro(ui.banner());
         // 1) Sign in
         let token = (0, credentials_1.getToken)(profile);
@@ -82,37 +112,46 @@ class Setup extends base_1.BaseCommand {
             await (0, auth_1.deviceLogin)({ baseUrl: base, profile });
         }
         // 2) Connect a provider
-        let chosenAlias;
+        let provider = { status: 'skipped' };
         if (!flags['skip-provider']) {
             const existing = await api.providersList().catch(() => ({ connections: [] }));
             const conns = existing.connections ?? (Array.isArray(existing) ? existing : []);
             let addNew = true;
             if (conns.length) {
-                addNew = (await ui.select({
-                    message: 'Provider',
-                    options: [
-                        { value: 'existing', label: `Use existing connection (${conns.length})` },
-                        { value: 'new', label: 'Connect a new provider' },
-                    ],
-                })) === 'new';
+                addNew =
+                    (await ui.select({
+                        message: 'Provider',
+                        options: [
+                            { value: 'existing', label: `Use existing connection (${conns.length})` },
+                            { value: 'new', label: 'Connect a new provider' },
+                        ],
+                    })) === 'new';
+                if (!addNew)
+                    provider = { status: 'connected' };
             }
             if (addNew) {
-                chosenAlias = await this.connectProvider(api, flags);
+                provider = await this.connectProvider(api, flags);
             }
         }
-        // 3) Create a Byte key
+        // 3) Choose the optimization mode
+        const preset = await ui.select({
+            message: 'Optimization mode',
+            options: presets_1.PRESET_CARDS.map((c) => ({ value: c.value, label: c.label, hint: c.hint })),
+            initialValue: presets_1.PRESET_CARDS.some((c) => c.value === flags.preset) ? flags.preset : 'maximum',
+        });
+        // 4) Create a Byte key
         let byteKey = (0, credentials_1.getByteKey)(profile);
         if (!byteKey) {
             const name = await ui.text({ message: 'Name this Byte key', defaultValue: flags['key-name'] || 'cli' });
-            const res = await api.keysCreate({ name: name || 'cli', preset: flags.preset });
-            const created = String(res.key);
-            (0, credentials_1.setByteKey)(profile, created);
-            await ui.revealSecret('Your Byte API key', created);
+            const res = await api.keysCreate({ name: name || 'cli', preset });
+            byteKey = String(res.key);
+            (0, credentials_1.setByteKey)(profile, byteKey);
+            await ui.revealSecret('Your Byte API key', byteKey);
         }
-        // 4) Optimization preset
-        await api.optPatch({ default_mode: flags.preset }).catch(() => undefined);
-        await ui.log.success(`Optimizations: ${flags.preset} preset applied`);
-        // 5) Connect a tool
+        // 5) Apply the optimization mode to the org
+        await api.optPatch({ default_mode: preset }).catch(() => undefined);
+        await ui.log.success(`Optimizations: ${preset} mode applied — every layer this mode enables now runs on each request.`);
+        // 6) Connect a tool
         const connect = await ui.select({
             message: 'Connect a coding tool now?',
             options: [
@@ -126,11 +165,76 @@ class Setup extends base_1.BaseCommand {
             ],
         });
         if (connect !== 'skip') {
-            const argv = [connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])];
+            const argv = [connect, '--write', '--yes', ...(provider.alias ? ['--model', provider.alias] : [])];
             await this.config.runCommand('integrate', argv);
         }
-        await ui.outro(`${ui.theme.ok('Setup complete.')}  Next: ${ui.theme.accent('byte run "hello from byte"')} · ${ui.theme.accent('byte usage')}`);
-        return { status: 'setup_complete', profile, model: chosenAlias };
+        // Accurate close-out — never claim a provider is wired when it is not.
+        const tips = [`${ui.theme.accent('byte run "hello from byte"')}`, `${ui.theme.accent('byte usage')}`];
+        if (provider.status === 'saved') {
+            await ui.note(`Your provider is saved but no model loaded yet. Fix the key/URL, then run ${ui.theme.accent('byte providers test')}.`, 'One thing left');
+        }
+        else if (provider.status === 'skipped' && !flags['skip-provider']) {
+            tips.unshift(`${ui.theme.accent('byte providers add')}`);
+        }
+        await ui.outro(`${ui.theme.ok('Setup complete.')}  Next: ${tips.join(' · ')}`);
+        return { status: 'setup_complete', profile, model: provider.alias, provider: provider.status, preset };
+    }
+    // Adapts the existing auth + API surface into the WizardPorts the Ink island calls. Every port
+    // wraps a call the clack flow already uses, so both paths hit identical backend behavior.
+    buildWizardPorts(flags, profile, base) {
+        const api = this.api(flags);
+        return {
+            signIn: async () => {
+                const r = await (0, auth_1.deviceLogin)({ baseUrl: base, profile });
+                return { email: r.email };
+            },
+            listProviders: async () => {
+                const existing = await api.providersList().catch(() => ({ connections: [] }));
+                return existing.connections ?? (Array.isArray(existing) ? existing : []);
+            },
+            connectProvider: async (a) => {
+                const res = await api.providersAdd({
+                    api_key: a.apiKey,
+                    gateway_mode: flags.mode || a.mode,
+                    base_url: a.baseUrl,
+                    auto_fetch: true,
+                });
+                const fetchResult = res.fetch_result ?? {};
+                const models = res.models ?? fetchResult.models ?? [];
+                const connId = res.id ?? res.connection?.id;
+                const failed = fetchResult.status === 'error' || Boolean(res.fetch_error) || Boolean(fetchResult.last_error);
+                const status = failed && !models.length ? 'saved' : 'connected';
+                return {
+                    status,
+                    models,
+                    connId,
+                    error: failed ? String(fetchResult.last_error || res.fetch_error || 'Provider models could not be loaded.') : undefined,
+                };
+            },
+            rotateAndTest: async (connId, apiKey) => {
+                try {
+                    await api.providersRotate(connId, apiKey);
+                    const test = await api.providersTest(connId);
+                    const models = test.models ?? [];
+                    return { models, error: models.length ? undefined : 'No models returned.' };
+                }
+                catch (err) {
+                    return { models: [], error: err?.message ?? String(err) };
+                }
+            },
+            enableModel: async (id) => {
+                await api.modelEnable(id).catch(() => undefined);
+            },
+            createByteKey: async (name, preset) => {
+                const res = await api.keysCreate({ name: name || 'cli', preset });
+                const key = String(res.key);
+                (0, credentials_1.setByteKey)(profile, key);
+                return { key };
+            },
+            applyPreset: async (preset) => {
+                await api.optPatch({ default_mode: preset }).catch(() => undefined);
+            },
+        };
     }
     async connectProvider(api, flags) {
         const providerId = await ui.select({
@@ -151,27 +255,72 @@ class Setup extends base_1.BaseCommand {
         const key = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
         const spin = await ui.spinner();
         spin.start(`Connecting ${preset.label}…`);
+        let res;
         try {
-            const res = await api.providersAdd({ api_key: key, gateway_mode: flags.mode || preset.gateway_mode, base_url: baseUrl, auto_fetch: true });
-            const models = res.fetch_result?.models ?? res.models ?? [];
-            spin.stop(`Connected ${preset.label} — ${models.length} model(s) imported.`);
-            if (models.length) {
-                return ui.select({
-                    message: 'Default model',
-                    options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
-                });
-            }
+            res = await api.providersAdd({ api_key: key, gateway_mode: flags.mode || preset.gateway_mode, base_url: baseUrl, auto_fetch: true });
         }
         catch (err) {
-            spin.stop('Provider connection failed.');
+            spin.stop('Could not save the provider connection.');
             await ui.log.error(err?.message ?? String(err));
+            return { status: 'failed' };
+        }
+        const connId = res.id ?? res.connection?.id;
+        let fetchResult = res.fetch_result ?? {};
+        let models = res.models ?? fetchResult.models ?? [];
+        // Retry / keep / skip loop — a failed model import never silently passes as success.
+        for (;;) {
+            const failed = fetchResult.status === 'error' || Boolean(res.fetch_error) || Boolean(fetchResult.last_error);
+            if (!failed || models.length) {
+                spin.stop(`Connected ${preset.label} — ${models.length} model(s) imported.`);
+                break;
+            }
+            spin.stop(`Saved ${preset.label}, but its models could not be loaded.`);
+            await ui.log.warn(String(fetchResult.last_error || res.fetch_error || 'The provider URL or key looks unreachable right now.'));
+            const choice = await ui.select({
+                message: 'What would you like to do?',
+                options: [
+                    { value: 'retry', label: 'Re-enter the key and retry' },
+                    { value: 'keep', label: 'Keep it — I will pick a model later' },
+                    { value: 'skip', label: 'Skip the provider for now' },
+                ],
+            });
+            if (choice !== 'retry' || !connId)
+                return { status: choice === 'skip' ? 'skipped' : 'saved' };
+            const retryKey = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
+            spin.start('Retrying…');
+            try {
+                await api.providersRotate(connId, retryKey);
+                const test = await api.providersTest(connId);
+                models = test.models ?? [];
+                fetchResult = { status: models.length ? 'ok' : 'error', last_error: models.length ? null : 'No models returned.' };
+                res = { ...res, fetch_error: undefined };
+            }
+            catch (err) {
+                models = [];
+                fetchResult = { status: 'error', last_error: err?.message ?? String(err) };
+                res = { ...res, fetch_error: undefined };
+            }
         }
-        return undefined;
+        if (models.length) {
+            const alias = await ui.select({
+                message: 'Default model',
+                options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
+            });
+            // Enable the chosen model so the gateway can route to it right away. Imported models
+            // start disabled — without this the first `byte run` would hit BYTE_ALIAS_NOT_CONFIGURED.
+            const picked = models.find((m) => m.byte_alias === alias);
+            if (picked?.id)
+                await api.modelEnable(picked.id).catch(() => undefined);
+            return { alias, status: 'connected' };
+        }
+        return { status: 'saved' };
     }
     async runNonInteractive(flags, profile, base) {
         this.requireToken(flags);
         const api = this.api(flags);
         let imported = 0;
+        let providerStatus = flags['skip-provider'] ? 'skipped' : 'skipped';
+        let providerError;
         let chosenAlias;
         const key = flags['provider-key'];
         if (key && !flags['skip-provider']) {
@@ -182,20 +331,42 @@ class Setup extends base_1.BaseCommand {
                 return this.error('Provide --provider <preset> or --provider-base-url for the upstream provider.', { exit: 2 });
             }
             const res = await api.providersAdd({ api_key: key, gateway_mode: mode, base_url: baseUrl, auto_fetch: true });
-            imported = res.fetch_result?.imported ?? res.imported ?? 0;
-            chosenAlias = res.fetch_result?.models?.[0]?.byte_alias;
+            const fetchResult = res.fetch_result ?? {};
+            imported = fetchResult.imported ?? res.imported ?? 0;
+            const firstModel = res.models?.[0];
+            chosenAlias = firstModel?.byte_alias;
+            // Enable the first model so the gateway works immediately (imported models start disabled).
+            if (firstModel?.id)
+                await api.modelEnable(firstModel.id).catch(() => undefined);
+            if (fetchResult.status === 'error' || res.fetch_error) {
+                providerStatus = 'saved';
+                providerError = String(fetchResult.last_error || res.fetch_error);
+            }
+            else {
+                providerStatus = 'connected';
+            }
         }
         await api.optPatch({ default_mode: flags.preset }).catch(() => undefined);
         const keyRes = await api.keysCreate({ name: flags['key-name'] || 'cli', preset: flags.preset });
         (0, credentials_1.setByteKey)(profile, keyRes.key);
         if (flags.connect) {
-            await this.config.runCommand('integrate', [flags.connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])]);
+            const argv = [flags.connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])];
+            await this.config.runCommand('integrate', argv);
         }
         if (!this.jsonEnabled()) {
             this.log(`Byte key: ${keyRes.key}`);
             this.log(`Provider models imported: ${imported}`);
+            if (providerStatus === 'saved')
+                this.log(`Provider saved but models not loaded: ${providerError ?? 'unreachable'}. Run \`byte providers test\`.`);
         }
-        return { byte_key: keyRes.key, provider_models_imported: imported, preset: flags.preset, model: chosenAlias };
+        return {
+            byte_key: keyRes.key,
+            provider_models_imported: imported,
+            provider: providerStatus,
+            provider_error: providerError,
+            preset: flags.preset,
+            model: chosenAlias,
+        };
     }
 }
 exports.default = Setup;

package/dist/commands/usage.js

@@ -16,16 +16,40 @@ class Usage extends base_1.BaseCommand {
             return res;
         const points = res.series ?? res.points ?? (Array.isArray(res) ? res : []);
         if (!points.length) {
-            this.log('No usage recorded yet.');
+            this.log('No usage recorded yet. Send a request through your Byte key, then check back.');
             return res;
         }
-        this.log((0, output_1.renderTable)(['Bucket', 'Requests', 'Tokens', 'Cost', 'Savings'], points.map((p) => [
-            p.bucket ?? p.date ?? p.t ?? '-',
-            p.requests ?? p.total_requests ?? '-',
-            p.tokens ?? p.total_tokens ?? '-',
-            (0, output_1.fmtUsd)(p.cost_usd ?? p.cost_byte_usd),
-            (0, output_1.fmtUsd)(p.savings_usd),
-        ])));
+        const num = (v) => {
+            const n = typeof v === 'number' ? v : Number(v);
+            return Number.isFinite(n) ? n : 0;
+        };
+        const tokensOf = (p) => num(p.tokens_in) + num(p.tokens_out);
+        const rows = points.map((p) => [
+            (0, output_1.fmtBucket)(p.timestamp ?? p.bucket ?? p.date),
+            (0, output_1.fmtNum)(num(p.requests)),
+            (0, output_1.fmtNum)(num(p.cached)),
+            (0, output_1.fmtNum)(tokensOf(p)),
+            (0, output_1.fmtUsd)(num(p.cost_byte_usd ?? p.cost_usd)),
+            (0, output_1.fmtUsd)(num(p.savings_usd)),
+        ]);
+        const totals = {
+            requests: points.reduce((a, p) => a + num(p.requests), 0),
+            cached: points.reduce((a, p) => a + num(p.cached), 0),
+            tokens: points.reduce((a, p) => a + tokensOf(p), 0),
+            cost: points.reduce((a, p) => a + num(p.cost_byte_usd ?? p.cost_usd), 0),
+            savings: points.reduce((a, p) => a + num(p.savings_usd), 0),
+            raw: points.reduce((a, p) => a + num(p.cost_raw_usd), 0),
+        };
+        rows.push(['Total', (0, output_1.fmtNum)(totals.requests), (0, output_1.fmtNum)(totals.cached), (0, output_1.fmtNum)(totals.tokens), (0, output_1.fmtUsd)(totals.cost), (0, output_1.fmtUsd)(totals.savings)]);
+        this.log((0, output_1.renderTable)(['Bucket', 'Requests', 'Cached', 'Tokens', 'Cost', 'Savings'], rows));
+        const plain = Boolean(process.env.NO_COLOR) || process.env.BYTE_PLAIN === '1';
+        const spark = (0, output_1.sparkline)(points.map((p) => num(p.savings_usd)), plain);
+        if (spark)
+            this.log(`\nSavings trend  ${spark}`);
+        const savedPct = totals.raw > 0 ? (0, output_1.pct)(totals.savings / totals.raw) : null;
+        const hitRate = totals.requests > 0 ? (0, output_1.pct)(totals.cached / totals.requests) : null;
+        this.log(`Saved ${(0, output_1.fmtUsd)(totals.savings)}${savedPct ? ` (${savedPct})` : ''} across ${(0, output_1.fmtNum)(totals.requests)} requests` +
+            `${hitRate ? `, cache hit rate ${hitRate}` : ''}.`);
         return res;
     }
 }

package/dist/hooks/init/home.js

@@ -33,13 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../lib/api");
 const config_1 = require("../../lib/config");
 const credentials_1 = require("../../lib/credentials");
+const home_1 = require("../../lib/home");
+const output_1 = require("../../lib/output");
 const tty_1 = require("../../lib/tty");
 const ui = __importStar(require("../../lib/ui"));
 // oclif runs init hooks before it would print help. Bare `byte` (no command) in a real
-// terminal opens an interactive home menu; anything else (a command, a pipe, CI, --help)
-// returns and lets oclif behave normally.
+// terminal opens the live home dashboard + an interactive menu; anything else (a command,
+// a pipe, CI, --help) returns and lets oclif behave normally.
 const hook = async function (opts) {
     if (opts.id !== undefined)
         return;
@@ -50,9 +53,42 @@ const hook = async function (opts) {
         return;
     const profile = (0, config_1.profileName)();
     const prof = (0, config_1.getProfile)(profile);
-    const signedIn = Boolean((0, credentials_1.getToken)(profile));
-    const status = signedIn ? ui.theme.muted(`signed in · ${prof.email ?? prof.org_name ?? profile}`) : ui.theme.muted('not signed in');
-    await ui.intro(`${ui.banner()}   ${status}`);
+    const token = (0, credentials_1.getToken)(profile);
+    const signedIn = Boolean(token);
+    const byteKey = (0, credentials_1.getByteKey)(profile);
+    // Live, branded home dashboard. Every cell is best-effort: an unreachable service or a
+    // signed-out profile degrades to a dim placeholder rather than blocking the screen.
+    let data = { savingsSeries: [], savedTotal: 0, tokensTotal: 0, byteKey, gateway: 'unknown' };
+    if (signedIn) {
+        const api = new api_1.ByteApi(prof.base_url || config_1.DEFAULT_BASE_URL, token);
+        const loaded = await (0, home_1.loadHomeData)(api, byteKey, profile).catch(() => undefined);
+        if (loaded)
+            data = { ...data, ...loaded };
+    }
+    // Full-screen Ink home dashboard + quick-actions menu, when the terminal supports it. Any
+    // failure inside the island returns {status:'fallback'} and we drop straight through to the
+    // existing clack dashboard below — nothing regresses.
+    const tui = require('../../lib/tui');
+    if (tui.useInk()) {
+        const res = await tui.renderHomeIsland({
+            signedIn,
+            data: { ...data, gateway: data.gateway ?? 'unknown', byteKeyMasked: (0, output_1.maskKey)(byteKey) },
+            plainColor: Boolean(process.env.NO_COLOR),
+            ascii: tui.computeAscii(),
+            version: this.config.version,
+        });
+        if (res.status === 'exit') {
+            await this.exit(0);
+            return;
+        }
+        if (res.status === 'action') {
+            await this.config.runCommand(res.commandId, res.argv);
+            await this.exit(0);
+            return;
+        }
+        // status === 'fallback' → continue to the clack dashboard.
+    }
+    this.log(`\n${(0, home_1.renderHome)(data, signedIn)}\n`);
     const choice = await ui.select({
         message: 'What would you like to do?',
         initialValue: signedIn ? 'setup' : 'login',

package/dist/lib/api.d.ts

@@ -22,6 +22,7 @@ export declare class ByteApi {
     providersAdd(body: Record<string, unknown>): Promise<any>;
     providersRotate(id: number, apiKey: string): Promise<any>;
     providersTest(id: number): Promise<any>;
+    modelEnable(id: number): Promise<any>;
     optShow(): Promise<any>;
     optPatch(body: Record<string, unknown>): Promise<any>;
     usage(granularity: string): Promise<any>;

package/dist/lib/api.js

@@ -94,6 +94,12 @@ class ByteApi {
     providersTest(id) {
         return this.request('POST', `/api/v1/model-connections/${id}/fetch-models`, { body: {} });
     }
+    // Enable an imported provider model so the gateway can route to it. Imported models
+    // arrive disabled; without enabling at least one, the gateway returns
+    // BYTE_ALIAS_NOT_CONFIGURED. Setup/providers-add call this on the model the user picks.
+    modelEnable(id) {
+        return this.request('PATCH', `/api/v1/models/${id}`, { body: { enabled: true } });
+    }
     // --- optimizations ---
     optShow() {
         return this.request('GET', '/api/v1/optimizations');

package/dist/lib/friendly.d.ts

@@ -0,0 +1,8 @@
+import { ByteError } from './errors';
+export interface Friendly {
+    issue: string;
+    why: string;
+    next: string;
+}
+export declare function friendlyError(err: ByteError): Friendly;
+export declare function renderErrorPanel(f: Friendly): string;