@guildai/cli 0.6.2 → 0.7.1

package/dist/commands/setup.js

@@ -11,7 +11,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageRoot = path.resolve(__dirname, '..', '..');
 const docsDir = path.join(packageRoot, 'docs');
-const SKILL_FILES = [
+const CLAUDE_SKILL_FILES = [
     {
         src: path.join(docsDir, 'skills', 'agent-dev.md'),
         dest: path.join('.claude', 'skills', 'agent-dev', 'skill.md'),
@@ -22,6 +22,18 @@ const SKILL_FILES = [
         dest: path.join('.claude', 'skills', 'guild-cli-workflow', 'skill.md'),
         label: '.claude/skills/guild-cli-workflow/skill.md',
     },
+    {
+        src: path.join(docsDir, 'skills', 'integrations.md'),
+        dest: path.join('.claude', 'skills', 'integrations', 'skill.md'),
+        label: '.claude/skills/integrations/skill.md',
+    },
+];
+const CODEX_SKILL_FILES = [
+    {
+        src: path.join(docsDir, 'skills', 'codex-agent-dev.md'),
+        dest: path.join('.agents', 'skills', 'guild-agent-dev', 'SKILL.md'),
+        label: '.agents/skills/guild-agent-dev/SKILL.md',
+    },
 ];
 const CLAUDE_MD_TEMPLATE = `# CLAUDE.md
 
@@ -38,6 +50,22 @@ guild agent save --message "Initial version" --wait --publish
 
 See \`.claude/skills/agent-dev/skill.md\` for SDK reference, patterns, and anti-hallucination guide.
 `;
+const AGENTS_MD_TEMPLATE = `# AGENTS.md
+
+## Guild Agent Development
+
+This project uses Guild for agent development. Codex instructions are installed in \`.agents/skills/guild-agent-dev/SKILL.md\`.
+
+### Quick Start
+
+\`\`\`bash
+guild agent init --name my-agent --template LLM
+guild agent test --ephemeral
+guild agent save -A --message "Initial version"
+\`\`\`
+
+Use \`guild doctor\` to check authentication, server connectivity, workspace selection, and git setup.
+`;
 async function fileExists(filePath) {
     try {
         await fs.access(filePath);
@@ -82,21 +110,29 @@ async function setupMcp(options) {
 }
 async function setup(options) {
     const output = createOutputWriter();
-    // Verify source docs exist
-    const docsExist = await fileExists(path.join(docsDir, 'skills', 'agent-dev.md'));
-    if (!docsExist) {
-        output.error('Could not find Guild CLI docs. Reinstall the CLI: npm install -g @guildai/cli');
+    if (options.agentsMd && !options.codex) {
+        output.error('--agents-md requires --codex', 'Create Codex setup files with:\n  guild setup --codex --agents-md');
+        process.exit(1);
+    }
+    if (options.claudeMd && options.codex) {
+        output.error('--claude-md cannot be used with --codex', 'Create Claude setup with:\n  guild setup --claude-md\n\nCreate Codex setup with:\n  guild setup --codex --agents-md');
         process.exit(1);
     }
+    const skillFiles = options.codex ? CODEX_SKILL_FILES : CLAUDE_SKILL_FILES;
+    // Verify source docs exist
+    for (const file of skillFiles) {
+        if (!(await fileExists(file.src))) {
+            output.error('Could not find Guild CLI docs. Reinstall the CLI: npm install -g @guildai/cli');
+            process.exit(1);
+        }
+    }
     output.progress('Setting up Guild CLI skills...');
     output.progress('');
-    // Ensure .claude/skills/ directory exists
-    const skillsDir = path.join(process.cwd(), '.claude', 'skills');
-    await fs.mkdir(skillsDir, { recursive: true });
     let filesCreated = 0;
     let filesSkipped = 0;
+    let codexProjectFilesChanged = false;
     // Copy skill files
-    for (const file of SKILL_FILES) {
+    for (const file of skillFiles) {
         const destPath = path.join(process.cwd(), file.dest);
         const exists = await fileExists(destPath);
         if (exists && !options.force) {
@@ -113,6 +149,9 @@ async function setup(options) {
                 output.success(`Created ${file.label}`);
             }
             filesCreated++;
+            if (options.codex) {
+                codexProjectFilesChanged = true;
+            }
         }
     }
     // Handle --mcp flag
@@ -139,6 +178,21 @@ async function setup(options) {
             filesCreated++;
         }
     }
+    // Handle AGENTS.md template for Codex setup
+    if (options.agentsMd) {
+        const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
+        const exists = await fileExists(agentsMdPath);
+        if (exists) {
+            output.progress('AGENTS.md already exists (not overwriting)');
+            filesSkipped++;
+        }
+        else {
+            await fs.writeFile(agentsMdPath, AGENTS_MD_TEMPLATE, 'utf-8');
+            output.success('Created AGENTS.md');
+            filesCreated++;
+            codexProjectFilesChanged = true;
+        }
+    }
     // Summary
     output.progress('');
     if (filesCreated > 0 && filesSkipped === 0) {
@@ -155,13 +209,18 @@ async function setup(options) {
     else {
         output.success('Guild CLI skills installed.');
     }
+    if (codexProjectFilesChanged) {
+        output.progress('Restart Codex to pick up the new project instructions.');
+    }
 }
 export function createSetupCommand() {
     const cmd = new Command('setup');
     cmd
-        .description('Set up Guild CLI skills for coding assistants (Claude Code, etc.)')
-        .option('--force', 'Overwrite existing skill files', false)
+        .description('Set up Guild CLI skills for coding assistants (Claude Code, Codex, etc.)')
+        .option('--force', 'Overwrite existing skill files and Guild MCP config', false)
+        .option('--codex', 'Install Codex skill files instead of Claude Code skills', false)
         .option('--claude-md', 'Also create a CLAUDE.md template in the project root', false)
+        .option('--agents-md', 'With --codex, also create an AGENTS.md template in the project root', false)
         .option('--no-mcp', 'Skip MCP server configuration')
         .action(async (options) => {
         await setup(options);

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/index.js

@@ -59,6 +59,7 @@ import { createSessionEventsCommand } from './commands/session/events.js';
 import { createSessionTasksCommand } from './commands/session/tasks.js';
 import { createSessionCreateCommand } from './commands/session/create.js';
 import { createSessionSendCommand } from './commands/session/send.js';
+import { createSessionInterruptCommand } from './commands/session/interrupt.js';
 import { createJobGetCommand } from './commands/job/get.js';
 import { createJobStepGetCommand } from './commands/job/step-get.js';
 import { createConfigListCommand } from './commands/config/list.js';
@@ -276,6 +277,7 @@ sessionCmd.addCommand(createSessionEventsCommand());
 sessionCmd.addCommand(createSessionTasksCommand());
 sessionCmd.addCommand(createSessionCreateCommand());
 sessionCmd.addCommand(createSessionSendCommand());
+sessionCmd.addCommand(createSessionInterruptCommand());
 // Job command group
 const jobCmd = program.command('job').description('Job management');
 jobCmd.addCommand(createJobGetCommand());

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

package/dist/lib/alternate-screen.js

@@ -50,6 +50,8 @@ export function suppressScrollbackClear() {
                 chunk = chunk.replace(CLEAR_TERMINAL, CLEAR_SUBSEQUENT);
             }
         }
+        if (!originalWrite)
+            return false;
         return originalWrite.apply(this, [chunk, ...args]);
     };
     process.stdout.write = patched;

package/dist/lib/api-client.js

@@ -3,7 +3,7 @@
 import axios from 'axios';
 import { getAuthToken, clearAuthToken } from './auth.js';
 import { retry, debug, GuildCLIError, ErrorCodes } from './errors.js';
-import { getGuildcoreUrl } from './config.js';
+import { getUserAgent, getGuildcoreUrl } from './config.js';
 import { getIapHeaders } from './iap.js';
 /**
  * HTTP client for Guild API
@@ -24,6 +24,7 @@ export class GuildAPIClient {
             headers: {
                 'Content-Type': 'application/json',
                 Accept: 'application/json',
+                'User-Agent': getUserAgent(),
             },
         });
         debug(`API Client initialized: ${this.baseUrl}, retry: ${this.enableRetry}, max retries: ${this.maxRetries}`);

package/dist/lib/config.d.ts

@@ -1,3 +1,6 @@
+export declare function getCliVersion(): string;
+export declare function isDevBuild(): boolean;
+export declare function getUserAgent(): string;
 /**
  * IAP (Identity-Aware Proxy) configuration for internal *.guildai.dev hosts.
  * Users must run `gcloud auth login` with an authorized Google account to access.

package/dist/lib/config.js

@@ -1,5 +1,38 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
+import { readFileSync } from 'fs';
+import path from 'path';
+const FALLBACK_VERSION = 'unknown';
+let cachedVersion;
+export function getCliVersion() {
+    if (!cachedVersion) {
+        try {
+            const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf-8'));
+            cachedVersion = pkg.version ?? FALLBACK_VERSION;
+        }
+        catch {
+            cachedVersion = FALLBACK_VERSION;
+        }
+    }
+    return cachedVersion;
+}
+export function isDevBuild() {
+    try {
+        return !__dirname.includes('node_modules');
+    }
+    catch {
+        return false;
+    }
+}
+export function getUserAgent() {
+    try {
+        const base = `GuildCLI/${getCliVersion()}`;
+        return isDevBuild() ? `${base}/dev` : base;
+    }
+    catch {
+        return 'GuildCLI';
+    }
+}
 /**
  * IAP configuration for shared.guildai.dev
  */