@guildai/cli 0.6.2 → 0.7.0

package/README.md

@@ -229,6 +229,8 @@ guild version                           # Show version info
 ```bash
 guild setup                             # Install skills + configure MCP server
 guild setup --claude-md                 # Also create a CLAUDE.md template
+guild setup --codex                     # Install Codex skills + configure MCP server
+guild setup --codex --agents-md         # Also create an AGENTS.md template
 guild setup --no-mcp                    # Install skills only, skip MCP configuration
 guild mcp                               # Start MCP server (used by Claude Code, etc.)
 ```
@@ -243,7 +245,7 @@ The CLI includes an [MCP](https://modelcontextprotocol.io/) server that exposes
 guild setup
 ```
 
-This installs Claude Code skills and adds a `guild` entry to `.mcp.json` in your project. Claude Code (and other MCP-compatible tools) will automatically connect when they detect it.
+This installs Claude Code skills and adds a `guild` entry to `.mcp.json` in your project. Use `guild setup --codex` to install Codex skills instead. Claude Code and other MCP-compatible tools will automatically connect when they detect `.mcp.json`.
 
 **What it provides:**
 

package/dist/commands/agent/chat.js

@@ -16,7 +16,6 @@ import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { format } from '../../lib/progress.js';
 import { showBetaGuidance } from '../../lib/auth.js';
 import { pollUntilComplete } from '../../lib/polling.js';
-import { runGit } from '../../lib/git.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
 import * as readline from 'readline';
 import { pollForResponse } from '../../lib/session-polling.js';
@@ -34,7 +33,7 @@ export function createAgentChatCommand() {
         .option('--path <dir>', 'Path to agent directory (defaults to current directory)')
         .option('--workspace <identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
         .option('--mode <format>', 'Input mode: json (one-shot) or jsonl (line-by-line)')
-        .option('--ephemeral', 'Chat using unsaved changes (no guild agent save required)')
+        .option('--version <id>', 'Chat with a specific version (UUID or version number)')
         .option('--no-splash', 'Skip the splash screen animation')
         .option('--resume <session-id>', 'Resume an existing session')
         .option('--open', 'Open session in web dashboard')
@@ -67,10 +66,23 @@ export function createAgentChatCommand() {
             const quiet = isQuietMode();
             const resolvedPath = path.resolve(agentPath);
             // Resolve the version to chat with.
-            // Default: use the latest saved version (requires clean working tree).
-            // --ephemeral: read local files and create an ephemeral version.
+            // Default: create ephemeral version from working directory.
+            // --version: use a specific existing version.
             let version;
-            if (options.ephemeral) {
+            if (options.version) {
+                // Explicit version: look it up by ID or version number
+                const existingVersions = (await client.get(`/agents/${agentId}/versions`));
+                const match = existingVersions.items.find((v) => v.id === options.version || v.version_number === options.version);
+                if (!match) {
+                    console.error(`Error: Version not found: ${options.version}`);
+                    console.error('');
+                    console.error('List available versions:');
+                    console.error(`  guild agent versions ${agentId}`);
+                    process.exit(1);
+                }
+                version = match;
+            }
+            else {
                 if (!quiet) {
                     console.error('Building agent...');
                 }
@@ -81,43 +93,6 @@ export function createAgentChatCommand() {
                     version_type: 'EPHEMERAL',
                 }));
             }
-            else {
-                // Require clean working tree
-                const { stdout: statusOutput } = await runGit(['status', '--porcelain'], {
-                    cwd: resolvedPath,
-                });
-                if (statusOutput.trim().length > 0) {
-                    console.error('Error: Working tree has unsaved changes');
-                    console.error('');
-                    console.error('Options:');
-                    console.error('  1. Save your changes first:');
-                    console.error('       guild agent save --message "your changes"');
-                    console.error('');
-                    console.error('  2. Chat with unsaved changes:');
-                    console.error('       guild agent chat --ephemeral');
-                    process.exit(1);
-                }
-                // Get commit SHA and look for an existing version
-                const { stdout: shaOutput } = await runGit(['rev-parse', 'HEAD'], {
-                    cwd: resolvedPath,
-                });
-                const commitSha = shaOutput.trim();
-                const existingVersions = (await client.get(`/agents/${agentId}/versions`));
-                const existing = existingVersions.items.find((v) => v.sha === commitSha);
-                if (existing) {
-                    version = existing;
-                }
-                else {
-                    if (!quiet) {
-                        console.error('Building agent...');
-                    }
-                    version = (await client.post(`/agents/${agentId}/versions`, {
-                        commit_sha: commitSha,
-                        summary: '[Chat] Development version',
-                        version_type: 'COMMITTED',
-                    }));
-                }
-            }
             // Wait for build to complete (skip if version already validated)
             if (version.validation_status === 'PENDING' ||
                 version.validation_status === 'RUNNING') {

package/dist/commands/agent/test.js

@@ -17,7 +17,7 @@ import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
 import { pollForResponse } from '../../lib/session-polling.js';
 import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
-import { runGit, GitError, formatGitError } from '../../lib/git.js';
+import { GitError, formatGitError } from '../../lib/git.js';
 import { pollUntilComplete } from '../../lib/polling.js';
 import { readAgentFiles } from '../../lib/agent-helpers.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
@@ -33,7 +33,7 @@ export function createAgentTestCommand() {
         .description('Test agent in interactive REPL session')
         .option('--workspace <identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
         .option('--mode <format>', 'Input mode: json (one-shot) or jsonl (line-by-line)')
-        .option('--ephemeral', 'Test unsaved changes via ephemeral version (no guild agent save required)')
+        .option('--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')
         .action(async (options) => {
@@ -75,12 +75,10 @@ export function createAgentTestCommand() {
                 console.error('  guild agent clone <agent-id>');
                 process.exit(1);
             }
-            // For ephemeral mode, we skip git checks and read files directly
-            // For committed mode, we require a clean working tree
-            let commitSha = null;
+            // Read agent files from disk for ephemeral version creation.
+            // Skipped when --version is provided (testing a specific existing version).
             let agentFiles = null;
-            if (options.ephemeral) {
-                // Ephemeral mode: read files from disk
+            if (!options.version) {
                 try {
                     agentFiles = await readAgentFiles(cwd);
                 }
@@ -96,28 +94,6 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
-            else {
-                // Committed mode: require clean working tree
-                const { stdout: statusOutput } = await runGit(['status', '--porcelain'], {
-                    cwd,
-                });
-                if (statusOutput.trim().length > 0) {
-                    console.error('Error: Working tree has unsaved changes');
-                    console.error('');
-                    console.error('Options:');
-                    console.error('  1. Save your changes first:');
-                    console.error('       guild agent save --message "your changes"');
-                    console.error('');
-                    console.error('  2. Test unsaved changes:');
-                    console.error('       guild agent test --ephemeral');
-                    process.exit(1);
-                }
-                // Get commit SHA
-                const { stdout: shaOutput } = await runGit(['rev-parse', 'HEAD'], {
-                    cwd,
-                });
-                commitSha = shaOutput.trim();
-            }
             // If using JSON input, read and validate it early (before auth/session creation)
             // This provides better UX - fail fast on bad JSON without needing auth
             let inputData;
@@ -156,33 +132,31 @@ export function createAgentTestCommand() {
             }
             // Validate auth before any API calls or UI rendering
             await ensureAuthenticated();
-            // Create version for testing
+            // Resolve version for testing
             const client = new GuildAPIClient();
             let version;
             try {
-                if (options.ephemeral && agentFiles) {
-                    // Ephemeral version: send file contents directly
+                if (options.version) {
+                    // Explicit version: look it up by ID or version number
+                    const existingVersions = (await client.get(`/agents/${guildConfig.agent_id}/versions`));
+                    const match = existingVersions.items.find((v) => v.id === options.version || v.version_number === options.version);
+                    if (!match) {
+                        console.error(`Error: Version not found: ${options.version}`);
+                        console.error('');
+                        console.error('List available versions:');
+                        console.error(`  guild agent versions ${guildConfig.agent_id}`);
+                        process.exit(1);
+                    }
+                    version = match;
+                }
+                else {
+                    // Default: create ephemeral version from working directory
                     version = (await client.post(`/agents/${guildConfig.agent_id}/versions`, {
                         files: agentFiles,
                         summary: '[Test] Ephemeral development version',
                         version_type: 'EPHEMERAL',
                     }));
                 }
-                else {
-                    // Committed mode: check if a version for this commit already exists
-                    const existingVersions = (await client.get(`/agents/${guildConfig.agent_id}/versions`));
-                    const existing = existingVersions.items.find((v) => v.sha === commitSha);
-                    if (existing) {
-                        version = existing;
-                    }
-                    else {
-                        version = (await client.post(`/agents/${guildConfig.agent_id}/versions`, {
-                            commit_sha: commitSha,
-                            summary: '[Test] Development version',
-                            version_type: 'COMMITTED',
-                        }));
-                    }
-                }
             }
             catch (error) {
                 const formattedError = handleAxiosError(error);
@@ -280,9 +254,9 @@ export function createAgentTestCommand() {
             const quiet = isQuietMode();
             if (!quiet) {
                 console.log(`✓ Agent: ${guildConfig.name} (${guildConfig.agent_id})`);
-                const versionDisplay = options.ephemeral
-                    ? 'ephemeral (unsaved changes)'
-                    : commitSha?.substring(0, 12) || 'unknown';
+                const versionDisplay = options.version
+                    ? options.version
+                    : 'ephemeral (working directory)';
                 console.log(`✓ Version: ${versionDisplay}`);
                 console.log(`✓ Workspace: ${workspaceId}`);
                 const sessionLink = session.session_url
@@ -452,7 +426,6 @@ export function createAgentTestCommand() {
             console.error('Failed to start test session. Troubleshooting:');
             console.error('  - Verify the agent exists: guild agent get');
             console.error('  - Check your workspace: guild workspace list');
-            console.error('  - Test unsaved changes: guild agent test --ephemeral');
             if (formattedError.code) {
                 console.error(`  - Error code: ${formattedError.code}`);
             }

package/dist/commands/chat.d.ts

@@ -17,8 +17,9 @@ export interface ChatAppProps {
     resumeEvents?: SessionEvent[];
     resumeCommand?: string;
     openDashboard?: boolean;
+    eventFilter?: Set<string>;
 }
-export declare function ChatApp({ initialPrompt, version, workspaceId, versionId, agentName, showSplash, resumeSession, resumeEvents, resumeCommand, openDashboard, }: ChatAppProps): React.JSX.Element;
+export declare function ChatApp({ initialPrompt, version, workspaceId, versionId, agentName, showSplash, resumeSession, resumeEvents, resumeCommand, openDashboard, eventFilter, }: ChatAppProps): React.JSX.Element;
 export declare function ensureAuthenticated(): Promise<string>;
 export declare function createSession(client: GuildAPIClient, workspaceId: string | undefined, initialPrompt: string, versionId?: string, onProgress?: (status: string) => void): Promise<Session>;
 export declare function createChatCommand(): Command;

package/dist/commands/chat.js

@@ -15,6 +15,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, matchesAgent, 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...');
@@ -1075,7 +1163,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/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