@guildai/cli 0.8.1 → 0.9.1

package/dist/commands/agent/chat.d.ts

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
 export declare function createAgentChatCommand(): Command;
+export declare function handleAgentChatAction(_promptArgs: string[], _options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=chat.d.ts.map

package/dist/commands/agent/chat.js

@@ -19,6 +19,7 @@ import * as readline from 'readline';
 import { pollForResponse } from '../../lib/session-polling.js';
 import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
+import { getWorkspaceId, getWorkspaceSourceLabel } from '../../lib/guild-config.js';
 // ESM equivalent of __dirname
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Read version from package.json
@@ -103,9 +104,26 @@ export function createAgentChatCommand() {
                 const sessionPrompt = options.mode === 'json' && inputData
                     ? JSON.stringify(inputData)
                     : initialPrompt;
-                const session = await createSession(client, options.workspace, sessionPrompt, version.id);
+                // Pre-resolve workspace so we can show the source label in output.
+                // When --workspace is given explicitly, no source label is shown.
+                let resolvedWorkspaceId = options.workspace;
+                let workspaceSourceLabel;
+                if (!resolvedWorkspaceId) {
+                    const wsResolved = await getWorkspaceId(resolvedPath);
+                    resolvedWorkspaceId = wsResolved?.workspaceId;
+                    workspaceSourceLabel = wsResolved
+                        ? getWorkspaceSourceLabel(wsResolved.source)
+                        : undefined;
+                }
+                const session = await createSession(client, resolvedWorkspaceId, sessionPrompt, version.id);
                 if (!quiet) {
                     console.log(`✓ Agent: ${config?.name || agentId}`);
+                    if (session.workspace_id) {
+                        const workspaceDisplay = workspaceSourceLabel
+                            ? `${session.workspace_id} (from ${workspaceSourceLabel})`
+                            : session.workspace_id;
+                        console.log(`✓ Workspace: ${workspaceDisplay}`);
+                    }
                     const sessionLink = session.session_url
                         ? hyperlink(session.id, session.session_url)
                         : session.id;
@@ -252,4 +270,9 @@ export function createAgentChatCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleAgentChatAction(_promptArgs, _options) {
+    const cmd = createAgentChatCommand();
+    await cmd.parseAsync(process.argv.slice(3), { from: 'user' });
+}
 //# sourceMappingURL=chat.js.map

package/dist/commands/agent/init.js

@@ -1,7 +1,6 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
 import { Command } from 'commander';
-import inquirer from 'inquirer';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { createSteps, createSpinner, format } from '../../lib/progress.js';
@@ -61,6 +60,7 @@ async function promptForName(defaultName) {
     return ask();
 }
 async function promptForTemplate() {
+    const { default: inquirer } = await import('inquirer');
     const { template } = await inquirer.prompt([
         {
             type: 'list',

package/dist/commands/agent/test.d.ts

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
 export declare function createAgentTestCommand(): Command;
+export declare function handleAgentTestAction(_options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=test.d.ts.map

package/dist/commands/agent/test.js

@@ -12,14 +12,14 @@ import { hyperlink } from '../../lib/colors.js';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { format } from '../../lib/progress.js';
-import * as readline from 'readline';
 import { parseEventFilter } from '../../lib/event-filter.js';
 import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
 import { pollForResponse, pollForResponseWithEvents, } from '../../lib/session-polling.js';
-import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
-import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
+import { readStdinAsJSON, readStdinAsText, ensureInteractiveStdin, } from '../../lib/stdin.js';
+import { loadLocalConfig, getWorkspaceId, getWorkspaceSourceLabel, } from '../../lib/guild-config.js';
 import { GitError, formatGitError } from '../../lib/git.js';
 import { readAgentFiles, buildEphemeralVersion, buildBundledVersion, BundleNotFoundError, BuildTimeoutError, BuildFailedError, } from '../../lib/agent-helpers.js';
+import { validateInputSchema } from '../../lib/validate-input-schema.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
 import { ChatApp, ensureAuthenticated } from '../chat.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
@@ -83,9 +83,10 @@ export function createAgentTestCommand() {
                 console.error('  guild agent clone <agent-id>');
                 process.exit(1);
             }
-            // 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
+            // If using JSON/JSONL input, read and validate it early (before auth/session creation)
+            // This provides better UX - fail fast on bad input without needing auth
             let inputData;
+            let jsonlInputs;
             if (options.mode === 'json') {
                 try {
                     inputData = await readStdinAsJSON();
@@ -100,6 +101,57 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
+            else if (options.mode === 'jsonl') {
+                try {
+                    const stdinContent = await readStdinAsText();
+                    jsonlInputs = [];
+                    const lines = stdinContent.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        try {
+                            jsonlInputs.push(JSON.parse(line));
+                        }
+                        catch {
+                            console.error(`Error: Invalid JSON on line ${i + 1}`);
+                            console.error('');
+                            console.error('Each line must be valid JSON.');
+                            console.error('  cat inputs.jsonl | guild agent test --mode jsonl');
+                            process.exit(1);
+                        }
+                    }
+                    if (jsonlInputs.length === 0) {
+                        console.error('Error: No JSON input provided');
+                        console.error('');
+                        console.error('Example usage:');
+                        console.error('  cat inputs.jsonl | guild agent test --mode jsonl');
+                        process.exit(1);
+                    }
+                }
+                catch (error) {
+                    const err = error;
+                    console.error(`Error: ${err.message}`);
+                    process.exit(1);
+                }
+            }
+            // Validate input against agent's schema locally (before build)
+            // Skip when --agent-version is set since local source may differ from that version
+            const inputsToValidate = inputData !== undefined ? [inputData] : (jsonlInputs ?? []);
+            if (inputsToValidate.length > 0 && !options.agentVersion) {
+                const validationResult = await validateInputSchema(cwd, inputsToValidate);
+                if (!validationResult.valid) {
+                    console.error('Input validation failed:');
+                    for (const err of validationResult.errors) {
+                        const pathStr = err.path?.length ? ` (at ${err.path.join('.')})` : '';
+                        console.error(`  - ${err.message}${pathStr}`);
+                    }
+                    process.exit(1);
+                }
+                if ('skipped' in validationResult && validationResult.skipped) {
+                    format.warn(`Skipping local validation: ${validationResult.reason}`);
+                }
+            }
             // If using bundle, verify the file exists early (before auth/session creation)
             // so we fail fast without needing auth if the path is wrong.
             if (options.bundle) {
@@ -117,9 +169,13 @@ export function createAgentTestCommand() {
             }
             // Determine workspace (priority: flag > local config > global config)
             let workspaceId = options.workspace;
+            let workspaceSourceLabel;
             if (!workspaceId) {
                 const resolved = await getWorkspaceId(cwd);
                 workspaceId = resolved?.workspaceId;
+                workspaceSourceLabel = resolved
+                    ? getWorkspaceSourceLabel(resolved.source)
+                    : undefined;
                 if (!workspaceId) {
                     console.error('Error: No default workspace configured');
                     console.error('');
@@ -251,7 +307,10 @@ export function createAgentTestCommand() {
                             ? 'ephemeral (cached, no changes)'
                             : 'ephemeral (working directory)';
                 console.log(`✓ Version: ${versionDisplay}`);
-                console.log(`✓ Workspace: ${workspaceId}`);
+                const workspaceDisplay = workspaceSourceLabel
+                    ? `${workspaceId} (from ${workspaceSourceLabel})`
+                    : workspaceId;
+                console.log(`✓ Workspace: ${workspaceDisplay}`);
                 const sessionLink = session.session_url
                     ? hyperlink(session.id, session.session_url)
                     : session.id;
@@ -325,25 +384,16 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
-            else if (options.mode === 'jsonl') {
-                // JSONL input mode: line-by-line processing
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                    terminal: false,
-                });
-                let lineNumber = 0;
+            else if (options.mode === 'jsonl' && jsonlInputs) {
+                // JSONL input mode: line-by-line processing (inputs already parsed and validated)
                 let processedCount = 0;
                 let lastEventId;
-                for await (const line of rl) {
-                    lineNumber++;
-                    if (!line.trim())
-                        continue; // Skip empty lines
+                for (let inputIndex = 0; inputIndex < jsonlInputs.length; inputIndex++) {
+                    const jsonInput = jsonlInputs[inputIndex];
+                    if (!quiet) {
+                        console.error(`Processing input ${inputIndex + 1}/${jsonlInputs.length}...`);
+                    }
                     try {
-                        const jsonInput = JSON.parse(line);
-                        if (!quiet) {
-                            console.error(`Processing line ${lineNumber}...`);
-                        }
                         // Send message
                         await client.post(`/sessions/${session.id}/events`, {
                             mode: 'json',
@@ -355,13 +405,12 @@ export function createAgentTestCommand() {
                             : await pollForResponse(client, session.id, lastEventId, 180000);
                         lastEventId = result.lastEventId;
                         if (!result.response) {
-                            console.error(`Timeout: No response for line ${lineNumber}`);
+                            console.error(`Timeout: No response for input ${inputIndex + 1}`);
                             continue;
                         }
                         const response = result.response;
                         // Output response
                         if (quiet) {
-                            // In quiet mode, output just the message content (or as JSON if --json is used)
                             console.log(response);
                         }
                         else {
@@ -371,10 +420,8 @@ export function createAgentTestCommand() {
                         processedCount++;
                     }
                     catch (error) {
-                        const err = error;
-                        console.error(`Error: Invalid JSON on line ${lineNumber}`);
-                        console.error(`Failed to parse JSON: ${err.message}`);
-                        console.error('Skipping line and continuing...');
+                        const formattedErr = handleAxiosError(error);
+                        console.error(`Error processing input ${inputIndex + 1}: ${formattedErr.details}`);
                     }
                 }
                 if (!quiet) {
@@ -431,4 +478,9 @@ export function createAgentTestCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleAgentTestAction(_options) {
+    const cmd = createAgentTestCommand();
+    await cmd.parseAsync(process.argv.slice(3), { from: 'user' });
+}
 //# sourceMappingURL=test.js.map

package/dist/commands/chat.d.ts

@@ -23,4 +23,5 @@ export declare function ChatApp({ initialPrompt, version, workspaceId, versionId
 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;
+export declare function handleChatAction(_promptArgs: string[], _options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=chat.d.ts.map

package/dist/commands/chat.js

@@ -13,12 +13,12 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, } from '../lib/session-events.js';
+import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } 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';
+import { getWorkspaceId, getWorkspaceSourceLabel } from '../lib/guild-config.js';
 import { ensureInteractiveStdin } from '../lib/stdin.js';
 import { brand, BRAND_COLOR, code as codeColor, hyperlink } from '../lib/colors.js';
 import { SplashAnimation } from '../components/SplashAnimation.js';
@@ -48,6 +48,48 @@ function fixListItemMarkdown(text) {
     text = text.replace(/(?<![\\w])_([^_]+)_(?![\\w])/g, (_, content) => chalk.italic(content));
     return text;
 }
+function extractMessageText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
+        return text;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
+            return typeof parsed.message === 'string' ? parsed.message : text;
+        }
+    }
+    catch {
+        // If parsing fails, use the content as-is.
+    }
+    return text;
+}
+function extractRuntimeDoneText(content) {
+    if (content === null || content === undefined)
+        return null;
+    if (typeof content === 'string')
+        return content.trim() ? content : null;
+    if (typeof content !== 'object' || Array.isArray(content)) {
+        return JSON.stringify(content);
+    }
+    const record = content;
+    if (Object.keys(record).length === 0)
+        return null;
+    if (record.type === 'text') {
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.data === 'string')
+            return record.data;
+    }
+    if (typeof record.message === 'string')
+        return record.message;
+    // runtime_done content is agent output, not notification content. Preserve
+    // structured outputs rather than trying to render notification-only shapes.
+    return JSON.stringify(content);
+}
+function renderAssistantMessage(text, taskName) {
+    const rendered = fixListItemMarkdown(marked.parse(text));
+    return `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+}
 /**
  * Output the result of a --once mode session.
  * Handles both JSON and human-readable output formats.
@@ -57,21 +99,29 @@ async function outputOnceResult(sessionId, events, mode) {
         console.log(JSON.stringify({ session_id: sessionId, events }, null, 2));
     }
     else {
-        const agentMessages = events.filter((e) => e.type === 'agent_notification_message');
-        if (agentMessages.length > 0) {
-            let messageContent = agentMessages[agentMessages.length - 1].content.data;
-            const trimmed = messageContent.trim();
-            if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
-                        messageContent = parsed.message;
-                    }
-                }
-                catch {
-                    // If parsing fails, use content as-is
-                }
+        const finalAgentMessages = events.filter((e) => e.type === 'agent_notification_message' &&
+            isRootTaskEvent(e) &&
+            !isResponseStreamEvent(e));
+        const streamFallbacks = events.filter((e) => e.type === 'agent_notification_message' &&
+            isRootTaskEvent(e) &&
+            isDoneResponseStreamEvent(e));
+        if (finalAgentMessages.length > 0) {
+            const messageContent = extractMessageText(getAgentNotificationText(finalAgentMessages[finalAgentMessages.length - 1]));
+            const rendered = fixListItemMarkdown(await marked(messageContent));
+            console.log(rendered.trim());
+            return;
+        }
+        const runtimeDoneEvents = events.filter((e) => e.type === 'runtime_done' && isRootTaskEvent(e) && e.content);
+        const runtimeDoneWithContent = runtimeDoneEvents[runtimeDoneEvents.length - 1];
+        if (runtimeDoneWithContent?.type === 'runtime_done') {
+            const runtimeDoneText = extractRuntimeDoneText(runtimeDoneWithContent.content);
+            if (runtimeDoneText) {
+                console.log(runtimeDoneText);
+                return;
             }
+        }
+        if (streamFallbacks.length > 0) {
+            const messageContent = extractMessageText(getAgentNotificationText(streamFallbacks[streamFallbacks.length - 1]));
             const rendered = fixListItemMarkdown(await marked(messageContent));
             console.log(rendered.trim());
         }
@@ -427,6 +477,83 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
     const isPolling = useRef(false);
     const receivedResponseSinceLastInput = useRef(false);
     const firstMessageNotified = useRef(!!resumeEvents);
+    const responseStreamKeys = useRef(new Map());
+    const responseStreamTimestamps = useRef(new Map());
+    const responseStreamKeysByTask = useRef(new Map());
+    const clearResponseStreamsForTask = (taskId) => {
+        if (!taskId)
+            return;
+        const keys = responseStreamKeysByTask.current.get(taskId);
+        if (!keys?.size)
+            return;
+        for (const [streamId, key] of responseStreamKeys.current.entries()) {
+            if (keys.has(key)) {
+                responseStreamKeys.current.delete(streamId);
+                responseStreamTimestamps.current.delete(streamId);
+            }
+        }
+        responseStreamKeysByTask.current.delete(taskId);
+        setMessages((prev) => prev.filter((message) => !keys.has(message.key)));
+    };
+    const upsertResponseStreamMessage = (event) => {
+        if (!isResponseStreamEvent(event))
+            return;
+        if (!isRootTaskEvent(event))
+            return;
+        const streamId = event.content.stream_id;
+        const taskId = event.task?.id;
+        const existingKey = responseStreamKeys.current.get(streamId);
+        if (event.content.status === 'aborted') {
+            if (existingKey) {
+                responseStreamKeys.current.delete(streamId);
+                responseStreamTimestamps.current.delete(streamId);
+                if (taskId) {
+                    const keys = responseStreamKeysByTask.current.get(taskId);
+                    keys?.delete(existingKey);
+                    if (keys?.size === 0)
+                        responseStreamKeysByTask.current.delete(taskId);
+                }
+                setMessages((prev) => prev.filter((message) => message.key !== existingKey));
+            }
+            return;
+        }
+        const text = event.content.text;
+        if (!text.trim())
+            return;
+        const key = existingKey ?? `response-stream-${streamId}`;
+        responseStreamKeys.current.set(streamId, key);
+        if (taskId) {
+            const keys = responseStreamKeysByTask.current.get(taskId) ?? new Set();
+            keys.add(key);
+            responseStreamKeysByTask.current.set(taskId, keys);
+        }
+        const taskName = agentName || 'assistant';
+        const messageContent = renderAssistantMessage(text, taskName);
+        const timestamp = responseStreamTimestamps.current.get(streamId) ?? new Date().toLocaleTimeString();
+        responseStreamTimestamps.current.set(streamId, timestamp);
+        setMessages((prev) => {
+            const index = prev.findIndex((message) => message.key === key);
+            const message = {
+                key,
+                content: messageContent,
+                type: 'assistant',
+                timestamp,
+            };
+            if (index === -1)
+                return [...prev, message];
+            const next = [...prev];
+            next[index] = message;
+            return next;
+        });
+        if (!firstMessageNotified.current && onFirstMessage) {
+            firstMessageNotified.current = true;
+            onFirstMessage();
+        }
+        if (event.content.status === 'done') {
+            receivedResponseSinceLastInput.current = true;
+            setCurrentOperation('');
+        }
+    };
     // Mark initial prompt as sent (skip for resume — we already have the events)
     useEffect(() => {
         if (!resumeEvents) {
@@ -526,6 +653,7 @@ 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') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // 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)
@@ -639,32 +767,15 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             }
                         }
                         else if (event.type === 'agent_notification_message') {
-                            let text = typeof event.content === 'string'
-                                ? event.content
-                                : event.content?.data || '';
-                            // Extract message content, handling JSON responses with "message" field
-                            const trimmed = text.trim();
-                            if (trimmed) {
-                                // Check if content looks like JSON object with "message" field
-                                if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                                    try {
-                                        const parsed = JSON.parse(trimmed);
-                                        // If JSON has a "message" field, extract it (some agents wrap responses this way)
-                                        if (typeof parsed === 'object' &&
-                                            parsed !== null &&
-                                            'message' in parsed) {
-                                            text = parsed.message;
-                                        }
-                                        // Otherwise use full JSON content as-is (legitimate JSON responses)
-                                    }
-                                    catch {
-                                        // If parsing fails, use the content as-is
-                                    }
-                                }
-                                const rendered = fixListItemMarkdown(marked.parse(text));
-                                // Add attribution with task name
+                            if (isResponseStreamEvent(event)) {
+                                upsertResponseStreamMessage(event);
+                                continue;
+                            }
+                            const text = extractMessageText(getAgentNotificationText(event));
+                            if (text.trim()) {
+                                clearResponseStreamsForTask(taskInfo?.id);
                                 const taskName = agentName || 'assistant';
-                                const messageContent = `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+                                const messageContent = renderAssistantMessage(text, taskName);
                                 setMessages((prev) => [
                                     ...prev,
                                     {
@@ -684,6 +795,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             setCurrentOperation('');
                         }
                         else if (event.type === 'agent_notification_error') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // Show error in chat (task status is updated via tasks poll)
                             const errorText = typeof event.content === 'string'
                                 ? event.content
@@ -730,6 +842,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                                 event.content !== undefined &&
                                 taskInfo &&
                                 'agent' in taskInfo) {
+                                clearResponseStreamsForTask(taskInfo.id);
                                 // 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.
@@ -759,6 +872,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             }
                         }
                         else if (event.type === 'interrupted') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // Session was interrupted — interrupted sessions are terminal on the backend
                             setMessages((prev) => [
                                 ...prev,
@@ -987,6 +1101,10 @@ export async function createSession(client, workspaceId, initialPrompt, versionI
         const resolved = await getWorkspaceId();
         if (resolved) {
             workspaceId = resolved.workspaceId;
+            const sourceLabel = getWorkspaceSourceLabel(resolved.source);
+            if (sourceLabel) {
+                progress(`Using workspace from ${sourceLabel}`);
+            }
         }
     }
     if (!workspaceId) {
@@ -1045,7 +1163,9 @@ export function createChatCommand() {
             try {
                 await ensureAuthenticated();
                 const client = new GuildAPIClient();
-                const session = await createSession(client, options.workspace, initialPrompt, options.agent);
+                const session = await createSession(client, options.workspace, initialPrompt, options.agent, (status) => {
+                    spinner.text = status;
+                });
                 spinner.succeed('Connected');
                 if (session.session_url) {
                     const sessionLink = hyperlink(session.id, session.session_url);
@@ -1084,12 +1204,18 @@ export function createChatCommand() {
                     else {
                         inactivityCounter++;
                     }
-                    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 if we got a completion response from the root agent.
+                    // Stream done events are only a rendering fallback; wait for the
+                    // final root message or runtime completion so child drafts cannot
+                    // terminate --once early.
+                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTaskEvent(e));
+                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
+                        isRootTaskEvent(e) &&
+                        !isResponseStreamEvent(e));
+                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTaskEvent(e));
                     // Check for a ui_prompt request... that ends the game.
                     const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
+                        !isResponseStreamEvent(e) &&
                         e.task?.tool_name === 'ui_prompt');
                     if (hasRootTaskError) {
                         debug('Found error event from root agent, exiting --once mode');
@@ -1177,4 +1303,10 @@ export function createChatCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleChatAction(_promptArgs, _options) {
+    const cmd = createChatCommand();
+    // Re-parse the original argv so the command's own action handler runs
+    await cmd.parseAsync(process.argv.slice(2), { from: 'user' });
+}
 //# sourceMappingURL=chat.js.map

package/dist/commands/integration/connect.js

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Command } from 'commander';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
@@ -40,6 +39,7 @@ export function createIntegrationConnectCommand() {
             }
             let apiKey = options.token;
             if (!apiKey) {
+                const { default: inquirer } = await import('inquirer');
                 const answer = await inquirer.prompt([
                     {
                         type: 'password',