@guildai/cli 0.9.1 → 0.11.0

package/dist/lib/owner-helpers.js

@@ -11,9 +11,10 @@
  * 2. GUILD_OWNER_ID environment variable
  * 3. default_owner from ~/.guild/config.json
  * 4. Fetch user + orgs from API:
- *    - No orgs → use current user
- *    - Has orgs + interactive → prompt
- *    - Has orgs + non-interactive → use current user
+ *    - No orgs + non-interactive → use current user (single-account, stated explicitly)
+ *    - No orgs + interactive → prompt with personal account as only choice
+ *    - Has orgs + interactive → prompt to select from all accounts
+ *    - Has orgs + non-interactive → error: require --owner flag
  */
 import inquirer from 'inquirer';
 import { loadGlobalConfig } from './guild-config.js';
@@ -35,7 +36,7 @@ export async function lookupOwner(client, val) {
     return undefined;
 }
 export async function resolveOwnerId(options) {
-    const { ownerFlag, client, interactive } = options;
+    const { ownerFlag, client, interactive, requireExplicitOwner = false } = options;
     // Priority 1: --owner flag
     if (ownerFlag) {
         debug('Using owner from --owner flag: %s', ownerFlag);
@@ -71,17 +72,23 @@ export async function resolveOwnerId(options) {
     // Priority 4: Fetch user + orgs
     const me = await client.get('/me');
     const orgs = await client.fetchAll('/me/organizations');
-    // No orgs → use current user
-    if (orgs.length === 0) {
+    // No orgs + non-interactive → use current user (single account, stated explicitly by caller)
+    if (orgs.length === 0 && !interactive) {
         debug('No organizations found, using current user as owner');
         return { id: me.id, name: me.name, type: 'user' };
     }
-    // Has orgs + non-interactive → use current user
-    if (!interactive) {
-        debug('Non-interactive mode with orgs available, using current user as owner');
+    // Has orgs + non-interactive
+    if (orgs.length > 0 && !interactive) {
+        if (requireExplicitOwner) {
+            debug('Non-interactive mode with multiple accounts available, requiring --owner');
+            throw new Error('Owner is required in non-interactive mode when multiple accounts are available.\n\n' +
+                'Use --owner <name-or-id> to specify an owner, or set a default:\n' +
+                '  guild config set default_owner <name-or-id>');
+        }
+        debug('Multiple accounts available, defaulting to current user');
         return { id: me.id, name: me.name, type: 'user' };
     }
-    // Has orgs + interactive → prompt
+    // Interactive → prompt (always, even with single account)
     const choices = [
         {
             name: `${me.name} (personal)`,

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.9.1",
+  "version": "0.11.0",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",