oh-my-codex 0.18.6 → 0.18.8

package/dist/hooks/keyword-detector.js

@@ -9,19 +9,22 @@
  * skill/workflow state. AGENTS.md now carries the behavioral fallback contract
  * rather than the full keyword/state table.
  */
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { access, lstat, mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
 import { withModeRuntimeContext } from '../state/mode-state-context.js';
-import { dirname, join } from 'node:path';
+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 { 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 { buildWorkflowTransitionError, evaluateWorkflowTransition, isTrackedWorkflowMode, } from '../state/workflow-transition.js';
 import { reconcileWorkflowTransition } from '../state/workflow-transition-reconcile.js';
 import { clearDeepInterviewQuestionObligation, } from '../question/deep-interview.js';
 import { buildDeepInterviewConfigStateFields, resolveDeepInterviewRuntimeConfig, } from '../config/deep-interview.js';
+import { inferTerminalLifecycleOutcome } from '../runtime/run-outcome.js';
 const ACTIVE_SKILL_CONTINUATION_PATTERNS = [
     /^[\\/]?\s*keep going(?:\s+now)?[.!]?\s*$/i,
     /^[\\/]?\s*continue(?:\s+now)?[.!]?\s*$/i,
@@ -57,6 +60,198 @@ const STATEFUL_SKILL_SEED_CONFIG = {
     ultrawork: { mode: 'ultrawork', initialPhase: 'planning' },
     ultraqa: { mode: 'ultraqa', initialPhase: 'planning' },
 };
+function slugifyAutopilotTask(text) {
+    const slug = text
+        .replace(/(?:^|\s)\$?(?:oh-my-codex:)?autopilot\b/gi, ' ')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase()
+        .slice(0, 48)
+        .replace(/-+$/g, '');
+    return slug || 'autopilot-task';
+}
+function utcCompactTimestamp(nowIso) {
+    const parsed = new Date(nowIso);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`Invalid Autopilot context timestamp: ${nowIso}`);
+    }
+    return parsed.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+}
+function isSafeAutopilotContextSnapshotPath(value) {
+    const path = safeString(value).trim();
+    const contextPrefix = '.omx/context/';
+    const snapshotName = path.startsWith(contextPrefix) ? path.slice(contextPrefix.length) : '';
+    return path.startsWith('.omx/context/')
+        && path.endsWith('.md')
+        && !isAbsolute(path)
+        && !path.split('/').includes('..')
+        && !path.includes('\\')
+        && snapshotName !== ''
+        && !snapshotName.includes('/');
+}
+function isAutopilotRecoverySnapshotPath(path) {
+    return path.startsWith('.omx/context/autopilot-recovery-');
+}
+const MAX_REUSABLE_AUTOPILOT_CONTEXT_SNAPSHOT_BYTES = 1024 * 1024;
+async function isReadableAutopilotContextSnapshotPath(sourceCwd, value) {
+    if (!isSafeAutopilotContextSnapshotPath(value))
+        return false;
+    const contextDir = await ensureSafeAutopilotContextDir(sourceCwd);
+    const absolutePath = join(sourceCwd, value);
+    try {
+        const snapshotStat = await lstat(absolutePath);
+        if (!snapshotStat.isFile() || snapshotStat.isSymbolicLink())
+            return false;
+        if (snapshotStat.size > MAX_REUSABLE_AUTOPILOT_CONTEXT_SNAPSHOT_BYTES)
+            return false;
+        const contextRealPath = await realpath(contextDir);
+        const snapshotRealPath = await realpath(absolutePath);
+        const relativeToContext = relative(contextRealPath, snapshotRealPath);
+        if (relativeToContext === '' || relativeToContext.startsWith('..') || isAbsolute(relativeToContext))
+            return false;
+        await access(absolutePath, fsConstants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function normalizeAutopilotContextSnapshotCandidate(candidate) {
+    if (isRecord(candidate.value)) {
+        const path = safeString(candidate.value.path).trim();
+        const kind = safeString(candidate.value.kind).trim();
+        if (!path || !['canonical', 'legacy', 'recovery'].includes(kind))
+            return null;
+        if (kind === 'recovery' || isAutopilotRecoverySnapshotPath(path))
+            return null;
+        return { path, kind };
+    }
+    const path = safeString(candidate.value).trim();
+    if (!path)
+        return null;
+    if (isAutopilotRecoverySnapshotPath(path))
+        return null;
+    return { path, kind: candidate.kind ?? 'legacy' };
+}
+async function findReusableAutopilotContextSnapshotPath(sourceCwd, candidates) {
+    for (const candidate of candidates) {
+        const normalized = normalizeAutopilotContextSnapshotCandidate(candidate);
+        if (!normalized || isAutopilotRecoverySnapshotPath(normalized.path) || !isSafeAutopilotContextSnapshotPath(normalized.path))
+            continue;
+        if (await isReadableAutopilotContextSnapshotPath(sourceCwd, normalized.path))
+            return normalized;
+    }
+    return undefined;
+}
+const AUTOPILOT_CONTEXT_RECOVERY_REASON_MESSAGES = {
+    'missing-or-unsafe-legacy-context-snapshot': 'no safe legacy Autopilot context snapshot path was available during continuation.',
+    'missing-autopilot-mode-state': 'active Autopilot skill state existed but no matching Autopilot mode state was available during continuation.',
+    'malformed-autopilot-mode-state': 'active Autopilot mode state could not be parsed during continuation.',
+    'nonpreservable-autopilot-mode-state-missing-current-phase': 'active Autopilot mode state was missing current_phase during continuation.',
+};
+async function ensureSafeAutopilotContextDir(sourceCwd) {
+    const rootRealPath = await realpath(sourceCwd);
+    const omxDir = join(sourceCwd, '.omx');
+    await mkdir(omxDir, { recursive: true });
+    if ((await lstat(omxDir)).isSymbolicLink()) {
+        throw new Error('Unsafe Autopilot context directory: .omx is a symbolic link');
+    }
+    const contextDir = join(omxDir, 'context');
+    await mkdir(contextDir, { recursive: true });
+    if ((await lstat(contextDir)).isSymbolicLink()) {
+        throw new Error('Unsafe Autopilot context directory: .omx/context is a symbolic link');
+    }
+    const contextRealPath = await realpath(contextDir);
+    const relativeToRoot = relative(rootRealPath, contextRealPath);
+    if (relativeToRoot === '' || relativeToRoot.startsWith('..') || isAbsolute(relativeToRoot)) {
+        throw new Error('Unsafe Autopilot context directory: resolved path escapes repository root');
+    }
+    return contextDir;
+}
+async function writeUniqueAutopilotContextSnapshot(sourceCwd, slug, nowIso, body) {
+    const contextDir = await ensureSafeAutopilotContextDir(sourceCwd);
+    const timestamp = utcCompactTimestamp(nowIso);
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const suffix = attempt === 0 ? '' : `-${attempt + 1}`;
+        const filename = `${slug}-${timestamp}${suffix}.md`;
+        const relativePath = `.omx/context/${filename}`;
+        const absolutePath = resolve(contextDir, filename);
+        try {
+            await writeFile(absolutePath, body, { encoding: 'utf-8', flag: 'wx' });
+            return relativePath;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                continue;
+            throw error;
+        }
+    }
+    throw new Error(`Unable to allocate unique Autopilot context snapshot for ${slug}`);
+}
+async function ensureAutopilotContextSnapshot(sourceCwd, nowIso, activationText, existingSnapshot, options = {}) {
+    if (existingSnapshot) {
+        if (isSafeAutopilotContextSnapshotPath(existingSnapshot.path)) {
+            return {
+                path: existingSnapshot.path,
+                kind: existingSnapshot.kind,
+                original_task_status: existingSnapshot.kind === 'legacy' ? 'legacy-unverified' : 'activation-prompt',
+            };
+        }
+        throw new Error(`Unsafe Autopilot context snapshot path: ${existingSnapshot.path}`);
+    }
+    if (options.allowTaskSnapshotCreation === false) {
+        const slug = 'autopilot-recovery';
+        const continuationInput = activationText.trim() || '<empty>';
+        const reason = options.recoveryReason ?? 'missing-or-unsafe-legacy-context-snapshot';
+        const body = [
+            '# Autopilot context recovery',
+            '',
+            '- recovery status: degraded',
+            `- recovery reason: ${reason}`,
+            `- reason detail: ${AUTOPILOT_CONTEXT_RECOVERY_REASON_MESSAGES[reason]}`,
+            `- continuation input: ${continuationInput}`,
+            '- original task status: unavailable',
+            '- original task seed: unavailable; do not treat the continuation input as the task seed.',
+            '- required follow-up: re-establish or confirm the intended task context before downstream handoff.',
+            '',
+        ].join('\n');
+        const path = await writeUniqueAutopilotContextSnapshot(sourceCwd, slug, nowIso, body);
+        return {
+            path,
+            kind: 'recovery',
+            original_task_status: 'unavailable',
+            recovery: {
+                status: 'degraded',
+                reason,
+                recovered_at: nowIso,
+                source: 'keyword-detector',
+            },
+        };
+    }
+    const slug = slugifyAutopilotTask(activationText);
+    const taskSeed = activationText.trim() || '$autopilot';
+    const body = [
+        `# Autopilot task seed: ${slug}`,
+        '',
+        `- activation prompt / task seed: ${taskSeed}`,
+        '- original task status: activation-prompt',
+        '- scope note: this seed captures the Autopilot activation prompt and is not guaranteed to include prior conversation context.',
+        '- desired outcome: complete the requested Autopilot workflow correctly with durable gate evidence.',
+        '- known facts/evidence: Autopilot was activated from a UserPromptSubmit keyword.',
+        '- constraints: follow deep-interview -> ralplan -> ultragoal -> code-review -> ultraqa; do not skip gates without persisted evidence.',
+        '- unknowns/open questions: to be resolved by the deep-interview gate.',
+        '- likely codebase touchpoints: to be discovered during pre-context intake and planning.',
+        '',
+    ].join('\n');
+    return {
+        path: await writeUniqueAutopilotContextSnapshot(sourceCwd, slug, nowIso, body),
+        kind: 'canonical',
+        original_task_status: 'activation-prompt',
+    };
+}
 function createDeepInterviewInputLock(nowIso, previous) {
     return {
         active: true,
@@ -117,12 +312,21 @@ async function readExistingDeepInterviewState(statePath) {
     }
 }
 async function readJsonStateIfExists(path) {
+    return (await readJsonStateWithStatus(path)).state;
+}
+async function readJsonStateWithStatus(path) {
     try {
         const raw = await readFile(path, 'utf-8');
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            return { state: null, status: 'malformed' };
+        return { state: parsed, status: 'ok' };
     }
-    catch {
-        return null;
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { state: null, status: 'missing' };
+        }
+        return { state: null, status: 'malformed' };
     }
 }
 export async function persistDeepInterviewModeState(stateDir, nextSkill, nowIso, previousSkill, input) {
@@ -192,20 +396,39 @@ function resolveSeedStateFilePath(stateDir, mode, sessionId, scope = 'session')
         relativePath: `.omx/state/${mode}-state.json`,
     };
 }
-async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previousSkill) {
+function isResettableTerminalModeState(state, expectedMode) {
+    if (!state || safeString(state.mode).trim() !== expectedMode)
+        return false;
+    const phase = safeString(state.current_phase).trim().toLowerCase().replace(/_/g, '-');
+    const terminalPhases = expectedMode === 'ralph'
+        ? ['blocked-on-user', 'complete', 'completed', 'failed', 'cancelled', 'canceled', 'stopped', 'user-stopped']
+        : ['complete', 'completed', 'failed', 'cancelled', 'canceled', 'stopped', 'user-stopped'];
+    if (terminalPhases.includes(phase))
+        return true;
+    const lifecycleOutcome = inferTerminalLifecycleOutcome(state, { includeQuestionEnforcement: false });
+    return lifecycleOutcome === 'finished'
+        || lifecycleOutcome === 'failed'
+        || lifecycleOutcome === 'userinterlude'
+        || (expectedMode === 'ralph' && lifecycleOutcome === 'blocked');
+}
+async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previousSkill, activationText, sourceCwd, options = {}) {
     const config = STATEFUL_SKILL_SEED_CONFIG[nextSkill.skill];
     if (!config)
         return nextSkill;
     const { absolutePath, relativePath } = resolveSeedStateFilePath(stateDir, config.mode, nextSkill.session_id, config.scope);
-    const existingModeState = await readJsonStateIfExists(absolutePath);
+    const existingModeStateResult = await readJsonStateWithStatus(absolutePath);
+    const existingModeState = existingModeStateResult.state;
     const sameActiveSkill = previousSkill?.skill === nextSkill.skill && previousSkill.active;
     const existingModeMatches = safeString(existingModeState?.mode).trim() === config.mode;
     const existingPhase = safeString(existingModeState?.current_phase).trim();
+    const existingModeTerminal = existingModeMatches
+        && isResettableTerminalModeState(existingModeState, config.mode);
     const preserveExistingModeState = existingModeMatches
         && existingPhase !== ''
+        && !existingModeTerminal
         && (sameActiveSkill
             || (config.mode === 'team' && existingModeState?.active === true));
-    const startedAt = previousSkill?.skill === nextSkill.skill && previousSkill.active
+    const startedAt = previousSkill?.skill === nextSkill.skill && previousSkill.active && !existingModeTerminal
         ? safeString(existingModeState?.started_at).trim() || previousSkill.activated_at || nowIso
         : preserveExistingModeState
             ? safeString(existingModeState?.started_at).trim() || nowIso
@@ -228,20 +451,47 @@ async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previo
     if (config.includeIteration) {
         const defaultIteration = config.mode === 'autopilot' ? 1 : 0;
         const defaultMaxIterations = config.mode === 'autopilot' ? 10 : 50;
-        baseState.iteration = typeof existingModeState?.iteration === 'number' ? existingModeState.iteration : defaultIteration;
-        baseState.max_iterations = typeof existingModeState?.max_iterations === 'number' ? existingModeState.max_iterations : defaultMaxIterations;
+        const reusableModeState = preserveExistingModeState ? existingModeState : null;
+        baseState.iteration = typeof reusableModeState?.iteration === 'number' ? reusableModeState.iteration : defaultIteration;
+        baseState.max_iterations = typeof reusableModeState?.max_iterations === 'number' ? reusableModeState.max_iterations : defaultMaxIterations;
     }
     if (config.mode === 'deep-interview') {
         Object.assign(baseState, buildDeepInterviewConfigStateFields(nextSkill.deep_interview_config));
     }
     if (config.mode === 'autopilot') {
-        const existingState = (existingModeState?.state && typeof existingModeState.state === 'object')
-            ? existingModeState.state
+        const reusableModeState = preserveExistingModeState ? existingModeState : null;
+        const existingStateRaw = (reusableModeState?.state && typeof reusableModeState.state === 'object')
+            ? reusableModeState.state
             : {};
+        const { context_snapshot_path: legacyStateContextSnapshotPath, context_snapshot_recovery: _legacyContextSnapshotRecovery, ...existingState } = existingStateRaw;
         const existingHandoffs = (existingState.handoff_artifacts && typeof existingState.handoff_artifacts === 'object')
             ? existingState.handoff_artifacts
             : {};
-        baseState.review_cycle = typeof existingModeState?.review_cycle === 'number' ? existingModeState.review_cycle : 0;
+        let recoveryReason = 'missing-or-unsafe-legacy-context-snapshot';
+        if (options.activeContinuation === true && !preserveExistingModeState) {
+            if (existingModeStateResult.status === 'missing') {
+                recoveryReason = 'missing-autopilot-mode-state';
+            }
+            else if (existingModeStateResult.status === 'malformed') {
+                recoveryReason = 'malformed-autopilot-mode-state';
+            }
+            else if (existingModeMatches && existingPhase === '') {
+                recoveryReason = 'nonpreservable-autopilot-mode-state-missing-current-phase';
+            }
+        }
+        const existingContextSnapshotPath = await findReusableAutopilotContextSnapshotPath(sourceCwd, [
+            { value: existingHandoffs.context_snapshot },
+            { value: existingHandoffs.context_snapshot_path, kind: 'legacy' },
+            { value: legacyStateContextSnapshotPath, kind: 'legacy' },
+            { value: reusableModeState?.context_snapshot_path, kind: 'legacy' },
+        ]);
+        const contextSnapshot = await ensureAutopilotContextSnapshot(sourceCwd, nowIso, activationText || safeString(nextSkill.keyword) || '$autopilot', existingContextSnapshotPath, {
+            allowTaskSnapshotCreation: !(preserveExistingModeState || options.activeContinuation === true),
+            recoveryReason,
+        });
+        const contextSnapshotPath = contextSnapshot.path;
+        baseState.review_cycle = typeof reusableModeState?.review_cycle === 'number' ? reusableModeState.review_cycle : 0;
+        delete baseState.context_snapshot_path;
         baseState.state = {
             ...existingState,
             phase_cycle: Array.isArray(existingState.phase_cycle) ? existingState.phase_cycle : ['deep-interview', 'ralplan', 'ultragoal', 'code-review', 'ultraqa'],
@@ -261,6 +511,13 @@ async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previo
                 code_review: null,
                 ultraqa: null,
                 ...existingHandoffs,
+                context_snapshot_path: contextSnapshotPath,
+                context_snapshot: {
+                    path: contextSnapshotPath,
+                    kind: contextSnapshot.kind,
+                    ...(contextSnapshot.original_task_status ? { original_task_status: contextSnapshot.original_task_status } : {}),
+                    ...(contextSnapshot.recovery ? { recovery: contextSnapshot.recovery } : {}),
+                },
             },
             review_verdict: Object.prototype.hasOwnProperty.call(existingState, 'review_verdict')
                 ? existingState.review_verdict
@@ -271,6 +528,7 @@ async function persistStatefulSkillSeedState(stateDir, nextSkill, nowIso, previo
             return_to_ralplan_reason: Object.prototype.hasOwnProperty.call(existingState, 'return_to_ralplan_reason')
                 ? existingState.return_to_ralplan_reason
                 : null,
+            ...(contextSnapshot.recovery ? { context_snapshot_recovery: contextSnapshot.recovery } : {}),
             deep_interview_gate: (existingState.deep_interview_gate && typeof existingState.deep_interview_gate === 'object')
                 ? existingState.deep_interview_gate
                 : {
@@ -307,7 +565,7 @@ const KEYWORD_MAP = KEYWORD_TRIGGER_DEFINITIONS.map((entry) => ({
     skill: entry.skill,
     priority: entry.priority,
 }));
-const KEYWORDS_REQUIRING_INTENT = new Set(['ralph', 'team', 'stop', 'abort', 'parallel', 'autoresearch', 'ultragoal']);
+const KEYWORDS_REQUIRING_INTENT = new Set(['ralph', 'team', 'stop', 'abort', 'parallel', 'autoresearch', 'ultragoal', 'autopilot']);
 const DEEP_INTERVIEW_ACTIVATION_PATTERNS = [
     /(?:^|[^\w])\$(?:deep-interview)\b/i,
     /\/prompts:deep-interview\b/i,
@@ -379,6 +637,13 @@ const KEYWORD_INTENT_PATTERNS = {
         /\b(?:use|run|start|enable|launch|invoke|activate|resume|continue)\s+(?:the\s+)?ultragoal\b/i,
         /\bultragoal\s+(?:mode|workflow|skill|loop|plan|goals?)\b/i,
     ],
+    autopilot: [
+        /(?:^|[^\w])\$(?:autopilot)\b/i,
+        /^\s*\/autopilot\b/i,
+        /^\s*(?:please\s+)?autopilot(?:\s+(?:this|mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i,
+        /\b(?:use|run|start|enable|launch|invoke|activate|resume|continue)\s+(?:the\s+)?autopilot(?:\s+(?:mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i,
+        /\bautopilot\s+(?:mode|workflow|skill|loop)\b/i,
+    ],
 };
 function hasExplicitPromptsInvocation(text) {
     return /(?:^|\s)\/prompts:[\w.-]+(?=[\s.,!?;:]|$)/i.test(text);
@@ -497,6 +762,13 @@ export function detectPrimaryKeyword(text) {
     const matches = detectKeywords(text);
     return matches.length > 0 ? matches[0] : null;
 }
+function filterMatchesForTeamMode(matches, teamEnabled) {
+    return teamEnabled ? matches : matches.filter((entry) => entry.skill !== 'team');
+}
+function detectPrimaryKeywordForTeamMode(text, teamEnabled) {
+    const matches = filterMatchesForTeamMode(detectKeywords(text), teamEnabled);
+    return matches[0] ?? null;
+}
 function isActiveSkillContinuationPrompt(text) {
     const normalized = text.trim();
     if (!normalized)
@@ -509,13 +781,56 @@ function isNamedActiveSkillContinuationPrompt(text, skill) {
         return false;
     return new RegExp(`^[\\\\/]?\\s*${normalizedSkill}\\b(?:\\s+(?:keep\\s+going|continue|resume))(?:\\s+now)?[.!]?\\s*$`, 'i').test(text.trim());
 }
+function isOmxQuestionAnsweredPrompt(text) {
+    return /^\s*\[omx question answered\]/i.test(text.trim());
+}
 function shouldReusePreviousSkillForContinuation(text, previous) {
     const previousSkill = safeString(previous?.skill).trim();
     if (!previousSkill || previous?.active !== true || !isTrackedWorkflowMode(previousSkill)) {
         return false;
     }
     return isActiveSkillContinuationPrompt(text)
-        || isNamedActiveSkillContinuationPrompt(text, previousSkill);
+        || isNamedActiveSkillContinuationPrompt(text, previousSkill)
+        || ((previousSkill === 'autopilot' || previousSkill === 'deep-interview') && isOmxQuestionAnsweredPrompt(text));
+}
+function isAutopilotSupervisedChildSkill(skill) {
+    return skill === 'code-review'
+        || skill === 'ultraqa'
+        || skill === 'ralplan'
+        || skill === 'ultragoal'
+        || skill === 'deep-interview';
+}
+const AUTOPILOT_SUPERVISED_TRACKED_CHILD_SKILLS = [
+    'deep-interview',
+    'ralplan',
+    'ultragoal',
+    'ultraqa',
+];
+async function reconcileAutopilotSupervisedChildModeStates(cwd, stateDir, sessionId, childSkill, nowIso) {
+    if (!isTrackedWorkflowMode(childSkill))
+        return [];
+    const activeChildModes = [];
+    for (const mode of AUTOPILOT_SUPERVISED_TRACKED_CHILD_SKILLS) {
+        const candidatePaths = [
+            resolveSeedStateFilePath(stateDir, mode, sessionId).absolutePath,
+        ];
+        for (const candidatePath of candidatePaths) {
+            const existing = await readJsonStateIfExists(candidatePath);
+            if (!existing || existing.active !== true || safeString(existing.mode).trim() !== mode)
+                continue;
+            activeChildModes.push(mode);
+            break;
+        }
+    }
+    const transition = await reconcileWorkflowTransition(cwd, childSkill, {
+        action: 'activate',
+        baseStateDir: stateDir,
+        currentModes: activeChildModes,
+        nowIso,
+        sessionId,
+        source: 'autopilot-supervised-child',
+    });
+    return transition.completedPaths;
 }
 function isDeepInterviewRuntimeConfig(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -535,10 +850,12 @@ function resolveContinuationKeywordMatch(text, previous, fallbackMatch) {
     if (!previousSkill || previous?.active !== true || !isTrackedWorkflowMode(previousSkill)) {
         return fallbackMatch;
     }
-    if (parseExplicitSkillInvocations(normalizeWorkflowKeyboardTypos(text)).sawExplicitLikeInvocation) {
+    const markedQuestionAnswerContinuation = (previousSkill === 'autopilot' || previousSkill === 'deep-interview')
+        && isOmxQuestionAnsweredPrompt(text);
+    if (!markedQuestionAnswerContinuation && parseExplicitSkillInvocations(normalizeWorkflowKeyboardTypos(text)).sawExplicitLikeInvocation) {
         return fallbackMatch;
     }
-    if (!shouldReusePreviousSkillForContinuation(text, previous) && !safeString(fallbackMatch?.keyword).trim().startsWith('$')) {
+    if (!markedQuestionAnswerContinuation && !shouldReusePreviousSkillForContinuation(text, previous) && !safeString(fallbackMatch?.keyword).trim().startsWith('$')) {
         return fallbackMatch;
     }
     return {
@@ -584,12 +901,13 @@ export async function recordSkillActivation(input) {
     const previousRoot = await readExistingSkillState(rootStatePath);
     const previousSession = sessionStatePath ? await readExistingSkillState(sessionStatePath) : null;
     const previous = input.sessionId ? previousSession : previousRoot;
-    const match = resolveContinuationKeywordMatch(input.text, previous, detectPrimaryKeyword(input.text));
+    const teamMode = readTeamModeConfig(sourceCwd);
+    const match = resolveContinuationKeywordMatch(input.text, previous, detectPrimaryKeywordForTeamMode(input.text, teamMode.enabled));
     if (!match)
         return null;
     const nowIso = input.nowIso ?? new Date().toISOString();
     const hadDeepInterviewLock = previous?.skill === 'deep-interview' && previous?.input_lock?.active === true;
-    const matches = detectKeywords(input.text);
+    const matches = filterMatchesForTeamMode(detectKeywords(input.text), teamMode.enabled);
     const hasCancelIntent = matches.some((entry) => entry.skill === 'cancel');
     if (hasCancelIntent && hadDeepInterviewLock) {
         const state = {
@@ -619,7 +937,14 @@ export async function recordSkillActivation(input) {
     const sameSkill = previous?.active === true && previous.skill === match.skill;
     const sameKeyword = previous?.keyword?.toLowerCase() === match.keyword.toLowerCase();
     const sameSkillContinuation = sameSkill && shouldReusePreviousSkillForContinuation(input.text, previous);
-    const preserveActivatedAt = sameSkill && (sameKeyword || sameSkillContinuation);
+    const matchedSeedConfig = STATEFUL_SKILL_SEED_CONFIG[match.skill];
+    const matchedModeState = matchedSeedConfig
+        ? await readJsonStateIfExists(resolveSeedStateFilePath(input.stateDir, matchedSeedConfig.mode, input.sessionId, matchedSeedConfig.scope).absolutePath)
+        : null;
+    const matchedModeTerminal = matchedSeedConfig
+        ? isResettableTerminalModeState(matchedModeState, matchedSeedConfig.mode)
+        : false;
+    const preserveActivatedAt = sameSkill && !matchedModeTerminal && (sameKeyword || sameSkillContinuation);
     const previousEntries = listActiveSkills(previous ?? {});
     const previousWorkflowEntries = previousEntries.filter((entry) => (isTrackedWorkflowMode(entry.skill)
         && (!input.sessionId
@@ -627,12 +952,16 @@ export async function recordSkillActivation(input) {
             || safeString(entry.session_id).trim() === safeString(input.sessionId).trim())));
     const isTrackedWorkflowMatch = isTrackedWorkflowMode(match.skill);
     const trackedMatchSkill = isTrackedWorkflowMatch ? match.skill : null;
+    const markedQuestionAnswerContinuation = sameSkill
+        && (match.skill === 'autopilot' || match.skill === 'deep-interview')
+        && isOmxQuestionAnsweredPrompt(input.text);
     const normalizedInputText = isTrackedWorkflowMatch
         ? normalizeWorkflowKeyboardTypos(input.text)
         : input.text;
-    const workflowMatches = isTrackedWorkflowMatch
+    const workflowMatches = isTrackedWorkflowMatch && !markedQuestionAnswerContinuation
         ? parseExplicitSkillInvocations(normalizedInputText).matches
             .map((entry) => entry.skill)
+            .filter((skill) => teamMode.enabled || skill !== 'team')
             .filter(isTrackedWorkflowMode)
         : [];
     const resolvedWorkflowRequest = isTrackedWorkflowMatch
@@ -651,6 +980,49 @@ export async function recordSkillActivation(input) {
     const deepInterviewConfig = willActivateDeepInterview
         ? reusableDeepInterviewConfig ?? resolveDeepInterviewRuntimeConfig({ cwd: sourceCwd, text: input.text })
         : null;
+    if (previous?.active === true && previous.skill === 'autopilot' && isAutopilotSupervisedChildSkill(match.skill)) {
+        const nextState = {
+            ...previous,
+            version: 1,
+            active: true,
+            updated_at: nowIso,
+            source: 'keyword-detector',
+            session_id: input.sessionId ?? previous.session_id,
+            thread_id: input.threadId ?? previous.thread_id,
+            turn_id: input.turnId ?? previous.turn_id,
+            active_skills: listActiveSkills(previous).map((entry) => (entry.skill === 'autopilot'
+                ? {
+                    ...entry,
+                    active: true,
+                    updated_at: nowIso,
+                    session_id: input.sessionId ?? entry.session_id,
+                    thread_id: input.threadId ?? entry.thread_id,
+                    turn_id: input.turnId ?? entry.turn_id,
+                }
+                : entry)),
+            supervised_child_keyword: match.keyword,
+            supervised_child_skill: match.skill,
+        };
+        try {
+            await reconcileAutopilotSupervisedChildModeStates(sourceCwd, input.stateDir, input.sessionId ?? previous.session_id, match.skill, nowIso);
+            await writeSkillActiveStateCopiesForStateDir(input.stateDir, nextState, input.sessionId, selectRootSkillStateCopy(previousRoot, nextState, input.sessionId));
+        }
+        catch (error) {
+            return {
+                ...previous,
+                version: 1,
+                active: true,
+                updated_at: nowIso,
+                source: 'keyword-detector',
+                session_id: input.sessionId ?? previous.session_id,
+                thread_id: input.threadId ?? previous.thread_id,
+                turn_id: input.turnId ?? previous.turn_id,
+                active_skills: listActiveSkills(previous),
+                transition_error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        return nextState;
+    }
     if (isTrackedWorkflowMatch) {
         let nextWorkflowEntries = previousWorkflowEntries.map((entry) => ({ ...entry }));
         const transitionMessages = [];
@@ -676,13 +1048,35 @@ export async function recordSkillActivation(input) {
                 };
             }
             if (decision.autoCompleteModes.length > 0) {
-                const transition = await reconcileWorkflowTransition(sourceCwd, requestedMode, {
-                    action: 'activate',
-                    sessionId: input.sessionId,
-                    source: 'keyword-detector',
-                    baseStateDir: input.stateDir,
-                    currentModes: nextWorkflowEntries.map((entry) => entry.skill),
-                });
+                let transition;
+                try {
+                    transition = await reconcileWorkflowTransition(sourceCwd, requestedMode, {
+                        action: 'activate',
+                        sessionId: input.sessionId,
+                        source: 'keyword-detector',
+                        baseStateDir: input.stateDir,
+                        currentModes: nextWorkflowEntries.map((entry) => entry.skill),
+                    });
+                }
+                catch (error) {
+                    return {
+                        ...(previous ?? {}),
+                        version: 1,
+                        active: previous?.active ?? nextWorkflowEntries.length > 0,
+                        skill: previous?.skill || match.skill,
+                        keyword: previous?.keyword || match.keyword,
+                        phase: previous?.phase || initialWorkflowPhaseForMode(trackedMatchSkill),
+                        activated_at: previous?.activated_at || nowIso,
+                        updated_at: nowIso,
+                        source: 'keyword-detector',
+                        session_id: input.sessionId ?? previous?.session_id,
+                        thread_id: input.threadId ?? previous?.thread_id,
+                        turn_id: input.turnId ?? previous?.turn_id,
+                        active_skills: previousEntries,
+                        ...(previous?.input_lock ? { input_lock: previous.input_lock } : {}),
+                        transition_error: error instanceof Error ? error.message : String(error),
+                    };
+                }
                 if (transition.transitionMessage) {
                     transitionMessages.push(transition.transitionMessage);
                 }
@@ -691,7 +1085,7 @@ export async function recordSkillActivation(input) {
             nextWorkflowEntries = nextWorkflowEntries.filter((entry) => (isTrackedWorkflowMode(entry.skill) && survivingSkills.has(entry.skill)));
             const existingEntry = nextWorkflowEntries.find((entry) => entry.skill === requestedMode);
             if (existingEntry) {
-                existingEntry.phase = requestedMode === match.skill && !sameSkill
+                existingEntry.phase = requestedMode === match.skill && (!sameSkill || matchedModeTerminal)
                     ? initialWorkflowPhaseForMode(requestedMode)
                     : existingEntry.phase;
                 existingEntry.active = true;
@@ -753,7 +1147,7 @@ export async function recordSkillActivation(input) {
                     activated_at: requestedEntry.activated_at || workflowState.activated_at,
                     updated_at: requestedEntry.updated_at || workflowState.updated_at,
                     ...(requestedEntry.skill === 'deep-interview' && deepInterviewConfig ? { deep_interview_config: deepInterviewConfig } : {}),
-                }, nowIso, previous);
+                }, nowIso, previous, input.text, sourceCwd, { activeContinuation: requestedEntry.skill === 'autopilot' && sameSkillContinuation });
                 if (requestedEntry.skill === workflowState.skill) {
                     nextState = {
                         ...workflowState,
@@ -798,7 +1192,7 @@ export async function recordSkillActivation(input) {
         ...(match.skill === 'deep-interview' && deepInterviewConfig ? { deep_interview_config: deepInterviewConfig } : {}),
     };
     try {
-        const nextState = await persistStatefulSkillSeedState(input.stateDir, state, nowIso, previous);
+        const nextState = await persistStatefulSkillSeedState(input.stateDir, state, nowIso, previous, input.text, sourceCwd, { activeContinuation: match.skill === 'autopilot' && sameSkillContinuation });
         nextState.active_skills = buildActiveSkills(nextState);
         await writeSkillActiveStateCopiesForStateDir(input.stateDir, nextState, input.sessionId, selectRootSkillStateCopy(previousRoot, nextState, input.sessionId));
         await persistDeepInterviewModeState(input.stateDir, nextState, nowIso, previous, input);
@@ -914,7 +1308,9 @@ export function applyRalplanGate(keywords, text, options = {}) {
         return { keywords, gateApplied: false, gatedKeywords: [] };
     }
     const planningComplete = isPlanningComplete(readPlanningArtifacts(options.cwd ?? process.cwd()));
-    const consensusComplete = hasDurableRalplanConsensusEvidenceForCwd(options.cwd ?? process.cwd());
+    const consensusComplete = hasDurableRalplanConsensusEvidenceForCwd(options.cwd ?? process.cwd(), {
+        requireNativeSubagents: options.requireNativeSubagents,
+    });
     const shortFollowupBypasses = executionKeywords.filter((keyword) => {
         if (keyword !== 'team' && keyword !== 'ralph')
             return false;