@workflow/cli 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/lib/inspect/output.test.js

@@ -1,5 +1,6 @@
-import { describe, expect, it } from 'vitest';
-import { formatTableValue, hasExpiredData } from './output.js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getObservabilityUpgradeRequiredMessage, isObservabilityUpgradeRequiredError, } from './errors.js';
+import { formatTableValue, hasExpiredData, listEvents, listRuns, listSleeps, listSteps, } from './output.js';
 const makeRun = (overrides = {}) => ({
     runId: 'run-1',
     status: 'running',
@@ -17,6 +18,9 @@ const makeRun = (overrides = {}) => ({
     executionContext: {},
     ...overrides,
 });
+afterEach(() => {
+    vi.restoreAllMocks();
+});
 describe('hasExpiredData', () => {
     it('returns false when expiredAt is undefined', () => {
         expect(hasExpiredData(makeRun({ expiredAt: undefined }))).toBe(false);
@@ -49,4 +53,660 @@ describe('formatTableValue expired data handling', () => {
         expect(String(result)).not.toContain('expired');
     });
 });
-//# sourceMappingURL=output.test.js.map
+describe('isObservabilityUpgradeRequiredError', () => {
+    it('detects workflow analytics 402 errors by top-level code', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 402,
+            code: 'observability-upgrade-required',
+        })).toBe(true);
+    });
+    it('detects workflow analytics 402 errors by response body error', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 402,
+            body: { error: 'observability-upgrade-required' },
+        })).toBe(true);
+    });
+    it('does not treat 404s as upgrade prompts', () => {
+        expect(isObservabilityUpgradeRequiredError({
+            status: 404,
+            code: 'observability-upgrade-required',
+        })).toBe(false);
+    });
+    it('uses an upgrade prompt message', () => {
+        expect(getObservabilityUpgradeRequiredMessage()).toContain('Upgrade Observability Plus');
+    });
+});
+describe('listRuns', () => {
+    it('preserves analytics page metadata in JSON output', async () => {
+        const run = {
+            runId: 'run-1',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const pageInfo = {
+            currentLookbackDays: 2,
+            maxLookbackDays: 30,
+            currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),
+            maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),
+            upgradeAvailable: true,
+        };
+        const world = {
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        expect(world.analytics?.runs.list).toHaveBeenCalledWith({
+            workflowName: undefined,
+            status: undefined,
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+        });
+        expect(write).toHaveBeenCalledTimes(1);
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual({
+            data: [
+                {
+                    ...run,
+                    createdAt: '2026-06-30T00:00:00.000Z',
+                    updatedAt: '2026-06-30T00:00:00.000Z',
+                    startedAt: '2026-06-30T00:00:01.000Z',
+                },
+            ],
+            cursor: null,
+            hasMore: false,
+            pageInfo: {
+                currentLookbackDays: 2,
+                maxLookbackDays: 30,
+                currentWindowStart: '2026-06-28T00:00:00.000Z',
+                maxWindowStart: '2026-06-01T00:00:00.000Z',
+                upgradeAvailable: true,
+            },
+        });
+    });
+    it('includes world-specific fields when the world defines describeRun', async () => {
+        const run = {
+            runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const describeRun = vi.fn().mockReturnValue({ region: 'sfo1', shard: 'a' });
+        const world = {
+            describeRun,
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        expect(describeRun).toHaveBeenCalledWith(expect.objectContaining({ runId: run.runId }));
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect(output.data[0].region).toBe('sfo1');
+        expect(output.data[0].shard).toBe('a');
+    });
+    it('preserves null field values from describeRun in JSON output', async () => {
+        // null means "applicable but undeterminable" — distinguishable from
+        // the hook being absent (key missing entirely).
+        const run = {
+            runId: 'wrun_malformed',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            describeRun: vi.fn().mockReturnValue({ region: null }),
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect('region' in output.data[0]).toBe(true);
+        expect(output.data[0].region).toBeNull();
+    });
+    it('never lets describeRun overwrite canonical run fields', async () => {
+        const run = {
+            runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            // Hostile/buggy world: tries to clobber canonical fields.
+            describeRun: vi
+                .fn()
+                .mockReturnValue({ status: 'hacked', runId: 'nope', region: 'sfo1' }),
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect(output.data[0].status).toBe('running');
+        expect(output.data[0].runId).toBe(run.runId);
+        expect(output.data[0].region).toBe('sfo1');
+    });
+    it('treats a throwing describeRun as contributing no fields', async () => {
+        const run = {
+            runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            describeRun: vi.fn().mockImplementation(() => {
+                throw new Error('buggy world');
+            }),
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        // Must not throw despite the world violating the no-throw contract.
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect(output.data[0].status).toBe('running');
+        expect('region' in output.data[0]).toBe(false);
+    });
+    it('supports async describeRun implementations', async () => {
+        const run = {
+            runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            describeRun: vi.fn().mockResolvedValue({ region: 'sfo1' }),
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect(output.data[0].region).toBe('sfo1');
+    });
+    it('treats a rejecting async describeRun as contributing no fields', async () => {
+        const run = {
+            runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            describeRun: vi.fn().mockRejectedValue(new Error('async buggy world')),
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect(output.data[0].status).toBe('running');
+        expect('region' in output.data[0]).toBe(false);
+    });
+    it('adds no world fields when the world lacks describeRun', async () => {
+        const run = {
+            runId: 'wrun_01KX2M5N3RBNC12RYWYYH4WWQJ',
+            status: 'running',
+            deploymentId: 'dep-1',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            specVersion: 2,
+            attributes: {},
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            analytics: {
+                runs: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [run],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listRuns(world, { json: true });
+        const output = JSON.parse(String(write.mock.calls[0][0]));
+        expect('region' in output.data[0]).toBe(false);
+    });
+});
+describe('listSteps', () => {
+    it('passes cursors and preserves the JSON array output', async () => {
+        const step = {
+            runId: 'run-1',
+            stepId: 'step-1',
+            stepName: 'doWork',
+            status: 'completed',
+            attempt: 1,
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:02.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: new Date('2026-06-30T00:00:02.000Z'),
+            retryAfter: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            analytics: {
+                steps: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [step],
+                        cursor: 'next-step-cursor',
+                        hasMore: true,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSteps(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'step-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.steps.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'step-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...step,
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:02.000Z',
+                startedAt: '2026-06-30T00:00:01.000Z',
+                completedAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+    it('falls back to storage when the first analytics page is empty', async () => {
+        const step = {
+            runId: 'run-1',
+            stepId: 'step-1',
+            stepName: 'step//./src/workflows/test//doWork',
+            status: 'completed',
+            attempt: 1,
+            input: undefined,
+            output: undefined,
+            createdAt: new Date('2026-06-30T00:00:00.000Z'),
+            updatedAt: new Date('2026-06-30T00:00:02.000Z'),
+            startedAt: new Date('2026-06-30T00:00:01.000Z'),
+            completedAt: new Date('2026-06-30T00:00:02.000Z'),
+        };
+        const world = {
+            analytics: {
+                steps: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+            steps: {
+                list: vi.fn().mockResolvedValue({
+                    data: [step],
+                    cursor: null,
+                    hasMore: false,
+                }),
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSteps(world, { json: true, runId: 'run-1' });
+        expect(world.analytics?.steps.list).toHaveBeenCalled();
+        expect(world.steps.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+            resolveData: 'none',
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...step,
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:02.000Z',
+                startedAt: '2026-06-30T00:00:01.000Z',
+                completedAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+});
+describe('listEvents', () => {
+    it('passes cursors and preserves the JSON array output', async () => {
+        const event = {
+            runId: 'run-1',
+            eventId: 'event-1',
+            eventType: 'step_completed',
+            correlationId: 'step-1',
+            entityId: 'step-1',
+            stepName: 'doWork',
+            workflowName: 'workflow//./src/workflows/test//myWorkflow',
+            deploymentId: 'dep-1',
+            specVersion: 2,
+            runCreatedAt: new Date('2026-06-30T00:00:00.000Z'),
+            createdAt: new Date('2026-06-30T00:00:02.000Z'),
+            region: null,
+            vercelId: null,
+            requestId: null,
+            resumeAt: null,
+            retryAfter: null,
+            errorCode: null,
+            workflowCoreVersion: null,
+            isWebhook: false,
+            isSystem: false,
+            workflowEncryptionEnabled: false,
+        };
+        const world = {
+            analytics: {
+                events: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [event],
+                        cursor: 'next-event-cursor',
+                        hasMore: true,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listEvents(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'event-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.events.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            correlationId: undefined,
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'event-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...event,
+                runCreatedAt: '2026-06-30T00:00:00.000Z',
+                createdAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+    it('falls back to storage when the first analytics page is empty', async () => {
+        const event = {
+            runId: 'run-1',
+            eventId: 'event-1',
+            eventType: 'step_completed',
+            correlationId: 'step-1',
+            eventData: {
+                stepName: 'doWork',
+                result: undefined,
+            },
+            createdAt: new Date('2026-06-30T00:00:02.000Z'),
+        };
+        const world = {
+            analytics: {
+                events: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [],
+                        cursor: null,
+                        hasMore: false,
+                    }),
+                },
+            },
+            events: {
+                list: vi.fn().mockResolvedValue({
+                    data: [event],
+                    cursor: null,
+                    hasMore: false,
+                }),
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listEvents(world, { json: true, runId: 'run-1' });
+        expect(world.analytics?.events.list).toHaveBeenCalled();
+        expect(world.events.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: undefined,
+                limit: 20,
+            },
+            resolveData: 'none',
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...event,
+                createdAt: '2026-06-30T00:00:02.000Z',
+            },
+        ]);
+    });
+});
+describe('listSleeps', () => {
+    const wait = {
+        runId: 'run-1',
+        waitId: 'wait-1',
+        status: 'waiting',
+        resumeAt: new Date('2026-06-30T00:01:00.000Z'),
+        createdAt: new Date('2026-06-30T00:00:00.000Z'),
+        updatedAt: new Date('2026-06-30T00:00:00.000Z'),
+        completedAt: null,
+        workflowCoreVersion: null,
+        workflowEncryptionEnabled: false,
+    };
+    const pageInfo = {
+        currentLookbackDays: 2,
+        maxLookbackDays: 30,
+        currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),
+        maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),
+        upgradeAvailable: true,
+    };
+    it('passes cursors and preserves the JSON array output through analytics', async () => {
+        const world = {
+            analytics: {
+                waits: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [wait],
+                        cursor: 'next-wait-cursor',
+                        hasMore: true,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const write = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+        await listSleeps(world, {
+            json: true,
+            runId: 'run-1',
+            cursor: 'wait-cursor',
+            limit: 1,
+        });
+        expect(world.analytics?.waits.list).toHaveBeenCalledWith({
+            runId: 'run-1',
+            pagination: {
+                sortOrder: 'desc',
+                cursor: 'wait-cursor',
+                limit: 1,
+            },
+        });
+        expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([
+            {
+                ...wait,
+                resumeAt: '2026-06-30T00:01:00.000Z',
+                createdAt: '2026-06-30T00:00:00.000Z',
+                updatedAt: '2026-06-30T00:00:00.000Z',
+            },
+        ]);
+    });
+    it('surfaces the observability upgrade hint in table mode', async () => {
+        const world = {
+            analytics: {
+                waits: {
+                    list: vi.fn().mockResolvedValue({
+                        data: [wait],
+                        cursor: null,
+                        hasMore: false,
+                        pageInfo,
+                    }),
+                },
+            },
+        };
+        const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        await listSleeps(world, { runId: 'run-1' });
+        expect(log.mock.calls.flat().join('\n')).toContain('Upgrade Observability Plus');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output.test.js","sourceRoot":"","sources":["../../../src/lib/inspect/output.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AnalyticsEvent,\n  AnalyticsRun,\n  AnalyticsStep,\n  AnalyticsWait,\n  Event,\n  Step,\n  WorkflowRun,\n  World,\n} from '@workflow/world';\nimport { afterEach, describe, expect, it, vi } from 'vitest';\nimport {\n  getObservabilityUpgradeRequiredMessage,\n  isObservabilityUpgradeRequiredError,\n} from './errors.js';\nimport {\n  formatTableValue,\n  hasExpiredData,\n  listEvents,\n  listRuns,\n  listSleeps,\n  listSteps,\n} from './output.js';\n\nconst makeRun = (overrides: Partial<WorkflowRun> = {}): WorkflowRun =>\n  ({\n    runId: 'run-1',\n    status: 'running',\n    deploymentId: 'dep-1',\n    workflowName: 'workflow//./src/workflows/test//myWorkflow',\n    input: undefined,\n    output: undefined,\n    error: undefined,\n    createdAt: new Date('2025-01-01'),\n    updatedAt: new Date('2025-01-01'),\n    completedAt: undefined,\n    startedAt: undefined,\n    expiredAt: undefined,\n    specVersion: 2,\n    executionContext: {},\n    ...overrides,\n  }) as unknown as WorkflowRun;\n\nafterEach(() => {\n  vi.restoreAllMocks();\n});\n\ndescribe('hasExpiredData', () => {\n  it('returns false when expiredAt is undefined', () => {\n    expect(hasExpiredData(makeRun({ expiredAt: undefined }))).toBe(false);\n  });\n\n  it('returns false when expiredAt is in the future', () => {\n    const future = new Date(Date.now() + 24 * 60 * 60 * 1000);\n    expect(hasExpiredData(makeRun({ expiredAt: future }))).toBe(false);\n  });\n\n  it('returns true when expiredAt is in the past', () => {\n    const past = new Date(Date.now() - 24 * 60 * 60 * 1000);\n    expect(hasExpiredData(makeRun({ expiredAt: past }))).toBe(true);\n  });\n});\n\ndescribe('formatTableValue expired data handling', () => {\n  it('returns input value when expiredAt is in the future', () => {\n    const future = new Date(Date.now() + 24 * 60 * 60 * 1000);\n    const item = { expiredAt: future.toISOString(), input: 'hello' };\n    const result = formatTableValue('input', 'hello', {}, undefined, item);\n    expect(result).not.toContain('expired');\n  });\n\n  it('returns expired message when expiredAt is in the past', () => {\n    const past = new Date(Date.now() - 24 * 60 * 60 * 1000);\n    const item = { expiredAt: past.toISOString(), output: 'hello' };\n    const result = formatTableValue('output', 'hello', {}, undefined, item);\n    expect(String(result)).toContain('data expired');\n  });\n\n  it('returns input value when expiredAt is not present', () => {\n    const item = { input: 'hello' };\n    const result = formatTableValue('input', 'hello', {}, undefined, item);\n    expect(String(result)).not.toContain('expired');\n  });\n});\n\ndescribe('isObservabilityUpgradeRequiredError', () => {\n  it('detects workflow analytics 402 errors by top-level code', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 402,\n        code: 'observability-upgrade-required',\n      })\n    ).toBe(true);\n  });\n\n  it('detects workflow analytics 402 errors by response body error', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 402,\n        body: { error: 'observability-upgrade-required' },\n      })\n    ).toBe(true);\n  });\n\n  it('does not treat 404s as upgrade prompts', () => {\n    expect(\n      isObservabilityUpgradeRequiredError({\n        status: 404,\n        code: 'observability-upgrade-required',\n      })\n    ).toBe(false);\n  });\n\n  it('uses an upgrade prompt message', () => {\n    expect(getObservabilityUpgradeRequiredMessage()).toContain(\n      'Upgrade Observability Plus'\n    );\n  });\n});\n\ndescribe('listRuns', () => {\n  it('preserves analytics page metadata in JSON output', async () => {\n    const run = {\n      runId: 'run-1',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const pageInfo = {\n      currentLookbackDays: 2,\n      maxLookbackDays: 30,\n      currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),\n      maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),\n      upgradeAvailable: true,\n    };\n    const world = {\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    expect(world.analytics?.runs.list).toHaveBeenCalledWith({\n      workflowName: undefined,\n      status: undefined,\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n    });\n    expect(write).toHaveBeenCalledTimes(1);\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual({\n      data: [\n        {\n          ...run,\n          createdAt: '2026-06-30T00:00:00.000Z',\n          updatedAt: '2026-06-30T00:00:00.000Z',\n          startedAt: '2026-06-30T00:00:01.000Z',\n        },\n      ],\n      cursor: null,\n      hasMore: false,\n      pageInfo: {\n        currentLookbackDays: 2,\n        maxLookbackDays: 30,\n        currentWindowStart: '2026-06-28T00:00:00.000Z',\n        maxWindowStart: '2026-06-01T00:00:00.000Z',\n        upgradeAvailable: true,\n      },\n    });\n  });\n\n  it('includes world-specific fields when the world defines describeRun', async () => {\n    const run = {\n      runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const describeRun = vi.fn().mockReturnValue({ region: 'sfo1', shard: 'a' });\n    const world = {\n      describeRun,\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    expect(describeRun).toHaveBeenCalledWith(\n      expect.objectContaining({ runId: run.runId })\n    );\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect(output.data[0].region).toBe('sfo1');\n    expect(output.data[0].shard).toBe('a');\n  });\n\n  it('preserves null field values from describeRun in JSON output', async () => {\n    // null means \"applicable but undeterminable\" — distinguishable from\n    // the hook being absent (key missing entirely).\n    const run = {\n      runId: 'wrun_malformed',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      describeRun: vi.fn().mockReturnValue({ region: null }),\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect('region' in output.data[0]).toBe(true);\n    expect(output.data[0].region).toBeNull();\n  });\n\n  it('never lets describeRun overwrite canonical run fields', async () => {\n    const run = {\n      runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      // Hostile/buggy world: tries to clobber canonical fields.\n      describeRun: vi\n        .fn()\n        .mockReturnValue({ status: 'hacked', runId: 'nope', region: 'sfo1' }),\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect(output.data[0].status).toBe('running');\n    expect(output.data[0].runId).toBe(run.runId);\n    expect(output.data[0].region).toBe('sfo1');\n  });\n\n  it('treats a throwing describeRun as contributing no fields', async () => {\n    const run = {\n      runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      describeRun: vi.fn().mockImplementation(() => {\n        throw new Error('buggy world');\n      }),\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    // Must not throw despite the world violating the no-throw contract.\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect(output.data[0].status).toBe('running');\n    expect('region' in output.data[0]).toBe(false);\n  });\n\n  it('supports async describeRun implementations', async () => {\n    const run = {\n      runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      describeRun: vi.fn().mockResolvedValue({ region: 'sfo1' }),\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect(output.data[0].region).toBe('sfo1');\n  });\n\n  it('treats a rejecting async describeRun as contributing no fields', async () => {\n    const run = {\n      runId: 'wrun_41KX206BTK10M0C31CMN2AS1JS',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      describeRun: vi.fn().mockRejectedValue(new Error('async buggy world')),\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect(output.data[0].status).toBe('running');\n    expect('region' in output.data[0]).toBe(false);\n  });\n\n  it('adds no world fields when the world lacks describeRun', async () => {\n    const run = {\n      runId: 'wrun_01KX2M5N3RBNC12RYWYYH4WWQJ',\n      status: 'running',\n      deploymentId: 'dep-1',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      specVersion: 2,\n      attributes: {},\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsRun;\n    const world = {\n      analytics: {\n        runs: {\n          list: vi.fn().mockResolvedValue({\n            data: [run],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listRuns(world, { json: true });\n\n    const output = JSON.parse(String(write.mock.calls[0][0]));\n    expect('region' in output.data[0]).toBe(false);\n  });\n});\n\ndescribe('listSteps', () => {\n  it('passes cursors and preserves the JSON array output', async () => {\n    const step = {\n      runId: 'run-1',\n      stepId: 'step-1',\n      stepName: 'doWork',\n      status: 'completed',\n      attempt: 1,\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:02.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: new Date('2026-06-30T00:00:02.000Z'),\n      retryAfter: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsStep;\n    const world = {\n      analytics: {\n        steps: {\n          list: vi.fn().mockResolvedValue({\n            data: [step],\n            cursor: 'next-step-cursor',\n            hasMore: true,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSteps(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'step-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.steps.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'step-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...step,\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:02.000Z',\n        startedAt: '2026-06-30T00:00:01.000Z',\n        completedAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n\n  it('falls back to storage when the first analytics page is empty', async () => {\n    const step = {\n      runId: 'run-1',\n      stepId: 'step-1',\n      stepName: 'step//./src/workflows/test//doWork',\n      status: 'completed',\n      attempt: 1,\n      input: undefined,\n      output: undefined,\n      createdAt: new Date('2026-06-30T00:00:00.000Z'),\n      updatedAt: new Date('2026-06-30T00:00:02.000Z'),\n      startedAt: new Date('2026-06-30T00:00:01.000Z'),\n      completedAt: new Date('2026-06-30T00:00:02.000Z'),\n    } satisfies Step;\n    const world = {\n      analytics: {\n        steps: {\n          list: vi.fn().mockResolvedValue({\n            data: [],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n      steps: {\n        list: vi.fn().mockResolvedValue({\n          data: [step],\n          cursor: null,\n          hasMore: false,\n        }),\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSteps(world, { json: true, runId: 'run-1' });\n\n    expect(world.analytics?.steps.list).toHaveBeenCalled();\n    expect(world.steps.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n      resolveData: 'none',\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...step,\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:02.000Z',\n        startedAt: '2026-06-30T00:00:01.000Z',\n        completedAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n});\n\ndescribe('listEvents', () => {\n  it('passes cursors and preserves the JSON array output', async () => {\n    const event = {\n      runId: 'run-1',\n      eventId: 'event-1',\n      eventType: 'step_completed',\n      correlationId: 'step-1',\n      entityId: 'step-1',\n      stepName: 'doWork',\n      workflowName: 'workflow//./src/workflows/test//myWorkflow',\n      deploymentId: 'dep-1',\n      specVersion: 2,\n      runCreatedAt: new Date('2026-06-30T00:00:00.000Z'),\n      createdAt: new Date('2026-06-30T00:00:02.000Z'),\n      region: null,\n      vercelId: null,\n      requestId: null,\n      resumeAt: null,\n      retryAfter: null,\n      errorCode: null,\n      workflowCoreVersion: null,\n      isWebhook: false,\n      isSystem: false,\n      workflowEncryptionEnabled: false,\n    } satisfies AnalyticsEvent;\n    const world = {\n      analytics: {\n        events: {\n          list: vi.fn().mockResolvedValue({\n            data: [event],\n            cursor: 'next-event-cursor',\n            hasMore: true,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listEvents(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'event-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.events.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      correlationId: undefined,\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'event-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...event,\n        runCreatedAt: '2026-06-30T00:00:00.000Z',\n        createdAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n\n  it('falls back to storage when the first analytics page is empty', async () => {\n    const event = {\n      runId: 'run-1',\n      eventId: 'event-1',\n      eventType: 'step_completed',\n      correlationId: 'step-1',\n      eventData: {\n        stepName: 'doWork',\n        result: undefined,\n      },\n      createdAt: new Date('2026-06-30T00:00:02.000Z'),\n    } as unknown as Event;\n    const world = {\n      analytics: {\n        events: {\n          list: vi.fn().mockResolvedValue({\n            data: [],\n            cursor: null,\n            hasMore: false,\n          }),\n        },\n      },\n      events: {\n        list: vi.fn().mockResolvedValue({\n          data: [event],\n          cursor: null,\n          hasMore: false,\n        }),\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listEvents(world, { json: true, runId: 'run-1' });\n\n    expect(world.analytics?.events.list).toHaveBeenCalled();\n    expect(world.events.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: undefined,\n        limit: 20,\n      },\n      resolveData: 'none',\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...event,\n        createdAt: '2026-06-30T00:00:02.000Z',\n      },\n    ]);\n  });\n});\n\ndescribe('listSleeps', () => {\n  const wait = {\n    runId: 'run-1',\n    waitId: 'wait-1',\n    status: 'waiting',\n    resumeAt: new Date('2026-06-30T00:01:00.000Z'),\n    createdAt: new Date('2026-06-30T00:00:00.000Z'),\n    updatedAt: new Date('2026-06-30T00:00:00.000Z'),\n    completedAt: null,\n    workflowCoreVersion: null,\n    workflowEncryptionEnabled: false,\n  } satisfies AnalyticsWait;\n  const pageInfo = {\n    currentLookbackDays: 2,\n    maxLookbackDays: 30,\n    currentWindowStart: new Date('2026-06-28T00:00:00.000Z'),\n    maxWindowStart: new Date('2026-06-01T00:00:00.000Z'),\n    upgradeAvailable: true,\n  };\n\n  it('passes cursors and preserves the JSON array output through analytics', async () => {\n    const world = {\n      analytics: {\n        waits: {\n          list: vi.fn().mockResolvedValue({\n            data: [wait],\n            cursor: 'next-wait-cursor',\n            hasMore: true,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const write = vi\n      .spyOn(process.stdout, 'write')\n      .mockImplementation(() => true);\n\n    await listSleeps(world, {\n      json: true,\n      runId: 'run-1',\n      cursor: 'wait-cursor',\n      limit: 1,\n    });\n\n    expect(world.analytics?.waits.list).toHaveBeenCalledWith({\n      runId: 'run-1',\n      pagination: {\n        sortOrder: 'desc',\n        cursor: 'wait-cursor',\n        limit: 1,\n      },\n    });\n    expect(JSON.parse(String(write.mock.calls[0][0]))).toEqual([\n      {\n        ...wait,\n        resumeAt: '2026-06-30T00:01:00.000Z',\n        createdAt: '2026-06-30T00:00:00.000Z',\n        updatedAt: '2026-06-30T00:00:00.000Z',\n      },\n    ]);\n  });\n\n  it('surfaces the observability upgrade hint in table mode', async () => {\n    const world = {\n      analytics: {\n        waits: {\n          list: vi.fn().mockResolvedValue({\n            data: [wait],\n            cursor: null,\n            hasMore: false,\n            pageInfo,\n          }),\n        },\n      },\n    } as unknown as World;\n    const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);\n\n    await listSleeps(world, { runId: 'run-1' });\n\n    expect(log.mock.calls.flat().join('\\n')).toContain(\n      'Upgrade Observability Plus'\n    );\n  });\n});\n"]}