@guildai/cli 0.8.0 → 0.9.0

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

@@ -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

@@ -12,11 +12,10 @@ 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';
-import { pollForResponse, pollForResponseWithEvents, } from '../../lib/session-polling.js';
+import { pollForResponseWithEvents } from '../../lib/session-polling.js';
 import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
 import { GitError, formatGitError } from '../../lib/git.js';
@@ -37,15 +36,13 @@ export function createAgentTestCommand() {
         .option('--agent-version <id>', 'Test a specific version (UUID or version number)')
         .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('--events <types>', 'Event types to stream (default: all). 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();
-        // Parse --events filter once, before any branching
-        const eventFilter = options.events
-            ? parseEventFilter(options.events)
-            : undefined;
+        // Parse --events filter once, before any branching (default: all)
+        const eventFilter = parseEventFilter(options.events ?? 'all');
         try {
             // Handle --resume: skip build, fetch existing session, hand off to ChatApp
             if (options.resume) {
@@ -273,9 +270,7 @@ export function createAgentTestCommand() {
                     });
                     // Poll for response (starting from beginning)
                     // 3 minutes - allow time for agents that use LLM calls for input parsing
-                    const { response } = eventFilter
-                        ? await pollForResponseWithEvents(client, session.id, eventFilter, undefined, 180000)
-                        : await pollForResponse(client, session.id, undefined, 180000);
+                    const { response } = await pollForResponseWithEvents(client, session.id, eventFilter, undefined, 180000);
                     if (!response) {
                         console.error('Error: No response received from agent within timeout');
                         console.error('');
@@ -351,9 +346,7 @@ export function createAgentTestCommand() {
                             content: jsonInput,
                         });
                         // Wait for response (looking for events after last seen)
-                        const result = eventFilter
-                            ? await pollForResponseWithEvents(client, session.id, eventFilter, lastEventId, 180000)
-                            : await pollForResponse(client, session.id, lastEventId, 180000);
+                        const result = await pollForResponseWithEvents(client, session.id, eventFilter, lastEventId, 180000);
                         lastEventId = result.lastEventId;
                         if (!result.response) {
                             console.error(`Timeout: No response for line ${lineNumber}`);
@@ -417,7 +410,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/job/get-step.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createJobGetStepCommand(): Command;
+//# sourceMappingURL=get-step.d.ts.map

package/dist/commands/job/{step-get.js → get-step.js}

@@ -5,8 +5,8 @@ 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';
-export function createJobStepGetCommand() {
-    const cmd = new Command('step-get');
+export function createJobGetStepCommand() {
+    const cmd = new Command('get-step');
     cmd
         .description('Get details of a step in a job')
         .argument('<job-id>', 'Job ID')
@@ -37,4 +37,4 @@ export function createJobStepGetCommand() {
     });
     return cmd;
 }
-//# sourceMappingURL=step-get.js.map
+//# sourceMappingURL=get-step.js.map

package/dist/commands/mcp.js

@@ -6,7 +6,7 @@ export function createMcpCommand() {
     const cmd = new Command('mcp');
     cmd
         .description('Start an MCP server over stdio for use with Claude Code, Cursor, and other MCP hosts')
-        .option('--workspace <id>', 'Workspace ID (defaults to configured workspace)')
+        .option('--workspace <id>', 'Workspace ID or name (defaults to configured workspace)')
         .option('--debug', 'Enable debug logging to stderr')
         .addHelpText('after', `
 Configuration:

package/dist/commands/session/create.js

@@ -10,10 +10,10 @@ export function createSessionCreateCommand() {
     const cmd = new Command('create');
     cmd
         .description('Create a new session')
-        .option('--workspace <id>', 'Workspace ID or name')
+        .option('--workspace <id>', 'Workspace ID or name (e.g., owner~workspace-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/list.js

@@ -11,7 +11,7 @@ export function createSessionListCommand() {
     const cmd = new Command('list');
     cmd
         .description('List sessions in a workspace')
-        .option('--workspace <id>', 'Workspace ID or name')
+        .option('--workspace <id>', 'Workspace ID or name (e.g., owner~workspace-name)')
         .option('--type <type>', 'Filter by session type: chat, webhook, time, agent_test')
         .option('--limit <number>', 'Number of results to return', '20')
         .option('--offset <number>', 'Offset for pagination', '0')

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/index.js

@@ -61,7 +61,7 @@ import { createSessionCreateCommand } from './commands/session/create.js';
 import { createSessionSendCommand } from './commands/session/send.js';
 import { createSessionInterruptCommand } from './commands/session/interrupt.js';
 import { createJobGetCommand } from './commands/job/get.js';
-import { createJobStepGetCommand } from './commands/job/step-get.js';
+import { createJobGetStepCommand } from './commands/job/get-step.js';
 import { createConfigListCommand } from './commands/config/list.js';
 import { createConfigGetCommand } from './commands/config/get.js';
 import { createConfigSetCommand } from './commands/config/set.js';
@@ -281,7 +281,10 @@ sessionCmd.addCommand(createSessionInterruptCommand());
 // Job command group
 const jobCmd = program.command('job').description('Job management');
 jobCmd.addCommand(createJobGetCommand());
-jobCmd.addCommand(createJobStepGetCommand());
+jobCmd.addCommand(createJobGetStepCommand());
+const stepGetAlias = createJobGetStepCommand();
+stepGetAlias.name('step-get');
+jobCmd.addCommand(stepGetAlias, { hidden: true });
 // Config command group
 const configCmd = program
     .command('config')

package/dist/lib/api-client.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import axios from 'axios';
 import { getAuthToken, clearAuthToken } from './auth.js';
-import { retry, debug, GuildCLIError, ErrorCodes } from './errors.js';
+import { retry, debug, GuildCLIError, ErrorCodes, shouldClearAuthToken, } from './errors.js';
 import { getUserAgent, getGuildcoreUrl } from './config.js';
 import { getIapHeaders } from './iap.js';
 /**
@@ -69,14 +69,21 @@ export class GuildAPIClient {
                 return response.data;
             }
             catch (error) {
-                // Handle invalid/expired token - clear it and give clear error
                 if (error &&
                     typeof error === 'object' &&
                     'response' in error &&
                     error.response?.status === 401) {
-                    debug('Token rejected by server (401), clearing invalid token');
-                    await clearAuthToken();
-                    throw new GuildCLIError(ErrorCodes.AUTH_TOKEN_INVALID, 'Your authentication token is invalid or expired. Please run: guild auth login');
+                    const resp = error.response;
+                    const data = resp?.data;
+                    const message = typeof data === 'object' && data && 'message' in data
+                        ? data.message
+                        : undefined;
+                    if (shouldClearAuthToken(message)) {
+                        debug('Guild auth failure (401), clearing token');
+                        await clearAuthToken();
+                        throw new GuildCLIError(ErrorCodes.AUTH_TOKEN_INVALID, 'Your authentication token is invalid or expired. Please run: guild auth login');
+                    }
+                    debug(`Non-auth 401: ${message ?? 'no message'}`);
                 }
                 throw error;
             }