@guildai/cli 0.7.1 → 0.8.1

package/dist/commands/agent/chat.js

@@ -14,7 +14,6 @@ import { GuildAPIClient } from '../../lib/api-client.js';
 import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { format } from '../../lib/progress.js';
-import { showBetaGuidance } from '../../lib/auth.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
 import * as readline from 'readline';
 import { pollForResponse } from '../../lib/session-polling.js';
@@ -245,7 +244,6 @@ export function createAgentChatCommand() {
             if (formattedError.code === ErrorCodes.AUTH_REQUIRED ||
                 formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
                 format.error('Not authenticated. Run: guild auth login');
-                showBetaGuidance();
                 process.exit(1);
             }
             console.error(`Error: ${formattedError.details}`);

package/dist/commands/agent/init.js

@@ -210,7 +210,7 @@ export function createAgentInitCommand() {
                 .then(() => true)
                 .catch(() => false);
             if (!gitExists) {
-                await runGit(['init'], { cwd: targetDir });
+                await runGit(['init', '-b', 'main'], { cwd: targetDir });
                 steps.succeed('Initialize git repository');
             }
             else {
@@ -323,15 +323,17 @@ export function createAgentInitCommand() {
             const gitignorePath = path.join(targetDir, '.gitignore');
             try {
                 const gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
-                let additions = '';
-                if (!gitignoreContent.includes('guild.json')) {
-                    additions += '\nguild.json\n';
+                const existingLines = gitignoreContent.split('\n').map((l) => l.trim());
+                const lines = [];
+                if (!existingLines.includes('guild.json')) {
+                    lines.push('guild.json');
                 }
-                if (!gitignoreContent.includes('.guild/cache/')) {
-                    additions += '.guild/cache/\n';
+                if (!existingLines.includes('.guild/cache/')) {
+                    lines.push('.guild/cache/');
                 }
-                if (additions) {
-                    await fs.appendFile(gitignorePath, additions);
+                if (lines.length > 0) {
+                    const prefix = gitignoreContent.endsWith('\n') ? '' : '\n';
+                    await fs.appendFile(gitignorePath, prefix + lines.join('\n') + '\n');
                 }
             }
             catch {

package/dist/commands/agent/list.js

@@ -17,13 +17,20 @@ export function createAgentListCommand() {
     cmd
         .description('List agents')
         .option('--search <query>', 'Search agents by name or description')
-        .option('--sort <field>', 'Sort by: updated, newest, name, popular (default: updated)', 'updated')
+        .option('--sort <field>', 'Sort by: name, updated, newest, popular (default: name)', 'name')
         .option('--published', 'Only show published agents')
+        .option('--archived', 'Show only archived agents')
+        .option('--all', 'Show all agents including archived')
+        .option('--owner <name>', 'Filter by owner (user or org name). Without this flag, lists your own agents')
         .option('--workspace <id>', 'Filter agents by workspace ID or name')
         .option('--limit <number>', 'Number of results to return', '20')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (options) => {
         const output = createOutputWriter();
+        if (options.archived && options.all) {
+            output.error('--archived and --all are mutually exclusive', 'Use --archived to show only archived agents, or --all to show all agents including archived');
+            process.exit(1);
+        }
         try {
             const token = await getAuthToken();
             if (!token) {
@@ -40,25 +47,57 @@ export function createAgentListCommand() {
             if (options.published) {
                 params.append('published_only', 'true');
             }
-            if (options.workspace) {
-                params.append('for_workspace', options.workspace);
-            }
             const sortField = SORT_MAP[options.sort];
             if (sortField) {
                 params.append('sort_by', sortField);
             }
-            const response = await client.get(`/agents?${params.toString()}`);
+            // Determine the right endpoint:
+            // - --workspace → GET /agents?for_workspace=... (global, workspace-scoped)
+            // - --owner → GET /users/{owner}/agents or /organizations/{owner}/agents
+            // - default → GET /users/{me}/agents (same as web)
+            let endpoint;
+            const showArchived = options.all || options.archived;
+            if (options.workspace) {
+                // Workspace filter uses the global endpoint
+                params.append('for_workspace', options.workspace);
+                endpoint = `/agents?${params.toString()}`;
+            }
+            else {
+                // Use scoped endpoint (matches web frontend pattern)
+                if (options.archived) {
+                    params.append('include_archived', 'true');
+                }
+                else if (options.all) {
+                    params.append('include_archived', 'true');
+                }
+                const ownerName = options.owner ?? (await client.get('/me')).name;
+                endpoint = `/users/${encodeURIComponent(ownerName)}/agents?${params.toString()}`;
+            }
+            const response = await client.get(endpoint);
+            // When --archived is used, filter to only archived agents client-side
+            // (the backend only supports include_archived, not archived_only)
+            if (options.archived) {
+                response.items = response.items.filter((a) => a.is_archived);
+            }
             if (getOutputMode() === 'json') {
                 output.data(response);
             }
             else {
-                formatAgentTable(response.items, response.pagination);
+                formatAgentTable(response.items, response.pagination, showArchived);
             }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);
             if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error('Workspace not found');
+                if (options.workspace) {
+                    output.error('Workspace not found');
+                }
+                else if (options.owner) {
+                    output.error(`Owner not found: ${options.owner}`);
+                }
+                else {
+                    output.error('Not found');
+                }
                 process.exit(1);
             }
             output.error(`Failed to list agents: ${formattedError.details}`);

package/dist/commands/agent/owners.js

@@ -5,10 +5,12 @@ import chalk from 'chalk';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter } from '../../lib/output.js';
 import { loadGlobalConfig } from '../../lib/guild-config.js';
 export function createAgentOwnersCommand() {
     const cmd = new Command('owners');
     cmd.description('List accounts that can own agents').action(async () => {
+        const output = createOutputWriter();
         try {
             const mode = getOutputMode();
             const client = new GuildAPIClient();
@@ -33,7 +35,7 @@ export function createAgentOwnersCommand() {
                 })),
             ];
             if (mode === 'json') {
-                console.log(JSON.stringify({ owners }, null, 2));
+                output.data({ owners });
                 return;
             }
             // Table display
@@ -56,18 +58,14 @@ export function createAgentOwnersCommand() {
         catch (error) {
             const formattedError = handleAxiosError(error);
             if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                console.error('Not authenticated. Please log in first.');
-                console.error('');
-                console.error('Run: guild auth login');
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
                 process.exit(1);
             }
             if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                console.error('Cannot connect to Guild servers.');
-                console.error('');
-                console.error('Please check your connection and try again.');
+                output.error('Cannot connect to Guild servers.', 'Please check your connection and try again.');
                 process.exit(1);
             }
-            console.error(`Failed to list owners: ${formattedError.details}`);
+            output.error(`Failed to list owners: ${formattedError.details}`);
             process.exit(1);
         }
     });

package/dist/commands/agent/test.js

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import { render } from 'ink';
 import React from 'react';
 import { readFileSync } from 'fs';
+import { access } from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import open from 'open';
@@ -11,7 +12,6 @@ import { hyperlink } from '../../lib/colors.js';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { format } from '../../lib/progress.js';
-import { showBetaGuidance } from '../../lib/auth.js';
 import * as readline from 'readline';
 import { parseEventFilter } from '../../lib/event-filter.js';
 import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
@@ -19,7 +19,7 @@ import { pollForResponse, pollForResponseWithEvents, } from '../../lib/session-p
 import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
 import { GitError, formatGitError } from '../../lib/git.js';
-import { readAgentFiles, buildEphemeralVersion, BuildTimeoutError, BuildFailedError, } from '../../lib/agent-helpers.js';
+import { readAgentFiles, buildEphemeralVersion, buildBundledVersion, BundleNotFoundError, BuildTimeoutError, BuildFailedError, } from '../../lib/agent-helpers.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
 import { ChatApp, ensureAuthenticated } from '../chat.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
@@ -37,6 +37,7 @@ export function createAgentTestCommand() {
         .option('--resume <session-id>', 'Resume an existing test session')
         .option('--open', 'Open session in web dashboard')
         .option('--events <types>', 'Event types to stream (default: user). Shorthands: none, user, system, all, or comma-separated type names')
+        .option('--bundle <file>', 'Path to a pre-built gzip+base64 bundle file')
         .option('--no-cache', 'Skip ephemeral build cache (force a fresh build)')
         .action(async (options) => {
         const cwd = process.cwd();
@@ -99,6 +100,21 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
+            // If using bundle, verify the file exists early (before auth/session creation)
+            // so we fail fast without needing auth if the path is wrong.
+            if (options.bundle) {
+                try {
+                    await access(options.bundle);
+                }
+                catch {
+                    console.error(`Error: Bundle file not found: ${options.bundle}`);
+                    console.error('');
+                    console.error('Ensure the bundle file exists and the path is correct:');
+                    console.error('  npm run build');
+                    console.error('  guild agent test --bundle agent.js.gz');
+                    process.exit(1);
+                }
+            }
             // Determine workspace (priority: flag > local config > global config)
             let workspaceId = options.workspace;
             if (!workspaceId) {
@@ -139,6 +155,11 @@ export function createAgentTestCommand() {
                     }
                     version = match;
                 }
+                else if (options.bundle) {
+                    // Pre-built bundle: skip server-side compilation entirely.
+                    const result = await buildBundledVersion(client, guildConfig.agent_id, options.bundle, cwd, '[Test] Pre-built bundle');
+                    version = result.version;
+                }
                 else {
                     // Default: build ephemeral version from working directory,
                     // reusing the last build if files haven't changed.
@@ -150,6 +171,14 @@ export function createAgentTestCommand() {
                 }
             }
             catch (error) {
+                if (error instanceof BundleNotFoundError) {
+                    console.error(`Error: ${error.message}`);
+                    console.error('');
+                    console.error('Ensure the bundle file exists and the path is correct:');
+                    console.error('  npm run build');
+                    console.error('  guild agent test --bundle agent.js.gz');
+                    process.exit(1);
+                }
                 if (error instanceof BuildTimeoutError) {
                     console.error('Error: Build did not complete');
                     console.error('');
@@ -216,9 +245,11 @@ export function createAgentTestCommand() {
                 console.log(`✓ Agent: ${guildConfig.name} (${guildConfig.agent_id})`);
                 const versionDisplay = options.agentVersion
                     ? options.agentVersion
-                    : ephemeralCached
-                        ? 'ephemeral (cached, no changes)'
-                        : 'ephemeral (working directory)';
+                    : options.bundle
+                        ? `bundle (${path.basename(options.bundle)})`
+                        : ephemeralCached
+                            ? 'ephemeral (cached, no changes)'
+                            : 'ephemeral (working directory)';
                 console.log(`✓ Version: ${versionDisplay}`);
                 console.log(`✓ Workspace: ${workspaceId}`);
                 const sessionLink = session.session_url
@@ -385,7 +416,6 @@ export function createAgentTestCommand() {
             if (formattedError.code === ErrorCodes.AUTH_REQUIRED ||
                 formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
                 format.error('Not authenticated. Run: guild auth login');
-                showBetaGuidance();
                 process.exit(1);
             }
             console.error(`Error: ${formattedError.details}`);

package/dist/commands/chat.js

@@ -3,7 +3,7 @@
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, Static, render, useInput, useApp } from 'ink';
 import { Command } from 'commander';
-import { getAuthToken, showBetaGuidance } from '../lib/auth.js';
+import { getAuthToken } from '../lib/auth.js';
 import { GuildAPIClient } from '../lib/api-client.js';
 import { handleAxiosError, ErrorCodes, debug, isDebugMode, retry, } from '../lib/errors.js';
 import { createSpinner, format } from '../lib/progress.js';
@@ -213,7 +213,6 @@ export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentN
                 if (formattedError.code === ErrorCodes.AUTH_REQUIRED ||
                     formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
                     format.error('Not authenticated. Run: guild auth login');
-                    showBetaGuidance();
                 }
                 else if (details.includes('workspace')) {
                     format.error('Workspace not found. Run: guild workspace select');
@@ -963,7 +962,6 @@ export async function ensureAuthenticated() {
     const token = await getAuthToken();
     if (!token) {
         format.error('Not authenticated. Run: guild auth login');
-        showBetaGuidance();
         process.exit(1);
     }
     // Validate token against the server to catch expired/invalid tokens
@@ -977,7 +975,6 @@ export async function ensureAuthenticated() {
         const { clearAuthToken } = await import('../lib/auth.js');
         await clearAuthToken();
         format.error('Session expired. Run: guild auth login');
-        showBetaGuidance();
         process.exit(1);
     }
     return token;
@@ -1028,9 +1025,9 @@ export function createChatCommand() {
     cmd
         .description('Chat with an agent (default: Guild assistant)')
         .argument('[prompt...]', 'Optional initial prompt (multiple words)')
-        .option('--agent <identifier>', 'Agent ID or full name (default: assistant)')
+        .option('--agent <identifier>', 'Agent ID or full name, e.g., foo~bar (default: assistant)')
         .option('--once', 'One-shot mode: send message, wait for response, exit (non-interactive)')
-        .option('--mode <format>', 'Input/output format: json or jsonl (default: human-readable)')
+        .option('--mode <format>', 'Machine-readable output format: json or jsonl')
         .option('--workspace <identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
         .option('--no-splash', 'Skip the splash screen animation')
         .option('--resume <session-id>', 'Resume an existing session')
@@ -1144,10 +1141,6 @@ export function createChatCommand() {
                         console.error(`  • ${suggestion}`);
                     });
                 }
-                if (formattedError.code === ErrorCodes.AUTH_REQUIRED ||
-                    formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
-                    showBetaGuidance();
-                }
                 process.exit(1);
             }
         }

package/dist/commands/session/create.js

@@ -13,7 +13,7 @@ export function createSessionCreateCommand() {
         .option('--workspace <id>', 'Workspace ID or name')
         .option('--type <type>', 'Session type: chat or agent_test', 'chat')
         .option('--prompt <text>', 'Initial prompt (required for chat sessions)')
-        .option('--agent <identifier>', 'Agent identifier, e.g., owner/agent-name')
+        .option('--agent <identifier>', 'Agent identifier, e.g., owner~agent-name')
         .action(async (options) => {
         const output = createOutputWriter();
         try {

package/dist/commands/session/tasks.js

@@ -4,7 +4,8 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
-import { createOutputWriter } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatTaskTable } from '../../lib/output.js';
 export function createSessionTasksCommand() {
     const cmd = new Command('tasks');
     cmd
@@ -25,7 +26,12 @@ export function createSessionTasksCommand() {
             params.append('limit', options.limit);
             params.append('offset', options.offset);
             const response = await client.get(`/sessions/${sessionId}/tasks?${params.toString()}`);
-            output.data(response);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                formatTaskTable(response.items, response.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/trigger/create.js

@@ -13,18 +13,20 @@ export function createTriggerCreateCommand() {
         .description('Create a new trigger')
         .option('--workspace <id>', 'Workspace ID or name')
         .requiredOption('--type <type>', 'Trigger type: webhook or time')
-        .requiredOption('--agent <identifier>', 'Agent identifier (e.g., owner/agent-name)')
+        .requiredOption('--agent <identifier>', 'Agent identifier (e.g., owner~agent-name)')
         // Webhook options
         .option('--integration <name>', 'Integration name for webhook triggers (e.g., github, slack, jira)')
         .option('--event <event>', 'Event type (e.g., app_mention, issues)')
         .option('--action <action>', 'Event action (e.g., opened, created)')
         .option('--service-config <json>', 'Service-specific config as JSON')
         // Time options
-        .option('--frequency <freq>', 'Time trigger frequency: HOURLY, DAILY, WEEKLY, MONTHLY')
+        .option('--frequency <freq>', 'Time trigger frequency: HOURLY, DAILY, WEEKLY, MONTHLY, CRON')
         .option('--time <time>', 'Time of day in HH:MM format')
         .option('--days-of-week <days>', 'Days of week (comma-separated: MONDAY,TUESDAY,...)')
         .option('--days-of-month <days>', 'Days of month (comma-separated: 1,15,-1)')
         .option('--minutes-of-hour <minutes>', 'Minutes of hour, comma-separated (0-59)')
+        .option('--cron-expression <expression>', '5-field cron expression (required with --frequency CRON)')
+        .option('--cron-timezone <timezone>', 'IANA timezone for --cron-expression (default: UTC)')
         .option('--input <json>', 'Agent input as JSON object')
         .action(async (options) => {
         const output = createOutputWriter();
@@ -41,7 +43,13 @@ export function createTriggerCreateCommand() {
                 process.exit(1);
             }
             if (triggerType === 'time' && !options.frequency) {
-                output.error(`--frequency is required for time triggers. Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
+                output.error(`--frequency is required for time triggers. Valid frequencies: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
+                process.exit(1);
+            }
+            if (triggerType === 'time' &&
+                options.frequency?.toUpperCase() === 'CRON' &&
+                !options.cronExpression) {
+                output.error('--cron-expression is required when --frequency is CRON');
                 process.exit(1);
             }
             const token = await getAuthToken();
@@ -116,12 +124,6 @@ export function createTriggerCreateCommand() {
             }
             else {
                 // Time trigger
-                const frequency = options.frequency.toUpperCase();
-                if (!TIME_TRIGGER_FREQUENCIES.includes(frequency)) {
-                    output.error(`Invalid frequency "${options.frequency}". Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
-                    process.exit(1);
-                }
-                // Parse agent input
                 let agentInput = {};
                 if (options.input) {
                     try {
@@ -132,24 +134,46 @@ export function createTriggerCreateCommand() {
                         process.exit(1);
                     }
                 }
+                const frequency = options.frequency.toUpperCase();
+                if (!TIME_TRIGGER_FREQUENCIES.includes(frequency)) {
+                    output.error(`Invalid frequency "${options.frequency}". Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
+                    process.exit(1);
+                }
+                // Validate options match the frequency
+                const frequencyOptions = {
+                    HOURLY: new Set(['minutesOfHour']),
+                    DAILY: new Set(['time']),
+                    WEEKLY: new Set(['time', 'daysOfWeek']),
+                    MONTHLY: new Set(['time', 'daysOfMonth']),
+                    CRON: new Set(['cronExpression', 'cronTimezone']),
+                };
+                const allOptions = new Set(Object.values(frequencyOptions).flatMap((s) => [...s]));
+                const allowed = frequencyOptions[frequency] ?? new Set();
+                const invalid = [...allOptions]
+                    .filter((opt) => !allowed.has(opt) && options[opt])
+                    .map((opt) => '--' + opt.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase()));
+                if (invalid.length > 0) {
+                    output.error(`${invalid.join(', ')} cannot be used with ${frequency} frequency`);
+                    process.exit(1);
+                }
                 body = {
                     type: 'time',
                     frequency: frequency,
                     workspace_agent_id: workspaceAgent.id,
                     agent_input: agentInput,
                 };
-                if (options.time) {
+                if (options.time)
                     body.time_of_day = options.time;
-                }
-                if (options.daysOfWeek) {
+                if (options.daysOfWeek)
                     body.days_of_week = options.daysOfWeek;
-                }
-                if (options.daysOfMonth) {
+                if (options.daysOfMonth)
                     body.days_of_month = options.daysOfMonth;
-                }
-                if (options.minutesOfHour) {
+                if (options.minutesOfHour)
                     body.minutes_of_hour = options.minutesOfHour;
-                }
+                if (options.cronExpression)
+                    body.cron_expression = options.cronExpression;
+                if (options.cronTimezone)
+                    body.cron_timezone = options.cronTimezone;
             }
             const response = await client.post(`/workspaces/${workspaceId}/triggers`, body);
             output.data(response);

package/dist/commands/trigger/update.js

@@ -16,11 +16,13 @@ export function createTriggerUpdateCommand() {
         .option('--action <action>', 'Event action (for webhook triggers)')
         .option('--service-config <json>', 'Service-specific config as JSON (for webhook triggers)')
         // Time options
-        .option('--frequency <freq>', 'Frequency: HOURLY, DAILY, WEEKLY, MONTHLY (for time triggers)')
+        .option('--frequency <freq>', 'Frequency: HOURLY, DAILY, WEEKLY, MONTHLY, CRON (for time triggers)')
         .option('--time <time>', 'Time of day in HH:MM format (for time triggers)')
         .option('--days-of-week <days>', 'Days of week, comma-separated (for time triggers)')
         .option('--days-of-month <days>', 'Days of month, comma-separated (for time triggers)')
         .option('--minutes-of-hour <minutes>', 'Minutes of hour, comma-separated (0-59, for HOURLY triggers)')
+        .option('--cron-expression <expression>', '5-field cron expression (for CRON triggers)')
+        .option('--cron-timezone <timezone>', 'IANA timezone for --cron-expression (default: UTC)')
         .option('--input <json>', 'Agent input as JSON object (for time triggers)')
         .action(async (triggerId, options) => {
         const output = createOutputWriter();
@@ -50,26 +52,47 @@ export function createTriggerUpdateCommand() {
                 }
             }
             // Time options
+            let frequency;
             if (options.frequency !== undefined) {
-                const frequency = options.frequency.toUpperCase();
+                frequency = options.frequency.toUpperCase();
                 if (!TIME_TRIGGER_FREQUENCIES.includes(frequency)) {
                     output.error(`Invalid frequency "${options.frequency}". Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
                     process.exit(1);
                 }
                 body.frequency = frequency;
             }
-            if (options.time !== undefined) {
-                body.time_of_day = options.time;
+            // Validate options match the frequency (when frequency is being set)
+            if (frequency) {
+                const frequencyOptions = {
+                    HOURLY: new Set(['minutesOfHour']),
+                    DAILY: new Set(['time']),
+                    WEEKLY: new Set(['time', 'daysOfWeek']),
+                    MONTHLY: new Set(['time', 'daysOfMonth']),
+                    CRON: new Set(['cronExpression', 'cronTimezone']),
+                };
+                const allOptions = new Set(Object.values(frequencyOptions).flatMap((s) => [...s]));
+                const allowed = frequencyOptions[frequency] ?? new Set();
+                const invalid = [...allOptions]
+                    .filter((opt) => !allowed.has(opt) &&
+                    options[opt] !== undefined)
+                    .map((opt) => '--' + opt.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase()));
+                if (invalid.length > 0) {
+                    output.error(`${invalid.join(', ')} cannot be used with ${frequency} frequency`);
+                    process.exit(1);
+                }
             }
-            if (options.daysOfWeek !== undefined) {
+            if (options.time !== undefined)
+                body.time_of_day = options.time;
+            if (options.daysOfWeek !== undefined)
                 body.days_of_week = options.daysOfWeek;
-            }
-            if (options.daysOfMonth !== undefined) {
+            if (options.daysOfMonth !== undefined)
                 body.days_of_month = options.daysOfMonth;
-            }
-            if (options.minutesOfHour !== undefined) {
+            if (options.minutesOfHour !== undefined)
                 body.minutes_of_hour = options.minutesOfHour;
-            }
+            if (options.cronExpression !== undefined)
+                body.cron_expression = options.cronExpression;
+            if (options.cronTimezone !== undefined)
+                body.cron_timezone = options.cronTimezone;
             if (options.input !== undefined) {
                 try {
                     body.agent_input = JSON.parse(options.input);

package/dist/commands/workspace/agent/add.js

@@ -10,7 +10,7 @@ export function createWorkspaceAgentAddCommand() {
     const cmd = new Command('add');
     cmd
         .description('Add an agent to a workspace')
-        .argument('<agent>', 'Agent identifier (e.g., owner/agent-name or UUID)')
+        .argument('<agent>', 'Agent identifier (e.g., owner~agent-name or UUID)')
         .option('--workspace <id>', 'Target workspace ID or name')
         .option('--no-autoupdate', 'Disable automatic updates for this agent')
         .action(async (agentIdentifier, options) => {
@@ -32,7 +32,7 @@ export function createWorkspaceAgentAddCommand() {
                 }
                 workspaceId = resolved.workspaceId;
             }
-            // Resolve agent - the backend accepts both UUID and owner/name format
+            // Resolve agent - the backend accepts both UUID and owner~agent-name format
             // First, look up the agent to get its ID and display info
             let agent;
             try {
@@ -46,7 +46,7 @@ export function createWorkspaceAgentAddCommand() {
                 }
                 if (formattedError.code === ErrorCodes.FORBIDDEN ||
                     formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
-                    console.error('Cannot add agent: access denied. Ensure the agent is public or check your permissions.');
+                    output.error('Cannot add agent: access denied. Ensure the agent is public or check your permissions.');
                     process.exit(1);
                 }
                 throw error;

package/dist/commands/workspace/agent/remove.js

@@ -10,7 +10,7 @@ export function createWorkspaceAgentRemoveCommand() {
     const cmd = new Command('remove');
     cmd
         .description('Remove an agent from a workspace')
-        .argument('<agent>', 'Agent identifier (e.g., owner/agent-name or UUID)')
+        .argument('<agent>', 'Agent identifier (e.g., owner~agent-name or UUID)')
         .option('--workspace <id>', 'Workspace ID or name')
         .action(async (agentIdentifier, options) => {
         const output = createOutputWriter();

package/dist/lib/agent-helpers.d.ts

@@ -84,4 +84,19 @@ export declare function buildEphemeralVersion(client: GuildAPIClient, agentId: s
     version: AgentVersion;
     cached: boolean;
 }>;
+/** Thrown when the specified bundle file cannot be found on disk. */
+export declare class BundleNotFoundError extends Error {
+    constructor(filePath: string);
+}
+/**
+ * Upload a pre-built bundle as an ephemeral version.
+ *
+ * The bundle file must be gzip+base64 encoded (the output of
+ * `esbuild ... | gzip | base64`). Source files are included for
+ * dashboard viewing, but the server skips its own build step because
+ * the ready-to-run artifact is already provided.
+ */
+export declare function buildBundledVersion(client: GuildAPIClient, agentId: string, bundlePath: string, cwd: string, summary: string): Promise<{
+    version: AgentVersion;
+}>;
 //# sourceMappingURL=agent-helpers.d.ts.map