oh-my-codex 0.18.1 → 0.18.3

package/dist/hooks/__tests__/keyword-detector.test.js

@@ -8,6 +8,21 @@ import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, DEEP_INTER
 import { SKILL_ACTIVE_STATE_FILE } from '../../state/skill-active.js';
 import { isUnderspecifiedForExecution, applyRalplanGate } from '../keyword-detector.js';
 import { KEYWORD_TRIGGER_DEFINITIONS } from '../keyword-registry.js';
+async function withIsolatedHome(prefix, run) {
+    const homeDir = await mkdtemp(join(tmpdir(), `omx-keyword-home-${prefix}-`));
+    const previousHome = process.env.HOME;
+    try {
+        process.env.HOME = homeDir;
+        return await run(homeDir);
+    }
+    finally {
+        if (typeof previousHome === 'string')
+            process.env.HOME = previousHome;
+        else
+            delete process.env.HOME;
+        await rm(homeDir, { recursive: true, force: true });
+    }
+}
 describe('keyword detector team compatibility', () => {
     it('keeps explicit $skill order in detectKeywords results (left-to-right)', () => {
         const matches = detectKeywords('$analyze $ultraqa $code-review now');
@@ -194,6 +209,11 @@ describe('keyword detector team compatibility', () => {
         assert.equal(detectPrimaryKeyword('cleanup stale deep-interview state after session clear'), null);
         assert.equal(detectPrimaryKeyword('remove the stale deep interview lock from .omx/state'), null);
     });
+    it('does not trigger deep-interview from casual discussion mentions', () => {
+        assert.equal(detectPrimaryKeyword('the deep interview report is useful context for the next plan'), null);
+        assert.equal(detectPrimaryKeyword('we already did a deep interview and should not reactivate it'), null);
+        assert.equal(detectPrimaryKeyword('this interview transcript says implementation is ready'), null);
+    });
     it('maps "gather requirements" to deep-interview skill', () => {
         const match = detectPrimaryKeyword('let us gather requirements first');
         assert.ok(match);
@@ -285,6 +305,13 @@ describe('explicit skill-name invocation requirement', () => {
     it('does not trigger ralplan from bare skill-name usage', () => {
         assert.equal(detectPrimaryKeyword('please do ralplan first'), null);
     });
+    it('detects explicit prometheus-strict invocation only', () => {
+        const match = detectPrimaryKeyword('please run $prometheus-strict before implementation');
+        assert.ok(match);
+        assert.equal(match.skill, 'prometheus-strict');
+        assert.equal(match.keyword.toLowerCase(), '$prometheus-strict');
+        assert.equal(detectPrimaryKeyword('please use prometheus-strict planning here'), null);
+    });
 });
 describe('keyword registry coverage', () => {
     it('includes key team aliases in runtime keyword registry', () => {
@@ -304,6 +331,7 @@ describe('keyword registry coverage', () => {
         assert.ok(registryKeywords.has('wiki lint'));
         assert.ok(registryKeywords.has('$autoresearch'));
         assert.ok(registryKeywords.has('$ultragoal'));
+        assert.ok(registryKeywords.has('$prometheus-strict'));
         assert.ok(registryKeywords.has('ultragoal'));
     });
 });
@@ -398,7 +426,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(root, { recursive: true, force: true });
         }
     });
-    it('writes skill-active-state.json with ralplan phase when autopilot keyword activates', async () => {
+    it('writes skill-active-state.json with deep-interview phase when autopilot keyword activates', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-'));
         const stateDir = join(cwd, '.omx', 'state');
         try {
@@ -413,11 +441,11 @@ describe('keyword detector skill-active-state lifecycle', () => {
             });
             assert.ok(result);
             assert.equal(result.skill, 'autopilot');
-            assert.equal(result.phase, 'ralplan');
+            assert.equal(result.phase, 'deep-interview');
             assert.equal(result.active, true);
             assert.deepEqual(result.active_skills, [{
                     skill: 'autopilot',
-                    phase: 'ralplan',
+                    phase: 'deep-interview',
                     active: true,
                     activated_at: '2026-02-25T00:00:00.000Z',
                     updated_at: '2026-02-25T00:00:00.000Z',
@@ -439,7 +467,27 @@ describe('keyword detector skill-active-state lifecycle', () => {
             assert.equal(modeState.review_cycle, 0);
             assert.equal(modeState.max_iterations, 10);
             assert.deepEqual(modeState.state.phase_cycle, ['deep-interview', 'ralplan', 'ultragoal', 'code-review', 'ultraqa']);
-            assert.deepEqual(modeState.state.handoff_artifacts, { deep_interview: null, ralplan: null, ultragoal: null, code_review: null, ultraqa: null });
+            assert.deepEqual(modeState.state.deep_interview_gate, {
+                status: 'required',
+                skip_reason: null,
+                rationale: 'Autopilot starts at the deep-interview gate by default; clear bounded tasks may skip only with an explicit persisted skip reason.',
+            });
+            assert.deepEqual(modeState.state.handoff_artifacts, {
+                deep_interview: null,
+                ralplan: null,
+                ralplan_consensus_gate: {
+                    required: true,
+                    sequence: ['architect-review', 'critic-review'],
+                    planning_artifacts_are_not_consensus: true,
+                    required_review_roles: ['architect', 'critic'],
+                    ralplan_architect_review: null,
+                    ralplan_critic_review: null,
+                    complete: false,
+                },
+                ultragoal: null,
+                code_review: null,
+                ultraqa: null,
+            });
             assert.equal(modeState.state.review_verdict, null);
             assert.equal(modeState.state.qa_verdict, null);
             assert.equal(modeState.state.return_to_ralplan_reason, null);
@@ -792,18 +840,56 @@ describe('keyword detector skill-active-state lifecycle', () => {
             }, null, 2));
             const result = await recordSkillActivation({
                 stateDir,
-                text: '$ralplan implement the approved contract',
+                text: '$ultragoal turn the clarified spec into goals',
                 sessionId: 'sess-handoff',
                 nowIso: '2026-04-10T00:00:00.000Z',
             });
             assert.equal(result?.transition_error, undefined);
-            assert.equal(result?.transition_message, 'mode transiting: deep-interview -> ralplan');
+            assert.equal(result?.skill, 'ultragoal');
+            assert.equal(result?.initialized_mode, 'ultragoal');
+            assert.equal(result?.initialized_state_path, '.omx/state/sessions/sess-handoff/ultragoal-state.json');
+            assert.equal(result?.transition_message, 'mode transiting: deep-interview -> ultragoal');
             const completed = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-handoff', 'deep-interview-state.json'), 'utf-8'));
             assert.equal(completed.active, false);
             assert.equal(completed.current_phase, 'completed');
             assert.equal(completed.question_enforcement?.status, 'cleared');
             assert.equal(completed.question_enforcement?.clear_reason, 'handoff');
             assert.ok(completed.question_enforcement?.cleared_at);
+            const ultragoal = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-handoff', 'ultragoal-state.json'), 'utf-8'));
+            assert.equal(ultragoal.active, true);
+            assert.equal(ultragoal.mode, 'ultragoal');
+            assert.equal(ultragoal.current_phase, 'planning');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps ralplan as an allowlisted deep-interview forward handoff', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-ralplan-handoff-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(stateDir, 'sessions', 'sess-ralplan-handoff'), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-handoff', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'deep-interview',
+                phase: 'planning',
+                session_id: 'sess-ralplan-handoff',
+                active_skills: [{ skill: 'deep-interview', phase: 'planning', active: true, session_id: 'sess-ralplan-handoff' }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-handoff', 'deep-interview-state.json'), JSON.stringify({ active: true, mode: 'deep-interview', current_phase: 'intent-first' }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$ralplan implement the approved contract',
+                sessionId: 'sess-ralplan-handoff',
+                nowIso: '2026-04-10T00:00:00.000Z',
+            });
+            assert.equal(result?.transition_error, undefined);
+            assert.equal(result?.skill, 'ralplan');
+            assert.equal(result?.transition_message, 'mode transiting: deep-interview -> ralplan');
+            const completed = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-handoff', 'deep-interview-state.json'), 'utf-8'));
+            assert.equal(completed.active, false);
+            assert.equal(completed.current_phase, 'completed');
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1008,6 +1094,292 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('persists repo-local deep-interview config values into activation and mode state', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-config-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'config.toml'), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+enableChallengeModes = false
+`);
+            const result = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$deep-interview clarify runtime config',
+                sessionId: 'sess-deep-interview-config',
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'deep-interview');
+            assert.equal(result.deep_interview_config?.profile, 'standard');
+            assert.equal(result.deep_interview_config?.threshold, 0.05);
+            assert.equal(result.deep_interview_config?.maxRounds, 15);
+            assert.equal(result.initialized_state_path, '.omx/state/sessions/sess-deep-interview-config/deep-interview-state.json');
+            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-deep-interview-config', DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
+            assert.equal(modeState.profile, 'standard');
+            assert.equal(modeState.threshold, 0.05);
+            assert.equal(modeState.max_rounds, 15);
+            assert.equal(modeState.enable_challenge_modes, false);
+            assert.equal(modeState.config_source, join(cwd, '.omx', 'config.toml'));
+            assert.equal(modeState.deep_interview_config?.sourcePath, join(cwd, '.omx', 'config.toml'));
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('persists deep-interview config when mixed workflow prompts defer execution modes', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-config-mixed-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-deep-interview-config-mixed';
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'config.toml'), `[omx.deepInterview]
+defaultProfile = "deep"
+deepThreshold = 0.13
+deepMaxRounds = 21
+enableChallengeModes = false
+`);
+            const result = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$autopilot $deep-interview prove mixed workflow config',
+                sessionId,
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'deep-interview');
+            assert.deepEqual(result.deferred_skills, ['autopilot']);
+            assert.equal(result.input_lock?.active, true);
+            assert.equal(result.deep_interview_config?.profile, 'deep');
+            assert.equal(result.deep_interview_config?.threshold, 0.13);
+            assert.equal(result.deep_interview_config?.maxRounds, 21);
+            assert.equal(result.deep_interview_config?.enableChallengeModes, false);
+            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
+            assert.equal(modeState.profile, 'deep');
+            assert.equal(modeState.threshold, 0.13);
+            assert.equal(modeState.max_rounds, 21);
+            assert.equal(modeState.enable_challenge_modes, false);
+            assert.equal(modeState.config_source, join(cwd, '.omx', 'config.toml'));
+            assert.equal(modeState.deep_interview_config?.profile, 'deep');
+            assert.equal(modeState.input_lock?.active, true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('shows before-after state change when deep-interview config is added at runtime', async () => {
+        await withIsolatedHome('deep-interview-config-before-after', async () => {
+            const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-config-before-after-'));
+            const stateDir = join(cwd, '.omx', 'state');
+            const sessionId = 'sess-deep-interview-config-before-after';
+            const statePath = join(stateDir, 'sessions', sessionId, DEEP_INTERVIEW_STATE_FILE);
+            try {
+                await mkdir(join(cwd, '.omx'), { recursive: true });
+                await mkdir(stateDir, { recursive: true });
+                const before = await recordSkillActivation({
+                    stateDir,
+                    sourceCwd: cwd,
+                    text: '$deep-interview prove config before state',
+                    sessionId,
+                    nowIso: '2026-02-25T00:00:00.000Z',
+                });
+                const beforeModeState = JSON.parse(await readFile(statePath, 'utf-8'));
+                assert.ok(before);
+                assert.equal(before.deep_interview_config, undefined);
+                assert.equal(beforeModeState.deep_interview_config, undefined);
+                assert.equal(beforeModeState.profile, undefined);
+                assert.equal(beforeModeState.threshold, undefined);
+                assert.equal(beforeModeState.max_rounds, undefined);
+                assert.equal(beforeModeState.config_source, undefined);
+                await writeFile(join(cwd, '.omx', 'config.toml'), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+`);
+                const after = await recordSkillActivation({
+                    stateDir,
+                    sourceCwd: cwd,
+                    text: '$deep-interview prove config after state',
+                    sessionId,
+                    nowIso: '2026-02-25T00:00:01.000Z',
+                });
+                const afterModeState = JSON.parse(await readFile(statePath, 'utf-8'));
+                assert.ok(after);
+                assert.equal(after.deep_interview_config?.profile, 'standard');
+                assert.equal(after.deep_interview_config?.threshold, 0.05);
+                assert.equal(after.deep_interview_config?.maxRounds, 15);
+                assert.equal(afterModeState.deep_interview_config?.profile, 'standard');
+                assert.equal(afterModeState.profile, 'standard');
+                assert.equal(afterModeState.threshold, 0.05);
+                assert.equal(afterModeState.max_rounds, 15);
+                assert.equal(afterModeState.config_source, join(cwd, '.omx', 'config.toml'));
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        });
+    });
+    it('preserves deep-interview config values during continuation prompts', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-config-continuation-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-deep-interview-config-continuation';
+        const statePath = join(stateDir, 'sessions', sessionId, DEEP_INTERVIEW_STATE_FILE);
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'config.toml'), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.05
+standardMaxRounds = 15
+`);
+            await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$deep-interview prove config continuation',
+                sessionId,
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            const continued = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: 'continue',
+                sessionId,
+                nowIso: '2026-02-25T00:00:01.000Z',
+            });
+            const modeState = JSON.parse(await readFile(statePath, 'utf-8'));
+            assert.equal(continued?.skill, 'deep-interview');
+            assert.equal(continued?.deep_interview_config?.profile, 'standard');
+            assert.equal(continued?.deep_interview_config?.threshold, 0.05);
+            assert.equal(continued?.deep_interview_config?.maxRounds, 15);
+            assert.equal(modeState.deep_interview_config?.profile, 'standard');
+            assert.equal(modeState.profile, 'standard');
+            assert.equal(modeState.threshold, 0.05);
+            assert.equal(modeState.max_rounds, 15);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('preserves explicit deep-interview profile flags during continuation prompts', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-config-profile-continuation-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-deep-interview-config-profile-continuation';
+        const statePath = join(stateDir, 'sessions', sessionId, DEEP_INTERVIEW_STATE_FILE);
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'config.toml'), `[omx.deepInterview]
+defaultProfile = "standard"
+standardThreshold = 0.22
+standardMaxRounds = 13
+deepThreshold = 0.13
+deepMaxRounds = 21
+`);
+            const started = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$deep-interview --deep prove explicit profile continuation',
+                sessionId,
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            const continued = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: 'continue',
+                sessionId,
+                nowIso: '2026-02-25T00:00:01.000Z',
+            });
+            const modeState = JSON.parse(await readFile(statePath, 'utf-8'));
+            assert.equal(started?.deep_interview_config?.profile, 'deep');
+            assert.equal(continued?.deep_interview_config?.profile, 'deep');
+            assert.equal(continued?.deep_interview_config?.threshold, 0.13);
+            assert.equal(continued?.deep_interview_config?.maxRounds, 21);
+            assert.equal(modeState.deep_interview_config?.profile, 'deep');
+            assert.equal(modeState.profile, 'deep');
+            assert.equal(modeState.threshold, 0.13);
+            assert.equal(modeState.max_rounds, 21);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps the documented deep-interview Suggested Config executable through activation state', async () => {
+        const skillDoc = await readFile(join(process.cwd(), 'skills', 'deep-interview', 'SKILL.md'), 'utf-8');
+        const markerIndex = skillDoc.indexOf('## Suggested Config (optional)');
+        assert.notEqual(markerIndex, -1);
+        const configMatch = skillDoc.slice(markerIndex).match(/```toml\n([\s\S]*?)\n```/);
+        assert.ok(configMatch);
+        const documentedConfig = configMatch[1]?.trimEnd();
+        assert.ok(documentedConfig);
+        assert.match(documentedConfig, /standardThreshold = 0\.20/);
+        assert.match(documentedConfig, /standardMaxRounds = 12/);
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-doc-config-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-deep-interview-doc-config';
+        const statePath = join(stateDir, 'sessions', sessionId, DEEP_INTERVIEW_STATE_FILE);
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'config.toml'), `${documentedConfig}\n`);
+            const result = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$deep-interview prove documented config runtime contract',
+                sessionId,
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            const modeState = JSON.parse(await readFile(statePath, 'utf-8'));
+            assert.ok(result);
+            assert.equal(result.deep_interview_config?.profile, 'standard');
+            assert.equal(result.deep_interview_config?.threshold, 0.2);
+            assert.equal(result.deep_interview_config?.maxRounds, 12);
+            assert.equal(modeState.deep_interview_config?.profile, 'standard');
+            assert.equal(modeState.profile, 'standard');
+            assert.equal(modeState.threshold, 0.2);
+            assert.equal(modeState.max_rounds, 12);
+            assert.equal(modeState.config_source, join(cwd, '.omx', 'config.toml'));
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps deep-interview activation alive when repo config TOML is malformed', async () => {
+        await withIsolatedHome('deep-interview-malformed-config', async () => {
+            const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-malformed-config-'));
+            const stateDir = join(cwd, '.omx', 'state');
+            const originalWarn = console.warn;
+            try {
+                console.warn = () => { };
+                await mkdir(join(cwd, '.omx'), { recursive: true });
+                await mkdir(stateDir, { recursive: true });
+                await writeFile(join(cwd, '.omx', 'config.toml'), '[omx.deepInterview\nstandardThreshold = 0.05\n');
+                const result = await recordSkillActivation({
+                    stateDir,
+                    sourceCwd: cwd,
+                    text: '$deep-interview clarify despite malformed config',
+                    sessionId: 'sess-deep-interview-malformed-config',
+                    nowIso: '2026-02-25T00:00:00.000Z',
+                });
+                assert.ok(result);
+                assert.equal(result.skill, 'deep-interview');
+                assert.equal(result.active, true);
+                assert.equal(result.deep_interview_config, undefined);
+                const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-deep-interview-malformed-config', DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
+                assert.equal(modeState.mode, 'deep-interview');
+                assert.equal(modeState.active, true);
+                assert.equal(modeState.deep_interview_config, undefined);
+            }
+            finally {
+                console.warn = originalWarn;
+                await rm(cwd, { recursive: true, force: true });
+            }
+        });
+    });
     it('creates the session-scoped deep-interview state directory before persisting mode state', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-session-dir-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -1151,7 +1523,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('records ultragoal as a prompt skill without seeding unrelated mode state', async () => {
+    it('records ultragoal as a prompt skill with first-class mode state', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-ultragoal-'));
         const stateDir = join(cwd, '.omx', 'state');
         try {
@@ -1163,9 +1535,12 @@ describe('keyword detector skill-active-state lifecycle', () => {
             assert.ok(result);
             assert.equal(result.skill, 'ultragoal');
             assert.equal(result.keyword, '$ultragoal');
-            assert.equal(result.initialized_mode, undefined);
-            assert.equal(result.initialized_state_path, undefined);
-            assert.equal(existsSync(join(stateDir, 'ultragoal-state.json')), false);
+            assert.equal(result.initialized_mode, 'ultragoal');
+            assert.equal(result.initialized_state_path, '.omx/state/ultragoal-state.json');
+            const modeState = JSON.parse(await readFile(join(stateDir, 'ultragoal-state.json'), 'utf-8'));
+            assert.equal(modeState.active, true);
+            assert.equal(modeState.mode, 'ultragoal');
+            assert.equal(modeState.current_phase, 'planning');
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1696,7 +2071,7 @@ describe('isUnderspecifiedForExecution', () => {
     });
 });
 describe('applyRalplanGate', () => {
-    it('does not re-enter ralplan for a short approved team follow-up', async () => {
+    it('gates short team follow-up when only PRD/test-spec artifacts exist', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-followup-'));
         try {
             const plansDir = join(cwd, '.omx', 'plans');
@@ -1704,20 +2079,32 @@ describe('applyRalplanGate', () => {
             await writeFile(join(plansDir, 'prd-issue-831.md'), '# Approved plan\n\nLaunch hint: omx team 3:executor "Execute approved issue 831 plan"\n');
             await writeFile(join(plansDir, 'test-spec-issue-831.md'), '# Test spec\n');
             const result = applyRalplanGate(['team'], 'team', { cwd });
-            assert.equal(result.gateApplied, false);
-            assert.deepEqual(result.keywords, ['team']);
+            assert.equal(result.gateApplied, true);
+            assert.deepEqual(result.keywords, ['ralplan']);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('does not re-enter ralplan for a short approved Korean team follow-up', async () => {
+    it('does not re-enter ralplan for a short approved team follow-up with durable consensus', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-followup-ko-'));
         try {
             const plansDir = join(cwd, '.omx', 'plans');
+            const stateDir = join(cwd, '.omx', 'state');
             await mkdir(plansDir, { recursive: true });
+            await mkdir(stateDir, { recursive: true });
             await writeFile(join(plansDir, 'prd-issue-831.md'), '# Approved plan\n\nLaunch hint: omx team 3:executor "Execute approved issue 831 plan"\n');
             await writeFile(join(plansDir, 'test-spec-issue-831.md'), '# Test spec\n');
+            await writeFile(join(stateDir, 'ralplan-state.json'), JSON.stringify({
+                current_phase: 'complete',
+                planning_complete: true,
+                ralplan_consensus_gate: {
+                    complete: true,
+                    sequence: ['architect-review', 'critic-review'],
+                    ralplan_architect_review: { agent_role: 'architect', verdict: 'approve', iteration: 1 },
+                    ralplan_critic_review: { agent_role: 'critic', verdict: 'approve', iteration: 1 },
+                },
+            }));
             const result = applyRalplanGate(['team'], 'team으로 해줘', { cwd });
             assert.equal(result.gateApplied, false);
             assert.deepEqual(result.keywords, ['team']);
@@ -1726,13 +2113,25 @@ describe('applyRalplanGate', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('does not re-enter ralplan for a short approved ralph follow-up', async () => {
+    it('does not re-enter ralplan for a short approved ralph follow-up with durable consensus', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-followup-ralph-'));
         try {
             const plansDir = join(cwd, '.omx', 'plans');
+            const stateDir = join(cwd, '.omx', 'state');
             await mkdir(plansDir, { recursive: true });
+            await mkdir(stateDir, { recursive: true });
             await writeFile(join(plansDir, 'prd-issue-832.md'), '# Approved plan\n\nLaunch hint: omx ralph "Execute approved issue 832 plan"\n');
             await writeFile(join(plansDir, 'test-spec-issue-832.md'), '# Test spec\n');
+            await writeFile(join(stateDir, 'ralplan-state.json'), JSON.stringify({
+                current_phase: 'complete',
+                planning_complete: true,
+                ralplan_consensus_gate: {
+                    complete: true,
+                    sequence: ['architect-review', 'critic-review'],
+                    ralplan_architect_review: { agent_role: 'architect', verdict: 'approve', iteration: 1 },
+                    ralplan_critic_review: { agent_role: 'critic', verdict: 'approve', iteration: 1 },
+                },
+            }));
             const result = applyRalplanGate(['ralph'], 'ralph please', { cwd, priorSkill: 'ralplan' });
             assert.equal(result.gateApplied, false);
             assert.deepEqual(result.keywords, ['ralph']);
@@ -1741,6 +2140,63 @@ describe('applyRalplanGate', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('ignores ambient OMX_ROOT consensus state for local PRD/test-spec-only follow-up gating', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-local-'));
+        const ambientRoot = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-ambient-'));
+        const previousOmxRoot = process.env.OMX_ROOT;
+        try {
+            const plansDir = join(cwd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            await writeFile(join(plansDir, 'prd-local.md'), '# Plan\n');
+            await writeFile(join(plansDir, 'test-spec-local.md'), '# Test spec\n');
+            const ambientStateDir = join(ambientRoot, '.omx', 'state');
+            await mkdir(ambientStateDir, { recursive: true });
+            await writeFile(join(ambientStateDir, 'ralplan-state.json'), JSON.stringify({
+                current_phase: 'complete',
+                planning_complete: true,
+                ralplan_consensus_gate: {
+                    complete: true,
+                    ralplan_architect_review: { agent_role: 'architect', verdict: 'approve', iteration: 1 },
+                    ralplan_critic_review: { agent_role: 'critic', verdict: 'approve', iteration: 1 },
+                },
+            }));
+            process.env.OMX_ROOT = ambientRoot;
+            const result = applyRalplanGate(['team'], 'team', { cwd });
+            assert.equal(result.gateApplied, true);
+            assert.deepEqual(result.keywords, ['ralplan']);
+        }
+        finally {
+            if (previousOmxRoot === undefined)
+                delete process.env.OMX_ROOT;
+            else
+                process.env.OMX_ROOT = previousOmxRoot;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(ambientRoot, { recursive: true, force: true });
+        }
+    });
+    it('gates short follow-up when local state only has latest verdict fields', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-latest-only-'));
+        try {
+            const plansDir = join(cwd, '.omx', 'plans');
+            const stateDir = join(cwd, '.omx', 'state');
+            await mkdir(plansDir, { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(plansDir, 'prd-local.md'), '# Plan\n\nLaunch hint: omx team 3:executor "Execute approved local plan"\n');
+            await writeFile(join(plansDir, 'test-spec-local.md'), '# Test spec\n');
+            await writeFile(join(stateDir, 'ralplan-state.json'), JSON.stringify({
+                current_phase: 'complete',
+                planning_complete: true,
+                latest_architect_verdict: 'approve',
+                latest_critic_verdict: 'approve',
+            }));
+            const result = applyRalplanGate(['team'], 'team', { cwd });
+            assert.equal(result.gateApplied, true);
+            assert.deepEqual(result.keywords, ['ralplan']);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('redirects underspecified execution keywords to ralplan', () => {
         const result = applyRalplanGate(['ralph'], 'ralph fix this');
         assert.equal(result.gateApplied, true);