@guildai/cli 0.10.0 → 0.11.0

package/dist/lib/output-mode.js

@@ -4,21 +4,42 @@
  * Output mode detection for the CLI
  *
  * Interactive mode (default): Colors, tables, spinners, interactive
- * JSON mode (--json): Pure JSON, non-interactive, machine-readable
+ * JSON mode (--mode json or --json): Pure JSON, non-interactive, machine-readable
+ * JSONL mode (--mode jsonl): Line-delimited JSON for streaming
  */
 import { getConfigFlag } from './config-cache.js';
 /**
  * Detect output mode from CLI flags or config
  *
- * Checks --json flag and config. CLI flag overrides config.
+ * Priority: --mode <value> > --json (backward compat) > config
  * Does NOT auto-detect pipes (user must request JSON explicitly).
  */
 export function getOutputMode() {
+    // Check --mode <value> first (primary flag)
+    const modeIndex = process.argv.indexOf('--mode');
+    if (modeIndex !== -1 && modeIndex + 1 < process.argv.length) {
+        const value = process.argv[modeIndex + 1];
+        if (value === 'json' || value === 'jsonl') {
+            return value;
+        }
+        // --mode interactive falls through to default
+    }
+    // Backward compat: --json is equivalent to --mode json
     if (process.argv.includes('--json') || getConfigFlag('json')) {
         return 'json';
     }
     return 'interactive';
 }
+/**
+ * Check if the current output mode is machine-readable (json or jsonl).
+ *
+ * Use this in list/get commands instead of `getOutputMode() === 'json'`
+ * so that both --mode json and --mode jsonl trigger non-interactive output.
+ */
+export function isMachineReadable() {
+    const mode = getOutputMode();
+    return mode === 'json' || mode === 'jsonl';
+}
 /**
  * Check if quiet mode is enabled (CLI flag or config)
  *

package/dist/lib/output.d.ts

@@ -1,5 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Task, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Task, ValidationStep, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
@@ -57,6 +57,12 @@ export declare function formatPoliciesTable(policies: CredentialsPolicy[], pagin
  * Used by job get command.
  */
 export declare function formatJobStepTable(steps: JobStep[]): void;
+/**
+ * Format validation step logs as human-readable output.
+ * Prints each step's name, colored status, and full log content.
+ * Used by the `guild agent logs` command.
+ */
+export declare function formatValidationLogs(steps: ValidationStep[]): void;
 /**
  * Output writer interface for consistent CLI output
  *

package/dist/lib/output.js

@@ -506,6 +506,35 @@ export function formatJobStepTable(steps) {
     });
     table.printTable();
 }
+/**
+ * Format validation step logs as human-readable output.
+ * Prints each step's name, colored status, and full log content.
+ * Used by the `guild agent logs` command.
+ */
+export function formatValidationLogs(steps) {
+    if (steps.length === 0) {
+        console.log(chalk.dim('No steps found'));
+        return;
+    }
+    const hr = chalk.dim('─'.repeat(60));
+    steps.forEach((step, index) => {
+        if (index > 0) {
+            console.log(hr);
+        }
+        const statusColor = step.status === 'SUCCEEDED'
+            ? chalk.green
+            : step.status === 'FAILED' || step.status === 'ERRORED'
+                ? chalk.red
+                : step.status === 'RUNNING'
+                    ? chalk.yellow
+                    : chalk.dim;
+        console.log(`${chalk.bold(step.name)}  ${statusColor(step.status)}`);
+        if (step.content) {
+            console.log();
+            console.log(step.content);
+        }
+    });
+}
 /**
  * Human-friendly output writer
  *
@@ -573,7 +602,9 @@ export class JSONOutputWriter {
  */
 export function createOutputWriter() {
     const mode = getOutputMode();
-    return mode === 'json' ? new JSONOutputWriter() : new InteractiveOutputWriter();
+    return mode === 'interactive'
+        ? new InteractiveOutputWriter()
+        : new JSONOutputWriter();
 }
 /**
  * Create a no-op spinner (for quiet/JSON modes)

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

@@ -97,14 +97,23 @@ export interface TextContent {
     type: 'text';
     data: string;
 }
+export interface UnknownContent {
+    type: string;
+    data?: unknown;
+}
+export interface MultipartContent {
+    type: 'multipart/mixed';
+    parts: UnknownContent[];
+}
 export interface ResponseStreamContent {
     type: 'application/guild-response-stream';
     stream_id: string;
     sequence: number;
-    status: 'streaming' | 'done' | 'aborted';
+    status: 'streaming' | 'done' | 'continued' | 'aborted';
     text: string;
+    is_delta?: boolean;
 }
-export type AgentNotificationMessageContent = TextContent | ResponseStreamContent;
+export type AgentNotificationMessageContent = TextContent | MultipartContent | ResponseStreamContent;
 export interface AgentNotificationMessageEvent extends BaseEvent {
     type: 'agent_notification_message';
     content: AgentNotificationMessageContent;
@@ -181,6 +190,8 @@ export declare function isDoneResponseStreamEvent(event: SessionEvent): event is
         status: 'done';
     };
 };
+/** Apply a response-stream payload to the accumulated display text. */
+export declare function applyResponseStreamText(currentText: string, content: ResponseStreamContent): string;
 /** Extract display text from notification content. */
 export declare function getAgentNotificationText(event: AgentNotificationMessageEvent): string;
 /** Check if an event belongs to the root task or has no task context. */

package/dist/lib/session-events.js

@@ -96,9 +96,23 @@ export function isResponseStreamEvent(event) {
 export function isDoneResponseStreamEvent(event) {
     return isResponseStreamEvent(event) && event.content.status === 'done';
 }
+/** Apply a response-stream payload to the accumulated display text. */
+export function applyResponseStreamText(currentText, content) {
+    return content.is_delta ? currentText + content.text : content.text;
+}
 /** Extract display text from notification content. */
 export function getAgentNotificationText(event) {
-    return event.content.type === 'text' ? event.content.data : event.content.text;
+    if (event.content.type === 'text') {
+        return event.content.data;
+    }
+    if (event.content.type === 'application/guild-response-stream') {
+        return event.content.text;
+    }
+    if (event.content.type === 'multipart/mixed' && event.content.parts.length === 1) {
+        const part = event.content.parts[0];
+        return part.type === 'text' && typeof part.data === 'string' ? part.data : '';
+    }
+    return '';
 }
 /** Check if an event belongs to the root task or has no task context. */
 export function isRootTaskEvent(event) {

package/dist/lib/session-polling.js

@@ -3,7 +3,7 @@
 import { debug, isDebugMode } from './errors.js';
 import { shouldShowEvent } from './event-filter.js';
 import { fetchEvents } from './session-events-fetch.js';
-import { getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
+import { applyResponseStreamText, getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
 /**
  * Poll for agent response using from_id cursor.
  *
@@ -20,6 +20,7 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
     const startTime = Date.now();
     let fromId = afterEventId;
     let responseStreamDone = null;
+    const responseStreamTexts = new Map();
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
@@ -28,9 +29,11 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
             debug(`pollForResponse event: ${event.type}`);
             if (event.type === 'agent_notification_message') {
                 if (isResponseStreamEvent(event)) {
+                    const streamText = applyResponseStreamText(responseStreamTexts.get(event.content.stream_id) ?? '', event.content);
+                    responseStreamTexts.set(event.content.stream_id, streamText);
                     if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
                         responseStreamDone = {
-                            response: getAgentNotificationText(event),
+                            response: streamText,
                             lastEventId: event.id,
                         };
                     }
@@ -91,6 +94,7 @@ export async function pollForResponseWithEvents(client, sessionId, eventFilter,
     const startTime = Date.now();
     let fromId = afterEventId;
     let responseStreamDone = null;
+    const responseStreamTexts = new Map();
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
@@ -105,9 +109,11 @@ export async function pollForResponseWithEvents(client, sessionId, eventFilter,
             }
             if (event.type === 'agent_notification_message') {
                 if (isResponseStreamEvent(event)) {
+                    const streamText = applyResponseStreamText(responseStreamTexts.get(event.content.stream_id) ?? '', event.content);
+                    responseStreamTexts.set(event.content.stream_id, streamText);
                     if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
                         responseStreamDone = {
-                            response: getAgentNotificationText(event),
+                            response: streamText,
                             lastEventId: event.id,
                         };
                     }

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

@@ -1,5 +1,5 @@
 import { GuildAPIClient } from './api-client.js';
-import { SessionEvent, Session } from './session-events.js';
+import { type ResponseStreamContent, SessionEvent, Session } from './session-events.js';
 /**
  * Print a dimmed resume hint to stderr on session exit.
  * Only call when a session ID is available.
@@ -19,6 +19,20 @@ export interface DisplayMessage {
     type: 'user' | 'assistant' | 'progress';
     timestamp?: string;
 }
+export interface ResponseStreamResumeState {
+    keys: Map<string, string>;
+    contents: Map<string, ResponseStreamContent[]>;
+    texts: Map<string, string>;
+    timestamps: Map<string, string>;
+    statuses: Map<string, ResponseStreamContent['status']>;
+    keysByTask: Map<string, Set<string>>;
+}
+export interface SessionResumeDisplay {
+    displayMessages: DisplayMessage[];
+    responseStreamState: ResponseStreamResumeState;
+}
+export declare function responseStreamResumeStateFromEvents(events: SessionEvent[]): ResponseStreamResumeState;
+export declare function prepareSessionResumeDisplay(events: SessionEvent[]): SessionResumeDisplay;
 /**
  * Convert session events to display messages for resume.
  * Maps user_message, agent_notification_message, and agent_notification_error

package/dist/lib/session-resume.js

@@ -7,7 +7,7 @@
 import chalk from 'chalk';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
-import { getAgentNotificationText, isResponseStreamEvent, } from './session-events.js';
+import { applyResponseStreamText, getAgentNotificationText, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
 import { fetchEvents } from './session-events-fetch.js';
 import { brand, code as codeColor } from './colors.js';
 // Configure marked for terminal rendering (same config as chat.tsx)
@@ -48,13 +48,127 @@ export async function fetchSession(client, sessionId) {
     const session = (await client.get(`/sessions/${sessionId}`));
     return session;
 }
-/**
- * Convert session events to display messages for resume.
- * Maps user_message, agent_notification_message, and agent_notification_error
- * to DisplayMessage objects. Skips progress, console, runtime events.
- */
-export function eventsToDisplayMessages(events) {
+function renderAssistantText(key, text, timestamp) {
+    const rendered = renderMarkdown(text);
+    const messageContent = `${chalk.green('●')} ${chalk.bold('assistant')}\n${rendered.trim()}`;
+    return {
+        key,
+        content: messageContent,
+        type: 'assistant',
+        timestamp,
+    };
+}
+function textMatches(left, right) {
+    return left === right;
+}
+function formatDisplayTimestamp(timestamp) {
+    if (timestamp === undefined)
+        return undefined;
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime()))
+        return timestamp;
+    return date.toLocaleTimeString();
+}
+function upsertResponseStreamEvent(events, event) {
+    const existingIndex = events.findIndex((existing) => existing.content.sequence === event.content.sequence);
+    if (existingIndex === -1) {
+        events.push(event);
+    }
+    else {
+        events[existingIndex] = event;
+    }
+}
+function collectResponseStreamResumeEntries(events) {
+    const responseStreamGroups = new Map();
+    const finalMessagesByTask = new Map();
+    for (const [index, event] of events.entries()) {
+        if (event.type !== 'agent_notification_message')
+            continue;
+        if (!isRootTaskEvent(event))
+            continue;
+        if (isResponseStreamEvent(event)) {
+            const streamId = event.content.stream_id;
+            const current = responseStreamGroups.get(streamId);
+            if (current) {
+                upsertResponseStreamEvent(current.events, event);
+                // Insertion order and sequence can diverge if backfilled events arrive out
+                // of order; use insertion index only for "later final message" dedupe.
+                current.lastIndex = Math.max(current.lastIndex, index);
+            }
+            else {
+                responseStreamGroups.set(streamId, {
+                    events: [event],
+                    lastIndex: index,
+                });
+            }
+            continue;
+        }
+        const taskId = event.task?.id;
+        if (!taskId)
+            continue;
+        const text = getAgentNotificationText(event);
+        if (!text.trim())
+            continue;
+        const finalMessages = finalMessagesByTask.get(taskId) ?? [];
+        finalMessages.push({ index, text });
+        finalMessagesByTask.set(taskId, finalMessages);
+    }
+    const entries = [];
+    for (const [streamId, streamGroup] of responseStreamGroups.entries()) {
+        const streamEvents = [...streamGroup.events].sort((left, right) => left.content.sequence - right.content.sequence);
+        const latest = streamEvents[streamEvents.length - 1];
+        const text = streamEvents.reduce((currentText, streamEvent) => applyResponseStreamText(currentText, streamEvent.content), '');
+        const taskId = latest.task?.id;
+        const matchingLaterFinalMessage = taskId !== undefined &&
+            (finalMessagesByTask.get(taskId) ?? []).some((message) => message.index > streamGroup.lastIndex && textMatches(text, message.text));
+        if (latest.content.status !== 'aborted' &&
+            !matchingLaterFinalMessage &&
+            text.trim()) {
+            entries.push({
+                streamId,
+                key: `response-stream-${streamId}`,
+                contents: streamEvents.map((event) => event.content),
+                text,
+                status: latest.content.status,
+                timestamp: formatDisplayTimestamp(latest.created_at),
+                taskId,
+            });
+        }
+    }
+    return entries;
+}
+function responseStreamResumeStateFromEntries(entries) {
+    const state = {
+        keys: new Map(),
+        contents: new Map(),
+        texts: new Map(),
+        timestamps: new Map(),
+        statuses: new Map(),
+        keysByTask: new Map(),
+    };
+    for (const entry of entries) {
+        state.keys.set(entry.streamId, entry.key);
+        state.contents.set(entry.streamId, entry.contents);
+        state.texts.set(entry.streamId, entry.text);
+        state.statuses.set(entry.streamId, entry.status);
+        if (entry.timestamp !== undefined) {
+            state.timestamps.set(entry.streamId, entry.timestamp);
+        }
+        if (entry.taskId !== undefined) {
+            const keys = state.keysByTask.get(entry.taskId) ?? new Set();
+            keys.add(entry.key);
+            state.keysByTask.set(entry.taskId, keys);
+        }
+    }
+    return state;
+}
+export function responseStreamResumeStateFromEvents(events) {
+    return responseStreamResumeStateFromEntries(collectResponseStreamResumeEntries(events));
+}
+function eventsToDisplayMessagesWithResponseStreamEntries(events, responseStreamEntries) {
     const messages = [];
+    const responseStreamEntriesById = new Map(responseStreamEntries.map((entry) => [entry.streamId, entry]));
+    const renderedResponseStreamIds = new Set();
     for (const event of events) {
         if (event.type === 'user_message') {
             messages.push({
@@ -65,18 +179,22 @@ export function eventsToDisplayMessages(events) {
             });
         }
         else if (event.type === 'agent_notification_message') {
-            if (isResponseStreamEvent(event))
+            if (isResponseStreamEvent(event)) {
+                if (!isRootTaskEvent(event))
+                    continue;
+                const streamId = event.content.stream_id;
+                if (renderedResponseStreamIds.has(streamId))
+                    continue;
+                const streamEntry = responseStreamEntriesById.get(streamId);
+                if (!streamEntry)
+                    continue;
+                renderedResponseStreamIds.add(streamId);
+                messages.push(renderAssistantText(streamEntry.key, streamEntry.text, streamEntry.timestamp));
                 continue;
+            }
             const text = getAgentNotificationText(event);
             if (text.trim()) {
-                const rendered = renderMarkdown(text);
-                const messageContent = `${chalk.green('●')} ${chalk.bold('assistant')}\n${rendered.trim()}`;
-                messages.push({
-                    key: event.id,
-                    content: messageContent,
-                    type: 'assistant',
-                    timestamp: event.created_at,
-                });
+                messages.push(renderAssistantText(event.id, text, event.created_at));
             }
         }
         else if (event.type === 'agent_notification_error') {
@@ -93,4 +211,19 @@ export function eventsToDisplayMessages(events) {
     }
     return messages;
 }
+export function prepareSessionResumeDisplay(events) {
+    const responseStreamEntries = collectResponseStreamResumeEntries(events);
+    return {
+        displayMessages: eventsToDisplayMessagesWithResponseStreamEntries(events, responseStreamEntries),
+        responseStreamState: responseStreamResumeStateFromEntries(responseStreamEntries),
+    };
+}
+/**
+ * Convert session events to display messages for resume.
+ * Maps user_message, agent_notification_message, and agent_notification_error
+ * to DisplayMessage objects. Skips progress, console, runtime events.
+ */
+export function eventsToDisplayMessages(events) {
+    return prepareSessionResumeDisplay(events).displayMessages;
+}
 //# sourceMappingURL=session-resume.js.map

package/dist/lib/splash.js

@@ -3,6 +3,7 @@
 import chalk from 'chalk';
 import LOGO from './logo.js';
 import { brand } from './colors.js';
+import { isMachineReadable } from './output-mode.js';
 /**
  * Show splash screen with logo
  */
@@ -21,8 +22,8 @@ export function showSplashScreen(options) {
  * Never for: --json, data commands, action commands
  */
 export function shouldShowSplash() {
-    // Never in JSON mode
-    if (process.argv.includes('--json')) {
+    // Never in machine-readable mode (--mode json, --mode jsonl, --json)
+    if (isMachineReadable()) {
         return false;
     }
     const args = process.argv.slice(2);

package/dist/lib/stdin.d.ts

@@ -1,5 +1,9 @@
 /**
- * Check if stdin is connected to an interactive terminal (TTY).
+ * Check if the CLI is running in interactive mode.
+ *
+ * Returns false when:
+ *  - stdin is not a TTY (piped input, CI, cron)
+ *  - the global --non-interactive flag is set
  */
 export declare function isInteractive(): boolean;
 /**

package/dist/lib/stdin.js

@@ -1,9 +1,16 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Check if stdin is connected to an interactive terminal (TTY).
+ * Check if the CLI is running in interactive mode.
+ *
+ * Returns false when:
+ *  - stdin is not a TTY (piped input, CI, cron)
+ *  - the global --non-interactive flag is set
  */
 export function isInteractive() {
+    if (process.argv.includes('--non-interactive')) {
+        return false;
+    }
     return process.stdin.isTTY === true;
 }
 /**

package/dist/lib/version-helpers.js

@@ -66,22 +66,38 @@ export async function waitForValidation(versionId, output) {
 }
 /**
  * Fetch validation step details for a failed version.
+ * Shows content from all steps (not just failed) so the full build output is visible.
  */
 async function fetchValidationFailureDetails(versionId) {
     const client = new GuildAPIClient();
     let failureDetails = '';
     try {
         const stepsResponse = await client.get(`/versions/${versionId}/validation/steps`);
-        const failedSteps = stepsResponse.steps.filter((step) => step.status === 'FAILED');
-        if (failedSteps.length > 0) {
-            failureDetails = failedSteps
-                .map((step) => step.content
-                ? `Step "${step.name}" failed: ${step.content}`
-                : `Step "${step.name}" failed`)
-                .join('\n');
+        if (stepsResponse.steps.length > 0) {
+            failureDetails = stepsResponse.steps
+                .map((step) => {
+                let icon;
+                switch (step.status) {
+                    case 'SUCCEEDED':
+                        icon = '✓';
+                        break;
+                    case 'FAILED':
+                    case 'ERRORED':
+                        icon = '✗';
+                        break;
+                    case 'RUNNING':
+                        icon = '⟳';
+                        break;
+                    default:
+                        icon = '○';
+                }
+                const header = `${icon} ${step.name} [${step.status}]`;
+                return step.content ? `${header}\n${step.content}` : header;
+            })
+                .join('\n\n');
         }
         else {
-            failureDetails = 'No failed steps found. Check validation logs for details.';
+            failureDetails = 'No steps found. Check validation logs for details.';
         }
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",