oh-my-codex 0.18.6 → 0.18.7

package/dist/state/__tests__/operations.test.js

@@ -2,9 +2,10 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { executeStateOperation } from '../operations.js';
+import { subagentTrackingPath } from '../../subagents/tracker.js';
 async function withAmbientTmuxEnv(env, run) {
     const previousTmux = process.env.TMUX;
     const previousTmuxPane = process.env.TMUX_PANE;
@@ -39,6 +40,80 @@ async function withAmbientTmuxEnv(env, run) {
             delete process.env.PATH;
     }
 }
+async function withOmxRootEnv(root, run) {
+    const previousOmxRoot = process.env.OMX_ROOT;
+    const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
+    const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+    process.env.OMX_ROOT = root;
+    delete process.env.OMX_STATE_ROOT;
+    delete process.env.OMX_TEAM_STATE_ROOT;
+    try {
+        return await run();
+    }
+    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;
+    }
+}
+async function writeNativeSubagentTracking(cwd, sessionId) {
+    const trackingPath = subagentTrackingPath(cwd);
+    const now = '2026-05-28T00:00:00.000Z';
+    await mkdir(dirname(trackingPath), { recursive: true });
+    await writeFile(trackingPath, JSON.stringify({
+        schemaVersion: 1,
+        sessions: {
+            [sessionId]: {
+                session_id: sessionId,
+                leader_thread_id: 'thread-leader',
+                updated_at: now,
+                threads: {
+                    'thread-leader': { thread_id: 'thread-leader', kind: 'leader', first_seen_at: now, last_seen_at: now, turn_count: 1 },
+                    'thread-architect': { thread_id: 'thread-architect', kind: 'subagent', first_seen_at: now, last_seen_at: now, completed_at: now, turn_count: 1 },
+                    'thread-critic': { thread_id: 'thread-critic', kind: 'subagent', first_seen_at: now, last_seen_at: now, completed_at: now, turn_count: 1 },
+                },
+            },
+        },
+    }, null, 2));
+}
+function ralplanConsensusGate(sessionId, provenanceKind, threadOverrides = {}) {
+    const architectThread = threadOverrides.architect ?? (provenanceKind === 'native_subagent' ? 'thread-architect' : 'exec-architect');
+    const criticThread = threadOverrides.critic ?? (provenanceKind === 'native_subagent' ? 'thread-critic' : 'exec-critic');
+    return {
+        required: true,
+        complete: true,
+        sequence: ['architect-review', 'critic-review'],
+        planning_artifacts_are_not_consensus: true,
+        required_review_roles: ['architect', 'critic'],
+        ralplan_architect_review: {
+            agent_role: 'architect',
+            verdict: 'approve',
+            provenance_kind: provenanceKind,
+            session_id: sessionId,
+            thread_id: architectThread,
+            artifact_path: '.omx/artifacts/architect.md',
+            tracker_path: '.omx/state/subagent-tracking.json',
+        },
+        ralplan_critic_review: {
+            agent_role: 'critic',
+            verdict: 'approve',
+            provenance_kind: provenanceKind,
+            session_id: sessionId,
+            thread_id: criticThread,
+            artifact_path: '.omx/artifacts/critic.md',
+            tracker_path: '.omx/state/subagent-tracking.json',
+        },
+    };
+}
 async function createFakeTmuxBin(wd) {
     const fakeBin = join(wd, 'bin');
     await mkdir(fakeBin, { recursive: true });
@@ -123,6 +198,69 @@ describe('state operations directory initialization', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('surfaces active ultragoal artifacts in list-active without mode state files', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-ultragoal-artifact-'));
+        try {
+            await mkdir(join(wd, '.omx', 'ultragoal'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'ultragoal', 'goals.json'), JSON.stringify({
+                activeGoalId: 'G001',
+                goals: [{
+                        id: 'G001',
+                        title: 'Fix duplicate HUD panes',
+                        objective: 'Keep one HUD renderer per leader.',
+                        status: 'in_progress',
+                    }],
+            }, null, 2));
+            const activeResponse = await executeStateOperation('state_list_active', {
+                workingDirectory: wd,
+            });
+            assert.deepEqual(activeResponse.payload, { active_modes: ['ultragoal'] });
+            const statusResponse = await executeStateOperation('state_get_status', {
+                workingDirectory: wd,
+                mode: 'ultragoal',
+            });
+            const statuses = statusResponse.payload.statuses || {};
+            assert.equal(statuses.ultragoal?.active, true);
+            assert.equal(statuses.ultragoal?.phase, 'in_progress');
+            assert.equal(statuses.ultragoal?.path, join(wd, '.omx', 'ultragoal', 'goals.json'));
+            assert.equal(statuses.ultragoal?.source, 'ultragoal-artifacts');
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('prefers active ultragoal artifacts over stale inactive mode state', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-ultragoal-stale-state-'));
+        try {
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await mkdir(join(wd, '.omx', 'ultragoal'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'ultragoal-state.json'), JSON.stringify({ active: false, current_phase: 'cleared' }, null, 2));
+            await writeFile(join(wd, '.omx', 'ultragoal', 'goals.json'), JSON.stringify({
+                activeGoalId: 'G001',
+                goals: [{
+                        id: 'G001',
+                        title: 'Fix duplicate HUD panes',
+                        objective: 'Keep one HUD renderer per leader.',
+                        status: 'in_progress',
+                    }],
+            }, null, 2));
+            const activeResponse = await executeStateOperation('state_list_active', {
+                workingDirectory: wd,
+            });
+            assert.deepEqual(activeResponse.payload, { active_modes: ['ultragoal'] });
+            const statusResponse = await executeStateOperation('state_get_status', {
+                workingDirectory: wd,
+                mode: 'ultragoal',
+            });
+            const statuses = statusResponse.payload.statuses || {};
+            assert.equal(statuses.ultragoal?.active, true);
+            assert.equal(statuses.ultragoal?.phase, 'in_progress');
+            assert.equal(statuses.ultragoal?.source, 'ultragoal-artifacts');
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('does not treat root fallback as active for explicit session list-active decisions', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-active-scope-'));
         try {
@@ -478,6 +616,879 @@ describe('state operations directory initialization', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('rejects standalone ralplan writes while preserving active Autopilot supervisor state', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-child-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-child';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'required',
+                            skip_reason: null,
+                        },
+                    },
+                }, null, 2));
+                const denied = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'ralplan',
+                    active: true,
+                    current_phase: 'planning',
+                });
+                assert.equal(denied.isError, true);
+                assert.match(String(denied.payload.error || ''), /Execution-to-planning rollback auto-complete is not allowed\./);
+                assert.equal(existsSync(join(sessionDir, 'ralplan-state.json')), false);
+                const autopilotState = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(autopilotState.active, true);
+                assert.equal(autopilotState.mode, 'autopilot');
+                assert.equal(autopilotState.current_phase, 'deep-interview');
+                assert.equal(autopilotState.auto_completed_reason, undefined);
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('allows Autopilot itself to enter the supervised ralplan child phase', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-child-phase-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-child-phase';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Requirements clarified and ready for consensus planning.',
+                        },
+                        handoff_artifacts: {
+                            deep_interview: {
+                                summary: 'Autopilot may proceed to ralplan.',
+                            },
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, undefined);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.active, true);
+                assert.equal(state.mode, 'autopilot');
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot direct deep-interview to ultragoal skip without deep-interview evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-direct-di-skip-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-direct-di-skip-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: { status: 'required' },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /Cannot transition ralplan -> ultragoal|Unsupported|cannot/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'deep-interview');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot deep-interview completion before the ralplan gate', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-di-complete-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-di-complete-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: { status: 'required' },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: false,
+                    current_phase: 'complete',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /Cannot complete Autopilot before ralplan gate/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'deep-interview');
+                assert.equal(state.active, true);
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot direct deep-interview to ultragoal skip even with deep-interview evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-direct-di-complete-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-direct-di-complete-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Deep-interview is complete, but ralplan consensus is not.',
+                        },
+                        handoff_artifacts: {
+                            deep_interview: { summary: 'Ready for ralplan only.' },
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /Cannot transition ralplan -> ultragoal|Unsupported|cannot/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'deep-interview');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot deep-interview to ralplan self-write when only a satisfied question exists', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-child-phase-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-child-phase-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    question_enforcement: {
+                        obligation_id: 'obligation-answered',
+                        source: 'omx-question',
+                        status: 'satisfied',
+                        lifecycle_outcome: 'askuserQuestion',
+                        requested_at: '2026-05-28T00:00:00.000Z',
+                        question_id: 'question-answered',
+                        satisfied_at: '2026-05-28T00:01:00.000Z',
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /missing deep-interview completion\/skip gate/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'deep-interview');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot waiting-for-user to ralplan self-write while the deep-interview question is unresolved', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-waiting-question-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-waiting-question-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'waiting-for-user',
+                    run_outcome: 'blocked_on_user',
+                    lifecycle_outcome: 'askuserQuestion',
+                    state: {
+                        deep_interview_question: {
+                            status: 'waiting_for_user',
+                            source: 'omx-question',
+                            obligation_id: 'obligation-waiting',
+                            previous_phase: 'deep-interview',
+                            requested_at: '2026-05-28T00:00:00.000Z',
+                        },
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Stale completion gate must not bypass an unresolved question.',
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /question obligation is still pending/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'waiting-for-user');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot handoff when the next state omits a still-pending deep-interview question', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-omitted-question-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-omitted-question-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'waiting-for-user',
+                    run_outcome: 'blocked_on_user',
+                    lifecycle_outcome: 'askuserQuestion',
+                    state: {
+                        deep_interview_question: {
+                            status: 'waiting_for_user',
+                            source: 'omx-question',
+                            obligation_id: 'obligation-omitted',
+                            previous_phase: 'deep-interview',
+                            requested_at: '2026-05-28T00:00:00.000Z',
+                        },
+                        deep_interview_gate: {
+                            status: 'required',
+                            rationale: 'Question still needs an answer.',
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Replacement state must not erase an unanswered question obligation.',
+                        },
+                        handoff_artifacts: {
+                            deep_interview: { summary: 'Ready for planning.' },
+                        },
+                    },
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /question obligation is still pending/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'waiting-for-user');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('ignores stale standalone deep-interview question state for Autopilot supervisor handoff', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ignore-standalone-di-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ignore-standalone-di';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'deep-interview-state.json'), JSON.stringify({
+                    active: false,
+                    mode: 'deep-interview',
+                    current_phase: 'completed',
+                    question_enforcement: {
+                        obligation_id: 'stale-obligation',
+                        source: 'omx-question',
+                        status: 'pending',
+                        lifecycle_outcome: 'askuserQuestion',
+                        requested_at: '2026-05-28T00:00:00.000Z',
+                    },
+                }, null, 2));
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Autopilot-owned gate is complete.',
+                        },
+                        handoff_artifacts: {
+                            deep_interview: { summary: 'Autopilot-owned handoff is ready.' },
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, undefined);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot satisfied nested question handoff without a record-backed question id', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-satisfied-question-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-satisfied-question-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_question: {
+                            status: 'satisfied',
+                            source: 'omx-question',
+                            obligation_id: 'obligation-no-record',
+                            previous_phase: 'deep-interview',
+                            requested_at: '2026-05-28T00:00:00.000Z',
+                            satisfied_at: '2026-05-28T00:01:00.000Z',
+                        },
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'Question satisfaction must be backed by an answered record.',
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /lacks same-session answered omx question record/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'deep-interview');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('allows Autopilot handoff when next state satisfies a previously pending question', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-next-question-satisfied-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-next-question-satisfied';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                const questionId = 'question-next-satisfied';
+                await mkdir(join(sessionDir, 'questions'), { recursive: true });
+                await writeFile(join(sessionDir, 'questions', `${questionId}.json`), JSON.stringify({
+                    kind: 'omx.question/v1',
+                    question_id: questionId,
+                    session_id: sessionId,
+                    source: 'deep-interview',
+                    status: 'answered',
+                    answer: 'lowercase ascii slug',
+                    answers: [{ question_id: 'q-1', index: 0, answer: 'lowercase ascii slug' }],
+                }, null, 2));
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_question: {
+                            obligation_id: 'obligation-next-satisfied',
+                            source: 'omx-question',
+                            status: 'waiting_for_user',
+                            requested_at: '2026-05-28T00:00:00.000Z',
+                        },
+                        deep_interview_gate: { status: 'required' },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                    state: {
+                        deep_interview_question: {
+                            obligation_id: 'obligation-next-satisfied',
+                            source: 'omx-question',
+                            status: 'satisfied',
+                            requested_at: '2026-05-28T00:00:00.000Z',
+                            question_id: questionId,
+                            satisfied_at: '2026-05-28T00:01:00.000Z',
+                        },
+                        deep_interview_gate: {
+                            status: 'complete',
+                            rationale: 'The answered question resolves the CLI output policy.',
+                        },
+                        handoff_artifacts: {
+                            deep_interview: { summary: 'Ready for ralplan after answered question.' },
+                        },
+                    },
+                });
+                assert.equal(response.isError, undefined);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('allows Autopilot deep-interview to ralplan self-write with explicit user-authorized skip evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-child-phase-skip-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-child-phase-skip';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'deep-interview',
+                    state: {
+                        deep_interview_gate: {
+                            status: 'skipped',
+                            skip_authorized_by_user: true,
+                            skip_reason: 'User explicitly authorized skipping deep-interview for this bounded follow-up.',
+                            skipped_at: '2026-05-28T00:02:00.000Z',
+                            source: 'user',
+                            session_id: sessionId,
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ralplan',
+                });
+                assert.equal(response.isError, undefined);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('resolves Autopilot satisfied question evidence under OMX_TEAM_STATE_ROOT', async () => {
+        const root = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-team-question-'));
+        const previousOmxRoot = process.env.OMX_ROOT;
+        const previousOmxStateRoot = process.env.OMX_STATE_ROOT;
+        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            const wd = join(root, 'source');
+            const teamStateRoot = join(root, 'team-state');
+            const sessionId = 'sess-autopilot-team-question';
+            const sessionDir = join(teamStateRoot, 'sessions', sessionId);
+            const questionId = 'question-team-satisfied';
+            await mkdir(join(sessionDir, 'questions'), { recursive: true });
+            await writeFile(join(sessionDir, 'questions', `${questionId}.json`), JSON.stringify({
+                kind: 'omx.question/v1',
+                question_id: questionId,
+                session_id: sessionId,
+                source: 'deep-interview',
+                status: 'answered',
+                answer: 'clarified scope',
+                answers: [{ question_id: 'q-1', index: 0, answer: 'clarified scope' }],
+            }, null, 2));
+            await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'deep-interview',
+                question_enforcement: {
+                    obligation_id: 'obligation-team-question',
+                    source: 'omx-question',
+                    status: 'satisfied',
+                    lifecycle_outcome: 'askuserQuestion',
+                    requested_at: '2026-05-28T00:00:00.000Z',
+                    question_id: questionId,
+                    satisfied_at: '2026-05-28T00:01:00.000Z',
+                },
+                state: {
+                    deep_interview_gate: {
+                        status: 'complete',
+                        rationale: 'The answered question resolves the execution boundary.',
+                    },
+                },
+            }, null, 2));
+            delete process.env.OMX_ROOT;
+            delete process.env.OMX_STATE_ROOT;
+            process.env.OMX_TEAM_STATE_ROOT = teamStateRoot;
+            const response = await executeStateOperation('state_write', {
+                workingDirectory: wd,
+                session_id: sessionId,
+                mode: 'autopilot',
+                active: true,
+                current_phase: 'ralplan',
+            });
+            assert.equal(response.isError, undefined);
+            const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+            assert.equal(state.current_phase, 'ralplan');
+            assert.equal(existsSync(join(wd, '.omx', 'state', 'sessions', sessionId, 'questions', `${questionId}.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('denies Autopilot direct ralplan to code-review skip without native consensus evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-direct-ralplan-skip-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-direct-ralplan-skip-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'code-review',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /Cannot skip Autopilot ultragoal gate/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot ralplan completion before the ultragoal gate', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-complete-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-complete-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                    state: {
+                        handoff_artifacts: {
+                            ralplan: {
+                                plan_path: '.omx/plans/prd.md',
+                                test_spec_path: '.omx/plans/test-spec.md',
+                            },
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: false,
+                    current_phase: 'complete',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /Cannot complete Autopilot before ultragoal gate/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+                assert.equal(state.active, true);
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot ralplan to ultragoal self-write with codex_exec consensus evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-native-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-native-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                    state: {
+                        handoff_artifacts: {
+                            ralplan: {
+                                plan_path: '.omx/plans/prd.md',
+                                test_spec_path: '.omx/plans/test-spec.md',
+                            },
+                            ralplan_consensus_gate: ralplanConsensusGate(sessionId, 'codex_exec'),
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /tracker-backed native architect and critic lanes/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('explains when native ralplan reviews are not present in subagent tracking', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-native-missing-tracker-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-native-missing-tracker';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                    state: {
+                        handoff_artifacts: {
+                            ralplan: {
+                                plan_path: '.omx/plans/prd.md',
+                                test_spec_path: '.omx/plans/test-spec.md',
+                            },
+                            ralplan_consensus_gate: ralplanConsensusGate(sessionId, 'native_subagent'),
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                const error = String(response.payload.error || '');
+                assert.match(error, /subagent-tracking\.json/);
+                assert.match(error, /only reviews recorded in OMX subagent-tracking\.json count as native lanes/i);
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies Autopilot ralplan to ultragoal self-write when native reviews reuse one subagent thread', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-same-thread-deny-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-same-thread-deny';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeNativeSubagentTracking(wd, sessionId);
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                    state: {
+                        handoff_artifacts: {
+                            ralplan: {
+                                plan_path: '.omx/plans/prd.md',
+                                test_spec_path: '.omx/plans/test-spec.md',
+                            },
+                            ralplan_consensus_gate: ralplanConsensusGate(sessionId, 'native_subagent', {
+                                critic: 'thread-architect',
+                            }),
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /tracker-backed native architect and critic lanes/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ralplan');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies legacy Autopilot planning to ultragoal without ralplan consensus evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-legacy-planning-gate-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-legacy-planning-gate';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'planning',
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /ralplan consensus/i);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'planning');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('allows Autopilot ralplan to ultragoal self-write with tracker-backed native consensus evidence', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-autopilot-ralplan-native-allow-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-autopilot-ralplan-native-allow';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeNativeSubagentTracking(wd, sessionId);
+                await writeFile(join(sessionDir, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: 'ralplan',
+                    state: {
+                        handoff_artifacts: {
+                            ralplan: {
+                                plan_path: '.omx/plans/prd.md',
+                                test_spec_path: '.omx/plans/test-spec.md',
+                            },
+                            ralplan_consensus_gate: ralplanConsensusGate(sessionId, 'native_subagent'),
+                        },
+                    },
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'autopilot',
+                    active: true,
+                    current_phase: 'ultragoal',
+                });
+                assert.equal(response.isError, undefined);
+                const state = JSON.parse(await readFile(join(sessionDir, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(state.current_phase, 'ultragoal');
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed when canonical deep-interview is active but mode state is missing', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-missing-deep-interview-state-'));
+        try {
+            await withOmxRootEnv(wd, async () => {
+                const sessionId = 'sess-missing-deep-interview-state';
+                const sessionDir = join(wd, '.omx', 'state', 'sessions', sessionId);
+                await mkdir(sessionDir, { recursive: true });
+                await writeFile(join(sessionDir, 'skill-active-state.json'), JSON.stringify({
+                    version: 1,
+                    active: true,
+                    skill: 'deep-interview',
+                    session_id: sessionId,
+                    active_skills: [{
+                            skill: 'deep-interview',
+                            active: true,
+                            phase: 'intent-first',
+                            session_id: sessionId,
+                        }],
+                }, null, 2));
+                const response = await executeStateOperation('state_write', {
+                    workingDirectory: wd,
+                    session_id: sessionId,
+                    mode: 'ralplan',
+                    active: true,
+                    current_phase: 'planning',
+                });
+                assert.equal(response.isError, true);
+                assert.match(String(response.payload.error || ''), /missing deep-interview completion\/skip gate/i);
+                assert.equal(existsSync(join(sessionDir, 'ralplan-state.json')), false);
+                const canonical = JSON.parse(await readFile(join(sessionDir, 'skill-active-state.json'), 'utf-8'));
+                assert.equal(canonical.active_skills?.[0]?.skill, 'deep-interview');
+                assert.equal(canonical.active_skills?.[0]?.active, true);
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('does not auto-complete existing workflow state when tracked write validation fails', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-state-ops-validate-before-transition-'));
         try {