sofia-cli 0.1.1

package/dist/tests/unit/cli/directCommands.spec.js

@@ -0,0 +1,279 @@
+/**
+ * Unit tests for directCommands module (T052).
+ *
+ * Covers:
+ * - Input validation (missing session, missing phase in non-interactive)
+ * - Phase validation
+ * - JSON error output format
+ * - ioContext TTY/non-TTY detection
+ * - JSON output separation (stdout vs stderr)
+ * - Retry behavior and backoff
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { Readable, Writable } from 'node:stream';
+import { createFakeCopilotClient } from '../../../src/shared/copilotClient.js';
+import { SessionStore } from '../../../src/sessions/sessionStore.js';
+import { runDirectCommand } from '../../../src/cli/directCommands.js';
+import { createLoopIO } from '../../../src/cli/ioContext.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createTestSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'unit-direct-test',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        turns: [],
+        ...overrides,
+    };
+}
+function createTestIO(opts = {}) {
+    let inputIdx = 0;
+    const output = [];
+    const activityLog = [];
+    const inputs = opts.inputs ?? [null];
+    const gateChoice = opts.gateChoice ?? { choice: 'exit' };
+    return {
+        write(text) { output.push(text); },
+        writeActivity(text) { activityLog.push(text); },
+        writeToolSummary(_toolName, _summary) { },
+        async readInput(_prompt) {
+            if (inputIdx >= inputs.length)
+                return null;
+            return inputs[inputIdx++];
+        },
+        async showDecisionGate(_phase) {
+            return gateChoice;
+        },
+        isJsonMode: opts.isJsonMode ?? false,
+        isTTY: opts.isTTY ?? false,
+        output,
+        activityLog,
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('directCommands validation', () => {
+    let tmpDir;
+    let store;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-unit-dc-'));
+        store = new SessionStore(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('rejects undefined sessionId', async () => {
+        const io = createTestIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: undefined,
+            phase: 'Discover',
+            store, client, io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('session');
+    });
+    it('rejects empty sessionId', async () => {
+        const io = createTestIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: '',
+            phase: 'Discover',
+            store, client, io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('session');
+    });
+    it('rejects missing phase in non-interactive mode', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createTestIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: undefined,
+            store, client, io,
+            nonInteractive: true,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('phase');
+    });
+    it('rejects invalid phase name', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createTestIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Brainstorm',
+            store, client, io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('Invalid phase');
+        expect(result.error).toContain('Brainstorm');
+    });
+    it('rejects nonexistent session', async () => {
+        const io = createTestIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: 'does-not-exist',
+            phase: 'Discover',
+            store, client, io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('not found');
+    });
+});
+describe('directCommands JSON output', () => {
+    let tmpDir;
+    let store;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-unit-dc-json-'));
+        store = new SessionStore(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('emits error as JSON when json=true', async () => {
+        const io = createTestIO({ isJsonMode: true });
+        const client = createFakeCopilotClient([]);
+        await runDirectCommand({
+            sessionId: 'missing',
+            phase: 'Discover',
+            store, client, io,
+            json: true,
+        });
+        const jsonLines = io.output.filter(l => {
+            try {
+                JSON.parse(l);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        expect(jsonLines.length).toBeGreaterThan(0);
+        const parsed = JSON.parse(jsonLines[0]);
+        expect(parsed.error).toBeDefined();
+        expect(typeof parsed.error).toBe('string');
+        expect(parsed.error).toContain('not found');
+    });
+    it('emits result summary as JSON on success', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createTestIO({ isJsonMode: true, inputs: ['hello', null] });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: 'I understand.' },
+        ]);
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store, client, io,
+            json: true,
+        });
+        // Should contain at least the result summary
+        const jsonLines = io.output
+            .filter(l => { try {
+            const o = JSON.parse(l);
+            return o.sessionId;
+        }
+        catch {
+            return false;
+        } });
+        expect(jsonLines.length).toBeGreaterThan(0);
+        const result = JSON.parse(jsonLines[0]);
+        expect(result.sessionId).toBe(session.sessionId);
+        expect(result.phase).toBe('Discover');
+    });
+});
+describe('ioContext', () => {
+    it('creates TTY IO when input stream has isTTY', () => {
+        const input = new Readable({ read() { } });
+        input.isTTY = true;
+        const output = new Writable({ write(_c, _e, cb) { cb(); } });
+        const io = createLoopIO({ input, output });
+        expect(io.isTTY).toBe(true);
+        expect(io.isJsonMode).toBe(false);
+    });
+    it('creates non-TTY IO when nonInteractive is true', () => {
+        const input = new Readable({ read() { } });
+        input.isTTY = true;
+        const output = new Writable({ write(_c, _e, cb) { cb(); } });
+        const io = createLoopIO({ input, output, nonInteractive: true });
+        expect(io.isTTY).toBe(false);
+    });
+    it('sets isJsonMode when json option is true', () => {
+        const io = createLoopIO({ json: true });
+        expect(io.isJsonMode).toBe(true);
+    });
+    it('non-interactive readInput returns null', async () => {
+        const io = createLoopIO({ nonInteractive: true });
+        const result = await io.readInput('prompt: ');
+        expect(result).toBeNull();
+    });
+});
+describe('directCommands retry', () => {
+    let tmpDir;
+    let store;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-unit-dc-retry-'));
+        store = new SessionStore(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('does not retry non-recoverable errors', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        let callCount = 0;
+        const client = createFakeCopilotClient([], {
+            onChat: async () => {
+                callCount++;
+                // Auth errors are not recoverable
+                const err = new Error('Unauthorized');
+                err.statusCode = 401;
+                throw err;
+            },
+        });
+        const io = createTestIO({ inputs: ['test', 'test', 'test'] });
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store, client, io,
+            retry: 3,
+        });
+        // Should only attempt once — auth errors are not retried
+        expect(callCount).toBe(1);
+    });
+    it('logs retry activity messages', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        let callCount = 0;
+        const client = createFakeCopilotClient([], {
+            onChat: async () => {
+                callCount++;
+                if (callCount <= 1) {
+                    throw Object.assign(new Error('Connection refused'), { code: 'ECONNREFUSED' });
+                }
+                return { role: 'assistant', content: 'OK' };
+            },
+        });
+        const io = createTestIO({ inputs: ['test', 'test', null] });
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store, client, io,
+            retry: 2,
+        });
+        // Should have logged retry activity
+        const retryLogs = io.activityLog.filter(l => l.includes('Retrying'));
+        expect(retryLogs.length).toBeGreaterThan(0);
+    });
+});

package/dist/tests/unit/cli/envLoader.spec.js

@@ -0,0 +1,58 @@
+/**
+ * Environment loader tests.
+ *
+ * Validates that dotenv is loaded at startup to populate process.env
+ * from a .env file in the project root.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+describe('loadEnvFile', () => {
+    let tmpDir;
+    const savedEnv = {};
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sofia-env-'));
+        // Save and clear any existing values
+        savedEnv['FOUNDRY_PROJECT_ENDPOINT'] = process.env.FOUNDRY_PROJECT_ENDPOINT;
+        savedEnv['FOUNDRY_MODEL_DEPLOYMENT_NAME'] = process.env.FOUNDRY_MODEL_DEPLOYMENT_NAME;
+        delete process.env.FOUNDRY_PROJECT_ENDPOINT;
+        delete process.env.FOUNDRY_MODEL_DEPLOYMENT_NAME;
+    });
+    afterEach(() => {
+        // Restore original env
+        for (const [key, val] of Object.entries(savedEnv)) {
+            if (val === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = val;
+        }
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('loads variables from .env file into process.env', async () => {
+        const envPath = path.join(tmpDir, '.env');
+        fs.writeFileSync(envPath, [
+            'FOUNDRY_PROJECT_ENDPOINT="https://my-endpoint.cognitiveservices.azure.com"',
+            'FOUNDRY_MODEL_DEPLOYMENT_NAME="gpt-4.1-mini"',
+        ].join('\n'));
+        // Dynamic import to avoid caching
+        const { loadEnvFile } = await import('../../../src/cli/envLoader.js');
+        loadEnvFile(envPath);
+        expect(process.env.FOUNDRY_PROJECT_ENDPOINT).toBe('https://my-endpoint.cognitiveservices.azure.com');
+        expect(process.env.FOUNDRY_MODEL_DEPLOYMENT_NAME).toBe('gpt-4.1-mini');
+    });
+    it('does not overwrite existing env vars', async () => {
+        process.env.FOUNDRY_PROJECT_ENDPOINT = 'already-set';
+        const envPath = path.join(tmpDir, '.env');
+        fs.writeFileSync(envPath, 'FOUNDRY_PROJECT_ENDPOINT="from-file"');
+        const { loadEnvFile } = await import('../../../src/cli/envLoader.js');
+        loadEnvFile(envPath);
+        expect(process.env.FOUNDRY_PROJECT_ENDPOINT).toBe('already-set');
+    });
+    it('does nothing when .env file does not exist', async () => {
+        const envPath = path.join(tmpDir, '.env-nonexistent');
+        const { loadEnvFile } = await import('../../../src/cli/envLoader.js');
+        // Should not throw
+        expect(() => loadEnvFile(envPath)).not.toThrow();
+    });
+});

package/dist/tests/unit/cli/ioContext.spec.js

@@ -0,0 +1,119 @@
+/**
+ * Tests for writeToolSummary in LoopIO / ioContext (T086).
+ *
+ * Verifies that tool summaries are correctly formatted in default mode,
+ * expanded in --debug mode, and suppressed in JSON/non-TTY mode.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Writable } from 'node:stream';
+import { Readable } from 'node:stream';
+import { createLoopIO } from '../../../src/cli/ioContext.js';
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function createCaptureStream() {
+    const chunks = [];
+    const stream = new Writable({
+        write(chunk, _encoding, callback) {
+            chunks.push(chunk.toString());
+            callback();
+        },
+    });
+    stream.getOutput = () => chunks.join('');
+    return stream;
+}
+function createMockInput() {
+    const readable = new Readable({ read() { } });
+    // Mark as non-TTY by default
+    return readable;
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('writeToolSummary in LoopIO (T086)', () => {
+    describe('default mode (TTY, no debug, no JSON)', () => {
+        let errorStream;
+        let outputStream;
+        beforeEach(() => {
+            errorStream = createCaptureStream();
+            outputStream = createCaptureStream();
+        });
+        it('prints "✓ <toolName>: <summary>" to stderr', () => {
+            const input = createMockInput();
+            input.isTTY = true;
+            const io = createLoopIO({
+                input,
+                output: outputStream,
+                errorOutput: errorStream,
+            });
+            io.writeToolSummary('WorkIQ', 'Found 12 relevant processes');
+            const errOutput = errorStream.getOutput();
+            expect(errOutput).toContain('✓ WorkIQ: Found 12 relevant processes');
+        });
+        it('does not write tool summary to stdout', () => {
+            const input = createMockInput();
+            input.isTTY = true;
+            const io = createLoopIO({
+                input,
+                output: outputStream,
+                errorOutput: errorStream,
+            });
+            io.writeToolSummary('Context7', '8 docs found');
+            const stdOutput = outputStream.getOutput();
+            expect(stdOutput).toBe('');
+        });
+    });
+    describe('debug mode', () => {
+        let errorStream;
+        let outputStream;
+        beforeEach(() => {
+            errorStream = createCaptureStream();
+            outputStream = createCaptureStream();
+        });
+        it('shows tool args and result details in addition to summary', () => {
+            const input = createMockInput();
+            input.isTTY = true;
+            const io = createLoopIO({
+                input,
+                output: outputStream,
+                errorOutput: errorStream,
+                debug: true,
+            });
+            io.writeToolSummary('WorkIQ', 'Found 5 processes', {
+                args: { query: 'logistics', limit: 10 },
+                result: { count: 5, processes: ['p1', 'p2'] },
+            });
+            const errOutput = errorStream.getOutput();
+            expect(errOutput).toContain('✓ WorkIQ: Found 5 processes');
+            expect(errOutput).toContain('query');
+            expect(errOutput).toContain('logistics');
+            expect(errOutput).toContain('count');
+        });
+    });
+    describe('JSON mode', () => {
+        it('omits tool summaries from stdout', () => {
+            const errorStream = createCaptureStream();
+            const outputStream = createCaptureStream();
+            const input = createMockInput();
+            const io = createLoopIO({
+                json: true,
+                input,
+                output: outputStream,
+                errorOutput: errorStream,
+            });
+            io.writeToolSummary('WorkIQ', 'Found stuff');
+            expect(outputStream.getOutput()).toBe('');
+        });
+    });
+    describe('non-interactive mode', () => {
+        it('omits tool summaries from stdout', () => {
+            const errorStream = createCaptureStream();
+            const outputStream = createCaptureStream();
+            const input = createMockInput();
+            const io = createLoopIO({
+                nonInteractive: true,
+                input,
+                output: outputStream,
+                errorOutput: errorStream,
+            });
+            io.writeToolSummary('GitHub', 'Repo cloned');
+            expect(outputStream.getOutput()).toBe('');
+        });
+    });
+});

package/dist/tests/unit/cli/preflight.spec.js

@@ -0,0 +1,108 @@
+/**
+ * Preflight checks tests (T056, T023).
+ *
+ * Validates startup checks for:
+ * - Copilot SDK availability
+ * - MCP server configuration presence
+ * - Environment variable requirements
+ * - Graceful degradation when services unavailable
+ * - Legacy env var detection (FR-016)
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { runPreflightChecks, checkLegacyWebSearchEnvVars, } from '../../../src/cli/preflight.js';
+describe('preflight checks', () => {
+    it('returns all-pass when all checks succeed', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => ({ name: 'copilot-sdk', status: 'pass', message: 'SDK available' }),
+            checkMcpConfig: async () => ({ name: 'mcp-config', status: 'pass', message: 'Config found' }),
+        });
+        expect(result.passed).toBe(true);
+        expect(result.checks.every((c) => c.status === 'pass')).toBe(true);
+    });
+    it('returns failed when a required check fails', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => ({ name: 'copilot-sdk', status: 'fail', message: 'SDK not found', required: true }),
+            checkMcpConfig: async () => ({ name: 'mcp-config', status: 'pass', message: 'Config found' }),
+        });
+        expect(result.passed).toBe(false);
+        expect(result.checks.find((c) => c.name === 'copilot-sdk')?.status).toBe('fail');
+    });
+    it('returns pass with warnings for optional failures', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => ({ name: 'copilot-sdk', status: 'pass', message: 'SDK available' }),
+            checkMcpConfig: async () => ({ name: 'mcp-config', status: 'warn', message: 'Config not found, will use defaults' }),
+        });
+        expect(result.passed).toBe(true);
+        expect(result.checks.find((c) => c.name === 'mcp-config')?.status).toBe('warn');
+    });
+    it('handles check functions that throw', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => { throw new Error('Unexpected failure'); },
+            checkMcpConfig: async () => ({ name: 'mcp-config', status: 'pass', message: 'OK' }),
+        });
+        expect(result.passed).toBe(false);
+        const failedCheck = result.checks.find((c) => c.status === 'fail');
+        expect(failedCheck).toBeDefined();
+        expect(failedCheck.message).toContain('Unexpected failure');
+    });
+    it('collects all check results even when some fail', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => ({ name: 'copilot-sdk', status: 'fail', message: 'Missing', required: true }),
+            checkMcpConfig: async () => ({ name: 'mcp-config', status: 'fail', message: 'Missing', required: true }),
+        });
+        expect(result.checks).toHaveLength(2);
+        expect(result.checks.filter((c) => c.status === 'fail')).toHaveLength(2);
+    });
+    it('includes check names and messages in results', async () => {
+        const result = await runPreflightChecks({
+            checkCopilotSdk: async () => ({ name: 'copilot-sdk', status: 'pass', message: 'v1.0.0 available' }),
+        });
+        expect(result.checks[0].name).toBe('copilot-sdk');
+        expect(result.checks[0].message).toBe('v1.0.0 available');
+    });
+});
+describe('checkLegacyWebSearchEnvVars (T023)', () => {
+    const originalEnv = { ...process.env };
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('passes when no legacy env vars are set', async () => {
+        delete process.env.SOFIA_FOUNDRY_AGENT_ENDPOINT;
+        delete process.env.SOFIA_FOUNDRY_AGENT_KEY;
+        const result = await checkLegacyWebSearchEnvVars();
+        expect(result.status).toBe('pass');
+        expect(result.name).toBe('legacy-web-search-env');
+    });
+    it('fails when SOFIA_FOUNDRY_AGENT_ENDPOINT is set', async () => {
+        process.env.SOFIA_FOUNDRY_AGENT_ENDPOINT = 'https://old-endpoint.example.com';
+        delete process.env.SOFIA_FOUNDRY_AGENT_KEY;
+        const result = await checkLegacyWebSearchEnvVars();
+        expect(result.status).toBe('fail');
+        expect(result.required).toBe(true);
+        expect(result.message).toContain('Legacy web search env vars detected');
+        expect(result.message).toContain('FOUNDRY_PROJECT_ENDPOINT');
+    });
+    it('fails when SOFIA_FOUNDRY_AGENT_KEY is set', async () => {
+        delete process.env.SOFIA_FOUNDRY_AGENT_ENDPOINT;
+        process.env.SOFIA_FOUNDRY_AGENT_KEY = 'old-api-key';
+        const result = await checkLegacyWebSearchEnvVars();
+        expect(result.status).toBe('fail');
+        expect(result.required).toBe(true);
+        expect(result.message).toContain('API key auth is no longer used');
+    });
+    it('fails when both legacy vars are set', async () => {
+        process.env.SOFIA_FOUNDRY_AGENT_ENDPOINT = 'https://old-endpoint.example.com';
+        process.env.SOFIA_FOUNDRY_AGENT_KEY = 'old-api-key';
+        const result = await checkLegacyWebSearchEnvVars();
+        expect(result.status).toBe('fail');
+        expect(result.required).toBe(true);
+    });
+    it('fails preflight when integrated with runPreflightChecks', async () => {
+        process.env.SOFIA_FOUNDRY_AGENT_ENDPOINT = 'https://old-endpoint.example.com';
+        const result = await runPreflightChecks({
+            checkLegacyWebSearch: checkLegacyWebSearchEnvVars,
+        });
+        expect(result.passed).toBe(false);
+        expect(result.checks[0].name).toBe('legacy-web-search-env');
+    });
+});

package/dist/tests/unit/cli/statusCommand.spec.js

@@ -0,0 +1,111 @@
+/**
+ * T064: Unit tests for statusCommand — session name display.
+ *
+ * Verifies that statusCommand displays the session name in both
+ * TTY table and JSON output formats.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+function makeSession(overrides) {
+    return {
+        sessionId: 'test-session-001',
+        schemaVersion: '1.0.0',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T01:00:00Z',
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        turns: [],
+        ...overrides,
+    };
+}
+// Mock sessionStore
+const mockStore = {
+    load: vi.fn(),
+    save: vi.fn(),
+    exists: vi.fn(),
+    list: vi.fn(),
+};
+vi.mock('../../../src/sessions/sessionStore.js', () => ({
+    createDefaultStore: () => mockStore,
+    SessionStore: vi.fn(),
+}));
+describe('statusCommand', () => {
+    let stdoutChunks;
+    let stderrChunks;
+    const originalWrite = process.stdout.write;
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    beforeEach(() => {
+        stdoutChunks = [];
+        stderrChunks = [];
+        process.stdout.write = vi.fn((chunk) => {
+            stdoutChunks.push(chunk.toString());
+            return true;
+        });
+        console.log = vi.fn((...args) => {
+            stdoutChunks.push(args.map(String).join(' '));
+        });
+        console.error = vi.fn((...args) => {
+            stderrChunks.push(args.map(String).join(' '));
+        });
+        process.exitCode = undefined;
+        vi.resetAllMocks();
+    });
+    afterEach(() => {
+        process.stdout.write = originalWrite;
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+        process.exitCode = undefined;
+    });
+    describe('session name display (T064)', () => {
+        it('displays session name in JSON output for single session', async () => {
+            const session = makeSession({ name: 'Logistics AI Workshop' });
+            mockStore.exists.mockResolvedValue(true);
+            mockStore.load.mockResolvedValue(session);
+            const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+            await statusCommand({ session: 'test-session-001', json: true });
+            const output = stdoutChunks.join('');
+            const parsed = JSON.parse(output);
+            expect(parsed.name).toBe('Logistics AI Workshop');
+        });
+        it('omits name from JSON output when session has no name', async () => {
+            const session = makeSession();
+            mockStore.exists.mockResolvedValue(true);
+            mockStore.load.mockResolvedValue(session);
+            const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+            await statusCommand({ session: 'test-session-001', json: true });
+            const output = stdoutChunks.join('');
+            const parsed = JSON.parse(output);
+            expect(parsed.name).toBeUndefined();
+        });
+        it('displays session name in TTY output for single session', async () => {
+            const session = makeSession({ name: 'Retail AI Insights' });
+            mockStore.exists.mockResolvedValue(true);
+            mockStore.load.mockResolvedValue(session);
+            const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+            await statusCommand({ session: 'test-session-001', json: false });
+            const output = stdoutChunks.join(' ');
+            expect(output).toContain('Retail AI Insights');
+        });
+        it('displays session name in session list JSON output', async () => {
+            const session = makeSession({ name: 'Supply Chain AI' });
+            mockStore.list.mockResolvedValue(['test-session-001']);
+            mockStore.load.mockResolvedValue(session);
+            const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+            await statusCommand({ json: true });
+            const output = stdoutChunks.join('');
+            const parsed = JSON.parse(output);
+            expect(parsed.sessions[0].name).toBe('Supply Chain AI');
+        });
+        it('displays session name in session list TTY table', async () => {
+            const session = makeSession({ name: 'HR Automation' });
+            mockStore.list.mockResolvedValue(['test-session-001']);
+            mockStore.load.mockResolvedValue(session);
+            const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+            await statusCommand({ json: false });
+            const output = stdoutChunks.join(' ');
+            expect(output).toContain('HR Automation');
+        });
+    });
+});