claudecode-omc 4.8.2 → 4.8.3

package/scripts/persistent-mode.cjs

@@ -14,6 +14,7 @@ const {
   writeFileSync,
   readdirSync,
   mkdirSync,
+  unlinkSync,
 } = require("fs");
 const { join, dirname, resolve, normalize } = require("path");
 const { homedir } = require("os");
@@ -130,6 +131,35 @@ async function sendStopNotification(modeName, stateData, sessionId, directory) {
  */
 const STALE_STATE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
 
+// Stop breaker constants for first-class mode enforcement
+const TEAM_PIPELINE_STOP_BLOCKER_MAX = 20;
+const TEAM_PIPELINE_STOP_BLOCKER_TTL_MS = 5 * 60 * 1000; // 5 min
+const RALPLAN_STOP_BLOCKER_MAX = 30;
+const RALPLAN_STOP_BLOCKER_TTL_MS = 45 * 60 * 1000; // 45 min
+const TEAM_TERMINAL_PHASES = new Set([
+  "completed",
+  "complete",
+  "failed",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "terminated",
+  "done",
+]);
+const TEAM_ACTIVE_PHASES = new Set([
+  "team-plan",
+  "team-prd",
+  "team-exec",
+  "team-verify",
+  "team-fix",
+  "planning",
+  "executing",
+  "verify",
+  "verification",
+  "fix",
+  "fixing",
+]);
+
 /**
  * Check if a state is stale based on its timestamps.
  * A state is considered stale if it hasn't been updated recently.
@@ -150,6 +180,63 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+function normalizeTeamPhase(state) {
+  if (!state || typeof state !== "object") return null;
+
+  const rawPhase = state.current_phase ?? state.phase ?? state.stage;
+  if (typeof rawPhase !== "string") return null;
+
+  const phase = rawPhase.trim().toLowerCase();
+  if (!phase || TEAM_TERMINAL_PHASES.has(phase)) return null;
+  return TEAM_ACTIVE_PHASES.has(phase) ? phase : null;
+}
+
+function getSafeReinforcementCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? Math.floor(value)
+    : 0;
+}
+
+// ---------------------------------------------------------------------------
+// Stop Breaker helpers (shared by team pipeline and ralplan)
+// ---------------------------------------------------------------------------
+
+function readStopBreaker(stateDir, name, sessionId, ttlMs) {
+  const dir = sessionId
+    ? join(stateDir, "sessions", sessionId)
+    : stateDir;
+  const breakerPath = join(dir, `${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(stateDir, name, count, sessionId) {
+  const dir = sessionId
+    ? join(stateDir, "sessions", sessionId)
+    : stateDir;
+
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const breakerPath = join(dir, `${name}-stop-breaker.json`);
+    writeJsonFile(breakerPath, { count, updated_at: new Date().toISOString() });
+  } catch {
+    // Fail-open
+  }
+}
+
 /**
  * Check if a cancel signal is in progress for the session.
  * Cancel signals are written by state_clear and expire after 30 seconds.
@@ -255,7 +342,26 @@ function readStateFileWithSession(stateDir, filename, sessionId) {
     if (state) {
       return { state, path: sessionPath, isGlobal: false };
     }
-    // Session path not found — do NOT fall back to legacy
+    // Session path not found — fallback: scan ALL session dirs for a state
+    // whose session_id matches ours (handles path mismatches)
+    try {
+      const allSessionsDir = join(stateDir, 'sessions');
+      if (existsSync(allSessionsDir)) {
+        const dirs = readdirSync(allSessionsDir).filter(d => /^[a-zA-Z0-9]/.test(d));
+        for (const dir of dirs) {
+          const candidatePath = join(allSessionsDir, dir, filename);
+          const candidateState = readJsonFile(candidatePath);
+          if (candidateState && candidateState.session_id === sessionId) {
+            return { state: candidateState, path: candidatePath, isGlobal: false };
+          }
+        }
+      }
+    } catch { /* ignore scan errors */ }
+    // Also check legacy path if its session_id matches
+    const legacyResult = readStateFile(stateDir, filename);
+    if (legacyResult.state && legacyResult.state.session_id === sessionId) {
+      return legacyResult;
+    }
     return { state: null, path: null, isGlobal: false };
   }
   // No sessionId: fall back to legacy path (backward compat)
@@ -355,7 +461,15 @@ function countIncompleteTodos(sessionId, projectDir) {
  * See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/213
  */
 function isContextLimitStop(data) {
-  const reason = (data.stop_reason || data.stopReason || "").toLowerCase();
+  const reasons = [
+    data.stop_reason,
+    data.stopReason,
+    data.end_turn_reason,
+    data.endTurnReason,
+    data.reason,
+  ]
+    .filter((value) => typeof value === "string" && value.trim().length > 0)
+    .map((value) => value.toLowerCase().replace(/[\s-]+/g, "_"));
 
   const contextPatterns = [
     "context_limit",
@@ -369,20 +483,27 @@ function isContextLimitStop(data) {
     "input_too_long",
   ];
 
-  if (contextPatterns.some((p) => reason.includes(p))) {
-    return true;
-  }
+  return reasons.some((reason) => contextPatterns.some((p) => reason.includes(p)));
+}
 
-  const endTurnReason = (
-    data.end_turn_reason ||
-    data.endTurnReason ||
-    ""
-  ).toLowerCase();
-  if (endTurnReason && contextPatterns.some((p) => endTurnReason.includes(p))) {
-    return true;
-  }
+const CRITICAL_CONTEXT_STOP_PERCENT = 95;
 
-  return false;
+function estimateContextPercent(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return 0;
+
+  try {
+    const content = readFileSync(transcriptPath, "utf-8");
+    const windowMatch = content.match(/"context_window"\s{0,5}:\s{0,5}(\d+)/g);
+    const inputMatch = content.match(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g);
+    if (!windowMatch || !inputMatch) return 0;
+
+    const lastWindow = parseInt(windowMatch[windowMatch.length - 1].match(/(\d+)/)[1], 10);
+    const lastInput = parseInt(inputMatch[inputMatch.length - 1].match(/(\d+)/)[1], 10);
+    if (!Number.isFinite(lastWindow) || lastWindow <= 0 || !Number.isFinite(lastInput)) return 0;
+    return Math.round((lastInput / lastWindow) * 100);
+  } catch {
+    return 0;
+  }
 }
 
 /**
@@ -460,6 +581,12 @@ async function main() {
       return;
     }
 
+    const criticalTranscriptPath = data.transcript_path || data.transcriptPath || "";
+    if (estimateContextPercent(criticalTranscriptPath) >= CRITICAL_CONTEXT_STOP_PERCENT) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Respect user abort (Ctrl+C, cancel)
     if (isUserAbort(data)) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
@@ -480,6 +607,7 @@ async function main() {
     const ultraqa = readStateFileWithSession(stateDir, "ultraqa-state.json", sessionId);
     const pipeline = readStateFileWithSession(stateDir, "pipeline-state.json", sessionId);
     const team = readStateFileWithSession(stateDir, "team-state.json", sessionId);
+    const ralplan = readStateFileWithSession(stateDir, "ralplan-state.json", sessionId);
     const omcTeams = readStateFileWithSession(stateDir, "omc-teams-state.json", sessionId);
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
@@ -492,7 +620,9 @@ async function main() {
     const totalIncomplete = taskCount + todoCount;
 
     // Check if cancel is in progress - if so, allow stop immediately
-    if (isSessionCancelInProgress(stateDir, sessionId)) {
+    // Cache the result to pass to sub-checks (avoids TOCTOU re-reads, issue #1058)
+    const cancelInProgress = isSessionCancelInProgress(stateDir, sessionId);
+    if (cancelInProgress) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
@@ -513,7 +643,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
-            decision: "block",
+            continue: false, decision: "block",
             reason: `[RALPH LOOP - ITERATION ${iteration + 1}/${maxIter}] Work is NOT done. Continue working.\nWhen FULLY complete (after Architect verification), run /oh-my-claudecode:cancel to cleanly exit ralph mode and clean up all state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.\n${ralph.state.prompt ? `Task: ${ralph.state.prompt}` : ""}`,
           }),
         );
@@ -536,7 +666,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[AUTOPILOT - Phase: ${phase}] Autopilot not complete. Continue working. When all phases are complete, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -545,6 +675,102 @@ async function main() {
       }
     }
 
+    // Priority 2.5: Team Pipeline (standalone team mode — first-class enforcement)
+    // When team runs WITHOUT ralph, this provides stop-hook blocking.
+    // When team runs WITH ralph, checkRalphLoop (Priority 1) handles it.
+    let teamPipelineHandled = false;
+    if (team.state && isSessionMatch(team.state, sessionId)) {
+      if (!team.state.active) {
+        // Inactive — reset breaker, allow stop, mark as handled
+        writeStopBreaker(stateDir, "team-pipeline", 0, sessionId);
+        teamPipelineHandled = true;
+      } else if (!isStaleState(team.state)) {
+        teamPipelineHandled = true;
+
+        // Cancel-in-progress bypass (TOCTOU defense, issue #1058)
+        if (!cancelInProgress) {
+          // Read phase: canonical field priority matching bridge code
+          const rawPhase = team.state.phase
+            ?? team.state.current_phase
+            ?? team.state.currentStage
+            ?? team.state.current_stage
+            ?? team.state.stage;
+
+          if (typeof rawPhase !== "string") {
+            // No valid phase — fail-open (don't block)
+          } else {
+            const phase = rawPhase.trim().toLowerCase();
+
+            if (TEAM_TERMINAL_PHASES.has(phase) || phase === "cancel") {
+              // Terminal — reset breaker, allow stop
+              writeStopBreaker(stateDir, "team-pipeline", 0, sessionId);
+            } else if (!TEAM_ACTIVE_PHASES.has(phase)) {
+              // Unknown phase — fail-open (don't block)
+            } else {
+              // Status-level terminal check
+              const rawStatus = team.state.status;
+              const status = typeof rawStatus === "string" ? rawStatus.trim().toLowerCase() : null;
+              if (status && TEAM_TERMINAL_PHASES.has(status)) {
+                writeStopBreaker(stateDir, "team-pipeline", 0, sessionId);
+              } else if (team.state.cancel?.requested) {
+                // Cancel requested — allow stop
+                writeStopBreaker(stateDir, "team-pipeline", 0, sessionId);
+              } else {
+                // Active phase — block with circuit breaker
+                const breakerCount = readStopBreaker(stateDir, "team-pipeline", sessionId, TEAM_PIPELINE_STOP_BLOCKER_TTL_MS) + 1;
+                if (breakerCount > TEAM_PIPELINE_STOP_BLOCKER_MAX) {
+                  writeStopBreaker(stateDir, "team-pipeline", 0, sessionId);
+                  // Circuit breaker tripped — allow stop
+                } else {
+                  writeStopBreaker(stateDir, "team-pipeline", breakerCount, sessionId);
+                  sendStopNotification("team", team.state, sessionId, directory).catch(() => {});
+
+                  console.log(JSON.stringify({
+                    continue: false, decision: "block",
+                    reason: `[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.`,
+                  }));
+                  return;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Priority 2.6: Ralplan (standalone consensus planning — first-class enforcement)
+    if (ralplan.state?.active && !isStaleState(ralplan.state) && isSessionMatch(ralplan.state, sessionId)) {
+      // Terminal phase detection
+      const currentPhase = ralplan.state.current_phase;
+      let ralplanTerminal = false;
+      if (typeof currentPhase === "string") {
+        const terminal = ["complete", "completed", "failed", "cancelled", "canceled", "done"];
+        if (terminal.includes(currentPhase.toLowerCase())) {
+          writeStopBreaker(stateDir, "ralplan", 0, sessionId);
+          ralplanTerminal = true;
+        }
+      }
+
+      if (!ralplanTerminal && !cancelInProgress) {
+        // Circuit breaker
+        const breakerCount = readStopBreaker(stateDir, "ralplan", sessionId, RALPLAN_STOP_BLOCKER_TTL_MS) + 1;
+        if (breakerCount > RALPLAN_STOP_BLOCKER_MAX) {
+          writeStopBreaker(stateDir, "ralplan", 0, sessionId);
+          // Circuit breaker tripped — allow stop
+        } else {
+          writeStopBreaker(stateDir, "ralplan", breakerCount, sessionId);
+
+          sendStopNotification("ralplan", ralplan.state, sessionId, directory).catch(() => {});
+
+          console.log(JSON.stringify({
+            continue: false, decision: "block",
+            reason: `[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.`,
+          }));
+          return;
+        }
+      }
+    }
+
     // Priority 3: Ultrapilot (parallel autopilot)
     if (ultrapilot.state?.active && !isStaleState(ultrapilot.state) && isSessionMatch(ultrapilot.state, sessionId)) {
       const workers = ultrapilot.state.workers || [];
@@ -563,7 +789,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[ULTRAPILOT] ${incomplete} workers still running. Continue working. When all workers complete, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -588,7 +814,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[SWARM ACTIVE] ${pending} tasks remain. Continue working. When all tasks are done, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -613,7 +839,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[PIPELINE - Stage ${currentStage + 1}/${totalStages}] Pipeline not complete. Continue working. When all stages complete, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -622,12 +848,11 @@ async function main() {
       }
     }
 
-    // Priority 6: Team (native Claude Code teams)
-    if (team.state?.active && !isStaleState(team.state) && isSessionMatch(team.state, sessionId)) {
-      const phase = team.state.current_phase || "executing";
-      const terminalPhases = ["completed", "complete", "failed", "cancelled"];
-      if (!terminalPhases.includes(phase)) {
-        const newCount = (team.state.reinforcement_count || 0) + 1;
+    // Priority 6: Team (native Claude Code teams) — fallback for cases not handled by Priority 2.5
+    if (!teamPipelineHandled && team.state?.active && !isStaleState(team.state) && isSessionMatch(team.state, sessionId)) {
+      const phase = normalizeTeamPhase(team.state);
+      if (phase) {
+        const newCount = getSafeReinforcementCount(team.state.reinforcement_count) + 1;
         if (newCount <= 20) {
           team.state.reinforcement_count = newCount;
           team.state.last_checked_at = new Date().toISOString();
@@ -638,7 +863,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[TEAM - Phase: ${phase}] Team mode active. Continue working. When all team tasks complete, run /oh-my-claudecode:cancel to cleanly exit. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -649,10 +874,9 @@ async function main() {
 
     // Priority 6.5: OMC Teams (tmux CLI workers — independent of native team state)
     if (omcTeams.state?.active && !isStaleState(omcTeams.state) && isSessionMatch(omcTeams.state, sessionId)) {
-      const phase = omcTeams.state.current_phase || "executing";
-      const terminalPhases = ["completed", "complete", "failed", "cancelled"];
-      if (!terminalPhases.includes(phase)) {
-        const newCount = (omcTeams.state.reinforcement_count || 0) + 1;
+      const phase = normalizeTeamPhase(omcTeams.state);
+      if (phase) {
+        const newCount = getSafeReinforcementCount(omcTeams.state.reinforcement_count) + 1;
         if (newCount <= 20) {
           omcTeams.state.reinforcement_count = newCount;
           omcTeams.state.last_checked_at = new Date().toISOString();
@@ -663,7 +887,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
-              decision: "block",
+              continue: false, decision: "block",
               reason: `[OMC TEAMS - Phase: ${phase}] OMC Teams workers active. Continue working. When all workers complete, run /oh-my-claudecode:cancel to cleanly exit. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
             }),
           );
@@ -686,7 +910,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
-            decision: "block",
+            continue: false, decision: "block",
             reason: `[ULTRAQA - Cycle ${cycle + 1}/${maxCycles}] Tests not all passing. Continue fixing. When all tests pass, run /oh-my-claudecode:cancel to cleanly exit and clean up state files. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
           }),
         );
@@ -737,10 +961,47 @@ async function main() {
         reason += `\nTask: ${ultrawork.state.original_prompt}`;
       }
 
-      console.log(JSON.stringify({ decision: "block", reason }));
+      console.log(JSON.stringify({ continue: false, decision: "block", reason }));
       return;
     }
 
+    // Priority 9: Skill Active State (issue #1033)
+    // Skills like code-review, plan, ralplan, tdd, etc. write skill-active-state.json
+    // when invoked via the Skill tool. This prevents premature stops mid-skill.
+    {
+      const skillState = readStateFileWithSession(stateDir, "skill-active-state.json", sessionId);
+      if (skillState.state?.active) {
+        // Staleness check (per-skill TTL)
+        const sLastChecked = skillState.state.last_checked_at ? new Date(skillState.state.last_checked_at).getTime() : 0;
+        const sStartedAt = skillState.state.started_at ? new Date(skillState.state.started_at).getTime() : 0;
+        const sMostRecent = Math.max(sLastChecked, sStartedAt);
+        const sTtl = skillState.state.stale_ttl_ms || 5 * 60 * 1000;
+        const sAge = sMostRecent > 0 ? Date.now() - sMostRecent : Infinity;
+        const isStale = sMostRecent === 0 || sAge > sTtl;
+
+        if (!isStale && isSessionMatch(skillState.state, sessionId)) {
+          const count = skillState.state.reinforcement_count || 0;
+          const maxReinforcements = skillState.state.max_reinforcements || 3;
+
+          if (count < maxReinforcements) {
+            skillState.state.reinforcement_count = count + 1;
+            skillState.state.last_checked_at = new Date().toISOString();
+            writeJsonFile(skillState.path, skillState.state);
+
+            const skillName = skillState.state.skill_name || "unknown";
+            console.log(JSON.stringify({
+              continue: false, decision: "block",
+              reason: `[SKILL ACTIVE: ${skillName}] The "${skillName}" skill is still executing (reinforcement ${count + 1}/${maxReinforcements}). Continue working on the skill's instructions. Do not stop until the skill completes its workflow.`,
+            }));
+            return;
+          } else {
+            // Reinforcement limit reached - clear state and allow stop
+            try { if (skillState.path && existsSync(skillState.path)) unlinkSync(skillState.path); } catch {}
+          }
+        }
+      }
+    }
+
     // No blocking needed — Claude is truly idle.
     // Send session-idle notification (fire-and-forget) so external integrations
     // (Telegram, Discord) know the session went idle without any active mode.

package/scripts/persistent-mode.mjs

@@ -132,6 +132,29 @@ Do NOT skip this step. Do NOT move on without fixing the error.
  * from causing the stop hook to malfunction in new sessions.
  */
 const STALE_STATE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
+const TEAM_TERMINAL_PHASES = new Set([
+  "completed",
+  "complete",
+  "failed",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "terminated",
+  "done",
+]);
+const TEAM_ACTIVE_PHASES = new Set([
+  "team-plan",
+  "team-prd",
+  "team-exec",
+  "team-verify",
+  "team-fix",
+  "planning",
+  "executing",
+  "verify",
+  "verification",
+  "fix",
+  "fixing",
+]);
 
 /**
  * Check if a state is stale based on its timestamps.
@@ -153,6 +176,23 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+function normalizeTeamPhase(state) {
+  if (!state || typeof state !== "object") return null;
+
+  const rawPhase = state.current_phase ?? state.phase ?? state.stage;
+  if (typeof rawPhase !== "string") return null;
+
+  const phase = rawPhase.trim().toLowerCase();
+  if (!phase || TEAM_TERMINAL_PHASES.has(phase)) return null;
+  return TEAM_ACTIVE_PHASES.has(phase) ? phase : null;
+}
+
+function getSafeReinforcementCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? Math.floor(value)
+    : 0;
+}
+
 /**
  * Normalize a path for comparison.
  */
@@ -325,7 +365,15 @@ function countIncompleteTodos(sessionId, projectDir) {
  * See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/213
  */
 function isContextLimitStop(data) {
-  const reason = (data.stop_reason || data.stopReason || "").toLowerCase();
+  const reasons = [
+    data.stop_reason,
+    data.stopReason,
+    data.end_turn_reason,
+    data.endTurnReason,
+    data.reason,
+  ]
+    .filter((value) => typeof value === "string" && value.trim().length > 0)
+    .map((value) => value.toLowerCase().replace(/[\s-]+/g, "_"));
 
   const contextPatterns = [
     "context_limit",
@@ -339,20 +387,26 @@ function isContextLimitStop(data) {
     "input_too_long",
   ];
 
-  if (contextPatterns.some((p) => reason.includes(p))) {
-    return true;
-  }
+  return reasons.some((reason) => contextPatterns.some((p) => reason.includes(p)));
+}
 
-  const endTurnReason = (
-    data.end_turn_reason ||
-    data.endTurnReason ||
-    ""
-  ).toLowerCase();
-  if (endTurnReason && contextPatterns.some((p) => endTurnReason.includes(p))) {
-    return true;
-  }
+const CRITICAL_CONTEXT_STOP_PERCENT = 95;
 
-  return false;
+function estimateContextPercent(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return 0;
+  try {
+    const content = readFileSync(transcriptPath, "utf-8");
+    const windowMatch = content.match(/"context_window"\s{0,5}:\s{0,5}(\d+)/g);
+    const inputMatch = content.match(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g);
+    if (!windowMatch || !inputMatch) return 0;
+
+    const lastWindow = parseInt(windowMatch[windowMatch.length - 1].match(/(\d+)/)[1], 10);
+    const lastInput = parseInt(inputMatch[inputMatch.length - 1].match(/(\d+)/)[1], 10);
+    if (!Number.isFinite(lastWindow) || lastWindow <= 0 || !Number.isFinite(lastInput)) return 0;
+    return Math.round((lastInput / lastWindow) * 100);
+  } catch {
+    return 0;
+  }
 }
 
 /**
@@ -433,6 +487,12 @@ async function main() {
       return;
     }
 
+    const criticalTranscriptPath = data.transcript_path || data.transcriptPath || "";
+    if (estimateContextPercent(criticalTranscriptPath) >= CRITICAL_CONTEXT_STOP_PERCENT) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Respect user abort (Ctrl+C, cancel)
     if (isUserAbort(data)) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
@@ -720,10 +780,9 @@ async function main() {
         ? team.state.session_id === sessionId
         : !team.state.session_id || team.state.session_id === sessionId;
       if (sessionMatches) {
-        const phase = team.state.current_phase || "executing";
-        const terminalPhases = ["completed", "complete", "failed", "cancelled"];
-        if (!terminalPhases.includes(phase)) {
-          const newCount = (team.state.reinforcement_count || 0) + 1;
+        const phase = normalizeTeamPhase(team.state);
+        if (phase) {
+          const newCount = getSafeReinforcementCount(team.state.reinforcement_count) + 1;
           if (newCount <= 20) {
             const toolError = readLastToolError(stateDir);
             const errorGuidance = getToolErrorRetryGuidance(toolError);
@@ -760,10 +819,9 @@ async function main() {
         ? omcTeams.state.session_id === sessionId
         : !omcTeams.state.session_id || omcTeams.state.session_id === sessionId;
       if (sessionMatches) {
-        const phase = omcTeams.state.current_phase || "executing";
-        const terminalPhases = ["completed", "complete", "failed", "cancelled"];
-        if (!terminalPhases.includes(phase)) {
-          const newCount = (omcTeams.state.reinforcement_count || 0) + 1;
+        const phase = normalizeTeamPhase(omcTeams.state);
+        if (phase) {
+          const newCount = getSafeReinforcementCount(omcTeams.state.reinforcement_count) + 1;
           if (newCount <= 20) {
             const toolError = readLastToolError(stateDir);
             const errorGuidance = getToolErrorRetryGuidance(toolError);

package/scripts/plugin-setup.mjs

@@ -104,7 +104,16 @@ async function main() {
     }
   }
 
-  // 3. Fallback: provide targeted repair guidance
+  // 3. Marketplace clone (for marketplace installs without a populated cache)
+  const marketplaceHudPath = join(configDir, "plugins", "marketplaces", "omc", "dist/hud/index.js");
+  if (existsSync(marketplaceHudPath)) {
+    try {
+      await import(pathToFileURL(marketplaceHudPath).href);
+      return;
+    } catch { /* continue */ }
+  }
+
+  // 4. Fallback: provide targeted repair guidance
   if (pluginCacheDir && existsSync(pluginCacheDir)) {
     const distDir = join(pluginCacheDir, "dist");
     if (!existsSync(distDir)) {