oh-my-codex 0.20.3 → 0.20.5

package/dist/hooks/keyword-detector.js

@@ -16,10 +16,10 @@ import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { classifyTaskSize, isHeavyMode } from './task-size-detector.js';
 import { isApprovedExecutionFollowupShortcut } from '../team/followup-planner.js';
 import { isPlanningComplete, readPlanningArtifacts } from '../planning/artifacts.js';
-import { hasDurableRalplanConsensusEvidenceForCwd } from '../ralplan/consensus-gate.js';
+import { buildRalplanConsensusGateForCwd, shouldBlockFreshAutopilotForRalplanReceipt, } from '../ralplan/consensus-gate.js';
 import { getExplicitSkillDefinition, KEYWORD_TRIGGER_DEFINITIONS, compareKeywordMatches } from './keyword-registry.js';
 import { readTeamModeConfig } from '../config/team-mode.js';
-import { SKILL_ACTIVE_STATE_FILE, listActiveSkills, writeSkillActiveStateCopiesForStateDir, } from '../state/skill-active.js';
+import { SKILL_ACTIVE_STATE_FILE, listActiveSkills, readSkillActiveState, writeSkillActiveStateCopiesForStateDir, } from '../state/skill-active.js';
 import { buildWorkflowTransitionError, evaluateWorkflowTransition, isTrackedWorkflowMode, } from '../state/workflow-transition.js';
 import { reconcileWorkflowTransition } from '../state/workflow-transition-reconcile.js';
 import { clearDeepInterviewQuestionObligation, } from '../question/deep-interview.js';
@@ -293,13 +293,7 @@ function releaseDeepInterviewInputLock(previous, nowIso, reason = 'handoff') {
     };
 }
 async function readExistingSkillState(statePath) {
-    try {
-        const raw = await readFile(statePath, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
+    return await readSkillActiveState(statePath);
 }
 function buildActiveSkills(state) {
     if (!state.active)
@@ -429,6 +423,30 @@ function isResettableTerminalModeState(state, expectedMode) {
         || lifecycleOutcome === 'userinterlude'
         || (expectedMode === 'ralph' && lifecycleOutcome === 'blocked');
 }
+async function persistBlockedFreshAutopilotState(stateDir, sessionId, nowIso) {
+    const { absolutePath } = resolveSeedStateFilePath(stateDir, 'autopilot', sessionId);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    const error = 'documented_host_consensus_receipt_unavailable';
+    const state = withModeRuntimeContext({}, {
+        active: false,
+        mode: 'autopilot',
+        current_phase: 'failed',
+        iteration: 0,
+        max_iterations: 10,
+        started_at: nowIso,
+        completed_at: nowIso,
+        updated_at: nowIso,
+        error,
+        status_message: 'Status: failed — Autopilot cannot start without an official host consensus receipt verifier.',
+        handoff_artifacts: {
+            ralplan_consensus_gate: {
+                blocked_reason: error,
+                blocked_details: ['official host consensus receipt verifier is unavailable'],
+            },
+        },
+    }, { nowIso });
+    await writeFile(absolutePath, JSON.stringify(state, null, 2));
+}
 async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previousSkill, activationText, sourceCwd, options = {}) {
     const config = STATEFUL_SKILL_SEED_CONFIG[nextSkill.skill];
     if (!config)
@@ -3076,7 +3094,7 @@ async function preflightKeywordTargetState(stateDir, sessionId, context, nowIso)
     }
     return preflightSelectedTargetOwner(context, evidence, 'native', nowIso);
 }
-export async function recordSkillActivation(input) {
+export async function recordSkillActivation(input, dependencies = {}) {
     const classification = input.classification ?? classifyKeywordInput(input.text);
     if (classification.originalText !== input.text) {
         throw new Error('Keyword input classification text does not match activation text');
@@ -3150,9 +3168,35 @@ export async function recordSkillActivation(input) {
     const matchedModeState = matchedSeedConfig
         ? await readJsonStateIfExists(resolveSeedStateFilePath(input.stateDir, matchedSeedConfig.mode, input.sessionId, matchedSeedConfig.scope).absolutePath)
         : null;
+    const freshAutopilot = match.skill === 'autopilot'
+        && !(previous?.active === true && previous.skill === 'autopilot')
+        && matchedModeState?.active !== true;
     const matchedModeTerminal = matchedSeedConfig
         ? isResettableTerminalModeState(matchedModeState, matchedSeedConfig.mode)
         : false;
+    if (match.skill === 'autopilot'
+        && matchedModeState?.active === true
+        && !matchedModeTerminal
+        && shouldBlockFreshAutopilotForRalplanReceipt(dependencies.getRalplanHostConsensusReceiptVerifierCapability?.())) {
+        const phase = safeString(matchedModeState.current_phase).trim() || 'deep-interview';
+        const preserved = previous ?? {
+            version: 1,
+            active: true,
+            skill: 'autopilot',
+            keyword: match.keyword,
+            phase,
+            activated_at: safeString(matchedModeState.started_at).trim() || nowIso,
+            updated_at: safeString(matchedModeState.updated_at).trim() || nowIso,
+            source: 'keyword-detector',
+            session_id: input.sessionId,
+            active_skills: [{ skill: 'autopilot', active: true, phase, session_id: input.sessionId }],
+        };
+        return {
+            ...preserved,
+            initialized_mode: 'autopilot',
+            initialized_state_path: resolveSeedStateFilePath(input.stateDir, 'autopilot', input.sessionId ?? preserved.session_id).relativePath,
+        };
+    }
     if (classification.reservedInput === 'omx-question-answered' && matchedModeTerminal)
         return null;
     const preserveActivatedAt = sameSkill && !matchedModeTerminal && (sameKeyword || sameSkillContinuation);
@@ -3244,7 +3288,12 @@ export async function recordSkillActivation(input) {
         const transitionMessages = [];
         for (const requestedMode of requestedWorkflowSkills) {
             const decision = evaluateWorkflowTransition(nextWorkflowEntries.map((entry) => entry.skill), requestedMode);
-            if (!decision.allowed) {
+            const hasStandaloneRalplanPreflightDenial = freshAutopilot
+                && previous?.active === true
+                && previous.skill === 'ralplan'
+                && decision.currentModes.length === 1
+                && decision.currentModes[0] === 'ralplan';
+            if (!decision.allowed && !hasStandaloneRalplanPreflightDenial) {
                 return {
                     ...(previous ?? {}),
                     version: 1,
@@ -3263,6 +3312,44 @@ export async function recordSkillActivation(input) {
                     transition_error: buildWorkflowTransitionError(nextWorkflowEntries.map((entry) => entry.skill), requestedMode, 'activate'),
                 };
             }
+            if (freshAutopilot
+                && requestedMode === 'autopilot'
+                && shouldBlockFreshAutopilotForRalplanReceipt(dependencies.getRalplanHostConsensusReceiptVerifierCapability?.())) {
+                const error = 'documented_host_consensus_receipt_unavailable';
+                if (previous?.active === true && previous.skill === 'ralplan') {
+                    return {
+                        ...previous,
+                        updated_at: nowIso,
+                        transition_error: error,
+                    };
+                }
+                const state = {
+                    version: 1,
+                    active: false,
+                    skill: 'autopilot',
+                    keyword: match.keyword,
+                    phase: 'failed',
+                    activated_at: nowIso,
+                    updated_at: nowIso,
+                    source: 'keyword-detector',
+                    session_id: input.sessionId,
+                    thread_id: input.threadId,
+                    turn_id: input.turnId,
+                    active_skills: [],
+                    error,
+                    transition_error: error,
+                    status_message: 'Status: failed — Autopilot cannot start without an official host consensus receipt verifier.',
+                };
+                const nextState = applyProvenanceOwner(state);
+                try {
+                    await persistBlockedFreshAutopilotState(input.stateDir, input.sessionId, nowIso);
+                    await writeSkillActiveStateCopiesForStateDir(input.stateDir, nextState, input.sessionId, selectRootSkillStateCopy(previousRoot, nextState, input.sessionId, suppressRootMutation));
+                }
+                catch (error) {
+                    console.warn('[omx] warning: failed to persist keyword activation state', error);
+                }
+                return nextState;
+            }
             if (decision.autoCompleteModes.length > 0) {
                 let transition;
                 try {
@@ -3514,29 +3601,33 @@ export function isUnderspecifiedForExecution(text) {
 }
 export function applyRalplanGate(keywords, text, options = {}) {
     if (keywords.length === 0) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
     // Don't gate if cancel is present (cancel always wins)
     if (keywords.includes('cancel')) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
     // Don't gate if ralplan is already in the list
     if (keywords.includes('ralplan')) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
     // Check if any execution keywords are present
     const executionKeywords = keywords.filter(k => EXECUTION_GATE_KEYWORDS.has(k));
     if (executionKeywords.length === 0) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
     // Check if prompt is underspecified
     if (!isUnderspecifiedForExecution(text)) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
-    const planningComplete = isPlanningComplete(readPlanningArtifacts(options.cwd ?? process.cwd()));
-    const consensusComplete = hasDurableRalplanConsensusEvidenceForCwd(options.cwd ?? process.cwd(), {
+    const cwd = options.cwd ?? process.cwd();
+    const planningComplete = isPlanningComplete(readPlanningArtifacts(cwd));
+    const consensusEvidence = buildRalplanConsensusGateForCwd(cwd, {
         requireNativeSubagents: options.requireNativeSubagents,
     });
+    const consensusComplete = consensusEvidence.complete;
+    const consensusBlockedFollowup = planningComplete
+        && executionKeywords.some((keyword) => keyword === 'team' || keyword === 'ralph');
     const shortFollowupBypasses = executionKeywords.filter((keyword) => {
         if (keyword !== 'team' && keyword !== 'ralph')
             return false;
@@ -3546,14 +3637,19 @@ export function applyRalplanGate(keywords, text, options = {}) {
         });
     });
     if (shortFollowupBypasses.length > 0) {
-        return { keywords, gateApplied: false, gatedKeywords: [] };
+        return { keywords, gateApplied: false, gatedKeywords: [], blockedReason: null };
     }
     // Gate: replace execution keywords with ralplan
     const filtered = keywords.filter(k => !EXECUTION_GATE_KEYWORDS.has(k));
     if (!filtered.includes('ralplan')) {
         filtered.push('ralplan');
     }
-    return { keywords: filtered, gateApplied: true, gatedKeywords: executionKeywords };
+    return {
+        keywords: filtered,
+        gateApplied: true,
+        gatedKeywords: executionKeywords,
+        blockedReason: consensusBlockedFollowup ? consensusEvidence.blockedReason : null,
+    };
 }
 /**
  * Get all keywords with task-size-based filtering applied.