oh-my-codex 0.20.3 → 0.21.0

package/dist/mcp/__tests__/state-server.test.js

@@ -83,1028 +83,6 @@ exit 1
     return fakeBin;
 }
 describe('state-server directory initialization', () => {
-    it('keeps read-only state tools side-effect-free without setup', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-test-'));
-        try {
-            const stateDir = join(wd, '.omx', 'state');
-            const tmuxHookConfig = join(wd, '.omx', 'tmux-hook.json');
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_list_active',
-                    arguments: { workingDirectory: wd },
-                },
-            });
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            assert.deepEqual(JSON.parse(response.content[0]?.text || '{}'), { active_modes: [] });
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('creates boxed runtime state under OMX_ROOT for mutating tools', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const { handleStateToolCall } = await import('../state-server.js');
-        const root = await mkdtemp(join(tmpdir(), 'omx-state-server-boxed-'));
-        const box = join(root, 'box');
-        const wd = join(root, 'source');
-        try {
-            await mkdir(wd, { recursive: true });
-            process.env.OMX_ROOT = box;
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'ralph',
-                        active: true,
-                        iteration: 1,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            assert.equal(existsSync(join(box, '.omx', 'state', 'ralph-state.json')), true);
-            assert.equal(existsSync(join(box, '.omx', 'tmux-hook.json')), true);
-            assert.equal(existsSync(join(wd, '.omx', 'state')), false);
-            assert.equal(existsSync(join(wd, '.omx', 'tmux-hook.json')), false);
-        }
-        finally {
-            if (typeof previousOmxRoot === 'string')
-                process.env.OMX_ROOT = previousOmxRoot;
-            else
-                delete process.env.OMX_ROOT;
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it('co-locates boxed tracked mode and canonical skill state under OMX_ROOT', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const { handleStateToolCall } = await import('../state-server.js');
-        const root = await mkdtemp(join(tmpdir(), 'omx-state-server-boxed-skill-'));
-        const box = join(root, 'box');
-        const wd = join(root, 'source');
-        const sessionId = 'sess-boxed-ralplan';
-        try {
-            await mkdir(wd, { recursive: true });
-            process.env.OMX_ROOT = box;
-            delete process.env.OMX_STATE_ROOT;
-            delete process.env.OMX_TEAM_STATE_ROOT;
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: sessionId,
-                        mode: 'ralplan',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            const boxedSessionDir = join(box, '.omx', 'state', 'sessions', sessionId);
-            assert.equal(existsSync(join(boxedSessionDir, 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(boxedSessionDir, 'skill-active-state.json')), true);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'ralplan-state.json')), false);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'skill-active-state.json')), false);
-        }
-        finally {
-            if (typeof previousOmxRoot === 'string')
-                process.env.OMX_ROOT = previousOmxRoot;
-            else
-                delete process.env.OMX_ROOT;
-            if (typeof previousOmxStateRoot === 'string')
-                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
-            else
-                delete process.env.OMX_STATE_ROOT;
-            if (typeof previousTeamStateRoot === 'string')
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            else
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it('co-locates tracked mode and canonical skill state under OMX_TEAM_STATE_ROOT', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const { handleStateToolCall } = await import('../state-server.js');
-        const root = await mkdtemp(join(tmpdir(), 'omx-state-server-team-skill-'));
-        const teamStateRoot = join(root, 'team-state');
-        const wd = join(root, 'source');
-        const sessionId = 'sess-team-ralplan';
-        try {
-            await mkdir(wd, { recursive: true });
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_STATE_ROOT;
-            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: sessionId,
-                        mode: 'ralplan',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            const teamSessionDir = join(teamStateRoot, 'sessions', sessionId);
-            assert.equal(existsSync(join(teamSessionDir, 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(teamSessionDir, 'skill-active-state.json')), true);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'ralplan-state.json')), false);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'skill-active-state.json')), false);
-        }
-        finally {
-            if (typeof previousOmxRoot === 'string')
-                process.env.OMX_ROOT = previousOmxRoot;
-            else
-                delete process.env.OMX_ROOT;
-            if (typeof previousOmxStateRoot === 'string')
-                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
-            else
-                delete process.env.OMX_STATE_ROOT;
-            if (typeof previousTeamStateRoot === 'string')
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            else
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it('keeps auto-completed transition canonical state under OMX_TEAM_STATE_ROOT', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const { handleStateToolCall } = await import('../state-server.js');
-        const root = await mkdtemp(join(tmpdir(), 'omx-state-server-team-transition-'));
-        const teamStateRoot = join(root, 'team-state');
-        const wd = join(root, 'source');
-        const sessionId = 'sess-team-transition';
-        try {
-            await mkdir(wd, { recursive: true });
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_STATE_ROOT;
-            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
-            const deepInterview = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: sessionId,
-                        mode: 'deep-interview',
-                        active: true,
-                        current_phase: 'interviewing',
-                        deep_interview_gate: {
-                            status: 'complete',
-                            rationale: 'Requirements are clarified and ready for ralplan consensus.',
-                        },
-                    },
-                },
-            });
-            assert.equal(deepInterview.isError, undefined);
-            const ralplan = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: sessionId,
-                        mode: 'ralplan',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(ralplan.isError, undefined);
-            const teamSessionDir = join(teamStateRoot, 'sessions', sessionId);
-            const completedDeepInterview = JSON.parse(await readFile(join(teamSessionDir, 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(completedDeepInterview.active, false);
-            assert.equal(completedDeepInterview.current_phase, 'completed');
-            assert.equal(existsSync(join(teamSessionDir, 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(teamSessionDir, 'skill-active-state.json')), true);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'deep-interview-state.json')), false);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'skill-active-state.json')), false);
-        }
-        finally {
-            if (typeof previousOmxRoot === 'string')
-                process.env.OMX_ROOT = previousOmxRoot;
-            else
-                delete process.env.OMX_ROOT;
-            if (typeof previousOmxStateRoot === 'string')
-                process.env.OMX_STATE_ROOT = previousOmxStateRoot;
-            else
-                delete process.env.OMX_STATE_ROOT;
-            if (typeof previousTeamStateRoot === 'string')
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            else
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it('keeps missing state_read side-effect-free without setup', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-read-test-'));
-        try {
-            const stateDir = join(wd, '.omx', 'state');
-            const tmuxHookConfig = join(wd, '.omx', 'tmux-hook.json');
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_read',
-                    arguments: { workingDirectory: wd, mode: 'deep-interview' },
-                },
-            });
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            assert.deepEqual(JSON.parse(response.content[0]?.text || '{}'), { exists: false, mode: 'deep-interview' });
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('keeps state_get_status side-effect-free without setup', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-status-test-'));
-        try {
-            const stateDir = join(wd, '.omx', 'state');
-            const tmuxHookConfig = join(wd, '.omx', 'tmux-hook.json');
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_get_status',
-                    arguments: { workingDirectory: wd },
-                },
-            });
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            assert.deepEqual(JSON.parse(response.content[0]?.text || '{}'), { statuses: {} });
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('bootstraps state-tool tmux-hook from the current tmux pane for mutating tools', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-test-live-'));
-        try {
-            const tmuxHookConfig = join(wd, '.omx', 'tmux-hook.json');
-            const fakeBin = await createFakeTmuxBin(wd);
-            await withAmbientTmuxEnv({
-                TMUX: '/tmp/maintainer-default,123,0',
-                TMUX_PANE: '%777',
-                PATH: `${fakeBin}:${process.env.PATH || ''}`,
-            }, async () => {
-                const response = await handleStateToolCall({
-                    params: {
-                        name: 'state_write',
-                        arguments: {
-                            workingDirectory: wd,
-                            mode: 'deep-interview',
-                            active: true,
-                            current_phase: 'deep-interview',
-                        },
-                    },
-                });
-                const payload = JSON.parse(response.content[0]?.text || '{}');
-                assert.equal(payload.success, true);
-            });
-            const tmuxConfig = JSON.parse(await readFile(tmuxHookConfig, 'utf-8'));
-            assert.deepEqual(tmuxConfig.target, { type: 'pane', value: '%777' });
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('writes and reads deep-interview state', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-test-'));
-        try {
-            const writeResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                        active: true,
-                        current_phase: 'deep-interview',
-                        state: {
-                            current_focus: 'intent',
-                            threshold: 0.2,
-                        },
-                    },
-                },
-            });
-            assert.equal(writeResponse.isError, undefined);
-            assert.deepEqual(JSON.parse(writeResponse.content[0]?.text || '{}'), {
-                success: true,
-                mode: 'deep-interview',
-                path: join(wd, '.omx', 'state', 'deep-interview-state.json'),
-            });
-            const readResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_read',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                    },
-                },
-            });
-            assert.equal(readResponse.isError, undefined);
-            const readBody = JSON.parse(readResponse.content[0]?.text || '{}');
-            assert.equal(readBody.active, true);
-            assert.equal(readBody.current_phase, 'deep-interview');
-            assert.equal(readBody.current_focus, 'intent');
-            assert.equal(readBody.threshold, 0.2);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('accepts canonical lifecycle_outcome and backfills compatibility run_outcome', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-lifecycle-'));
-        try {
-            const writeResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                        active: false,
-                        lifecycle_outcome: 'askuserQuestion',
-                        state: {
-                            current_focus: 'intent',
-                        },
-                    },
-                },
-            });
-            assert.equal(writeResponse.isError, undefined);
-            const readResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_read',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                    },
-                },
-            });
-            const readBody = JSON.parse(readResponse.content[0]?.text || '{}');
-            assert.equal(readBody.lifecycle_outcome, 'askuserQuestion');
-            assert.equal(readBody.run_outcome, 'blocked_on_user');
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('derives canonical lifecycle_outcome from legacy run_outcome when needed', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-run-outcome-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        active: false,
-                        run_outcome: 'cancelled',
-                    },
-                },
-            });
-            const readResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_read',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                    },
-                },
-            });
-            const readBody = JSON.parse(readResponse.content[0]?.text || '{}');
-            assert.equal(readBody.lifecycle_outcome, 'userinterlude');
-            assert.equal(readBody.run_outcome, 'cancelled');
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('keeps session-scoped state_get_status side-effect-free when session_id is provided', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-test-'));
-        try {
-            const stateDir = join(wd, '.omx', 'state');
-            const sessionDir = join(wd, '.omx', 'state', 'sessions', 'sess1');
-            const tmuxHookConfig = join(wd, '.omx', 'tmux-hook.json');
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(sessionDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_get_status',
-                    arguments: { workingDirectory: wd, session_id: 'sess1' },
-                },
-            });
-            assert.equal(existsSync(stateDir), false);
-            assert.equal(existsSync(sessionDir), false);
-            assert.equal(existsSync(tmuxHookConfig), false);
-            assert.deepEqual(JSON.parse(response.content[0]?.text || '{}'), { statuses: {} });
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('state_write accepts canonical lifecycle_outcome while preserving compatibility run_outcome', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-lifecycle-'));
-        try {
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'autopilot',
-                        active: false,
-                        current_phase: 'waiting-for-user-answer',
-                        lifecycle_outcome: 'askuserQuestion',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            const state = JSON.parse(await readFile(join(wd, '.omx', 'state', 'autopilot-state.json'), 'utf-8'));
-            assert.equal(state.active, false);
-            assert.equal(state.lifecycle_outcome, 'askuserQuestion');
-            assert.equal(state.terminal_outcome, undefined);
-            assert.equal(state.run_outcome, 'blocked_on_user');
-            assert.ok(state.completed_at);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('state_write lets canonical lifecycle_outcome take precedence over legacy run_outcome', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-lifecycle-precedence-'));
-        try {
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'autopilot',
-                        active: false,
-                        current_phase: 'user-stopped',
-                        run_outcome: 'failed',
-                        lifecycle_outcome: 'userinterlude',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            const state = JSON.parse(await readFile(join(wd, '.omx', 'state', 'autopilot-state.json'), 'utf-8'));
-            assert.equal(state.lifecycle_outcome, 'userinterlude');
-            assert.equal(state.run_outcome, 'cancelled');
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('serializes concurrent state_write calls per mode file and preserves merged fields', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-test-'));
-        try {
-            const writes = Array.from({ length: 16 }, (_, i) => handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        state: { [`k${i}`]: i },
-                    },
-                },
-            }));
-            const responses = await Promise.all(writes);
-            for (const response of responses) {
-                assert.equal(response.isError, undefined);
-            }
-            const filePath = join(wd, '.omx', 'state', 'team-state.json');
-            const state = JSON.parse(await readFile(filePath, 'utf-8'));
-            for (let i = 0; i < 16; i++) {
-                assert.equal(state[`k${i}`], i);
-            }
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('syncs canonical skill-active state for tracked mode writes and clears', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-canonical-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-sync',
-                        mode: 'ralph',
-                        active: true,
-                        iteration: 1,
-                        max_iterations: 3,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            const canonicalPath = join(wd, '.omx', 'state', 'sessions', 'sess-sync', 'skill-active-state.json');
-            const canonical = JSON.parse(await readFile(canonicalPath, 'utf-8'));
-            assert.deepEqual(canonical.active_skills, [{
-                    skill: 'ralph',
-                    phase: 'executing',
-                    active: true,
-                    activated_at: canonical.active_skills?.[0]?.activated_at,
-                    updated_at: canonical.active_skills?.[0]?.updated_at,
-                    session_id: 'sess-sync',
-                }]);
-            await handleStateToolCall({
-                params: {
-                    name: 'state_clear',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-sync',
-                        mode: 'ralph',
-                    },
-                },
-            });
-            const clearedCanonical = JSON.parse(await readFile(canonicalPath, 'utf-8'));
-            assert.equal(clearedCanonical.active, false);
-            assert.deepEqual(clearedCanonical.active_skills, []);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('writes a session-scoped inactive tombstone when clearing a mode under an active session', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-clear-root-fallback-'));
-        try {
-            const stateDir = join(wd, '.omx', 'state');
-            const sessionId = 'sess-clear';
-            const sessionDir = join(stateDir, 'sessions', sessionId);
-            await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
-            await writeFile(join(stateDir, 'deep-interview-state.json'), JSON.stringify({ active: true, mode: 'deep-interview', current_phase: 'legacy-root' }, null, 2));
-            await writeFile(join(sessionDir, 'deep-interview-state.json'), JSON.stringify({ active: true, mode: 'deep-interview', current_phase: 'session-active' }, null, 2));
-            await handleStateToolCall({
-                params: {
-                    name: 'state_clear',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                    },
-                },
-            });
-            const sessionState = JSON.parse(await readFile(join(sessionDir, 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(sessionState.active, false);
-            assert.equal(sessionState.current_phase, 'cleared');
-            assert.equal(sessionState.session_id, sessionId);
-            const listResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_list_active',
-                    arguments: {
-                        workingDirectory: wd,
-                    },
-                },
-            });
-            assert.deepEqual(JSON.parse(listResponse.content[0]?.text || '{}'), { active_modes: [] });
-            const readResponse = await handleStateToolCall({
-                params: {
-                    name: 'state_read',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'deep-interview',
-                    },
-                },
-            });
-            const readBody = JSON.parse(readResponse.content[0]?.text || '{}');
-            assert.equal(readBody.active, false);
-            assert.equal(readBody.current_phase, 'cleared');
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('allows approved overlaps and preserves the remaining canonical state on clear', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-overlap-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-overlap',
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'running',
-                    },
-                },
-            });
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-overlap',
-                        mode: 'ralph',
-                        active: true,
-                        iteration: 1,
-                        max_iterations: 3,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            const canonicalPath = join(wd, '.omx', 'state', 'sessions', 'sess-overlap', 'skill-active-state.json');
-            const canonical = JSON.parse(await readFile(canonicalPath, 'utf-8'));
-            assert.deepEqual(canonical.active_skills?.map((entry) => entry.skill), ['team', 'ralph']);
-            await handleStateToolCall({
-                params: {
-                    name: 'state_clear',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-overlap',
-                        mode: 'team',
-                    },
-                },
-            });
-            const clearedCanonical = JSON.parse(await readFile(canonicalPath, 'utf-8'));
-            assert.equal(clearedCanonical.active, true);
-            assert.equal(clearedCanonical.skill, 'ralph');
-            assert.deepEqual(clearedCanonical.active_skills?.map((entry) => entry.skill), ['ralph']);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('denies unsupported overlaps without writing the requested mode state', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-deny-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-deny',
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'running',
-                    },
-                },
-            });
-            const denied = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-deny',
-                        mode: 'autopilot',
-                        active: true,
-                        current_phase: 'ralplan',
-                    },
-                },
-            });
-            assert.equal(denied.isError, true);
-            assert.match(denied.content[0]?.text || '', /Unsupported workflow overlap: team \+ autopilot\./);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', 'sess-deny', 'autopilot-state.json')), false);
-            const canonical = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-deny', 'skill-active-state.json'), 'utf-8'));
-            assert.deepEqual(canonical.active_skills?.map((entry) => entry.skill), ['team']);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('allows ultrawork when canonical session state is stricter than mode files', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-canonical-prevalidate-'));
-        try {
-            await mkdir(join(wd, '.omx', 'state', 'sessions', 'sess-canonical-deny'), { recursive: true });
-            await writeFile(join(wd, '.omx', 'state', 'team-state.json'), JSON.stringify({ active: true, mode: 'team', current_phase: 'running' }, null, 2));
-            await writeFile(join(wd, '.omx', 'state', 'skill-active-state.json'), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'team',
-                active_skills: [{ skill: 'team', phase: 'running', active: true }],
-            }, null, 2));
-            await writeFile(join(wd, '.omx', 'state', 'sessions', 'sess-canonical-deny', 'skill-active-state.json'), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'team',
-                session_id: 'sess-canonical-deny',
-                active_skills: [
-                    { skill: 'team', phase: 'running', active: true },
-                    { skill: 'ralph', phase: 'executing', active: true, session_id: 'sess-canonical-deny' },
-                ],
-            }, null, 2));
-            const allowed = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-canonical-deny',
-                        mode: 'ultrawork',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(allowed.isError, undefined);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', 'sess-canonical-deny', 'ultrawork-state.json')), true);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('removes tracked workflows from canonical skill-active state on all_sessions clear', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-canonical-clear-all-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'running',
-                    },
-                },
-            });
-            await handleStateToolCall({
-                params: {
-                    name: 'state_clear',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        all_sessions: true,
-                    },
-                },
-            });
-            const canonicalPath = join(wd, '.omx', 'state', 'skill-active-state.json');
-            const canonical = JSON.parse(await readFile(canonicalPath, 'utf-8'));
-            assert.equal(canonical.active, false);
-            assert.deepEqual(canonical.active_skills, []);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('does not propagate root clears into isolated session canonical copies', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-root-clear-propagate-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'running',
-                    },
-                },
-            });
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-root-clear',
-                        mode: 'ralph',
-                        active: true,
-                        iteration: 1,
-                        max_iterations: 3,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            await handleStateToolCall({
-                params: {
-                    name: 'state_clear',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                    },
-                },
-            });
-            const sessionCanonical = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-root-clear', 'skill-active-state.json'), 'utf-8'));
-            assert.deepEqual(sessionCanonical.active_skills?.map((entry) => entry.skill), ['ralph']);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('keeps root-scoped team state out of session-scoped ralph canonical state', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-team-ralph-'));
-        try {
-            const teamWrite = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'running',
-                    },
-                },
-            });
-            assert.equal(teamWrite.isError, undefined);
-            const ralphWrite = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-team-ralph',
-                        mode: 'ralph',
-                        active: true,
-                        iteration: 1,
-                        max_iterations: 5,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            assert.equal(ralphWrite.isError, undefined);
-            const rootCanonical = JSON.parse(await readFile(join(wd, '.omx', 'state', 'skill-active-state.json'), 'utf-8'));
-            assert.deepEqual(rootCanonical.active_skills?.map(({ skill, phase, session_id }) => ({
-                skill,
-                phase,
-                session_id,
-            })), [{ skill: 'team', phase: 'running', session_id: undefined }]);
-            const sessionCanonical = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-team-ralph', 'skill-active-state.json'), 'utf-8'));
-            assert.deepEqual(sessionCanonical.active_skills?.map(({ skill, phase, session_id }) => ({
-                skill,
-                phase,
-                session_id,
-            })), [{ skill: 'ralph', phase: 'executing', session_id: 'sess-team-ralph' }]);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('rejects standalone overlaps without mutating canonical state', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-standalone-overlap-'));
-        try {
-            const autopilotWrite = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-standalone',
-                        mode: 'autopilot',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(autopilotWrite.isError, undefined);
-            const invalidTeamWrite = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-standalone',
-                        mode: 'team',
-                        active: true,
-                        current_phase: 'starting',
-                    },
-                },
-            });
-            assert.equal(invalidTeamWrite.isError, true);
-            const body = JSON.parse(invalidTeamWrite.content[0]?.text || '{}');
-            assert.match(body.error || '', /omx state/i);
-            assert.match(body.error || '', /omx_state\.\*/i);
-            const canonical = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-standalone', 'skill-active-state.json'), 'utf-8'));
-            assert.deepEqual(canonical.active_skills?.map(({ skill, phase, session_id }) => ({
-                skill,
-                phase,
-                session_id,
-            })), [{ skill: 'autopilot', phase: 'planning', session_id: 'sess-standalone' }]);
-            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', 'sess-standalone', 'team-state.json')), false);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('auto-completes deep-interview when starting ralplan and returns transition messaging', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-handoff-interview-'));
-        try {
-            await mkdir(join(wd, '.omx', 'state', 'sessions', 'sess-handoff'), { recursive: true });
-            await writeFile(join(wd, '.omx', 'state', 'sessions', 'sess-handoff', 'deep-interview-state.json'), JSON.stringify({
-                active: true,
-                mode: 'deep-interview',
-                current_phase: 'intent-first',
-                deep_interview_gate: {
-                    status: 'complete',
-                    rationale: 'Requirements are clarified and ready for ralplan consensus.',
-                },
-            }, null, 2));
-            const response = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-handoff',
-                        mode: 'ralplan',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(response.isError, undefined);
-            const body = JSON.parse(response.content[0]?.text || '{}');
-            assert.equal(body.transition, 'mode transiting: deep-interview -> ralplan');
-            const completed = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-handoff', 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(completed.active, false);
-            assert.equal(completed.current_phase, 'completed');
-            assert.equal(typeof completed.completed_at, 'string');
-            assert.equal(completed.run_outcome, 'finish');
-            assert.match(completed.auto_completed_reason || '', /mode transiting: deep-interview -> ralplan/);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
-    it('rejects execution-to-planning rollback with clear-first guidance', async () => {
-        process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
-        const { handleStateToolCall } = await import('../state-server.js');
-        const wd = await mkdtemp(join(tmpdir(), 'omx-state-server-rollback-'));
-        try {
-            await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-rollback',
-                        mode: 'ralph',
-                        active: true,
-                        current_phase: 'executing',
-                    },
-                },
-            });
-            const denied = await handleStateToolCall({
-                params: {
-                    name: 'state_write',
-                    arguments: {
-                        workingDirectory: wd,
-                        session_id: 'sess-rollback',
-                        mode: 'ralplan',
-                        active: true,
-                        current_phase: 'planning',
-                    },
-                },
-            });
-            assert.equal(denied.isError, true);
-            const body = JSON.parse(denied.content[0]?.text || '{}');
-            assert.match(body.error || '', /Execution-to-planning rollback auto-complete is not allowed/i);
-            assert.match(body.error || '', /First clear current state first and retry if this action is intended/i);
-        }
-        finally {
-            await rm(wd, { recursive: true, force: true });
-        }
-    });
     it('does not auto-complete existing workflow state when tracked write validation fails', async () => {
         process.env.OMX_STATE_SERVER_DISABLE_AUTO_START = '1';
         const { handleStateToolCall } = await import('../state-server.js');
@@ -1123,7 +101,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'definitely-invalid',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(denied.isError, true);
             const body = JSON.parse(denied.content[0]?.text || '{}');
             assert.match(body.error || '', /ralph\.current_phase/i);
@@ -1152,7 +130,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'planning',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(first.isError, undefined);
             const second = await handleStateToolCall({
                 params: {
@@ -1165,7 +143,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'planning',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(second.isError, undefined);
         }
         finally {
@@ -1188,7 +166,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'interview-a',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(writeA.isError, undefined);
             const writeB = await handleStateToolCall({
                 params: {
@@ -1203,7 +181,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'executing',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(writeB.isError, undefined);
             await handleStateToolCall({
                 params: {
@@ -1214,7 +192,7 @@ describe('state-server directory initialization', () => {
                         mode: 'ralph',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             const sessionAState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-a', 'deep-interview-state.json'), 'utf-8'));
             assert.equal(sessionAState.active, true);
             assert.equal(sessionAState.current_phase, 'interview-a');
@@ -1241,7 +219,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'asking',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             const rootWrite = await handleStateToolCall({
                 params: {
                     name: 'state_write',
@@ -1252,7 +230,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'planning',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(rootWrite.isError, undefined);
             const sessionState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-interview', 'deep-interview-state.json'), 'utf-8'));
             assert.equal(sessionState.active, true);
@@ -1283,7 +261,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'asking',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             await handleStateToolCall({
                 params: {
                     name: 'state_write',
@@ -1294,7 +272,7 @@ describe('state-server directory initialization', () => {
                         current_phase: 'root-asking',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             await handleStateToolCall({
                 params: {
                     name: 'state_clear',
@@ -1303,7 +281,7 @@ describe('state-server directory initialization', () => {
                         mode: 'deep-interview',
                     },
                 },
-            });
+            }, { allowWriterTools: true });
             assert.equal(existsSync(join(wd, '.omx', 'state', 'deep-interview-state.json')), false);
             const sessionState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'sessions', 'sess-keep', 'deep-interview-state.json'), 'utf-8'));
             assert.equal(sessionState.active, true);