@orchagent/cli 0.3.89 → 0.3.91

package/dist/commands/init-wizard.js

@@ -0,0 +1,160 @@
+"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.
+ */
+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: '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`);
+    }
+}
+// ---------------------------------------------------------------------------
+// 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 createSubdir = name !== dirName;
+        // 2. Agent type
+        const type = await promptSelect(rl, 'What type of agent?', [
+            { 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' },
+            { value: 'skill', label: 'skill', description: 'Knowledge module for other agents' },
+        ]);
+        // Skill and prompt don't need language/template
+        if (type === 'skill' || type === 'prompt') {
+            rl.close();
+            return {
+                name: createSubdir ? name : undefined,
+                type,
+                language: 'python',
+                template: undefined,
+                runMode: 'on_demand',
+                orchestrator: false,
+                loop: false,
+            };
+        }
+        // 3. Language (tool/agent only)
+        const language = await promptSelect(rl, 'Language?', [
+            { value: 'python', label: 'Python', description: 'Recommended — broadest library support' },
+            { value: 'javascript', label: 'JavaScript', description: 'Node.js runtime' },
+        ]);
+        // 4. Template (optional)
+        const applicableTemplates = exports.TEMPLATE_REGISTRY.filter(t => {
+            if (t.language !== 'both' && t.language !== language)
+                return false;
+            return true;
+        });
+        const templateOptions = [
+            { value: 'none', label: 'No template', description: 'Start from scratch' },
+            ...applicableTemplates.map(t => ({
+                value: t.name,
+                label: t.name,
+                description: t.description,
+            })),
+        ];
+        const template = await promptSelect(rl, 'Start from a template?', templateOptions);
+        // 5. Run mode (only if no template selected — templates set their own)
+        let runMode = 'on_demand';
+        if (template === 'none') {
+            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' },
+            ]);
+        }
+        // 6. Agent subtype (only for agent type, no template)
+        let orchestrator = false;
+        let loop = false;
+        if (type === 'agent' && template === 'none') {
+            const agentSubtype = await promptSelect(rl, 'Agent execution mode?', [
+                { value: 'code', label: 'Code runtime', description: 'You write the logic (call any LLM provider)' },
+                { value: 'orchestrator', label: 'Orchestrator', description: 'Coordinate other agents via SDK' },
+                ...(language === 'python' ? [{ value: 'loop', label: 'Managed loop', description: 'Platform-managed LLM loop with tool use' }] : []),
+            ]);
+            orchestrator = agentSubtype === 'orchestrator';
+            loop = agentSubtype === 'loop';
+        }
+        rl.close();
+        return {
+            name: createSubdir ? name : undefined,
+            type,
+            language,
+            template: template === 'none' ? undefined : template,
+            runMode,
+            orchestrator,
+            loop,
+        };
+    }
+    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,9 +4,11 @@ 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 support_agent_1 = require("./templates/support-agent");
 const MANIFEST_TEMPLATE = `{
@@ -1498,15 +1500,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)) {

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)

package/dist/commands/replay.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 isUuid(value) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);

package/dist/commands/run.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localCommandForEntrypoint = localCommandForEntrypoint;
 exports.validateInputSchema = validateInputSchema;
+exports.tryParseJsonObject = tryParseJsonObject;
 exports.isKeyedFileArg = isKeyedFileArg;
 exports.readKeyedFiles = readKeyedFiles;
 exports.mountDirectory = mountDirectory;
@@ -264,6 +265,26 @@ async function readStdin() {
         return null;
     return Buffer.concat(chunks);
 }
+/**
+ * Try to parse a Buffer as a JSON object (not array).
+ * Returns the parsed object on success, null on failure or if the content
+ * is not a JSON object (e.g. array, string, number).
+ */
+function tryParseJsonObject(buf) {
+    const text = buf.toString('utf8').trim();
+    if (!text.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 async function buildMultipartBody(filePaths, metadata) {
     if (!filePaths || filePaths.length === 0) {
         const stdinData = await readStdin();
@@ -2127,13 +2148,39 @@ async function executeCloud(agentRef, file, options) {
             sourceLabel = multipart.sourceLabel;
         }
         else if (llmCredentials) {
-            body = JSON.stringify({ llm_credentials: llmCredentials });
+            // Check for piped JSON stdin to merge with credentials
+            const stdinData = await readStdin();
+            const stdinJson = stdinData ? tryParseJsonObject(stdinData) : null;
+            if (stdinJson) {
+                stdinJson.llm_credentials = llmCredentials;
+                warnInputSchemaErrors(stdinJson, agentMeta.input_schema);
+                body = JSON.stringify(stdinJson);
+                sourceLabel = 'stdin';
+            }
+            else {
+                body = JSON.stringify({ llm_credentials: llmCredentials });
+            }
             headers['Content-Type'] = 'application/json';
         }
         else {
-            const multipart = await buildMultipartBody(undefined, options.metadata);
-            body = multipart.body;
-            sourceLabel = multipart.sourceLabel;
+            // No --data, no --file, no --metadata — check for piped JSON stdin
+            const stdinData = await readStdin();
+            if (stdinData) {
+                const stdinJson = tryParseJsonObject(stdinData);
+                if (stdinJson) {
+                    warnInputSchemaErrors(stdinJson, agentMeta.input_schema);
+                    body = JSON.stringify(stdinJson);
+                    headers['Content-Type'] = 'application/json';
+                    sourceLabel = 'stdin';
+                }
+                else {
+                    // Non-JSON stdin — send as binary file attachment
+                    const form = new FormData();
+                    form.append('files[]', new Blob([new Uint8Array(stdinData)]), 'stdin');
+                    body = form;
+                    sourceLabel = 'stdin';
+                }
+            }
         }
     } // end of non-injection path
     const verboseQs = options.verbose ? '?verbose=true' : '';

package/dist/commands/schedule.js

@@ -19,15 +19,24 @@ const api_2 = require("../lib/api");
 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>`.');
     }
-    return workspace.id;
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].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 formatDate(iso) {
     if (!iso)
@@ -148,6 +157,8 @@ function registerScheduleCommand(program) {
         .option('--input <json>', 'Input data as JSON string')
         .option('--provider <provider>', 'LLM provider (anthropic, openai, gemini)')
         .option('--pin-version', 'Pin to this version (disable auto-update on publish)')
+        .option('--alert-webhook <url>', 'Webhook URL to POST on failure (HTTPS required)')
+        .option('--alert-on-failure-count <n>', 'Number of consecutive failures before alerting (default: 3)', parseInt)
         .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
         .action(async (agentArg, options) => {
         const config = await (0, config_1.getResolvedConfig)();
@@ -162,8 +173,13 @@ function registerScheduleCommand(program) {
         }
         const workspaceId = await resolveWorkspaceId(config, options.workspace);
         const ref = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = ref.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
         // Resolve agent to get the ID (pass workspace context for private agents)
-        const agent = await (0, api_2.getAgentWithFallback)(config, ref.org, ref.agent, ref.version, workspaceId);
+        const agent = await (0, api_2.getAgentWithFallback)(config, org, ref.agent, ref.version, workspaceId);
         // Parse input data
         let inputData;
         if (options.input) {
@@ -190,6 +206,10 @@ function registerScheduleCommand(program) {
             body.llm_provider = options.provider;
         if (options.pinVersion)
             body.auto_update = false;
+        if (options.alertWebhook)
+            body.alert_webhook_url = options.alertWebhook;
+        if (options.alertOnFailureCount)
+            body.alert_on_failure_count = options.alertOnFailureCount;
         const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules`, {
             body: JSON.stringify(body),
             headers: { 'Content-Type': 'application/json' },
@@ -217,6 +237,10 @@ function registerScheduleCommand(program) {
         if (s.llm_provider) {
             process.stdout.write(`  Provider:    ${s.llm_provider}\n`);
         }
+        if (s.alert_webhook_url) {
+            process.stdout.write(`  Alert URL:   ${s.alert_webhook_url}\n`);
+            process.stdout.write(`  Alert after: ${s.alert_on_failure_count ?? 3} consecutive failures\n`);
+        }
         process.stdout.write('\n');
     });
     // orch schedule update <schedule-id>
@@ -231,6 +255,9 @@ function registerScheduleCommand(program) {
         .option('--disable', 'Disable the schedule')
         .option('--auto-update', 'Enable auto-update on publish')
         .option('--pin-version', 'Pin to current version (disable auto-update)')
+        .option('--alert-webhook <url>', 'Webhook URL to POST on failure (HTTPS required)')
+        .option('--alert-on-failure-count <n>', 'Number of consecutive failures before alerting', parseInt)
+        .option('--clear-alert-webhook', 'Remove the alert webhook URL')
         .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
         .action(async (scheduleId, options) => {
         const config = await (0, config_1.getResolvedConfig)();
@@ -243,6 +270,9 @@ function registerScheduleCommand(program) {
         if (options.autoUpdate && options.pinVersion) {
             throw new errors_1.CliError('Cannot use both --auto-update and --pin-version');
         }
+        if (options.alertWebhook && options.clearAlertWebhook) {
+            throw new errors_1.CliError('Cannot use both --alert-webhook and --clear-alert-webhook');
+        }
         const workspaceId = await resolveWorkspaceId(config, options.workspace);
         const updates = {};
         if (options.cron)
@@ -259,6 +289,12 @@ function registerScheduleCommand(program) {
             updates.auto_update = true;
         if (options.pinVersion)
             updates.auto_update = false;
+        if (options.alertWebhook)
+            updates.alert_webhook_url = options.alertWebhook;
+        if (options.alertOnFailureCount)
+            updates.alert_on_failure_count = options.alertOnFailureCount;
+        if (options.clearAlertWebhook)
+            updates.alert_webhook_url = '';
         if (options.input) {
             try {
                 updates.input_data = JSON.parse(options.input);
@@ -285,6 +321,13 @@ function registerScheduleCommand(program) {
         if (s.next_run_at) {
             process.stdout.write(`  Next:    ${formatDate(s.next_run_at)}\n`);
         }
+        if (s.alert_webhook_url) {
+            process.stdout.write(`  Alert:   ${s.alert_webhook_url}\n`);
+            process.stdout.write(`  After:   ${s.alert_on_failure_count ?? 3} failures\n`);
+        }
+        else if (options.clearAlertWebhook) {
+            process.stdout.write(`  Alert:   ${chalk_1.default.gray('removed')}\n`);
+        }
         process.stdout.write('\n');
     });
     // orch schedule delete <schedule-id>
@@ -498,4 +541,25 @@ function registerScheduleCommand(program) {
         process.stdout.write(`${table.toString()}\n`);
         process.stdout.write(chalk_1.default.gray(`\n${result.total} run${result.total !== 1 ? 's' : ''} total\n`));
     });
+    // orch schedule test-alert <schedule-id>
+    schedule
+        .command('test-alert <schedule-id>')
+        .description('Send a test alert to the schedule\'s configured webhook URL')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (partialScheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const scheduleId = await resolveScheduleId(config, partialScheduleId, workspaceId);
+        process.stdout.write('Sending test alert...\n');
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules/${scheduleId}/test-alert`);
+        if (result.success) {
+            process.stdout.write(chalk_1.default.green('\u2713') + ' Test alert delivered successfully\n');
+        }
+        else {
+            process.stdout.write(chalk_1.default.red('\u2717') + ' Test alert delivery failed\n');
+        }
+    });
 }

package/dist/commands/secrets.js

@@ -17,15 +17,24 @@ const SECRET_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
 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 formatDate(iso) {
     if (!iso)

package/dist/commands/service.js

@@ -17,15 +17,24 @@ const spinner_1 = require("../lib/spinner");
 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 formatDate(iso) {
     if (!iso)