@orchagent/cli 0.3.86 → 0.3.87

package/dist/commands/run.js

@@ -37,10 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localCommandForEntrypoint = localCommandForEntrypoint;
+exports.validateInputSchema = validateInputSchema;
 exports.isKeyedFileArg = isKeyedFileArg;
 exports.readKeyedFiles = readKeyedFiles;
 exports.mountDirectory = mountDirectory;
 exports.buildInjectedPayload = buildInjectedPayload;
+exports.renderProgress = renderProgress;
 exports.registerRunCommand = registerRunCommand;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
@@ -188,6 +190,69 @@ function applySchemaDefaults(body, schema) {
     }
     return body;
 }
+/**
+ * Validates input data against an agent's input_schema before sending to the server.
+ * Returns an array of human-readable error strings. Empty array = valid.
+ */
+function validateInputSchema(body, schema) {
+    if (!schema)
+        return [];
+    const s = schema;
+    const props = s.properties;
+    if (!props || typeof props !== 'object')
+        return [];
+    const errors = [];
+    const required = (s.required ?? []);
+    // Check required fields
+    for (const field of required) {
+        if (body[field] === undefined || body[field] === null) {
+            const prop = props[field];
+            const desc = prop?.description ? ` (${prop.description})` : '';
+            errors.push(`Missing required field: "${field}"${desc}`);
+        }
+    }
+    // Check types of provided fields
+    for (const [key, value] of Object.entries(body)) {
+        const prop = props[key];
+        if (!prop || value === undefined || value === null)
+            continue;
+        const expectedType = prop.type;
+        if (!expectedType)
+            continue;
+        const actualType = Array.isArray(value) ? 'array' : typeof value;
+        let mismatch = false;
+        switch (expectedType) {
+            case 'string':
+                mismatch = actualType !== 'string';
+                break;
+            case 'number':
+            case 'integer':
+                mismatch = actualType !== 'number';
+                break;
+            case 'boolean':
+                mismatch = actualType !== 'boolean';
+                break;
+            case 'array':
+                mismatch = actualType !== 'array';
+                break;
+            case 'object':
+                mismatch = actualType !== 'object';
+                break;
+        }
+        if (mismatch) {
+            errors.push(`Field "${key}" should be ${expectedType}, got ${actualType}`);
+        }
+    }
+    return errors;
+}
+function warnInputSchemaErrors(body, schema) {
+    const errors = validateInputSchema(body, schema);
+    if (errors.length === 0)
+        return;
+    process.stderr.write(chalk_1.default.yellow(`\nInput validation warning:\n`) +
+        errors.map(e => chalk_1.default.yellow(`  - ${e}`)).join('\n') +
+        chalk_1.default.yellow('\n\nThe request will still be sent, but may fail server-side.\n\n'));
+}
 async function readStdin() {
     if (process.stdin.isTTY)
         return null;
@@ -853,7 +918,13 @@ async function executeAgentLocally(agentDir, prompt, inputData, outputSchema, cu
             try {
                 const result = JSON.parse(stdout.trim());
                 if (exitCode !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
-                    throw new errors_1.CliError(`Agent error: ${result.error}`);
+                    const errorText = String(result.error);
+                    const err = new errors_1.CliError(`Agent error: ${errorText}`);
+                    // BUG-13: If stderr already showed this error during execution, don't print again
+                    if (stderr.includes(errorText)) {
+                        err.displayed = true;
+                    }
+                    throw err;
                 }
                 if (exitCode !== 0) {
                     (0, output_1.printJson)(result);
@@ -871,6 +942,12 @@ async function executeAgentLocally(agentDir, prompt, inputData, outputSchema, cu
             }
         }
         else if (exitCode !== 0) {
+            // BUG-13: stderr was already relayed to user in real-time; don't embed it again
+            if (stderr.trim()) {
+                const err = new errors_1.CliError(`Agent exited with code ${exitCode}`);
+                err.displayed = true;
+                throw err;
+            }
             throw new errors_1.CliError(`Agent exited with code ${exitCode} (no output)\n\n` +
                 `Common causes:\n` +
                 `  - Missing LLM API key (check ${apiKeyEnvVar || 'API key env var'})\n` +
@@ -1177,7 +1254,13 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
             try {
                 const result = JSON.parse(stdout.trim());
                 if (exitCode !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
-                    throw new errors_1.CliError(`Agent error: ${result.error}`);
+                    const errorText = String(result.error);
+                    const err = new errors_1.CliError(`Agent error: ${errorText}`);
+                    // BUG-13: If stderr already showed this error during execution, don't print again
+                    if (stderr.includes(errorText)) {
+                        err.displayed = true;
+                    }
+                    throw err;
                 }
                 if (exitCode !== 0) {
                     (0, output_1.printJson)(result);
@@ -1195,8 +1278,11 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
             }
         }
         else if (exitCode !== 0) {
+            // BUG-13: stderr was already relayed to user in real-time; don't embed it again
             if (stderr.trim()) {
-                throw new errors_1.CliError(`Agent exited with code ${exitCode}\n\nError output:\n${stderr.trim()}`);
+                const err = new errors_1.CliError(`Agent exited with code ${exitCode}`);
+                err.displayed = true;
+                throw err;
             }
             throw new errors_1.CliError(`Agent exited with code ${exitCode} (no output)\n\n` +
                 `Common causes:\n` +
@@ -1592,7 +1678,13 @@ async function executeLocalFromDir(dirPath, args, options) {
         try {
             const result = JSON.parse(stdout.trim());
             if (exitCode !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
-                throw new errors_1.CliError(`Agent error: ${result.error}`);
+                const errorText = String(result.error);
+                const err = new errors_1.CliError(`Agent error: ${errorText}`);
+                // BUG-13: If stderr already showed this error during execution, don't print again
+                if (stderr.includes(errorText)) {
+                    err.displayed = true;
+                }
+                throw err;
             }
             if (exitCode !== 0) {
                 (0, output_1.printJson)(result);
@@ -1610,15 +1702,53 @@ async function executeLocalFromDir(dirPath, args, options) {
         }
     }
     else if (exitCode !== 0) {
+        // BUG-13: stderr was already relayed to user in real-time; don't repeat
+        if (stderr.trim()) {
+            const err = new errors_1.CliError(`Agent exited with code ${exitCode}`);
+            err.displayed = true;
+            throw err;
+        }
         throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
     }
 }
 // ─── Cloud execution path ───────────────────────────────────────────────────
-function renderProgress(event) {
+function renderProgress(event, verbose = false) {
     switch (event.type) {
         case 'turn_start':
             process.stderr.write(chalk_1.default.gray(`  Turn ${event.turn}/${event.max_turns}\n`));
             break;
+        case 'sandbox_start':
+            process.stderr.write(chalk_1.default.gray('  Starting sandbox...\n'));
+            break;
+        case 'setup_step': {
+            const name = String(event.name || 'setup');
+            const status = String(event.status || 'started');
+            const icon = status === 'completed' ? chalk_1.default.green('✓') : status === 'failed' ? chalk_1.default.red('x') : chalk_1.default.gray('·');
+            process.stderr.write(`  ${icon} ${chalk_1.default.gray(name)} ${chalk_1.default.gray(status)}\n`);
+            break;
+        }
+        case 'stdout': {
+            if (!verbose)
+                break;
+            const text = typeof event.text === 'string' ? event.text : '';
+            if (text)
+                process.stderr.write(chalk_1.default.gray(text));
+            break;
+        }
+        case 'stderr': {
+            if (!verbose)
+                break;
+            const text = typeof event.text === 'string' ? event.text : '';
+            if (text)
+                process.stderr.write(chalk_1.default.yellow(text));
+            break;
+        }
+        case 'heartbeat':
+            // Keepalive for long-running silent steps; avoid noisy output.
+            break;
+        case 'output_truncated':
+            process.stderr.write(chalk_1.default.yellow('  Live output truncated. Use `orch logs <run-id>` for full output.\n'));
+            break;
         case 'tool_call': {
             const icon = event.tool === 'bash'
                 ? '$'
@@ -1635,9 +1765,23 @@ function renderProgress(event) {
             if (event.status === 'error')
                 process.stderr.write(chalk_1.default.yellow(`      (error)\n`));
             break;
-        case 'done':
+        case 'done': {
             process.stderr.write(chalk_1.default.green(`  Done\n`));
+            // In verbose mode, show exit code and execution time from done event
+            if (verbose) {
+                const parts = [];
+                if (typeof event.exit_code === 'number' && event.exit_code !== 0) {
+                    parts.push(`exit_code=${event.exit_code}`);
+                }
+                if (typeof event.execution_time_ms === 'number') {
+                    parts.push(`${(event.execution_time_ms / 1000).toFixed(1)}s`);
+                }
+                if (parts.length > 0) {
+                    process.stderr.write(chalk_1.default.gray(`  (${parts.join(', ')})\n`));
+                }
+            }
             break;
+        }
         case 'error':
             process.stderr.write(chalk_1.default.red(`  Error: ${event.message}\n`));
             break;
@@ -1696,6 +1840,50 @@ async function executeCloud(agentRef, file, options) {
             }
         }
     }
+    // --estimate: show cost estimate before running and ask for confirmation
+    if (options.estimate) {
+        try {
+            const est = await (0, api_1.getAgentCostEstimate)(resolved, org, parsed.agent, parsed.version);
+            const e = est.estimate;
+            if (e.sample_size === 0) {
+                process.stderr.write(chalk_1.default.yellow('\nNo run history available for cost estimation.\n'));
+                process.stderr.write(chalk_1.default.gray('This agent has not been run before — cost data will appear after first run.\n\n'));
+            }
+            else {
+                const fmtUsd = (v) => {
+                    if (v < 0.001)
+                        return '<$0.001';
+                    if (v < 0.01)
+                        return `$${v.toFixed(4)}`;
+                    if (v < 1)
+                        return `$${v.toFixed(3)}`;
+                    return `$${v.toFixed(2)}`;
+                };
+                process.stderr.write('\n' + chalk_1.default.bold('Cost Estimate') + chalk_1.default.gray(` (${e.sample_size} runs, last ${e.period_days}d)`) + '\n');
+                process.stderr.write(`  Average: ${chalk_1.default.green(fmtUsd(e.avg_cost_usd))}  ·  Median: ${chalk_1.default.green(fmtUsd(e.p50_cost_usd))}  ·  95th pct: ${chalk_1.default.yellow(fmtUsd(e.p95_cost_usd))}\n`);
+                if (e.provider_breakdown && e.provider_breakdown.length > 0) {
+                    const parts = e.provider_breakdown.map(p => `${p.provider}: ${fmtUsd(p.avg_cost_usd)}`).join(', ');
+                    process.stderr.write(chalk_1.default.gray(`  By provider: ${parts}\n`));
+                }
+                process.stderr.write('\n');
+            }
+            // Ask for confirmation
+            const rl = await Promise.resolve().then(() => __importStar(require('readline')));
+            const iface = rl.createInterface({ input: process.stdin, output: process.stderr });
+            const answer = await new Promise(resolve => {
+                iface.question('Proceed with run? [Y/n] ', resolve);
+            });
+            iface.close();
+            if (answer.trim().toLowerCase() === 'n') {
+                process.stderr.write('Run cancelled.\n');
+                return;
+            }
+        }
+        catch {
+            // Non-fatal: if estimate fails, proceed with the run
+            process.stderr.write(chalk_1.default.gray('Could not fetch cost estimate. Proceeding...\n\n'));
+        }
+    }
     const endpoint = options.endpoint?.trim() || agentMeta.default_endpoint || 'analyze';
     const headers = {
         Authorization: `Bearer ${resolved.apiKey}`,
@@ -1811,6 +1999,8 @@ async function executeCloud(agentRef, file, options) {
             mountArgs: options.mount,
             llmCredentials,
         });
+        const injectedObj = JSON.parse(injected.body);
+        warnInputSchemaErrors(injectedObj, agentMeta.input_schema);
         body = injected.body;
         sourceLabel = injected.sourceLabel;
         headers['Content-Type'] = 'application/json';
@@ -1851,6 +2041,7 @@ async function executeCloud(agentRef, file, options) {
                     }
                 }
                 applySchemaDefaults(bodyObj, agentMeta.input_schema);
+                warnInputSchemaErrors(bodyObj, agentMeta.input_schema);
                 if (llmCredentials)
                     bodyObj.llm_credentials = llmCredentials;
                 body = JSON.stringify(bodyObj);
@@ -1872,14 +2063,12 @@ async function executeCloud(agentRef, file, options) {
         else if (options.data) {
             const resolvedBody = await resolveJsonBody(options.data);
             warnIfLocalPathReference(resolvedBody);
+            const parsedBody = JSON.parse(resolvedBody);
+            warnInputSchemaErrors(parsedBody, agentMeta.input_schema);
             if (llmCredentials) {
-                const bodyObj = JSON.parse(resolvedBody);
-                bodyObj.llm_credentials = llmCredentials;
-                body = JSON.stringify(bodyObj);
-            }
-            else {
-                body = resolvedBody;
+                parsedBody.llm_credentials = llmCredentials;
             }
+            body = JSON.stringify(parsedBody);
             headers['Content-Type'] = 'application/json';
         }
         else if ((filePaths.length > 0 || options.metadata) && cloudEngine !== 'code_runtime') {
@@ -1919,6 +2108,7 @@ async function executeCloud(agentRef, file, options) {
                 }
             }
             applySchemaDefaults(bodyObj, agentMeta.input_schema);
+            warnInputSchemaErrors(bodyObj, agentMeta.input_schema);
             if (llmCredentials) {
                 bodyObj.llm_credentials = llmCredentials;
             }
@@ -1948,16 +2138,27 @@ async function executeCloud(agentRef, file, options) {
     } // end of non-injection path
     const verboseQs = options.verbose ? '?verbose=true' : '';
     const url = `${resolved.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}${verboseQs}`;
-    // Enable SSE streaming for managed-loop agents (unless --json or --no-stream or --output)
+    // Enable SSE streaming for sandbox-backed engines (unless --json or --no-stream or --output)
     const isManagedLoopAgent = cloudType === 'agent' && cloudEngine === 'managed_loop';
-    const wantStream = isManagedLoopAgent && !options.json && !options.noStream && !options.output;
+    const isCodeRuntimeAgent = cloudEngine === 'code_runtime';
+    const streamCapable = isManagedLoopAgent || isCodeRuntimeAgent;
+    const streamDisabled = options.stream === false || options.noStream === true;
+    const wantStream = streamCapable && !options.json && !streamDisabled && !options.output;
     if (wantStream) {
         headers['Accept'] = 'text/event-stream';
     }
-    const spinner = options.json ? null : (0, spinner_1.createSpinner)(`Running ${org}/${parsed.agent}@${parsed.version}...`);
+    // Print verbose debug info before request
+    if (options.verbose && !options.json) {
+        process.stderr.write(chalk_1.default.gray(`\n[verbose] ${org}/${parsed.agent}@${parsed.version}\n` +
+            `[verbose] type=${cloudType}  engine=${cloudEngine}  endpoint=${endpoint}\n` +
+            `[verbose] stream=${wantStream ? 'yes' : 'no'}  url=${url}\n`));
+    }
+    const { spinner, dispose: disposeSpinner } = options.json
+        ? { spinner: null, dispose: () => { } }
+        : (0, spinner_1.createElapsedSpinner)(`Running ${org}/${parsed.agent}@${parsed.version}...`);
     spinner?.start();
-    // Managed-loop runs can take longer; use 10 min timeout for streaming.
-    const timeoutMs = isManagedLoopAgent ? 600000 : undefined;
+    // Streamed sandbox runs can take longer; use 10 min timeout.
+    const timeoutMs = wantStream ? 600000 : undefined;
     let response;
     try {
         response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
@@ -1990,7 +2191,7 @@ async function executeCloud(agentRef, file, options) {
                 : undefined;
             throw new errors_1.CliError(`Your CLI version (${package_json_1.default.version}) is too old.\n\n` +
                 (minVersion ? `Minimum required: ${minVersion}\n` : '') +
-                'Update with: npm update -g @orchagent/cli');
+                'Update with: npm install -g @orchagent/cli@latest');
         }
         if (errorCode === 'LLM_KEY_REQUIRED') {
             spinner?.stop();
@@ -2021,6 +2222,14 @@ async function executeCloud(agentRef, file, options) {
             const hint = typeof payload === 'object' && payload
                 ? payload.error?.hint
                 : undefined;
+            // Read error category from gateway (UX-7)
+            const errorCategory = typeof payload === 'object' && payload
+                ? payload.error?.category
+                : undefined;
+            // Read sandbox_exit_code for backward compat with older gateways
+            const sandboxExitCode = typeof payload === 'object' && payload
+                ? payload.metadata?.sandbox_exit_code
+                : undefined;
             // Detect platform errors that surface as SANDBOX_ERROR (BUG-11)
             const lowerMessage = (message || '').toLowerCase();
             const isPlatformError = /\b403\b/.test(message || '') ||
@@ -2028,11 +2237,27 @@ async function executeCloud(agentRef, file, options) {
                 lowerMessage.includes('proxy token') ||
                 lowerMessage.includes('orchagent_service_key') ||
                 lowerMessage.includes('orchagent_billing_org');
-            const attribution = isPlatformError
-                ? `This may be a platform configuration issue, not an error in the agent's code.\n` +
-                    `If this persists, contact support with the ref below.`
-                : `This is an error in the agent's code, not the platform.\n` +
-                    `Check the agent code and requirements, then republish.`;
+            // Categorize: platform > gateway category > exit_code heuristic > neutral
+            let attribution;
+            if (isPlatformError) {
+                attribution =
+                    `This may be a platform configuration issue, not an error in the agent's code.\n` +
+                        `If this persists, contact support with the ref below.`;
+            }
+            else if (errorCategory === 'code_error' || (!errorCategory && sandboxExitCode != null && sandboxExitCode !== 0)) {
+                attribution =
+                    `This is an error in the agent's code, not the platform.\n` +
+                        `Check the agent code and requirements, then republish.`;
+            }
+            else if (errorCategory === 'setup_error') {
+                attribution =
+                    `The agent failed during setup. This may be a dependency or configuration issue.\n` +
+                        `Check requirements.txt and environment configuration.`;
+            }
+            else {
+                // No category from gateway, no exit code — can't determine blame
+                attribution = `Agent execution failed. Check agent logs for details.`;
+            }
             throw new errors_1.CliError(`${message}\n\n` +
                 attribution +
                 (hint ? `\n\nHint: ${hint}` : '') +
@@ -2095,11 +2320,22 @@ async function executeCloud(agentRef, file, options) {
         const { parseSSE } = await Promise.resolve().then(() => __importStar(require('../lib/sse.js')));
         let finalPayload = null;
         let hadError = false;
-        process.stderr.write(chalk_1.default.gray(`\nStreaming ${org}/${parsed.agent}@${parsed.version}:\n`));
+        if (options.verbose) {
+            process.stderr.write(chalk_1.default.gray(`\nStreaming ${org}/${parsed.agent}@${parsed.version} (verbose):\n`));
+            process.stderr.write(chalk_1.default.gray(`  type=${cloudType}  engine=${cloudEngine}  endpoint=${endpoint}\n`));
+        }
+        else {
+            process.stderr.write(chalk_1.default.gray(`\nStreaming ${org}/${parsed.agent}@${parsed.version}:\n`));
+        }
+        let progressErrorShown = false;
         for await (const { event, data } of parseSSE(response.body)) {
             if (event === 'progress') {
                 try {
-                    renderProgress(JSON.parse(data));
+                    const parsed = JSON.parse(data);
+                    renderProgress(parsed, !!options.verbose);
+                    if (parsed.type === 'error') {
+                        progressErrorShown = true;
+                    }
                 }
                 catch {
                     // ignore malformed progress events
@@ -2134,7 +2370,12 @@ async function executeCloud(agentRef, file, options) {
             const errMsg = typeof finalPayload === 'object' && finalPayload
                 ? finalPayload.error?.message || 'Agent execution failed'
                 : 'Agent execution failed';
-            throw new errors_1.CliError(errMsg);
+            const err = new errors_1.CliError(errMsg);
+            // BUG-13: Error was already displayed by renderProgress during streaming
+            if (progressErrorShown) {
+                err.displayed = true;
+            }
+            throw err;
         }
         if (finalPayload !== null) {
             (0, output_1.printJson)(finalPayload);
@@ -2341,6 +2582,7 @@ async function executeLocal(agentRef, args, options) {
         catch {
             throw new errors_1.CliError('Invalid JSON input');
         }
+        warnInputSchemaErrors(agentInputData, agentData.input_schema);
         // Write prompt to temp dir and run
         const tempAgentDir = path_1.default.join(os_1.default.tmpdir(), `orchagent-agent-${parsed.agent}-${Date.now()}`);
         await promises_1.default.mkdir(tempAgentDir, { recursive: true });
@@ -2466,6 +2708,7 @@ async function executeLocal(agentRef, args, options) {
             throw new errors_1.CliError('Invalid JSON input');
         }
     }
+    warnInputSchemaErrors(inputData, agentData.input_schema);
     // Handle skill composition
     let skillPrompts = [];
     if (!options.noSkills) {
@@ -2495,14 +2738,15 @@ function registerRunCommand(program) {
         .option('--data <json>', 'JSON payload (string or @file, @- for stdin)')
         .option('--input <json>', 'Alias for --data')
         .option('--json', 'Output raw JSON')
-        .option('--verbose', 'Show sandbox stdout/stderr output (cloud only)')
+        .option('--verbose', 'Show sandbox stdout/stderr and debug info (cloud only)')
+        .option('--estimate', 'Show cost estimate before running and ask for confirmation')
         .option('--provider <provider>', 'LLM provider (openai, anthropic, gemini, ollama)')
         .option('--model <model>', 'LLM model to use (overrides agent default)')
         .option('--key <key>', 'LLM API key (overrides env vars)')
         .option('--skills <skills>', 'Add skills (comma-separated)')
         .option('--skills-only <skills>', 'Use only these skills')
         .option('--no-skills', 'Ignore default skills')
-        .option('--no-stream', 'Disable real-time streaming for agent-type agents')
+        .option('--no-stream', 'Disable real-time streaming for stream-capable sandbox runs')
         // Cloud-only options
         .option('--endpoint <endpoint>', 'Override agent endpoint (cloud only)')
         .option('--tenant <tenant>', 'Tenant identifier for multi-tenant callers (cloud only)')

package/dist/commands/schedule.js

@@ -196,14 +196,16 @@ function registerScheduleCommand(program) {
         });
         const s = result.schedule;
         process.stdout.write(chalk_1.default.green('\u2713') + ` Schedule created\n\n`);
-        process.stdout.write(`  ID:     ${s.id}\n`);
-        process.stdout.write(`  Agent:  ${s.agent_name}@${s.agent_version}\n`);
-        process.stdout.write(`  Type:   ${s.schedule_type}\n`);
+        process.stdout.write(`  ID:          ${s.id}\n`);
+        process.stdout.write(`  Agent:       ${s.agent_name}@${s.agent_version}\n`);
+        process.stdout.write(`  Type:        ${s.schedule_type}\n`);
+        process.stdout.write(`  Enabled:     ${chalk_1.default.green('yes')}\n`);
+        process.stdout.write(`  Auto-update: ${s.auto_update === false ? chalk_1.default.yellow('no (pinned)') : chalk_1.default.green('yes')}\n`);
         if (s.schedule_type === 'cron') {
-            process.stdout.write(`  Cron:   ${s.cron_expression}\n`);
-            process.stdout.write(`  TZ:     ${s.timezone}\n`);
+            process.stdout.write(`  Cron:        ${s.cron_expression}\n`);
+            process.stdout.write(`  Timezone:    ${s.timezone}\n`);
             if (s.next_run_at) {
-                process.stdout.write(`  Next:   ${formatDate(s.next_run_at)}\n`);
+                process.stdout.write(`  Next run:    ${formatDate(s.next_run_at)}\n`);
             }
         }
         else {
@@ -212,6 +214,9 @@ function registerScheduleCommand(program) {
                 process.stdout.write(`  ${s.webhook_url}\n`);
             }
         }
+        if (s.llm_provider) {
+            process.stdout.write(`  Provider:    ${s.llm_provider}\n`);
+        }
         process.stdout.write('\n');
     });
     // orch schedule update <schedule-id>

package/dist/commands/test.js

@@ -17,6 +17,7 @@ const dotenv_1 = require("../lib/dotenv");
 const config_1 = require("../lib/config");
 const llm_1 = require("../lib/llm");
 const bundle_1 = require("../lib/bundle");
+const test_mock_runner_1 = require("../lib/test-mock-runner");
 // ─── Utility functions ───────────────────────────────────────────────────────
 function validateFixture(data, fixturePath) {
     const fileName = path_1.default.basename(fixturePath);
@@ -793,6 +794,13 @@ async function executeTests(agentDir, validation, testFiles, verbose, config) {
             process.stderr.write(chalk_1.default.gray('    "expected_contains": ["response"]\n'));
             process.stderr.write(chalk_1.default.gray('  }\n\n'));
             if (validation.executionEngine === 'managed_loop') {
+                process.stderr.write('For orchestrators with sub-agents, add mocked fixtures:\n');
+                process.stderr.write(chalk_1.default.gray('  # tests/fixture-mock-basic.json\n'));
+                process.stderr.write(chalk_1.default.gray('  {\n'));
+                process.stderr.write(chalk_1.default.gray('    "input": {"task": "..."},\n'));
+                process.stderr.write(chalk_1.default.gray('    "mocks": {"tool_name": {"key": "mock response"}},\n'));
+                process.stderr.write(chalk_1.default.gray('    "expected_contains": ["expected"]\n'));
+                process.stderr.write(chalk_1.default.gray('  }\n\n'));
                 process.stderr.write('Or test the full agent loop:\n');
                 process.stderr.write(chalk_1.default.gray(`  orch run . --local --data '{"task": "..."}'\n\n`));
             }
@@ -833,8 +841,51 @@ async function executeTests(agentDir, validation, testFiles, verbose, config) {
             if (code !== 0)
                 exitCode = 1;
         }
+        else if (validation.executionEngine === 'managed_loop') {
+            // For managed_loop agents, split fixtures: mocked vs regular
+            const mockedFixtures = [];
+            const regularFixtures = [];
+            for (const fixturePath of testFiles.fixtures) {
+                try {
+                    const raw = await promises_1.default.readFile(fixturePath, 'utf-8');
+                    const data = JSON.parse(raw);
+                    if (data.mocks && typeof data.mocks === 'object' && !Array.isArray(data.mocks)) {
+                        mockedFixtures.push(fixturePath);
+                    }
+                    else {
+                        regularFixtures.push(fixturePath);
+                    }
+                }
+                catch {
+                    regularFixtures.push(fixturePath); // Let downstream validation handle errors
+                }
+            }
+            // Run mocked orchestration tests (full agent loop with mock sub-agents)
+            if (mockedFixtures.length > 0) {
+                try {
+                    const manifestPath = path_1.default.join(agentDir, 'orchagent.json');
+                    const manifestRaw = await promises_1.default.readFile(manifestPath, 'utf-8');
+                    const manifest = JSON.parse(manifestRaw);
+                    const code = await (0, test_mock_runner_1.runMockedAgentFixtureTests)(agentDir, mockedFixtures, manifest, verbose, config);
+                    if (code !== 0)
+                        exitCode = 1;
+                }
+                catch (err) {
+                    if (err instanceof errors_1.CliError)
+                        throw err;
+                    process.stderr.write(chalk_1.default.red(`  Error running mocked tests: ${err.message}\n`));
+                    exitCode = 1;
+                }
+            }
+            // Run regular (non-mocked) fixtures as LLM-based prompt tests
+            if (regularFixtures.length > 0) {
+                const code = await runPromptFixtureTests(agentDir, regularFixtures, verbose, config);
+                if (code !== 0)
+                    exitCode = 1;
+            }
+        }
         else {
-            // Prompt, skill, and managed_loop agents: LLM-based fixture tests
+            // Prompt, skill agents: LLM-based fixture tests
             const code = await runPromptFixtureTests(agentDir, testFiles.fixtures, verbose, config);
             if (code !== 0)
                 exitCode = 1;
@@ -1040,6 +1091,22 @@ Fixture Format (tests/fixture-basic.json):
   For code_runtime agents, fixtures run your entrypoint with input as stdin.
   For prompt/agent types, fixtures call the LLM with your prompt + input.
 
+Mocked Orchestration Tests (tests/fixture-mock-*.json):
+  For agent-type (managed_loop) orchestrators, add "mocks" to test the full
+  agent loop with deterministic sub-agent responses:
+  {
+    "description": "Orchestrator handles scan results",
+    "input": {"code": "import os"},
+    "mocks": {
+      "scan_secrets": {"findings": [{"type": "code_injection"}]},
+      "scan_deps": {"vulnerabilities": []}
+    },
+    "expected_contains": ["code_injection"]
+  }
+
+  The LLM runs the full tool-use loop, but custom tool calls return mock
+  responses instead of calling real sub-agents. Great for CI testing.
+
 Run mode (--run):
   Validates the agent, then executes it once with the provided --data.
   Loads .env automatically. Same interface as: orch run . --local --data '...'