claudecode-omc 4.4.4 → 4.4.6

package/skills/security-review/SKILL.md

@@ -86,15 +86,15 @@ Output: Security review report with:
 )
 ```
 
-## External Model Consultation (Preferred)
+## External Consultation (Optional)
 
-The security-reviewer agent SHOULD consult Codex for cross-validation.
+The security-reviewer agent MAY consult a Claude Task agent for cross-validation.
 
 ### Protocol
 1. **Form your OWN security analysis FIRST** - Complete the review independently
-2. **Consult for validation** - Cross-check findings with Codex
+2. **Consult for validation** - Cross-check findings via a Claude Task agent
 3. **Critically evaluate** - Never blindly adopt external findings
-4. **Graceful fallback** - Never block if tools unavailable
+4. **Graceful fallback** - Never block if delegation is unavailable
 
 ### When to Consult
 - Authentication/authorization code
@@ -110,8 +110,7 @@ The security-reviewer agent SHOULD consult Codex for cross-validation.
 - Code with existing security tests
 
 ### Tool Usage
-Before first MCP tool use, run the 3-step discovery: (1) `ToolSearch("mcp")`, (2) look for `mcp__x__ask_codex` in the results, (3) fall back to the `security-reviewer` Claude agent only if step 1 returns empty. Never use `ToolSearch("ask_codex")` as the primary search -- it can return false negatives even when MCP tools are present.
-Use `mcp__x__ask_codex` with `agent_role: "security-reviewer"`.
+Use `Task(subagent_type="oh-my-claudecode:security-reviewer", ...)` for cross-validation.
 
 **Note:** Security second opinions are high-value. Consider consulting for CRITICAL/HIGH findings.
 

package/skills/tdd/SKILL.md

@@ -76,15 +76,15 @@ Changes: [what was cleaned up]
 Result: [tests still pass]
 ```
 
-## External Model Consultation (Preferred)
+## External Consultation (Optional)
 
-The test-engineer agent SHOULD consult Codex for test strategy validation.
+The test-engineer agent MAY consult a Claude Task agent for test strategy validation.
 
 ### Protocol
 1. **Form your OWN test strategy FIRST** - Design tests independently
-2. **Consult for validation** - Cross-check test coverage strategy
+2. **Consult for validation** - Cross-check test coverage strategy via a Claude Task agent
 3. **Critically evaluate** - Never blindly adopt external suggestions
-4. **Graceful fallback** - Never block if tools unavailable
+4. **Graceful fallback** - Never block if delegation is unavailable
 
 ### When to Consult
 - Complex domain logic requiring comprehensive test coverage
@@ -99,7 +99,6 @@ The test-engineer agent SHOULD consult Codex for test strategy validation.
 - Small, isolated functionality
 
 ### Tool Usage
-Before first MCP tool use, run the 3-step discovery: (1) `ToolSearch("mcp")`, (2) look for `mcp__x__ask_codex` in the results, (3) fall back to the `test-engineer` Claude agent only if step 1 returns empty. Never use `ToolSearch("ask_codex")` as the primary search -- it can return false negatives even when MCP tools are present.
-Use `mcp__x__ask_codex` with `agent_role: "test-engineer"`.
+Use `Task(subagent_type="oh-my-claudecode:test-engineer", ...)` for test strategy cross-validation.
 
 **Remember:** The discipline IS the value. Shortcuts destroy the benefit.

package/skills/team/SKILL.md

@@ -21,7 +21,7 @@ Spawn N coordinated agents working on a shared task list using Claude Code's nat
 ### Parameters
 
 - **N** - Number of teammate agents (1-20). Optional; defaults to auto-sizing based on task decomposition.
-- **agent-type** - OMC agent to spawn for the `team-exec` stage (e.g., executor, build-fixer, designer). Optional; defaults to stage-aware routing (see Stage Agent Routing below).
+- **agent-type** - OMC agent to spawn for the `team-exec` stage (e.g., executor, build-fixer, designer, codex, gemini). Optional; defaults to stage-aware routing. Use `codex` to spawn Codex CLI workers or `gemini` for Gemini CLI workers (requires respective CLIs installed). See Stage Agent Routing below.
 - **task** - High-level task to decompose and distribute among teammates
 - **ralph** - Optional modifier. When present, wraps the team pipeline in Ralph's persistence loop (retry on failure, architect verification before completion). See Team + Ralph Composition below.
 
@@ -33,6 +33,11 @@ Spawn N coordinated agents working on a shared task list using Claude Code's nat
 /team 4:designer "implement responsive layouts for all page components"
 /team "refactor the auth module with security review"
 /team ralph "build a complete REST API for user management"
+# With Codex CLI workers (requires: npm install -g @openai/codex)
+/team 2:codex "review architecture and suggest improvements"
+# With Gemini CLI workers (requires: npm install -g @google/gemini-cli)
+/team 2:gemini "redesign the UI components"
+# Mixed: Codex for backend analysis, Gemini for frontend (use /ccg instead for this)
 ```
 
 ## Architecture
@@ -104,7 +109,7 @@ Each pipeline stage uses **specialized agents** -- not just executors. The lead
 **Routing rules:**
 
 1. **The lead picks agents per stage, not the user.** The user's `N:agent-type` parameter only overrides the `team-exec` stage worker type. All other stages use stage-appropriate specialists.
-2. **MCP providers complement Claude agents.** Route analysis/review to Codex (`ask_codex`) and UI/large-context work to Gemini (`ask_gemini`) when available. MCP workers are one-shot and don't participate in team communication.
+2. **Specialist agents complement executor agents.** Route analysis/review to architect/critic Claude agents and UI work to designer agents. Tmux CLI workers are one-shot and don't participate in team communication.
 3. **Cost mode affects model tier.** In downgrade: `opus` agents to `sonnet`, `sonnet` to `haiku` where quality permits. `team-verify` always uses at least `sonnet`.
 4. **Risk level escalates review.** Security-sensitive or >20 file changes must include `security-reviewer` + `code-reviewer` (opus) in `team-verify`.
 
@@ -567,9 +572,9 @@ This scans for processes matching the team name whose config no longer exists, a
 
 **IMPORTANT:** The `request_id` is provided in the shutdown request message that the teammate receives. The teammate must extract it and pass it back. Do NOT fabricate request IDs.
 
-## MCP Workers (Hybrid Roles)
+## CLI Workers (Codex and Gemini)
 
-The team skill supports **hybrid execution** combining Claude agent teammates with external MCP workers (Codex and Gemini CLIs). Both types can make code changes -- they differ in capabilities and cost.
+The team skill supports **hybrid execution** combining Claude agent teammates with external CLI workers (Codex CLI and Gemini CLI). Both types can make code changes -- they differ in capabilities and cost. These are standalone CLI tools, not MCP servers.
 
 ### Execution Modes
 
@@ -578,21 +583,21 @@ Tasks are tagged with an execution mode during decomposition:
 | Execution Mode | Provider | Capabilities |
 |---------------|----------|-------------|
 | `claude_worker` | Claude agent | Full Claude Code tool access (Read/Write/Edit/Bash/Task). Best for tasks needing Claude's reasoning + iterative tool use. |
-| `mcp_codex` | Codex CLI (`ask_codex`) | Full filesystem access in working_directory. Runs autonomously. Best for code review, security analysis, refactoring, architecture. |
-| `mcp_gemini` | Gemini CLI (`ask_gemini`) | Full filesystem access + 1M token context. Runs autonomously. Best for UI/frontend work, large-scale changes, documentation. |
+| `codex_worker` | Codex CLI (tmux pane) | Full filesystem access in working_directory. Runs autonomously via tmux pane. Best for code review, security analysis, refactoring, architecture. Requires `npm install -g @openai/codex`. |
+| `gemini_worker` | Gemini CLI (tmux pane) | Full filesystem access in working_directory. Runs autonomously via tmux pane. Best for UI/design work, documentation, large-context tasks. Requires `npm install -g @google/gemini-cli`. |
 
-### How MCP Workers Operate
+### How CLI Workers Operate
 
-Codex and Gemini CLIs run in full-auto mode with filesystem access. They are **autonomous executors**, not just analysts:
+Tmux CLI workers run in dedicated tmux panes with filesystem access. They are **autonomous executors**, not just analysts:
 
-1. Lead writes task instructions to a `prompt_file`
-2. Lead calls `ask_codex` or `ask_gemini` with `working_directory` set to the project root
-3. The CLI reads files, makes changes, runs commands -- all within the working directory
-4. Results/summary are written to `output_file`
+1. Lead writes task instructions to a prompt file
+2. Lead spawns a tmux CLI worker with `working_directory` set to the project root
+3. The worker reads files, makes changes, runs commands -- all within the working directory
+4. Results/summary are written to an output file
 5. Lead reads the output, marks the task complete, and feeds results to dependent tasks
 
 **Key difference from Claude teammates:**
-- MCP workers operate via CLI, not Claude Code's tool system
+- CLI workers operate via tmux, not Claude Code's tool system
 - They cannot use TaskList/TaskUpdate/SendMessage (no team awareness)
 - They run as one-shot autonomous jobs, not persistent teammates
 - The lead manages their lifecycle (spawn, monitor, collect results)
@@ -602,46 +607,42 @@ Codex and Gemini CLIs run in full-auto mode with filesystem access. They are **a
 | Task Type | Best Route | Why |
 |-----------|-----------|-----|
 | Iterative multi-step work | Claude teammate | Needs tool-mediated iteration + team communication |
-| Code review / security audit | Codex MCP | Specialized, cheaper than Claude opus |
-| Architecture analysis / planning | Codex MCP | External perspective, strong analytical reasoning |
-| Refactoring (well-scoped) | Codex MCP | Autonomous execution, good at structured transforms |
-| UI/frontend implementation | Gemini MCP | 1M context window, design expertise, can edit many files |
-| Large-scale documentation | Gemini MCP | Writing expertise + large context for consistency |
-| Visual/image analysis | Gemini MCP | Multimodal capability |
+| Code review / security audit | CLI worker or specialist agent | Autonomous execution, good at structured analysis |
+| Architecture analysis / planning | architect Claude agent | Strong analytical reasoning with codebase access |
+| Refactoring (well-scoped) | CLI worker or executor agent | Autonomous execution, good at structured transforms |
+| UI/frontend implementation | designer Claude agent | Design expertise, framework idioms |
+| Large-scale documentation | writer Claude agent | Writing expertise + large context for consistency |
 | Build/test iteration loops | Claude teammate | Needs Bash tool + iterative fix cycles |
 | Tasks needing team coordination | Claude teammate | Needs SendMessage for status updates |
 
-### Example: Hybrid Team with MCP Executors
+### Example: Hybrid Team with CLI Workers
 
 ```
 /team 3:executor "refactor auth module with security review"
 
 Task decomposition:
-#1 [mcp_codex] Security review of current auth code -> output to .omc/research/auth-security.md
-#2 [mcp_codex] Refactor auth/login.ts and auth/session.ts (uses #1 findings)
-#3 [mcp_gemini] Redesign auth UI components (login form, session indicator)
+#1 [codex_worker] Security review of current auth code -> output to .omc/research/auth-security.md
+#2 [codex_worker] Refactor auth/login.ts and auth/session.ts (uses #1 findings)
+#3 [claude_worker:designer] Redesign auth UI components (login form, session indicator)
 #4 [claude_worker] Update auth tests + fix integration issues
-#5 [mcp_codex] Final code review of all changes
+#5 [gemini_worker] Final code review of all changes
 ```
 
-The lead runs #1 (Codex analysis), then #2 and #3 in parallel (Codex refactors backend, Gemini redesigns frontend), then #4 (Claude teammate handles test iteration), then #5 (final Codex review).
+The lead runs #1 (Codex security analysis), then #2 and #3 in parallel (Codex refactors backend, designer agent redesigns frontend), then #4 (Claude teammate handles test iteration), then #5 (Gemini final review).
 
-### MCP Pre-flight Analysis (Optional)
+### Pre-flight Analysis (Optional)
 
 For large ambiguous tasks, run analysis before team creation:
 
-1. Call `ToolSearch("mcp")` to discover deferred MCP tools; from the results, confirm `mcp__x__ask_codex` is present before proceeding. Never use `ToolSearch("ask_codex")` as the primary search -- it can return false negatives even when MCP tools are present.
-2. Call `ask_codex` (planner role) with task description + codebase context
-3. Use the analysis to produce better task decomposition
-4. Create team and tasks with enriched context
-
-If ToolSearch finds no MCP tools, skip MCP pre-flight and use Claude agents instead.
+1. Spawn `Task(subagent_type="oh-my-claudecode:planner", ...)` with task description + codebase context
+2. Use the analysis to produce better task decomposition
+3. Create team and tasks with enriched context
 
 This is especially useful when the task scope is unclear and benefits from external reasoning before committing to a specific decomposition.
 
 ## Monitor Enhancement: Outbox Auto-Ingestion
 
-The lead can proactively ingest outbox messages from MCP workers using the outbox reader utilities, enabling event-driven monitoring without relying solely on `SendMessage` delivery.
+The lead can proactively ingest outbox messages from CLI workers using the outbox reader utilities, enabling event-driven monitoring without relying solely on `SendMessage` delivery.
 
 ### Outbox Reader Functions
 
@@ -929,4 +930,4 @@ MCP workers can operate in isolated git worktrees to prevent file conflicts betw
 
 10. **Broadcast is expensive** -- Each broadcast sends a separate message to every teammate. Use `message` (DM) by default. Only broadcast for truly team-wide critical alerts.
 
-11. **MCP workers are one-shot, not persistent** -- Codex and Gemini CLIs have full filesystem access and CAN make code changes. However, they run as autonomous one-shot jobs -- they cannot use TaskList/TaskUpdate/SendMessage. The lead must manage their lifecycle: write prompt_file, call MCP, read output_file, mark task complete. They don't participate in team communication like Claude teammates do.
+11. **CLI workers are one-shot, not persistent** -- Tmux CLI workers have full filesystem access and CAN make code changes. However, they run as autonomous one-shot jobs -- they cannot use TaskList/TaskUpdate/SendMessage. The lead must manage their lifecycle: write prompt_file, spawn CLI worker, read output_file, mark task complete. They don't participate in team communication like Claude teammates do.

package/templates/hooks/keyword-detector.mjs

@@ -18,9 +18,7 @@
  * 10. ultrathink: Extended reasoning
  * 11. deepsearch: Codebase search (restricted patterns)
  * 12. analyze: Analysis mode (restricted patterns)
- * 13. codex/gpt: Delegate to Codex MCP (ask_codex)
- * 14. gemini: Delegate to Gemini MCP (ask_gemini)
- * 8. ccg: Claude-Codex-Gemini tri-model orchestration
+ * 13. ccg: Claude-Codex-Gemini tri-model orchestration
  */
 
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'fs';
@@ -204,62 +202,14 @@ IMPORTANT: Invoke ALL skills listed above. Start with the first skill IMMEDIATEL
 }
 
 /**
- * Create MCP delegation message (NOT a skill invocation)
+ * Create combined output for multiple skill matches
  */
-function createMcpDelegation(provider, originalPrompt) {
-  const configs = {
-    codex: {
-      tool: 'ask_codex',
-      roles: 'architect, planner, critic, analyst, code-reviewer, security-reviewer, tdd-guide',
-      defaultRole: 'architect',
-    },
-    gemini: {
-      tool: 'ask_gemini',
-      roles: 'designer, writer, vision',
-      defaultRole: 'designer',
-    },
-  };
-  const config = configs[provider];
-  if (!config) return '';
-
-  return `[MAGIC KEYWORD: ${provider.toUpperCase()}]
-
-You MUST delegate this task to the ${provider === 'codex' ? 'Codex' : 'Gemini'} MCP tool.
-
-Steps:
-1. Call ToolSearch("mcp") to discover available MCP tools (required -- they are deferred and not in your tool list by default)
-2. Write a prompt file to \`.omc/prompts/${provider}-{purpose}-{timestamp}.md\` containing clear task instructions derived from the user's request
-3. Determine the appropriate agent_role from: ${config.roles}
-4. Call the \`${config.tool}\` MCP tool with:
-   - agent_role: <detected or default "${config.defaultRole}">
-   - prompt_file: <path you wrote>
-   - output_file: <corresponding -summary.md path>
-   - context_files: <relevant files from user's request>
-
-If ToolSearch returns no MCP tools, the MCP server is not configured. Fall back to the equivalent Claude agent instead.
-
-User request:
-${originalPrompt}
-
-IMPORTANT: Do NOT invoke a skill. Discover MCP tools via ToolSearch first, then delegate IMMEDIATELY.`;
-}
-
-/**
- * Create combined output for skills + MCP delegations
- */
-function createCombinedOutput(skillMatches, delegationMatches, originalPrompt) {
+function createCombinedOutput(skillMatches, originalPrompt) {
   const parts = [];
-
   if (skillMatches.length > 0) {
     parts.push('## Section 1: Skill Invocations\n\n' + createMultiSkillInvocation(skillMatches, originalPrompt));
   }
-
-  if (delegationMatches.length > 0) {
-    const delegationParts = delegationMatches.map(d => createMcpDelegation(d.name, originalPrompt));
-    parts.push('## Section ' + (skillMatches.length > 0 ? '2' : '1') + ': MCP Delegations\n\n' + delegationParts.join('\n\n---\n\n'));
-  }
-
-  const allNames = [...skillMatches, ...delegationMatches].map(m => m.name.toUpperCase());
+  const allNames = skillMatches.map(m => m.name.toUpperCase());
   return `[MAGIC KEYWORDS DETECTED: ${allNames.join(', ')}]\n\n${parts.join('\n\n---\n\n')}\n\nIMPORTANT: Complete ALL sections above in order.`;
 }
 
@@ -291,9 +241,7 @@ function resolveConflicts(matches) {
 
   // Sort by priority order
 const priorityOrder = ['cancel','ralph','autopilot','team','ultrawork',
-    'pipeline','ralplan','plan','tdd','ultrathink','deepsearch','analyze',
-    'pipeline','ccg','ralplan','plan','tdd','research','ultrathink','deepsearch','analyze',
-    'codex','gemini'];
+    'pipeline','ccg','ralplan','plan','tdd','research','ultrathink','deepsearch','analyze'];
   resolved.sort((a, b) => priorityOrder.indexOf(a.name) - priorityOrder.indexOf(b.name));
 
   return resolved;
@@ -320,7 +268,9 @@ function createHookOutput(additionalContext) {
  */
 function isTeamEnabled() {
   try {
-    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    // Check settings.json first (authoritative, user-controlled)
+    const cfgDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+    const settingsPath = join(cfgDir, 'settings.json');
     if (existsSync(settingsPath)) {
       const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
       if (settings.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === '1' ||
@@ -328,6 +278,7 @@ function isTeamEnabled() {
         return true;
       }
     }
+    // Fallback: check env var (for dev/CI environments)
     if (process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === '1' ||
         process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === 'true') {
       return true;
@@ -426,16 +377,6 @@ async function main() {
       matches.push({ name: 'analyze', args: '' });
     }
 
-    // Codex keywords (intent-phrase only)
-    if (/\b(ask|use|delegate\s+to)\s+(codex|gpt)\b/i.test(cleanPrompt)) {
-      matches.push({ name: 'codex', args: '' });
-    }
-
-    // Gemini keywords (intent-phrase only)
-    if (/\b(ask|use|delegate\s+to)\s+gemini\b/i.test(cleanPrompt)) {
-      matches.push({ name: 'gemini', args: '' });
-    }
-
     // No matches - pass through
     if (matches.length === 0) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
@@ -500,20 +441,8 @@ async function main() {
       return;
     }
 
-    // Split resolved into skills vs MCP delegations
-    const MCP_KEYWORDS = ['codex', 'gemini'];
-    const skillMatches = resolved.filter(m => !MCP_KEYWORDS.includes(m.name));
-    const delegationMatches = resolved.filter(m => MCP_KEYWORDS.includes(m.name));
-
-    if (skillMatches.length > 0 && delegationMatches.length > 0) {
-      // Combined: skills + MCP delegations
-      console.log(JSON.stringify(createHookOutput(createCombinedOutput(skillMatches, delegationMatches, prompt))));
-    } else if (delegationMatches.length > 0) {
-      // MCP delegation only
-      const delegationParts = delegationMatches.map(d => createMcpDelegation(d.name, prompt));
-      console.log(JSON.stringify(createHookOutput(delegationParts.join('\n\n---\n\n'))));
-    } else {
-      // Skills only (existing behavior)
+    const skillMatches = resolved;
+    if (skillMatches.length > 0) {
       console.log(JSON.stringify(createHookOutput(createMultiSkillInvocation(skillMatches, prompt))));
     }
   } catch (error) {

package/templates/hooks/persistent-mode.mjs

@@ -5,7 +5,7 @@
  * Minimal continuation enforcer for all OMC modes.
  * Stripped down for reliability — no optional imports, no PRD, no notepad pruning.
  *
- * Supported modes: ralph, autopilot, ultrapilot, swarm, ultrawork, ultraqa, pipeline
+ * Supported modes: ralph, autopilot, ultrapilot, swarm, ultrawork, ultraqa, pipeline, team
  */
 
 import {
@@ -153,6 +153,28 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+/**
+ * Check if a skill active state is stale based on its per-skill TTL.
+ * Unlike mode states (which use the global 2-hour threshold), skill states
+ * carry their own stale_ttl_ms value set when the skill was activated.
+ */
+function isStaleSkillState(state) {
+  if (!state) return true;
+  if (!state.active) return true;
+
+  const lastChecked = state.last_checked_at
+    ? new Date(state.last_checked_at).getTime()
+    : 0;
+  const startedAt = state.started_at ? new Date(state.started_at).getTime() : 0;
+  const mostRecent = Math.max(lastChecked, startedAt);
+
+  if (mostRecent === 0) return true;
+
+  const ttl = state.stale_ttl_ms || 5 * 60 * 1000; // Default 5 min
+  const age = Date.now() - mostRecent;
+  return age > ttl;
+}
+
 /**
  * Normalize a path for comparison.
  * Uses path.resolve() + path.normalize() for proper handling of:
@@ -467,8 +489,15 @@ async function main() {
       "pipeline-state.json",
       sessionId,
     );
+    const team = readStateFileWithSession(
+      stateDir,
+      globalStateDir,
+      "team-state.json",
+      sessionId,
+    );
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
+    // Note: Swarm only reads from local stateDir, never global fallback
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
     const swarmSummary = readJsonFile(join(stateDir, "swarm-summary.json"));
 
@@ -679,7 +708,46 @@ async function main() {
       }
     }
 
-    // Priority 6: UltraQA (QA cycling)
+    // Priority 6: Team (omc-teams / staged pipeline)
+    if (
+      team.state?.active &&
+      !isStaleState(team.state) &&
+      isStateForCurrentProject(team.state, directory, team.isGlobal)
+    ) {
+      const sessionMatches = hasValidSessionId
+        ? 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;
+          if (newCount <= 20) {
+            const toolError = readLastToolError(stateDir);
+            const errorGuidance = getToolErrorRetryGuidance(toolError);
+
+            team.state.reinforcement_count = newCount;
+            team.state.last_checked_at = new Date().toISOString();
+            writeJsonFile(team.path, team.state);
+
+            let 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.`;
+            if (errorGuidance) {
+              reason = errorGuidance + reason;
+            }
+
+            console.log(
+              JSON.stringify({
+                decision: "block",
+                reason,
+              }),
+            );
+            return;
+          }
+        }
+      }
+    }
+
+    // Priority 7: UltraQA (QA cycling)
     if (
       ultraqa.state?.active &&
       !isStaleState(ultraqa.state) &&
@@ -713,7 +781,7 @@ async function main() {
       }
     }
 
-    // Priority 7: Ultrawork - ALWAYS continue while active (not just when tasks exist)
+    // Priority 8: Ultrawork - ALWAYS continue while active (not just when tasks exist)
     // This prevents false stops from bash errors, transient failures, etc.
     // Session isolation: only block if state belongs to this session (issue #311)
     // If state has session_id, it must match. If no session_id (legacy), allow.
@@ -766,6 +834,55 @@ async function main() {
       return;
     }
 
+    // Priority 9: 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.
+    const skillState = readStateFileWithSession(
+      stateDir,
+      globalStateDir,
+      "skill-active-state.json",
+      sessionId,
+    );
+    if (
+      skillState.state?.active &&
+      !isStaleSkillState(skillState.state)
+    ) {
+      const sessionMatches = hasValidSessionId
+        ? skillState.state.session_id === sessionId
+        : !skillState.state.session_id || skillState.state.session_id === sessionId;
+      if (sessionMatches) {
+        const count = skillState.state.reinforcement_count || 0;
+        const maxReinforcements = skillState.state.max_reinforcements || 3;
+
+        if (count < maxReinforcements) {
+          const toolError = readLastToolError(stateDir);
+          const errorGuidance = getToolErrorRetryGuidance(toolError);
+
+          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";
+          let 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.`;
+          if (errorGuidance) {
+            reason = errorGuidance + reason;
+          }
+
+          console.log(JSON.stringify({ decision: "block", reason }));
+          return;
+        } else {
+          // Reinforcement limit reached - clear state and allow stop
+          try {
+            if (existsSync(skillState.path)) {
+              unlinkSync(skillState.path);
+            }
+          } catch {
+            // Ignore cleanup errors
+          }
+        }
+      }
+    }
+
     // No blocking needed
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   } catch (error) {

package/templates/hooks/post-tool-use-failure.mjs

@@ -155,10 +155,28 @@ async function main() {
     // Write error state
     writeErrorState(stateDir, toolName, inputPreview, error, retryCount);
 
-    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    // Inject continuation guidance so the model analyzes the error instead of stopping.
+    // Without this, PostToolUseFailure returns silently and the model may end its turn.
+    // The PostToolUse hook (post-tool-verifier.mjs) provides similar guidance for
+    // successful Bash calls with error patterns, but PostToolUseFailure is a separate
+    // event that needs its own guidance injection.
+    let guidance;
+    if (retryCount >= 5) {
+      guidance = `Tool "${toolName}" has failed ${retryCount} times. Stop retrying the same approach — try a different command, check dependencies, or ask the user for guidance.`;
+    } else {
+      guidance = `Tool "${toolName}" failed. Analyze the error, fix the issue, and continue working.`;
+    }
+
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUseFailure',
+        additionalContext: guidance,
+      },
+    }));
   } catch (error) {
     // Never block on hook errors
-    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    console.log(JSON.stringify({ continue: true }));
   }
 }
 

package/templates/hooks/session-start.mjs

@@ -69,7 +69,7 @@ async function checkForUpdates(currentVersion) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 2000);
 
-    const response = await fetch('https://registry.npmjs.org/oh-my-claudecode/latest', {
+    const response = await fetch('https://registry.npmjs.org/oh-my-claude-sisyphus/latest', {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
@@ -221,7 +221,7 @@ async function main() {
 oh-my-claudecode v${updateInfo.latestVersion} is available (current: v${updateInfo.currentVersion}).
 
 ACTION: Use AskUserQuestion to ask the user if they want to upgrade now. Offer these options:
-- "Upgrade now" (Recommended): Run \`npm install -g oh-my-claudecode@latest\` via Bash, then run \`omc install --force --skip-claude-check --refresh-hooks\` to reconcile hooks and CLAUDE.md
+- "Upgrade now" (Recommended): Run \`npm install -g oh-my-claude-sisyphus@latest\` via Bash, then run \`omc install --force --skip-claude-check --refresh-hooks\` to reconcile hooks and CLAUDE.md
 - "Skip this time": Continue the session without upgrading
 - "Don't ask again": Tell the user to set "autoUpgradePrompt": false in ~/.claude/.omc-config.json to disable future prompts
 
@@ -347,20 +347,6 @@ ${agentsContent}${truncationNotice}
       }
     }
 
-    // MCP tool discovery reminder (deferred tools need ToolSearch before use)
-    messages.push(`<session-restore>
-
-[MCP TOOL DISCOVERY REQUIRED]
-
-MCP tools (ask_codex, ask_gemini) are deferred and NOT in your tool list yet.
-Before first use, call ToolSearch("mcp") to discover all available MCP tools.
-If ToolSearch returns no results, MCP servers are not configured -- use Claude agent fallbacks instead.
-
-</session-restore>
-
----
-`);
-
     if (messages.length > 0) {
       console.log(JSON.stringify({
         continue: true,

package/dist/__tests__/analytics/backfill-dedup.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=backfill-dedup.test.d.ts.map

package/dist/__tests__/analytics/backfill-dedup.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-dedup.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/analytics/backfill-dedup.test.ts"],"names":[],"mappings":""}