@stanco323/oh-my-claude-code 4.10.3

package/dist/hooks/persistent-mode/index.js

@@ -0,0 +1,1074 @@
+/**
+ * Persistent Mode Hook
+ *
+ * Unified handler for persistent work modes: ultrawork, ralph, and todo-continuation.
+ * This hook intercepts Stop events and enforces work continuation based on:
+ * 1. Active ultrawork mode with pending todos
+ * 2. Active ralph loop (until cancelled via /oh-my-claudecode:cancel)
+ * 3. Any pending todos (general enforcement)
+ *
+ * Priority order: Ralph > Ultrawork > Todo Continuation
+ */
+import { existsSync, readFileSync, unlinkSync, statSync, openSync, readSync, closeSync, mkdirSync } from 'fs';
+import { atomicWriteJsonSync } from '../../lib/atomic-write.js';
+import { join } from 'path';
+import { getHardMaxIterations } from '../../lib/security-config.js';
+import { getClaudeConfigDir, getGlobalOmcConfigCandidates } from '../../utils/paths.js';
+import { readUltraworkState, writeUltraworkState, incrementReinforcement, deactivateUltrawork, getUltraworkPersistenceMessage } from '../ultrawork/index.js';
+import { resolveToWorktreeRoot, resolveSessionStatePath, resolveStatePath, getOmcRoot } from '../../lib/worktree-paths.js';
+import { readModeState } from '../../lib/mode-state-io.js';
+import { readRalphState, writeRalphState, incrementRalphIteration, clearRalphState, getPrdCompletionStatus, getRalphContext, readVerificationState, startVerification, recordArchitectFeedback, getArchitectVerificationPrompt, getArchitectRejectionContinuationPrompt, detectArchitectApproval, detectArchitectRejection, clearVerificationState, } from '../ralph/index.js';
+import { checkIncompleteTodos, getNextPendingTodo, isUserAbort, isContextLimitStop, isRateLimitStop, isExplicitCancelCommand, isAuthenticationError } from '../todo-continuation/index.js';
+import { TODO_CONTINUATION_PROMPT } from '../../installer/hooks.js';
+import { isAutopilotActive } from '../autopilot/index.js';
+import { checkAutopilot } from '../autopilot/enforcement.js';
+import { readTeamPipelineState } from '../team-pipeline/state.js';
+import { getActiveAgentSnapshot } from '../subagent-tracker/index.js';
+/** Maximum todo-continuation attempts before giving up (prevents infinite loops) */
+const MAX_TODO_CONTINUATION_ATTEMPTS = 5;
+const CANCEL_SIGNAL_TTL_MS = 30_000;
+/** Track todo-continuation attempts per session to prevent infinite loops */
+const todoContinuationAttempts = new Map();
+export function shouldWriteStateBack(statePath) {
+    return Boolean(statePath && existsSync(statePath));
+}
+/**
+ * Check whether this session is in an explicit cancel window.
+ * Used to prevent stop-hook re-enforcement races during /cancel.
+ */
+function isSessionCancelInProgress(directory, sessionId) {
+    if (!sessionId)
+        return false;
+    let cancelSignalPath;
+    try {
+        cancelSignalPath = resolveSessionStatePath('cancel-signal', sessionId, directory);
+    }
+    catch {
+        return false;
+    }
+    if (!existsSync(cancelSignalPath)) {
+        return false;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(cancelSignalPath, 'utf-8'));
+        const now = Date.now();
+        const expiresAt = raw.expires_at ? new Date(raw.expires_at).getTime() : NaN;
+        const requestedAt = raw.requested_at ? new Date(raw.requested_at).getTime() : NaN;
+        const fallbackExpiry = Number.isFinite(requestedAt) ? requestedAt + CANCEL_SIGNAL_TTL_MS : NaN;
+        const effectiveExpiry = Number.isFinite(expiresAt) ? expiresAt : fallbackExpiry;
+        if (!Number.isFinite(effectiveExpiry) || effectiveExpiry <= now) {
+            unlinkSync(cancelSignalPath);
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read last tool error from state directory.
+ * Returns null if file doesn't exist or error is stale (>60 seconds old).
+ */
+export function readLastToolError(directory) {
+    const stateDir = join(getOmcRoot(directory), 'state');
+    const errorPath = join(stateDir, 'last-tool-error.json');
+    try {
+        if (!existsSync(errorPath)) {
+            return null;
+        }
+        const content = readFileSync(errorPath, 'utf-8');
+        const toolError = JSON.parse(content);
+        if (!toolError || !toolError.timestamp) {
+            return null;
+        }
+        // Check staleness - errors older than 60 seconds are ignored
+        const parsedTime = new Date(toolError.timestamp).getTime();
+        if (!Number.isFinite(parsedTime)) {
+            return null;
+        }
+        const age = Date.now() - parsedTime;
+        if (age > 60000) {
+            return null;
+        }
+        return toolError;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Clear tool error state file atomically.
+ */
+export function clearToolErrorState(directory) {
+    const stateDir = join(getOmcRoot(directory), 'state');
+    const errorPath = join(stateDir, 'last-tool-error.json');
+    try {
+        if (existsSync(errorPath)) {
+            unlinkSync(errorPath);
+        }
+    }
+    catch {
+        // Ignore errors - file may have been removed already
+    }
+}
+/**
+ * Generate retry guidance message for tool errors.
+ * After 5+ retries, suggests alternative approaches.
+ */
+export function getToolErrorRetryGuidance(toolError) {
+    if (!toolError) {
+        return '';
+    }
+    const retryCount = toolError.retry_count || 1;
+    const toolName = toolError.tool_name || 'unknown';
+    const error = toolError.error || 'Unknown error';
+    if (retryCount >= 5) {
+        return `[TOOL ERROR - ALTERNATIVE APPROACH NEEDED]
+The "${toolName}" operation has failed ${retryCount} times.
+
+STOP RETRYING THE SAME APPROACH. Instead:
+1. Try a completely different command or approach
+2. Check if the environment/dependencies are correct
+3. Consider breaking down the task differently
+4. If stuck, ask the user for guidance
+
+`;
+    }
+    return `[TOOL ERROR - RETRY REQUIRED]
+The previous "${toolName}" operation failed.
+
+Error: ${error}
+
+REQUIRED ACTIONS:
+1. Analyze why the command failed
+2. Fix the issue (wrong path? permission? syntax? missing dependency?)
+3. RETRY the operation with corrected parameters
+4. Continue with your original task after success
+
+Do NOT skip this step. Do NOT move on without fixing the error.
+
+`;
+}
+/**
+ * Get or increment todo-continuation attempt counter
+ */
+function trackTodoContinuationAttempt(sessionId) {
+    if (todoContinuationAttempts.size > 200)
+        todoContinuationAttempts.clear();
+    const current = todoContinuationAttempts.get(sessionId) || 0;
+    const next = current + 1;
+    todoContinuationAttempts.set(sessionId, next);
+    return next;
+}
+/**
+ * Reset todo-continuation attempt counter (call when todos actually change)
+ */
+export function resetTodoContinuationAttempts(sessionId) {
+    todoContinuationAttempts.delete(sessionId);
+}
+/**
+ * Read the session-idle notification cooldown in seconds from global OMC config.
+ * Default: 60 seconds. 0 = disabled (no cooldown).
+ */
+export function getIdleNotificationCooldownSeconds() {
+    for (const configPath of getGlobalOmcConfigCandidates('config.json')) {
+        try {
+            if (!existsSync(configPath))
+                continue;
+            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+            const cooldown = config?.notificationCooldown;
+            const val = cooldown?.sessionIdleSeconds;
+            if (typeof val === 'number' && Number.isFinite(val))
+                return Math.max(0, val);
+            return 60;
+        }
+        catch {
+            return 60;
+        }
+    }
+    return 60;
+}
+function getIdleNotificationCooldownPath(stateDir, sessionId) {
+    // Keep session segments filesystem-safe; fall back to legacy global path otherwise.
+    if (sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId)) {
+        return join(stateDir, 'sessions', sessionId, 'idle-notif-cooldown.json');
+    }
+    return join(stateDir, 'idle-notif-cooldown.json');
+}
+/**
+ * Check whether the session-idle notification cooldown has elapsed.
+ * Returns true if the notification should be sent.
+ */
+export function shouldSendIdleNotification(stateDir, sessionId) {
+    const cooldownSecs = getIdleNotificationCooldownSeconds();
+    if (cooldownSecs === 0)
+        return true; // cooldown disabled
+    const cooldownPath = getIdleNotificationCooldownPath(stateDir, sessionId);
+    try {
+        if (!existsSync(cooldownPath))
+            return true;
+        const data = JSON.parse(readFileSync(cooldownPath, 'utf-8'));
+        if (data?.lastSentAt && typeof data.lastSentAt === 'string') {
+            const elapsed = (Date.now() - new Date(data.lastSentAt).getTime()) / 1000;
+            if (Number.isFinite(elapsed) && elapsed < cooldownSecs)
+                return false;
+        }
+    }
+    catch {
+        // ignore — treat as no cooldown file
+    }
+    return true;
+}
+/**
+ * Record that the session-idle notification was sent at the current timestamp.
+ */
+export function recordIdleNotificationSent(stateDir, sessionId) {
+    const cooldownPath = getIdleNotificationCooldownPath(stateDir, sessionId);
+    try {
+        atomicWriteJsonSync(cooldownPath, { lastSentAt: new Date().toISOString() });
+    }
+    catch {
+        // ignore write errors
+    }
+}
+/** Max bytes to read from the tail of a transcript for architect approval detection. */
+const TRANSCRIPT_TAIL_BYTES = 32 * 1024; // 32 KB
+const CRITICAL_CONTEXT_STOP_PERCENT = 95;
+/**
+ * Read the tail of a potentially large transcript file.
+ * Architect approval/rejection markers appear near the end of the conversation,
+ * so reading only the last N bytes avoids loading megabyte-sized transcripts.
+ */
+function readTranscriptTail(transcriptPath) {
+    const size = statSync(transcriptPath).size;
+    if (size <= TRANSCRIPT_TAIL_BYTES) {
+        return readFileSync(transcriptPath, 'utf-8');
+    }
+    const fd = openSync(transcriptPath, 'r');
+    try {
+        const offset = size - TRANSCRIPT_TAIL_BYTES;
+        const buf = Buffer.allocUnsafe(TRANSCRIPT_TAIL_BYTES);
+        const bytesRead = readSync(fd, buf, 0, TRANSCRIPT_TAIL_BYTES, offset);
+        return buf.subarray(0, bytesRead).toString('utf-8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function estimateTranscriptContextPercent(transcriptPath) {
+    if (!transcriptPath || !existsSync(transcriptPath)) {
+        return 0;
+    }
+    try {
+        const content = readTranscriptTail(transcriptPath);
+        const windowMatches = [...content.matchAll(/"context_window"\s{0,5}:\s{0,5}(\d+)/g)];
+        const inputMatches = [...content.matchAll(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g)];
+        const lastWindow = windowMatches.at(-1)?.[1];
+        const lastInput = inputMatches.at(-1)?.[1];
+        if (!lastWindow || !lastInput) {
+            return 0;
+        }
+        const contextWindow = parseInt(lastWindow, 10);
+        const inputTokens = parseInt(lastInput, 10);
+        if (!Number.isFinite(contextWindow) || contextWindow <= 0 || !Number.isFinite(inputTokens)) {
+            return 0;
+        }
+        return Math.round((inputTokens / contextWindow) * 100);
+    }
+    catch {
+        return 0;
+    }
+}
+function isCriticalContextStop(stopContext) {
+    if (isContextLimitStop(stopContext)) {
+        return true;
+    }
+    const transcriptPath = stopContext?.transcript_path ?? stopContext?.transcriptPath;
+    return estimateTranscriptContextPercent(transcriptPath) >= CRITICAL_CONTEXT_STOP_PERCENT;
+}
+function isAwaitingConfirmation(state) {
+    return Boolean(state &&
+        typeof state === 'object' &&
+        state.awaiting_confirmation === true);
+}
+/**
+ * Check for architect approval in session transcript
+ */
+function checkArchitectApprovalInTranscript(sessionId) {
+    const claudeDir = getClaudeConfigDir();
+    const possiblePaths = [
+        join(claudeDir, 'sessions', sessionId, 'transcript.md'),
+        join(claudeDir, 'sessions', sessionId, 'messages.json'),
+        join(claudeDir, 'transcripts', `${sessionId}.md`)
+    ];
+    for (const transcriptPath of possiblePaths) {
+        if (existsSync(transcriptPath)) {
+            try {
+                const content = readTranscriptTail(transcriptPath);
+                if (detectArchitectApproval(content)) {
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check for architect rejection in session transcript
+ */
+function checkArchitectRejectionInTranscript(sessionId) {
+    const claudeDir = getClaudeConfigDir();
+    const possiblePaths = [
+        join(claudeDir, 'sessions', sessionId, 'transcript.md'),
+        join(claudeDir, 'sessions', sessionId, 'messages.json'),
+        join(claudeDir, 'transcripts', `${sessionId}.md`)
+    ];
+    for (const transcriptPath of possiblePaths) {
+        if (existsSync(transcriptPath)) {
+            try {
+                const content = readTranscriptTail(transcriptPath);
+                const result = detectArchitectRejection(content);
+                if (result.rejected) {
+                    return result;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return { rejected: false, feedback: '' };
+}
+/**
+ * Check Ralph Loop state and determine if it should continue
+ * Now includes Architect verification for completion claims
+ */
+async function checkRalphLoop(sessionId, directory, cancelInProgress) {
+    const workingDir = resolveToWorktreeRoot(directory);
+    const state = readRalphState(workingDir, sessionId);
+    const ralphStatePath = sessionId
+        ? resolveSessionStatePath('ralph', sessionId, workingDir)
+        : resolveStatePath('ralph', workingDir);
+    if (!state || !state.active) {
+        return null;
+    }
+    // Strict session isolation: only process state for matching session
+    if (state.session_id !== sessionId) {
+        return null;
+    }
+    if (isAwaitingConfirmation(state)) {
+        return null;
+    }
+    // Explicit cancellation window: never re-arm Ralph internals while cancel is in progress.
+    // Uses cached cancel signal from checkPersistentModes to avoid TOCTOU re-reads.
+    if (cancelInProgress) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // Self-heal linked ultrawork: if ralph is active and marked linked but ultrawork
+    // state is missing, recreate it so stop reinforcement cannot silently disappear.
+    if (state.linked_ultrawork) {
+        const ultraworkState = readUltraworkState(workingDir, sessionId);
+        if (!ultraworkState?.active) {
+            const now = new Date().toISOString();
+            const restoredState = {
+                active: true,
+                started_at: state.started_at || now,
+                original_prompt: state.prompt || 'Ralph loop task',
+                session_id: sessionId,
+                project_path: workingDir,
+                reinforcement_count: 0,
+                last_checked_at: now,
+                linked_to_ralph: true
+            };
+            writeUltraworkState(restoredState, workingDir, sessionId);
+        }
+    }
+    // Check team pipeline state coordination
+    // When team mode is active alongside ralph, respect team phase transitions
+    const teamState = readTeamPipelineState(workingDir, sessionId);
+    if (teamState && teamState.active !== undefined) {
+        const teamPhase = teamState.phase;
+        // If team pipeline reached a terminal state, ralph should also complete
+        if (teamPhase === 'complete') {
+            clearRalphState(workingDir, sessionId);
+            clearVerificationState(workingDir, sessionId);
+            deactivateUltrawork(workingDir, sessionId);
+            return {
+                shouldBlock: false,
+                message: `[RALPH LOOP COMPLETE - TEAM] Team pipeline completed successfully. Ralph loop ending after ${state.iteration} iteration(s).`,
+                mode: 'none'
+            };
+        }
+        if (teamPhase === 'failed') {
+            clearRalphState(workingDir, sessionId);
+            clearVerificationState(workingDir, sessionId);
+            deactivateUltrawork(workingDir, sessionId);
+            return {
+                shouldBlock: false,
+                message: `[RALPH LOOP STOPPED - TEAM FAILED] Team pipeline failed. Ralph loop ending after ${state.iteration} iteration(s).`,
+                mode: 'none'
+            };
+        }
+        if (teamPhase === 'cancelled') {
+            clearRalphState(workingDir, sessionId);
+            clearVerificationState(workingDir, sessionId);
+            deactivateUltrawork(workingDir, sessionId);
+            return {
+                shouldBlock: false,
+                message: `[RALPH LOOP CANCELLED - TEAM] Team pipeline was cancelled. Ralph loop ending after ${state.iteration} iteration(s).`,
+                mode: 'none'
+            };
+        }
+    }
+    // Check for existing verification state (architect verification in progress)
+    const verificationState = readVerificationState(workingDir, sessionId);
+    if (verificationState?.pending) {
+        // Verification is in progress - check for architect's response
+        if (sessionId) {
+            // Check for architect approval
+            if (checkArchitectApprovalInTranscript(sessionId)) {
+                // Architect approved - truly complete
+                // Also deactivate ultrawork if it was active alongside ralph
+                clearVerificationState(workingDir, sessionId);
+                clearRalphState(workingDir, sessionId);
+                deactivateUltrawork(workingDir, sessionId);
+                const criticLabel = verificationState.critic_mode === 'codex'
+                    ? 'Codex critic'
+                    : verificationState.critic_mode === 'critic'
+                        ? 'Critic'
+                        : 'Architect';
+                return {
+                    shouldBlock: false,
+                    message: `[RALPH LOOP VERIFIED COMPLETE] ${criticLabel} verified task completion after ${state.iteration} iteration(s). Excellent work!`,
+                    mode: 'none'
+                };
+            }
+            // Check for architect rejection
+            const rejection = checkArchitectRejectionInTranscript(sessionId);
+            if (rejection.rejected) {
+                // Architect rejected - continue with feedback
+                recordArchitectFeedback(workingDir, false, rejection.feedback, sessionId);
+                const updatedVerification = readVerificationState(workingDir, sessionId);
+                if (updatedVerification) {
+                    const continuationPrompt = getArchitectRejectionContinuationPrompt(updatedVerification);
+                    return {
+                        shouldBlock: true,
+                        message: continuationPrompt,
+                        mode: 'ralph',
+                        metadata: {
+                            iteration: state.iteration,
+                            maxIterations: state.max_iterations
+                        }
+                    };
+                }
+            }
+        }
+        // Verification still pending - remind to run the selected reviewer
+        // Get current story for story-aware verification
+        const prdInfo = getPrdCompletionStatus(workingDir);
+        const currentStory = prdInfo.nextStory ?? undefined;
+        const verificationPrompt = getArchitectVerificationPrompt(verificationState, currentStory);
+        return {
+            shouldBlock: true,
+            message: verificationPrompt,
+            mode: 'ralph',
+            metadata: {
+                iteration: state.iteration,
+                maxIterations: state.max_iterations
+            }
+        };
+    }
+    // Check for PRD-based completion (all stories have passes: true).
+    // Enter a verification phase instead of clearing Ralph immediately.
+    const prdStatus = getPrdCompletionStatus(workingDir);
+    if (prdStatus.hasPrd && prdStatus.allComplete) {
+        const startedVerification = startVerification(workingDir, `All ${prdStatus.status?.total || 0} PRD stories are marked passes: true.`, state.prompt, state.critic_mode, sessionId);
+        return {
+            shouldBlock: true,
+            message: getArchitectVerificationPrompt(startedVerification),
+            mode: 'ralph',
+            metadata: {
+                iteration: state.iteration,
+                maxIterations: state.max_iterations
+            }
+        };
+    }
+    // Check max iterations (cancel already checked at function entry via cached flag)
+    if (state.iteration >= state.max_iterations) {
+        const hardMax = getHardMaxIterations();
+        if (hardMax > 0 && state.max_iterations >= hardMax) {
+            // Hard limit reached — auto-disable to prevent unbounded execution
+            state.active = false;
+            if (!shouldWriteStateBack(ralphStatePath)) {
+                return {
+                    shouldBlock: false,
+                    message: '',
+                    mode: 'none'
+                };
+            }
+            writeRalphState(workingDir, state, sessionId);
+            return {
+                shouldBlock: true,
+                message: `[RALPH - HARD LIMIT] Reached hard max iterations (${hardMax}). Mode auto-disabled. Restart with /oh-my-claudecode:ralph if needed.`,
+                mode: 'ralph',
+                metadata: { iteration: state.iteration, maxIterations: state.max_iterations }
+            };
+        }
+        // Extend the limit and continue enforcement so user-visible cancellation
+        // remains the only explicit termination path.
+        state.max_iterations += 10;
+        if (!shouldWriteStateBack(ralphStatePath)) {
+            return {
+                shouldBlock: false,
+                message: '',
+                mode: 'none'
+            };
+        }
+        writeRalphState(workingDir, state, sessionId);
+    }
+    // Read tool error before generating message
+    const toolError = readLastToolError(workingDir);
+    const errorGuidance = getToolErrorRetryGuidance(toolError);
+    // Increment and continue
+    const newState = incrementRalphIteration(workingDir, sessionId);
+    if (!newState) {
+        return null;
+    }
+    // Get PRD context for injection
+    const ralphContext = getRalphContext(workingDir);
+    const prdInstruction = prdStatus.hasPrd
+        ? `2. Check prd.json - verify the current story's acceptance criteria are met, then mark it passes: true. Are ALL stories complete?`
+        : `2. Check your todo list - are ALL items marked complete?`;
+    const continuationPrompt = `<ralph-continuation>
+${errorGuidance ? errorGuidance + '\n' : ''}
+[RALPH - ITERATION ${newState.iteration}/${newState.max_iterations}]
+
+The task is NOT complete yet. Continue working.
+${ralphContext}
+CRITICAL INSTRUCTIONS:
+1. Review your progress and the original task
+${prdInstruction}
+3. Continue from where you left off
+4. When FULLY complete (after ${state.critic_mode === 'codex' ? 'Codex critic' : state.critic_mode === 'critic' ? 'Critic' : 'Architect'} verification), run \`/oh-my-claudecode:cancel\` to cleanly exit and clean up state files. If cancel fails, retry with \`/oh-my-claudecode:cancel --force\`.
+5. Do NOT stop until the task is truly done
+
+${newState.prompt ? `Original task: ${newState.prompt}` : ''}
+
+</ralph-continuation>
+
+---
+
+`;
+    return {
+        shouldBlock: true,
+        message: continuationPrompt,
+        mode: 'ralph',
+        metadata: {
+            iteration: newState.iteration,
+            maxIterations: newState.max_iterations,
+            toolError: toolError || undefined
+        }
+    };
+}
+function readStopBreaker(directory, name, sessionId, ttlMs) {
+    const stateDir = sessionId
+        ? join(getOmcRoot(directory), 'state', 'sessions', sessionId)
+        : join(getOmcRoot(directory), 'state');
+    const breakerPath = join(stateDir, `${name}-stop-breaker.json`);
+    try {
+        if (!existsSync(breakerPath))
+            return 0;
+        const raw = JSON.parse(readFileSync(breakerPath, 'utf-8'));
+        if (ttlMs && raw.updated_at) {
+            const updatedAt = new Date(raw.updated_at).getTime();
+            if (Number.isFinite(updatedAt) && Date.now() - updatedAt > ttlMs) {
+                unlinkSync(breakerPath);
+                return 0;
+            }
+        }
+        return typeof raw.count === 'number' ? raw.count : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function writeStopBreaker(directory, name, count, sessionId) {
+    const stateDir = sessionId
+        ? join(getOmcRoot(directory), 'state', 'sessions', sessionId)
+        : join(getOmcRoot(directory), 'state');
+    try {
+        mkdirSync(stateDir, { recursive: true });
+        const breakerPath = join(stateDir, `${name}-stop-breaker.json`);
+        const data = { count, updated_at: new Date().toISOString() };
+        atomicWriteJsonSync(breakerPath, data);
+    }
+    catch {
+        // Ignore write errors — fail-open
+    }
+}
+// ---------------------------------------------------------------------------
+// Team Pipeline enforcement (standalone team mode)
+// ---------------------------------------------------------------------------
+const TEAM_PIPELINE_STOP_BLOCKER_MAX = 20;
+const TEAM_PIPELINE_STOP_BLOCKER_TTL_MS = 5 * 60 * 1000; // 5 min
+/**
+ * Check Team Pipeline state for standalone team mode enforcement.
+ * When team runs WITHOUT ralph, this provides the stop-hook blocking.
+ * When team runs WITH ralph, checkRalphLoop() handles it (higher priority).
+ */
+async function checkTeamPipeline(sessionId, directory, cancelInProgress) {
+    const workingDir = resolveToWorktreeRoot(directory);
+    const teamState = readTeamPipelineState(workingDir, sessionId);
+    if (!teamState) {
+        return null;
+    }
+    if (!teamState.active) {
+        writeStopBreaker(workingDir, 'team-pipeline', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'team'
+        };
+    }
+    // Session isolation: readTeamPipelineState already checks session_id match
+    // and returns null on mismatch (team-pipeline/state.ts:81)
+    // Cancel-in-progress bypass
+    if (cancelInProgress) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'team'
+        };
+    }
+    // Read phase from canonical team-pipeline/current_phase shape first,
+    // then fall back to bridge.ts / legacy stage fields for compatibility.
+    const rawPhase = teamState.phase
+        ?? teamState.current_phase
+        ?? teamState.currentStage
+        ?? teamState.current_stage
+        ?? teamState.stage;
+    if (typeof rawPhase !== 'string') {
+        // Fail-open but still claim mode='team' so bridge.ts defers to this result
+        // instead of running its own team enforcement (which could falsely block).
+        return { shouldBlock: false, message: '', mode: 'team' };
+    }
+    const phase = rawPhase.trim().toLowerCase();
+    // Terminal phases — allow stop
+    if (phase === 'complete' || phase === 'completed' || phase === 'failed' || phase === 'cancelled' || phase === 'canceled' || phase === 'cancel') {
+        writeStopBreaker(workingDir, 'team-pipeline', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'team'
+        };
+    }
+    // Fail-open: only known active phases should block.
+    // Missing, malformed, or unknown phases do not block (safety principle).
+    const KNOWN_ACTIVE_PHASES = new Set(['team-plan', 'team-prd', 'team-exec', 'team-verify', 'team-fix']);
+    if (!KNOWN_ACTIVE_PHASES.has(phase)) {
+        // Still claim mode='team' so bridge.ts defers
+        return { shouldBlock: false, message: '', mode: 'team' };
+    }
+    // Status-level terminal check (bridge.ts format uses `status` field)
+    const rawStatus = teamState.status;
+    const status = typeof rawStatus === 'string' ? rawStatus.trim().toLowerCase() : null;
+    if (status === 'cancelled' || status === 'canceled' || status === 'cancel' || status === 'failed' || status === 'complete' || status === 'completed') {
+        writeStopBreaker(workingDir, 'team-pipeline', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'team'
+        };
+    }
+    // Cancel requested on team state — allow stop
+    if (teamState.cancel?.requested) {
+        writeStopBreaker(workingDir, 'team-pipeline', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'team'
+        };
+    }
+    // Circuit breaker
+    const breakerCount = readStopBreaker(workingDir, 'team-pipeline', sessionId, TEAM_PIPELINE_STOP_BLOCKER_TTL_MS) + 1;
+    if (breakerCount > TEAM_PIPELINE_STOP_BLOCKER_MAX) {
+        writeStopBreaker(workingDir, 'team-pipeline', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: `[TEAM PIPELINE CIRCUIT BREAKER] Stop enforcement exceeded ${TEAM_PIPELINE_STOP_BLOCKER_MAX} reinforcements. Allowing stop to prevent infinite blocking.`,
+            mode: 'team'
+        };
+    }
+    writeStopBreaker(workingDir, 'team-pipeline', breakerCount, sessionId);
+    return {
+        shouldBlock: true,
+        message: `<team-pipeline-continuation>
+
+[TEAM PIPELINE - PHASE: ${phase.toUpperCase()} | REINFORCEMENT ${breakerCount}/${TEAM_PIPELINE_STOP_BLOCKER_MAX}]
+
+The team pipeline is active in phase "${phase}". Continue working on the team workflow.
+Do not stop until the pipeline reaches a terminal state (complete/failed/cancelled).
+When done, run \`/oh-my-claudecode:cancel\` to cleanly exit.
+
+</team-pipeline-continuation>
+
+---
+
+`,
+        mode: 'team',
+        metadata: {
+            phase,
+            tasksCompleted: teamState.execution?.tasks_completed,
+            tasksTotal: teamState.execution?.tasks_total,
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Ralplan enforcement (standalone consensus planning)
+// ---------------------------------------------------------------------------
+const RALPLAN_STOP_BLOCKER_MAX = 30;
+const RALPLAN_STOP_BLOCKER_TTL_MS = 45 * 60 * 1000; // 45 min
+const RALPLAN_ACTIVE_AGENT_RECENCY_WINDOW_MS = 5_000;
+/**
+ * Check Ralplan state for standalone ralplan mode enforcement.
+ * Ralplan state is written by the MCP state_write tool.
+ * Only `active` and `session_id` are used for blocking decisions.
+ */
+async function checkRalplan(sessionId, directory, cancelInProgress) {
+    const workingDir = resolveToWorktreeRoot(directory);
+    const state = readModeState('ralplan', workingDir, sessionId);
+    if (!state || !state.active) {
+        return null;
+    }
+    // Session isolation
+    if (sessionId && state.session_id && state.session_id !== sessionId) {
+        return null;
+    }
+    if (isAwaitingConfirmation(state)) {
+        return null;
+    }
+    // Terminal phase detection — allow stop when ralplan has completed
+    const currentPhase = state.current_phase;
+    if (typeof currentPhase === 'string') {
+        const terminal = ['complete', 'completed', 'failed', 'cancelled', 'done'];
+        if (terminal.includes(currentPhase.toLowerCase())) {
+            writeStopBreaker(workingDir, 'ralplan', 0, sessionId);
+            return { shouldBlock: false, message: '', mode: 'ralplan' };
+        }
+    }
+    // Cancel-in-progress bypass
+    if (cancelInProgress) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'ralplan'
+        };
+    }
+    // Orchestrators are allowed to go idle while delegated work is still active,
+    // but the raw running-agent count can lag behind the real lifecycle because
+    // SubagentStop/post-tool-use bookkeeping lands after the stop event. Only
+    // trust the bypass when the tracker itself was updated recently enough to
+    // look live; otherwise fail closed and keep consensus enforcement active.
+    const activeAgents = getActiveAgentSnapshot(workingDir);
+    const activeAgentStateUpdatedAt = activeAgents.lastUpdatedAt ? new Date(activeAgents.lastUpdatedAt).getTime() : NaN;
+    const hasFreshActiveAgentState = Number.isFinite(activeAgentStateUpdatedAt)
+        && Date.now() - activeAgentStateUpdatedAt <= RALPLAN_ACTIVE_AGENT_RECENCY_WINDOW_MS;
+    if (activeAgents.count > 0 && hasFreshActiveAgentState) {
+        writeStopBreaker(workingDir, 'ralplan', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'ralplan',
+        };
+    }
+    // Circuit breaker
+    const breakerCount = readStopBreaker(workingDir, 'ralplan', sessionId, RALPLAN_STOP_BLOCKER_TTL_MS) + 1;
+    if (breakerCount > RALPLAN_STOP_BLOCKER_MAX) {
+        writeStopBreaker(workingDir, 'ralplan', 0, sessionId);
+        return {
+            shouldBlock: false,
+            message: `[RALPLAN CIRCUIT BREAKER] Stop enforcement exceeded ${RALPLAN_STOP_BLOCKER_MAX} reinforcements. Allowing stop to prevent infinite blocking.`,
+            mode: 'ralplan'
+        };
+    }
+    writeStopBreaker(workingDir, 'ralplan', breakerCount, sessionId);
+    return {
+        shouldBlock: true,
+        message: `<ralplan-continuation>
+
+[RALPLAN - CONSENSUS PLANNING | REINFORCEMENT ${breakerCount}/${RALPLAN_STOP_BLOCKER_MAX}]
+
+The ralplan consensus workflow is active. Continue the Planner/Architect/Critic loop.
+Do not stop until consensus is reached or the workflow completes.
+When done, run \`/oh-my-claudecode:cancel\` to cleanly exit.
+
+</ralplan-continuation>
+
+---
+
+`,
+        mode: 'ralplan',
+    };
+}
+/**
+ * Check Ultrawork state and determine if it should reinforce
+ */
+async function checkUltrawork(sessionId, directory, _hasIncompleteTodos, cancelInProgress) {
+    const workingDir = resolveToWorktreeRoot(directory);
+    const state = readUltraworkState(workingDir, sessionId);
+    if (!state || !state.active) {
+        return null;
+    }
+    // Strict session isolation: only process state for matching session
+    if (state.session_id !== sessionId) {
+        return null;
+    }
+    if (isAwaitingConfirmation(state)) {
+        return null;
+    }
+    // Uses cached cancel signal from checkPersistentModes to avoid TOCTOU re-reads.
+    if (cancelInProgress) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // Reinforce ultrawork mode - ALWAYS continue while active.
+    // This prevents false stops from bash errors, transient failures, etc.
+    const newState = incrementReinforcement(workingDir, sessionId);
+    if (!newState) {
+        return null;
+    }
+    const message = getUltraworkPersistenceMessage(newState);
+    return {
+        shouldBlock: true,
+        message,
+        mode: 'ultrawork',
+        metadata: {
+            reinforcementCount: newState.reinforcement_count
+        }
+    };
+}
+/**
+ * Check for incomplete todos (baseline enforcement)
+ * Includes max-attempts counter to prevent infinite loops when agent is stuck
+ */
+async function _checkTodoContinuation(sessionId, directory) {
+    const result = await checkIncompleteTodos(sessionId, directory);
+    if (result.count === 0) {
+        // Reset counter when todos are cleared
+        if (sessionId) {
+            resetTodoContinuationAttempts(sessionId);
+        }
+        return null;
+    }
+    // Track continuation attempts to prevent infinite loops
+    const attemptCount = sessionId ? trackTodoContinuationAttempt(sessionId) : 1;
+    // Use dynamic label based on source (Tasks vs todos)
+    const _sourceLabel = result.source === 'task' ? 'Tasks' : 'todos';
+    const sourceLabelLower = result.source === 'task' ? 'tasks' : 'todos';
+    if (attemptCount > MAX_TODO_CONTINUATION_ATTEMPTS) {
+        // Too many attempts - agent appears stuck, allow stop but warn
+        return {
+            shouldBlock: false,
+            message: `[TODO CONTINUATION LIMIT] Attempted ${MAX_TODO_CONTINUATION_ATTEMPTS} continuations without progress. ${result.count} ${sourceLabelLower} remain incomplete. Consider reviewing the stuck ${sourceLabelLower} or asking the user for guidance.`,
+            mode: 'none',
+            metadata: {
+                todoCount: result.count,
+                todoContinuationAttempts: attemptCount
+            }
+        };
+    }
+    const nextTodo = getNextPendingTodo(result);
+    const nextTaskInfo = nextTodo
+        ? `\n\nNext ${result.source === 'task' ? 'Task' : 'todo'}: "${nextTodo.content}" (${nextTodo.status})`
+        : '';
+    const attemptInfo = attemptCount > 1
+        ? `\n[Continuation attempt ${attemptCount}/${MAX_TODO_CONTINUATION_ATTEMPTS}]`
+        : '';
+    const message = `<todo-continuation>
+
+${TODO_CONTINUATION_PROMPT}
+
+[Status: ${result.count} of ${result.total} ${sourceLabelLower} remaining]${nextTaskInfo}${attemptInfo}
+
+</todo-continuation>
+
+---
+
+`;
+    return {
+        shouldBlock: true,
+        message,
+        mode: 'todo-continuation',
+        metadata: {
+            todoCount: result.count,
+            todoContinuationAttempts: attemptCount
+        }
+    };
+}
+/**
+ * Main persistent mode checker
+ * Checks all persistent modes in priority order and returns appropriate action
+ */
+export async function checkPersistentModes(sessionId, directory, stopContext // NEW: from todo-continuation types
+) {
+    const workingDir = resolveToWorktreeRoot(directory);
+    // CRITICAL: Never block context-limit/critical-context stops.
+    // Blocking these causes a deadlock where Claude Code cannot compact or exit.
+    // See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/213
+    if (isCriticalContextStop(stopContext)) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // Explicit /cancel paths must always bypass continuation re-enforcement.
+    // This prevents cancel races where stop-hook persistence can re-arm Ralph/Ultrawork
+    // (self-heal, max-iteration extension, reinforcement) during shutdown.
+    if (isExplicitCancelCommand(stopContext)) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // Session-scoped cancel signal from state_clear during /cancel flow.
+    // Cache once and pass to sub-functions to avoid TOCTOU re-reads (issue #1058).
+    const cancelInProgress = isSessionCancelInProgress(workingDir, sessionId);
+    if (cancelInProgress) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // Check for user abort - skip all continuation enforcement
+    if (isUserAbort(stopContext)) {
+        return {
+            shouldBlock: false,
+            message: '',
+            mode: 'none'
+        };
+    }
+    // CRITICAL: Never block rate-limit stops.
+    // When the API returns 429 / quota-exhausted, Claude Code stops the session.
+    // Blocking these stops creates an infinite retry loop: the hook injects a
+    // continuation prompt → Claude hits the rate limit again → stops again → loops.
+    // Fix for: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/777
+    if (isRateLimitStop(stopContext)) {
+        return {
+            shouldBlock: false,
+            message: '[RALPH PAUSED - RATE LIMITED] API rate limit detected. Ralph loop paused until the rate limit resets. Resume manually once the limit clears.',
+            mode: 'none'
+        };
+    }
+    // CRITICAL: Never block authentication/authorization failures.
+    // Expired OAuth/unauthorized responses can otherwise trigger an infinite
+    // continuation loop (especially with staged Team mode prompts).
+    // Fix for: issue #1308
+    if (isAuthenticationError(stopContext)) {
+        return {
+            shouldBlock: false,
+            message: '[PERSISTENT MODE PAUSED - AUTHENTICATION ERROR] Authentication failure detected (for example 401/403 or expired OAuth token). Re-authenticate, then resume manually.',
+            mode: 'none'
+        };
+    }
+    // First, check for incomplete todos (we need this info for ultrawork)
+    // Note: stopContext already checked above, but pass it for consistency
+    const todoResult = await checkIncompleteTodos(sessionId, workingDir, stopContext);
+    const hasIncompleteTodos = todoResult.count > 0;
+    // Priority 1: Ralph (explicit loop mode)
+    const ralphResult = await checkRalphLoop(sessionId, workingDir, cancelInProgress);
+    if (ralphResult) {
+        return ralphResult;
+    }
+    // Priority 1.5: Autopilot (full orchestration mode - higher than ultrawork, lower than ralph)
+    if (isAutopilotActive(workingDir, sessionId)) {
+        const autopilotResult = await checkAutopilot(sessionId, workingDir);
+        if (autopilotResult?.shouldBlock) {
+            return {
+                shouldBlock: true,
+                message: autopilotResult.message,
+                mode: 'autopilot',
+                metadata: {
+                    iteration: autopilotResult.metadata?.iteration,
+                    maxIterations: autopilotResult.metadata?.maxIterations,
+                    phase: autopilotResult.phase,
+                    tasksCompleted: autopilotResult.metadata?.tasksCompleted,
+                    tasksTotal: autopilotResult.metadata?.tasksTotal,
+                    toolError: autopilotResult.metadata?.toolError
+                }
+            };
+        }
+    }
+    // Priority 1.7: Team Pipeline (standalone team mode)
+    // When team runs without ralph, this provides stop-hook blocking.
+    // When team runs with ralph, checkRalphLoop() handles it (Priority 1).
+    // Return ANY non-null result (including circuit breaker shouldBlock=false with message).
+    const teamResult = await checkTeamPipeline(sessionId, workingDir, cancelInProgress);
+    if (teamResult) {
+        return teamResult;
+    }
+    // Priority 1.8: Ralplan (standalone consensus planning)
+    // Ralplan consensus loops (Planner/Architect/Critic) need hard-blocking.
+    // When ralplan runs under ralph, checkRalphLoop() handles it (Priority 1).
+    // Return ANY non-null result (including circuit breaker shouldBlock=false with message).
+    const ralplanResult = await checkRalplan(sessionId, workingDir, cancelInProgress);
+    if (ralplanResult) {
+        return ralplanResult;
+    }
+    // Priority 2: Ultrawork Mode (performance mode with persistence)
+    const ultraworkResult = await checkUltrawork(sessionId, workingDir, hasIncompleteTodos, cancelInProgress);
+    if (ultraworkResult?.shouldBlock) {
+        return ultraworkResult;
+    }
+    // Priority 3: Skill Active State (issue #1033)
+    // Skills like code-review, plan, tdd, etc. write skill-active-state.json
+    // when invoked via the Skill tool. This prevents premature stops mid-skill.
+    try {
+        const { checkSkillActiveState } = await import('../skill-state/index.js');
+        const skillResult = checkSkillActiveState(workingDir, sessionId);
+        if (skillResult.shouldBlock) {
+            return {
+                shouldBlock: true,
+                message: skillResult.message,
+                mode: 'ultrawork', // Reuse ultrawork mode type for compatibility
+                metadata: {
+                    phase: `skill:${skillResult.skillName || 'unknown'}`,
+                }
+            };
+        }
+    }
+    catch {
+        // If skill-state module is unavailable, skip gracefully
+    }
+    // No blocking needed
+    return {
+        shouldBlock: false,
+        message: '',
+        mode: 'none'
+    };
+}
+/**
+ * Create hook output for Claude Code.
+ * Returns `continue: false` when `shouldBlock` is true to hard-block the stop event.
+ * Returns `continue: true` for terminal states, escape hatches, and errors.
+ */
+export function createHookOutput(result) {
+    return {
+        continue: !result.shouldBlock,
+        message: result.message || undefined
+    };
+}
+//# sourceMappingURL=index.js.map