@guildai/cli 0.5.13 → 0.6.1

package/dist/lib/auth.js

@@ -10,6 +10,7 @@ import { createSpinner } from './progress.js';
 import { getGuildcoreUrl } from './config.js';
 import { getIapHeaders } from './iap.js';
 import { brand, warn } from './colors.js';
+import { isInteractive } from './stdin.js';
 const SERVICE_NAME = 'guild-cli';
 /**
  * Get account name for keyring, keyed by host to support multiple backends
@@ -137,6 +138,7 @@ export async function startDeviceFlow(authUrl = getGuildcoreUrl(), returnUrl, re
  * @returns Access token if successful, null if failed/expired
  */
 export async function pollForToken(authUrl, code, interval) {
+    const isTTY = process.stderr.isTTY || false;
     const spinner = createSpinner('Waiting for authorization...');
     spinner.start();
     const maxAttempts = 90; // 3 minutes (90 * 2 seconds)
@@ -167,7 +169,9 @@ export async function pollForToken(authUrl, code, interval) {
                 }
                 if (error.response?.data?.error === 'authorization_pending' ||
                     error.response?.data?.error === 'slow_down') {
-                    spinner.text = `Waiting for authorization... (${attempts}/${maxAttempts})`;
+                    if (isTTY) {
+                        spinner.text = `Waiting for authorization... (${attempts}/${maxAttempts})`;
+                    }
                     continue;
                 }
             }
@@ -196,18 +200,18 @@ export function showBetaGuidance() {
  * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
  * @returns true if successful, false otherwise
  */
-export async function login(returnUrl, returnLabel, noBrowser) {
+export async function login(returnUrl, returnLabel, nonInteractive) {
     const authUrl = getGuildcoreUrl();
     try {
         console.log(chalk.bold('\nGuild.ai Authentication'));
         const deviceCode = await startDeviceFlow(authUrl, returnUrl, returnLabel);
-        // Display styled verification code box
-        displayVerificationCode(deviceCode.user_code, deviceCode.verification_uri_complete);
-        const skipBrowser = noBrowser || process.stdin.isTTY !== true;
+        const skipBrowser = nonInteractive || !isInteractive();
         if (skipBrowser) {
-            console.log(chalk.dim('Open the URL above in your browser to complete authentication.'));
+            console.log(`\nVerification code: ${deviceCode.user_code}`);
+            console.log(`Open to authenticate: ${deviceCode.verification_uri_complete}\n`);
         }
         else {
+            displayVerificationCode(deviceCode.user_code, deviceCode.verification_uri_complete);
             // Wait for user to press Enter before opening browser
             // This gives them time to see and copy the code before browser opens
             // Critical for VSCode integration where browser may open full screen

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

@@ -0,0 +1,15 @@
+import { GuildAPIClient } from './api-client.js';
+/**
+ * Resolve a version ID from an integration identifier and optional semver.
+ *
+ * 1. GET /integrations/<identifier> to resolve the integration
+ * 2. GET /integrations/<id>/versions to list versions
+ * 3. If semver provided, find matching version_number; otherwise use latest (first)
+ */
+export declare function resolveVersionId(client: GuildAPIClient, identifier: string, versionNumber?: string): Promise<string>;
+/**
+ * Resolve the latest draft version ID for an integration.
+ * Used by the build command where --version is not applicable (drafts have no semver).
+ */
+export declare function resolveLatestDraftId(client: GuildAPIClient, identifier: string): Promise<string>;
+//# sourceMappingURL=integration-helpers.d.ts.map

package/dist/lib/integration-helpers.js

@@ -0,0 +1,38 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Resolve a version ID from an integration identifier and optional semver.
+ *
+ * 1. GET /integrations/<identifier> to resolve the integration
+ * 2. GET /integrations/<id>/versions to list versions
+ * 3. If semver provided, find matching version_number; otherwise use latest (first)
+ */
+export async function resolveVersionId(client, identifier, versionNumber) {
+    const integration = await client.get(`/integrations/${identifier}`);
+    const versions = await client.get(`/integrations/${integration.id}/versions?limit=100`);
+    if (versions.items.length === 0) {
+        throw new Error('No versions found for this integration');
+    }
+    if (versionNumber) {
+        const match = versions.items.find((v) => v.version_number === versionNumber);
+        if (!match) {
+            throw new Error(`Version ${versionNumber} not found`);
+        }
+        return match.id;
+    }
+    return versions.items[0].id;
+}
+/**
+ * Resolve the latest draft version ID for an integration.
+ * Used by the build command where --version is not applicable (drafts have no semver).
+ */
+export async function resolveLatestDraftId(client, identifier) {
+    const integration = await client.get(`/integrations/${identifier}`);
+    const versions = await client.get(`/integrations/${integration.id}/versions?limit=100`);
+    const draft = versions.items.find((v) => v.version_number === null);
+    if (!draft) {
+        throw new Error('No draft version found for this integration');
+    }
+    return draft.id;
+}
+//# sourceMappingURL=integration-helpers.js.map

package/dist/lib/output.d.ts

@@ -1,10 +1,20 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Container, ContainerEvent, ContainerImageListItem, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
  */
 export declare function formatAgentTable(agents: Agent[], pagination: Pagination): void;
+/**
+ * Format an integration list as a human-readable table.
+ * Used by integration list command.
+ */
+export declare function formatIntegrationTable(integrations: Integration[], pagination: Pagination): void;
+/**
+ * Format an integration version list as a human-readable table.
+ * Used by integration version list command.
+ */
+export declare function formatIntegrationVersionTable(versions: IntegrationVersion[], pagination: Pagination, integrationName: string): void;
 /**
  * Format an agent version list as a human-readable table.
  * Used by agent versions command.
@@ -35,21 +45,8 @@ export declare function formatSessionTable(sessions: Session[], pagination: Pagi
  * Used by trigger list command.
  */
 export declare function formatTriggerTable(triggers: Trigger[], pagination: Pagination): void;
-/**
- * Format a container list as a human-readable table.
- * Used by container list command.
- */
-export declare function formatContainerTable(containers: Container[], pagination: Pagination): void;
-/**
- * Format a container image list as a human-readable table.
- * Used by container-image list command.
- */
-export declare function formatContainerImageTable(images: ContainerImageListItem[], pagination: Pagination): void;
-/**
- * Format a container event list as a human-readable table.
- * Used by container events command.
- */
-export declare function formatContainerEventTable(events: ContainerEvent[], pagination: Pagination): void;
+export declare function formatCredentialsTable(credentials: Credentials[], pagination: Pagination): void;
+export declare function formatPoliciesTable(policies: CredentialsPolicy[], pagination: Pagination): void;
 /**
  * Format job steps as a human-readable table.
  * Used by job get command.

package/dist/lib/output.js

@@ -81,6 +81,100 @@ export function formatAgentTable(agents, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} agents`));
     }
 }
+/**
+ * Format an integration list as a human-readable table.
+ * Used by integration list command.
+ */
+export function formatIntegrationTable(integrations, pagination) {
+    if (integrations.length === 0) {
+        console.log(chalk.dim('No integrations found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'name', title: 'NAME', alignment: 'left' },
+            { name: 'description', title: 'DESCRIPTION', alignment: 'left' },
+            { name: 'visibility', title: 'VISIBILITY', alignment: 'left' },
+            { name: 'owner', title: 'OWNER', alignment: 'left', color: 'cyan' },
+            { name: 'updated', title: 'UPDATED', alignment: 'left' },
+        ],
+    });
+    integrations.forEach((integration) => {
+        table.addRow({
+            name: integration.name,
+            description: truncate(integration.description || '', 40),
+            visibility: integration.is_public ? 'public' : 'internal',
+            owner: integration.owner?.name || '',
+            updated: integration.updated_at ? formatRelativeTime(integration.updated_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, integrations.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} integrations. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} integrations`));
+    }
+}
+/**
+ * Format an integration version list as a human-readable table.
+ * Used by integration version list command.
+ */
+export function formatIntegrationVersionTable(versions, pagination, integrationName) {
+    if (versions.length === 0) {
+        console.log(chalk.dim('No versions found'));
+        return;
+    }
+    console.log(chalk.bold(`Versions for ${integrationName}`));
+    console.log();
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'version', title: 'VERSION', alignment: 'left' },
+            { name: 'author', title: 'AUTHOR', alignment: 'left', color: 'cyan' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'published', title: 'PUBLISHED', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    versions.forEach((v) => {
+        let statusLabel;
+        switch (v.validation_status) {
+            case 'PASSED':
+                statusLabel = chalk.green('Valid');
+                break;
+            case 'FAILED':
+                statusLabel = chalk.red('Failed');
+                break;
+            case 'RUNNING':
+                statusLabel = chalk.yellow('Building');
+                break;
+            default:
+                statusLabel = chalk.dim('—');
+        }
+        table.addRow({
+            id: v.id,
+            version: v.version_number || 'Draft',
+            author: v.author?.name || '',
+            status: statusLabel,
+            published: v.published_at ? formatRelativeTime(v.published_at) : chalk.dim('—'),
+            created: v.created_at ? formatRelativeTime(v.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, versions.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} versions. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} versions`));
+    }
+}
 /**
  * Format an agent version list as a human-readable table.
  * Used by agent versions command.
@@ -313,151 +407,85 @@ export function formatTriggerTable(triggers, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} triggers`));
     }
 }
-/**
- * Format a container list as a human-readable table.
- * Used by container list command.
- */
-export function formatContainerTable(containers, pagination) {
-    if (containers.length === 0) {
-        console.log(chalk.dim('No containers found'));
+export function formatCredentialsTable(credentials, pagination) {
+    if (credentials.length === 0) {
+        console.log(chalk.dim('No credentials found'));
         return;
     }
     const table = new Table({
         columns: [
             { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'status', title: 'STATUS', alignment: 'left' },
-            { name: 'image', title: 'IMAGE', alignment: 'left' },
-            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'integration', title: 'INTEGRATION', alignment: 'left' },
+            { name: 'creator', title: 'CREATOR', alignment: 'left', color: 'cyan' },
             { name: 'created', title: 'CREATED', alignment: 'left' },
         ],
     });
-    containers.forEach((container) => {
-        const statusColor = container.status === 'RUNNING'
-            ? chalk.green
-            : container.status === 'ERRORED'
-                ? chalk.red
-                : container.status === 'DESTROYED'
-                    ? chalk.dim
-                    : chalk.yellow;
-        table.addRow({
-            id: container.id,
-            status: statusColor(container.status),
-            image: container.image?.name || '-',
-            tag: container.image?.tag || '-',
-            created: container.created_at ? formatRelativeTime(container.created_at) : '',
-        });
-    });
-    table.printTable();
-    const showing = Math.min(pagination.limit, containers.length);
-    if (pagination.has_more) {
-        const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} containers. ` +
-            chalk.dim(`Use --offset ${nextOffset} to see more.`));
-    }
-    else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} containers`));
-    }
-}
-/**
- * Format a container image list as a human-readable table.
- * Used by container-image list command.
- */
-export function formatContainerImageTable(images, pagination) {
-    if (images.length === 0) {
-        console.log(chalk.dim('No container images found'));
-        return;
-    }
-    const table = new Table({
-        columns: [
-            { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'name', title: 'NAME', alignment: 'left' },
-            { name: 'image', title: 'IMAGE', alignment: 'left' },
-            { name: 'tag', title: 'TAG', alignment: 'left' },
-            { name: 'public', title: 'PUBLIC', alignment: 'left' },
-        ],
-    });
-    images.forEach((image) => {
+    credentials.forEach((cred) => {
         table.addRow({
-            id: image.id,
-            name: image.name,
-            image: image.image_name,
-            tag: image.tag,
-            public: image.is_public ? chalk.green('yes') : chalk.dim('no'),
+            id: cred.id,
+            integration: cred.integration.full_name,
+            creator: cred.creator.name,
+            created: formatRelativeTime(cred.created_at),
         });
     });
     table.printTable();
-    const showing = Math.min(pagination.limit, images.length);
+    const showing = Math.min(pagination.limit, credentials.length);
     if (pagination.has_more) {
         const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} images. ` +
+        console.log(`\nShowing ${showing} of ${pagination.total_count} credentials. ` +
             chalk.dim(`Use --offset ${nextOffset} to see more.`));
     }
     else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} images`));
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} credentials`));
     }
 }
-/**
- * Derive a human-readable event type label from entity_type.
- */
-function formatEventType(entityType) {
-    if (entityType === 'EntContainerEventCreate')
-        return 'create';
-    if (entityType === 'EntContainerEventDestroy')
-        return 'destroy';
-    if (entityType === 'EntContainerEventCommand')
-        return 'command';
-    return entityType;
-}
-/**
- * Format a container event list as a human-readable table.
- * Used by container events command.
- */
-export function formatContainerEventTable(events, pagination) {
-    if (events.length === 0) {
-        console.log(chalk.dim('No events found'));
+export function formatPoliciesTable(policies, pagination) {
+    if (policies.length === 0) {
+        console.log(chalk.dim('No policies found'));
         return;
     }
     const table = new Table({
         columns: [
             { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'type', title: 'TYPE', alignment: 'left', color: 'cyan' },
-            { name: 'status', title: 'STATUS', alignment: 'left' },
-            { name: 'actor', title: 'ACTOR', alignment: 'left' },
-            { name: 'detail', title: 'DETAIL', alignment: 'left' },
+            { name: 'decision', title: 'DECISION', alignment: 'left' },
+            { name: 'operations', title: 'OPERATIONS', alignment: 'left' },
+            { name: 'workspaces', title: 'WORKSPACES', alignment: 'left' },
+            { name: 'agents', title: 'AGENTS', alignment: 'left' },
+            { name: 'resources', title: 'RESOURCES', alignment: 'left' },
             { name: 'created', title: 'CREATED', alignment: 'left' },
         ],
     });
-    events.forEach((event) => {
-        const statusColor = event.status === 'SUCCESS'
-            ? chalk.green
-            : event.status === 'ERROR'
-                ? chalk.red
-                : chalk.yellow;
-        let detail = '';
-        if (event.entity_type === 'EntContainerEventCommand') {
-            detail = truncate(event.command, 30);
-        }
-        else if (event.status === 'ERROR' && event.error) {
-            detail = truncate(event.error, 30);
-        }
+    policies.forEach((policy) => {
+        const decisionColor = policy.decision === 'ALLOW' ? chalk.green : chalk.red;
         table.addRow({
-            id: event.id,
-            type: formatEventType(event.entity_type),
-            status: statusColor(event.status),
-            actor: event.actor?.name || event.actor?.full_name || '-',
-            detail,
-            created: event.created_at ? formatRelativeTime(event.created_at) : '',
+            id: policy.id,
+            decision: decisionColor(policy.decision),
+            operations: policy.operations
+                ? truncate(policy.operations.join(', '), 30)
+                : chalk.dim('all'),
+            workspaces: policy.workspaces.length > 0
+                ? truncate(policy.workspaces.map((w) => w.full_name || w.name).join(', '), 20)
+                : chalk.dim('all'),
+            agents: policy.agents.length > 0
+                ? truncate(policy.agents.map((a) => a.full_name || a.name).join(', '), 20)
+                : chalk.dim('all'),
+            resources: policy.resources
+                ? truncate(Object.entries(policy.resources)
+                    .map(([k, v]) => `${k}: ${v.join(', ')}`)
+                    .join('; '), 30)
+                : chalk.dim('none'),
+            created: formatRelativeTime(policy.created_at),
         });
     });
     table.printTable();
-    const showing = Math.min(pagination.limit, events.length);
+    const showing = Math.min(pagination.limit, policies.length);
     if (pagination.has_more) {
         const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} events. ` +
+        console.log(`\nShowing ${showing} of ${pagination.total_count} policies. ` +
             chalk.dim(`Use --offset ${nextOffset} to see more.`));
     }
     else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} events`));
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} policies`));
     }
 }
 /**

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

@@ -0,0 +1,27 @@
+/**
+ * Shared event/task fetching for session polling.
+ *
+ * Consolidates the duplicate response parsing that was scattered across
+ * chat.tsx, session-polling.ts, and session-resume.ts.
+ */
+import { GuildAPIClient } from './api-client.js';
+import { SessionEvent, SessionTask } from './session-events.js';
+interface FetchOptions {
+    /** Only return events after this event ID (server-side cursor). */
+    fromId?: string;
+    /** Maximum number of events to return. Default 1000. */
+    limit?: number;
+}
+/**
+ * Fetch session events from the API.
+ *
+ * Uses from_id cursor so callers only fetch new events
+ * instead of re-fetching everything on every poll cycle.
+ */
+export declare function fetchEvents(client: GuildAPIClient, sessionId: string, options?: FetchOptions): Promise<SessionEvent[]>;
+/**
+ * Fetch session tasks from the API.
+ */
+export declare function fetchTasks(client: GuildAPIClient, sessionId: string): Promise<SessionTask[]>;
+export {};
+//# sourceMappingURL=session-events-fetch.d.ts.map

package/dist/lib/session-events-fetch.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Fetch session events from the API.
+ *
+ * Uses from_id cursor so callers only fetch new events
+ * instead of re-fetching everything on every poll cycle.
+ */
+export async function fetchEvents(client, sessionId, options = {}) {
+    const { fromId, limit = 1000 } = options;
+    let url = `/sessions/${sessionId}/events?limit=${limit}`;
+    if (fromId) {
+        url += `&from_id=${fromId}`;
+    }
+    const response = await client.get(url);
+    return response?.items || [];
+}
+/**
+ * Fetch session tasks from the API.
+ */
+export async function fetchTasks(client, sessionId) {
+    const response = await client.get(`/sessions/${sessionId}/tasks?limit=1000`);
+    return response?.items || [];
+}
+//# sourceMappingURL=session-events-fetch.js.map

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

@@ -1,6 +1,11 @@
 import { GuildAPIClient } from './api-client.js';
+export interface PollResult {
+    response: string | null;
+    /** Last event ID seen — pass as `afterEventId` on next call. */
+    lastEventId: string | undefined;
+}
 /**
- * Poll for agent response after a certain event count.
+ * Poll for agent response using from_id cursor.
  *
  * Handles both multi-turn agents (which emit agent_notification_message)
  * and one-shot agents (which may only emit runtime_done with output content).
@@ -10,5 +15,5 @@ import { GuildAPIClient } from './api-client.js';
  * 2. runtime_done from agent tasks — fallback for one-shot agents
  * 3. runtime_error from agent tasks — fail fast
  */
-export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventCount: number, maxWaitTime?: number): Promise<string | null>;
+export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventId: string | undefined, maxWaitTime?: number): Promise<PollResult>;
 //# sourceMappingURL=session-polling.d.ts.map

package/dist/lib/session-polling.js

@@ -1,8 +1,9 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
-import { isDebugMode } from './errors.js';
+import { debug, isDebugMode } from './errors.js';
+import { fetchEvents } from './session-events-fetch.js';
 /**
- * Poll for agent response after a certain event count.
+ * Poll for agent response using from_id cursor.
  *
  * Handles both multi-turn agents (which emit agent_notification_message)
  * and one-shot agents (which may only emit runtime_done with output content).
@@ -12,16 +13,16 @@ import { isDebugMode } from './errors.js';
  * 2. runtime_done from agent tasks — fallback for one-shot agents
  * 3. runtime_error from agent tasks — fail fast
  */
-export async function pollForResponse(client, sessionId, afterEventCount, maxWaitTime = 60000) {
+export async function pollForResponse(client, sessionId, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
+    let fromId = afterEventId;
     while (Date.now() - startTime < maxWaitTime) {
-        const response = await client.get(`/sessions/${sessionId}/events?limit=1000`);
-        const events = response?.items || [];
+        const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
-        for (let i = afterEventCount; i < events.length; i++) {
-            const event = events[i];
+        for (const event of events) {
+            debug(`pollForResponse event: ${event.type}`);
             if (event.type === 'agent_notification_message') {
-                return event.content.data;
+                return { response: event.content.data, lastEventId: event.id };
             }
             if (event.type === 'runtime_done' &&
                 event.content !== undefined &&
@@ -30,17 +31,23 @@ export async function pollForResponse(client, sessionId, afterEventCount, maxWai
                 lastAgentRuntimeDone = JSON.stringify(event.content);
             }
             if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
-                return JSON.stringify({ error: event.content });
+                return {
+                    response: JSON.stringify({ error: event.content }),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'agent_console' && isDebugMode()) {
                 process.stderr.write(`[console.${event.level}] ${event.content}\n`);
             }
         }
+        if (events.length > 0) {
+            fromId = events[events.length - 1].id;
+        }
         if (lastAgentRuntimeDone !== null) {
-            return lastAgentRuntimeDone;
+            return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
         await new Promise((resolve) => setTimeout(resolve, 500));
     }
-    return null;
+    return { 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 { fetchEvents } from './session-events-fetch.js';
 import { brand, code as codeColor } from './colors.js';
 // Configure marked for terminal rendering (same config as chat.tsx)
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -37,11 +38,7 @@ export function printResumeHint(sessionId, command) {
  * Fetch all events for a session from the API.
  */
 export async function fetchSessionEvents(client, sessionId) {
-    const response = await client.get(`/sessions/${sessionId}/events?limit=1000`);
-    const events = (Array.isArray(response)
-        ? response
-        : response?.items || []);
-    return events;
+    return fetchEvents(client, sessionId);
 }
 /**
  * Fetch an existing session by ID.

package/dist/lib/table.d.ts

@@ -6,7 +6,6 @@ interface ColumnConfig {
 }
 /**
  * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
- * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
  */
 export declare class Table {
     private columns;

package/dist/lib/table.js

@@ -4,7 +4,6 @@ import chalk from 'chalk';
 import stringWidth from 'string-width';
 /**
  * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
- * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
  */
 export class Table {
     columns;