@guildai/cli 0.6.2 → 0.7.1

package/dist/commands/chat.js

@@ -13,8 +13,9 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, matchesAgent, getAgentName, } from '../lib/session-events.js';
+import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, } from '../lib/session-events.js';
 import { printResumeHint, fetchSession, fetchSessionEvents, eventsToDisplayMessages, } from '../lib/session-resume.js';
+import { DEFAULT_EVENT_TYPES, parseEventFilter, shouldShowEvent, } from '../lib/event-filter.js';
 import { fetchEvents, fetchTasks } from '../lib/session-events-fetch.js';
 import { AgentInstallPrompt } from '../components/AgentInstallPrompt.js';
 import { getWorkspaceId } from '../lib/guild-config.js';
@@ -117,7 +118,7 @@ function InputWrapper({ isReady, isInterrupted, input, setInput, handleSubmit, t
         React.createElement(Text, { color: isReady ? BRAND_COLOR : 'gray' }, "> "),
         isReady && isActive ? (React.createElement(CustomInput, { value: input, onChange: setInput, onSubmit: handleSubmit, trackedTasksSize: trackedTasksSize, setShowTaskPanel: setShowTaskPanel, isActive: isActive })) : isReady ? (React.createElement(Text, null, input)) : (React.createElement(Text, null, chalk.dim('(connecting...)')))));
 }
-export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentName, showSplash = true, resumeSession, resumeEvents, resumeCommand, openDashboard, }) {
+export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentName, showSplash = true, resumeSession, resumeEvents, resumeCommand, openDashboard, eventFilter, }) {
     const { exit } = useApp();
     const isResuming = !!resumeSession;
     const [phase, setPhase] = useState(isResuming || !showSplash ? 'chat' : 'splash');
@@ -241,13 +242,14 @@ export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentN
                 }
                 // If not connected yet, ignore escape (let connection complete)
             } })),
-        phase === 'chat' && (React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), resumeEvents: resumeEvents, resumeCommand: resumeCommand })),
+        phase === 'chat' && (React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), resumeEvents: resumeEvents, resumeCommand: resumeCommand, eventFilter: eventFilter })),
         (phase === 'splash' || phase === 'finalizing') &&
             connectedSession &&
             connectedClient && (React.createElement(Box, { display: "none" },
-            React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), isActive: false })))));
+            React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), isActive: false, eventFilter: eventFilter })))));
 }
-function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _versionId, agentName, client: preConnectedClient, session: preConnectedSession, onFirstMessage, isActive = true, resumeEvents, resumeCommand, }) {
+function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _versionId, agentName, client: preConnectedClient, session: preConnectedSession, onFirstMessage, isActive = true, resumeEvents, resumeCommand, eventFilter, }) {
+    const activeFilter = eventFilter ?? DEFAULT_EVENT_TYPES;
     // Note: We handle SIGINT directly via process.on, not using useApp().exit
     // Task panel state - managed at this level to handle keyboard input before TextInput
     // Default to showing task panel (Ctrl-T to toggle)
@@ -525,18 +527,107 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                         }
                         // Process events that affect the chat UI (task state comes from tasks poll)
                         if (event.type === 'runtime_error') {
-                            // Show runtime errors in the chat
-                            const errorText = typeof event.content === 'string' ? event.content : 'Unknown error';
-                            const taskName = agentName || 'assistant';
-                            setMessages((prev) => [
-                                ...prev,
-                                {
-                                    key: `error-${Date.now()}`,
-                                    content: `${chalk.red('●')} ${chalk.bold(taskName)}\n${chalk.red(`Error: ${errorText}`)}`,
-                                    type: 'assistant',
-                                },
-                            ]);
+                            // Always clear the spinner on runtime errors so the UI doesn't get stuck
                             setCurrentOperation('');
+                            // Show runtime errors in the chat (gated on --events filter)
+                            if (shouldShowEvent('runtime_error', activeFilter)) {
+                                const errorText = typeof event.content === 'string' ? event.content : 'Unknown error';
+                                const taskName = agentName || 'assistant';
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `error-${Date.now()}`,
+                                        content: `${chalk.red('●')} ${chalk.bold(taskName)}\n${chalk.red(`Error: ${errorText}`)}`,
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'runtime_start') {
+                            if (shouldShowEvent('runtime_start', activeFilter)) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `runtime-start-${Date.now()}`,
+                                        content: chalk.dim('[runtime/start]'),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'runtime_running') {
+                            if (shouldShowEvent('runtime_running', activeFilter)) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `runtime-running-${Date.now()}`,
+                                        content: chalk.dim('[runtime/running]'),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'runtime_waiting') {
+                            if (shouldShowEvent('runtime_waiting', activeFilter)) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `runtime-waiting-${Date.now()}`,
+                                        content: chalk.dim('[runtime/waiting]'),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'trigger_message') {
+                            if (shouldShowEvent('trigger_message', activeFilter)) {
+                                const triggerText = typeof event.content === 'object' ? event.content?.data || '' : '';
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `trigger-${Date.now()}`,
+                                        content: `${chalk.cyan('[trigger]')} ${triggerText}`,
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'system_error') {
+                            if (shouldShowEvent('system_error', activeFilter)) {
+                                const errText = typeof event.content === 'object' ? event.content?.data || '' : '';
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `system-error-${Date.now()}`,
+                                        content: `${chalk.red('[system_error]')} ${errText}`,
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'llm_start') {
+                            if (shouldShowEvent('llm_start', activeFilter)) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `llm-start-${Date.now()}`,
+                                        content: chalk.dim(`[llm_start] provider:${event.provider}`),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
+                        }
+                        else if (event.type === 'llm_done') {
+                            if (shouldShowEvent('llm_done', activeFilter)) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `llm-done-${Date.now()}`,
+                                        content: chalk.dim(`[llm_done] HTTP ${event.status_code}`),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
                         }
                         else if (event.type === 'agent_notification_progress') {
                             // Update status line with progress text (task tracking is done by tasks poll)
@@ -609,48 +700,63 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             ]);
                             setCurrentOperation('');
                         }
-                        else if (event.type === 'agent_console' && isDebugMode()) {
-                            // Show console logs when debug mode is enabled (matches www debug checkbox behavior)
-                            const content = typeof event.content === 'string' ? event.content : '';
-                            setMessages((prev) => [
-                                ...prev,
-                                {
-                                    key: `console-${Date.now()}-${Math.random()}`,
-                                    content: chalk.dim(`[console.${event.level}] ${content}`),
-                                    type: 'assistant',
-                                },
-                            ]);
+                        else if (event.type === 'agent_console') {
+                            // Show console logs when enabled via --events or --debug
+                            // --debug continues to show console logs for backwards compatibility
+                            if (shouldShowEvent('agent_console', activeFilter) || isDebugMode()) {
+                                const content = typeof event.content === 'string' ? event.content : '';
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        key: `console-${Date.now()}-${Math.random()}`,
+                                        content: chalk.dim(`[console.${event.level}] ${content}`),
+                                        type: 'assistant',
+                                    },
+                                ]);
+                            }
                         }
-                        else if (event.type === 'runtime_done' &&
-                            !receivedResponseSinceLastInput.current &&
-                            event.content !== undefined &&
-                            taskInfo &&
-                            'agent' in taskInfo) {
-                            // One-shot agents may complete with runtime_done without sending
-                            // agent_notification_message. Display the output if we haven't
-                            // already shown a response for this input cycle.
-                            const contentStr = typeof event.content === 'string'
-                                ? event.content
-                                : JSON.stringify(event.content);
-                            if (contentStr && contentStr !== '{}' && contentStr !== 'null') {
-                                const rendered = fixListItemMarkdown(marked.parse(contentStr));
-                                const taskName = agentName || 'assistant';
-                                const messageContent = `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+                        else if (event.type === 'runtime_done') {
+                            if (shouldShowEvent('runtime_done', activeFilter)) {
+                                // Show runtime_done as a system event when enabled via --events
                                 setMessages((prev) => [
                                     ...prev,
                                     {
-                                        key: `msg-${Date.now()}-${Math.random()}`,
-                                        content: messageContent,
+                                        key: `runtime-done-${Date.now()}`,
+                                        content: chalk.dim('[runtime/done]'),
                                         type: 'assistant',
-                                        timestamp: new Date().toLocaleTimeString(),
                                     },
                                 ]);
-                                if (!firstMessageNotified.current && onFirstMessage) {
-                                    firstMessageNotified.current = true;
-                                    onFirstMessage();
+                            }
+                            if (!receivedResponseSinceLastInput.current &&
+                                event.content !== undefined &&
+                                taskInfo &&
+                                'agent' in taskInfo) {
+                                // One-shot agents may complete with runtime_done without sending
+                                // agent_notification_message. Display the output if we haven't
+                                // already shown a response for this input cycle.
+                                const contentStr = typeof event.content === 'string'
+                                    ? event.content
+                                    : JSON.stringify(event.content);
+                                if (contentStr && contentStr !== '{}' && contentStr !== 'null') {
+                                    const rendered = fixListItemMarkdown(marked.parse(contentStr));
+                                    const taskName = agentName || 'assistant';
+                                    const messageContent = `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+                                    setMessages((prev) => [
+                                        ...prev,
+                                        {
+                                            key: `msg-${Date.now()}-${Math.random()}`,
+                                            content: messageContent,
+                                            type: 'assistant',
+                                            timestamp: new Date().toLocaleTimeString(),
+                                        },
+                                    ]);
+                                    if (!firstMessageNotified.current && onFirstMessage) {
+                                        firstMessageNotified.current = true;
+                                        onFirstMessage();
+                                    }
+                                    receivedResponseSinceLastInput.current = true;
+                                    setCurrentOperation('');
                                 }
-                                receivedResponseSinceLastInput.current = true;
-                                setCurrentOperation('');
                             }
                         }
                         else if (event.type === 'interrupted') {
@@ -887,29 +993,7 @@ export async function createSession(client, workspaceId, initialPrompt, versionI
         }
     }
     if (!workspaceId) {
-        // Fall back to fetching workspaces from API
-        progress('Fetching workspaces');
-        const response = await client.get('/me/workspaces');
-        if (!response) {
-            throw new Error('Failed to fetch workspaces');
-        }
-        // Handle both array and paginated object responses
-        const workspaces = (Array.isArray(response)
-            ? response
-            : response?.items || []);
-        if (workspaces.length === 0) {
-            // Get current user to use as workspace owner
-            progress('Creating workspace');
-            const me = (await client.get('/me'));
-            const newWorkspace = (await client.post('/workspaces', {
-                name: 'My Workspace',
-                owner_id: me.id,
-            }));
-            workspaceId = newWorkspace.id;
-        }
-        else {
-            workspaceId = workspaces[0].id;
-        }
+        throw new Error('No workspace configured. Run: guild workspace select, or pass --workspace <id>');
     }
     progress('Creating session');
     const sessionData = {
@@ -950,9 +1034,13 @@ export function createChatCommand() {
         .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')
+        .option('--events <types>', 'Event types to show (default: user). Shorthands: none, user, system, all, or comma-separated type names (e.g. agent_console,llm_start)')
         .addHelpText('after', '\nTo chat with a local agent under development: guild agent chat')
         .action(async (promptArgs, options) => {
         const initialPrompt = promptArgs.length > 0 ? promptArgs.join(' ') : 'Hello';
+        const eventFilter = options.events
+            ? parseEventFilter(options.events)
+            : DEFAULT_EVENT_TYPES;
         if (options.once) {
             // --once mode: use old spinner-based approach
             const spinner = createSpinner('Connecting to Guild servers...');
@@ -999,24 +1087,37 @@ export function createChatCommand() {
                     else {
                         inactivityCounter++;
                     }
-                    // Check if we got a completion response
-                    // Look for runtime_done events from the ROOT task (the agent we're chatting with)
-                    // For orchestrating agents like agent-builder that spawn child tasks, we need to
-                    // wait for the root agent's completion, not just any runtime_done event.
-                    const targetAgent = options.agent || 'assistant';
-                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id // Root task has no parent
-                    );
-                    // Also check for agent_notification_message events from the root agent
-                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id);
+                    const isRootTask = (e) => !e.task?.parent_task;
+                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTask(e));
+                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' && isRootTask(e));
+                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTask(e));
                     // Check for a ui_prompt request... that ends the game.
                     const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
                         e.task?.tool_name === 'ui_prompt');
+                    if (hasRootTaskError) {
+                        debug('Found error event from root agent, exiting --once mode');
+                        const errorEvents = allEvents.filter((e) => e.type === 'runtime_error' || e.type === 'agent_notification_error');
+                        if (errorEvents.length > 0 && !options.mode) {
+                            const lastError = errorEvents[errorEvents.length - 1];
+                            const content = lastError.content;
+                            if (content?.data) {
+                                console.error(chalk.red(`Error: ${content.data}`));
+                            }
+                            else {
+                                console.error(chalk.red('Agent failed to start'));
+                            }
+                        }
+                        else if (options.mode === 'json') {
+                            console.log(JSON.stringify({
+                                session_id: session.id,
+                                events: allEvents,
+                                error: true,
+                            }, null, 2));
+                        }
+                        process.exit(1);
+                    }
                     if (hasRootTaskDone || hasAgentMessage || hasUIPromptMessage) {
-                        debug(`Found completion event from root agent (${targetAgent}), exiting --once mode`);
+                        debug('Found completion event from root agent, exiting --once mode');
                         await outputOnceResult(session.id, allEvents, options.mode);
                         process.exit(0);
                     }
@@ -1075,7 +1176,7 @@ export function createChatCommand() {
             if (shouldShowSplash) {
                 suppressScrollbackClear();
             }
-            const { waitUntilExit } = render(React.createElement(ChatApp, { initialPrompt: initialPrompt, version: packageJson.version, workspaceId: options.workspace, versionId: options.agent, showSplash: shouldShowSplash, resumeSession: resumeSession, resumeEvents: resumeSessionEvents, resumeCommand: resumeCommand }), {
+            const { waitUntilExit } = render(React.createElement(ChatApp, { initialPrompt: initialPrompt, version: packageJson.version, workspaceId: options.workspace, versionId: options.agent, showSplash: shouldShowSplash, resumeSession: resumeSession, resumeEvents: resumeSessionEvents, resumeCommand: resumeCommand, eventFilter: eventFilter }), {
                 exitOnCtrlC: false, // We handle Ctrl-C in useInput (raw mode)
             });
             await waitUntilExit();

package/dist/commands/config/list.js

@@ -27,13 +27,13 @@ export function createConfigListCommand() {
             output.progress(chalk.dim('  guild workspace select'));
             return;
         }
-        if (hasGlobal) {
+        if (config.global && hasGlobal) {
             output.progress(chalk.bold('Global config') + chalk.dim(' (~/.guild/config.json):'));
             for (const [key, value] of Object.entries(config.global)) {
                 output.progress(`  ${key}: ${chalk.cyan(String(value))}`);
             }
         }
-        if (hasLocal) {
+        if (config.local && hasLocal) {
             if (hasGlobal)
                 output.progress('');
             output.progress(chalk.bold('Local config') + chalk.dim(' (guild.json):'));

package/dist/commands/integration/operation/create.js

@@ -17,7 +17,7 @@ export function createIntegrationOperationCreateCommand() {
     cmd
         .description('Create operation(s) for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--operation <name>', 'Operation identifier, e.g. list_users')
         .option('--method <method>', 'HTTP method: GET, POST, PUT, PATCH, DELETE')
         .option('--path <path>', 'REST path, e.g. /{owner}/{repo}/issues')
@@ -35,7 +35,7 @@ export function createIntegrationOperationCreateCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.openapi) {
                 // OpenAPI mode
                 if (!existsSync(options.openapi)) {

package/dist/commands/integration/operation/list.js

@@ -14,7 +14,7 @@ export function createIntegrationOperationListCommand() {
     cmd
         .description('List operations for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (identifier, options) => {
@@ -26,7 +26,7 @@ export function createIntegrationOperationListCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);

package/dist/commands/integration/update.js

@@ -63,7 +63,7 @@ export function createIntegrationUpdateCommand() {
                 hasUpdates = true;
             }
             if (options.baseUrl !== undefined) {
-                body.protocol_config = { base_url: options.baseUrl };
+                body.protocol_config = { protocol: 'REST', base_url: options.baseUrl };
                 hasUpdates = true;
             }
             // Auth config updates need the discriminator

package/dist/commands/integration/version/get.js

@@ -34,7 +34,7 @@ export function createIntegrationVersionGetCommand() {
     cmd
         .description('Get version details')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -44,7 +44,7 @@ export function createIntegrationVersionGetCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const response = await client.get(`/integration_versions/${versionId}`);
             if (getOutputMode() === 'json') {
                 output.data(response);

package/dist/commands/integration/version/publish.js

@@ -23,7 +23,7 @@ export function createIntegrationVersionPublishCommand() {
     cmd
         .description('Publish a built version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version to publish, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version to publish, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -33,7 +33,7 @@ export function createIntegrationVersionPublishCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             // Get current version info for display
             const currentVersion = await client.get(`/integration_versions/${versionId}`);
             const versionDisplay = currentVersion.version_number || versionId;

package/dist/commands/integration/version/test.js

@@ -22,7 +22,7 @@ export function createIntegrationVersionTestCommand() {
     cmd
         .description('Test an endpoint invocation')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .requiredOption('--operation <name>', 'Operation to test, e.g. list_users')
         .option('--account <name>', 'Account name to resolve credential from')
         .option('--input-path <json>', 'JSON object of path parameters')
@@ -50,7 +50,7 @@ export function createIntegrationVersionTestCommand() {
                 body.input_body = parseJsonFlag(options.inputBody, '--input-body');
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.account) {
                 const creds = await client.get(`/accounts/${options.account}/credentials?integration=${encodeURIComponent(identifier)}`);
                 if (creds.items.length === 0) {

package/dist/commands/session/events.js

@@ -3,6 +3,7 @@
 import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
+import { parseEventFilter } from '../../lib/event-filter.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
 export function createSessionEventsCommand() {
@@ -10,7 +11,7 @@ export function createSessionEventsCommand() {
     cmd
         .description('List events in a session')
         .argument('<session-id>', 'Session ID')
-        .option('--types <types>', 'Comma-separated event types to filter (e.g., user_message,agent_notification_message)')
+        .option('--events <types>', 'Event types to show. Shorthands: none, user, system, all, or comma-separated type names')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (sessionId, options) => {
@@ -25,8 +26,11 @@ export function createSessionEventsCommand() {
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);
-            if (options.types) {
-                params.append('types', options.types);
+            if (options.events) {
+                const filter = parseEventFilter(options.events);
+                if (filter.size > 0) {
+                    params.append('types', [...filter].join(','));
+                }
             }
             const response = await client.get(`/sessions/${sessionId}/events?${params.toString()}`);
             output.data(response);

package/dist/commands/session/interrupt.d.ts

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

package/dist/commands/session/interrupt.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 createSessionInterruptCommand() {
+    const cmd = new Command('interrupt');
+    cmd
+        .description('Interrupt a running session')
+        .argument('<session-id>', 'Session ID')
+        .action(async (sessionId) => {
+        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(`/sessions/${sessionId}/interrupt`, {});
+            output.data(response);
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to interrupt session: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=interrupt.js.map