oh-my-codex 0.18.6 → 0.18.8

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

@@ -1,7 +1,7 @@
 import { describe, it, mock } from 'node:test';
 import assert from 'node:assert/strict';
 import { existsSync } from 'node:fs';
-import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { detectKeywords, detectPrimaryKeyword, recordSkillActivation, DEEP_INTERVIEW_STATE_FILE, DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS, DEEP_INTERVIEW_INPUT_LOCK_MESSAGE, persistDeepInterviewModeState, } from '../keyword-detector.js';
@@ -23,6 +23,54 @@ async function withIsolatedHome(prefix, run) {
         await rm(homeDir, { recursive: true, force: true });
     }
 }
+const AUTOPILOT_TEST_NOW = '2026-05-30T00:00:00.000Z';
+const AUTOPILOT_TEST_STARTED_AT = '2026-05-29T00:00:00.000Z';
+const AUTOPILOT_TEST_UPDATED_AT = '2026-05-29T00:10:00.000Z';
+async function writeActiveAutopilotSkillState(stateDir, sessionId, phase = 'ralplan') {
+    await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+    await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+        version: 1,
+        active: true,
+        skill: 'autopilot',
+        keyword: '$autopilot',
+        phase,
+        activated_at: AUTOPILOT_TEST_STARTED_AT,
+        updated_at: AUTOPILOT_TEST_UPDATED_AT,
+        session_id: sessionId,
+        active_skills: [{ skill: 'autopilot', active: true, phase, session_id: sessionId }],
+    }, null, 2));
+}
+async function readAutopilotModeState(stateDir, sessionId) {
+    return JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), 'utf-8'));
+}
+async function continueAutopilotTestState(stateDir, cwd, sessionId, suffix, text = 'continue') {
+    await recordSkillActivation({
+        stateDir,
+        sourceCwd: cwd,
+        text,
+        sessionId,
+        threadId: `thread-${suffix}`,
+        turnId: `turn-${suffix}`,
+        nowIso: AUTOPILOT_TEST_NOW,
+    });
+}
+async function assertAutopilotRecoverySnapshot(cwd, modeState, expectedPath, expectedReason) {
+    const snapshotPath = modeState.state?.handoff_artifacts?.context_snapshot_path ?? '';
+    if (typeof expectedPath === 'string')
+        assert.equal(snapshotPath, expectedPath);
+    else
+        assert.match(snapshotPath, expectedPath);
+    assert.equal(modeState.state?.handoff_artifacts?.context_snapshot?.kind, 'recovery');
+    assert.equal(modeState.state?.handoff_artifacts?.context_snapshot?.recovery?.reason, expectedReason);
+    assert.equal(modeState.state?.context_snapshot_recovery?.status, 'degraded');
+    assert.equal(modeState.state?.context_snapshot_recovery?.reason, expectedReason);
+    const recoverySnapshot = await readFile(join(cwd, snapshotPath), 'utf-8');
+    assert.match(recoverySnapshot, /recovery status: degraded/);
+    assert.match(recoverySnapshot, new RegExp(`recovery reason: ${expectedReason}`));
+    assert.match(recoverySnapshot, /do not treat the continuation input as the task seed/);
+    assert.doesNotMatch(recoverySnapshot, /task seed: continue/);
+    return snapshotPath;
+}
 describe('keyword detector team compatibility', () => {
     it('keeps explicit $skill order in detectKeywords results (left-to-right)', () => {
         const matches = detectKeywords('$analyze $ultraqa $code-review now');
@@ -133,6 +181,28 @@ describe('keyword detector team compatibility', () => {
         const pathOnly = detectPrimaryKeyword('inspect .omx/ultragoal/goals.json');
         assert.notEqual(pathOnly?.skill, 'ultragoal');
     });
+    it('maps bare and command-style autopilot invocations to autopilot', () => {
+        for (const prompt of ['autopilot', 'run autopilot', 'autopilot this', 'autopilot mode']) {
+            const match = detectPrimaryKeyword(prompt);
+            assert.ok(match, `expected autopilot match for ${prompt}`);
+            assert.equal(match.skill, 'autopilot');
+            assert.equal(match.keyword.toLowerCase(), 'autopilot');
+        }
+    });
+    it('does not trigger autopilot from management/debug prose mentions', () => {
+        assert.equal(detectPrimaryKeyword('inspect autopilot state before continuing'), null);
+        assert.equal(detectPrimaryKeyword('fix the autopilot bug in the detector'), null);
+        assert.equal(detectPrimaryKeyword('why did autopilot fail?'), null);
+        assert.equal(detectPrimaryKeyword('run autopilot tests'), null);
+        assert.equal(detectPrimaryKeyword('run autopilot regression tests'), null);
+        assert.equal(detectPrimaryKeyword('continue autopilot debugging'), null);
+        assert.equal(detectPrimaryKeyword('start autopilot bug investigation'), null);
+    });
+    it('keeps higher-priority workflow keywords ahead of autopilot mentions', () => {
+        const match = detectPrimaryKeyword('autopilot this after consensus plan');
+        assert.ok(match);
+        assert.equal(match.skill, 'ralplan');
+    });
     it('maps code-review keyword variants to code-review skill', () => {
         const hyphen = detectPrimaryKeyword('run $code-review before merge');
         assert.ok(hyphen);
@@ -333,6 +403,7 @@ describe('keyword registry coverage', () => {
         assert.ok(registryKeywords.has('$ultragoal'));
         assert.ok(registryKeywords.has('$prometheus-strict'));
         assert.ok(registryKeywords.has('ultragoal'));
+        assert.ok(registryKeywords.has('autopilot'));
     });
 });
 describe('keyword detector skill-active-state lifecycle', () => {
@@ -473,6 +544,12 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 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, {
+                context_snapshot_path: '.omx/context/please-run-and-keep-going-20260225T000000Z.md',
+                context_snapshot: {
+                    path: '.omx/context/please-run-and-keep-going-20260225T000000Z.md',
+                    kind: 'canonical',
+                    original_task_status: 'activation-prompt',
+                },
                 deep_interview: null,
                 ralplan: null,
                 ralplan_consensus_gate: {
@@ -491,11 +568,445 @@ describe('keyword detector skill-active-state lifecycle', () => {
             assert.equal(modeState.state.review_verdict, null);
             assert.equal(modeState.state.qa_verdict, null);
             assert.equal(modeState.state.return_to_ralplan_reason, null);
+            const snapshot = await readFile(join(cwd, '.omx', 'context', 'please-run-and-keep-going-20260225T000000Z.md'), 'utf-8');
+            assert.match(snapshot, /activation prompt \/ task seed: please run \$autopilot and keep going/);
+            assert.match(snapshot, /scope note: this seed captures the Autopilot activation prompt/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('migrates legacy Autopilot context snapshot paths into handoff artifacts', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-legacy-context-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-legacy-context';
+        try {
+            await writeActiveAutopilotSkillState(stateDir, sessionId, 'deep-interview');
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'deep-interview',
+                started_at: AUTOPILOT_TEST_STARTED_AT,
+                context_snapshot_path: '.omx/context/legacy-task-20260529T000000Z.md',
+                state: { handoff_artifacts: { deep_interview: null } },
+            }, null, 2));
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'legacy-task-20260529T000000Z.md'), '# legacy task');
+            await continueAutopilotTestState(stateDir, cwd, sessionId, 'legacy');
+            const modeState = await readAutopilotModeState(stateDir, sessionId);
+            assert.equal(modeState.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/legacy-task-20260529T000000Z.md');
+            assert.deepEqual(modeState.state?.handoff_artifacts?.context_snapshot, {
+                path: '.omx/context/legacy-task-20260529T000000Z.md',
+                kind: 'legacy',
+                original_task_status: 'legacy-unverified',
+            });
+            assert.equal(existsSync(join(cwd, '.omx', 'context', 'continue-20260530T000000Z.md')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('rejects unsafe legacy Autopilot context snapshot paths without writing outside .omx/context', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-unsafe-context-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-unsafe-context';
+        try {
+            await writeActiveAutopilotSkillState(stateDir, sessionId, 'deep-interview');
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'deep-interview',
+                started_at: AUTOPILOT_TEST_STARTED_AT,
+                context_snapshot_path: '.omx/context/../../escape.md',
+                state: { handoff_artifacts: { deep_interview: null } },
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: 'continue',
+                sessionId,
+                threadId: 'thread-unsafe',
+                turnId: 'turn-unsafe',
+                nowIso: '2026-05-30T00:00:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(existsSync(join(cwd, '.omx', 'escape.md')), false);
+            const modeState = await readAutopilotModeState(stateDir, sessionId);
+            assert.equal(modeState.context_snapshot_path, undefined);
+            await assertAutopilotRecoverySnapshot(cwd, modeState, '.omx/context/autopilot-recovery-20260530T000000Z.md', 'missing-or-unsafe-legacy-context-snapshot');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('does not snapshot bare continuation text when active Autopilot mode state is corrupt', async () => {
+        const expectedReasons = {
+            'missing-current-phase': 'nonpreservable-autopilot-mode-state-missing-current-phase',
+            'malformed-json': 'malformed-autopilot-mode-state',
+            'array-json': 'malformed-autopilot-mode-state',
+        };
+        for (const fixture of ['missing-current-phase', 'malformed-json', 'array-json']) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-keyword-autopilot-corrupt-continuation-${fixture}-`));
+            const stateDir = join(cwd, '.omx', 'state');
+            const sessionId = `sess-autopilot-corrupt-continuation-${fixture}`;
+            try {
+                await writeActiveAutopilotSkillState(stateDir, sessionId);
+                const modeStatePath = join(stateDir, 'sessions', sessionId, 'autopilot-state.json');
+                if (fixture === 'missing-current-phase') {
+                    await writeFile(modeStatePath, JSON.stringify({
+                        active: true,
+                        mode: 'autopilot',
+                        started_at: AUTOPILOT_TEST_STARTED_AT,
+                        state: { handoff_artifacts: {} },
+                    }, null, 2));
+                }
+                else if (fixture === 'malformed-json') {
+                    await writeFile(modeStatePath, '{ "active": true, "mode": "autopilot",');
+                }
+                else {
+                    await writeFile(modeStatePath, '[]');
+                }
+                await continueAutopilotTestState(stateDir, cwd, sessionId, fixture);
+                assert.equal(existsSync(join(cwd, '.omx', 'context', 'continue-20260530T000000Z.md')), false);
+                await assertAutopilotRecoverySnapshot(cwd, JSON.parse(await readFile(modeStatePath, 'utf-8')), /^\.omx\/context\/autopilot-recovery-20260530T000000Z(?:-\d+)?\.md$/, expectedReasons[fixture]);
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
+    it('rejects nested symlink Autopilot context snapshot candidates during reuse', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-nested-symlink-context-'));
+        const outside = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-nested-symlink-outside-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-nested-symlink-context';
+        try {
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await symlink(outside, join(cwd, '.omx', 'context', 'link'));
+            await writeFile(join(outside, 'exfil.md'), '# outside context');
+            await writeActiveAutopilotSkillState(stateDir, sessionId);
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'ralplan',
+                started_at: AUTOPILOT_TEST_STARTED_AT,
+                state: { handoff_artifacts: { context_snapshot_path: '.omx/context/link/exfil.md' } },
+            }, null, 2));
+            await continueAutopilotTestState(stateDir, cwd, sessionId, 'nested-symlink');
+            await assertAutopilotRecoverySnapshot(cwd, await readAutopilotModeState(stateDir, sessionId), '.omx/context/autopilot-recovery-20260530T000000Z.md', 'missing-or-unsafe-legacy-context-snapshot');
+            assert.equal(existsSync(join(outside, 'exfil.md')), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+            await rm(outside, { recursive: true, force: true });
+        }
+    });
+    it('rejects typed canonical Autopilot recovery snapshot candidates during reuse', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-typed-recovery-context-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-typed-recovery-context';
+        try {
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'autopilot-recovery-20260529T000000Z.md'), '# stale degraded recovery');
+            await writeActiveAutopilotSkillState(stateDir, sessionId);
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'ralplan',
+                started_at: AUTOPILOT_TEST_STARTED_AT,
+                state: {
+                    handoff_artifacts: {
+                        context_snapshot: {
+                            path: '.omx/context/autopilot-recovery-20260529T000000Z.md',
+                            kind: 'canonical',
+                        },
+                    },
+                },
+            }, null, 2));
+            await continueAutopilotTestState(stateDir, cwd, sessionId, 'typed-recovery');
+            await assertAutopilotRecoverySnapshot(cwd, await readAutopilotModeState(stateDir, sessionId), '.omx/context/autopilot-recovery-20260530T000000Z.md', 'missing-or-unsafe-legacy-context-snapshot');
+            assert.equal(existsSync(join(cwd, '.omx', 'context', 'autopilot-recovery-20260529T000000Z.md')), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('rejects oversized Autopilot context snapshot candidates during reuse', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-oversized-context-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-oversized-context';
+        try {
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'oversized-legacy-20260529T000000Z.md'), 'x'.repeat((1024 * 1024) + 1));
+            await writeActiveAutopilotSkillState(stateDir, sessionId);
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'ralplan',
+                started_at: AUTOPILOT_TEST_STARTED_AT,
+                state: {
+                    handoff_artifacts: {
+                        context_snapshot_path: '.omx/context/oversized-legacy-20260529T000000Z.md',
+                    },
+                },
+            }, null, 2));
+            await continueAutopilotTestState(stateDir, cwd, sessionId, 'oversized-context');
+            await assertAutopilotRecoverySnapshot(cwd, await readAutopilotModeState(stateDir, sessionId), '.omx/context/autopilot-recovery-20260530T000000Z.md', 'missing-or-unsafe-legacy-context-snapshot');
+            assert.equal(existsSync(join(cwd, '.omx', 'context', 'oversized-legacy-20260529T000000Z.md')), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('does not promote degraded recovery snapshots to canonical context on reactivation', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-recovery-reactivation-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-recovery-reactivation';
+        try {
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'autopilot-recovery-20260529T000000Z.md'), '# degraded recovery');
+            await writeActiveAutopilotSkillState(stateDir, sessionId, 'complete');
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'complete',
+                completed_at: AUTOPILOT_TEST_UPDATED_AT,
+                state: {
+                    handoff_artifacts: {
+                        context_snapshot_path: '.omx/context/autopilot-recovery-20260529T000000Z.md',
+                        context_snapshot: {
+                            path: '.omx/context/autopilot-recovery-20260529T000000Z.md',
+                            kind: 'recovery',
+                            recovery: { status: 'degraded', reason: 'missing-or-unsafe-legacy-context-snapshot' },
+                        },
+                    },
+                    context_snapshot_recovery: { status: 'degraded', reason: 'missing-or-unsafe-legacy-context-snapshot' },
+                },
+            }, null, 2));
+            await continueAutopilotTestState(stateDir, cwd, sessionId, 'recovery-reactivation', '$autopilot implement the real task');
+            const modeState = await readAutopilotModeState(stateDir, sessionId);
+            assert.equal(modeState.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/implement-the-real-task-20260530T000000Z.md');
+            assert.deepEqual(modeState.state?.handoff_artifacts?.context_snapshot, {
+                path: '.omx/context/implement-the-real-task-20260530T000000Z.md',
+                kind: 'canonical',
+                original_task_status: 'activation-prompt',
+            });
+            assert.equal(modeState.state?.context_snapshot_recovery, undefined);
+            const snapshot = await readFile(join(cwd, '.omx', 'context', 'implement-the-real-task-20260530T000000Z.md'), 'utf-8');
+            assert.match(snapshot, /activation prompt \/ task seed: \$autopilot implement the real task/);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('does not follow symlinked Autopilot context directories when writing snapshots', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-symlink-context-'));
+        const outside = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-symlink-outside-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await symlink(outside, join(cwd, '.omx', 'context'));
+            await mkdir(stateDir, { recursive: true });
+            const warnings = [];
+            mock.method(console, 'warn', (...args) => {
+                warnings.push(args);
+            });
+            await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$autopilot symlink escape',
+                sessionId: 'sess-autopilot-symlink-context',
+                threadId: 'thread-symlink-context',
+                turnId: 'turn-symlink-context',
+                nowIso: '2026-05-30T00:00:00.000Z',
+            });
+            assert.equal(warnings.length, 1);
+            assert.match(String(warnings[0][1]), /symbolic link/);
+            assert.equal(existsSync(join(outside, 'symlink-escape-20260530T000000Z.md')), false);
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-autopilot-symlink-context', 'autopilot-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+            await rm(outside, { recursive: true, force: true });
+        }
+    });
+    it('allocates unique Autopilot context snapshot paths for same-second matching slugs', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-context-collision-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(stateDir, { recursive: true });
+            await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$autopilot same task',
+                sessionId: 'sess-autopilot-collision-a',
+                threadId: 'thread-collision',
+                turnId: 'turn-collision-a',
+                nowIso: '2026-05-30T00:00:00.000Z',
+            });
+            await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$autopilot same task',
+                sessionId: 'sess-autopilot-collision-b',
+                threadId: 'thread-collision',
+                turnId: 'turn-collision-b',
+                nowIso: '2026-05-30T00:00:00.000Z',
+            });
+            const first = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-autopilot-collision-a', 'autopilot-state.json'), 'utf-8'));
+            const second = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-autopilot-collision-b', 'autopilot-state.json'), 'utf-8'));
+            assert.equal(first.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/same-task-20260530T000000Z.md');
+            assert.equal(second.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/same-task-20260530T000000Z-2.md');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('fully resets terminal Autopilot mode state when reactivated', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-autopilot-terminal-reset-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-terminal-reset';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'complete',
+                activated_at: '2026-05-29T00:00:00.000Z',
+                updated_at: '2026-05-29T00:00:00.000Z',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', active: true, phase: 'complete', session_id: sessionId }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'complete',
+                started_at: '2026-05-29T00:00:00.000Z',
+                completed_at: '2026-05-29T00:10:00.000Z',
+                iteration: 10,
+                max_iterations: 10,
+                review_cycle: 3,
+                lifecycle_outcome: 'finished',
+                run_outcome: 'finish',
+                handoff_artifacts: {
+                    code_review: { verdict: 'APPROVE / CLEAR' },
+                    ultraqa: { verdict: 'pass' },
+                },
+                state: {
+                    handoff_artifacts: {
+                        ralplan_consensus_gate: { complete: false },
+                        code_review: { verdict: 'stale' },
+                    },
+                },
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$autopilot investigate the next issue',
+                sessionId,
+                threadId: 'thread-reactivated',
+                turnId: 'turn-reactivated',
+                nowIso: '2026-05-30T00:00:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            assert.equal(result.phase, 'deep-interview');
+            assert.equal(result.activated_at, '2026-05-30T00:00:00.000Z');
+            assert.equal(result.active_skills?.[0]?.phase, 'deep-interview');
+            assert.equal(result.active_skills?.[0]?.activated_at, '2026-05-30T00:00:00.000Z');
+            const skillState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), 'utf-8'));
+            assert.equal(skillState.phase, 'deep-interview');
+            assert.equal(skillState.activated_at, '2026-05-30T00:00:00.000Z');
+            assert.equal(skillState.active_skills?.[0]?.phase, 'deep-interview');
+            assert.equal(skillState.active_skills?.[0]?.activated_at, '2026-05-30T00:00:00.000Z');
+            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), 'utf-8'));
+            assert.equal(modeState.active, true);
+            assert.equal(modeState.current_phase, 'deep-interview');
+            assert.equal(modeState.started_at, '2026-05-30T00:00:00.000Z');
+            assert.equal(modeState.completed_at, undefined);
+            assert.equal(modeState.iteration, 1);
+            assert.equal(modeState.max_iterations, 10);
+            assert.equal(modeState.review_cycle, 0);
+            assert.equal(modeState.lifecycle_outcome, undefined);
+            assert.equal(modeState.run_outcome, undefined);
+            assert.equal(modeState.handoff_artifacts, undefined);
+            assert.deepEqual(modeState.state?.handoff_artifacts, {
+                context_snapshot_path: '.omx/context/investigate-the-next-issue-20260530T000000Z.md',
+                context_snapshot: {
+                    path: '.omx/context/investigate-the-next-issue-20260530T000000Z.md',
+                    kind: 'canonical',
+                    original_task_status: 'activation-prompt',
+                },
+                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,
+            });
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('resets stopped Autopilot mode state when reactivated', async () => {
+        for (const phase of ['stopped', 'user-stopped']) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-keyword-autopilot-${phase}-reset-`));
+            const stateDir = join(cwd, '.omx', 'state');
+            const sessionId = `sess-autopilot-${phase}-reset`;
+            try {
+                await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+                await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                    version: 1,
+                    active: true,
+                    skill: 'autopilot',
+                    keyword: '$autopilot',
+                    phase,
+                    activated_at: '2026-05-29T00:00:00.000Z',
+                    updated_at: '2026-05-29T00:00:00.000Z',
+                    source: 'keyword-detector',
+                    session_id: sessionId,
+                    active_skills: [{ skill: 'autopilot', active: true, phase, session_id: sessionId }],
+                }, null, 2));
+                await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                    active: true,
+                    mode: 'autopilot',
+                    current_phase: phase,
+                    started_at: '2026-05-29T00:00:00.000Z',
+                    completed_at: '2026-05-29T00:10:00.000Z',
+                    iteration: 10,
+                    max_iterations: 10,
+                    review_cycle: 3,
+                    state: { handoff_artifacts: { code_review: { verdict: 'stale' } } },
+                }, null, 2));
+                const result = await recordSkillActivation({
+                    stateDir,
+                    text: '$autopilot new task after stop',
+                    sessionId,
+                    nowIso: '2026-05-30T00:00:00.000Z',
+                });
+                assert.ok(result);
+                assert.equal(result.phase, 'deep-interview');
+                assert.equal(result.activated_at, '2026-05-30T00:00:00.000Z');
+                const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), 'utf-8'));
+                assert.equal(modeState.current_phase, 'deep-interview');
+                assert.equal(modeState.iteration, 1);
+                assert.equal(modeState.review_cycle, 0);
+                assert.equal(modeState.state?.handoff_artifacts?.code_review, null);
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
     it('adds approved workflow overlaps without deleting the existing canonical state', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-overlap-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -864,7 +1375,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
-    it('keeps ralplan as an allowlisted deep-interview forward handoff', async () => {
+    it('denies ralplan handoff from deep-interview without completion or explicit skip evidence', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-ralplan-handoff-'));
         const stateDir = join(cwd, '.omx', 'state');
         try {
@@ -884,10 +1395,49 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 sessionId: 'sess-ralplan-handoff',
                 nowIso: '2026-04-10T00:00:00.000Z',
             });
+            assert.equal(result?.skill, 'deep-interview');
+            assert.match(String(result?.transition_error), /missing deep-interview completion\/skip gate/i);
+            const preserved = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-handoff', 'deep-interview-state.json'), 'utf-8'));
+            assert.equal(preserved.active, true);
+            assert.equal(preserved.current_phase, 'intent-first');
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-ralplan-handoff', 'ralplan-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('allows ralplan handoff from deep-interview with a durable completion gate', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-ralplan-handoff-complete-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(stateDir, 'sessions', 'sess-ralplan-handoff-complete'), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-handoff-complete', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'deep-interview',
+                phase: 'planning',
+                session_id: 'sess-ralplan-handoff-complete',
+                active_skills: [{ skill: 'deep-interview', phase: 'planning', active: true, session_id: 'sess-ralplan-handoff-complete' }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-handoff-complete', '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 result = await recordSkillActivation({
+                stateDir,
+                text: '$ralplan implement the approved contract',
+                sessionId: 'sess-ralplan-handoff-complete',
+                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'));
+            const completed = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-handoff-complete', 'deep-interview-state.json'), 'utf-8'));
             assert.equal(completed.active, false);
             assert.equal(completed.current_phase, 'completed');
         }
@@ -965,6 +1515,72 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('does not activate team state when persisted Team mode is disabled', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-team-disabled-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'setup-scope.json'), JSON.stringify({ scope: 'project', teamMode: 'disabled' }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$team coordinate the hotfix',
+                sessionId: 'sess-team-disabled',
+                nowIso: '2026-04-08T00:00:00.000Z',
+            });
+            assert.equal(result, null);
+            assert.equal(existsSync(join(stateDir, 'team-state.json')), false);
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-team-disabled', SKILL_ACTIVE_STATE_FILE)), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('ignores disabled Team when selecting the primary workflow', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-team-disabled-primary-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'setup-scope.json'), JSON.stringify({ scope: 'project', teamMode: 'disabled' }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$team $ralph ship this fix',
+                sessionId: 'sess-team-disabled-primary',
+                nowIso: '2026-04-10T01:00:00.000Z',
+            });
+            assert.equal(result?.skill, 'ralph');
+            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ralph']);
+            assert.equal(existsSync(join(stateDir, 'team-state.json')), false);
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-team-disabled-primary', 'ralph-state.json')), true);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('filters deferred team handoffs when persisted Team mode is disabled', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-team-disabled-deferred-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(cwd, '.omx'), { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(cwd, '.omx', 'setup-scope.json'), JSON.stringify({ scope: 'project', teamMode: 'disabled' }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$ralplan $team $ralph ship this fix',
+                sessionId: 'sess-team-disabled-deferred',
+                nowIso: '2026-04-10T00:00:00.000Z',
+            });
+            assert.equal(result?.skill, 'ralplan');
+            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ralplan']);
+            assert.deepEqual(result?.deferred_skills, ['ralph']);
+            assert.equal(existsSync(join(stateDir, 'team-state.json')), false);
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-team-disabled-deferred', 'team-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('preserves active team root state when $team is re-entered from prompt routing', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-team-preserve-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -1034,6 +1650,57 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('emits terminal ralplan state before explicit ultragoal execution handoff', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-ralplan-ultragoal-handoff-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(join(stateDir, 'sessions', 'sess-ralplan-ultragoal'), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-ultragoal', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'ralplan',
+                keyword: '$ralplan',
+                phase: 'planning',
+                session_id: 'sess-ralplan-ultragoal',
+                active_skills: [{ skill: 'ralplan', phase: 'planning', active: true, session_id: 'sess-ralplan-ultragoal' }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', 'sess-ralplan-ultragoal', 'ralplan-state.json'), JSON.stringify({
+                active: true,
+                mode: 'ralplan',
+                current_phase: 'complete',
+                planning_complete: true,
+                ralplan_consensus_gate: {
+                    complete: true,
+                    sequence: ['architect-review', 'critic-review'],
+                    ralplan_architect_review: { agent_role: 'architect', verdict: 'approve', approved: true },
+                    ralplan_critic_review: { agent_role: 'critic', verdict: 'approve', approved: true },
+                },
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                sourceCwd: cwd,
+                text: '$ultragoal execute the approved ralplan',
+                sessionId: 'sess-ralplan-ultragoal',
+                nowIso: '2026-04-10T00:20:00.000Z',
+            });
+            assert.equal(result?.transition_error, undefined);
+            assert.equal(result?.skill, 'ultragoal');
+            assert.equal(result?.transition_message, 'mode transiting: ralplan -> ultragoal');
+            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ultragoal']);
+            const ralplan = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-ultragoal', 'ralplan-state.json'), 'utf-8'));
+            assert.equal(ralplan.active, false);
+            assert.equal(ralplan.current_phase, 'completed');
+            assert.equal(ralplan.auto_completed_reason, 'mode transiting: ralplan -> ultragoal');
+            assert.ok(ralplan.completed_at);
+            const ultragoal = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-ultragoal', '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 root team state out of the session-scoped Ralph canonical state', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-team-ralph-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -1523,6 +2190,211 @@ deepMaxRounds = 21
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('keeps Autopilot visible when a supervised code-review child keyword appears', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-child-code-review-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-child-code-review';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'ralplan',
+                activated_at: '2026-05-30T00:00:00.000Z',
+                updated_at: '2026-05-30T00:01:00.000Z',
+                source: 'keyword-detector',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'ralplan', active: true, session_id: sessionId }],
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: 'CODE REVIEW the current diff before continuing',
+                sessionId,
+                threadId: 'thread-autopilot-child-code-review',
+                turnId: 'turn-autopilot-child-code-review',
+                nowIso: '2026-05-30T00:02:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            assert.equal(result.phase, 'ralplan');
+            assert.equal(result.supervised_child_skill, 'code-review');
+            const persisted = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), 'utf-8'));
+            assert.equal(persisted.skill, 'autopilot');
+            assert.equal(persisted.phase, 'ralplan');
+            assert.deepEqual(persisted.active_skills?.map((entry) => entry.skill), ['autopilot']);
+            assert.equal(existsSync(join(stateDir, 'sessions', sessionId, 'code-review-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps tracked Autopilot child keywords supervised and completes stale child mode state', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-child-ultraqa-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-child-ultraqa';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'ultraqa',
+                activated_at: '2026-05-30T00:00:00.000Z',
+                updated_at: '2026-05-30T00:01:00.000Z',
+                source: 'keyword-detector',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'ultraqa', active: true, session_id: sessionId }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', sessionId, 'ultragoal-state.json'), JSON.stringify({
+                active: true,
+                mode: 'ultragoal',
+                current_phase: 'planning',
+                session_id: sessionId,
+                started_at: '2026-05-29T23:00:00.000Z',
+                updated_at: '2026-05-29T23:05:00.000Z',
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$ultraqa run adversarial checks',
+                sessionId,
+                threadId: 'thread-autopilot-child-ultraqa',
+                turnId: 'turn-autopilot-child-ultraqa',
+                nowIso: '2026-05-30T00:02:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            assert.equal(result.phase, 'ultraqa');
+            assert.equal(result.supervised_child_skill, 'ultraqa');
+            assert.equal(result.transition_error, undefined);
+            assert.equal(existsSync(join(stateDir, 'sessions', sessionId, 'ultraqa-state.json')), false);
+            const ultragoal = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'ultragoal-state.json'), 'utf-8'));
+            assert.equal(ultragoal.active, false);
+            assert.equal(ultragoal.current_phase, 'completed');
+            assert.match(ultragoal.auto_completed_reason || '', /mode transiting: ultragoal -> ultraqa/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies supervised Autopilot child rollback without clearing stale execution state', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-child-rollback-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-child-rollback';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'ultragoal',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'ultragoal', active: true, session_id: sessionId }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', sessionId, 'ultragoal-state.json'), JSON.stringify({
+                active: true,
+                mode: 'ultragoal',
+                current_phase: 'executing',
+                session_id: sessionId,
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$deep-interview go back and re-plan',
+                sessionId,
+                nowIso: '2026-05-30T00:03:00.000Z',
+            });
+            assert.equal(result?.skill, 'autopilot');
+            assert.match(String(result?.transition_error), /Execution-to-planning rollback auto-complete is not allowed/i);
+            assert.equal(result?.supervised_child_skill, undefined);
+            assert.equal(existsSync(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json')), false);
+            const ultragoal = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'ultragoal-state.json'), 'utf-8'));
+            assert.equal(ultragoal.active, true);
+            assert.equal(ultragoal.current_phase, 'executing');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('surfaces supervised Autopilot deep-interview to ralplan gate failures', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-child-gate-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-child-gate';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'deep-interview',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'deep-interview', active: true, session_id: sessionId }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json'), JSON.stringify({
+                active: true,
+                mode: 'deep-interview',
+                current_phase: 'intent-first',
+                session_id: sessionId,
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$ralplan continue without interview completion evidence',
+                sessionId,
+                nowIso: '2026-05-30T00:04:00.000Z',
+            });
+            assert.equal(result?.skill, 'autopilot');
+            assert.match(String(result?.transition_error), /missing deep-interview completion\/skip gate/i);
+            assert.equal(result?.supervised_child_skill, undefined);
+            assert.equal(existsSync(join(stateDir, 'sessions', sessionId, 'ralplan-state.json')), false);
+            const deepInterview = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json'), 'utf-8'));
+            assert.equal(deepInterview.active, true);
+            assert.equal(deepInterview.current_phase, 'intent-first');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('ignores stale root child mode state during session-scoped Autopilot child reconciliation', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-child-session-root-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-child-session-root';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'deep-interview',
+                session_id: sessionId,
+                active_skills: [{ skill: 'autopilot', phase: 'deep-interview', active: true, session_id: sessionId }],
+            }, null, 2));
+            await writeFile(join(stateDir, 'ultragoal-state.json'), JSON.stringify({
+                active: true,
+                mode: 'ultragoal',
+                current_phase: 'executing',
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '$deep-interview continue scoped interview',
+                sessionId,
+                nowIso: '2026-05-30T00:05:00.000Z',
+            });
+            assert.equal(result?.skill, 'autopilot');
+            assert.equal(result?.supervised_child_skill, 'deep-interview');
+            assert.equal(result?.transition_error, undefined);
+            const rootUltragoal = JSON.parse(await readFile(join(stateDir, 'ultragoal-state.json'), 'utf-8'));
+            assert.equal(rootUltragoal.active, true);
+            assert.equal(rootUltragoal.current_phase, 'executing');
+            assert.equal(existsSync(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     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');
@@ -1547,19 +2419,27 @@ deepMaxRounds = 21
         }
     });
     it('emits a warning when skill-active-state persistence fails', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-persist-fail-'));
         const warnings = [];
         mock.method(console, 'warn', (...args) => {
             warnings.push(args);
         });
-        const result = await recordSkillActivation({
-            stateDir: join('/definitely-missing', 'nested', 'state-dir'),
-            text: 'please run $autopilot',
-            nowIso: '2026-02-25T00:00:00.000Z',
-        });
-        assert.ok(result);
-        assert.equal(result.skill, 'autopilot');
-        assert.equal(warnings.length, 1);
-        assert.match(String(warnings[0][0]), /failed to persist keyword activation state/);
+        try {
+            const blockingFile = join(cwd, 'state-root-file');
+            await writeFile(blockingFile, 'not a directory');
+            const result = await recordSkillActivation({
+                stateDir: join(blockingFile, 'nested', 'state-dir'),
+                text: 'please run $autopilot',
+                nowIso: '2026-02-25T00:00:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            assert.equal(warnings.length, 1);
+            assert.match(String(warnings[0][0]), /failed to persist keyword activation state/);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
     });
     it('preserves activated_at for same-skill continuation', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-continuation-'));
@@ -1618,6 +2498,8 @@ deepMaxRounds = 21
                 session_id: 'sess-autopilot',
                 state: { context_snapshot_path: '.omx/context/existing.md' },
             }));
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'existing.md'), '# existing context');
             const result = await recordSkillActivation({
                 stateDir,
                 text: 'autopilot keep going',
@@ -1631,7 +2513,8 @@ deepMaxRounds = 21
             const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-autopilot', 'autopilot-state.json'), 'utf-8'));
             assert.equal(modeState.current_phase, 'code-review');
             assert.equal(modeState.started_at, '2026-02-25T00:00:00.000Z');
-            assert.equal(modeState.state?.context_snapshot_path, '.omx/context/existing.md');
+            assert.equal(modeState.state?.context_snapshot_path, undefined);
+            assert.equal(modeState.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/existing.md');
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
@@ -1801,6 +2684,8 @@ deepMaxRounds = 21
                 session_id: 'sess-autopilot-bare',
                 state: { context_snapshot_path: '.omx/context/autopilot.md' },
             }, null, 2));
+            await mkdir(join(cwd, '.omx', 'context'), { recursive: true });
+            await writeFile(join(cwd, '.omx', 'context', 'autopilot.md'), '# autopilot context');
             const result = await recordSkillActivation({
                 stateDir,
                 text: '\\ keep going now',
@@ -1813,13 +2698,149 @@ deepMaxRounds = 21
             assert.equal(result.transition_error, undefined);
             const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-autopilot-bare', 'autopilot-state.json'), 'utf-8'));
             assert.equal(modeState.current_phase, 'code-review');
-            assert.equal(modeState.state?.context_snapshot_path, '.omx/context/autopilot.md');
+            assert.equal(modeState.state?.context_snapshot_path, undefined);
+            assert.equal(modeState.state?.handoff_artifacts?.context_snapshot_path, '.omx/context/autopilot.md');
             assert.equal(existsSync(join(stateDir, 'sessions', 'sess-autopilot-bare', 'ralph-state.json')), false);
         }
         finally {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('preserves active Autopilot question-wait state on bare continuation', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autopilot-question-wait-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        const sessionId = 'sess-autopilot-question-wait';
+        try {
+            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'autopilot',
+                keyword: '$autopilot',
+                phase: 'waiting-for-user',
+                activated_at: '2026-04-19T00:00:00.000Z',
+                updated_at: '2026-04-19T00:10:00.000Z',
+                source: 'keyword-detector',
+                session_id: sessionId,
+                active_skills: [
+                    {
+                        skill: 'autopilot',
+                        phase: 'waiting-for-user',
+                        active: true,
+                        activated_at: '2026-04-19T00:00:00.000Z',
+                        updated_at: '2026-04-19T00:10:00.000Z',
+                        session_id: sessionId,
+                    },
+                ],
+            }, null, 2));
+            await writeFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'waiting-for-user',
+                started_at: '2026-04-19T00:00:00.000Z',
+                updated_at: '2026-04-19T00:10:00.000Z',
+                session_id: sessionId,
+                iteration: 4,
+                max_iterations: 10,
+                review_cycle: 2,
+                run_outcome: 'blocked_on_user',
+                lifecycle_outcome: 'askuserQuestion',
+                state: {
+                    deep_interview_question: {
+                        status: 'waiting_for_user',
+                        obligation_id: 'obligation-question-wait',
+                        previous_phase: 'deep-interview',
+                    },
+                },
+            }, null, 2));
+            const result = await recordSkillActivation({
+                stateDir,
+                text: '\\ keep going now',
+                sessionId,
+                nowIso: '2026-04-19T00:15:00.000Z',
+            });
+            assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'autopilot-state.json'), 'utf-8'));
+            assert.equal(modeState.current_phase, 'waiting-for-user');
+            assert.equal(modeState.iteration, 4);
+            assert.equal(modeState.max_iterations, 10);
+            assert.equal(modeState.review_cycle, 2);
+            assert.equal(modeState.lifecycle_outcome, 'askuserQuestion');
+            assert.equal(modeState.state?.deep_interview_question?.status, 'waiting_for_user');
+            assert.equal(modeState.state?.deep_interview_question?.obligation_id, 'obligation-question-wait');
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('resets terminal Ralph blocked_on_user state when reactivated', async () => {
+        const cases = [
+            { name: 'phase', phase: 'blocked_on_user', run_outcome: undefined },
+            { name: 'outcome', phase: 'executing', run_outcome: 'blocked_on_user' },
+        ];
+        for (const testCase of cases) {
+            const cwd = await mkdtemp(join(tmpdir(), `omx-keyword-state-ralph-terminal-${testCase.name}-reactivation-`));
+            const stateDir = join(cwd, '.omx', 'state');
+            const sessionId = `sess-ralph-terminal-${testCase.name}`;
+            try {
+                await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+                await writeFile(join(stateDir, 'sessions', sessionId, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
+                    version: 1,
+                    active: true,
+                    skill: 'ralph',
+                    keyword: '$ralph',
+                    phase: testCase.phase,
+                    activated_at: '2026-04-19T00:00:00.000Z',
+                    updated_at: '2026-04-19T00:10:00.000Z',
+                    source: 'keyword-detector',
+                    session_id: sessionId,
+                    active_skills: [
+                        {
+                            skill: 'ralph',
+                            phase: testCase.phase,
+                            active: true,
+                            activated_at: '2026-04-19T00:00:00.000Z',
+                            updated_at: '2026-04-19T00:10:00.000Z',
+                            session_id: sessionId,
+                        },
+                    ],
+                }, null, 2));
+                await writeFile(join(stateDir, 'sessions', sessionId, 'ralph-state.json'), JSON.stringify({
+                    active: false,
+                    mode: 'ralph',
+                    current_phase: testCase.phase,
+                    started_at: '2026-04-19T00:00:00.000Z',
+                    completed_at: '2026-04-19T00:10:00.000Z',
+                    iteration: 50,
+                    max_iterations: 50,
+                    ...(testCase.run_outcome ? { run_outcome: testCase.run_outcome } : {}),
+                }, null, 2));
+                const result = await recordSkillActivation({
+                    stateDir,
+                    text: '\\ keep going now',
+                    sessionId,
+                    nowIso: '2026-04-19T00:15:00.000Z',
+                });
+                assert.ok(result);
+                assert.equal(result.skill, 'ralph');
+                assert.equal(result.phase, 'planning');
+                assert.equal(result.activated_at, '2026-04-19T00:15:00.000Z');
+                assert.equal(result.active_skills?.[0]?.phase, 'planning');
+                assert.equal(result.active_skills?.[0]?.activated_at, '2026-04-19T00:15:00.000Z');
+                const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'ralph-state.json'), 'utf-8'));
+                assert.equal(modeState.active, true);
+                assert.equal(modeState.current_phase, 'starting');
+                assert.equal(modeState.started_at, '2026-04-19T00:15:00.000Z');
+                assert.equal(modeState.completed_at, undefined);
+                assert.equal(modeState.iteration, 0);
+                assert.equal(modeState.max_iterations, 50);
+            }
+            finally {
+                await rm(cwd, { recursive: true, force: true });
+            }
+        }
+    });
     it('routes bare keep-going continuation to the active ralph skill instead of resetting through generic keep-going detection', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-ralph-bare-continuation-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -2113,6 +3134,43 @@ describe('applyRalplanGate', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('keeps native-proof execution follow-ups gated when consensus is artifact-only', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-native-required-'));
+        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-833.md'), '# Approved plan\n\nLaunch hint: omx team 3:executor "Execute approved issue 833 plan"\n');
+            await writeFile(join(plansDir, 'test-spec-issue-833.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,
+                        provenance_kind: 'codex_exec',
+                    },
+                    ralplan_critic_review: {
+                        agent_role: 'critic',
+                        verdict: 'approve',
+                        iteration: 1,
+                        provenance_kind: 'codex_exec',
+                    },
+                },
+            }));
+            const result = applyRalplanGate(['team'], 'team', { cwd, requireNativeSubagents: true });
+            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 ralph follow-up with durable consensus', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-gate-followup-ralph-'));
         try {