@guildai/cli 0.5.10 → 0.5.11

package/dist/commands/agent/init.js

@@ -34,18 +34,30 @@ function slugify(text) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '');
 }
+const NAME_RULES = 'Lowercase letters, digits, hyphens, and underscores only (1-100 characters)';
+function isValidAgentName(name) {
+    return name.length >= 1 && name.length <= 100 && /^[a-z0-9\-_.]+$/.test(name);
+}
 async function promptForName(defaultName) {
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
-    return new Promise((resolve) => {
+    const ask = () => new Promise((resolve) => {
         rl.question(`Agent name [${defaultName}]: `, (answer) => {
-            rl.close();
             const trimmed = answer.trim();
-            resolve(trimmed || defaultName);
+            const name = trimmed || defaultName;
+            if (!isValidAgentName(name)) {
+                console.error(`Invalid name "${name}": ${NAME_RULES}`);
+                resolve(ask());
+            }
+            else {
+                rl.close();
+                resolve(name);
+            }
         });
     });
+    return ask();
 }
 async function promptForTemplate() {
     const { template } = await inquirer.prompt([
@@ -120,6 +132,15 @@ export function createAgentInitCommand() {
                     process.exit(1);
                 }
             }
+            // Validate name (catches --name flag and non-interactive paths)
+            if (!isValidAgentName(agentName)) {
+                console.error(`Error: Invalid agent name "${agentName}"`);
+                console.error('');
+                console.error(`Agent names must use ${NAME_RULES}`);
+                console.error('');
+                console.error('Examples: my-agent, my_agent');
+                process.exit(1);
+            }
             // Determine template: use --template option, prompt if interactive, or error
             let template = options.template;
             if (!template) {

package/dist/commands/container/destroy.d.ts

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

package/dist/commands/container/destroy.js

@@ -0,0 +1,48 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter } from '../../lib/output.js';
+export function createContainerDestroyCommand() {
+    const cmd = new Command('destroy');
+    cmd
+        .description('Destroy a running container')
+        .argument('<container-id>', 'Container ID')
+        .action(async (containerId) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.post(`/containers/${containerId}/destroy`, {});
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                if (response.status === 'SUCCESS') {
+                    output.success(`Container ${containerId} destroyed`);
+                }
+                else if (response.status === 'ERROR') {
+                    output.error(`Failed to destroy container: ${response.error || 'unknown error'}`);
+                    process.exit(1);
+                }
+                else {
+                    output.progress(`Container destruction ${response.status.toLowerCase()}...`);
+                }
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to destroy container: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=destroy.js.map

package/dist/commands/container/events.d.ts

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

package/dist/commands/container/events.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatContainerEventTable } from '../../lib/output.js';
+export function createContainerEventsCommand() {
+    const cmd = new Command('events');
+    cmd
+        .description('List events for a container')
+        .argument('<container-id>', 'Container ID')
+        .option('--limit <number>', 'Number of results to return', '20')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .action(async (containerId, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const params = new URLSearchParams();
+            params.append('limit', options.limit);
+            params.append('offset', options.offset);
+            const response = await client.get(`/containers/${containerId}/events?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                formatContainerEventTable(response.items, response.pagination);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list container events: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=events.js.map

package/dist/commands/container/exec.d.ts

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

package/dist/commands/container/exec.js

@@ -0,0 +1,64 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter } from '../../lib/output.js';
+export function createContainerExecCommand() {
+    const cmd = new Command('exec');
+    cmd
+        .description('Execute a command in a running container')
+        .argument('<container-id>', 'Container ID')
+        .argument('<command>', 'Command to execute')
+        .action(async (containerId, command) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.post(`/containers/${containerId}/command`, { command });
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                // Display return code
+                if (response.return_code !== null) {
+                    const codeColor = response.return_code === 0 ? chalk.green : chalk.red;
+                    console.error(chalk.dim('Return code:'), codeColor(String(response.return_code)));
+                }
+                // Display stdout
+                if (response.stdout) {
+                    console.log(response.stdout);
+                }
+                // Display stderr
+                if (response.stderr) {
+                    console.error(chalk.red(response.stderr));
+                }
+                // Display error from event
+                if (response.status === 'ERROR' && response.error) {
+                    console.error(chalk.red(`Error: ${response.error}`));
+                }
+            }
+            // Exit with the command's return code if available
+            if (response.return_code !== null && response.return_code !== 0) {
+                process.exit(response.return_code);
+            }
+            if (response.status === 'ERROR') {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to execute command: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=exec.js.map

package/dist/commands/container/get.d.ts

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

package/dist/commands/container/get.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+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';
+export function createContainerGetCommand() {
+    const cmd = new Command('get');
+    cmd
+        .description('Get container details')
+        .argument('<container-id>', 'Container ID')
+        .action(async (containerId) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.get(`/containers/${containerId}`);
+            output.data(response);
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get container: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/container/list.d.ts

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

package/dist/commands/container/list.js

@@ -0,0 +1,48 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatContainerTable } from '../../lib/output.js';
+export function createContainerListCommand() {
+    const cmd = new Command('list');
+    cmd
+        .description('List containers for an account')
+        .requiredOption('--account <id-or-name>', 'Account ID or name')
+        .option('--status <status>', 'Filter by status: STARTING, RUNNING, ERRORED, DESTROYED')
+        .option('--limit <number>', 'Number of results to return', '20')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .action(async (options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const params = new URLSearchParams();
+            params.append('limit', options.limit);
+            params.append('offset', options.offset);
+            if (options.status) {
+                params.append('statuses', options.status.toUpperCase());
+            }
+            const response = await client.get(`/accounts/${options.account}/containers?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                formatContainerTable(response.items, response.pagination);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list containers: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/container-image/create.d.ts

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

package/dist/commands/container-image/create.js

@@ -0,0 +1,41 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+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';
+export function createContainerImageCreateCommand() {
+    const cmd = new Command('create');
+    cmd
+        .description('Create a container image')
+        .requiredOption('--account <id-or-name>', 'Account or organization ID or name')
+        .requiredOption('--name <name>', 'Image name (1-100 characters)')
+        .requiredOption('--image <image>', 'Container image path (e.g. registry.example.com/org/image)')
+        .requiredOption('--tag <tag>', 'Image tag (e.g. latest)')
+        .action(async (opts) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.post('/container-images', {
+                name: opts.name,
+                image_name: opts.image,
+                tag: opts.tag,
+                owner_id_or_name: opts.account,
+            });
+            output.data(response);
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to create container image: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/container-image/get.d.ts

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

package/dist/commands/container-image/get.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+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';
+export function createContainerImageGetCommand() {
+    const cmd = new Command('get');
+    cmd
+        .description('Get container image details')
+        .argument('<image-id-or-name>', 'Container image ID or name (owner~name)')
+        .action(async (imageIdOrName) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.get(`/container-images/${imageIdOrName}`);
+            output.data(response);
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get container image: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/container-image/list.d.ts

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

package/dist/commands/container-image/list.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatContainerImageTable } from '../../lib/output.js';
+export function createContainerImageListCommand() {
+    const cmd = new Command('list');
+    cmd
+        .description('List container images for an account')
+        .requiredOption('--account <id-or-name>', 'Account 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();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const params = new URLSearchParams();
+            params.append('limit', options.limit);
+            params.append('offset', options.offset);
+            const response = await client.get(`/accounts/${options.account}/container-images?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                formatContainerImageTable(response.items, response.pagination);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list container images: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/job/get.d.ts

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

package/dist/commands/job/get.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatJobStepTable } from '../../lib/output.js';
+export function createJobGetCommand() {
+    const cmd = new Command('get');
+    cmd
+        .description('Get job details and steps')
+        .argument('<job-id>', 'Job ID')
+        .action(async (jobId) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const [job, stepsResponse] = await Promise.all([
+                client.get(`/jobs/${jobId}`),
+                client.get(`/jobs/${jobId}/steps`),
+            ]);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify({ ...job, steps: stepsResponse.steps }, null, 2));
+            }
+            else {
+                output.data(job);
+                console.log();
+                formatJobStepTable(stepsResponse.steps);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get job: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/job/step-get.d.ts

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

package/dist/commands/job/step-get.js

@@ -0,0 +1,40 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+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';
+export function createJobStepGetCommand() {
+    const cmd = new Command('step-get');
+    cmd
+        .description('Get details of a step in a job')
+        .argument('<job-id>', 'Job ID')
+        .argument('<step-name>', 'Step name')
+        .action(async (jobId, stepName) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const stepsResponse = await client.get(`/jobs/${jobId}/steps`);
+            const step = stepsResponse.steps.find((s) => s.name === stepName);
+            if (!step) {
+                const available = stepsResponse.steps.map((s) => s.name).join(', ');
+                output.error(`Step "${stepName}" not found. Available steps: ${available || 'none'}`);
+                process.exit(1);
+            }
+            output.data(step);
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get job step: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=step-get.js.map

package/dist/commands/trigger/create.js

@@ -24,6 +24,7 @@ export function createTriggerCreateCommand() {
         .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('--input <json>', 'Agent input as JSON object')
         .action(async (options) => {
         const output = createOutputWriter();
@@ -130,6 +131,9 @@ export function createTriggerCreateCommand() {
                 if (options.daysOfMonth) {
                     body.days_of_month = options.daysOfMonth;
                 }
+                if (options.minutesOfHour) {
+                    body.minutes_of_hour = options.minutesOfHour;
+                }
             }
             const response = await client.post(`/workspaces/${workspaceId}/triggers`, body);
             output.data(response);

package/dist/commands/trigger/update.js

@@ -20,6 +20,7 @@ export function createTriggerUpdateCommand() {
         .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('--input <json>', 'Agent input as JSON object (for time triggers)')
         .action(async (triggerId, options) => {
         const output = createOutputWriter();
@@ -66,6 +67,9 @@ export function createTriggerUpdateCommand() {
             if (options.daysOfMonth !== undefined) {
                 body.days_of_month = options.daysOfMonth;
             }
+            if (options.minutesOfHour !== undefined) {
+                body.minutes_of_hour = options.minutesOfHour;
+            }
             if (options.input !== undefined) {
                 try {
                     body.agent_input = JSON.parse(options.input);

package/dist/index.js

@@ -60,6 +60,16 @@ import { createSessionEventsCommand } from './commands/session/events.js';
 import { createSessionTasksCommand } from './commands/session/tasks.js';
 import { createSessionCreateCommand } from './commands/session/create.js';
 import { createSessionSendCommand } from './commands/session/send.js';
+import { createContainerGetCommand } from './commands/container/get.js';
+import { createContainerListCommand } from './commands/container/list.js';
+import { createContainerEventsCommand } from './commands/container/events.js';
+import { createContainerExecCommand } from './commands/container/exec.js';
+import { createContainerDestroyCommand } from './commands/container/destroy.js';
+import { createContainerImageListCommand } from './commands/container-image/list.js';
+import { createContainerImageGetCommand } from './commands/container-image/get.js';
+import { createContainerImageCreateCommand } from './commands/container-image/create.js';
+import { createJobGetCommand } from './commands/job/get.js';
+import { createJobStepGetCommand } from './commands/job/step-get.js';
 import { createConfigListCommand } from './commands/config/list.js';
 import { createConfigGetCommand } from './commands/config/get.js';
 import { createConfigSetCommand } from './commands/config/set.js';
@@ -208,6 +218,20 @@ triggerCmd.addCommand(createTriggerUpdateCommand());
 triggerCmd.addCommand(createTriggerActivateCommand());
 triggerCmd.addCommand(createTriggerDeactivateCommand());
 triggerCmd.addCommand(createTriggerSessionsCommand());
+// Container command group
+const containerCmd = program.command('container').description('Container management');
+containerCmd.addCommand(createContainerListCommand());
+containerCmd.addCommand(createContainerGetCommand());
+containerCmd.addCommand(createContainerEventsCommand());
+containerCmd.addCommand(createContainerExecCommand());
+containerCmd.addCommand(createContainerDestroyCommand());
+// Container image command group
+const containerImageCmd = program
+    .command('container-image')
+    .description('Container image management');
+containerImageCmd.addCommand(createContainerImageCreateCommand());
+containerImageCmd.addCommand(createContainerImageListCommand());
+containerImageCmd.addCommand(createContainerImageGetCommand());
 // Session command group
 const sessionCmd = program.command('session').description('Session management');
 sessionCmd.addCommand(createSessionListCommand());
@@ -216,6 +240,10 @@ sessionCmd.addCommand(createSessionEventsCommand());
 sessionCmd.addCommand(createSessionTasksCommand());
 sessionCmd.addCommand(createSessionCreateCommand());
 sessionCmd.addCommand(createSessionSendCommand());
+// Job command group
+const jobCmd = program.command('job').description('Job management');
+jobCmd.addCommand(createJobGetCommand());
+jobCmd.addCommand(createJobStepGetCommand());
 // Config command group
 const configCmd = program
     .command('config')

package/dist/lib/api-types.d.ts

@@ -315,6 +315,141 @@ export interface Organization {
     viewer_role: 'ADMIN' | 'MEMBER' | null;
 }
 export type OrganizationListResponse = PaginatedResponse<Organization>;
+/**
+ * Session entity from API responses.
+ * Used by: session list, container list (as owner)
+ */
+export interface Session {
+    id: string;
+    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
+    name?: string;
+    workspace?: {
+        id: string;
+        name: string;
+    };
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerStatus = 'STARTING' | 'RUNNING' | 'ERRORED' | 'DESTROYED';
+/**
+ * Container image entity from the API.
+ */
+export interface ContainerImage {
+    id: string;
+    name: string;
+    image_name: string;
+    tag: string;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * The actor that created the container (user or task agent).
+ */
+export interface ContainerActor {
+    id: string;
+    entity_type: string;
+    name?: string;
+    full_name?: string;
+}
+/**
+ * Container entity from the API.
+ * Used by: container list
+ */
+export interface Container {
+    id: string;
+    status: ContainerStatus;
+    owner: Session;
+    created_by: ContainerActor;
+    image: ContainerImage;
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerListResponse = PaginatedResponse<Container>;
+/**
+ * Container image as returned in list responses.
+ */
+export interface ContainerImageListItem {
+    id: string;
+    name: string;
+    image_name: string;
+    tag: string;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerImageListResponse = PaginatedResponse<ContainerImageListItem>;
+export type ContainerEventStatus = 'PENDING' | 'ERROR' | 'SUCCESS';
+/**
+ * Base fields shared by all container events.
+ */
+export interface ContainerEventBase {
+    id: string;
+    entity_type: string;
+    actor: ContainerActor;
+    status: ContainerEventStatus;
+    completed_at: string | null;
+    error: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface ContainerEventCreate extends ContainerEventBase {
+    entity_type: 'EntContainerEventCreate';
+    is_local: boolean;
+}
+export interface ContainerEventDestroy extends ContainerEventBase {
+    entity_type: 'EntContainerEventDestroy';
+    found: boolean | null;
+}
+export interface ContainerEventCommand extends ContainerEventBase {
+    entity_type: 'EntContainerEventCommand';
+    command: string;
+    return_code: number | null;
+    stdout: string | null;
+    stderr: string | null;
+}
+export type ContainerEvent = ContainerEventCreate | ContainerEventDestroy | ContainerEventCommand;
+export type ContainerEventListResponse = PaginatedResponse<ContainerEvent>;
+export type JobType = 'VALIDATION' | 'PUBLISH' | 'PUBLISH_PRE_CHECK';
+export type JobStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'ERRORED' | 'CANCELLED';
+export type JobStepStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'SKIPPED' | 'ERRORED';
+/**
+ * Job entity from the API.
+ * Used by: job get
+ */
+export interface Job {
+    id: string;
+    target_id: string;
+    job_type: JobType;
+    status: JobStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    error_message: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Job step entity from the API.
+ * Used by: job get (steps table)
+ */
+export interface JobStep {
+    id: string;
+    job: Job;
+    name: string;
+    status: JobStepStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    content: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Response from GET /jobs/:id/steps.
+ */
+export interface JobStepsResponse {
+    job_id: string;
+    steps: JobStep[];
+}
 /**
  * Contents of guild.json file in agent directories.
  */

package/dist/lib/generated-types.d.ts

@@ -1,5 +1,5 @@
 export declare const WEBHOOK_SERVICES: readonly ["AZURE_DEVOPS", "BITBUCKET", "CYPRESS", "GITHUB", "GOOGLE_DOCS", "GOOGLE_COMPUTE", "GOOGLE_LOGGING", "JIRA", "LINEAR", "NEWRELIC", "NOTION", "SLACK", "TESTRAIL", "ZENDESK"];
 export type WebhookService = (typeof WEBHOOK_SERVICES)[number];
-export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY"];
+export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "CRON"];
 export type TimeTriggerFrequency = (typeof TIME_TRIGGER_FREQUENCIES)[number];
 //# sourceMappingURL=generated-types.d.ts.map

package/dist/lib/generated-types.js

@@ -29,5 +29,6 @@ export const TIME_TRIGGER_FREQUENCIES = [
     'DAILY',
     'WEEKLY',
     'MONTHLY',
+    'CRON',
 ];
 //# sourceMappingURL=generated-types.js.map

package/dist/lib/output.d.ts

@@ -1,19 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Context, Pagination, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
-/**
- * Session type from API responses
- */
-interface Session {
-    id: string;
-    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
-    name?: string;
-    workspace?: {
-        id: string;
-        name: string;
-    };
-    created_at: string;
-    updated_at: string;
-}
+import type { Agent, AgentVersion, Container, ContainerEvent, ContainerImageListItem, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
@@ -49,6 +35,26 @@ export declare function formatSessionTable(sessions: Session[], pagination: Pagi
  * Used by trigger list command.
  */
 export declare function formatTriggerTable(triggers: Trigger[], pagination: Pagination): void;
+/**
+ * Format a container list as a human-readable table.
+ * Used by container list command.
+ */
+export declare function formatContainerTable(containers: Container[], pagination: Pagination): void;
+/**
+ * Format a container image list as a human-readable table.
+ * Used by container-image list command.
+ */
+export declare function formatContainerImageTable(images: ContainerImageListItem[], pagination: Pagination): void;
+/**
+ * Format a container event list as a human-readable table.
+ * Used by container events command.
+ */
+export declare function formatContainerEventTable(events: ContainerEvent[], pagination: Pagination): void;
+/**
+ * Format job steps as a human-readable table.
+ * Used by job get command.
+ */
+export declare function formatJobStepTable(steps: JobStep[]): void;
 /**
  * Output writer interface for consistent CLI output
  *
@@ -108,5 +114,4 @@ export declare class JSONOutputWriter implements OutputWriter {
  * Create output writer based on current mode
  */
 export declare function createOutputWriter(): OutputWriter;
-export {};
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
 import chalk from 'chalk';
-import { Table } from 'console-table-printer';
+import { Table } from './table.js';
 import { getOutputMode, isQuietMode } from './output-mode.js';
 import { createSpinner } from './progress.js';
 import { brand, hyperlink } from './colors.js';
@@ -313,6 +313,189 @@ export function formatTriggerTable(triggers, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} triggers`));
     }
 }
+/**
+ * Format a container list as a human-readable table.
+ * Used by container list command.
+ */
+export function formatContainerTable(containers, pagination) {
+    if (containers.length === 0) {
+        console.log(chalk.dim('No containers found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'image', title: 'IMAGE', alignment: 'left' },
+            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    containers.forEach((container) => {
+        const statusColor = container.status === 'RUNNING'
+            ? chalk.green
+            : container.status === 'ERRORED'
+                ? chalk.red
+                : container.status === 'DESTROYED'
+                    ? chalk.dim
+                    : chalk.yellow;
+        table.addRow({
+            id: container.id,
+            status: statusColor(container.status),
+            image: container.image?.name || '-',
+            tag: container.image?.tag || '-',
+            created: container.created_at ? formatRelativeTime(container.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, containers.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} containers. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} containers`));
+    }
+}
+/**
+ * Format a container image list as a human-readable table.
+ * Used by container-image list command.
+ */
+export function formatContainerImageTable(images, pagination) {
+    if (images.length === 0) {
+        console.log(chalk.dim('No container images found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'name', title: 'NAME', alignment: 'left' },
+            { name: 'image', title: 'IMAGE', alignment: 'left' },
+            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'public', title: 'PUBLIC', alignment: 'left' },
+        ],
+    });
+    images.forEach((image) => {
+        table.addRow({
+            id: image.id,
+            name: image.name,
+            image: image.image_name,
+            tag: image.tag,
+            public: image.is_public ? chalk.green('yes') : chalk.dim('no'),
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, images.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} images. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} images`));
+    }
+}
+/**
+ * Derive a human-readable event type label from entity_type.
+ */
+function formatEventType(entityType) {
+    if (entityType === 'EntContainerEventCreate')
+        return 'create';
+    if (entityType === 'EntContainerEventDestroy')
+        return 'destroy';
+    if (entityType === 'EntContainerEventCommand')
+        return 'command';
+    return entityType;
+}
+/**
+ * Format a container event list as a human-readable table.
+ * Used by container events command.
+ */
+export function formatContainerEventTable(events, pagination) {
+    if (events.length === 0) {
+        console.log(chalk.dim('No events found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'type', title: 'TYPE', alignment: 'left', color: 'cyan' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'actor', title: 'ACTOR', alignment: 'left' },
+            { name: 'detail', title: 'DETAIL', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    events.forEach((event) => {
+        const statusColor = event.status === 'SUCCESS'
+            ? chalk.green
+            : event.status === 'ERROR'
+                ? chalk.red
+                : chalk.yellow;
+        let detail = '';
+        if (event.entity_type === 'EntContainerEventCommand') {
+            detail = truncate(event.command, 30);
+        }
+        else if (event.status === 'ERROR' && event.error) {
+            detail = truncate(event.error, 30);
+        }
+        table.addRow({
+            id: event.id,
+            type: formatEventType(event.entity_type),
+            status: statusColor(event.status),
+            actor: event.actor?.name || event.actor?.full_name || '-',
+            detail,
+            created: event.created_at ? formatRelativeTime(event.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, events.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} events. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} events`));
+    }
+}
+/**
+ * Format job steps as a human-readable table.
+ * Used by job get command.
+ */
+export function formatJobStepTable(steps) {
+    if (steps.length === 0) {
+        console.log(chalk.dim('No steps found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'name', title: 'STEP', alignment: 'left' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'started', title: 'STARTED', alignment: 'left' },
+            { name: 'completed', title: 'COMPLETED', alignment: 'left' },
+        ],
+    });
+    steps.forEach((step) => {
+        const statusColor = step.status === 'SUCCEEDED'
+            ? chalk.green
+            : step.status === 'FAILED' || step.status === 'ERRORED'
+                ? chalk.red
+                : step.status === 'RUNNING'
+                    ? chalk.yellow
+                    : step.status === 'SKIPPED'
+                        ? chalk.dim
+                        : chalk.white;
+        table.addRow({
+            name: step.name,
+            status: statusColor(step.status),
+            started: step.started_at ? formatRelativeTime(step.started_at) : '-',
+            completed: step.completed_at ? formatRelativeTime(step.completed_at) : '-',
+        });
+    });
+    table.printTable();
+}
 /**
  * Human-friendly output writer
  *

package/dist/lib/session-events.d.ts

@@ -85,6 +85,7 @@ export interface RuntimeWaitingEvent extends BaseEvent {
 export interface RuntimeErrorEvent extends BaseEvent {
     type: 'runtime_error';
     content: string;
+    stack: string | null;
 }
 export interface RuntimeDoneEvent extends BaseEvent {
     type: 'runtime_done';

package/dist/lib/table.d.ts

@@ -0,0 +1,22 @@
+interface ColumnConfig {
+    name: string;
+    title: string;
+    alignment?: 'left';
+    color?: string;
+}
+/**
+ * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
+ * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
+ */
+export declare class Table {
+    private columns;
+    private rows;
+    constructor(config: {
+        columns: ColumnConfig[];
+    });
+    addRow(row: Record<string, string>): void;
+    render(): string;
+    printTable(): void;
+}
+export {};
+//# sourceMappingURL=table.d.ts.map

package/dist/lib/table.js

@@ -0,0 +1,60 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+/**
+ * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
+ * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
+ */
+export class Table {
+    columns;
+    rows = [];
+    constructor(config) {
+        this.columns = config.columns;
+    }
+    addRow(row) {
+        const sanitized = {};
+        for (const [k, v] of Object.entries(row)) {
+            sanitized[k] = v.replace(/[\r\n]+/g, ' ').trim();
+        }
+        this.rows.push(sanitized);
+    }
+    render() {
+        const widths = this.columns.map((col) => {
+            const headerWidth = stringWidth(col.title);
+            const maxData = this.rows.reduce((max, row) => Math.max(max, stringWidth(row[col.name] ?? '')), 0);
+            return Math.max(headerWidth, maxData);
+        });
+        const pad = (text, width) => {
+            const visible = stringWidth(text);
+            return visible >= width ? text : text + ' '.repeat(width - visible);
+        };
+        const top = '┌' + widths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐';
+        const mid = '├' + widths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤';
+        const bot = '└' + widths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
+        const header = '│' +
+            this.columns
+                .map((col, i) => ' ' + chalk.bold(pad(col.title, widths[i])) + ' ')
+                .join('│') +
+            '│';
+        const dataRows = this.rows.map((row) => '│' +
+            this.columns
+                .map((col, i) => {
+                const val = row[col.name] ?? '';
+                const padded = pad(val, widths[i]);
+                if (col.color && col.color in chalk) {
+                    return (' ' +
+                        chalk[col.color](padded) +
+                        ' ');
+                }
+                return ' ' + padded + ' ';
+            })
+                .join('│') +
+            '│');
+        return [top, header, mid, ...dataRows, bot].join('\n');
+    }
+    printTable() {
+        console.log(this.render());
+    }
+}
+//# sourceMappingURL=table.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -59,9 +59,7 @@
     "@napi-rs/keyring": "^1.2.0",
     "axios": "^1.13.2",
     "chalk": "^5.3.0",
-    "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
-    "console-table-printer": "^2.15.0",
     "dotenv": "^16.4.7",
     "execa": "^9.6.1",
     "ink": "^5.0.1",
@@ -76,6 +74,7 @@
     "react": "^18.3.1",
     "sharp": "^0.34.5",
     "shell-quote": "^1.8.2",
+    "string-width": "^7.2.0",
     "svg-pathdata": "^8.0.0",
     "svgdom": "^0.1.22",
     "ws": "^8.18.0",