@jstn-sdk/rcs 0.1.0 → 0.1.1

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

@@ -1,1716 +0,0 @@
-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 { 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';
-import { SKILL_ACTIVE_STATE_FILE } from '../../state/skill-active.js';
-import { isUnderspecifiedForExecution, applyRalplanGate } from '../keyword-detector.js';
-import { KEYWORD_TRIGGER_DEFINITIONS } from '../keyword-registry.js';
-describe('keyword detector swarm/team compatibility', () => {
-    it('keeps explicit $skill order in detectKeywords results (left-to-right)', () => {
-        const matches = detectKeywords('$analyze $ultraqa $code-review now');
-        assert.deepEqual(matches.map((m) => m.skill).slice(0, 3), ['analyze', 'ultraqa', 'code-review']);
-    });
-    it('de-duplicates repeated explicit skill tokens', () => {
-        const matches = detectKeywords('$analyze $analyze root cause');
-        assert.deepEqual(matches.map((m) => m.skill), ['analyze']);
-    });
-    it('limits explicit multi-skill invocation to the first contiguous $skill block', () => {
-        const matches = detectKeywords('$ralplan Fix issue #1030 and ensure other directives ($ralph, $team, $deep-interview) are not affected');
-        assert.deepEqual(matches.map((m) => m.skill), ['ralplan']);
-    });
-    it('does not merge implicit keyword matches when an explicit $skill is present', () => {
-        const matches = detectKeywords('please run $team and then analyze the result');
-        assert.deepEqual(matches.map((m) => m.skill), ['team']);
-    });
-    it('does not fall back to implicit keyword detection when an unknown $token is present', () => {
-        const matches = detectKeywords('$maer-thinking 다시 설명해봐 keep going');
-        assert.deepEqual(matches, []);
-        const primary = detectPrimaryKeyword('$maer-thinking 다시 설명해봐 keep going');
-        assert.equal(primary, null);
-    });
-    it('recognizes plugin-prefixed explicit skill tokens', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:ralplan implement issue #1307');
-        assert.deepEqual(matches.map((m) => m.skill), ['ralplan']);
-        assert.equal(matches[0]?.keyword, '$roblox-ai-os-creator-skills:ralplan');
-    });
-    it('supports mixed-form explicit multi-skill invocation ordering and dedupe', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:ralplan $ralph $roblox-ai-os-creator-skills:ralplan ship this');
-        assert.deepEqual(matches.map((m) => m.skill), ['ralplan', 'ralph']);
-        assert.deepEqual(matches.map((m) => m.keyword), ['$roblox-ai-os-creator-skills:ralplan', '$ralph']);
-    });
-    it('keeps recognized tokens on both sides of an unknown plugin-prefixed token in the same contiguous block', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:ralplan $roblox-ai-os-creator-skills:unknown $ralph');
-        assert.deepEqual(matches.map((m) => m.skill), ['ralplan', 'ralph']);
-        assert.deepEqual(matches.map((m) => m.keyword), ['$roblox-ai-os-creator-skills:ralplan', '$ralph']);
-    });
-    it('limits mixed-form explicit invocation to the first contiguous block', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:ralplan text $ralph');
-        assert.deepEqual(matches.map((m) => m.skill), ['ralplan']);
-    });
-    it('normalizes plugin-prefixed alias tokens', () => {
-        const swarm = detectPrimaryKeyword('$roblox-ai-os-creator-skills:swarm handle this');
-        assert.ok(swarm);
-        assert.equal(swarm.skill, 'team');
-        assert.equal(swarm.keyword, '$roblox-ai-os-creator-skills:swarm');
-        const ulw = detectPrimaryKeyword('$roblox-ai-os-creator-skills:ulw continue');
-        assert.ok(ulw);
-        assert.equal(ulw.skill, 'ultrawork');
-        assert.equal(ulw.keyword, '$roblox-ai-os-creator-skills:ulw');
-    });
-    it('supports plugin-prefixed hyphenated workflow tokens', () => {
-        const deepInterview = detectPrimaryKeyword('$roblox-ai-os-creator-skills:deep-interview gather requirements');
-        assert.ok(deepInterview);
-        assert.equal(deepInterview.skill, 'deep-interview');
-        assert.equal(deepInterview.keyword, '$roblox-ai-os-creator-skills:deep-interview');
-        const codeReview = detectPrimaryKeyword('$roblox-ai-os-creator-skills:code-review before merge');
-        assert.ok(codeReview);
-        assert.equal(codeReview.skill, 'code-review');
-        assert.equal(codeReview.keyword, '$roblox-ai-os-creator-skills:code-review');
-    });
-    it('supports explicit colon-form creator psychology commands', () => {
-        const audience = detectPrimaryKeyword('$brief:audience farming simulator audience fit');
-        assert.ok(audience);
-        assert.equal(audience.skill, 'brief-audience');
-        assert.equal(audience.keyword, '$brief:audience');
-        const progression = detectPrimaryKeyword('$forge:progression write the ladder');
-        assert.ok(progression);
-        assert.equal(progression.skill, 'forge-progression');
-        assert.equal(progression.keyword, '$forge:progression');
-    });
-    it('supports plugin-prefixed creator psychology commands', () => {
-        const match = detectPrimaryKeyword('$roblox-ai-os-creator-skills:brief:audience map the audience');
-        assert.ok(match);
-        assert.equal(match.skill, 'brief-audience');
-        assert.equal(match.keyword, '$roblox-ai-os-creator-skills:brief:audience');
-    });
-    it('rejects arbitrary explicit prefixes that are not allowlisted namespaces', () => {
-        assert.equal(detectPrimaryKeyword('$anything:team ship it'), null);
-        assert.equal(detectPrimaryKeyword('$foo:brief:audience map the audience'), null);
-    });
-    it('does not fall back to implicit keyword detection when an unknown plugin-prefixed $token is present', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:maer-thinking 다시 설명해봐 keep going');
-        assert.deepEqual(matches, []);
-        const primary = detectPrimaryKeyword('$roblox-ai-os-creator-skills:maer-thinking 다시 설명해봐 keep going');
-        assert.equal(primary, null);
-    });
-    it('suppresses implicit detection when an unknown plugin-prefixed token is present with other keyword text', () => {
-        const matches = detectKeywords('$roblox-ai-os-creator-skills:unknown analyze this issue');
-        assert.deepEqual(matches, []);
-        assert.equal(detectPrimaryKeyword('$roblox-ai-os-creator-skills:unknown analyze this issue'), null);
-    });
-    it('does not auto-detect keywords for explicit /prompts invocation without $skills', () => {
-        const matches = detectKeywords('/prompts:architect analyze this issue');
-        assert.deepEqual(matches, []);
-        const primary = detectPrimaryKeyword('/prompts:architect analyze this issue');
-        assert.equal(primary, null);
-    });
-    it('treats /prompts invocation with trailing punctuation as explicit command', () => {
-        const matches = detectKeywords('/prompts:architect, analyze this issue');
-        assert.deepEqual(matches, []);
-        const primary = detectPrimaryKeyword('/prompts:architect, analyze this issue');
-        assert.equal(primary, null);
-    });
-    it('maps explicit $analyze invocation to analyze skill', () => {
-        const match = detectPrimaryKeyword('please run $analyze on this workflow');
-        assert.ok(match);
-        assert.equal(match.skill, 'analyze');
-        assert.equal(match.keyword.toLowerCase(), '$analyze');
-    });
-    it('maps code-review keyword variants to code-review skill', () => {
-        const hyphen = detectPrimaryKeyword('run $code-review before merge');
-        assert.ok(hyphen);
-        assert.equal(hyphen.skill, 'code-review');
-        assert.equal(hyphen.keyword.toLowerCase(), '$code-review');
-        const spaced = detectPrimaryKeyword('please do a code review');
-        assert.ok(spaced);
-        assert.equal(spaced.skill, 'code-review');
-    });
-    it('supports explicit multi-skill invocation by prioritizing left-most $skill', () => {
-        const match = detectPrimaryKeyword('$ultraqa $analyze $code-review run now');
-        assert.ok(match);
-        assert.equal(match.skill, 'ultraqa');
-        assert.equal(match.keyword.toLowerCase(), '$ultraqa');
-    });
-    it('maps "coordinated team" phrase to team orchestration skill', () => {
-        const match = detectPrimaryKeyword('run a coordinated team for implementation');
-        assert.ok(match);
-        assert.equal(match.skill, 'team');
-        assert.match(match.keyword.toLowerCase(), /team/);
-    });
-    it('maps "swarm" to team orchestration skill', () => {
-        const match = detectPrimaryKeyword('please use swarm for this task');
-        assert.ok(match);
-        assert.equal(match.skill, 'team');
-    });
-    it('maps "coordinated swarm" phrase to team orchestration skill', () => {
-        const match = detectPrimaryKeyword('run a coordinated swarm for implementation');
-        assert.ok(match);
-        assert.equal(match.skill, 'team');
-        assert.match(match.keyword.toLowerCase(), /swarm/);
-    });
-    it('keeps swarm trigger priority aligned with explicit team invocation', () => {
-        const teamMatch = detectKeywords('use $team agents for this').find((entry) => entry.skill === 'team');
-        const swarmMatch = detectKeywords('use swarm for this').find((entry) => entry.skill === 'team');
-        assert.ok(teamMatch);
-        assert.ok(swarmMatch);
-        assert.equal(swarmMatch.priority, teamMatch.priority);
-    });
-    it('does not trigger team keyword from filesystem/team-state path text', () => {
-        const match = detectPrimaryKeyword('You have 1 new message(s). Read .rcs/state/team/execute-plan/mailbox/worker-3.json, act now, reply with concrete progress, then continue assigned work or next feasible task.');
-        assert.equal(match, null);
-    });
-    it('does not trigger team skill from incidental prose usage', () => {
-        const match = detectPrimaryKeyword('the team reviewed the document and shared feedback');
-        assert.equal(match, null);
-    });
-    it('does not trigger team from bare skill-name phrasing without $ invocation', () => {
-        const match = detectPrimaryKeyword('please use team agents for this');
-        assert.equal(match, null);
-    });
-    it('still triggers team for explicit $team invocation', () => {
-        const match = detectPrimaryKeyword('please run $team now');
-        assert.ok(match);
-        assert.equal(match.skill, 'team');
-    });
-    it('does not trigger keyword detector for explicit /prompts:swarm invocation', () => {
-        const match = detectPrimaryKeyword('use /prompts:swarm for this');
-        assert.equal(match, null);
-    });
-    it('does not trigger ralph from plain conversational mention', () => {
-        const match = detectPrimaryKeyword('why does ralph keep blocking stop?');
-        assert.equal(match, null);
-    });
-    it('still triggers ralph for explicit $ralph invocation', () => {
-        const match = detectPrimaryKeyword('$ralph continue verification');
-        assert.ok(match);
-        assert.equal(match.skill, 'ralph');
-        assert.equal(match.keyword.toLowerCase(), '$ralph');
-    });
-    it('prefers ralplan over ralph follow-up language when both implicit routes are present', () => {
-        const match = detectPrimaryKeyword('keep going but do consensus plan first');
-        assert.ok(match);
-        assert.equal(match.skill, 'ralplan');
-    });
-    it('applies longest-match tie-breaker when priorities are equal', () => {
-        const match = detectPrimaryKeyword('please run a coordinated swarm for this');
-        assert.ok(match);
-        assert.equal(match.skill, 'team');
-        assert.equal(match.keyword.toLowerCase(), 'coordinated swarm');
-    });
-    it('maps "deep interview" phrase to deep-interview skill', () => {
-        const match = detectPrimaryKeyword('please run a deep interview before planning');
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), 'deep interview');
-    });
-    it('does not trigger deep-interview from cleanup or state-management mentions', () => {
-        assert.equal(detectPrimaryKeyword('clear deep interview state before continuing'), null);
-        assert.equal(detectPrimaryKeyword('cleanup stale deep-interview state after session clear'), null);
-        assert.equal(detectPrimaryKeyword('remove the stale deep interview lock from .rcs/state'), null);
-    });
-    it('maps "gather requirements" to deep-interview skill', () => {
-        const match = detectPrimaryKeyword('let us gather requirements first');
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), 'gather requirements');
-    });
-    it('maps "ouroboros" to deep-interview skill', () => {
-        const match = detectPrimaryKeyword('please run ouroboros before planning');
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), 'ouroboros');
-    });
-    it('maps "interview me" to deep-interview skill', () => {
-        const match = detectPrimaryKeyword('interview me before we start implementation');
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), 'interview me');
-    });
-    it('maps "don\'t assume" to deep-interview skill', () => {
-        const match = detectPrimaryKeyword("don't assume anything yet");
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), "don't assume");
-    });
-    it('prefers "deep interview" over "interview" for deterministic longest-match behavior', () => {
-        const match = detectPrimaryKeyword('deep interview this request first');
-        assert.ok(match);
-        assert.equal(match.skill, 'deep-interview');
-        assert.equal(match.keyword.toLowerCase(), 'deep interview');
-    });
-    it('treats direct abort commands as cancel intent', () => {
-        const match = detectPrimaryKeyword('abort now');
-        assert.ok(match);
-        assert.equal(match.skill, 'cancel');
-        assert.equal(match.keyword.toLowerCase(), 'abort');
-    });
-    it('treats direct stop commands as cancel intent', () => {
-        const match = detectPrimaryKeyword('stop now');
-        assert.ok(match);
-        assert.equal(match.skill, 'cancel');
-        assert.equal(match.keyword.toLowerCase(), 'stop');
-    });
-    it('does not trigger cancel from incidental stop/abort test-log prose', () => {
-        assert.equal(detectPrimaryKeyword('FAIL should stop retrying after max attempts'), null);
-        assert.equal(detectPrimaryKeyword('PASS request aborted when upstream returns 499'), null);
-    });
-    it('does not trigger ultrawork from incidental parallel test-log prose', () => {
-        assert.equal(detectPrimaryKeyword('PASS runs assertions in parallel when sharding is enabled'), null);
-        assert.equal(detectPrimaryKeyword('running 8 tests in parallel across 4 workers'), null);
-    });
-    it('normalizes the Korean keyboard typo for ulw to ultrawork only', () => {
-        const match = detectPrimaryKeyword('ㅕㅣㅈ로 이 작업 처리해줘');
-        assert.ok(match);
-        assert.equal(match.skill, 'ultrawork');
-        assert.equal(match.keyword, 'ulw');
-        const explicitMatch = detectPrimaryKeyword('$ㅕㅣㅈ로 이 작업 처리해줘');
-        assert.ok(explicitMatch);
-        assert.equal(explicitMatch.skill, 'ultrawork');
-        assert.equal(explicitMatch.keyword, '$ulw');
-        assert.equal(detectPrimaryKeyword('ㅁㅔㅔ로 처리해줘'), null);
-    });
-});
-describe('autoresearch keyword detection', () => {
-    it('detects explicit $autoresearch invocation', () => {
-        const match = detectPrimaryKeyword('please run $autoresearch now');
-        assert.ok(match);
-        assert.equal(match.skill, 'autoresearch');
-        assert.equal(match.keyword.toLowerCase(), '$autoresearch');
-    });
-    it('does not detect bare autoresearch phrasing without explicit $ invocation', () => {
-        const match = detectPrimaryKeyword('please use autoresearch workflow for this mission');
-        assert.equal(match, null);
-    });
-    it('does not trigger autoresearch from incidental prose', () => {
-        const match = detectPrimaryKeyword('Karpathy did autoresearch before native hooks existed');
-        assert.equal(match, null);
-    });
-});
-describe('explicit skill-name invocation requirement', () => {
-    it('does not trigger analyze from bare skill-name usage', () => {
-        assert.equal(detectPrimaryKeyword('please analyze this workflow'), null);
-    });
-    it('does not trigger autoresearch from bare skill-name usage', () => {
-        assert.equal(detectPrimaryKeyword('please run autoresearch now'), null);
-    });
-    it('does not trigger ralph from bare skill-name usage', () => {
-        assert.equal(detectPrimaryKeyword('please use ralph for this task'), null);
-    });
-    it('does not trigger ralplan from bare skill-name usage', () => {
-        assert.equal(detectPrimaryKeyword('please do ralplan first'), null);
-    });
-});
-describe('keyword registry coverage', () => {
-    it('includes key team/swarm aliases in runtime keyword registry', () => {
-        const registryKeywords = new Set(KEYWORD_TRIGGER_DEFINITIONS.map((v) => v.keyword.toLowerCase()));
-        assert.ok(registryKeywords.has('$ultraqa'));
-        assert.ok(registryKeywords.has('$analyze'));
-        assert.ok(registryKeywords.has('investigate'));
-        assert.ok(registryKeywords.has('code review'));
-        assert.ok(registryKeywords.has('$code-review'));
-        assert.ok(registryKeywords.has('coordinated team'));
-        assert.ok(registryKeywords.has('swarm'));
-        assert.ok(registryKeywords.has('coordinated swarm'));
-        assert.ok(registryKeywords.has('ouroboros'));
-        assert.ok(registryKeywords.has("don't assume"));
-        assert.ok(registryKeywords.has('interview me'));
-        assert.ok(registryKeywords.has('wiki query'));
-        assert.ok(registryKeywords.has('wiki add'));
-        assert.ok(registryKeywords.has('wiki lint'));
-        assert.ok(registryKeywords.has('$autoresearch'));
-        assert.ok(registryKeywords.has('$brief:audience'));
-        assert.ok(registryKeywords.has('$brief:motivation'));
-        assert.ok(registryKeywords.has('$blueprint:psych'));
-        assert.ok(registryKeywords.has('$blueprint:loop'));
-        assert.ok(registryKeywords.has('$blueprint:retention'));
-        assert.ok(registryKeywords.has('$blueprint:social'));
-        assert.ok(registryKeywords.has('$forge:reward-loop'));
-        assert.ok(registryKeywords.has('$forge:daily-loop'));
-        assert.ok(registryKeywords.has('$forge:event-loop'));
-        assert.ok(registryKeywords.has('$forge:progression'));
-        assert.ok(registryKeywords.has('$forge:status'));
-        assert.ok(registryKeywords.has('$forge:fomo'));
-        assert.ok(registryKeywords.has('$forge:mastery'));
-        assert.ok(registryKeywords.has('$forge:community'));
-    });
-});
-describe('keyword detector skill-active-state lifecycle', () => {
-    it('writes skill-active-state.json with ralplan phase when autopilot keyword activates', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'please run $autopilot and keep going',
-                sessionId: 'sess-1',
-                threadId: 'thread-1',
-                turnId: 'turn-1',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.equal(result.phase, 'ralplan');
-            assert.equal(result.active, true);
-            assert.deepEqual(result.active_skills, [{
-                    skill: 'autopilot',
-                    phase: 'ralplan',
-                    active: true,
-                    activated_at: '2026-02-25T00:00:00.000Z',
-                    updated_at: '2026-02-25T00:00:00.000Z',
-                    session_id: 'sess-1',
-                    thread_id: 'thread-1',
-                    turn_id: 'turn-1',
-                }]);
-            assert.equal(result.initialized_mode, 'autopilot');
-            assert.equal(result.initialized_state_path, '.rcs/state/sessions/sess-1/autopilot-state.json');
-            const persisted = JSON.parse(await readFile(join(stateDir, SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.equal(persisted.skill, 'autopilot');
-            assert.equal(persisted.phase, 'ralplan');
-            assert.equal(persisted.active, true);
-            assert.deepEqual(persisted.active_skills, [{
-                    skill: 'autopilot',
-                    phase: 'ralplan',
-                    active: true,
-                    activated_at: '2026-02-25T00:00:00.000Z',
-                    updated_at: '2026-02-25T00:00:00.000Z',
-                    session_id: 'sess-1',
-                    thread_id: 'thread-1',
-                    turn_id: 'turn-1',
-                }]);
-            assert.equal(persisted.initialized_mode, 'autopilot');
-            const sessionScopedSkillState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-1', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(sessionScopedSkillState.active_skills, persisted.active_skills);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-1', 'autopilot-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'autopilot');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'ralplan');
-            assert.equal(modeState.iteration, 1);
-            assert.equal(modeState.review_cycle, 0);
-            assert.equal(modeState.max_iterations, 10);
-            assert.deepEqual(modeState.state.phase_cycle, ['ralplan', 'ralph', 'code-review']);
-            assert.deepEqual(modeState.state.handoff_artifacts, { ralplan: null, ralph: null, code_review: null });
-            assert.equal(modeState.state.review_verdict, null);
-            assert.equal(modeState.state.return_to_ralplan_reason, 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(), 'rcs-keyword-state-overlap-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await recordSkillActivation({
-                stateDir,
-                text: '$team ship this',
-                sessionId: 'sess-overlap',
-                threadId: 'thread-overlap',
-                turnId: 'turn-1',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralph continue verification',
-                sessionId: 'sess-overlap',
-                threadId: 'thread-overlap',
-                turnId: 'turn-2',
-                nowIso: '2026-02-26T00:05:00.000Z',
-            });
-            assert.ok(result);
-            assert.deepEqual(result.active_skills?.map((entry) => entry.skill), ['team', 'ralph']);
-            const persisted = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-overlap', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(persisted.active_skills?.map((entry) => entry.skill), ['team', 'ralph']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('keeps a session-scoped Ralph activation out of the root canonical state for other sessions', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ralph-isolation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralph continue verification',
-                sessionId: 'sess-ralph-a',
-                threadId: 'thread-ralph-a',
-                turnId: 'turn-ralph-a',
-                nowIso: '2026-04-14T00:00:00.000Z',
-            });
-            assert.ok(result);
-            const rootSkillStatePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-            assert.equal(existsSync(rootSkillStatePath), false, 'session-scoped prompt activation should not create a root canonical skill state');
-            const sessionScopedSkillState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralph-a', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(sessionScopedSkillState.active_skills, [{
-                    skill: 'ralph',
-                    phase: 'planning',
-                    active: true,
-                    activated_at: '2026-04-14T00:00:00.000Z',
-                    updated_at: '2026-04-14T00:00:00.000Z',
-                    session_id: 'sess-ralph-a',
-                    thread_id: 'thread-ralph-a',
-                    turn_id: 'turn-ralph-a',
-                }]);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('hard-fails denied workflow overlaps without mutating current state', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deny-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await recordSkillActivation({
-                stateDir,
-                text: '$team ship this',
-                sessionId: 'sess-deny',
-                threadId: 'thread-deny',
-                turnId: 'turn-1',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            const denied = await recordSkillActivation({
-                stateDir,
-                text: '$autopilot do it too',
-                sessionId: 'sess-deny',
-                threadId: 'thread-deny',
-                turnId: 'turn-2',
-                nowIso: '2026-02-26T00:05:00.000Z',
-            });
-            assert.ok(denied?.transition_error);
-            assert.match(String(denied?.transition_error), /Unsupported workflow overlap: team \+ autopilot\./);
-            assert.match(String(denied?.transition_error), /`rcs state clear --mode <mode>`/);
-            assert.match(String(denied?.transition_error), /`rcs_state\.\*` MCP tools/);
-            const persisted = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-deny', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(persisted.active_skills?.map((entry) => entry.skill), ['team']);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-deny', 'autopilot-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('denies prompt-submit overlaps against the current session-visible canonical state', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-session-visible-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-visible'), { recursive: true });
-            await writeFile(join(stateDir, SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'team',
-                active_skills: [
-                    { skill: 'team', phase: 'running', active: true },
-                ],
-            }, null, 2));
-            await writeFile(join(stateDir, 'sessions', 'sess-visible', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'team',
-                session_id: 'sess-visible',
-                active_skills: [
-                    { skill: 'team', phase: 'running', active: true },
-                    { skill: 'ralph', phase: 'executing', active: true, session_id: 'sess-visible' },
-                ],
-            }, null, 2));
-            const allowed = await recordSkillActivation({
-                stateDir,
-                text: '$ultrawork continue',
-                sessionId: 'sess-visible',
-                nowIso: '2026-04-10T00:00:00.000Z',
-            });
-            assert.equal(allowed?.transition_error, undefined);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-visible', 'ultrawork-state.json')), true);
-            const persisted = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-visible', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(persisted.active_skills?.map((entry) => entry.skill), ['team', 'ralph', 'ultrawork']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('activates ultrawork mode from the Korean keyboard typo for ulw', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ulw-ko-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'ㅕㅣㅈ로 병렬 처리해줘',
-                sessionId: 'sess-ulw-ko',
-                threadId: 'thread-ulw-ko',
-                turnId: 'turn-ulw-ko',
-                nowIso: '2026-04-21T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ultrawork');
-            assert.equal(result.keyword, 'ulw');
-            assert.equal(result.initialized_mode, 'ultrawork');
-            assert.equal(result.initialized_state_path, '.rcs/state/sessions/sess-ulw-ko/ultrawork-state.json');
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ulw-ko', 'ultrawork-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'ultrawork');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'planning');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('seeds executing state for autoresearch prompt-submit activation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-autoresearch-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$autoresearch continue the mission',
-                sessionId: 'sess-autoresearch',
-                nowIso: '2026-04-17T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autoresearch');
-            assert.equal(result.phase, 'executing');
-            assert.equal(result.initialized_mode, 'autoresearch');
-            assert.equal(result.initialized_state_path, '.rcs/state/sessions/sess-autoresearch/autoresearch-state.json');
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-autoresearch', 'autoresearch-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'autoresearch');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'executing');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves the planning skill when ralplan and autoresearch are invoked together', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-autoresearch-planning-precedence-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan $autoresearch wire the mission loop',
-                sessionId: 'sess-autoresearch-precedence',
-                nowIso: '2026-04-17T00:05:00.000Z',
-            });
-            assert.equal(result?.transition_error, undefined);
-            assert.equal(result?.skill, 'ralplan');
-            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ralplan']);
-            assert.deepEqual(result?.deferred_skills, ['autoresearch']);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-autoresearch-precedence', 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-autoresearch-precedence', 'autoresearch-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('captures tmux_pane_id in seeded ralplan prompt-submit state when TMUX_PANE is present', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ralplan-pane-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const previousPane = process.env.TMUX_PANE;
-        try {
-            await mkdir(stateDir, { recursive: true });
-            process.env.TMUX_PANE = '%88';
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan tighten the plan',
-                sessionId: 'sess-ralplan-pane',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            assert.ok(result);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan-pane', 'ralplan-state.json'), 'utf-8'));
-            assert.equal(modeState.tmux_pane_id, '%88');
-        }
-        finally {
-            if (typeof previousPane === 'string')
-                process.env.TMUX_PANE = previousPane;
-            else
-                delete process.env.TMUX_PANE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('captures tmux_pane_id in deep-interview prompt-submit state when TMUX_PANE is present', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-pane-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const previousPane = process.env.TMUX_PANE;
-        try {
-            await mkdir(stateDir, { recursive: true });
-            process.env.TMUX_PANE = '%89';
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$deep-interview tighten the requirements',
-                sessionId: 'sess-deep-interview-pane',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            assert.ok(result);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-deep-interview-pane', 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(modeState.tmux_pane_id, '%89');
-        }
-        finally {
-            if (typeof previousPane === 'string')
-                process.env.TMUX_PANE = previousPane;
-            else
-                delete process.env.TMUX_PANE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves an existing deep-interview tmux_pane_id when prompt-submit re-seeds state without TMUX_PANE', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-preserve-pane-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const sessionId = 'sess-deep-interview-preserve-pane';
-        const previousPane = process.env.TMUX_PANE;
-        try {
-            await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
-            delete process.env.TMUX_PANE;
-            await writeFile(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json'), JSON.stringify({
-                active: true,
-                mode: 'deep-interview',
-                current_phase: 'intent-first',
-                started_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:00:00.000Z',
-                session_id: sessionId,
-                tmux_pane_id: '%89',
-                tmux_pane_set_at: '2026-02-25T00:00:00.000Z',
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$deep-interview tighten the requirements',
-                sessionId,
-                nowIso: '2026-02-25T00:05:00.000Z',
-            });
-            assert.ok(result);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', sessionId, 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(modeState.tmux_pane_id, '%89');
-            assert.equal(modeState.tmux_pane_set_at, '2026-02-25T00:00:00.000Z');
-        }
-        finally {
-            if (typeof previousPane === 'string')
-                process.env.TMUX_PANE = previousPane;
-            else
-                delete process.env.TMUX_PANE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('seeds first-class state for ralplan prompt-submit activation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ralplan-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan tighten the plan',
-                sessionId: 'sess-ralplan',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ralplan');
-            assert.equal(result.initialized_mode, 'ralplan');
-            assert.equal(result.initialized_state_path, '.rcs/state/sessions/sess-ralplan/ralplan-state.json');
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralplan', 'ralplan-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'ralplan');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'planning');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('auto-completes deep-interview during allowlisted forward handoff', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-handoff-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-handoff'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-handoff', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'deep-interview',
-                phase: 'planning',
-                session_id: 'sess-handoff',
-                active_skills: [{ skill: 'deep-interview', phase: 'planning', active: true, session_id: 'sess-handoff' }],
-            }, null, 2));
-            await writeFile(join(stateDir, 'sessions', 'sess-handoff', 'deep-interview-state.json'), JSON.stringify({
-                active: true,
-                mode: 'deep-interview',
-                current_phase: 'intent-first',
-                question_enforcement: {
-                    obligation_id: 'obligation-handoff',
-                    source: 'rcs-question',
-                    status: 'pending',
-                    requested_at: '2026-04-09T23:59:00.000Z',
-                },
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan implement the approved contract',
-                sessionId: 'sess-handoff',
-                nowIso: '2026-04-10T00:00:00.000Z',
-            });
-            assert.equal(result?.transition_error, undefined);
-            assert.equal(result?.transition_message, 'mode transiting: deep-interview -> ralplan');
-            const completed = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-handoff', 'deep-interview-state.json'), 'utf-8'));
-            assert.equal(completed.active, false);
-            assert.equal(completed.current_phase, 'completed');
-            assert.equal(completed.question_enforcement?.status, 'cleared');
-            assert.equal(completed.question_enforcement?.clear_reason, 'handoff');
-            assert.ok(completed.question_enforcement?.cleared_at);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves the planning skill when planning and execution workflows are invoked together', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-planning-precedence-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan $team $ralph ship this fix',
-                sessionId: 'sess-multi',
-                nowIso: '2026-04-10T00:00:00.000Z',
-            });
-            assert.equal(result?.transition_error, undefined);
-            assert.equal(result?.transition_message, undefined);
-            assert.equal(result?.skill, 'ralplan');
-            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ralplan']);
-            assert.deepEqual(result?.deferred_skills, ['team', 'ralph']);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-multi', 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(stateDir, 'team-state.json')), false);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-multi', 'ralph-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('lets planning win even when execution appears first in the contiguous skill block', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-planning-beats-execution-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralph $ralplan continue',
-                sessionId: 'sess-priority',
-                nowIso: '2026-04-10T00:00:00.000Z',
-            });
-            assert.equal(result?.transition_error, undefined);
-            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, 'sessions', 'sess-priority', 'ralplan-state.json')), true);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-priority', 'ralph-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('seeds first-class root team state for team prompt-submit activation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-team-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$team coordinate the hotfix',
-                sessionId: 'sess-team',
-                nowIso: '2026-04-08T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'team');
-            assert.equal(result.initialized_mode, 'team');
-            assert.equal(result.initialized_state_path, '.rcs/state/team-state.json');
-            const modeState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'team');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'starting');
-        }
-        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(), 'rcs-keyword-state-team-preserve-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({
-                active: true,
-                mode: 'team',
-                current_phase: 'team-verify',
-                started_at: '2026-04-08T00:00:00.000Z',
-                updated_at: '2026-04-08T00:05:00.000Z',
-                team_name: 'review-team',
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$team continue the review lane',
-                sessionId: 'sess-team-preserve',
-                nowIso: '2026-04-08T00:10:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.initialized_mode, 'team');
-            assert.equal(result.initialized_state_path, '.rcs/state/team-state.json');
-            const modeState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'team');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'team-verify');
-            assert.equal(modeState.team_name, 'review-team');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves active team root state when planning follow-up defers a simultaneous $team re-entry', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-team-planning-followup-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({
-                active: true,
-                mode: 'team',
-                current_phase: 'team-verify',
-                started_at: '2026-04-08T00:00:00.000Z',
-                updated_at: '2026-04-08T00:05:00.000Z',
-                team_name: 'review-team',
-                session_id: 'sess-team-root',
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralplan $team tighten the approved execution handoff',
-                sessionId: 'sess-team-followup',
-                nowIso: '2026-04-10T00:15:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result?.skill, 'ralplan');
-            assert.equal(result?.initialized_mode, 'ralplan');
-            assert.deepEqual(result?.active_skills?.map((entry) => entry.skill), ['ralplan']);
-            assert.deepEqual(result?.deferred_skills, ['team']);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
-            assert.equal(modeState.mode, 'team');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'team-verify');
-            assert.equal(modeState.team_name, 'review-team');
-            assert.equal(modeState.session_id, 'sess-team-root');
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-team-followup', 'team-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves root team state when $ralph is activated for the current session', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-team-ralph-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await recordSkillActivation({
-                stateDir,
-                text: '$team coordinate the rollout',
-                sessionId: 'sess-team-ralph',
-                nowIso: '2026-04-09T00:00:00.000Z',
-            });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ralph complete the approved plan',
-                sessionId: 'sess-team-ralph',
-                nowIso: '2026-04-09T00:05:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ralph');
-            const rootCanonical = JSON.parse(await readFile(join(stateDir, SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(rootCanonical.active_skills?.map(({ skill, phase, session_id }) => ({
-                skill,
-                phase,
-                session_id,
-            })), [{ skill: 'team', phase: 'planning', session_id: 'sess-team-ralph' }]);
-            const sessionCanonical = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-team-ralph', SKILL_ACTIVE_STATE_FILE), 'utf-8'));
-            assert.deepEqual(sessionCanonical.active_skills?.map(({ skill, phase, session_id }) => ({
-                skill,
-                phase,
-                session_id,
-            })), [
-                { skill: 'team', phase: 'planning', session_id: 'sess-team-ralph' },
-                { skill: 'ralph', phase: 'planning', session_id: 'sess-team-ralph' },
-            ]);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('acquires a deep-interview input lock immediately on activation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'please run a deep interview before planning',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'deep-interview');
-            assert.equal(result.input_lock?.active, true);
-            assert.deepEqual(result.input_lock?.blocked_inputs, [...DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS]);
-            assert.equal(result.input_lock?.blocked_inputs.includes('next i should'), true);
-            assert.equal(result.input_lock?.message, DEEP_INTERVIEW_INPUT_LOCK_MESSAGE);
-            const modeState = JSON.parse(await readFile(join(stateDir, DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
-            assert.equal(modeState.mode, 'deep-interview');
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.current_phase, 'intent-first');
-            assert.equal(modeState.input_lock?.active, true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('creates the session-scoped deep-interview state directory before persisting mode state', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-session-dir-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await persistDeepInterviewModeState(stateDir, {
-                version: 1,
-                active: true,
-                skill: 'deep-interview',
-                keyword: 'deep interview',
-                phase: 'ralplan',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:00:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-sync',
-                input_lock: {
-                    active: true,
-                    scope: 'deep-interview-auto-approval',
-                    acquired_at: '2026-02-25T00:00:00.000Z',
-                    blocked_inputs: [...DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS],
-                    message: DEEP_INTERVIEW_INPUT_LOCK_MESSAGE,
-                },
-            }, '2026-02-25T00:00:00.000Z', null, { sessionId: 'sess-sync' });
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-sync', DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
-            assert.equal(modeState.active, true);
-            assert.equal(modeState.mode, 'deep-interview');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('clears stale pending deep-interview question enforcement when deep-interview is reactivated', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-reactivation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-reactivate'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-reactivate', DEEP_INTERVIEW_STATE_FILE), JSON.stringify({
-                active: false,
-                mode: 'deep-interview',
-                current_phase: 'completed',
-                started_at: '2026-04-10T00:00:00.000Z',
-                updated_at: '2026-04-10T00:10:00.000Z',
-                completed_at: '2026-04-10T00:10:00.000Z',
-                question_enforcement: {
-                    obligation_id: 'obligation-reactivate',
-                    source: 'rcs-question',
-                    status: 'pending',
-                    requested_at: '2026-04-10T00:05:00.000Z',
-                },
-            }, null, 2));
-            await persistDeepInterviewModeState(stateDir, {
-                version: 1,
-                active: true,
-                skill: 'deep-interview',
-                keyword: 'deep interview',
-                phase: 'planning',
-                activated_at: '2026-04-10T00:11:00.000Z',
-                updated_at: '2026-04-10T00:11:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-reactivate',
-                input_lock: {
-                    active: true,
-                    scope: 'deep-interview-auto-approval',
-                    acquired_at: '2026-04-10T00:11:00.000Z',
-                    blocked_inputs: [...DEEP_INTERVIEW_BLOCKED_APPROVAL_INPUTS],
-                    message: DEEP_INTERVIEW_INPUT_LOCK_MESSAGE,
-                },
-            }, '2026-04-10T00:11:00.000Z', null, { sessionId: 'sess-reactivate' });
-            const reactivated = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-reactivate', DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
-            assert.equal(reactivated.active, true);
-            assert.equal(reactivated.question_enforcement?.status, 'cleared');
-            assert.equal(reactivated.question_enforcement?.clear_reason, 'handoff');
-            assert.ok(reactivated.question_enforcement?.cleared_at);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releases the deep-interview input lock on abort via cancel keyword', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-deep-interview-abort-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await recordSkillActivation({
-                stateDir,
-                text: 'please run $deep-interview',
-                nowIso: '2026-02-25T00:00:00.000Z',
-            });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'abort now',
-                nowIso: '2026-02-25T00:05:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'deep-interview');
-            assert.equal(result.active, false);
-            assert.equal(result.phase, 'completing');
-            assert.equal(result.input_lock?.active, false);
-            assert.equal(result.input_lock?.released_at, '2026-02-25T00:05:00.000Z');
-            const modeState = JSON.parse(await readFile(join(stateDir, DEEP_INTERVIEW_STATE_FILE), 'utf-8'));
-            assert.equal(modeState.active, false);
-            assert.equal(modeState.current_phase, 'completing');
-            assert.equal(modeState.completed_at, '2026-02-25T00:05:00.000Z');
-            assert.equal(modeState.input_lock?.active, false);
-            assert.equal(modeState.input_lock?.released_at, '2026-02-25T00:05:00.000Z');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not write state when no keyword is present', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-none-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'hello there, how are you',
-            });
-            assert.equal(result, null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not seed non-stateful skill mode state on keyword activation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-non-stateful-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'please do a code review before merge',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'code-review');
-            assert.equal(result.initialized_mode, undefined);
-            assert.equal(result.initialized_state_path, undefined);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('emits a warning when skill-active-state persistence fails', async () => {
-        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/);
-    });
-    it('preserves activated_at for same-skill continuation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-continuation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const statePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(statePath, JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: '$autopilot',
-                phase: 'ralplan',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                source: 'keyword-detector',
-            }));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'autopilot keep going',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.equal(result.transition_error, undefined);
-            assert.equal(result.activated_at, '2026-02-25T00:00:00.000Z');
-            assert.equal(result.updated_at, '2026-02-26T00:00:00.000Z');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves seeded mode progress for same-skill continuation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-seed-continuation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const statePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await mkdir(join(stateDir, 'sessions', 'sess-autopilot'), { recursive: true });
-            await writeFile(statePath, JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: 'autopilot',
-                phase: 'ralplan',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-autopilot',
-            }));
-            await writeFile(join(stateDir, 'sessions', 'sess-autopilot', 'autopilot-state.json'), JSON.stringify({
-                active: true,
-                mode: 'autopilot',
-                current_phase: 'code-review',
-                started_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                session_id: 'sess-autopilot',
-                state: { context_snapshot_path: '.rcs/context/existing.md' },
-            }));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'autopilot keep going',
-                sessionId: 'sess-autopilot',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.equal(result.phase, 'ralplan');
-            assert.equal(result.transition_error, undefined);
-            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, '.rcs/context/existing.md');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not persist Ralph workflow state for a plain conversational mention', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ralph-plain-text-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'why does ralph keep blocking stop?',
-                sessionId: 'sess-plain-ralph',
-                threadId: 'thread-plain-ralph',
-                turnId: 'turn-plain-ralph',
-                nowIso: '2026-04-17T00:00:00.000Z',
-            });
-            assert.equal(result, null);
-            assert.equal(existsSync(join(stateDir, SKILL_ACTIVE_STATE_FILE)), false);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-plain-ralph', SKILL_ACTIVE_STATE_FILE)), false);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-plain-ralph', 'ralph-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves Ralph iteration counters for same-skill continuation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ralph-continuation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const statePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(statePath, JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'ralph',
-                keyword: 'ralph',
-                phase: 'executing',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                source: 'keyword-detector',
-            }));
-            await writeFile(join(stateDir, 'ralph-state.json'), JSON.stringify({
-                active: true,
-                mode: 'ralph',
-                current_phase: 'verifying',
-                started_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                iteration: 3,
-                max_iterations: 10,
-            }));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'ralph keep going',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ralph');
-            assert.equal(result.transition_error, undefined);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'ralph-state.json'), 'utf-8'));
-            assert.equal(modeState.current_phase, 'verifying');
-            assert.equal(modeState.iteration, 3);
-            assert.equal(modeState.max_iterations, 10);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('keeps Korean ulw typo first in mixed explicit workflow persistence', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ulw-ko-mixed-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(stateDir, { recursive: true });
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ㅕㅣㅈ $autopilot 병렬 작업으로 처리해줘',
-                sessionId: 'sess-ulw-ko-mixed',
-                nowIso: '2026-04-21T00:20:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ultrawork');
-            assert.equal(result.keyword, '$ulw');
-            assert.deepEqual(result.requested_skills, ['ultrawork', 'autopilot']);
-            assert.deepEqual(result.active_skills?.map((entry) => entry.skill), ['ultrawork', 'autopilot']);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-ulw-ko-mixed', 'ultrawork-state.json')), true);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-ulw-ko-mixed', 'autopilot-state.json')), true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('lets an explicit Korean ulw typo override an active workflow continuation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-ulw-ko-explicit-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-ulw-ko-explicit'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-ulw-ko-explicit', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: '$autopilot',
-                phase: 'executing',
-                activated_at: '2026-04-21T00:00:00.000Z',
-                updated_at: '2026-04-21T00:05:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-ulw-ko-explicit',
-                active_skills: [
-                    {
-                        skill: 'autopilot',
-                        phase: 'executing',
-                        active: true,
-                        activated_at: '2026-04-21T00:00:00.000Z',
-                        updated_at: '2026-04-21T00:05:00.000Z',
-                        session_id: 'sess-ulw-ko-explicit',
-                    },
-                ],
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$ㅕㅣㅈ continue',
-                sessionId: 'sess-ulw-ko-explicit',
-                nowIso: '2026-04-21T00:10:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ultrawork');
-            assert.equal(result.keyword, '$ulw');
-            assert.deepEqual(result.active_skills?.map((entry) => entry.skill), ['autopilot', 'ultrawork']);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-ulw-ko-explicit', 'ultrawork-state.json')), true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('routes bare keep-going continuation to the active autopilot skill instead of generic ralph continuation', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-autopilot-bare-continuation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-autopilot-bare'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-autopilot-bare', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: '$autopilot',
-                phase: 'ralplan',
-                activated_at: '2026-04-19T00:00:00.000Z',
-                updated_at: '2026-04-19T00:10:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-autopilot-bare',
-                active_skills: [
-                    {
-                        skill: 'autopilot',
-                        phase: 'ralplan',
-                        active: true,
-                        activated_at: '2026-04-19T00:00:00.000Z',
-                        updated_at: '2026-04-19T00:10:00.000Z',
-                        session_id: 'sess-autopilot-bare',
-                    },
-                ],
-            }, null, 2));
-            await writeFile(join(stateDir, 'sessions', 'sess-autopilot-bare', 'autopilot-state.json'), JSON.stringify({
-                active: true,
-                mode: 'autopilot',
-                current_phase: 'code-review',
-                started_at: '2026-04-19T00:00:00.000Z',
-                updated_at: '2026-04-19T00:10:00.000Z',
-                session_id: 'sess-autopilot-bare',
-                state: { context_snapshot_path: '.rcs/context/autopilot.md' },
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '\\ keep going now',
-                sessionId: 'sess-autopilot-bare',
-                nowIso: '2026-04-19T00:15:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.equal(result.keyword, '$autopilot');
-            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, '.rcs/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('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(), 'rcs-keyword-state-ralph-bare-continuation-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-ralph-bare'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-ralph-bare', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'ralph',
-                keyword: '$ralph',
-                phase: 'executing',
-                activated_at: '2026-04-19T00:00:00.000Z',
-                updated_at: '2026-04-19T00:10:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-ralph-bare',
-                active_skills: [
-                    {
-                        skill: 'ralph',
-                        phase: 'executing',
-                        active: true,
-                        activated_at: '2026-04-19T00:00:00.000Z',
-                        updated_at: '2026-04-19T00:10:00.000Z',
-                        session_id: 'sess-ralph-bare',
-                    },
-                ],
-            }, null, 2));
-            await writeFile(join(stateDir, 'sessions', 'sess-ralph-bare', 'ralph-state.json'), JSON.stringify({
-                active: true,
-                mode: 'ralph',
-                current_phase: 'verifying',
-                started_at: '2026-04-19T00:00:00.000Z',
-                updated_at: '2026-04-19T00:10:00.000Z',
-                iteration: 7,
-                max_iterations: 50,
-                session_id: 'sess-ralph-bare',
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'keep going now',
-                sessionId: 'sess-ralph-bare',
-                nowIso: '2026-04-19T00:15:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'ralph');
-            assert.equal(result.keyword, '$ralph');
-            assert.equal(result.transition_error, undefined);
-            const modeState = JSON.parse(await readFile(join(stateDir, 'sessions', 'sess-ralph-bare', 'ralph-state.json'), 'utf-8'));
-            assert.equal(modeState.current_phase, 'verifying');
-            assert.equal(modeState.iteration, 7);
-            assert.equal(modeState.max_iterations, 50);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not reuse active workflow continuation when prompt contains an unknown plugin-prefixed explicit token', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-unknown-prefixed-explicit-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        try {
-            await mkdir(join(stateDir, 'sessions', 'sess-unknown-prefixed'), { recursive: true });
-            await writeFile(join(stateDir, 'sessions', 'sess-unknown-prefixed', SKILL_ACTIVE_STATE_FILE), JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'ralph',
-                keyword: '$ralph',
-                phase: 'executing',
-                activated_at: '2026-04-19T00:00:00.000Z',
-                updated_at: '2026-04-19T00:10:00.000Z',
-                source: 'keyword-detector',
-                session_id: 'sess-unknown-prefixed',
-                active_skills: [
-                    {
-                        skill: 'ralph',
-                        phase: 'executing',
-                        active: true,
-                        activated_at: '2026-04-19T00:00:00.000Z',
-                        updated_at: '2026-04-19T00:10:00.000Z',
-                        session_id: 'sess-unknown-prefixed',
-                    },
-                ],
-            }, null, 2));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: '$roblox-ai-os-creator-skills:unknown continue',
-                sessionId: 'sess-unknown-prefixed',
-                nowIso: '2026-04-19T00:15:00.000Z',
-            });
-            assert.equal(result, null);
-            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-unknown-prefixed', 'ralph-state.json')), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('denies switching away from a standalone workflow without explicit clear', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-skill-switch-deny-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const statePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(statePath, JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: 'autopilot',
-                phase: 'ralplan',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                source: 'keyword-detector',
-            }));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'please run $ralph now',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.match(String(result.transition_error), /Unsupported workflow overlap: autopilot \+ ralph\./);
-            assert.equal(result.activated_at, '2026-02-25T00:00:00.000Z');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('resets activated_at when keyword changes within the same skill', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-state-keyword-switch-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const statePath = join(stateDir, SKILL_ACTIVE_STATE_FILE);
-        try {
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(statePath, JSON.stringify({
-                version: 1,
-                active: true,
-                skill: 'autopilot',
-                keyword: 'autopilot',
-                phase: 'ralplan',
-                activated_at: '2026-02-25T00:00:00.000Z',
-                updated_at: '2026-02-25T00:10:00.000Z',
-                source: 'keyword-detector',
-            }));
-            const result = await recordSkillActivation({
-                stateDir,
-                text: 'I want a starter API',
-                nowIso: '2026-02-26T00:00:00.000Z',
-            });
-            assert.ok(result);
-            assert.equal(result.skill, 'autopilot');
-            assert.notEqual(result.keyword.toLowerCase(), 'autopilot');
-            assert.equal(result.activated_at, '2026-02-26T00:00:00.000Z');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-});
-describe('isUnderspecifiedForExecution', () => {
-    it('flags vague prompt with no files or functions', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph fix this'), true);
-    });
-    it('flags short vague prompt', () => {
-        assert.equal(isUnderspecifiedForExecution('autopilot build the app'), true);
-    });
-    it('flags prompt with only keyword and generic words', () => {
-        assert.equal(isUnderspecifiedForExecution('team improve performance'), true);
-    });
-    it('passes prompt with a file path reference', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph fix src/hooks/bridge.ts'), false);
-    });
-    it('passes prompt with a file extension reference', () => {
-        assert.equal(isUnderspecifiedForExecution('fix the bug in auth.ts'), false);
-    });
-    it('passes prompt with a directory/file path', () => {
-        assert.equal(isUnderspecifiedForExecution('update src/hooks/emulator.ts'), false);
-    });
-    it('passes prompt with a camelCase symbol', () => {
-        assert.equal(isUnderspecifiedForExecution('team fix processKeywordDetector'), false);
-    });
-    it('passes prompt with a PascalCase symbol', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph update UserModel'), false);
-    });
-    it('passes prompt with snake_case symbol', () => {
-        assert.equal(isUnderspecifiedForExecution('fix user_model validation'), false);
-    });
-    it('passes prompt with an issue number', () => {
-        assert.equal(isUnderspecifiedForExecution('autopilot implement #42'), false);
-    });
-    it('passes prompt with numbered steps', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph do:\n1. Add input validation\n2. Write tests\n3. Update README'), false);
-    });
-    it('passes prompt with acceptance criteria keyword', () => {
-        assert.equal(isUnderspecifiedForExecution('add login - acceptance criteria: user sees error on bad password'), false);
-    });
-    it('passes prompt with a specific error reference', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph fix TypeError in auth handler'), false);
-    });
-    it('passes with force: escape hatch prefix', () => {
-        assert.equal(isUnderspecifiedForExecution('force: ralph refactor the auth module'), false);
-    });
-    it('passes with ! escape hatch prefix', () => {
-        assert.equal(isUnderspecifiedForExecution('! autopilot optimize everything'), false);
-    });
-    it('returns true for empty string', () => {
-        assert.equal(isUnderspecifiedForExecution(''), true);
-    });
-    it('returns true for whitespace only', () => {
-        assert.equal(isUnderspecifiedForExecution('   '), true);
-    });
-    it('passes prompt with test runner command', () => {
-        assert.equal(isUnderspecifiedForExecution('ralph npm test && fix failures'), false);
-    });
-    it('passes longer prompt that exceeds word threshold', () => {
-        // 16+ effective words without specific signals → passes (not underspecified by word count)
-        const longVague = 'please help me improve the overall quality and performance and reliability of this system going forward';
-        assert.equal(isUnderspecifiedForExecution(longVague), false);
-    });
-    it('false positive prevention: camelCase identifiers pass', () => {
-        assert.equal(isUnderspecifiedForExecution('fix getUserById to handle null'), false);
-    });
-});
-describe('applyRalplanGate', () => {
-    it('does not re-enter ralplan for a short approved team follow-up', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-gate-followup-'));
-        try {
-            const plansDir = join(cwd, '.rcs', 'plans');
-            await mkdir(plansDir, { recursive: true });
-            await writeFile(join(plansDir, 'prd-issue-831.md'), '# Approved plan\n\nLaunch hint: rcs team 3:executor "Execute approved issue 831 plan"\n');
-            await writeFile(join(plansDir, 'test-spec-issue-831.md'), '# Test spec\n');
-            const result = applyRalplanGate(['team'], 'team', { cwd });
-            assert.equal(result.gateApplied, false);
-            assert.deepEqual(result.keywords, ['team']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not re-enter ralplan for a short approved Korean team follow-up', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-gate-followup-ko-'));
-        try {
-            const plansDir = join(cwd, '.rcs', 'plans');
-            await mkdir(plansDir, { recursive: true });
-            await writeFile(join(plansDir, 'prd-issue-831.md'), '# Approved plan\n\nLaunch hint: rcs team 3:executor "Execute approved issue 831 plan"\n');
-            await writeFile(join(plansDir, 'test-spec-issue-831.md'), '# Test spec\n');
-            const result = applyRalplanGate(['team'], 'team으로 해줘', { cwd });
-            assert.equal(result.gateApplied, false);
-            assert.deepEqual(result.keywords, ['team']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not re-enter ralplan for a short approved ralph follow-up', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-keyword-gate-followup-ralph-'));
-        try {
-            const plansDir = join(cwd, '.rcs', 'plans');
-            await mkdir(plansDir, { recursive: true });
-            await writeFile(join(plansDir, 'prd-issue-832.md'), '# Approved plan\n\nLaunch hint: rcs ralph "Execute approved issue 832 plan"\n');
-            await writeFile(join(plansDir, 'test-spec-issue-832.md'), '# Test spec\n');
-            const result = applyRalplanGate(['ralph'], 'ralph please', { cwd, priorSkill: 'ralplan' });
-            assert.equal(result.gateApplied, false);
-            assert.deepEqual(result.keywords, ['ralph']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('redirects underspecified execution keywords to ralplan', () => {
-        const result = applyRalplanGate(['ralph'], 'ralph fix this');
-        assert.equal(result.gateApplied, true);
-        assert.ok(result.keywords.includes('ralplan'));
-        assert.ok(!result.keywords.includes('ralph'));
-    });
-    it('redirects autopilot to ralplan when underspecified', () => {
-        const result = applyRalplanGate(['autopilot'], 'autopilot build the app');
-        assert.equal(result.gateApplied, true);
-        assert.ok(result.keywords.includes('ralplan'));
-    });
-    it('does not gate well-specified prompts', () => {
-        const result = applyRalplanGate(['ralph'], 'ralph fix src/hooks/bridge.ts null check');
-        assert.equal(result.gateApplied, false);
-        assert.ok(result.keywords.includes('ralph'));
-    });
-    it('does not gate when cancel is present', () => {
-        const result = applyRalplanGate(['cancel', 'ralph'], 'cancel ralph');
-        assert.equal(result.gateApplied, false);
-    });
-    it('does not gate when ralplan is already present', () => {
-        const result = applyRalplanGate(['ralplan'], 'ralplan add auth');
-        assert.equal(result.gateApplied, false);
-        assert.ok(result.keywords.includes('ralplan'));
-    });
-    it('does not gate non-execution keywords', () => {
-        const result = applyRalplanGate(['analyze'], 'analyze this');
-        assert.equal(result.gateApplied, false);
-    });
-    it('preserves non-execution keywords when gating', () => {
-        const result = applyRalplanGate(['ralph', 'tdd'], 'ralph tdd fix this');
-        assert.equal(result.gateApplied, true);
-        assert.ok(result.keywords.includes('tdd'));
-        assert.ok(result.keywords.includes('ralplan'));
-        assert.ok(!result.keywords.includes('ralph'));
-    });
-    it('handles force: escape hatch — does not gate', () => {
-        const result = applyRalplanGate(['ralph'], 'force: ralph refactor the auth module');
-        assert.equal(result.gateApplied, false);
-    });
-    it('gates multiple execution keywords at once', () => {
-        const result = applyRalplanGate(['ralph', 'team'], 'ralph team fix this');
-        assert.equal(result.gateApplied, true);
-        assert.ok(result.keywords.includes('ralplan'));
-        assert.ok(!result.keywords.includes('ralph'));
-        assert.ok(!result.keywords.includes('team'));
-        assert.ok(result.gatedKeywords.includes('ralph'));
-        assert.ok(result.gatedKeywords.includes('team'));
-    });
-    it('returns empty keywords unchanged when no keywords', () => {
-        const result = applyRalplanGate([], 'fix this');
-        assert.equal(result.gateApplied, false);
-        assert.deepEqual(result.keywords, []);
-    });
-    it('does not duplicate ralplan if already in filtered list', () => {
-        // ultrawork is an execution keyword; after filtering, ralplan added once
-        const result = applyRalplanGate(['ultrawork'], 'ultrawork do stuff');
-        assert.equal(result.keywords.filter(k => k === 'ralplan').length, 1);
-    });
-    it('reports gatedKeywords correctly', () => {
-        const result = applyRalplanGate(['ralph', 'ultrawork'], 'ralph ultrawork build');
-        assert.ok(result.gatedKeywords.includes('ralph'));
-        assert.ok(result.gatedKeywords.includes('ultrawork'));
-    });
-});
-//# sourceMappingURL=keyword-detector.test.js.map