@guildai/cli 0.6.1 → 0.7.0

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)
@@ -485,9 +487,9 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                 isPollingTasks.current = false;
             }
         };
-        // Poll immediately and then every second (like web)
+        // Poll immediately and then every 2 seconds
         pollTasks();
-        const interval = setInterval(pollTasks, 1000);
+        const interval = setInterval(pollTasks, 2000);
         return () => {
             clearInterval(interval);
         };
@@ -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') {
@@ -684,7 +790,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                 isPolling.current = false;
             }
         };
-        pollInterval.current = setInterval(poll, 500);
+        pollInterval.current = setInterval(poll, 2000);
         poll();
         return () => {
             if (pollInterval.current) {
@@ -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...');
@@ -972,7 +1060,7 @@ export function createChatCommand() {
                 // Timeout after 5 minutes of INACTIVITY (no new messages)
                 // Agent initialization can take 1-2 minutes with no events
                 const inactivityTimeoutMs = 300000; // 5 minutes
-                const pollIntervalMs = 500;
+                const pollIntervalMs = 2000;
                 const maxInactivityAttempts = inactivityTimeoutMs / pollIntervalMs;
                 let lastSeenEventId;
                 const allEvents = [];
@@ -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

package/dist/commands/setup.js

@@ -11,7 +11,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageRoot = path.resolve(__dirname, '..', '..');
 const docsDir = path.join(packageRoot, 'docs');
-const SKILL_FILES = [
+const CLAUDE_SKILL_FILES = [
     {
         src: path.join(docsDir, 'skills', 'agent-dev.md'),
         dest: path.join('.claude', 'skills', 'agent-dev', 'skill.md'),
@@ -22,6 +22,18 @@ const SKILL_FILES = [
         dest: path.join('.claude', 'skills', 'guild-cli-workflow', 'skill.md'),
         label: '.claude/skills/guild-cli-workflow/skill.md',
     },
+    {
+        src: path.join(docsDir, 'skills', 'integrations.md'),
+        dest: path.join('.claude', 'skills', 'integrations', 'skill.md'),
+        label: '.claude/skills/integrations/skill.md',
+    },
+];
+const CODEX_SKILL_FILES = [
+    {
+        src: path.join(docsDir, 'skills', 'codex-agent-dev.md'),
+        dest: path.join('.agents', 'skills', 'guild-agent-dev', 'SKILL.md'),
+        label: '.agents/skills/guild-agent-dev/SKILL.md',
+    },
 ];
 const CLAUDE_MD_TEMPLATE = `# CLAUDE.md
 
@@ -38,6 +50,22 @@ guild agent save --message "Initial version" --wait --publish
 
 See \`.claude/skills/agent-dev/skill.md\` for SDK reference, patterns, and anti-hallucination guide.
 `;
+const AGENTS_MD_TEMPLATE = `# AGENTS.md
+
+## Guild Agent Development
+
+This project uses Guild for agent development. Codex instructions are installed in \`.agents/skills/guild-agent-dev/SKILL.md\`.
+
+### Quick Start
+
+\`\`\`bash
+guild agent init --name my-agent --template LLM
+guild agent test --ephemeral
+guild agent save -A --message "Initial version"
+\`\`\`
+
+Use \`guild doctor\` to check authentication, server connectivity, workspace selection, and git setup.
+`;
 async function fileExists(filePath) {
     try {
         await fs.access(filePath);
@@ -82,21 +110,29 @@ async function setupMcp(options) {
 }
 async function setup(options) {
     const output = createOutputWriter();
-    // Verify source docs exist
-    const docsExist = await fileExists(path.join(docsDir, 'skills', 'agent-dev.md'));
-    if (!docsExist) {
-        output.error('Could not find Guild CLI docs. Reinstall the CLI: npm install -g @guildai/cli');
+    if (options.agentsMd && !options.codex) {
+        output.error('--agents-md requires --codex', 'Create Codex setup files with:\n  guild setup --codex --agents-md');
+        process.exit(1);
+    }
+    if (options.claudeMd && options.codex) {
+        output.error('--claude-md cannot be used with --codex', 'Create Claude setup with:\n  guild setup --claude-md\n\nCreate Codex setup with:\n  guild setup --codex --agents-md');
         process.exit(1);
     }
+    const skillFiles = options.codex ? CODEX_SKILL_FILES : CLAUDE_SKILL_FILES;
+    // Verify source docs exist
+    for (const file of skillFiles) {
+        if (!(await fileExists(file.src))) {
+            output.error('Could not find Guild CLI docs. Reinstall the CLI: npm install -g @guildai/cli');
+            process.exit(1);
+        }
+    }
     output.progress('Setting up Guild CLI skills...');
     output.progress('');
-    // Ensure .claude/skills/ directory exists
-    const skillsDir = path.join(process.cwd(), '.claude', 'skills');
-    await fs.mkdir(skillsDir, { recursive: true });
     let filesCreated = 0;
     let filesSkipped = 0;
+    let codexProjectFilesChanged = false;
     // Copy skill files
-    for (const file of SKILL_FILES) {
+    for (const file of skillFiles) {
         const destPath = path.join(process.cwd(), file.dest);
         const exists = await fileExists(destPath);
         if (exists && !options.force) {
@@ -113,6 +149,9 @@ async function setup(options) {
                 output.success(`Created ${file.label}`);
             }
             filesCreated++;
+            if (options.codex) {
+                codexProjectFilesChanged = true;
+            }
         }
     }
     // Handle --mcp flag
@@ -139,6 +178,21 @@ async function setup(options) {
             filesCreated++;
         }
     }
+    // Handle AGENTS.md template for Codex setup
+    if (options.agentsMd) {
+        const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
+        const exists = await fileExists(agentsMdPath);
+        if (exists) {
+            output.progress('AGENTS.md already exists (not overwriting)');
+            filesSkipped++;
+        }
+        else {
+            await fs.writeFile(agentsMdPath, AGENTS_MD_TEMPLATE, 'utf-8');
+            output.success('Created AGENTS.md');
+            filesCreated++;
+            codexProjectFilesChanged = true;
+        }
+    }
     // Summary
     output.progress('');
     if (filesCreated > 0 && filesSkipped === 0) {
@@ -155,13 +209,18 @@ async function setup(options) {
     else {
         output.success('Guild CLI skills installed.');
     }
+    if (codexProjectFilesChanged) {
+        output.progress('Restart Codex to pick up the new project instructions.');
+    }
 }
 export function createSetupCommand() {
     const cmd = new Command('setup');
     cmd
-        .description('Set up Guild CLI skills for coding assistants (Claude Code, etc.)')
-        .option('--force', 'Overwrite existing skill files', false)
+        .description('Set up Guild CLI skills for coding assistants (Claude Code, Codex, etc.)')
+        .option('--force', 'Overwrite existing skill files and Guild MCP config', false)
+        .option('--codex', 'Install Codex skill files instead of Claude Code skills', false)
         .option('--claude-md', 'Also create a CLAUDE.md template in the project root', false)
+        .option('--agents-md', 'With --codex, also create an AGENTS.md template in the project root', false)
         .option('--no-mcp', 'Skip MCP server configuration')
         .action(async (options) => {
         await setup(options);

package/dist/index.js

@@ -59,6 +59,7 @@ 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 { createSessionInterruptCommand } from './commands/session/interrupt.js';
 import { createJobGetCommand } from './commands/job/get.js';
 import { createJobStepGetCommand } from './commands/job/step-get.js';
 import { createConfigListCommand } from './commands/config/list.js';
@@ -276,6 +277,7 @@ sessionCmd.addCommand(createSessionEventsCommand());
 sessionCmd.addCommand(createSessionTasksCommand());
 sessionCmd.addCommand(createSessionCreateCommand());
 sessionCmd.addCommand(createSessionSendCommand());
+sessionCmd.addCommand(createSessionInterruptCommand());
 // Job command group
 const jobCmd = program.command('job').description('Job management');
 jobCmd.addCommand(createJobGetCommand());

package/dist/lib/event-filter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Event type filtering for the CLI `--events` flag.
+ *
+ * Mirrors the web UI's "Filter by type" modal, which groups event types into
+ * two categories: user-facing events (on by default) and system/debug events
+ * (off by default).
+ *
+ * The canonical event type list is generated from the backend EventType enum
+ * (see generated-types.ts). The user/system grouping is a UI concern defined
+ * here and in www/src/components/EventTypeFilters/types.ts.
+ */
+import type { EventType } from './generated-types.js';
+/**
+ * User-facing event types — shown by default (mirrors web UI defaults).
+ */
+export declare const USER_EVENT_TYPES: readonly EventType[];
+/**
+ * System / debug event types — hidden by default (mirrors web UI defaults).
+ */
+export declare const SYSTEM_EVENT_TYPES: readonly EventType[];
+/**
+ * Default active filter: all user-facing types, no system types.
+ */
+export declare const DEFAULT_EVENT_TYPES: Set<string>;
+/**
+ * Parse the value of the `--events` flag into a Set of event type names.
+ *
+ * Whatever you pass replaces the defaults entirely:
+ *  - `none`   → empty set (no event types shown)
+ *  - `user`   → all USER_EVENT_TYPES (same as default)
+ *  - `system` → only SYSTEM_EVENT_TYPES
+ *  - `all`    → both USER_EVENT_TYPES + SYSTEM_EVENT_TYPES
+ *
+ * Comma-separated for fine-grained control:
+ *  - `agent_console,llm_start` → only those two types
+ *  - `user,system` → same as `all`
+ */
+export declare function parseEventFilter(raw: string): Set<string>;
+/**
+ * Check whether an event should be shown given the active filter.
+ *
+ * Returns `true` when the event type is in the filter set.
+ *
+ * Note: certain event types (e.g. `agent_notification_progress`,
+ * `agent_notification_message`) drive core UI state (spinner, chat history)
+ * and are always processed regardless of the filter; only their *display* is
+ * gated here for new/optional event types.
+ */
+export declare function shouldShowEvent(type: string, filter: Set<string>): boolean;
+//# sourceMappingURL=event-filter.d.ts.map