claudecode-omc 4.9.4 → 5.0.0

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

@@ -1,1509 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { removeCodeBlocks, sanitizeForKeywordDetection, extractPromptText, detectKeywordsWithType, hasKeyword, getPrimaryKeyword, getAllKeywords, getAllKeywordsWithSizeCheck, isUnderspecifiedForExecution, applyRalplanGate, NON_LATIN_SCRIPT_PATTERN, } from '../index.js';
-// Mock isTeamEnabled
-vi.mock('../../../features/auto-update.js', () => ({
-    isTeamEnabled: vi.fn(() => true),
-}));
-import { isTeamEnabled } from '../../../features/auto-update.js';
-const mockedIsTeamEnabled = vi.mocked(isTeamEnabled);
-describe('keyword-detector', () => {
-    describe('removeCodeBlocks', () => {
-        it('should remove fenced code blocks with triple backticks', () => {
-            const text = 'Before ```code here``` after';
-            expect(removeCodeBlocks(text)).toBe('Before  after');
-        });
-        it('should remove fenced code blocks with tildes', () => {
-            const text = 'Before ~~~code here~~~ after';
-            expect(removeCodeBlocks(text)).toBe('Before  after');
-        });
-        it('should remove multiline fenced code blocks', () => {
-            const text = `Hello
-\`\`\`javascript
-const x = 1;
-const y = 2;
-\`\`\`
-World`;
-            expect(removeCodeBlocks(text)).toBe(`Hello
-
-World`);
-        });
-        it('should remove inline code with single backticks', () => {
-            const text = 'Use `autopilot` command here';
-            expect(removeCodeBlocks(text)).toBe('Use  command here');
-        });
-        it('should handle nested backticks in fenced blocks', () => {
-            // The regex matches ```...``` greedily, so ```const x = `test````
-            // matches from first ``` to the triple backtick at the end
-            const text = 'Before ```const x = `test` ``` after';
-            expect(removeCodeBlocks(text)).toBe('Before  after');
-        });
-        it('should handle multiple code blocks', () => {
-            const text = '`a` middle `b` end';
-            expect(removeCodeBlocks(text)).toBe(' middle  end');
-        });
-        it('should handle empty input', () => {
-            expect(removeCodeBlocks('')).toBe('');
-        });
-        it('should return text unchanged when no code blocks', () => {
-            const text = 'Regular text without code';
-            expect(removeCodeBlocks(text)).toBe('Regular text without code');
-        });
-        it('should handle code blocks with language specifier', () => {
-            const text = '```typescript\nconst x = 1;\n``` done';
-            expect(removeCodeBlocks(text)).toBe(' done');
-        });
-    });
-    describe('sanitizeForKeywordDetection', () => {
-        it('should strip XML tag blocks', () => {
-            const result = sanitizeForKeywordDetection('<system-reminder>ralph</system-reminder>');
-            expect(result).not.toContain('ralph');
-        });
-        it('should strip self-closing XML tags', () => {
-            const result = sanitizeForKeywordDetection('text <br /> more');
-            expect(result).not.toContain('<br');
-        });
-        it('should strip URLs', () => {
-            const result = sanitizeForKeywordDetection('see https://example.com/codex/path');
-            expect(result).not.toContain('codex');
-        });
-        it('should strip file paths', () => {
-            const result = sanitizeForKeywordDetection('open src/mcp/codex-core.ts');
-            expect(result).not.toContain('codex');
-        });
-        it('should strip markdown code blocks', () => {
-            const result = sanitizeForKeywordDetection('```\nask codex\n```');
-            expect(result).not.toContain('codex');
-        });
-        it('should strip inline code', () => {
-            const result = sanitizeForKeywordDetection('use `ask codex` command');
-            expect(result).not.toContain('codex');
-        });
-        it('should preserve normal text', () => {
-            const result = sanitizeForKeywordDetection('ask codex to review');
-            expect(result).toContain('ask codex');
-        });
-        it('should not over-strip when XML tag names differ', () => {
-            // Mismatched tags should not strip content between them
-            const result = sanitizeForKeywordDetection('<open>ralph</close> hello');
-            expect(result).toContain('ralph');
-        });
-        it('should strip matching XML tags correctly', () => {
-            const result = sanitizeForKeywordDetection('<div>ralph</div> hello');
-            expect(result).not.toContain('ralph');
-            expect(result).toContain('hello');
-        });
-        it('should strip nested matching XML tags', () => {
-            const result = sanitizeForKeywordDetection('<outer>some <inner>text</inner> ralph</outer> visible');
-            expect(result).not.toContain('ralph');
-            expect(result).toContain('visible');
-        });
-        it('should strip absolute file paths starting with /', () => {
-            const result = sanitizeForKeywordDetection('open /usr/local/bin/codex');
-            expect(result).not.toContain('codex');
-        });
-        it('should strip relative file paths starting with ./', () => {
-            const result = sanitizeForKeywordDetection('edit ./src/codex.ts');
-            expect(result).not.toContain('codex');
-        });
-        it('should strip multi-segment file paths', () => {
-            const result = sanitizeForKeywordDetection('open src/mcp/codex-core.ts');
-            expect(result).not.toContain('codex');
-        });
-        it('should NOT strip standalone words that look like single segments', () => {
-            // "ask codex" should not be stripped since "codex" is not a path
-            const result = sanitizeForKeywordDetection('ask codex to review');
-            expect(result).toContain('ask codex');
-        });
-        it('should NOT strip slash-less words with dots', () => {
-            // "file.txt" alone (no path separator) should be kept
-            const result = sanitizeForKeywordDetection('rename codex.config');
-            expect(result).toContain('codex');
-        });
-    });
-    describe('extractPromptText', () => {
-        it('should extract text from text parts', () => {
-            const parts = [
-                { type: 'text', text: 'Hello' },
-                { type: 'text', text: 'World' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello World');
-        });
-        it('should ignore non-text parts', () => {
-            const parts = [
-                { type: 'text', text: 'Hello' },
-                { type: 'image', url: 'http://example.com' },
-                { type: 'text', text: 'World' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello World');
-        });
-        it('should handle empty parts array', () => {
-            expect(extractPromptText([])).toBe('');
-        });
-        it('should handle parts with no text', () => {
-            const parts = [
-                { type: 'text' },
-                { type: 'text', text: 'Valid' },
-            ];
-            expect(extractPromptText(parts)).toBe('Valid');
-        });
-        it('should handle undefined text gracefully', () => {
-            const parts = [
-                { type: 'text', text: undefined },
-                { type: 'text', text: 'Hello' },
-            ];
-            expect(extractPromptText(parts)).toBe('Hello');
-        });
-        it('should handle all non-text parts', () => {
-            const parts = [
-                { type: 'image' },
-                { type: 'tool_use' },
-            ];
-            expect(extractPromptText(parts)).toBe('');
-        });
-    });
-    describe('detectKeywordsWithType', () => {
-        describe('ralph keyword', () => {
-            it('should detect ralph keyword', () => {
-                const result = detectKeywordsWithType('Please ralph this task');
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeDefined();
-                expect(ralphMatch?.keyword).toBe('ralph');
-            });
-            it('should NOT detect informational Korean questions about ralph and ralplan', () => {
-                const result = detectKeywordsWithType('ralph 와 ralplan 은 뭐야?');
-                expect(result).toEqual([]);
-            });
-            it('should NOT detect informational English questions about ralph', () => {
-                const result = detectKeywordsWithType('What is ralph and how do I use it?');
-                expect(result).toEqual([]);
-            });
-            it('should NOT detect informational Japanese questions about ralplan', () => {
-                const result = detectKeywordsWithType('ralplan とは？ 使い方を教えて');
-                expect(result).toEqual([]);
-            });
-            it('should NOT detect informational Chinese questions about ralph', () => {
-                const result = detectKeywordsWithType('ralph 是什么？怎么用？');
-                expect(result).toEqual([]);
-            });
-            it('Korean informational prompt does not trigger keyword', () => {
-                // "알려줘" (tell me about) is informational
-                expect(detectKeywordsWithType('오토파일럿 기능 알려줘')).toHaveLength(0);
-                expect(detectKeywordsWithType('랄프 뭐야')).toHaveLength(0);
-                expect(detectKeywordsWithType('울트라워크 사용법 설명해줘')).toHaveLength(0);
-                expect(detectKeywordsWithType('딥인터뷰 방법 소개해줘')).toHaveLength(0);
-            });
-            it('Korean expanded informational phrases do not trigger keyword', () => {
-                // "뭔데" (what is it), "어떤 기능이야", "소개 부탁", "알려줄래", "뭐가 달라" are informational
-                expect(detectKeywordsWithType('오토파일럿이 뭔데')).toHaveLength(0);
-                expect(detectKeywordsWithType('안티슬롭이 뭐야')).toHaveLength(0);
-                expect(detectKeywordsWithType('오토파일럿 어떤 기능이야')).toHaveLength(0);
-                expect(detectKeywordsWithType('랄프 소개 부탁해')).toHaveLength(0);
-                expect(detectKeywordsWithType('울트라워크 알려줄래')).toHaveLength(0);
-                expect(detectKeywordsWithType('오토파일럿이 랄프랑 뭐가 달라')).toHaveLength(0);
-            });
-            it('Korean imperative command with 기능/방법 SHOULD trigger keyword (not filtered)', () => {
-                // "기능 켜줘" / "기능으로 진행해줘" — 기능 alone without a question verb is NOT informational
-                const autopilotResult = detectKeywordsWithType('오토파일럿 기능 켜고 버그 고쳐줘');
-                expect(autopilotResult.find((r) => r.type === 'autopilot')).toBeDefined();
-                const ralphResult = detectKeywordsWithType('랄프 기능으로 끝까지 진행해줘');
-                expect(ralphResult.find((r) => r.type === 'ralph')).toBeDefined();
-            });
-            it('should NOT detect "don\'t stop" phrase', () => {
-                const result = detectKeywordsWithType("Don't stop until done");
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeUndefined();
-            });
-            it('should NOT detect "must complete" phrase', () => {
-                const result = detectKeywordsWithType('You must complete this task');
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeUndefined();
-            });
-            it('should NOT detect "until done" phrase', () => {
-                const result = detectKeywordsWithType('Keep going until done');
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeUndefined();
-            });
-        });
-        describe('autopilot keyword', () => {
-            it('should detect autopilot keyword', () => {
-                const result = detectKeywordsWithType('Run in autopilot mode');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should detect "auto pilot" with space', () => {
-                const result = detectKeywordsWithType('Enable auto pilot');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should detect "auto-pilot" with hyphen', () => {
-                const result = detectKeywordsWithType('Enable auto-pilot mode');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should detect "full auto" keyword', () => {
-                const result = detectKeywordsWithType('Go full auto on this');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should detect "fullsend" keyword', () => {
-                const result = detectKeywordsWithType('fullsend this implementation');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should NOT detect "build me" phrase', () => {
-                const result = detectKeywordsWithType('build me a web app');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeUndefined();
-            });
-            it('should NOT detect "autonomous" keyword', () => {
-                const result = detectKeywordsWithType('Run in autonomous mode');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeUndefined();
-            });
-        });
-        describe('ultrawork keyword', () => {
-            it('should detect ultrawork keyword', () => {
-                const result = detectKeywordsWithType('Do ultrawork on this');
-                const ultraworkMatch = result.find((r) => r.type === 'ultrawork');
-                expect(ultraworkMatch).toBeDefined();
-            });
-            it('should detect ulw abbreviation', () => {
-                const result = detectKeywordsWithType('ulw this code');
-                const ultraworkMatch = result.find((r) => r.type === 'ultrawork');
-                expect(ultraworkMatch).toBeDefined();
-            });
-            it('should NOT detect uw abbreviation', () => {
-                const result = detectKeywordsWithType('uw this code');
-                const ultraworkMatch = result.find((r) => r.type === 'ultrawork');
-                expect(ultraworkMatch).toBeUndefined();
-            });
-            it('should NOT detect deprecated pipeline phrases', () => {
-                const keywordResult = detectKeywordsWithType('agent pipeline the task and chain agents');
-                const pipelineLikeMatches = keywordResult.filter((r) => r.type === 'pipeline');
-                expect(pipelineLikeMatches).toHaveLength(0);
-            });
-        });
-        describe('tdd keyword', () => {
-            it('should detect tdd keyword', () => {
-                const result = detectKeywordsWithType('tdd this feature');
-                const tddMatch = result.find((r) => r.type === 'tdd');
-                expect(tddMatch).toBeDefined();
-            });
-            it('should detect test first phrase', () => {
-                const result = detectKeywordsWithType('test first approach');
-                const tddMatch = result.find((r) => r.type === 'tdd');
-                expect(tddMatch).toBeDefined();
-            });
-            it('should NOT detect red green phrase', () => {
-                const result = detectKeywordsWithType('red green refactor cycle');
-                const tddMatch = result.find((r) => r.type === 'tdd');
-                expect(tddMatch).toBeUndefined();
-            });
-        });
-        describe('code-review keyword', () => {
-            it('should detect code review phrase', () => {
-                const result = detectKeywordsWithType('please do a code review');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect review code phrase', () => {
-                const result = detectKeywordsWithType('review code for this change');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeDefined();
-            });
-        });
-        describe('security-review keyword', () => {
-            it('should detect security review phrase', () => {
-                const result = detectKeywordsWithType('run a security review');
-                const match = result.find((r) => r.type === 'security-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect review security phrase', () => {
-                const result = detectKeywordsWithType('review security for this change');
-                const match = result.find((r) => r.type === 'security-review');
-                expect(match).toBeDefined();
-            });
-        });
-        describe('ultrathink keyword', () => {
-            it('should detect ultrathink keyword', () => {
-                const result = detectKeywordsWithType('ultrathink about this problem');
-                const ultrathinkMatch = result.find((r) => r.type === 'ultrathink');
-                expect(ultrathinkMatch).toBeDefined();
-            });
-            it('should NOT detect "think hard" phrase', () => {
-                const result = detectKeywordsWithType('think hard about this problem');
-                const ultrathinkMatch = result.find((r) => r.type === 'ultrathink');
-                expect(ultrathinkMatch).toBeUndefined();
-            });
-            it('should NOT detect "think deeply" phrase', () => {
-                const result = detectKeywordsWithType('think deeply about this problem');
-                const ultrathinkMatch = result.find((r) => r.type === 'ultrathink');
-                expect(ultrathinkMatch).toBeUndefined();
-            });
-        });
-        describe('deepsearch keyword', () => {
-            it('should detect deepsearch keyword', () => {
-                const result = detectKeywordsWithType('deepsearch for files');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeDefined();
-            });
-            it('should detect search the codebase', () => {
-                const result = detectKeywordsWithType('search the codebase');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeDefined();
-            });
-            it('should detect find in codebase', () => {
-                const result = detectKeywordsWithType('find in codebase');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeDefined();
-            });
-            it('should detect find in the codebase', () => {
-                const result = detectKeywordsWithType('find in the codebase');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeDefined();
-            });
-            it('should NOT detect generic find', () => {
-                const result = detectKeywordsWithType('find the bug');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeUndefined();
-            });
-            it('should NOT detect search code pattern', () => {
-                const result = detectKeywordsWithType('search code for errors');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeUndefined();
-            });
-            it('should NOT detect find in all files', () => {
-                const result = detectKeywordsWithType('find in all files');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeUndefined();
-            });
-            it('should NOT detect search project', () => {
-                const result = detectKeywordsWithType('search the project');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeUndefined();
-            });
-            it('should NOT detect search files', () => {
-                const result = detectKeywordsWithType('search files for errors');
-                const searchMatch = result.find((r) => r.type === 'deepsearch');
-                expect(searchMatch).toBeUndefined();
-            });
-        });
-        describe('analyze keyword', () => {
-            it('should detect deep analyze keyword', () => {
-                const result = detectKeywordsWithType('deep analyze this code');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeDefined();
-            });
-            it('should detect deep-analyze with hyphen', () => {
-                const result = detectKeywordsWithType('deep-analyze this code');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeDefined();
-            });
-            it('should detect deepanalyze without space', () => {
-                const result = detectKeywordsWithType('deepanalyze this code');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeDefined();
-            });
-            it('should NOT detect investigate with context', () => {
-                const result = detectKeywordsWithType('investigate the issue');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect investigate this', () => {
-                const result = detectKeywordsWithType('investigate this bug');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect investigate why', () => {
-                const result = detectKeywordsWithType('investigate why this fails');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect debug the', () => {
-                const result = detectKeywordsWithType('debug the function');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect debug this', () => {
-                const result = detectKeywordsWithType('debug this issue');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect debug why', () => {
-                const result = detectKeywordsWithType('debug why this breaks');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-            it('should NOT detect generic analyze', () => {
-                const result = detectKeywordsWithType('analyze without context');
-                const analyzeMatch = result.find((r) => r.type === 'analyze');
-                expect(analyzeMatch).toBeUndefined();
-            });
-        });
-        describe('case insensitivity', () => {
-            it('should detect RALPH in uppercase', () => {
-                const result = detectKeywordsWithType('RALPH this task');
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeDefined();
-            });
-            it('should detect AUTOPILOT in uppercase', () => {
-                const result = detectKeywordsWithType('AUTOPILOT mode');
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch).toBeDefined();
-            });
-            it('should detect mixed case keywords', () => {
-                const result = detectKeywordsWithType('UltraThink about this');
-                const ultrathinkMatch = result.find((r) => r.type === 'ultrathink');
-                expect(ultrathinkMatch).toBeDefined();
-            });
-        });
-        describe('code block exclusion', () => {
-            it('should not detect keyword inside fenced code block', () => {
-                const text = '```\nautopilot\n```';
-                const result = detectKeywordsWithType(text);
-                expect(result.length).toBe(0);
-            });
-            it('should not detect keyword inside inline code', () => {
-                const text = 'Use `autopilot` command';
-                const result = detectKeywordsWithType(text);
-                expect(result.length).toBe(0);
-            });
-            it('should detect keyword outside code block but not inside', () => {
-                const text = 'autopilot ```autopilot``` end';
-                const result = detectKeywordsWithType(text);
-                const autopilotMatches = result.filter((r) => r.type === 'autopilot');
-                expect(autopilotMatches.length).toBeGreaterThan(0);
-            });
-            it('should not detect keyword inside XML tags', () => {
-                const text = '<system-reminder>ralph</system-reminder> hello';
-                const result = detectKeywordsWithType(text);
-                const ralphMatch = result.find((r) => r.type === 'ralph');
-                expect(ralphMatch).toBeUndefined();
-            });
-        });
-        describe('codex keyword', () => {
-            it('should detect "ask codex"', () => {
-                const result = detectKeywordsWithType('ask codex to review');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeDefined();
-            });
-            it('should detect "use gpt"', () => {
-                const result = detectKeywordsWithType('use gpt for review');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeDefined();
-            });
-            it('should detect "delegate to codex"', () => {
-                const result = detectKeywordsWithType('delegate to codex');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeDefined();
-            });
-            it('should detect "delegate to gpt"', () => {
-                const result = detectKeywordsWithType('delegate to gpt');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeDefined();
-            });
-            it('should NOT detect bare codex keyword', () => {
-                const result = detectKeywordsWithType('codex review this');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-            it('should NOT detect bare gpt keyword', () => {
-                const result = detectKeywordsWithType('gpt is great');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-            it('should NOT detect gpt model names', () => {
-                const result = detectKeywordsWithType('gpt-5.3 model');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-            it('should NOT detect chatgpt', () => {
-                const result = detectKeywordsWithType('chatgpt helped');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-        });
-        describe('ccg keyword', () => {
-            it('should detect "ccg" keyword', () => {
-                const result = detectKeywordsWithType('ccg this feature');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeDefined();
-                expect(ccgMatch?.keyword).toMatch(/ccg/i);
-            });
-            it('should detect "claude-codex-gemini" keyword', () => {
-                const result = detectKeywordsWithType('use claude-codex-gemini to build this');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeDefined();
-            });
-            it('should detect CCG in uppercase', () => {
-                const result = detectKeywordsWithType('CCG add user profile page');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeDefined();
-            });
-            it('should NOT detect ccg inside code block', () => {
-                const result = detectKeywordsWithType('```\nccg mode\n```');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeUndefined();
-            });
-            it('should NOT detect ccg inside inline code', () => {
-                const result = detectKeywordsWithType('use `ccg` command');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeUndefined();
-            });
-            it('should detect ccg with other text around it', () => {
-                const result = detectKeywordsWithType('please ccg this full-stack feature');
-                const ccgMatch = result.find((r) => r.type === 'ccg');
-                expect(ccgMatch).toBeDefined();
-            });
-        });
-        describe('gemini keyword', () => {
-            it('should detect "ask gemini"', () => {
-                const result = detectKeywordsWithType('ask gemini to design');
-                const geminiMatch = result.find((r) => r.type === 'gemini');
-                expect(geminiMatch).toBeDefined();
-            });
-            it('should detect "use gemini"', () => {
-                const result = detectKeywordsWithType('use gemini for UI');
-                const geminiMatch = result.find((r) => r.type === 'gemini');
-                expect(geminiMatch).toBeDefined();
-            });
-            it('should detect "delegate to gemini"', () => {
-                const result = detectKeywordsWithType('delegate to gemini');
-                const geminiMatch = result.find((r) => r.type === 'gemini');
-                expect(geminiMatch).toBeDefined();
-            });
-            it('should NOT detect bare gemini keyword', () => {
-                const result = detectKeywordsWithType('gemini constellation');
-                const geminiMatch = result.find((r) => r.type === 'gemini');
-                expect(geminiMatch).toBeUndefined();
-            });
-            it('should NOT detect gemini in non-intent context', () => {
-                const result = detectKeywordsWithType('the Gemini project');
-                const geminiMatch = result.find((r) => r.type === 'gemini');
-                expect(geminiMatch).toBeUndefined();
-            });
-        });
-        describe('sanitization false-positive prevention', () => {
-            it('should NOT detect codex in URL', () => {
-                const result = detectKeywordsWithType('see https://example.com/gpt');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-            it('should NOT detect codex in file path', () => {
-                const result = detectKeywordsWithType('open docs/gpt/README.md');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-            it('should NOT detect codex in inline code', () => {
-                const result = detectKeywordsWithType('`ask codex`');
-                const codexMatch = result.find((r) => r.type === 'codex');
-                expect(codexMatch).toBeUndefined();
-            });
-        });
-        describe('edge cases', () => {
-            it('should handle empty input', () => {
-                const result = detectKeywordsWithType('');
-                expect(result.length).toBe(0);
-            });
-            it('should handle whitespace only input', () => {
-                const result = detectKeywordsWithType('   \n\t   ');
-                expect(result.length).toBe(0);
-            });
-            it('should handle special characters', () => {
-                const result = detectKeywordsWithType('!@#$%^&*()');
-                expect(result.length).toBe(0);
-            });
-            it('should return position of detected keywords', () => {
-                const text = 'Please autopilot this';
-                const result = detectKeywordsWithType(text);
-                const autopilotMatch = result.find((r) => r.type === 'autopilot');
-                expect(autopilotMatch?.position).toBeGreaterThanOrEqual(0);
-            });
-            it('should detect multiple different keyword types', () => {
-                const text = 'autopilot and deep analyze the bug';
-                const result = detectKeywordsWithType(text);
-                const types = result.map((r) => r.type);
-                expect(types).toContain('autopilot');
-                expect(types).toContain('analyze');
-            });
-        });
-    });
-    describe('hasKeyword', () => {
-        it('should return true when keyword exists', () => {
-            expect(hasKeyword('autopilot this')).toBe(true);
-        });
-        it('should return true for ralph keyword', () => {
-            expect(hasKeyword('ralph the task')).toBe(true);
-        });
-        it('should return false when no keyword exists', () => {
-            expect(hasKeyword('regular text here')).toBe(false);
-        });
-        it('should return false for empty input', () => {
-            expect(hasKeyword('')).toBe(false);
-        });
-        it('should return false when keyword is inside code block', () => {
-            expect(hasKeyword('```autopilot```')).toBe(false);
-        });
-        it('should return true when keyword is outside code block', () => {
-            expect(hasKeyword('autopilot ```other code```')).toBe(true);
-        });
-    });
-    describe('getPrimaryKeyword', () => {
-        describe('priority order', () => {
-            it('should return ralph over autopilot', () => {
-                const result = getPrimaryKeyword('ralph and autopilot');
-                expect(result?.type).toBe('ralph');
-            });
-            it('should return autopilot over ultrawork', () => {
-                const result = getPrimaryKeyword('autopilot and ultrawork');
-                expect(result?.type).toBe('autopilot');
-            });
-            it('should return ultrawork over ultrathink', () => {
-                const result = getPrimaryKeyword('ultrawork and ultrathink');
-                expect(result?.type).toBe('ultrawork');
-            });
-            it('should return code-review over ultrathink', () => {
-                const result = getPrimaryKeyword('code review and ultrathink');
-                expect(result?.type).toBe('code-review');
-            });
-            it('should return security-review over ultrathink', () => {
-                const result = getPrimaryKeyword('security review and ultrathink');
-                expect(result?.type).toBe('security-review');
-            });
-            it('should return ultrathink over deepsearch', () => {
-                const result = getPrimaryKeyword('ultrathink and search the codebase');
-                expect(result?.type).toBe('ultrathink');
-            });
-            it('should return deepsearch over analyze', () => {
-                const result = getPrimaryKeyword('find in codebase and debug the issue');
-                expect(result?.type).toBe('deepsearch');
-            });
-            it('should return analyze when it is the only keyword', () => {
-                const result = getPrimaryKeyword('deep analyze the issue');
-                expect(result?.type).toBe('analyze');
-            });
-        });
-        describe('multiple keyword conflict resolution', () => {
-            it('should return cancel over everything', () => {
-                const result = getPrimaryKeyword('cancelomc ralph ultrawork');
-                expect(result?.type).toBe('cancel');
-            });
-            it('should return ralph over ultrawork', () => {
-                const result = getPrimaryKeyword('ralph ulw fix errors');
-                expect(result?.type).toBe('ralph');
-            });
-            it('should detect all keywords even when multiple present', () => {
-                const result = detectKeywordsWithType('ulw ralph fix errors');
-                const types = result.map(r => r.type);
-                expect(types).toContain('ultrawork');
-                expect(types).toContain('ralph');
-            });
-        });
-        it('should return null when no keyword found', () => {
-            const result = getPrimaryKeyword('regular text');
-            expect(result).toBeNull();
-        });
-        it('should return null for empty input', () => {
-            const result = getPrimaryKeyword('');
-            expect(result).toBeNull();
-        });
-        it('should return null when keyword is in code block', () => {
-            const result = getPrimaryKeyword('```autopilot```');
-            expect(result).toBeNull();
-        });
-        it('should return keyword with correct type and position', () => {
-            const result = getPrimaryKeyword('autopilot this task');
-            expect(result).not.toBeNull();
-            expect(result?.type).toBe('autopilot');
-            expect(result?.keyword).toBeDefined();
-            expect(result?.position).toBeGreaterThanOrEqual(0);
-        });
-        it('should handle complex text with multiple keywords', () => {
-            const text = 'Please ralph this and then autopilot the rest, think about it and analyze';
-            const result = getPrimaryKeyword(text);
-            // ralph has highest priority
-            expect(result?.type).toBe('ralph');
-        });
-    });
-    describe('getAllKeywords', () => {
-        it('should return single keyword in array', () => {
-            expect(getAllKeywords('autopilot this')).toEqual(['autopilot']);
-        });
-        it('should return multiple non-conflicting keywords in priority order', () => {
-            expect(getAllKeywords('ulw ralph fix errors')).toEqual(['ralph', 'ultrawork']);
-        });
-        it('should return cancel exclusively when present', () => {
-            expect(getAllKeywords('cancelomc ralph ultrawork')).toEqual(['cancel']);
-        });
-        it('should not detect deprecated ultrapilot keyword (#1131)', () => {
-            const result = getAllKeywords('autopilot ultrapilot build');
-            expect(result).not.toContain('ultrapilot');
-            // ultrapilot is deprecated, only autopilot should be detected
-            expect(result).toContain('autopilot');
-        });
-        it('should not detect deprecated swarm keyword (#1131)', () => {
-            const result = getAllKeywords('swarm 5 agents build this');
-            expect(result).not.toContain('swarm');
-        });
-        it('should return ralph with ultrawork (not mutually exclusive)', () => {
-            const result = getAllKeywords('ralph ultrawork fix');
-            expect(result).toContain('ralph');
-            expect(result).toContain('ultrawork');
-        });
-        it('should return ralph with codex', () => {
-            const result = getAllKeywords('ralph ask gpt to review');
-            expect(result).toContain('ralph');
-            expect(result).toContain('codex');
-        });
-        it('should return both codex and gemini when both present', () => {
-            const result = getAllKeywords('ask codex and ask gemini');
-            expect(result).toContain('codex');
-            expect(result).toContain('gemini');
-        });
-        it('should return ccg when ccg keyword present', () => {
-            const result = getAllKeywords('ccg add a user profile feature');
-            expect(result).toContain('ccg');
-        });
-        it('should return ccg with higher priority than codex/gemini', () => {
-            const result = getAllKeywords('ccg ask codex to review');
-            const ccgIdx = result.indexOf('ccg');
-            const codexIdx = result.indexOf('codex');
-            expect(ccgIdx).toBeGreaterThanOrEqual(0);
-            expect(codexIdx).toBeGreaterThanOrEqual(0);
-            expect(ccgIdx).toBeLessThan(codexIdx);
-        });
-        it('should return ralph before ccg in priority order', () => {
-            const result = getAllKeywords('ralph ccg build the app');
-            const ralphIdx = result.indexOf('ralph');
-            const ccgIdx = result.indexOf('ccg');
-            expect(ralphIdx).toBeGreaterThanOrEqual(0);
-            expect(ccgIdx).toBeGreaterThanOrEqual(0);
-            expect(ralphIdx).toBeLessThan(ccgIdx);
-        });
-        it('should not return ccg when cancel is present', () => {
-            const result = getAllKeywords('cancelomc ccg build');
-            expect(result).toEqual(['cancel']);
-            expect(result).not.toContain('ccg');
-        });
-        it('should return ralph over codex in priority', () => {
-            const primary = getPrimaryKeyword('ralph ask codex');
-            expect(primary?.type).toBe('ralph');
-        });
-        it('should return cancel over codex/gemini', () => {
-            expect(getAllKeywords('cancelomc ask codex')).toEqual(['cancel']);
-        });
-        it('should return empty array for no keywords', () => {
-            expect(getAllKeywords('regular text')).toEqual([]);
-        });
-        it('should handle code block exclusion', () => {
-            expect(getAllKeywords('```autopilot```')).toEqual([]);
-        });
-        it('should handle multiple combinable keywords', () => {
-            const result = getAllKeywords('ralph tdd fix');
-            expect(result).toContain('ralph');
-            expect(result).toContain('tdd');
-        });
-        it('should include code-review and security-review in priority order', () => {
-            const result = getAllKeywords('security review code review ultrathink');
-            expect(result).toEqual(['code-review', 'security-review', 'ultrathink']);
-        });
-        // Team keyword detection disabled — team is now explicit-only via /team skill
-        // to prevent infinite spawning when Claude workers receive prompts containing "team".
-        it('should NOT detect team keyword (explicit-only mode)', () => {
-            const result = getAllKeywords('team build the API');
-            expect(result).not.toContain('team');
-        });
-        it('should NOT detect coordinated team phrase (explicit-only)', () => {
-            const result = getAllKeywords('coordinated team build the API');
-            expect(result).not.toContain('team');
-        });
-        it('should still detect ralph when "team ralph" is used', () => {
-            const result = getAllKeywords('team ralph build the API');
-            expect(result).toContain('ralph');
-            expect(result).not.toContain('team');
-        });
-        it('should return ralph as primary when team ralph is used', () => {
-            const primary = getPrimaryKeyword('team ralph build the API');
-            expect(primary?.type).toBe('ralph');
-        });
-        it('should detect ralph and codex but not team', () => {
-            const result = getAllKeywords('team ralph ask codex to review');
-            expect(result).toContain('ralph');
-            expect(result).not.toContain('team');
-            expect(result).toContain('codex');
-        });
-        it('should not suppress autopilot when team is not detected', () => {
-            const result = getAllKeywords('ralph team autopilot build');
-            expect(result).toContain('ralph');
-            expect(result).not.toContain('team');
-            // autopilot is no longer suppressed by team since team is not detected
-            expect(result).toContain('autopilot');
-        });
-        it('should not detect deprecated ultrapilot (#1131)', () => {
-            const result = getAllKeywords('ultrapilot build all components');
-            expect(result).not.toContain('ultrapilot');
-        });
-        it('should not detect deprecated swarm (#1131)', () => {
-            const result = getAllKeywords('swarm 5 agents fix all errors');
-            expect(result).not.toContain('swarm');
-        });
-        it('should not detect cancel alongside team', () => {
-            const result = getAllKeywords('cancelomc team');
-            expect(result).toEqual(['cancel']);
-            expect(result).not.toContain('team');
-        });
-        // Dedup regression test
-        it('should deduplicate repeated keyword triggers', () => {
-            const result = getAllKeywords('autopilot autopilot fix errors');
-            const autopilotCount = result.filter(k => k === 'autopilot').length;
-            expect(autopilotCount).toBe(1);
-        });
-        describe('when team is disabled via config', () => {
-            beforeEach(() => {
-                mockedIsTeamEnabled.mockReturnValue(false);
-            });
-            afterEach(() => {
-                mockedIsTeamEnabled.mockReturnValue(true);
-            });
-            it('should NOT detect team keyword when disabled', () => {
-                const result = getAllKeywords('team build the API');
-                expect(result).not.toContain('team');
-            });
-            it('should NOT detect coordinated team when disabled', () => {
-                const result = getAllKeywords('coordinated team build');
-                expect(result).not.toContain('team');
-            });
-            it('should not detect deprecated ultrapilot regardless of team setting (#1131)', () => {
-                const result = getAllKeywords('ultrapilot build all');
-                expect(result).not.toContain('ultrapilot');
-            });
-            it('should not detect deprecated swarm regardless of team setting (#1131)', () => {
-                const result = getAllKeywords('swarm 5 agents fix errors');
-                expect(result).not.toContain('swarm');
-            });
-            it('should still detect other keywords when team disabled', () => {
-                const result = getAllKeywords('team ralph build the API');
-                expect(result).toContain('ralph');
-                expect(result).not.toContain('team');
-            });
-            it('should not suppress autopilot when team is disabled', () => {
-                const result = getAllKeywords('team autopilot build');
-                expect(result).toContain('autopilot');
-                expect(result).not.toContain('team');
-            });
-        });
-    });
-    describe('isUnderspecifiedForExecution (issue #997)', () => {
-        it('should flag vague prompt with just mode keyword', () => {
-            expect(isUnderspecifiedForExecution('ralph fix this')).toBe(true);
-        });
-        it('should flag prompt with no file or function references', () => {
-            expect(isUnderspecifiedForExecution('ralph improve the performance')).toBe(true);
-        });
-        it('should flag short vague prompt', () => {
-            expect(isUnderspecifiedForExecution('autopilot build the app')).toBe(true);
-        });
-        it('should flag empty prompt', () => {
-            expect(isUnderspecifiedForExecution('')).toBe(true);
-        });
-        it('should pass prompt with specific file reference', () => {
-            expect(isUnderspecifiedForExecution('ralph fix the bug in src/hooks/bridge.ts')).toBe(false);
-        });
-        it('should pass prompt with function reference', () => {
-            expect(isUnderspecifiedForExecution('ralph fix function processKeywordDetector')).toBe(false);
-        });
-        it('should pass prompt with issue reference', () => {
-            expect(isUnderspecifiedForExecution('ralph implement issue #42')).toBe(false);
-        });
-        it('should pass prompt with numbered steps', () => {
-            expect(isUnderspecifiedForExecution('ralph do:\n1. Add validation\n2. Add tests\n3. Update docs')).toBe(false);
-        });
-        it('should pass prompt with code block', () => {
-            const prompt = 'ralph add this function:\n```typescript\nfunction hello() { return "world"; }\n```';
-            expect(isUnderspecifiedForExecution(prompt)).toBe(false);
-        });
-        it('should pass prompt with force: escape hatch', () => {
-            expect(isUnderspecifiedForExecution('force: ralph fix this')).toBe(false);
-        });
-        it('should pass prompt with ! escape hatch', () => {
-            expect(isUnderspecifiedForExecution('! ralph improve it')).toBe(false);
-        });
-        it('should pass prompt with path reference', () => {
-            expect(isUnderspecifiedForExecution('ralph add logging to src/api/server.ts')).toBe(false);
-        });
-        it('should pass prompt with PR reference', () => {
-            expect(isUnderspecifiedForExecution('ralph fix PR #123')).toBe(false);
-        });
-        it('should pass prompt with directory path', () => {
-            expect(isUnderspecifiedForExecution('ralph refactor the hooks in src/hooks')).toBe(false);
-        });
-        it('should pass long detailed prompt without file refs', () => {
-            expect(isUnderspecifiedForExecution('ralph add a new API endpoint for user registration that accepts email and password, validates the input, hashes the password with bcrypt, stores in the users table, and returns a JWT token')).toBe(false);
-        });
-        it('should pass prompt with acceptance criteria', () => {
-            expect(isUnderspecifiedForExecution('ralph add login - acceptance criteria: user can log in with email')).toBe(false);
-        });
-        it('should pass prompt with error reference', () => {
-            expect(isUnderspecifiedForExecution('ralph fix TypeError in the auth module')).toBe(false);
-        });
-        it('should pass prompt with bullet list', () => {
-            expect(isUnderspecifiedForExecution('ralph implement:\n- Add user model\n- Add API routes')).toBe(false);
-        });
-        // False-positive prevention: concrete signals auto-pass
-        describe('false-positive prevention', () => {
-            it('should pass with camelCase symbol name', () => {
-                expect(isUnderspecifiedForExecution('ralph fix processKeywordDetector')).toBe(false);
-            });
-            it('should pass with PascalCase class name', () => {
-                expect(isUnderspecifiedForExecution('ralph update KeywordDetector')).toBe(false);
-            });
-            it('should pass with snake_case identifier', () => {
-                expect(isUnderspecifiedForExecution('team fix user_model')).toBe(false);
-            });
-            it('should pass with bare issue number #123', () => {
-                expect(isUnderspecifiedForExecution('ralph implement #42')).toBe(false);
-            });
-            it('should pass with test runner command', () => {
-                expect(isUnderspecifiedForExecution('ralph npm test && fix failures')).toBe(false);
-            });
-            it('should pass with vitest target', () => {
-                expect(isUnderspecifiedForExecution('ralph npx vitest run and fix')).toBe(false);
-            });
-            it('should pass with pytest command', () => {
-                expect(isUnderspecifiedForExecution('ralph pytest and fix failures')).toBe(false);
-            });
-            it('should pass with should return assertion', () => {
-                expect(isUnderspecifiedForExecution('ralph fix so it should return 200')).toBe(false);
-            });
-            it('should pass with stack trace reference', () => {
-                expect(isUnderspecifiedForExecution('ralph fix the stack trace error')).toBe(false);
-            });
-            it('should still gate truly vague prompts', () => {
-                expect(isUnderspecifiedForExecution('ralph fix the code')).toBe(true);
-            });
-            it('should still gate prompts with only stop words', () => {
-                expect(isUnderspecifiedForExecution('autopilot make it work')).toBe(true);
-            });
-        });
-    });
-    describe('applyRalplanGate (issue #997)', () => {
-        it('should redirect underspecified ralph to ralplan', () => {
-            const result = applyRalplanGate(['ralph'], 'ralph fix this');
-            expect(result.gateApplied).toBe(true);
-            expect(result.keywords).toContain('ralplan');
-            expect(result.keywords).not.toContain('ralph');
-            expect(result.gatedKeywords).toEqual(['ralph']);
-        });
-        it('should redirect underspecified autopilot to ralplan', () => {
-            const result = applyRalplanGate(['autopilot'], 'autopilot build the app');
-            expect(result.gateApplied).toBe(true);
-            expect(result.keywords).toContain('ralplan');
-            expect(result.keywords).not.toContain('autopilot');
-        });
-        it('should redirect underspecified team to ralplan', () => {
-            const result = applyRalplanGate(['team'], 'team improve performance');
-            expect(result.gateApplied).toBe(true);
-            expect(result.keywords).toContain('ralplan');
-            expect(result.keywords).not.toContain('team');
-        });
-        it('should not gate well-specified ralph prompt', () => {
-            const result = applyRalplanGate(['ralph'], 'ralph fix the bug in src/hooks/bridge.ts');
-            expect(result.gateApplied).toBe(false);
-            expect(result.keywords).toContain('ralph');
-        });
-        it('should not gate when cancel is present', () => {
-            const result = applyRalplanGate(['cancel'], 'cancelomc ralph fix this');
-            expect(result.gateApplied).toBe(false);
-        });
-        it('should not gate when ralplan is already present', () => {
-            const result = applyRalplanGate(['ralplan'], 'ralplan fix this');
-            expect(result.gateApplied).toBe(false);
-        });
-        it('should not gate non-execution keywords', () => {
-            const result = applyRalplanGate(['tdd', 'ultrathink'], 'tdd improve it');
-            expect(result.gateApplied).toBe(false);
-        });
-        it('should preserve non-execution keywords when gating', () => {
-            const result = applyRalplanGate(['ralph', 'tdd'], 'ralph tdd fix this');
-            expect(result.gateApplied).toBe(true);
-            expect(result.keywords).toContain('tdd');
-            expect(result.keywords).toContain('ralplan');
-            expect(result.keywords).not.toContain('ralph');
-        });
-        it('should return empty gatedKeywords when no gate applied', () => {
-            const result = applyRalplanGate([], 'regular text');
-            expect(result.gateApplied).toBe(false);
-            expect(result.gatedKeywords).toEqual([]);
-        });
-        it('should gate multiple execution keywords at once', () => {
-            const result = applyRalplanGate(['ralph', 'ultrawork'], 'ralph ultrawork fix it');
-            expect(result.gateApplied).toBe(true);
-            expect(result.keywords).toContain('ralplan');
-            expect(result.keywords).not.toContain('ralph');
-            expect(result.keywords).not.toContain('ultrawork');
-            expect(result.gatedKeywords).toContain('ralph');
-            expect(result.gatedKeywords).toContain('ultrawork');
-        });
-        it('should not gate with force: escape hatch', () => {
-            const result = applyRalplanGate(['ralph'], 'force: ralph fix this');
-            expect(result.gateApplied).toBe(false);
-            expect(result.keywords).toContain('ralph');
-        });
-    });
-    describe('bridge pipeline regression: task-size + ralplan gate ordering', () => {
-        it('should gate "ralph fix this" to ralplan even when task-size suppresses heavy modes', () => {
-            // Simulate the bridge pipeline:
-            // 1. getAllKeywordsWithSizeCheck suppresses ralph for small tasks
-            const sizeResult = getAllKeywordsWithSizeCheck('ralph fix this', {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            // ralph is suppressed because "ralph fix this" is a small task
-            expect(sizeResult.suppressedKeywords).toContain('ralph');
-            expect(sizeResult.keywords).not.toContain('ralph');
-            // 2. Reconstruct full keyword set (bridge fix: gate sees unsuppressed keywords)
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            expect(fullKeywords).toContain('ralph');
-            // 3. Gate evaluates on full set — should redirect to ralplan
-            const gateResult = applyRalplanGate(fullKeywords, 'ralph fix this');
-            expect(gateResult.gateApplied).toBe(true);
-            expect(gateResult.keywords).toContain('ralplan');
-            expect(gateResult.keywords).not.toContain('ralph');
-        });
-        it('should NOT gate well-specified small ralph prompt', () => {
-            const sizeResult = getAllKeywordsWithSizeCheck('ralph fix src/hooks/bridge.ts', {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, 'ralph fix src/hooks/bridge.ts');
-            // Well-specified: gate should NOT fire, ralph passes through
-            expect(gateResult.gateApplied).toBe(false);
-        });
-        it('should suppress heavy mode normally when gate does not apply and task is small', () => {
-            const sizeResult = getAllKeywordsWithSizeCheck('ralph fix src/hooks/bridge.ts', {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, 'ralph fix src/hooks/bridge.ts');
-            // Gate did not fire, so use task-size-suppressed result
-            expect(gateResult.gateApplied).toBe(false);
-            // Task-size suppression should still apply
-            expect(sizeResult.suppressedKeywords).toContain('ralph');
-        });
-        it('should gate correctly when keywords are NOT suppressed by size-check', () => {
-            // When size-check suppression is disabled, execution keywords flow through
-            // unsuppressed — the gate should still catch underspecified prompts.
-            const prompt = 'ralph fix this';
-            const sizeResult = getAllKeywordsWithSizeCheck(prompt, {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: false, // size-check won't suppress
-            });
-            // ralph is NOT suppressed (suppression disabled)
-            expect(sizeResult.suppressedKeywords).toHaveLength(0);
-            expect(sizeResult.keywords).toContain('ralph');
-            // Gate should still fire because the prompt is underspecified
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, prompt);
-            expect(gateResult.gateApplied).toBe(true);
-            expect(gateResult.keywords).toContain('ralplan');
-            expect(gateResult.keywords).not.toContain('ralph');
-        });
-        it('should let well-specified large prompt pass through both size-check and gate', () => {
-            const prompt = 'ralph fix the TypeError in src/hooks/bridge.ts function processKeywordDetector';
-            const sizeResult = getAllKeywordsWithSizeCheck(prompt, {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, prompt);
-            // Well-specified: gate should NOT fire
-            expect(gateResult.gateApplied).toBe(false);
-            // ralph should be in the final keyword list (either direct or via fullKeywords)
-            expect(fullKeywords).toContain('ralph');
-        });
-        it('should gate autopilot on short vague prompt even when suppressed by size-check', () => {
-            const prompt = 'autopilot make it better';
-            const sizeResult = getAllKeywordsWithSizeCheck(prompt, {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            // autopilot is suppressed by size-check (small task)
-            expect(sizeResult.suppressedKeywords).toContain('autopilot');
-            expect(sizeResult.keywords).not.toContain('autopilot');
-            // Reconstruct full keywords (as bridge.ts does) and gate
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, prompt);
-            // Gate should fire: redirect to ralplan
-            expect(gateResult.gateApplied).toBe(true);
-            expect(gateResult.keywords).toContain('ralplan');
-            expect(gateResult.keywords).not.toContain('autopilot');
-        });
-        it('should preserve non-execution keywords through the full pipeline', () => {
-            const prompt = 'ralph tdd fix this';
-            const sizeResult = getAllKeywordsWithSizeCheck(prompt, {
-                enabled: true,
-                smallWordLimit: 50,
-                largeWordLimit: 200,
-                suppressHeavyModesForSmallTasks: true,
-            });
-            const fullKeywords = [...sizeResult.keywords, ...sizeResult.suppressedKeywords];
-            const gateResult = applyRalplanGate(fullKeywords, prompt);
-            // Gate fires for ralph, tdd is preserved
-            expect(gateResult.gateApplied).toBe(true);
-            expect(gateResult.keywords).toContain('ralplan');
-            expect(gateResult.keywords).toContain('tdd');
-            expect(gateResult.keywords).not.toContain('ralph');
-        });
-    });
-    describe('non-ASCII prompt translation detection', () => {
-        describe('NON_LATIN_SCRIPT_PATTERN - should trigger', () => {
-            it('detects Japanese hiragana', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('UIコンポーネントを修正して')).toBe(true);
-            });
-            it('detects Japanese katakana', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('バグを修正してください')).toBe(true);
-            });
-            it('detects Chinese characters', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('修复这个错误')).toBe(true);
-            });
-            it('detects Korean Hangul', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('버그를 수정해주세요')).toBe(true);
-            });
-            it('detects Cyrillic (Russian)', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('исправь эту ошибку')).toBe(true);
-            });
-            it('detects Arabic', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('أصلح هذا الخطأ')).toBe(true);
-            });
-            it('detects Devanagari (Hindi)', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('इस बग को ठीक करें')).toBe(true);
-            });
-            it('detects mixed non-ASCII with English', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('ralph バグを修正して')).toBe(true);
-            });
-        });
-        describe('NON_LATIN_SCRIPT_PATTERN - should NOT trigger', () => {
-            it('does not trigger on pure ASCII', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('Fix the UI components')).toBe(false);
-            });
-            it('does not trigger on emoji only', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('👍 fix this bug')).toBe(false);
-            });
-            it('does not trigger on accented Latin (café)', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('café résumé naïve')).toBe(false);
-            });
-            it('does not trigger on accented Latin (Spanish)', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('arregla el error por favor')).toBe(false);
-            });
-            it('does not trigger on empty string', () => {
-                expect(NON_LATIN_SCRIPT_PATTERN.test('')).toBe(false);
-            });
-        });
-        describe('sanitizeForKeywordDetection strips non-ASCII from structural noise', () => {
-            it('strips non-ASCII from code blocks before detection', () => {
-                const text = 'Fix this: ```const x = "日本語";```';
-                const sanitized = sanitizeForKeywordDetection(text);
-                // After sanitization, code block content is removed
-                expect(NON_LATIN_SCRIPT_PATTERN.test(sanitized)).toBe(false);
-            });
-            it('strips non-ASCII from URLs before detection', () => {
-                const text = 'See https://example.com/path for details';
-                const sanitized = sanitizeForKeywordDetection(text);
-                // After sanitization, URL is removed - plain text remains
-                expect(sanitized).not.toContain('https://');
-            });
-            it('preserves non-ASCII in plain human-language text', () => {
-                const text = 'UIコンポーネントを修正して';
-                const sanitized = sanitizeForKeywordDetection(text);
-                // Plain Japanese text is preserved after sanitization
-                expect(NON_LATIN_SCRIPT_PATTERN.test(sanitized)).toBe(true);
-            });
-            it('preserves non-ASCII when mixed with English keywords', () => {
-                const text = 'ralph バグを修正して';
-                const sanitized = sanitizeForKeywordDetection(text);
-                // Japanese text preserved, English keyword also preserved
-                expect(NON_LATIN_SCRIPT_PATTERN.test(sanitized)).toBe(true);
-            });
-        });
-    });
-    describe('Korean cross-script keyword detection', () => {
-        describe('Korean keyword detection (basic matching)', () => {
-            it('should detect "오토파일럿" as autopilot', () => {
-                const result = detectKeywordsWithType('오토파일럿');
-                const match = result.find((r) => r.type === 'autopilot');
-                expect(match).toBeDefined();
-            });
-            it('should detect "오토파일럿 해줘" as autopilot', () => {
-                const result = detectKeywordsWithType('오토파일럿 해줘');
-                const match = result.find((r) => r.type === 'autopilot');
-                expect(match).toBeDefined();
-            });
-            it('should detect "랄프" as ralph', () => {
-                const result = detectKeywordsWithType('랄프');
-                const match = result.find((r) => r.type === 'ralph');
-                expect(match).toBeDefined();
-            });
-            it('should detect "랄프 모드" as ralph', () => {
-                const result = detectKeywordsWithType('랄프 모드');
-                const match = result.find((r) => r.type === 'ralph');
-                expect(match).toBeDefined();
-            });
-            it('should NOT detect "취소" as cancel (generic Korean word, too common)', () => {
-                const result = detectKeywordsWithType('취소');
-                const match = result.find((r) => r.type === 'cancel');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT detect "캔슬" as cancel (generic Korean word, too common)', () => {
-                const result = detectKeywordsWithType('캔슬');
-                const match = result.find((r) => r.type === 'cancel');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT detect "스톱" as cancel (generic Korean word, too common)', () => {
-                const result = detectKeywordsWithType('스톱');
-                const match = result.find((r) => r.type === 'cancel');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT trigger cancel for "설정 취소 방법 알려줘" (false positive example)', () => {
-                const result = detectKeywordsWithType('설정 취소 방법 알려줘');
-                const match = result.find((r) => r.type === 'cancel');
-                expect(match).toBeUndefined();
-            });
-            it('should detect "울트라워크" as ultrawork', () => {
-                const result = detectKeywordsWithType('울트라워크');
-                const match = result.find((r) => r.type === 'ultrawork');
-                expect(match).toBeDefined();
-            });
-            it('should detect "랄플랜" as ralplan', () => {
-                const result = detectKeywordsWithType('랄플랜');
-                const match = result.find((r) => r.type === 'ralplan');
-                expect(match).toBeDefined();
-            });
-            it('should detect "코드리뷰 해줘" as code-review', () => {
-                const result = detectKeywordsWithType('코드리뷰 해줘');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect "코드 리뷰 해줘" (spaced) as code-review', () => {
-                const result = detectKeywordsWithType('코드 리뷰 해줘');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect "보안리뷰" as security-review', () => {
-                const result = detectKeywordsWithType('보안리뷰');
-                const match = result.find((r) => r.type === 'security-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect "보안 리뷰" (spaced) as security-review', () => {
-                const result = detectKeywordsWithType('보안 리뷰');
-                const match = result.find((r) => r.type === 'security-review');
-                expect(match).toBeDefined();
-            });
-            it('should NOT detect "코드리뷰어 추천해줘" as code-review (reviewer false positive)', () => {
-                const result = detectKeywordsWithType('코드리뷰어 추천해줘');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT detect "보안리뷰어가 필요해" as security-review (reviewer false positive)', () => {
-                const result = detectKeywordsWithType('보안리뷰어가 필요해');
-                const match = result.find((r) => r.type === 'security-review');
-                expect(match).toBeUndefined();
-            });
-            it('should detect "울트라씽크" as ultrathink', () => {
-                const result = detectKeywordsWithType('울트라씽크');
-                const match = result.find((r) => r.type === 'ultrathink');
-                expect(match).toBeDefined();
-            });
-            it('should detect "딥서치" as deepsearch', () => {
-                const result = detectKeywordsWithType('딥서치');
-                const match = result.find((r) => r.type === 'deepsearch');
-                expect(match).toBeDefined();
-            });
-            it('should detect "딥 서치" (spaced) as deepsearch', () => {
-                const result = detectKeywordsWithType('딥 서치');
-                const match = result.find((r) => r.type === 'deepsearch');
-                expect(match).toBeDefined();
-            });
-            it('should detect "딥분석" as analyze', () => {
-                const result = detectKeywordsWithType('딥분석');
-                const match = result.find((r) => r.type === 'analyze');
-                expect(match).toBeDefined();
-            });
-            it('should detect "딥 분석" (spaced) as analyze', () => {
-                const result = detectKeywordsWithType('딥 분석');
-                const match = result.find((r) => r.type === 'analyze');
-                expect(match).toBeDefined();
-            });
-            it('should detect "딥인터뷰" as deep-interview', () => {
-                const result = detectKeywordsWithType('딥인터뷰');
-                const match = result.find((r) => r.type === 'deep-interview');
-                expect(match).toBeDefined();
-            });
-            it('should NOT detect "딥 인터뷰" (spaced) as deep-interview', () => {
-                const result = detectKeywordsWithType('딥 인터뷰');
-                const match = result.find((r) => r.type === 'deep-interview');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT detect "고객 딥 인터뷰 질문지를 만들어줘" as deep-interview', () => {
-                const result = detectKeywordsWithType('고객 딥 인터뷰 질문지를 만들어줘');
-                const match = result.find((r) => r.type === 'deep-interview');
-                expect(match).toBeUndefined();
-            });
-            it('should detect "씨씨지" as ccg', () => {
-                const result = detectKeywordsWithType('씨씨지');
-                const match = result.find((r) => r.type === 'ccg');
-                expect(match).toBeDefined();
-            });
-            it('should detect "테스트퍼스트" as tdd', () => {
-                const result = detectKeywordsWithType('테스트퍼스트');
-                const match = result.find((r) => r.type === 'tdd');
-                expect(match).toBeDefined();
-            });
-            it('should detect "테스트 퍼스트" (spaced) as tdd', () => {
-                const result = detectKeywordsWithType('테스트 퍼스트');
-                const match = result.find((r) => r.type === 'tdd');
-                expect(match).toBeDefined();
-            });
-        });
-        describe('Regression — English keywords still work', () => {
-            it('should detect "autopilot mode" as autopilot (unchanged)', () => {
-                const result = detectKeywordsWithType('autopilot mode');
-                const match = result.find((r) => r.type === 'autopilot');
-                expect(match).toBeDefined();
-            });
-            it('should detect "ralph해줘" (English keyword + Korean particle)', () => {
-                const result = detectKeywordsWithType('ralph해줘');
-                const match = result.find((r) => r.type === 'ralph');
-                expect(match).toBeDefined();
-            });
-            it('should detect "autopilot으로" (English keyword + Korean particle)', () => {
-                const result = detectKeywordsWithType('autopilot으로');
-                const match = result.find((r) => r.type === 'autopilot');
-                expect(match).toBeDefined();
-            });
-            it('should detect "tdd로 해줘" (English keyword + Korean particle)', () => {
-                const result = detectKeywordsWithType('tdd로 해줘');
-                const match = result.find((r) => r.type === 'tdd');
-                expect(match).toBeDefined();
-            });
-            it('should detect "cancelomc" as cancel (unchanged)', () => {
-                const result = detectKeywordsWithType('cancelomc');
-                const match = result.find((r) => r.type === 'cancel');
-                expect(match).toBeDefined();
-            });
-            it('should detect "ultrawork mode" as ultrawork (unchanged)', () => {
-                const result = detectKeywordsWithType('ultrawork mode');
-                const match = result.find((r) => r.type === 'ultrawork');
-                expect(match).toBeDefined();
-            });
-            it('should detect "code review this" as code-review (unchanged)', () => {
-                const result = detectKeywordsWithType('code review this');
-                const match = result.find((r) => r.type === 'code-review');
-                expect(match).toBeDefined();
-            });
-            it('should detect "deepsearch the codebase" as deepsearch (unchanged)', () => {
-                const result = detectKeywordsWithType('deepsearch the codebase');
-                const match = result.find((r) => r.type === 'deepsearch');
-                expect(match).toBeDefined();
-            });
-        });
-        describe('Negative tests — no false positives', () => {
-            it('should NOT match unrelated Korean text "오늘 날씨가 좋네요"', () => {
-                const result = detectKeywordsWithType('오늘 날씨가 좋네요');
-                expect(result.length).toBe(0);
-            });
-            it('should NOT match "프로그래밍을 배우고 싶어요"', () => {
-                const result = detectKeywordsWithType('프로그래밍을 배우고 싶어요');
-                expect(result.length).toBe(0);
-            });
-            it('should NOT match "코드를 작성해주세요" (contains 코드 but not 코드리뷰)', () => {
-                const result = detectKeywordsWithType('코드를 작성해주세요');
-                const codeReviewMatch = result.find((r) => r.type === 'code-review');
-                expect(codeReviewMatch).toBeUndefined();
-            });
-            it('should NOT match empty string', () => {
-                const result = detectKeywordsWithType('');
-                expect(result.length).toBe(0);
-            });
-        });
-        describe('Korean in code blocks should NOT match', () => {
-            it('should NOT detect "오토파일럿" inside fenced code block', () => {
-                const result = detectKeywordsWithType('```오토파일럿```');
-                const match = result.find((r) => r.type === 'autopilot');
-                expect(match).toBeUndefined();
-            });
-            it('should NOT detect "랄프" inside inline code', () => {
-                const result = detectKeywordsWithType('Use `랄프` command');
-                const match = result.find((r) => r.type === 'ralph');
-                expect(match).toBeUndefined();
-            });
-        });
-        describe('Korean priority ordering', () => {
-            it('should return cancel over autopilot when "cancelomc 오토파일럿"', () => {
-                const result = getPrimaryKeyword('cancelomc 오토파일럿');
-                expect(result?.type).toBe('cancel');
-            });
-            it('should return ralph first when "랄프 울트라워크"', () => {
-                const result = getAllKeywords('랄프 울트라워크');
-                expect(result).toContain('ralph');
-                expect(result).toContain('ultrawork');
-                const ralphIdx = result.indexOf('ralph');
-                const ultraworkIdx = result.indexOf('ultrawork');
-                expect(ralphIdx).toBeLessThan(ultraworkIdx);
-            });
-            it('should detect both keywords for "오토파일럿 코드리뷰"', () => {
-                const result = detectKeywordsWithType('오토파일럿 코드리뷰');
-                const types = result.map((r) => r.type);
-                expect(types).toContain('autopilot');
-                expect(types).toContain('code-review');
-            });
-        });
-        describe('Korean + English mixed keywords', () => {
-            it('should return cancel as primary for "ralph cancelomc"', () => {
-                const result = getPrimaryKeyword('ralph cancelomc');
-                expect(result?.type).toBe('cancel');
-            });
-            it('should detect both keywords for "autopilot 코드리뷰"', () => {
-                const result = getAllKeywords('autopilot 코드리뷰');
-                expect(result).toContain('autopilot');
-                expect(result).toContain('code-review');
-            });
-            it('should detect both "랄프 ultrawork", ralph first', () => {
-                const result = getAllKeywords('랄프 ultrawork');
-                expect(result).toContain('ralph');
-                expect(result).toContain('ultrawork');
-                const ralphIdx = result.indexOf('ralph');
-                const ultraworkIdx = result.indexOf('ultrawork');
-                expect(ralphIdx).toBeLessThan(ultraworkIdx);
-            });
-        });
-        describe('getAllKeywords and getPrimaryKeyword with Korean', () => {
-            it('getAllKeywords("랄프 코드리뷰") should return ["ralph", "code-review"]', () => {
-                expect(getAllKeywords('랄프 코드리뷰')).toEqual(['ralph', 'code-review']);
-            });
-            it('getPrimaryKeyword("오토파일럿")?.type should be "autopilot"', () => {
-                expect(getPrimaryKeyword('오토파일럿')?.type).toBe('autopilot');
-            });
-            it('hasKeyword("울트라워크") should be true', () => {
-                expect(hasKeyword('울트라워크')).toBe(true);
-            });
-            it('hasKeyword("오토파일럿") should be true', () => {
-                expect(hasKeyword('오토파일럿')).toBe(true);
-            });
-        });
-    });
-});
-//# sourceMappingURL=index.test.js.map