oh-my-codex 0.13.2 → 0.14.0

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

@@ -4,7 +4,7 @@ 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, } from '../keyword-detector.js';
+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';
@@ -43,15 +43,17 @@ describe('keyword detector swarm/team compatibility', () => {
         const primary = detectPrimaryKeyword('/prompts:architect, analyze this issue');
         assert.equal(primary, null);
     });
-    it('maps analyze keyword to analyze skill', () => {
-        const match = detectPrimaryKeyword('please analyze this workflow');
+    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');
+        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');
@@ -79,8 +81,8 @@ describe('keyword detector swarm/team compatibility', () => {
         assert.equal(match.skill, 'team');
         assert.match(match.keyword.toLowerCase(), /swarm/);
     });
-    it('keeps swarm trigger priority aligned with team trigger', () => {
-        const teamMatch = detectKeywords('use team agents for this').find((entry) => entry.skill === 'team');
+    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);
@@ -94,6 +96,10 @@ describe('keyword detector swarm/team compatibility', () => {
         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);
@@ -113,8 +119,8 @@ describe('keyword detector swarm/team compatibility', () => {
         assert.equal(match.skill, 'ralph');
         assert.equal(match.keyword.toLowerCase(), '$ralph');
     });
-    it('prefers ralplan over ralph when both keywords are present', () => {
-        const match = detectPrimaryKeyword('use ralph mode but do ralplan first');
+    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');
     });
@@ -181,14 +187,44 @@ describe('keyword detector swarm/team compatibility', () => {
         assert.equal(detectPrimaryKeyword('running 8 tests in parallel across 4 workers'), 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('$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('$code-review'));
         assert.ok(registryKeywords.has('coordinated team'));
         assert.ok(registryKeywords.has('swarm'));
         assert.ok(registryKeywords.has('coordinated swarm'));
@@ -198,6 +234,7 @@ describe('keyword registry coverage', () => {
         assert.ok(registryKeywords.has('wiki query'));
         assert.ok(registryKeywords.has('wiki add'));
         assert.ok(registryKeywords.has('wiki lint'));
+        assert.ok(registryKeywords.has('$autoresearch'));
     });
 });
 describe('keyword detector skill-active-state lifecycle', () => {
@@ -208,7 +245,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await mkdir(stateDir, { recursive: true });
             const result = await recordSkillActivation({
                 stateDir,
-                text: 'please run autopilot and keep going',
+                text: 'please run $autopilot and keep going',
                 sessionId: 'sess-1',
                 threadId: 'thread-1',
                 turnId: 'turn-1',
@@ -389,6 +426,53 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('seeds executing state for autoresearch prompt-submit activation', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-autoresearch-'));
+        const stateDir = join(cwd, '.omx', '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, '.omx/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(), 'omx-keyword-autoresearch-planning-precedence-'));
+        const stateDir = join(cwd, '.omx', '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('seeds first-class state for ralplan prompt-submit activation', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-ralplan-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -426,7 +510,17 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 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' }, 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: 'omx-question',
+                    status: 'pending',
+                    requested_at: '2026-04-09T23:59:00.000Z',
+                },
+            }, null, 2));
             const result = await recordSkillActivation({
                 stateDir,
                 text: '$ralplan implement the approved contract',
@@ -438,6 +532,9 @@ describe('keyword detector skill-active-state lifecycle', () => {
             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 });
@@ -647,6 +744,84 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('creates the session-scoped deep-interview state directory before persisting mode state', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-deep-interview-session-dir-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        try {
+            await mkdir(stateDir, { recursive: true });
+            await persistDeepInterviewModeState(stateDir, {
+                version: 1,
+                active: true,
+                skill: 'deep-interview',
+                keyword: 'deep interview',
+                phase: 'planning',
+                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(), 'omx-keyword-state-deep-interview-reactivation-'));
+        const stateDir = join(cwd, '.omx', '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: 'omx-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(), 'omx-keyword-state-deep-interview-abort-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -654,7 +829,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             await mkdir(stateDir, { recursive: true });
             await recordSkillActivation({
                 stateDir,
-                text: 'please run deep interview',
+                text: 'please run $deep-interview',
                 nowIso: '2026-02-25T00:00:00.000Z',
             });
             const result = await recordSkillActivation({
@@ -719,7 +894,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
         });
         const result = await recordSkillActivation({
             stateDir: join('/definitely-missing', 'nested', 'state-dir'),
-            text: 'please run autopilot',
+            text: 'please run $autopilot',
             nowIso: '2026-02-25T00:00:00.000Z',
         });
         assert.ok(result);
@@ -737,7 +912,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 version: 1,
                 active: true,
                 skill: 'autopilot',
-                keyword: 'autopilot',
+                keyword: '$autopilot',
                 phase: 'planning',
                 activated_at: '2026-02-25T00:00:00.000Z',
                 updated_at: '2026-02-25T00:10:00.000Z',
@@ -749,6 +924,8 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 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');
         }
@@ -790,6 +967,9 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 nowIso: '2026-02-26T00:00:00.000Z',
             });
             assert.ok(result);
+            assert.equal(result.skill, 'autopilot');
+            assert.equal(result.phase, 'planning');
+            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, 'execution');
             assert.equal(modeState.started_at, '2026-02-25T00:00:00.000Z');
@@ -852,6 +1032,8 @@ describe('keyword detector skill-active-state lifecycle', () => {
                 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);
@@ -861,6 +1043,115 @@ describe('keyword detector skill-active-state lifecycle', () => {
             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(), 'omx-keyword-state-autopilot-bare-continuation-'));
+        const stateDir = join(cwd, '.omx', '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: 'planning',
+                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: 'planning',
+                        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: 'execution',
+                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: '.omx/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, 'execution');
+            assert.equal(modeState.state?.context_snapshot_path, '.omx/context/autopilot.md');
+            assert.equal(existsSync(join(stateDir, 'sessions', 'sess-autopilot-bare', 'ralph-state.json')), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
+    it('routes bare keep-going continuation to the active ralph skill instead of resetting through generic keep-going detection', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-ralph-bare-continuation-'));
+        const stateDir = join(cwd, '.omx', 'state');
+        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('denies switching away from a standalone workflow without explicit clear', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-keyword-state-skill-switch-deny-'));
         const stateDir = join(cwd, '.omx', 'state');
@@ -879,7 +1170,7 @@ describe('keyword detector skill-active-state lifecycle', () => {
             }));
             const result = await recordSkillActivation({
                 stateDir,
-                text: 'please run ralph now',
+                text: 'please run $ralph now',
                 nowIso: '2026-02-26T00:00:00.000Z',
             });
             assert.ok(result);