@guildai/cli 0.9.0 → 0.10.0

package/dist/lib/guild-config.d.ts

@@ -83,4 +83,17 @@ export declare function getWorkspaceId(cwd?: string): Promise<{
  * Check if we're in an agent directory (has guild.json)
  */
 export declare function isAgentDirectory(cwd?: string): Promise<boolean>;
+/**
+ * Get a human-readable label for the workspace source.
+ * Returns undefined for 'env' (treated as explicit, like --workspace flag; no label needed).
+ *
+ * @param source - The source of workspace resolution
+ * @returns Human-readable label, or undefined for env source
+ *
+ * @example
+ * getWorkspaceSourceLabel('local')  // → 'guild.json'
+ * getWorkspaceSourceLabel('global') // → 'global config'
+ * getWorkspaceSourceLabel('env')    // → undefined
+ */
+export declare function getWorkspaceSourceLabel(source: 'env' | 'local' | 'global'): string | undefined;
 //# sourceMappingURL=guild-config.d.ts.map

package/dist/lib/guild-config.js

@@ -156,4 +156,23 @@ export async function getWorkspaceId(cwd = process.cwd()) {
 export async function isAgentDirectory(cwd = process.cwd()) {
     return fileExists(getLocalConfigPath(cwd));
 }
+/**
+ * Get a human-readable label for the workspace source.
+ * Returns undefined for 'env' (treated as explicit, like --workspace flag; no label needed).
+ *
+ * @param source - The source of workspace resolution
+ * @returns Human-readable label, or undefined for env source
+ *
+ * @example
+ * getWorkspaceSourceLabel('local')  // → 'guild.json'
+ * getWorkspaceSourceLabel('global') // → 'global config'
+ * getWorkspaceSourceLabel('env')    // → undefined
+ */
+export function getWorkspaceSourceLabel(source) {
+    if (source === 'local')
+        return 'guild.json';
+    if (source === 'global')
+        return 'global config';
+    return undefined; // 'env' is explicit (GUILD_WORKSPACE_ID), no magic label needed
+}
 //# sourceMappingURL=guild-config.js.map

package/dist/lib/npmrc.js

@@ -8,7 +8,8 @@ function getRegistryUrl() {
     const url = getGuildcoreUrl();
     return url.replace('/api', '/npm') + (url.endsWith('/') ? '' : '/');
 }
-const SCOPES = ['@guildai', '@guildai-services', '@guildai-agents'];
+const SCOPES = ['@guildai-services', '@guildai-agents'];
+const LEGACY_SCOPES = ['@guildai'];
 export async function configureNpmrc() {
     const registryUrl = getRegistryUrl();
     const scope = registryUrl.split(':').slice(1).join(':');
@@ -35,7 +36,10 @@ export async function configureNpmrc() {
 export async function cleanupNpmrc() {
     const registryUrl = getRegistryUrl();
     const scope = registryUrl.split(':').slice(1).join(':');
-    const keys = [...SCOPES.map((s) => `${s}:registry`), `${scope}:_authToken`];
+    const keys = [
+        ...[...SCOPES, ...LEGACY_SCOPES].map((s) => `${s}:registry`),
+        `${scope}:_authToken`,
+    ];
     for (const key of keys) {
         try {
             await execa('npm', [

package/dist/lib/output.js

@@ -195,7 +195,7 @@ export function formatVersionTable(versions, pagination) {
                 ? chalk.red
                 : chalk.dim;
         table.addRow({
-            id: v.id.substring(0, 8),
+            id: v.id,
             version: v.version_number || '-',
             status: v.status,
             validation: validationColor(v.validation_status || '-'),
@@ -225,7 +225,7 @@ export function formatContextTable(contexts, pagination) {
     });
     contexts.forEach((ctx) => {
         table.addRow({
-            id: truncate(ctx.id, 12),
+            id: ctx.id,
             status: ctx.status,
             type: ctx.type || '-',
             created: ctx.created_at ? formatRelativeTime(ctx.created_at) : '',
@@ -256,7 +256,7 @@ export function formatWorkspaceAgentTable(agents) {
         const agentUrl = wa.agent.full_name ? `${base}/agents/${wa.agent.full_name}` : '';
         table.addRow({
             name: agentUrl ? hyperlink(name, agentUrl) : name,
-            version: wa.agent_version.version_number || wa.agent_version.id.substring(0, 8),
+            version: wa.agent_version.version_number || wa.agent_version.id,
             auto_update: wa.should_autoupdate ? chalk.green('yes') : chalk.dim('no'),
         });
     });
@@ -353,7 +353,7 @@ export function formatTaskTable(tasks, pagination) {
                     ? chalk.yellow
                     : chalk.dim;
         table.addRow({
-            id: truncate(task.id, 13),
+            id: task.id,
             name,
             status: statusColor(task.status),
             tokens: task.token_usage ? task.token_usage.total_tokens.toLocaleString() : '-',

package/dist/lib/owner-helpers.d.ts

@@ -13,6 +13,9 @@ export interface ResolveOwnerOptions {
     ownerFlag?: string;
     client: GuildAPIClient;
     interactive: boolean;
+    /** When true, error if multiple accounts and no explicit owner in non-interactive mode.
+     *  When false (default), fall back to current user. */
+    requireExplicitOwner?: boolean;
 }
 export declare function resolveOwnerId(options: ResolveOwnerOptions): Promise<OwnerChoice>;
 //# sourceMappingURL=owner-helpers.d.ts.map

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

@@ -19,10 +19,12 @@ export interface AgentRef {
 }
 export interface SessionTaskAgentItem extends BaseTaskFields {
     agent: AgentRef;
+    parent_task_id: string | null;
 }
 export interface SessionTaskToolItem extends BaseTaskFields {
     tool_name: string;
     tool_call_id: string;
+    parent_task: SessionTaskItem | null;
 }
 export type SessionTaskItem = SessionTaskAgentItem | SessionTaskToolItem;
 export interface SessionTaskAgent extends SessionTaskAgentItem {
@@ -91,26 +93,29 @@ export interface RuntimeDoneEvent extends BaseEvent {
     type: 'runtime_done';
     content: Record<string, unknown>;
 }
+export interface TextContent {
+    type: 'text';
+    data: string;
+}
+export interface ResponseStreamContent {
+    type: 'application/guild-response-stream';
+    stream_id: string;
+    sequence: number;
+    status: 'streaming' | 'done' | 'aborted';
+    text: string;
+}
+export type AgentNotificationMessageContent = TextContent | ResponseStreamContent;
 export interface AgentNotificationMessageEvent extends BaseEvent {
     type: 'agent_notification_message';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: AgentNotificationMessageContent;
 }
 export interface AgentNotificationProgressEvent extends BaseEvent {
     type: 'agent_notification_progress';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
 }
 export interface AgentNotificationErrorEvent extends BaseEvent {
     type: 'agent_notification_error';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
 }
 export interface AgentConsoleEvent extends BaseEvent {
     type: 'agent_console';
@@ -126,10 +131,7 @@ export interface TriggerMessageEvent extends BaseEvent {
 }
 export interface SystemErrorEvent extends BaseEvent {
     type: 'system_error';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
     details?: Record<string, unknown>;
 }
 export interface LlmStartEvent extends BaseEvent {
@@ -169,6 +171,20 @@ export interface CredentialsRequestEvent extends BaseEvent {
 export declare function isUnfulfilledAgentInstallRequest(event: SessionEvent): event is AgentInstallRequestEvent;
 /** Check if event is an unfulfilled credentials request */
 export declare function isUnfulfilledCredentialsRequest(event: SessionEvent): event is CredentialsRequestEvent;
+/** Check if an agent notification message is a transient response stream draft. */
+export declare function isResponseStreamEvent(event: SessionEvent): event is AgentNotificationMessageEvent & {
+    content: ResponseStreamContent;
+};
+/** Check if a response stream event carries the final generated text. */
+export declare function isDoneResponseStreamEvent(event: SessionEvent): event is AgentNotificationMessageEvent & {
+    content: ResponseStreamContent & {
+        status: 'done';
+    };
+};
+/** 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. */
+export declare function isRootTaskEvent(event: SessionEvent): boolean;
 export interface InterruptedEvent extends BaseEvent {
     type: 'interrupted';
     interrupted_at: string;

package/dist/lib/session-events.js

@@ -87,4 +87,26 @@ export function isUnfulfilledAgentInstallRequest(event) {
 export function isUnfulfilledCredentialsRequest(event) {
     return event.type === 'credentials_request' && !event.is_fulfilled;
 }
+/** Check if an agent notification message is a transient response stream draft. */
+export function isResponseStreamEvent(event) {
+    return (event.type === 'agent_notification_message' &&
+        event.content.type === 'application/guild-response-stream');
+}
+/** Check if a response stream event carries the final generated text. */
+export function isDoneResponseStreamEvent(event) {
+    return isResponseStreamEvent(event) && event.content.status === 'done';
+}
+/** Extract display text from notification content. */
+export function getAgentNotificationText(event) {
+    return event.content.type === 'text' ? event.content.data : event.content.text;
+}
+/** Check if an event belongs to the root task or has no task context. */
+export function isRootTaskEvent(event) {
+    const task = event.task;
+    if (!task)
+        return true;
+    if ('parent_task_id' in task)
+        return task.parent_task_id === null;
+    return task.parent_task === null;
+}
 //# sourceMappingURL=session-events.js.map

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

@@ -11,9 +11,10 @@ export interface PollResult {
  * and one-shot agents (which may only emit runtime_done with output content).
  *
  * Priority:
- * 1. agent_notification_message — preferred, immediate return
- * 2. runtime_done from agent tasks — fallback for one-shot agents
- * 3. runtime_error from agent tasks — fail fast
+ * 1. root agent_notification_message — preferred, immediate return
+ * 2. root runtime_error — fail fast
+ * 3. root runtime_done content — fallback for one-shot agents
+ * 4. root done response-stream after root runtime_done — streaming fallback
  */
 export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventId: string | undefined, maxWaitTime?: number): Promise<PollResult>;
 /**

package/dist/lib/session-polling.js

@@ -3,6 +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';
 /**
  * Poll for agent response using from_id cursor.
  *
@@ -10,28 +11,51 @@ import { fetchEvents } from './session-events-fetch.js';
  * and one-shot agents (which may only emit runtime_done with output content).
  *
  * Priority:
- * 1. agent_notification_message — preferred, immediate return
- * 2. runtime_done from agent tasks — fallback for one-shot agents
- * 3. runtime_error from agent tasks — fail fast
+ * 1. root agent_notification_message — preferred, immediate return
+ * 2. root runtime_error — fail fast
+ * 3. root runtime_done content — fallback for one-shot agents
+ * 4. root done response-stream after root runtime_done — streaming fallback
  */
 export async function pollForResponse(client, sessionId, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
     let fromId = afterEventId;
+    let responseStreamDone = null;
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
+        let rootRuntimeDone = false;
         for (const event of events) {
             debug(`pollForResponse event: ${event.type}`);
             if (event.type === 'agent_notification_message') {
-                return { response: event.content.data, lastEventId: event.id };
+                if (isResponseStreamEvent(event)) {
+                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
+                        responseStreamDone = {
+                            response: getAgentNotificationText(event),
+                            lastEventId: event.id,
+                        };
+                    }
+                    continue;
+                }
+                if (!isRootTaskEvent(event))
+                    continue;
+                return {
+                    response: getAgentNotificationText(event),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'runtime_done' &&
-                event.content !== undefined &&
                 event.task &&
-                'agent' in event.task) {
-                lastAgentRuntimeDone = JSON.stringify(event.content);
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
+                rootRuntimeDone = true;
+                if (event.content !== undefined) {
+                    lastAgentRuntimeDone = JSON.stringify(event.content);
+                }
             }
-            if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
+            if (event.type === 'runtime_error' &&
+                event.task &&
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
                 return {
                     response: JSON.stringify({ error: event.content }),
                     lastEventId: event.id,
@@ -47,9 +71,14 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
         if (lastAgentRuntimeDone !== null) {
             return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
+        if (rootRuntimeDone && responseStreamDone !== null) {
+            return { response: responseStreamDone.response, lastEventId: fromId };
+        }
         await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-    return { response: null, lastEventId: fromId };
+    return responseStreamDone
+        ? { response: responseStreamDone.response, lastEventId: fromId }
+        : { response: null, lastEventId: fromId };
 }
 /**
  * Poll for agent response while streaming matching events to stdout as JSONL.
@@ -61,25 +90,49 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
 export async function pollForResponseWithEvents(client, sessionId, eventFilter, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
     let fromId = afterEventId;
+    let responseStreamDone = null;
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
+        let rootRuntimeDone = false;
         for (const event of events) {
             debug(`pollForResponseWithEvents event: ${event.type}`);
-            // Stream matching events to stdout as JSONL
-            if (shouldShowEvent(event.type, eventFilter)) {
+            // Stream matching events to stdout as JSONL. Response-stream events are
+            // transient drafts, so keep automation output stable and wait for the
+            // final agent message or terminal fallback.
+            if (shouldShowEvent(event.type, eventFilter) && !isResponseStreamEvent(event)) {
                 process.stdout.write(JSON.stringify(event) + '\n');
             }
             if (event.type === 'agent_notification_message') {
-                return { response: event.content.data, lastEventId: event.id };
+                if (isResponseStreamEvent(event)) {
+                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
+                        responseStreamDone = {
+                            response: getAgentNotificationText(event),
+                            lastEventId: event.id,
+                        };
+                    }
+                    continue;
+                }
+                if (!isRootTaskEvent(event))
+                    continue;
+                return {
+                    response: getAgentNotificationText(event),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'runtime_done' &&
-                event.content !== undefined &&
                 event.task &&
-                'agent' in event.task) {
-                lastAgentRuntimeDone = JSON.stringify(event.content);
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
+                rootRuntimeDone = true;
+                if (event.content !== undefined) {
+                    lastAgentRuntimeDone = JSON.stringify(event.content);
+                }
             }
-            if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
+            if (event.type === 'runtime_error' &&
+                event.task &&
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
                 return {
                     response: JSON.stringify({ error: event.content }),
                     lastEventId: event.id,
@@ -95,8 +148,13 @@ export async function pollForResponseWithEvents(client, sessionId, eventFilter,
         if (lastAgentRuntimeDone !== null) {
             return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
+        if (rootRuntimeDone && responseStreamDone !== null) {
+            return { response: responseStreamDone.response, lastEventId: fromId };
+        }
         await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-    return { response: null, lastEventId: fromId };
+    return responseStreamDone
+        ? { response: responseStreamDone.response, lastEventId: fromId }
+        : { response: null, lastEventId: fromId };
 }
 //# sourceMappingURL=session-polling.js.map

package/dist/lib/session-resume.js

@@ -7,6 +7,7 @@
 import chalk from 'chalk';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
+import { getAgentNotificationText, isResponseStreamEvent, } 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)
@@ -64,7 +65,9 @@ export function eventsToDisplayMessages(events) {
             });
         }
         else if (event.type === 'agent_notification_message') {
-            const text = typeof event.content === 'string' ? event.content : event.content?.data || '';
+            if (isResponseStreamEvent(event))
+                continue;
+            const text = getAgentNotificationText(event);
             if (text.trim()) {
                 const rendered = renderMarkdown(text);
                 const messageContent = `${chalk.green('●')} ${chalk.bold('assistant')}\n${rendered.trim()}`;

package/dist/lib/stdin.d.ts

@@ -8,6 +8,10 @@ export declare function isInteractive(): boolean;
  * accidentally pipe input without --mode get clear guidance instead of a hang.
  */
 export declare function ensureInteractiveStdin(command: string): void;
+/**
+ * Read raw text from stdin with a timeout.
+ */
+export declare function readStdinAsText(): Promise<string>;
 /**
  * Read JSON from stdin with a timeout.
  */

package/dist/lib/stdin.js

@@ -24,6 +24,29 @@ export function ensureInteractiveStdin(command) {
         process.exit(1);
     }
 }
+/**
+ * Read raw text from stdin with a timeout.
+ */
+export function readStdinAsText() {
+    return new Promise((resolve, reject) => {
+        let input = '';
+        const timeout = setTimeout(() => {
+            reject(new Error('Timeout waiting for stdin'));
+        }, 5000);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            input += chunk;
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timeout);
+            resolve(input);
+        });
+        process.stdin.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
 /**
  * Read JSON from stdin with a timeout.
  */

package/dist/lib/validate-input-schema.d.ts

@@ -0,0 +1,19 @@
+interface ValidationSuccess {
+    valid: true;
+}
+interface ValidationFailure {
+    valid: false;
+    errors: Array<{
+        message: string;
+        path?: string[];
+    }>;
+}
+interface ValidationSkipped {
+    valid: true;
+    skipped: true;
+    reason: string;
+}
+export type ValidationResult = ValidationSuccess | ValidationFailure | ValidationSkipped;
+export declare function validateInputSchema(agentDir: string, inputs: unknown[]): Promise<ValidationResult>;
+export {};
+//# sourceMappingURL=validate-input-schema.d.ts.map