@orchagent/cli 0.3.33 → 0.3.34

package/dist/commands/call.js

@@ -246,7 +246,8 @@ Paid Agents:
             }
             if (isOwner) {
                 // Owner: show free message, no balance check needed
-                process.stderr.write(`Cost: FREE (author)\n\n`);
+                if (!options.json)
+                    process.stderr.write(`Cost: FREE (author)\n\n`);
             }
             else {
                 // Non-owner: check balance
@@ -254,7 +255,8 @@ Paid Agents:
                 pricingInfo = { price_cents: price ?? null };
                 if (!price || price <= 0) {
                     // Price missing or invalid - warn but proceed (server will enforce)
-                    process.stderr.write(`Warning: Pricing data unavailable. The server will verify payment.\n\n`);
+                    if (!options.json)
+                        process.stderr.write(`Warning: Pricing data unavailable. The server will verify payment.\n\n`);
                 }
                 else {
                     // Valid price - check balance
@@ -272,11 +274,13 @@ Paid Agents:
                             process.exit(errors_1.ExitCodes.PERMISSION_DENIED);
                         }
                         // Sufficient balance - show cost preview
-                        process.stderr.write(`Cost: $${(price / 100).toFixed(2)}/call\n\n`);
+                        if (!options.json)
+                            process.stderr.write(`Cost: $${(price / 100).toFixed(2)}/call\n\n`);
                     }
                     catch (err) {
                         // Balance check failed - warn but proceed (server will enforce)
-                        process.stderr.write(`Warning: Could not verify balance. The server will check payment.\n\n`);
+                        if (!options.json)
+                            process.stderr.write(`Warning: Could not verify balance. The server will check payment.\n\n`);
                     }
                 }
             }
@@ -455,9 +459,9 @@ Paid Agents:
             sourceLabel = multipart.sourceLabel;
         }
         const url = `${resolved.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}`;
-        // Make the API call with a spinner
-        const spinner = (0, spinner_1.createSpinner)(`Calling ${org}/${parsed.agent}@${parsed.version}...`);
-        spinner.start();
+        // Make the API call with a spinner (suppress in --json mode for clean machine-readable output)
+        const spinner = options.json ? null : (0, spinner_1.createSpinner)(`Calling ${org}/${parsed.agent}@${parsed.version}...`);
+        spinner?.start();
         let response;
         try {
             response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
@@ -467,7 +471,7 @@ Paid Agents:
             });
         }
         catch (err) {
-            spinner.fail(`Call failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+            spinner?.fail(`Call failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
             throw err;
         }
         if (!response.ok) {
@@ -485,7 +489,7 @@ Paid Agents:
                 : undefined;
             // Part 2: Handle 402 Payment Required
             if (response.status === 402 || errorCode === 'INSUFFICIENT_CREDITS') {
-                spinner.fail('Insufficient credits');
+                spinner?.fail('Insufficient credits');
                 let errorMessage = 'Insufficient credits to call this agent.\n\n';
                 // Use pricing info from pre-call check if available
                 if (pricingInfo?.price_cents) {
@@ -498,22 +502,31 @@ Paid Agents:
                 throw new errors_1.CliError(errorMessage, errors_1.ExitCodes.PERMISSION_DENIED);
             }
             if (errorCode === 'LLM_KEY_REQUIRED') {
-                spinner.fail('LLM key required');
+                spinner?.fail('LLM key required');
                 throw new errors_1.CliError('This public agent requires you to provide an LLM key.\n' +
                     'Use --key <key> --provider <provider> or set OPENAI_API_KEY/ANTHROPIC_API_KEY env var.');
             }
+            if (errorCode === 'LLM_RATE_LIMITED') {
+                const rateLimitMsg = typeof payload === 'object' && payload
+                    ? payload.error?.message || 'Rate limit exceeded'
+                    : 'Rate limit exceeded';
+                spinner?.fail('Rate limited by LLM provider');
+                throw new errors_1.CliError(rateLimitMsg + '\n\n' +
+                    'This is the LLM provider\'s rate limit on your API key, not an OrchAgent limit.\n' +
+                    'To switch providers: orch call <agent> --provider <gemini|anthropic|openai>', errors_1.ExitCodes.RATE_LIMITED);
+            }
             const message = typeof payload === 'object' && payload
                 ? payload.error
                     ?.message ||
                     payload.message ||
                     response.statusText
                 : response.statusText;
-            spinner.fail(`Call failed: ${message}`);
+            spinner?.fail(`Call failed: ${message}`);
             throw new errors_1.CliError(message);
         }
-        spinner.succeed(`Called ${org}/${parsed.agent}@${parsed.version}`);
-        // After successful call, if it was a paid agent, show cost
-        if ((0, pricing_1.isPaidAgent)(agentMeta) && pricingInfo?.price_cents && pricingInfo.price_cents > 0) {
+        spinner?.succeed(`Called ${org}/${parsed.agent}@${parsed.version}`);
+        // After successful call, if it was a paid agent, show cost (suppress in --json mode)
+        if (!options.json && (0, pricing_1.isPaidAgent)(agentMeta) && pricingInfo?.price_cents && pricingInfo.price_cents > 0) {
             process.stderr.write(`\nCost: $${(pricingInfo.price_cents / 100).toFixed(2)} USD\n`);
         }
         // Track successful call

package/dist/commands/publish.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplateVariables = extractTemplateVariables;
+exports.deriveInputSchema = deriveInputSchema;
 exports.registerPublishCommand = registerPublishCommand;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
@@ -14,6 +16,44 @@ const api_1 = require("../lib/api");
 const errors_1 = require("../lib/errors");
 const analytics_1 = require("../lib/analytics");
 const bundle_1 = require("../lib/bundle");
+/**
+ * Extract template placeholders from a prompt template.
+ * Matches double-brace patterns like {{variable}}.
+ * Returns unique variable names in order of first appearance.
+ */
+function extractTemplateVariables(template) {
+    const seen = new Set();
+    const result = [];
+    // Match double-brace template variables: two opening braces, word chars, two closing braces
+    const pattern = /\{\{(\w+)\}\}/g;
+    let match;
+    while ((match = pattern.exec(template)) !== null) {
+        const name = match[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            result.push(name);
+        }
+    }
+    return result;
+}
+/**
+ * Derive a JSON Schema input object from template variable names.
+ * Each variable becomes a required string property.
+ */
+function deriveInputSchema(variables) {
+    const properties = {};
+    for (const name of variables) {
+        properties[name] = {
+            type: 'string',
+            description: `Value for the ${name} template variable`,
+        };
+    }
+    return {
+        type: 'object',
+        properties,
+        required: [...variables],
+    };
+}
 /**
  * Handle security flagged error response (422 with error: 'content_flagged')
  * Returns true if the error was handled, false otherwise
@@ -273,6 +313,7 @@ function registerPublishCommand(program) {
                     const price = parseFloat(options.price);
                     process.stdout.write(`Pricing: $${price.toFixed(2)} USD per call\n`);
                 }
+                process.stdout.write(`\nView analytics and usage: https://orchagent.io/dashboard\n`);
             }
             catch (err) {
                 if (handleSecurityFlaggedError(err)) {
@@ -338,12 +379,14 @@ function registerPublishCommand(program) {
         // Read schemas
         let inputSchema;
         let outputSchema;
+        let schemaFromFile = false;
         const schemaPath = path_1.default.join(cwd, 'schema.json');
         try {
             const raw = await promises_1.default.readFile(schemaPath, 'utf-8');
             const schemas = JSON.parse(raw);
             inputSchema = schemas.input;
             outputSchema = schemas.output;
+            schemaFromFile = true;
         }
         catch (err) {
             // Schema is optional
@@ -351,6 +394,33 @@ function registerPublishCommand(program) {
                 throw new errors_1.CliError(`Failed to read schema.json: ${err}`);
             }
         }
+        // For prompt agents, derive input schema from template variables if needed
+        if (prompt && (manifest.type === 'prompt' || manifest.type === 'skill')) {
+            const templateVars = extractTemplateVariables(prompt);
+            if (templateVars.length > 0) {
+                if (!schemaFromFile) {
+                    // No schema.json provided - auto-generate from template variables
+                    inputSchema = deriveInputSchema(templateVars);
+                }
+                else if (inputSchema && 'properties' in inputSchema) {
+                    // schema.json exists - check for mismatches with template variables
+                    const schemaProps = Object.keys(inputSchema.properties || {});
+                    const missing = templateVars.filter(v => !schemaProps.includes(v));
+                    const extra = schemaProps.filter(p => !templateVars.includes(p));
+                    if (missing.length > 0 || extra.length > 0) {
+                        const parts = [];
+                        if (missing.length > 0) {
+                            parts.push(`template uses {{${missing.join('}}, {{')}}} but schema.json doesn't define ${missing.join(', ')}`);
+                        }
+                        if (extra.length > 0) {
+                            parts.push(`schema.json defines ${extra.join(', ')} but template doesn't use {{${extra.join('}}, {{')}}}`);
+                        }
+                        process.stderr.write(chalk_1.default.yellow(`Warning: Schema mismatch - ${parts.join('; ')}.\n`));
+                        process.stderr.write(chalk_1.default.yellow(`  Consider updating schema.json to match your prompt.md template variables.\n`));
+                    }
+                }
+            }
+        }
         // For code-based agents, either --url is required OR we bundle the code
         let agentUrl = options.url;
         let shouldUploadBundle = false;
@@ -393,10 +463,14 @@ function registerPublishCommand(program) {
                 // Prompt agent validations
                 const promptBytes = prompt ? Buffer.byteLength(prompt, 'utf-8') : 0;
                 process.stderr.write(`  ✓ prompt.md found (${promptBytes.toLocaleString()} bytes)\n`);
-                if (inputSchema || outputSchema) {
+                if (schemaFromFile) {
                     const schemaTypes = [inputSchema ? 'input' : null, outputSchema ? 'output' : null].filter(Boolean).join(' + ');
                     process.stderr.write(`  ✓ schema.json found (${schemaTypes} schemas)\n`);
                 }
+                else if (inputSchema) {
+                    const vars = prompt ? extractTemplateVariables(prompt) : [];
+                    process.stderr.write(`  ✓ Input schema derived from template variables: ${vars.join(', ')}\n`);
+                }
             }
             else if (manifest.type === 'code') {
                 // Code agent validations
@@ -583,5 +657,6 @@ function registerPublishCommand(program) {
         if (shouldUploadBundle) {
             process.stdout.write(`\nNote: Hosted code execution is in beta. Contact support for full deployment.\n`);
         }
+        process.stdout.write(`\nView analytics and usage: https://orchagent.io/dashboard\n`);
     });
 }

package/dist/commands/search.js

@@ -16,6 +16,7 @@ function registerSearchCommand(program) {
         .option('--recent', 'Show most recently published')
         .option('--mine', 'Show only your own agents (including private)')
         .option('--type <type>', 'Filter by type: agents, skills, code, prompt, skill, all (default: all)', 'all')
+        .option('--tags <tags>', 'Filter by tags (comma-separated, e.g., security,devops)')
         .option('--limit <n>', `Max results (default: ${DEFAULT_LIMIT})`, String(DEFAULT_LIMIT))
         .option('--free', 'Show only free agents')
         .option('--paid', 'Show only paid agents')
@@ -25,6 +26,9 @@ Pricing Filters:
   --free    Show only free agents
   --paid    Show only paid agents
 
+Tag Filters:
+  --tags security,devops    Show agents matching any of these tags
+
 Ownership Filters:
   --mine    Show your own agents (public and private). Requires login.
 `)
@@ -34,6 +38,7 @@ Ownership Filters:
         // Map type filter for API (null means no filter)
         const typeFilter = options.type === 'all' ? undefined : options.type;
         const sort = options.popular ? 'stars' : options.recent ? 'recent' : undefined;
+        const tags = options.tags ? options.tags.split(',').map(t => t.trim()).filter(Boolean) : undefined;
         let agents;
         if (options.mine) {
             // --mine: search within user's own agents (public + private)
@@ -51,12 +56,12 @@ Ownership Filters:
                 options.popular = true;
             }
             if (query) {
-                agents = await (0, api_1.searchAgents)(config, query, { sort, type: typeFilter });
-                await (0, analytics_1.track)('cli_search', { query, type: options.type });
+                agents = await (0, api_1.searchAgents)(config, query, { sort, tags, type: typeFilter });
+                await (0, analytics_1.track)('cli_search', { query, type: options.type, tags: options.tags });
             }
             else {
-                agents = await (0, api_1.listPublicAgents)(config, { sort, type: typeFilter });
-                await (0, analytics_1.track)('cli_search', { mode: options.popular ? 'popular' : 'recent', type: options.type });
+                agents = await (0, api_1.listPublicAgents)(config, { sort, tags, type: typeFilter });
+                await (0, analytics_1.track)('cli_search', { mode: options.popular ? 'popular' : 'recent', type: options.type, tags: options.tags });
             }
         }
         // Filter by pricing if requested

package/dist/commands/security.js

@@ -67,7 +67,7 @@ function formatSummaryOutput(result) {
     process.stdout.write('━'.repeat(50) + '\n\n');
     // Agent info
     process.stdout.write(`${chalk_1.default.bold('Agent:')} ${result.agent_id}\n`);
-    process.stdout.write(`${chalk_1.default.bold('Scan Time:')} ${result.scan_timestamp}\n\n`);
+    process.stdout.write(`${chalk_1.default.bold('Scan Time:')} ${result.scanned_at}\n\n`);
     // Risk level banner
     process.stdout.write(`${chalk_1.default.bold('Risk Level:')} ${riskLevelColor(result.risk_level)}\n\n`);
     // Summary stats
@@ -282,7 +282,7 @@ function generateMarkdownReport(result) {
     lines.push('# Security Scan Report');
     lines.push('');
     lines.push(`**Agent:** ${result.agent_id}`);
-    lines.push(`**Scan Time:** ${result.scan_timestamp}`);
+    lines.push(`**Scan Time:** ${result.scanned_at}`);
     lines.push(`**Risk Level:** ${result.risk_level.toUpperCase()}`);
     lines.push('');
     lines.push('## Summary');

package/dist/commands/star.js

@@ -33,9 +33,16 @@ function registerStarCommand(program) {
             process.stdout.write(`Removed star from ${org}/${name}/${version}\n`);
         }
         else {
-            await (0, api_1.starAgent)(config, agentInfo.id);
-            await (0, analytics_1.track)('cli_star', { agent: `${org}/${name}/${version}` });
-            process.stdout.write(`Starred ${org}/${name}/${version}\n`);
+            const result = await (0, api_1.starAgent)(config, agentInfo.id);
+            if (result.starred) {
+                await (0, analytics_1.track)('cli_star', { agent: `${org}/${name}/${version}` });
+                process.stdout.write(`Starred ${org}/${name}/${version}\n`);
+            }
+            else {
+                // Already starred — toggle off
+                await (0, api_1.unstarAgent)(config, agentInfo.id);
+                process.stdout.write(`Unstarred ${org}/${name}/${version}\n`);
+            }
         }
     });
 }

package/dist/commands/whoami.js

@@ -13,6 +13,24 @@ function registerWhoamiCommand(program) {
         process.stdout.write(`Logged in as: ${org.name}\n`);
         process.stdout.write(`Org slug: ${org.slug}\n`);
         process.stdout.write(`API URL: ${config.apiUrl}\n`);
+        // Show active workspace if one is set
+        const configFile = await (0, config_1.loadConfig)();
+        if (configFile.workspace) {
+            try {
+                const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+                const workspace = response.workspaces.find((w) => w.slug === configFile.workspace);
+                if (workspace) {
+                    process.stdout.write(`Active workspace: ${workspace.name} (${workspace.slug})\n`);
+                }
+                else {
+                    process.stdout.write(`Active workspace: ${configFile.workspace} (not found)\n`);
+                }
+            }
+            catch {
+                // Workspace fetch failed - show slug only
+                process.stdout.write(`Active workspace: ${configFile.workspace}\n`);
+            }
+        }
         // Show balance after org info
         try {
             const balance = await (0, api_1.getCreditsBalance)(config);

package/dist/index.js

@@ -47,8 +47,10 @@ const errors_1 = require("./lib/errors");
 const analytics_1 = require("./lib/analytics");
 const config_1 = require("./lib/config");
 const spinner_1 = require("./lib/spinner");
+const update_notifier_1 = require("./lib/update-notifier");
 const package_json_1 = __importDefault(require("../package.json"));
 (0, analytics_1.initPostHog)();
+(0, update_notifier_1.checkForUpdates)();
 const program = new commander_1.Command();
 program
     .name('orchagent')
@@ -89,4 +91,7 @@ async function main() {
 }
 main()
     .catch(errors_1.exitWithError)
-    .finally(() => (0, analytics_1.shutdownPostHog)());
+    .finally(() => {
+    (0, update_notifier_1.printUpdateNotification)();
+    return (0, analytics_1.shutdownPostHog)();
+});

package/dist/lib/api.js

@@ -238,6 +238,8 @@ async function listPublicAgents(config, options) {
     const params = new URLSearchParams();
     if (options?.sort)
         params.append('sort', options.sort);
+    if (options?.tags?.length)
+        params.append('tags', options.tags.join(','));
     if (options?.type)
         params.append('type', options.type);
     const queryStr = params.toString();
@@ -257,7 +259,7 @@ async function createAgent(config, data) {
     });
 }
 async function starAgent(config, agentId) {
-    await request(config, 'POST', `/agents/${agentId}/star`);
+    return request(config, 'POST', `/agents/${agentId}/star`);
 }
 async function unstarAgent(config, agentId) {
     await request(config, 'DELETE', `/agents/${agentId}/star`);

package/dist/lib/doctor/checks/llm.js

@@ -1,128 +1,150 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkServerLlmKeys = checkServerLlmKeys;
-exports.checkLocalLlmEnvVars = checkLocalLlmEnvVars;
 exports.runLlmChecks = runLlmChecks;
 const config_1 = require("../../config");
 const api_1 = require("../../api");
-// Common LLM provider environment variables
-const LLM_ENV_VARS = [
-    { name: 'OPENAI_API_KEY', provider: 'OpenAI' },
-    { name: 'ANTHROPIC_API_KEY', provider: 'Anthropic' },
-    { name: 'GOOGLE_API_KEY', provider: 'Google' },
-    { name: 'GEMINI_API_KEY', provider: 'Gemini' },
+// All supported LLM providers (single source of truth)
+const PROVIDERS = [
+    { id: 'openai', displayName: 'OpenAI', envVars: ['OPENAI_API_KEY'], keyPrefix: 'sk-' },
+    { id: 'anthropic', displayName: 'Anthropic', envVars: ['ANTHROPIC_API_KEY'], keyPrefix: 'sk-ant-' },
+    { id: 'gemini', displayName: 'Gemini', envVars: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'] },
+    { id: 'ollama', displayName: 'Ollama', envVars: ['OLLAMA_HOST'], isEndpoint: true },
 ];
 /**
- * Check if LLM keys are configured on the server.
+ * Get a format hint for a key value, or null if the format looks OK.
+ * Hints are informational only — never errors or warnings.
  */
-async function checkServerLlmKeys() {
-    const config = await (0, config_1.getResolvedConfig)();
-    if (!config.apiKey) {
-        return {
-            category: 'llm',
-            name: 'server_llm_keys',
-            status: 'warning',
-            message: 'Cannot check server LLM keys (not logged in)',
-            details: { reason: 'no api key' },
-        };
+function getFormatHint(provider, value) {
+    if ('isEndpoint' in provider && provider.isEndpoint)
+        return null;
+    if (!('keyPrefix' in provider) || !provider.keyPrefix)
+        return null;
+    const prefix = provider.keyPrefix;
+    if (!value.startsWith(prefix)) {
+        return `Key doesn't match expected format (${prefix}...)`;
     }
-    try {
-        const keys = await (0, api_1.fetchLlmKeys)(config);
-        if (keys.length === 0) {
-            return {
-                category: 'llm',
-                name: 'server_llm_keys',
-                status: 'warning',
-                message: 'No LLM keys configured on server',
-                fix: 'Run `orch keys add <provider>` or add keys at orchagent.io/settings',
-                details: { count: 0, providers: [] },
-            };
-        }
-        const providers = keys.map((k) => k.provider);
-        // Warn if only one provider configured (no fallback for rate limits)
-        if (keys.length === 1) {
-            return {
-                category: 'llm',
-                name: 'server_llm_keys',
-                status: 'warning',
-                message: `Only 1 LLM provider configured (${providers[0]}). Consider adding a backup for rate limit fallback.`,
-                fix: 'Run: orchagent keys add <provider>',
-                details: { count: keys.length, providers },
-            };
-        }
-        return {
-            category: 'llm',
-            name: 'server_llm_keys',
-            status: 'success',
-            message: `Server LLM keys configured (${providers.join(', ')})`,
-            details: { count: keys.length, providers },
-        };
-    }
-    catch (err) {
-        if (err instanceof api_1.ApiError && err.status === 401) {
-            return {
-                category: 'llm',
-                name: 'server_llm_keys',
-                status: 'warning',
-                message: 'Cannot check server LLM keys (auth failed)',
-                details: { error: err.message },
-            };
+    return null;
+}
+/**
+ * Gather per-provider status from server keys and local env vars.
+ */
+function gatherProviderStatuses(serverProviders) {
+    return PROVIDERS.map((provider) => {
+        // Server status
+        const server = serverProviders === null ? null : serverProviders.includes(provider.id);
+        // Local status — check each env var
+        let local = false;
+        let localEnvVar;
+        let formatHint;
+        for (const envVar of provider.envVars) {
+            const value = process.env[envVar];
+            if (value) {
+                local = true;
+                localEnvVar = envVar;
+                const hint = getFormatHint(provider, value);
+                if (hint)
+                    formatHint = hint;
+                break;
+            }
         }
         return {
-            category: 'llm',
-            name: 'server_llm_keys',
-            status: 'warning',
-            message: 'Could not check server LLM keys',
-            details: { error: err instanceof Error ? err.message : 'unknown error' },
+            providerId: provider.id,
+            displayName: provider.displayName,
+            server,
+            local,
+            localEnvVar,
+            formatHint,
         };
+    });
+}
+/**
+ * Build a human-readable location string from server/local status.
+ */
+function locationString(status) {
+    if (status.server === null) {
+        // Server unknown (offline)
+        if (status.local)
+            return 'Server unknown, local configured';
+        return 'Server unknown, not local';
     }
+    if (status.server && status.local)
+        return 'Configured (server + local)';
+    if (status.server)
+        return 'Configured (server)';
+    if (status.local)
+        return 'Configured (local)';
+    return 'Not configured';
 }
 /**
- * Check if common LLM provider API keys are set in environment.
+ * Run all LLM configuration checks with per-provider breakdown.
+ *
+ * When skipServer is true, server status is null for all providers
+ * (shown as "unknown" in output). Use this when the gateway is unreachable.
  */
-async function checkLocalLlmEnvVars() {
-    const configuredProviders = [];
-    const details = {};
-    for (const { name, provider } of LLM_ENV_VARS) {
-        const isSet = !!process.env[name];
-        details[name] = isSet;
-        if (isSet) {
-            configuredProviders.push(provider);
+async function runLlmChecks(options) {
+    let serverProviders = null;
+    if (!options?.skipServer) {
+        try {
+            const config = await (0, config_1.getResolvedConfig)();
+            if (config.apiKey) {
+                const keys = await (0, api_1.fetchLlmKeys)(config);
+                serverProviders = keys.map((k) => k.provider);
+            }
+        }
+        catch (err) {
+            // If we can't reach the server, treat as unknown
+            if (err instanceof api_1.ApiError && err.status === 401) {
+                // Auth failed — server providers unknown
+            }
+            // Network error or other — server providers unknown
         }
     }
-    if (configuredProviders.length === 0) {
-        return {
+    const statuses = gatherProviderStatuses(serverProviders);
+    const results = [];
+    // Per-provider results
+    for (const status of statuses) {
+        const configured = status.server === true || status.local;
+        results.push({
             category: 'llm',
-            name: 'local_llm_env',
-            status: 'warning',
-            message: 'No local LLM API keys found in environment',
-            fix: 'Set OPENAI_API_KEY, ANTHROPIC_API_KEY, or similar for local runs',
-            details,
-        };
+            name: `llm_provider_${status.providerId}`,
+            status: configured ? 'success' : 'info',
+            message: `${status.providerId} — ${locationString(status)}`,
+            details: {
+                providerId: status.providerId,
+                displayName: status.displayName,
+                server: status.server,
+                local: status.local,
+                ...(status.localEnvVar && { localEnvVar: status.localEnvVar }),
+                ...(status.formatHint && { formatHint: status.formatHint }),
+            },
+        });
     }
-    // Deduplicate (Google and Gemini might both be set)
-    const uniqueProviders = [...new Set(configuredProviders)];
-    return {
-        category: 'llm',
-        name: 'local_llm_env',
-        status: 'success',
-        message: `Local LLM keys found (${uniqueProviders.join(', ')})`,
-        details,
-    };
-}
-/**
- * Run all LLM configuration checks.
- * If server keys are configured, local keys warning becomes informational.
- */
-async function runLlmChecks() {
-    const serverResult = await checkServerLlmKeys();
-    const localResult = await checkLocalLlmEnvVars();
-    // If server keys are configured, downgrade local keys warning to info
-    // Users who only use server-side calls don't need local keys
-    if (serverResult.status === 'success' && localResult.status === 'warning') {
-        localResult.status = 'info';
-        localResult.message = 'No local LLM API keys (using server keys)';
-        localResult.fix = undefined;
+    // Summary result
+    const configuredCount = statuses.filter((s) => s.server === true || s.local).length;
+    const firstUnconfigured = statuses.find((s) => s.server !== true && !s.local);
+    let summaryStatus;
+    let summaryMessage;
+    let summaryFix;
+    if (configuredCount === 0) {
+        summaryStatus = 'warning';
+        summaryMessage = 'No LLM providers configured';
+        summaryFix = firstUnconfigured ? `Run: orch keys add ${firstUnconfigured.providerId}` : undefined;
+    }
+    else {
+        summaryStatus = 'success';
+        summaryMessage =
+            configuredCount < 2
+                ? 'Tip: Multiple providers enable automatic rate limit fallback.'
+                : `${configuredCount} providers configured`;
+        summaryFix = firstUnconfigured ? `Run: orch keys add ${firstUnconfigured.providerId}` : undefined;
     }
-    return [serverResult, localResult];
+    results.push({
+        category: 'llm',
+        name: 'llm_provider_summary',
+        status: summaryStatus,
+        message: summaryMessage,
+        fix: summaryFix,
+        details: { configuredCount, totalProviders: PROVIDERS.length },
+    });
+    return results;
 }