claudecode-omc 4.9.4 → 5.0.0

package/dist/__tests__/smoke-slack-and-state.test.js

@@ -1,632 +0,0 @@
-/**
- * Functional Smoke Tests — Slack Socket Mode & State Cancel Cleanup
- *
- * Covers:
- *   1. SlackSocketClient — envelope parsing, message filtering, reconnect
- *      backoff, max-attempt enforcement, graceful shutdown, WS-unavailable
- *      fallback, and Slack API helper signatures (issues #1139)
- *   2. State tools — session-scoped write/read/clear cycle, cancel signal
- *      creation with TTL, ghost-legacy cleanup, broadcast clear, list_active
- *      with session scoping, and get_status details (issue #1143)
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-// ============================================================================
-// Module-level mock for worktree-paths (required before any state-tool imports)
-// ============================================================================
-const mockGetOmcRoot = vi.fn();
-vi.mock('../lib/worktree-paths.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        getOmcRoot: (...args) => mockGetOmcRoot(...args),
-        validateWorkingDirectory: (dir) => dir || '/tmp',
-    };
-});
-// Mock mode-registry — clearModeState/isModeActive use getOmcRoot internally,
-// and we need them to honour the same mockGetOmcRoot as worktree-paths.
-vi.mock('../hooks/mode-registry/index.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        // Passthrough but ensure the mock getOmcRoot from worktree-paths is used
-        canStartMode: () => ({ allowed: true }),
-        registerActiveMode: vi.fn(),
-        deregisterActiveMode: vi.fn(),
-    };
-});
-// ============================================================================
-// 1. SLACK SOCKET MODE — SlackSocketClient (issue #1139)
-// ============================================================================
-import { SlackSocketClient, postSlackBotMessage, addSlackReaction, replySlackThread, } from '../notifications/slack-socket.js';
-// ---------------------------------------------------------------------------
-// MockWebSocket — used across all Slack tests
-// ---------------------------------------------------------------------------
-class MockWebSocket {
-    static OPEN = 1;
-    readyState = MockWebSocket.OPEN;
-    listeners = {};
-    addEventListener(event, handler) {
-        if (!this.listeners[event])
-            this.listeners[event] = [];
-        this.listeners[event].push(handler);
-    }
-    removeEventListener(event, handler) {
-        if (!this.listeners[event])
-            return;
-        this.listeners[event] = this.listeners[event].filter(h => h !== handler);
-    }
-    send = vi.fn();
-    close = vi.fn(() => {
-        this.readyState = 3; // CLOSED
-        this.fire('close');
-    });
-    fire(event, data) {
-        (this.listeners[event] ?? []).forEach(h => h(data));
-    }
-}
-let lastWs = null;
-const mockFetch = vi.fn();
-const OrigWS = globalThis.WebSocket;
-globalThis.fetch = mockFetch;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const CONFIG = {
-    appToken: 'xapp-test',
-    botToken: 'xoxb-test',
-    channelId: 'C999',
-};
-function makeEnvelope(overrides = {}) {
-    return JSON.stringify({
-        envelope_id: 'env_smoke_1',
-        type: 'events_api',
-        payload: {
-            event: {
-                type: 'message',
-                channel: 'C999',
-                user: 'U42',
-                text: 'hello smoke',
-                ts: '1700000000.000001',
-            },
-        },
-        ...overrides,
-    });
-}
-function helloEnvelope() {
-    return JSON.stringify({ envelope_id: 'env_hello', type: 'hello' });
-}
-/** Send a hello envelope to authenticate the connection */
-async function authenticate(ws) {
-    ws.fire('message', { data: helloEnvelope() });
-    await new Promise(r => setTimeout(r, 0));
-}
-// ---------------------------------------------------------------------------
-// Describe: SlackSocketClient
-// ---------------------------------------------------------------------------
-describe('SMOKE: SlackSocketClient — envelope parsing & filtering (issue #1139)', () => {
-    beforeEach(() => {
-        lastWs = null;
-        globalThis.WebSocket = class extends MockWebSocket {
-            constructor(_url) {
-                super();
-                lastWs = this;
-                // auto-fire open on next microtask
-                queueMicrotask(() => this.fire('open'));
-            }
-        };
-        globalThis.WebSocket.OPEN = MockWebSocket.OPEN;
-        mockFetch.mockResolvedValue({
-            json: () => Promise.resolve({ ok: true, url: 'wss://fake-smoke.slack.test' }),
-        });
-    });
-    afterEach(() => {
-        if (OrigWS)
-            globalThis.WebSocket = OrigWS;
-        else
-            delete globalThis.WebSocket;
-        vi.restoreAllMocks();
-    });
-    it('hello envelope: acknowledged but no message dispatch', async () => {
-        const onMessage = vi.fn();
-        const client = new SlackSocketClient(CONFIG, onMessage, vi.fn());
-        await client.start();
-        await new Promise(r => queueMicrotask(r)); // flush open
-        lastWs.fire('message', { data: JSON.stringify({ envelope_id: 'env_hello_1', type: 'hello' }) });
-        await new Promise(r => setTimeout(r, 10));
-        // hello is acknowledged (has envelope_id) but does not dispatch to onMessage
-        expect(lastWs.send).toHaveBeenCalledWith(JSON.stringify({ envelope_id: 'env_hello_1' }));
-        expect(onMessage).not.toHaveBeenCalled();
-        client.stop();
-    });
-    it('disconnect envelope: calls ws.close() and schedules reconnect', async () => {
-        const log = vi.fn();
-        const client = new SlackSocketClient(CONFIG, vi.fn(), log);
-        await client.start();
-        await new Promise(r => queueMicrotask(r));
-        const ws = lastWs;
-        lastWs.fire('message', {
-            data: JSON.stringify({ envelope_id: 'env_disconnect_1', type: 'disconnect', reason: 'refresh_requested' }),
-        });
-        expect(ws.close).toHaveBeenCalled();
-        client.stop();
-    });
-    it('events_api with message: sends ACK and dispatches to onMessage', async () => {
-        const onMessage = vi.fn();
-        const client = new SlackSocketClient(CONFIG, onMessage, vi.fn());
-        await client.start();
-        await new Promise(r => queueMicrotask(r));
-        await authenticate(lastWs);
-        lastWs.fire('message', { data: makeEnvelope() });
-        await new Promise(r => setTimeout(r, 20));
-        expect(lastWs.send).toHaveBeenCalledWith(JSON.stringify({ envelope_id: 'env_smoke_1' }));
-        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'message', channel: 'C999', text: 'hello smoke' }));
-        client.stop();
-    });
-    it('filters out: wrong channel', async () => {
-        const onMessage = vi.fn();
-        const client = new SlackSocketClient(CONFIG, onMessage, vi.fn());
-        await client.start();
-        await new Promise(r => queueMicrotask(r));
-        await authenticate(lastWs);
-        lastWs.fire('message', {
-            data: makeEnvelope({
-                payload: {
-                    event: { type: 'message', channel: 'CWRONG', user: 'U1', text: 'hi', ts: '1' },
-                },
-            }),
-        });
-        await new Promise(r => setTimeout(r, 10));
-        expect(onMessage).not.toHaveBeenCalled();
-        client.stop();
-    });
-    it('filters out: has subtype (message_changed)', async () => {
-        const onMessage = vi.fn();
-        const client = new SlackSocketClient(CONFIG, onMessage, vi.fn());
-        await client.start();
-        await new Promise(r => queueMicrotask(r));
-        await authenticate(lastWs);
-        lastWs.fire('message', {
-            data: makeEnvelope({
-                payload: {
-                    event: {
-                        type: 'message',
-                        channel: 'C999',
-                        user: 'U1',
-                        text: 'edit',
-                        ts: '1',
-                        subtype: 'message_changed',
-                    },
-                },
-            }),
-        });
-        await new Promise(r => setTimeout(r, 10));
-        expect(onMessage).not.toHaveBeenCalled();
-        client.stop();
-    });
-    it('filters out: missing text', async () => {
-        const onMessage = vi.fn();
-        const client = new SlackSocketClient(CONFIG, onMessage, vi.fn());
-        await client.start();
-        await new Promise(r => queueMicrotask(r));
-        await authenticate(lastWs);
-        lastWs.fire('message', {
-            data: makeEnvelope({
-                payload: {
-                    event: { type: 'message', channel: 'C999', user: 'U1', ts: '1' },
-                },
-            }),
-        });
-        await new Promise(r => setTimeout(r, 10));
-        expect(onMessage).not.toHaveBeenCalled();
-        client.stop();
-    });
-});
-describe('SMOKE: SlackSocketClient — reconnect backoff (issue #1139)', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        lastWs = null;
-        // Each call to new WebSocket() creates a fresh MockWebSocket
-        globalThis.WebSocket = class extends MockWebSocket {
-            constructor(_url) {
-                super();
-                lastWs = this;
-                queueMicrotask(() => this.fire('open'));
-            }
-        };
-        globalThis.WebSocket.OPEN = MockWebSocket.OPEN;
-        mockFetch.mockResolvedValue({
-            json: () => Promise.resolve({ ok: true, url: 'wss://fake-smoke.slack.test' }),
-        });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        if (OrigWS)
-            globalThis.WebSocket = OrigWS;
-        else
-            delete globalThis.WebSocket;
-        vi.restoreAllMocks();
-    });
-    it('exponential backoff delays: 1s, 2s, 4s, 8s, 16s, 30s cap', async () => {
-        const log = vi.fn();
-        const client = new SlackSocketClient(CONFIG, vi.fn(), log);
-        // Initial connect succeeds normally
-        await client.start();
-        await vi.advanceTimersByTimeAsync(0);
-        // After initial connect, make all subsequent connect() calls fail
-        // so reconnectAttempts is never reset by a successful 'open' event.
-        mockFetch.mockRejectedValue(new Error('simulated network failure'));
-        const getDelay = (callIndex) => {
-            const calls = log.mock.calls.filter(c => typeof c[0] === 'string' && c[0].includes('reconnecting in'));
-            if (!calls[callIndex])
-                return -1;
-            const m = calls[callIndex][0].match(/reconnecting in (\d+)ms/);
-            return m ? parseInt(m[1], 10) : -1;
-        };
-        // Trigger first disconnect — attempt 0: delay = 1000 * 2^0 = 1000
-        lastWs.fire('close');
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(0)).toBe(1000);
-        // Advance past delay — connect() fails, scheduleReconnect again
-        // attempt 1: delay = 1000 * 2^1 = 2000
-        await vi.advanceTimersByTimeAsync(1001);
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(1)).toBe(2000);
-        // attempt 2: 4000
-        await vi.advanceTimersByTimeAsync(2001);
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(2)).toBe(4000);
-        // attempt 3: 8000
-        await vi.advanceTimersByTimeAsync(4001);
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(3)).toBe(8000);
-        // attempt 4: 16000
-        await vi.advanceTimersByTimeAsync(8001);
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(4)).toBe(16000);
-        // attempt 5: 1000 * 2^5 = 32000, capped at 30000
-        await vi.advanceTimersByTimeAsync(16001);
-        await vi.advanceTimersByTimeAsync(0);
-        expect(getDelay(5)).toBe(30000);
-        client.stop();
-    });
-    it('max 10 reconnect attempts: stops after 10', async () => {
-        const log = vi.fn();
-        const client = new SlackSocketClient(CONFIG, vi.fn(), log);
-        await client.start();
-        await vi.advanceTimersByTimeAsync(0);
-        // Make all reconnect attempts fail so counter keeps incrementing
-        mockFetch.mockRejectedValue(new Error('simulated network failure'));
-        // Trigger initial disconnect
-        lastWs.fire('close');
-        await vi.advanceTimersByTimeAsync(0);
-        // Drive through 10 reconnect attempts (each fails, schedules next)
-        for (let i = 0; i < 10; i++) {
-            await vi.advanceTimersByTimeAsync(30001);
-            await vi.advanceTimersByTimeAsync(0);
-        }
-        const maxReachedCalls = log.mock.calls.filter(c => typeof c[0] === 'string' && c[0].includes('max reconnect attempts'));
-        expect(maxReachedCalls.length).toBeGreaterThanOrEqual(1);
-        client.stop();
-    });
-});
-describe('SMOKE: SlackSocketClient — stop() and WS-unavailable (issue #1139)', () => {
-    afterEach(() => {
-        if (OrigWS)
-            globalThis.WebSocket = OrigWS;
-        else
-            delete globalThis.WebSocket;
-        vi.restoreAllMocks();
-    });
-    it('stop() sets isShuttingDown, clears timer, closes WS — no reconnect after stop', async () => {
-        vi.useFakeTimers();
-        lastWs = null;
-        mockFetch.mockResolvedValue({
-            json: () => Promise.resolve({ ok: true, url: 'wss://fake-smoke.slack.test' }),
-        });
-        globalThis.WebSocket = class extends MockWebSocket {
-            constructor(_url) {
-                super();
-                lastWs = this;
-                queueMicrotask(() => this.fire('open'));
-            }
-        };
-        globalThis.WebSocket.OPEN = MockWebSocket.OPEN;
-        const log = vi.fn();
-        const client = new SlackSocketClient(CONFIG, vi.fn(), log);
-        await client.start();
-        await vi.advanceTimersByTimeAsync(0);
-        const ws = lastWs;
-        client.stop();
-        expect(ws.close).toHaveBeenCalled();
-        // Fire close after stop — should NOT schedule reconnect
-        ws.fire('close');
-        await vi.advanceTimersByTimeAsync(0);
-        await vi.advanceTimersByTimeAsync(5000);
-        await vi.advanceTimersByTimeAsync(0);
-        const reconnectCalls = log.mock.calls.filter(c => typeof c[0] === 'string' && c[0].includes('reconnecting in'));
-        expect(reconnectCalls.length).toBe(0);
-        vi.useRealTimers();
-    });
-    it('WebSocket unavailable: logs warning, does not throw', async () => {
-        // Remove WebSocket from global
-        delete globalThis.WebSocket;
-        const log = vi.fn();
-        const client = new SlackSocketClient(CONFIG, vi.fn(), log);
-        await client.start(); // should not throw
-        expect(log).toHaveBeenCalledWith(expect.stringContaining('WebSocket not available'));
-        client.stop();
-    });
-});
-describe('SMOKE: Slack API helper function signatures (issue #1139)', () => {
-    beforeEach(() => {
-        mockFetch.mockReset();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('postSlackBotMessage: returns ok and ts on success', async () => {
-        mockFetch.mockResolvedValueOnce({
-            json: () => Promise.resolve({ ok: true, ts: '1700000001.000001' }),
-        });
-        const result = await postSlackBotMessage('xoxb-test', 'C999', 'hello from smoke');
-        expect(result.ok).toBe(true);
-        expect(result.ts).toBe('1700000001.000001');
-        expect(mockFetch).toHaveBeenCalledWith('https://slack.com/api/chat.postMessage', expect.objectContaining({ method: 'POST' }));
-    });
-    it('postSlackBotMessage: returns error on API failure', async () => {
-        mockFetch.mockResolvedValueOnce({
-            json: () => Promise.resolve({ ok: false, error: 'channel_not_found' }),
-        });
-        const result = await postSlackBotMessage('xoxb-test', 'CBAD', 'hi');
-        expect(result.ok).toBe(false);
-        expect(result.error).toBe('channel_not_found');
-    });
-    it('addSlackReaction: calls reactions.add endpoint', async () => {
-        mockFetch.mockResolvedValueOnce({ json: () => Promise.resolve({ ok: true }) });
-        await addSlackReaction('xoxb-test', 'C999', '1700000001.000001', 'white_check_mark');
-        expect(mockFetch).toHaveBeenCalledWith('https://slack.com/api/reactions.add', expect.objectContaining({ method: 'POST' }));
-    });
-    it('addSlackReaction: uses default emoji when omitted', async () => {
-        mockFetch.mockResolvedValueOnce({ json: () => Promise.resolve({ ok: true }) });
-        await addSlackReaction('xoxb-test', 'C999', '1700000001.000001');
-        const lastCall = mockFetch.mock.calls.at(-1);
-        const callBody = JSON.parse(lastCall[1].body);
-        expect(callBody.name).toBe('white_check_mark');
-    });
-    it('replySlackThread: calls chat.postMessage with thread_ts', async () => {
-        mockFetch.mockResolvedValueOnce({ json: () => Promise.resolve({ ok: true }) });
-        await replySlackThread('xoxb-test', 'C999', '1700000001.000001', 'threaded reply');
-        expect(mockFetch).toHaveBeenCalledWith('https://slack.com/api/chat.postMessage', expect.objectContaining({ method: 'POST' }));
-        const lastCall = mockFetch.mock.calls.at(-1);
-        const callBody = JSON.parse(lastCall[1].body);
-        expect(callBody.thread_ts).toBe('1700000001.000001');
-        expect(callBody.text).toBe('threaded reply');
-    });
-});
-// ============================================================================
-// 2. STATE CANCEL CLEANUP — consolidated state I/O (issue #1143)
-// ============================================================================
-import { stateWriteTool, stateReadTool, stateClearTool, stateListActiveTool, stateGetStatusTool, } from '../tools/state-tools.js';
-import { resolveSessionStatePath, } from '../lib/worktree-paths.js';
-describe('SMOKE: State Cancel Cleanup — session-scoped I/O (issue #1143)', () => {
-    let testDir;
-    let omcDir;
-    beforeEach(() => {
-        testDir = join(tmpdir(), `smoke-state-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        omcDir = join(testDir, '.omc');
-        mkdirSync(omcDir, { recursive: true });
-        mockGetOmcRoot.mockReturnValue(omcDir);
-    });
-    afterEach(() => {
-        if (existsSync(testDir))
-            rmSync(testDir, { recursive: true, force: true });
-    });
-    // Helper: call a tool handler with merged defaults
-    async function callTool(tool, args) {
-        const result = await tool.handler({
-            workingDirectory: testDir,
-            ...args,
-        });
-        return result.content[0].text;
-    }
-    it('session-scoped write → read → clear cycle', async () => {
-        const sessionId = 'smoke-sess-001';
-        // Write
-        const writeResult = await callTool(stateWriteTool, {
-            mode: 'ralph',
-            session_id: sessionId,
-            active: true,
-            iteration: 3,
-            task_description: 'smoke test task',
-        });
-        expect(writeResult).toContain('Successfully wrote state');
-        expect(writeResult).toContain(sessionId);
-        // Read back
-        const readResult = await callTool(stateReadTool, {
-            mode: 'ralph',
-            session_id: sessionId,
-        });
-        expect(readResult).toContain('smoke test task');
-        expect(readResult).toContain(sessionId);
-        // Clear
-        const clearResult = await callTool(stateClearTool, {
-            mode: 'ralph',
-            session_id: sessionId,
-        });
-        expect(clearResult).toContain('Successfully cleared state');
-        // Read after clear — should report no state
-        const readAfterClear = await callTool(stateReadTool, {
-            mode: 'ralph',
-            session_id: sessionId,
-        });
-        expect(readAfterClear).toContain('No state found');
-    });
-    it('state_clear with session_id writes cancel signal with TTL (~30s)', async () => {
-        const sessionId = 'smoke-cancel-sess';
-        // Write some state first so there is something to clear
-        await callTool(stateWriteTool, {
-            mode: 'autopilot',
-            session_id: sessionId,
-            active: true,
-        });
-        const before = Date.now();
-        await callTool(stateClearTool, {
-            mode: 'autopilot',
-            session_id: sessionId,
-        });
-        const after = Date.now();
-        // Compute path directly — avoids mock boundary issues with resolveSessionStatePath internals.
-        // State tools write to: {omcRoot}/state/sessions/{sessionId}/cancel-signal-state.json
-        // omcRoot = getOmcRoot(root) = mockGetOmcRoot(testDir) = omcDir
-        const cancelSignalPath = join(omcDir, 'state', 'sessions', sessionId, 'cancel-signal-state.json');
-        expect(existsSync(cancelSignalPath)).toBe(true);
-        const signal = JSON.parse(readFileSync(cancelSignalPath, 'utf-8'));
-        expect(signal.active).toBe(true);
-        expect(signal.mode).toBe('autopilot');
-        expect(signal.source).toBe('state_clear');
-        const requestedAt = new Date(signal.requested_at).getTime();
-        const expiresAt = new Date(signal.expires_at).getTime();
-        expect(requestedAt).toBeGreaterThanOrEqual(before);
-        expect(requestedAt).toBeLessThanOrEqual(after + 100);
-        const ttlMs = expiresAt - requestedAt;
-        expect(ttlMs).toBe(30_000);
-    });
-    it('ghost-legacy cleanup: session clear removes legacy file when sessionId matches', async () => {
-        const sessionId = 'smoke-ghost-match';
-        // Write session-scoped state
-        await callTool(stateWriteTool, {
-            mode: 'ultrawork',
-            session_id: sessionId,
-            active: true,
-        });
-        // Plant a legacy ghost file with matching sessionId in _meta
-        const legacyDir = join(omcDir, 'state');
-        mkdirSync(legacyDir, { recursive: true });
-        const legacyPath = join(legacyDir, 'ultrawork-state.json');
-        writeFileSync(legacyPath, JSON.stringify({
-            active: true,
-            _meta: { mode: 'ultrawork', sessionId, updatedBy: 'state_write_tool' },
-        }));
-        expect(existsSync(legacyPath)).toBe(true);
-        const clearResult = await callTool(stateClearTool, {
-            mode: 'ultrawork',
-            session_id: sessionId,
-        });
-        expect(clearResult).toContain('ghost legacy file also removed');
-        expect(existsSync(legacyPath)).toBe(false);
-    });
-    it('ghost-legacy preservation: session clear does NOT remove legacy file from a different session', async () => {
-        const sessionId = 'smoke-ghost-mine';
-        const otherSessionId = 'smoke-ghost-other';
-        await callTool(stateWriteTool, {
-            mode: 'ultrawork',
-            session_id: sessionId,
-            active: true,
-        });
-        // Plant a legacy ghost file belonging to another session
-        const legacyDir = join(omcDir, 'state');
-        mkdirSync(legacyDir, { recursive: true });
-        const legacyPath = join(legacyDir, 'ultrawork-state.json');
-        writeFileSync(legacyPath, JSON.stringify({
-            active: true,
-            _meta: { mode: 'ultrawork', sessionId: otherSessionId, updatedBy: 'state_write_tool' },
-        }));
-        await callTool(stateClearTool, {
-            mode: 'ultrawork',
-            session_id: sessionId,
-        });
-        // Legacy file belonging to a different session must survive
-        expect(existsSync(legacyPath)).toBe(true);
-    });
-    it('broadcast clear (no session_id) removes both legacy and session-scoped state', async () => {
-        // Write two session-scoped entries
-        await callTool(stateWriteTool, {
-            mode: 'team',
-            session_id: 'broadcast-sess-a',
-            active: true,
-        });
-        await callTool(stateWriteTool, {
-            mode: 'team',
-            session_id: 'broadcast-sess-b',
-            active: true,
-        });
-        // Write a legacy path directly
-        const legacyDir = join(omcDir, 'state');
-        mkdirSync(legacyDir, { recursive: true });
-        const legacyPath = join(legacyDir, 'team-state.json');
-        writeFileSync(legacyPath, JSON.stringify({ active: true }));
-        const clearResult = await callTool(stateClearTool, { mode: 'team' });
-        // Broadcast clear should mention multiple locations or warn about broad op
-        expect(clearResult).toMatch(/Cleared state|cleared/i);
-        expect(clearResult).toContain('WARNING');
-        // Both session paths should be gone
-        const sessAPath = resolveSessionStatePath('team', 'broadcast-sess-a', omcDir);
-        const sessBPath = resolveSessionStatePath('team', 'broadcast-sess-b', omcDir);
-        expect(existsSync(sessAPath)).toBe(false);
-        expect(existsSync(sessBPath)).toBe(false);
-        expect(existsSync(legacyPath)).toBe(false);
-    });
-    it('state_list_active with session_id only shows modes active in that session', async () => {
-        const sessionId = 'smoke-list-sess';
-        // Write active state for 'ralph' in this session
-        await callTool(stateWriteTool, {
-            mode: 'ralph',
-            session_id: sessionId,
-            active: true,
-        });
-        // Write active state for 'ultrawork' in a DIFFERENT session
-        await callTool(stateWriteTool, {
-            mode: 'ultrawork',
-            session_id: 'other-list-sess',
-            active: true,
-        });
-        const listResult = await callTool(stateListActiveTool, {
-            session_id: sessionId,
-        });
-        expect(listResult).toContain('ralph');
-        // ultrawork from another session must not appear
-        expect(listResult).not.toContain('ultrawork');
-    });
-    it('state_get_status returns correct path and existence details for a mode', async () => {
-        const sessionId = 'smoke-status-sess';
-        await callTool(stateWriteTool, {
-            mode: 'autopilot',
-            session_id: sessionId,
-            active: true,
-            iteration: 7,
-        });
-        const statusResult = await callTool(stateGetStatusTool, {
-            mode: 'autopilot',
-            session_id: sessionId,
-        });
-        expect(statusResult).toContain('autopilot');
-        // Path should point into the sessions directory
-        expect(statusResult).toContain(sessionId);
-        // Should indicate file exists
-        expect(statusResult).toContain('Yes');
-    });
-    it('state_read with no session_id aggregates all sessions and legacy', async () => {
-        const sess1 = 'agg-sess-1';
-        const sess2 = 'agg-sess-2';
-        await callTool(stateWriteTool, {
-            mode: 'ralph',
-            session_id: sess1,
-            active: true,
-            task_description: 'task from sess1',
-        });
-        await callTool(stateWriteTool, {
-            mode: 'ralph',
-            session_id: sess2,
-            active: true,
-            task_description: 'task from sess2',
-        });
-        const readResult = await callTool(stateReadTool, { mode: 'ralph' });
-        // Both sessions should appear
-        expect(readResult).toContain(sess1);
-        expect(readResult).toContain(sess2);
-    });
-});
-//# sourceMappingURL=smoke-slack-and-state.test.js.map