@guildai/cli 0.7.0 → 0.7.1

package/dist/commands/chat.js

@@ -13,7 +13,7 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, matchesAgent, getAgentName, } from '../lib/session-events.js';
+import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, } from '../lib/session-events.js';
 import { printResumeHint, fetchSession, fetchSessionEvents, eventsToDisplayMessages, } from '../lib/session-resume.js';
 import { DEFAULT_EVENT_TYPES, parseEventFilter, shouldShowEvent, } from '../lib/event-filter.js';
 import { fetchEvents, fetchTasks } from '../lib/session-events-fetch.js';
@@ -1087,24 +1087,37 @@ export function createChatCommand() {
                     else {
                         inactivityCounter++;
                     }
-                    // Check if we got a completion response
-                    // Look for runtime_done events from the ROOT task (the agent we're chatting with)
-                    // For orchestrating agents like agent-builder that spawn child tasks, we need to
-                    // wait for the root agent's completion, not just any runtime_done event.
-                    const targetAgent = options.agent || 'assistant';
-                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id // Root task has no parent
-                    );
-                    // Also check for agent_notification_message events from the root agent
-                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id);
+                    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 for a ui_prompt request... that ends the game.
                     const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
                         e.task?.tool_name === 'ui_prompt');
+                    if (hasRootTaskError) {
+                        debug('Found error event from root agent, exiting --once mode');
+                        const errorEvents = allEvents.filter((e) => e.type === 'runtime_error' || e.type === 'agent_notification_error');
+                        if (errorEvents.length > 0 && !options.mode) {
+                            const lastError = errorEvents[errorEvents.length - 1];
+                            const content = lastError.content;
+                            if (content?.data) {
+                                console.error(chalk.red(`Error: ${content.data}`));
+                            }
+                            else {
+                                console.error(chalk.red('Agent failed to start'));
+                            }
+                        }
+                        else if (options.mode === 'json') {
+                            console.log(JSON.stringify({
+                                session_id: session.id,
+                                events: allEvents,
+                                error: true,
+                            }, null, 2));
+                        }
+                        process.exit(1);
+                    }
                     if (hasRootTaskDone || hasAgentMessage || hasUIPromptMessage) {
-                        debug(`Found completion event from root agent (${targetAgent}), exiting --once mode`);
+                        debug('Found completion event from root agent, exiting --once mode');
                         await outputOnceResult(session.id, allEvents, options.mode);
                         process.exit(0);
                     }

package/dist/commands/config/list.js

@@ -27,13 +27,13 @@ export function createConfigListCommand() {
             output.progress(chalk.dim('  guild workspace select'));
             return;
         }
-        if (hasGlobal) {
+        if (config.global && hasGlobal) {
             output.progress(chalk.bold('Global config') + chalk.dim(' (~/.guild/config.json):'));
             for (const [key, value] of Object.entries(config.global)) {
                 output.progress(`  ${key}: ${chalk.cyan(String(value))}`);
             }
         }
-        if (hasLocal) {
+        if (config.local && hasLocal) {
             if (hasGlobal)
                 output.progress('');
             output.progress(chalk.bold('Local config') + chalk.dim(' (guild.json):'));

package/dist/commands/integration/operation/create.js

@@ -17,7 +17,7 @@ export function createIntegrationOperationCreateCommand() {
     cmd
         .description('Create operation(s) for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--operation <name>', 'Operation identifier, e.g. list_users')
         .option('--method <method>', 'HTTP method: GET, POST, PUT, PATCH, DELETE')
         .option('--path <path>', 'REST path, e.g. /{owner}/{repo}/issues')
@@ -35,7 +35,7 @@ export function createIntegrationOperationCreateCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.openapi) {
                 // OpenAPI mode
                 if (!existsSync(options.openapi)) {

package/dist/commands/integration/operation/list.js

@@ -14,7 +14,7 @@ export function createIntegrationOperationListCommand() {
     cmd
         .description('List operations for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (identifier, options) => {
@@ -26,7 +26,7 @@ export function createIntegrationOperationListCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);

package/dist/commands/integration/update.js

@@ -63,7 +63,7 @@ export function createIntegrationUpdateCommand() {
                 hasUpdates = true;
             }
             if (options.baseUrl !== undefined) {
-                body.protocol_config = { base_url: options.baseUrl };
+                body.protocol_config = { protocol: 'REST', base_url: options.baseUrl };
                 hasUpdates = true;
             }
             // Auth config updates need the discriminator

package/dist/commands/integration/version/get.js

@@ -34,7 +34,7 @@ export function createIntegrationVersionGetCommand() {
     cmd
         .description('Get version details')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -44,7 +44,7 @@ export function createIntegrationVersionGetCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const response = await client.get(`/integration_versions/${versionId}`);
             if (getOutputMode() === 'json') {
                 output.data(response);

package/dist/commands/integration/version/publish.js

@@ -23,7 +23,7 @@ export function createIntegrationVersionPublishCommand() {
     cmd
         .description('Publish a built version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version to publish, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version to publish, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -33,7 +33,7 @@ export function createIntegrationVersionPublishCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             // Get current version info for display
             const currentVersion = await client.get(`/integration_versions/${versionId}`);
             const versionDisplay = currentVersion.version_number || versionId;

package/dist/commands/integration/version/test.js

@@ -22,7 +22,7 @@ export function createIntegrationVersionTestCommand() {
     cmd
         .description('Test an endpoint invocation')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .requiredOption('--operation <name>', 'Operation to test, e.g. list_users')
         .option('--account <name>', 'Account name to resolve credential from')
         .option('--input-path <json>', 'JSON object of path parameters')
@@ -50,7 +50,7 @@ export function createIntegrationVersionTestCommand() {
                 body.input_body = parseJsonFlag(options.inputBody, '--input-body');
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.account) {
                 const creds = await client.get(`/accounts/${options.account}/credentials?integration=${encodeURIComponent(identifier)}`);
                 if (creds.items.length === 0) {

package/dist/commands/session/events.js

@@ -3,6 +3,7 @@
 import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
+import { parseEventFilter } from '../../lib/event-filter.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
 export function createSessionEventsCommand() {
@@ -10,7 +11,7 @@ export function createSessionEventsCommand() {
     cmd
         .description('List events in a session')
         .argument('<session-id>', 'Session ID')
-        .option('--types <types>', 'Comma-separated event types to filter (e.g., user_message,agent_notification_message)')
+        .option('--events <types>', 'Event types to show. Shorthands: none, user, system, all, or comma-separated type names')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (sessionId, options) => {
@@ -25,8 +26,11 @@ export function createSessionEventsCommand() {
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);
-            if (options.types) {
-                params.append('types', options.types);
+            if (options.events) {
+                const filter = parseEventFilter(options.events);
+                if (filter.size > 0) {
+                    params.append('types', [...filter].join(','));
+                }
             }
             const response = await client.get(`/sessions/${sessionId}/events?${params.toString()}`);
             output.data(response);

package/dist/commands/workspace/get.js

@@ -8,7 +8,7 @@ export function createWorkspaceGetCommand() {
     const cmd = new Command('get');
     cmd
         .description('Get workspace details')
-        .argument('<identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
+        .argument('<identifier>', 'Workspace ID or full name (e.g., owner~workspace-name)')
         .action(async (id) => {
         const output = createOutputWriter();
         try {

package/dist/commands/workspace/list.js

@@ -11,16 +11,38 @@ export function createWorkspaceListCommand() {
         .description('List workspaces')
         .option('--limit <number>', 'Number of results to return', '20')
         .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--owner <name>', 'Filter workspaces by owner name (case-insensitive)')
         .action(async (options) => {
         const output = createOutputWriter();
         try {
             const client = new GuildAPIClient();
-            const params = new URLSearchParams();
-            // Use filter=all to get workspaces from all orgs user is a member of
-            params.append('filter', 'all');
-            params.append('limit', options.limit);
-            params.append('offset', options.offset);
-            const response = await client.get(`/me/workspaces?${params.toString()}`);
+            let response;
+            if (options.owner) {
+                // When filtering by owner, fetch ALL workspaces first so the
+                // client-side filter is applied to the complete dataset, not just
+                // one page.  The backend's `filter` param only recognises "all" vs
+                // personal; owner-name filtering is not supported server-side.
+                const allWorkspaces = await client.fetchAll('/me/workspaces?filter=all');
+                const ownerLower = options.owner.toLowerCase();
+                const filtered = allWorkspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerLower);
+                response = {
+                    items: filtered,
+                    pagination: {
+                        total_count: filtered.length,
+                        limit: filtered.length,
+                        offset: 0,
+                        has_more: false,
+                    },
+                };
+            }
+            else {
+                const params = new URLSearchParams();
+                // Use filter=all to get workspaces from all orgs the user is a member of.
+                params.append('filter', 'all');
+                params.append('limit', options.limit);
+                params.append('offset', options.offset);
+                response = await client.get(`/me/workspaces?${params.toString()}`);
+            }
             if (getOutputMode() === 'json') {
                 console.log(JSON.stringify(response, null, 2));
             }

package/dist/commands/workspace/select.js

@@ -35,8 +35,10 @@ export function createWorkspaceSelectCommand() {
     cmd
         .description('Select default workspace for agent testing')
         .argument('[workspace]', 'Workspace name or ID to select directly')
-        .action(async (workspaceArg) => {
+        .option('--owner <name>', 'Filter workspaces by owner name (case-insensitive)')
+        .action(async (workspaceArg, options = {}) => {
         const output = createOutputWriter();
+        const ownerFilter = options.owner;
         try {
             const client = new GuildAPIClient();
             // If a workspace argument was provided, use server-side search to find it
@@ -45,19 +47,34 @@ export function createWorkspaceSelectCommand() {
                 // The backend searches only the "name" column via ILIKE, so full_name (owner/name)
                 // and ID lookups may not return results. Extract just the name part for search,
                 // and if still no match, fall back to fetching the full list.
+                // Always use filter=all — the backend's `filter` param only recognises "all"
+                // vs personal; owner-name filtering is applied client-side below.
                 const searchTerm = workspaceArg.includes('/')
-                    ? workspaceArg.split('/').pop()
+                    ? (workspaceArg.split('/').pop() ?? workspaceArg)
                     : workspaceArg;
                 const searchResults = await client.get(`/me/workspaces?filter=all&search=${encodeURIComponent(searchTerm)}&limit=100`);
-                let workspace = searchResults.items.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                let candidates = searchResults.items;
+                // Apply client-side owner filter on search results
+                if (ownerFilter) {
+                    candidates = candidates.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase());
+                }
                 // Search didn't find it (could be an ID lookup, or search term didn't match).
                 // Fall back to fetching all workspaces via pagination.
-                if (!workspace) {
+                const directMatch = candidates.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                if (!directMatch) {
                     const allWorkspaces = await client.fetchAll('/me/workspaces?filter=all');
-                    workspace = allWorkspaces.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                    candidates = ownerFilter
+                        ? allWorkspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase())
+                        : allWorkspaces;
                 }
+                const workspace = candidates.find((w) => matchesWorkspaceArg(w, workspaceArg));
                 if (!workspace) {
-                    output.error(`Workspace "${workspaceArg}" not found.`, 'Run: guild workspace list');
+                    if (ownerFilter) {
+                        output.error(`Workspace "${workspaceArg}" not found for owner "${ownerFilter}".`, 'Run: guild workspace list');
+                    }
+                    else {
+                        output.error(`Workspace "${workspaceArg}" not found.`, 'Run: guild workspace list');
+                    }
                     process.exit(1);
                 }
                 const target = await saveWorkspaceConfig(workspace.id, workspace.name);
@@ -73,10 +90,20 @@ export function createWorkspaceSelectCommand() {
                 output.error('Interactive mode requires a terminal.', 'Provide a workspace argument:\n  guild workspace select <name|id>');
                 process.exit(1);
             }
-            // Interactive mode: fetch all workspaces across all pages
-            const workspaces = await client.fetchAll('/me/workspaces?filter=all');
+            // Interactive mode: fetch all workspaces across all pages.
+            // Always use filter=all; owner-name filtering is applied client-side
+            // (the backend's `filter` param only recognises "all" vs personal).
+            let workspaces = await client.fetchAll('/me/workspaces?filter=all');
+            if (ownerFilter) {
+                workspaces = workspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase());
+            }
             if (workspaces.length === 0) {
-                output.error('No workspaces found.', 'Create a workspace first:\n  guild workspace create <name>');
+                if (ownerFilter) {
+                    output.error(`No workspaces found for owner "${ownerFilter}".`, 'Run: guild workspace list');
+                }
+                else {
+                    output.error('No workspaces found.', 'Create a workspace first:\n  guild workspace create <name>');
+                }
                 process.exit(1);
             }
             // Resolve the currently selected workspace (if any)
@@ -101,6 +128,10 @@ export function createWorkspaceSelectCommand() {
                 },
             });
             const selectedWorkspace = workspaces.find((w) => w.id === selectedId);
+            if (!selectedWorkspace) {
+                output.error('Selected workspace not found');
+                process.exit(1);
+            }
             const target = await saveWorkspaceConfig(selectedWorkspace.id, selectedWorkspace.name);
             if (target === 'local') {
                 output.success(`Workspace set for this agent: ${formatWorkspaceDisplay(selectedWorkspace)}`);

package/dist/components/TaskView.js

@@ -87,7 +87,7 @@ function calculateTaskDepths(tasks) {
     const taskMap = new Map(tasks.map((t) => [t.id, t]));
     function getDepth(taskId) {
         if (depthMap.has(taskId))
-            return depthMap.get(taskId);
+            return depthMap.get(taskId) ?? 0;
         const task = taskMap.get(taskId);
         const parentId = task?.parent_task?.id;
         if (!parentId) {
@@ -167,7 +167,7 @@ export function TaskView({ tasks }) {
             if (!tasksByParent.has(parentId)) {
                 tasksByParent.set(parentId, []);
             }
-            tasksByParent.get(parentId).push(task);
+            tasksByParent.get(parentId)?.push(task);
         });
         // Process root tasks first, then children
         const processedIds = new Set();

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

@@ -1,10 +1,26 @@
 import { LocalConfig } from './guild-config.js';
 import { GuildAPIClient } from './api-client.js';
+import type { AgentVersion } from './api-types.js';
+/** Thrown when the ephemeral version build times out or polling fails. */
+export declare class BuildTimeoutError extends Error {
+    constructor(message?: string);
+}
+/** Thrown when the ephemeral version build fails validation. */
+export declare class BuildFailedError extends Error {
+    readonly failedSteps: {
+        name: string;
+        content?: string;
+    }[];
+    constructor(failedSteps: {
+        name: string;
+        content?: string;
+    }[]);
+}
 /**
  * Resolve an agent identifier to a fully-qualified form.
  *
- * If the identifier already contains `/` or is a UUID, return it verbatim.
- * Otherwise, resolve the default owner and prepend `owner.name/`.
+ * If the identifier already contains `~` or is a UUID, return it verbatim.
+ * Otherwise, resolve the default owner and prepend `owner.name~`.
  */
 export declare function resolveAgentRef(client: GuildAPIClient, identifier: string): Promise<string>;
 /**
@@ -27,4 +43,45 @@ export declare function readAgentFiles(cwd: string): Promise<{
     path: string;
     content: string;
 }[]>;
+/**
+ * Compute a deterministic hash of agent files.
+ * Sorts by path to ensure consistent ordering.
+ */
+export declare function hashAgentFiles(files: {
+    path: string;
+    content: string;
+}[]): string;
+/**
+ * Get or create an ephemeral version, skipping the build if files haven't
+ * changed since the last successful ephemeral build.
+ *
+ * Returns the version (cached or newly created), a cache hit flag, and the
+ * computed hash (used by buildEphemeralVersion to write the cache on success).
+ */
+export declare function getOrCreateEphemeral(client: GuildAPIClient, agentId: string, files: {
+    path: string;
+    content: string;
+}[], cwd: string, summary: string, options?: {
+    noCache?: boolean;
+}): Promise<{
+    version: AgentVersion;
+    cached: boolean;
+    hash: string;
+}>;
+/**
+ * Build an ephemeral version end-to-end: get-or-create, poll for validation,
+ * cache on success, and report build failures.
+ *
+ * Consolidates the build/poll/cache pattern used by both `guild agent test`
+ * and `guild agent chat`.
+ */
+export declare function buildEphemeralVersion(client: GuildAPIClient, agentId: string, files: {
+    path: string;
+    content: string;
+}[], cwd: string, summary: string, options?: {
+    noCache?: boolean;
+}): Promise<{
+    version: AgentVersion;
+    cached: boolean;
+}>;
 //# sourceMappingURL=agent-helpers.d.ts.map

package/dist/lib/agent-helpers.js

@@ -1,23 +1,52 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'crypto';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { loadLocalConfig } from './guild-config.js';
 import { runGit } from './git.js';
 import { resolveOwnerId } from './owner-helpers.js';
+import { pollUntilComplete } from './polling.js';
+// ---------------------------------------------------------------------------
+// Build error types
+// ---------------------------------------------------------------------------
+/** Thrown when the ephemeral version build times out or polling fails. */
+export class BuildTimeoutError extends Error {
+    constructor(message = 'The agent version build timed out or failed to report status.') {
+        super(message);
+        this.name = 'BuildTimeoutError';
+    }
+}
+/** Thrown when the ephemeral version build fails validation. */
+export class BuildFailedError extends Error {
+    failedSteps;
+    constructor(failedSteps) {
+        const stepSummary = failedSteps.length > 0
+            ? failedSteps
+                .map((s) => `Step "${s.name}" failed:${s.content ? `\n${s.content}` : ''}`)
+                .join('\n')
+            : 'No failed steps found. Check validation logs for details.';
+        super(`Build failed\n\n${stepSummary}\n\nFix the issues and retry.`);
+        this.name = 'BuildFailedError';
+        this.failedSteps = failedSteps;
+    }
+}
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /**
  * Resolve an agent identifier to a fully-qualified form.
  *
- * If the identifier already contains `/` or is a UUID, return it verbatim.
- * Otherwise, resolve the default owner and prepend `owner.name/`.
+ * If the identifier already contains `~` or is a UUID, return it verbatim.
+ * Otherwise, resolve the default owner and prepend `owner.name~`.
  */
 export async function resolveAgentRef(client, identifier) {
-    if (identifier.includes('/') || UUID_RE.test(identifier)) {
+    if (identifier.includes('~') || UUID_RE.test(identifier)) {
         return identifier;
     }
+    if (identifier.includes('/')) {
+        return identifier.replace('/', '~');
+    }
     const owner = await resolveOwnerId({ client, interactive: false });
-    return `${owner.name}/${identifier}`;
+    return `${owner.name}~${identifier}`;
 }
 /**
  * Get agent ID from argument or guild.json in current directory
@@ -72,10 +101,7 @@ const REQUIRED_AGENT_FILES = ['agent.ts', 'package.json'];
 export async function readAgentFiles(cwd) {
     const { stdout } = await runGit(['ls-files', '--cached', '--others', '--exclude-standard'], { cwd });
     const gitFiles = stdout.split('\n').filter((f) => f.trim().length > 0);
-    const relevantFiles = gitFiles.filter((f) => {
-        const ext = path.extname(f);
-        return ['.ts', '.json', '.md'].includes(ext);
-    });
+    const relevantFiles = gitFiles.filter((f) => !f.startsWith('.guild/'));
     const files = [];
     for (const filePath of relevantFiles) {
         const fullPath = path.join(cwd, filePath);
@@ -89,4 +115,123 @@ export async function readAgentFiles(cwd) {
     }
     return files;
 }
+const CACHE_DIR = path.join('.guild', 'cache');
+const CACHE_FILE = 'last-ephemeral.json';
+/**
+ * Compute a deterministic hash of agent files.
+ * Sorts by path to ensure consistent ordering.
+ */
+export function hashAgentFiles(files) {
+    const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+    const hash = createHash('sha256');
+    for (const file of sorted) {
+        hash.update(file.path);
+        hash.update('\0');
+        hash.update(file.content);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+async function readEphemeralCache(cwd) {
+    try {
+        const cachePath = path.join(cwd, CACHE_DIR, CACHE_FILE);
+        const raw = await fs.readFile(cachePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.hash === 'string' && typeof parsed.version_id === 'string') {
+            return { hash: parsed.hash, version_id: parsed.version_id };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeEphemeralCache(cwd, cache) {
+    const dir = path.join(cwd, CACHE_DIR);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, CACHE_FILE), JSON.stringify(cache, null, 2) + '\n');
+}
+/**
+ * Get or create an ephemeral version, skipping the build if files haven't
+ * changed since the last successful ephemeral build.
+ *
+ * Returns the version (cached or newly created), a cache hit flag, and the
+ * computed hash (used by buildEphemeralVersion to write the cache on success).
+ */
+export async function getOrCreateEphemeral(client, agentId, files, cwd, summary, options) {
+    const hash = hashAgentFiles(files);
+    if (options?.noCache) {
+        const version = (await client.post(`/agents/${agentId}/versions`, {
+            files,
+            summary,
+            version_type: 'EPHEMERAL',
+        }));
+        return { version, cached: false, hash };
+    }
+    const cache = await readEphemeralCache(cwd);
+    if (cache && cache.hash === hash) {
+        // Verify the cached version still exists on the server
+        try {
+            const version = (await client.get(`/versions/${cache.version_id}`));
+            if (version.validation_status === 'PASSED') {
+                return { version, cached: true, hash };
+            }
+        }
+        catch {
+            // Version gone or inaccessible — fall through to create new one
+        }
+    }
+    const version = (await client.post(`/agents/${agentId}/versions`, {
+        files,
+        summary,
+        version_type: 'EPHEMERAL',
+    }));
+    return { version, cached: false, hash };
+}
+/**
+ * Build an ephemeral version end-to-end: get-or-create, poll for validation,
+ * cache on success, and report build failures.
+ *
+ * Consolidates the build/poll/cache pattern used by both `guild agent test`
+ * and `guild agent chat`.
+ */
+export async function buildEphemeralVersion(client, agentId, files, cwd, summary, options) {
+    const { version: initial, cached, hash, } = await getOrCreateEphemeral(client, agentId, files, cwd, summary, options);
+    if (cached) {
+        return { version: initial, cached: true };
+    }
+    // Poll for validation to complete
+    const pollResult = await pollUntilComplete({
+        resourceId: initial.id,
+        endpoint: `/versions/${initial.id}`,
+        isComplete: (r) => r.validation_status !== 'PENDING' && r.validation_status !== 'RUNNING',
+        message: 'Building...',
+        successMessage: 'Build finished',
+        timeoutMessage: 'Build timed out',
+        maxAttempts: 120,
+        delayMs: 1000,
+    });
+    if (!pollResult.success || !pollResult.response) {
+        throw new BuildTimeoutError();
+    }
+    const version = pollResult.response;
+    // Cache the successful build so we can skip it next time
+    if (version.validation_status === 'PASSED') {
+        await writeEphemeralCache(cwd, { hash, version_id: version.id });
+    }
+    if (version.validation_status === 'FAILED') {
+        let failedSteps = [];
+        try {
+            const stepsResponse = await client.get(`/versions/${version.id}/validation/steps`);
+            failedSteps = stepsResponse.steps
+                .filter((step) => step.status === 'FAILED')
+                .map((step) => ({ name: step.name, content: step.content ?? undefined }));
+        }
+        catch {
+            // Could not fetch validation details — throw with empty steps
+        }
+        throw new BuildFailedError(failedSteps);
+    }
+    return { version, cached: false };
+}
 //# sourceMappingURL=agent-helpers.js.map