@orchagent/cli 0.3.90 → 0.3.92

package/dist/commands/info.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const agent_ref_1 = require("../lib/agent-ref");
+const errors_1 = require("../lib/errors");
 function formatSchema(schema, indent = '  ') {
     const lines = [];
     const props = schema.properties || {};
@@ -147,7 +148,13 @@ function registerInfoCommand(program) {
         .option('--json', 'Output as JSON')
         .action(async (agentArg, options) => {
         const config = await (0, config_1.getResolvedConfig)();
-        const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const parsed = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = parsed.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
+        const { agent, version } = parsed;
         // Resolve workspace context for the target org
         const workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, org);
         // Fetch agent metadata

package/dist/commands/init-wizard.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Interactive wizard for `orch init`.
+ *
+ * Runs when `orch init` is invoked without arguments in a TTY.
+ * Uses Node.js built-in readline/promises — no extra dependencies.
+ *
+ * The wizard leads with "What do you want to build?" to directly address
+ * the most common new-user friction — not knowing which type/flavor to pick.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_REGISTRY = void 0;
+exports.runInitWizard = runInitWizard;
+exports.printTemplateList = printTemplateList;
+const promises_1 = __importDefault(require("readline/promises"));
+const path_1 = __importDefault(require("path"));
+exports.TEMPLATE_REGISTRY = [
+    { name: 'cron-job', description: 'Scheduled task — daily reports, syncs, cleanups', type: 'tool', language: 'both', runMode: 'on_demand' },
+    { name: 'discord', description: 'Discord bot powered by Claude (Python)', type: 'agent', language: 'python', runMode: 'always_on' },
+    { name: 'discord-js', description: 'Discord bot powered by Claude (JavaScript)', type: 'agent', language: 'javascript', runMode: 'always_on' },
+    { name: 'support-agent', description: 'Multi-platform support agent (Discord/Telegram/Slack)', type: 'agent', language: 'python', runMode: 'always_on' },
+    { name: 'fan-out', description: 'Parallel orchestration — call agents concurrently', type: 'agent', language: 'both', runMode: 'on_demand' },
+    { name: 'pipeline', description: 'Sequential orchestration — chain agents in series', type: 'agent', language: 'both', runMode: 'on_demand' },
+    { name: 'map-reduce', description: 'Map-reduce orchestration — split, process, aggregate', type: 'agent', language: 'both', runMode: 'on_demand' },
+    { name: 'github-weekly-summary', description: 'GitHub activity analyser with Discord delivery', type: 'agent', language: 'python', runMode: 'on_demand' },
+];
+// ---------------------------------------------------------------------------
+// Prompt helpers (readline-based, no dependencies)
+// ---------------------------------------------------------------------------
+function createInterface() {
+    return promises_1.default.createInterface({
+        input: process.stdin,
+        output: process.stderr, // prompts on stderr so stdout stays clean for piping
+    });
+}
+async function promptText(rl, question, defaultValue) {
+    const suffix = defaultValue ? ` (${defaultValue})` : '';
+    const answer = await rl.question(`  ${question}${suffix}: `);
+    return answer.trim() || defaultValue || '';
+}
+async function promptSelect(rl, question, options) {
+    process.stderr.write(`\n  ${question}\n`);
+    for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        process.stderr.write(`    ${i + 1}) ${opt.label}  — ${opt.description}\n`);
+    }
+    process.stderr.write('\n');
+    while (true) {
+        const answer = await rl.question(`  Choice [1-${options.length}]: `);
+        const num = parseInt(answer.trim(), 10);
+        if (num >= 1 && num <= options.length) {
+            return options[num - 1].value;
+        }
+        process.stderr.write(`  Please enter a number between 1 and ${options.length}.\n`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Language follow-up (shared by several use cases)
+// ---------------------------------------------------------------------------
+async function promptLanguage(rl) {
+    return promptSelect(rl, 'Language?', [
+        { value: 'python', label: 'Python', description: 'Recommended — broadest library support' },
+        { value: 'javascript', label: 'JavaScript', description: 'Node.js runtime' },
+    ]);
+}
+// ---------------------------------------------------------------------------
+// "More templates" sub-flow
+// ---------------------------------------------------------------------------
+async function handleMoreTemplates(rl, nameForResult) {
+    const language = await promptLanguage(rl);
+    const applicableTemplates = exports.TEMPLATE_REGISTRY.filter(t => t.language === 'both' || t.language === language);
+    const templateOptions = [
+        { value: 'none', label: 'No template', description: 'Start from scratch (choose type manually)' },
+        ...applicableTemplates.map(t => ({
+            value: t.name,
+            label: t.name,
+            description: t.description,
+        })),
+    ];
+    const template = await promptSelect(rl, 'Pick a template:', templateOptions);
+    if (template !== 'none') {
+        const info = exports.TEMPLATE_REGISTRY.find(t => t.name === template);
+        rl.close();
+        return {
+            name: nameForResult,
+            type: info.type,
+            language,
+            template,
+            runMode: info.runMode,
+            orchestrator: false,
+            loop: false,
+        };
+    }
+    // No template — fall back to manual type selection
+    const type = await promptSelect(rl, 'Agent type?', [
+        { value: 'prompt', label: 'prompt', description: 'Single LLM call with structured I/O' },
+        { value: 'tool', label: 'tool', description: 'Your own code (API calls, file processing)' },
+        { value: 'agent', label: 'agent', description: 'Multi-step LLM reasoning with tool use' },
+    ]);
+    let runMode = 'on_demand';
+    let orchestrator = false;
+    let loop = false;
+    if (type === 'tool') {
+        runMode = await promptSelect(rl, 'Run mode?', [
+            { value: 'on_demand', label: 'on_demand', description: 'Run per invocation (default)' },
+            { value: 'always_on', label: 'always_on', description: 'Long-lived HTTP service' },
+        ]);
+    }
+    if (type === 'agent') {
+        runMode = await promptSelect(rl, 'Run mode?', [
+            { value: 'on_demand', label: 'on_demand', description: 'Run per invocation (default)' },
+            { value: 'always_on', label: 'always_on', description: 'Long-lived HTTP service' },
+        ]);
+        const subtypeOptions = [
+            { value: 'code', label: 'Code runtime', description: 'You write the logic (call any LLM provider)' },
+            { value: 'orchestrator', label: 'Orchestrator', description: 'Coordinate other agents via SDK' },
+        ];
+        if (language === 'python') {
+            subtypeOptions.push({ value: 'loop', label: 'Managed loop', description: 'Platform-managed LLM loop with tool use' });
+        }
+        const agentSubtype = await promptSelect(rl, 'Agent execution mode?', subtypeOptions);
+        orchestrator = agentSubtype === 'orchestrator';
+        loop = agentSubtype === 'loop';
+    }
+    rl.close();
+    return { name: nameForResult, type, language, template: undefined, runMode, orchestrator, loop };
+}
+// ---------------------------------------------------------------------------
+// Wizard
+// ---------------------------------------------------------------------------
+async function runInitWizard() {
+    const rl = createInterface();
+    try {
+        process.stderr.write('\n  orch init — interactive setup\n');
+        process.stderr.write('  ─────────────────────────────\n\n');
+        // 1. Agent name
+        const dirName = path_1.default.basename(process.cwd());
+        const name = await promptText(rl, 'Agent name', dirName);
+        const nameForResult = name !== dirName ? name : undefined;
+        // 2. What do you want to build? (use-case-driven — replaces type/template questions)
+        const useCase = await promptSelect(rl, 'What do you want to build?', [
+            { value: 'prompt', label: 'Prompt agent', description: 'Single LLM call with structured I/O (simplest)' },
+            { value: 'tool-py', label: 'Tool (Python)', description: 'Your code processes data (stdin/stdout JSON)' },
+            { value: 'tool-js', label: 'Tool (JavaScript)', description: 'Your code processes data (Node.js)' },
+            { value: 'cron-job', label: 'Scheduled job', description: 'Runs on a cron schedule (reports, syncs, cleanups)' },
+            { value: 'discord-bot', label: 'Discord bot', description: 'Always-on chatbot in Discord channels' },
+            { value: 'orchestrator', label: 'Orchestrator', description: 'Coordinate multiple agents via SDK' },
+            { value: 'agent-loop', label: 'AI agent (LLM loop)', description: 'Multi-step reasoning with tool use' },
+            { value: 'skill', label: 'Knowledge skill', description: 'Reusable knowledge module for other agents' },
+            { value: 'more', label: 'More templates...', description: 'Fan-out, pipeline, map-reduce, support agent, etc.' },
+        ]);
+        // --- Direct-resolution use cases (no follow-up needed) ---
+        if (useCase === 'prompt') {
+            rl.close();
+            return { name: nameForResult, type: 'prompt', language: 'python', template: undefined, runMode: 'on_demand', orchestrator: false, loop: false };
+        }
+        if (useCase === 'skill') {
+            rl.close();
+            return { name: nameForResult, type: 'skill', language: 'python', template: undefined, runMode: 'on_demand', orchestrator: false, loop: false };
+        }
+        if (useCase === 'tool-py') {
+            rl.close();
+            return { name: nameForResult, type: 'tool', language: 'python', template: undefined, runMode: 'on_demand', orchestrator: false, loop: false };
+        }
+        if (useCase === 'tool-js') {
+            rl.close();
+            return { name: nameForResult, type: 'tool', language: 'javascript', template: undefined, runMode: 'on_demand', orchestrator: false, loop: false };
+        }
+        if (useCase === 'agent-loop') {
+            rl.close();
+            return { name: nameForResult, type: 'agent', language: 'python', template: undefined, runMode: 'on_demand', orchestrator: false, loop: true };
+        }
+        // --- Use cases that need a language follow-up ---
+        if (useCase === 'cron-job') {
+            const lang = await promptLanguage(rl);
+            rl.close();
+            return { name: nameForResult, type: 'tool', language: lang, template: 'cron-job', runMode: 'on_demand', orchestrator: false, loop: false };
+        }
+        if (useCase === 'discord-bot') {
+            const lang = await promptSelect(rl, 'Language?', [
+                { value: 'python', label: 'Python', description: 'Recommended — discord.py + anthropic' },
+                { value: 'javascript', label: 'JavaScript', description: 'discord.js + @anthropic-ai/sdk' },
+            ]);
+            const template = lang === 'javascript' ? 'discord-js' : 'discord';
+            rl.close();
+            return { name: nameForResult, type: 'agent', language: lang, template, runMode: 'always_on', orchestrator: false, loop: false };
+        }
+        if (useCase === 'orchestrator') {
+            const lang = await promptLanguage(rl);
+            rl.close();
+            return { name: nameForResult, type: 'agent', language: lang, template: undefined, runMode: 'on_demand', orchestrator: true, loop: false };
+        }
+        // --- "More templates..." sub-flow ---
+        if (useCase === 'more') {
+            return handleMoreTemplates(rl, nameForResult);
+        }
+        // Shouldn't reach here, but handle gracefully
+        rl.close();
+        return { name: nameForResult, type: 'prompt', language: 'python', template: undefined, runMode: 'on_demand', orchestrator: false, loop: false };
+    }
+    catch (err) {
+        rl.close();
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// List templates (for --list-templates flag)
+// ---------------------------------------------------------------------------
+function printTemplateList() {
+    process.stdout.write('\nAvailable templates:\n\n');
+    const nameWidth = Math.max(...exports.TEMPLATE_REGISTRY.map(t => t.name.length)) + 2;
+    const langWidth = 12;
+    process.stdout.write(`  ${'TEMPLATE'.padEnd(nameWidth)}${'LANGUAGE'.padEnd(langWidth)}${'RUN MODE'.padEnd(12)}DESCRIPTION\n`);
+    process.stdout.write(`  ${'─'.repeat(nameWidth)}${'─'.repeat(langWidth)}${'─'.repeat(12)}${'─'.repeat(40)}\n`);
+    for (const t of exports.TEMPLATE_REGISTRY) {
+        const lang = t.language === 'both' ? 'py / js' : t.language === 'python' ? 'python' : 'javascript';
+        process.stdout.write(`  ${t.name.padEnd(nameWidth)}${lang.padEnd(langWidth)}${t.runMode.padEnd(12)}${t.description}\n`);
+    }
+    process.stdout.write('\nUsage:\n');
+    process.stdout.write('  orch init my-agent --template <name>\n');
+    process.stdout.write('  orch init my-agent --template <name> --language javascript\n\n');
+}

package/dist/commands/init.js

@@ -4,10 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInitCommand = registerInitCommand;
+const commander_1 = require("commander");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const errors_1 = require("../lib/errors");
+const init_wizard_1 = require("./init-wizard");
 const github_weekly_summary_1 = require("./templates/github-weekly-summary");
+const cron_job_1 = require("./templates/cron-job");
 const support_agent_1 = require("./templates/support-agent");
 const MANIFEST_TEMPLATE = `{
   "name": "my-agent",
@@ -1498,15 +1501,49 @@ function resolveInitFlavor(typeOption) {
 function registerInitCommand(program) {
     program
         .command('init')
-        .description('Initialize a new agent project')
+        .description('Initialize a new agent project (interactive wizard when called without arguments)')
         .argument('[name]', 'Agent name (default: current directory name)')
         .option('--type <type>', 'Type: prompt, tool, agent, or skill (legacy aliases: agentic, code)', 'prompt')
         .option('--orchestrator', 'Create an orchestrator agent with dependency scaffolding and SDK boilerplate')
         .option('--run-mode <mode>', 'Run mode for agents: on_demand or always_on', 'on_demand')
         .option('--language <lang>', 'Language: python or javascript (default: python)', 'python')
         .option('--loop', 'Use platform-managed LLM loop instead of code runtime (requires --type agent)')
-        .option('--template <name>', 'Start from a template (available: fan-out, pipeline, map-reduce, support-agent, discord, discord-js, github-weekly-summary)')
+        .option('--template <name>', 'Start from a template (use --list-templates to see options)')
+        .option('--list-templates', 'Show available templates with descriptions')
         .action(async (name, options) => {
+        // --list-templates: print and exit
+        if (options.listTemplates) {
+            (0, init_wizard_1.printTemplateList)();
+            return;
+        }
+        // Interactive wizard: no name, TTY, and no explicit flags that indicate non-interactive intent
+        const rawArgs = process.argv.slice(2);
+        const initArgIndex = rawArgs.indexOf('init');
+        const argsAfterInit = initArgIndex >= 0 ? rawArgs.slice(initArgIndex + 1) : [];
+        const hasExplicitFlags = argsAfterInit.some(a => a.startsWith('--'));
+        const hasNameArg = name !== undefined;
+        if (!hasNameArg && !hasExplicitFlags && process.stdin.isTTY) {
+            const wizard = await (0, init_wizard_1.runInitWizard)();
+            // Re-invoke the action with wizard results by constructing args
+            const wizardArgs = ['node', 'orch', 'init'];
+            if (wizard.name)
+                wizardArgs.push(wizard.name);
+            wizardArgs.push('--type', wizard.type);
+            wizardArgs.push('--language', wizard.language);
+            wizardArgs.push('--run-mode', wizard.runMode);
+            if (wizard.template)
+                wizardArgs.push('--template', wizard.template);
+            if (wizard.orchestrator)
+                wizardArgs.push('--orchestrator');
+            if (wizard.loop)
+                wizardArgs.push('--loop');
+            // Create a fresh program to run with wizard args
+            const wizardProgram = new commander_1.Command();
+            wizardProgram.exitOverride();
+            registerInitCommand(wizardProgram);
+            await wizardProgram.parseAsync(wizardArgs);
+            return;
+        }
         const cwd = process.cwd();
         let runMode = (options.runMode || 'on_demand').trim().toLowerCase();
         if (!['on_demand', 'always_on'].includes(runMode)) {
@@ -1530,7 +1567,7 @@ function registerInitCommand(program) {
         }
         if (options.template) {
             const template = options.template.trim().toLowerCase();
-            const validTemplates = ['fan-out', 'pipeline', 'map-reduce', 'support-agent', 'discord', 'discord-js', 'github-weekly-summary'];
+            const validTemplates = ['fan-out', 'pipeline', 'map-reduce', 'support-agent', 'discord', 'discord-js', 'github-weekly-summary', 'cron-job'];
             if (!validTemplates.includes(template)) {
                 throw new errors_1.CliError(`Unknown --template '${template}'. Available templates: ${validTemplates.join(', ')}`);
             }
@@ -1564,6 +1601,9 @@ function registerInitCommand(program) {
             else if (template === 'github-weekly-summary') {
                 initMode = { type: 'agent', flavor: 'github_weekly_summary' };
             }
+            else if (template === 'cron-job') {
+                initMode = { type: 'tool', flavor: 'cron_job' };
+            }
         }
         // Validate --language option
         const language = (options.language || 'python').trim().toLowerCase();
@@ -1913,6 +1953,72 @@ function registerInitCommand(program) {
             process.stdout.write(AGENT_BUILDER_HINT);
             return;
         }
+        // Handle cron-job template
+        if (initMode.flavor === 'cron_job') {
+            const manifestPath = path_1.default.join(targetDir, 'orchagent.json');
+            try {
+                await promises_1.default.access(manifestPath);
+                throw new errors_1.CliError(`Already initialized (orchagent.json exists in ${name ? name + '/' : 'current directory'})`);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+            const manifest = {
+                name: agentName,
+                type: 'tool',
+                description: 'A scheduled job that runs on a cron schedule',
+                run_mode: 'on_demand',
+                runtime: { command: isJavaScript ? 'node main.js' : 'python main.py' },
+                required_secrets: [],
+                tags: ['scheduled', 'cron'],
+            };
+            if (isJavaScript) {
+                manifest.entrypoint = 'main.js';
+            }
+            await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+            if (isJavaScript) {
+                await promises_1.default.writeFile(path_1.default.join(targetDir, 'main.js'), cron_job_1.CRON_JOB_MAIN_JS);
+                await promises_1.default.writeFile(path_1.default.join(targetDir, 'package.json'), JSON.stringify({
+                    name: agentName,
+                    private: true,
+                    type: 'commonjs',
+                    dependencies: {},
+                }, null, 2) + '\n');
+            }
+            else {
+                await promises_1.default.writeFile(path_1.default.join(targetDir, 'main.py'), cron_job_1.CRON_JOB_MAIN_PY);
+            }
+            await promises_1.default.writeFile(path_1.default.join(targetDir, 'schema.json'), cron_job_1.CRON_JOB_SCHEMA);
+            await promises_1.default.writeFile(path_1.default.join(targetDir, 'README.md'), (0, cron_job_1.cronJobReadme)(agentName));
+            const prefix = name ? name + '/' : '';
+            process.stdout.write(`Initialized scheduled job "${agentName}" in ${targetDir}\n`);
+            process.stdout.write(`\nFiles created:\n`);
+            process.stdout.write(`  ${prefix}orchagent.json    - Agent configuration (cron job)\n`);
+            if (isJavaScript) {
+                process.stdout.write(`  ${prefix}main.js           - Scheduled job entrypoint\n`);
+                process.stdout.write(`  ${prefix}package.json      - npm dependencies\n`);
+            }
+            else {
+                process.stdout.write(`  ${prefix}main.py           - Scheduled job entrypoint\n`);
+            }
+            process.stdout.write(`  ${prefix}schema.json       - Input/output schemas\n`);
+            process.stdout.write(`  ${prefix}README.md         - Setup guide with cron patterns\n`);
+            process.stdout.write(`\nNext steps:\n`);
+            const stepNum = name ? 2 : 1;
+            if (name) {
+                process.stdout.write(`  1. cd ${name}\n`);
+            }
+            const mainFile = isJavaScript ? 'main.js' : 'main.py';
+            const testCmd = isJavaScript ? 'node main.js' : 'python main.py';
+            process.stdout.write(`  ${stepNum}. Edit ${mainFile} with your job logic\n`);
+            process.stdout.write(`  ${stepNum + 1}. Test: echo '{}' | ${testCmd}\n`);
+            process.stdout.write(`  ${stepNum + 2}. Publish: orch publish\n`);
+            process.stdout.write(`  ${stepNum + 3}. Schedule: orch schedule create <org>/${agentName} --cron "0 9 * * 1"\n`);
+            process.stdout.write(AGENT_BUILDER_HINT);
+            return;
+        }
         const manifestPath = path_1.default.join(targetDir, 'orchagent.json');
         const promptPath = path_1.default.join(targetDir, 'prompt.md');
         const schemaPath = path_1.default.join(targetDir, 'schema.json');

package/dist/commands/login.js

@@ -56,6 +56,7 @@ async function keyBasedLogin(apiKey) {
     const resolved = await (0, config_1.getResolvedConfig)({ api_key: apiKey });
     const org = await (0, api_1.getOrg)(resolved);
     const existing = await (0, config_1.loadConfig)();
+    const isFirstLogin = !existing.api_key;
     const nextConfig = {
         ...existing,
         api_key: apiKey,
@@ -67,12 +68,16 @@ async function keyBasedLogin(apiKey) {
     await (0, config_1.saveConfig)(nextConfig);
     await (0, analytics_1.track)('cli_login', { method: 'key' });
     process.stdout.write(`✓ Logged in to ${org.slug}\n`);
+    if (isFirstLogin) {
+        process.stdout.write('\n  Tip: Run `orch doctor` to verify your setup.\n\n');
+    }
 }
 /**
  * Login via browser OAuth flow.
  */
 async function browserBasedLogin(port) {
     const existing = await (0, config_1.loadConfig)();
+    const isFirstLogin = !existing.api_key;
     const resolved = await (0, config_1.getResolvedConfig)();
     process.stdout.write('Opening browser for authentication...\n');
     try {
@@ -88,6 +93,9 @@ async function browserBasedLogin(port) {
         await (0, config_1.saveConfig)(nextConfig);
         await (0, analytics_1.track)('cli_login', { method: 'browser' });
         process.stdout.write(`\n✓ Logged in to ${result.orgSlug}\n`);
+        if (isFirstLogin) {
+            process.stdout.write('\n  Tip: Run `orch doctor` to verify your setup.\n\n');
+        }
     }
     catch (err) {
         if (err instanceof errors_1.CliError) {

package/dist/commands/logs.js

@@ -16,15 +16,25 @@ const output_1 = require("../lib/output");
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
+    }
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
     }
-    return workspace.id;
+    // Multiple workspaces — list them and ask the user to pick
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 function formatDate(iso) {
     if (!iso)

package/dist/commands/metrics.js

@@ -15,15 +15,24 @@ const output_1 = require("../lib/output");
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
+    }
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
     }
-    return workspace.id;
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 function formatDuration(ms) {
     if (ms === 0)