claudecode-omc 4.5.7 → 4.7.4

package/templates/hooks/persistent-mode.mjs

@@ -175,6 +175,41 @@ function isStaleSkillState(state) {
   return age > ttl;
 }
 
+/**
+ * Check if a cancel signal is in progress for the session.
+ * Cancel signals are written by state_clear and expire after 30 seconds.
+ * @param {string} stateDir - The .omc/state directory path
+ * @param {string} sessionId - Optional session ID
+ * @returns {boolean} true if cancel is in progress
+ */
+function isSessionCancelInProgress(stateDir, sessionId) {
+  const CANCEL_SIGNAL_TTL_MS = 30000; // 30 seconds
+
+  // Try session-scoped path first
+  if (sessionId) {
+    const sessionSignalPath = join(stateDir, 'sessions', sessionId, 'cancel-signal-state.json');
+    const signal = readJsonFile(sessionSignalPath);
+    if (signal && signal.expires_at) {
+      const expiresAt = new Date(signal.expires_at).getTime();
+      if (Date.now() < expiresAt) {
+        return true;
+      }
+    }
+  }
+
+  // Fall back to legacy path
+  const legacySignalPath = join(stateDir, 'cancel-signal-state.json');
+  const signal = readJsonFile(legacySignalPath);
+  if (signal && signal.expires_at) {
+    const expiresAt = new Date(signal.expires_at).getTime();
+    if (Date.now() < expiresAt) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Normalize a path for comparison.
  * Uses path.resolve() + path.normalize() for proper handling of:
@@ -419,6 +454,38 @@ function isUserAbort(data) {
   );
 }
 
+const AUTHENTICATION_ERROR_PATTERNS = [
+  "authentication_error",
+  "authentication_failed",
+  "auth_error",
+  "unauthorized",
+  "unauthorised",
+  "401",
+  "403",
+  "forbidden",
+  "invalid_token",
+  "token_invalid",
+  "token_expired",
+  "expired_token",
+  "oauth_expired",
+  "oauth_token_expired",
+  "invalid_grant",
+  "insufficient_scope",
+];
+
+function isAuthenticationError(data) {
+  const reason = (data.stop_reason || data.stopReason || "").toLowerCase();
+  const endTurnReason = (
+    data.end_turn_reason ||
+    data.endTurnReason ||
+    ""
+  ).toLowerCase();
+
+  return AUTHENTICATION_ERROR_PATTERNS.some(
+    (pattern) => reason.includes(pattern) || endTurnReason.includes(pattern),
+  );
+}
+
 async function main() {
   try {
     const input = await readStdin();
@@ -452,6 +519,12 @@ async function main() {
       return;
     }
 
+    // Never block auth failures (401/403/expired OAuth): allow re-auth flow.
+    if (isAuthenticationError(data)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Read all mode states (session-scoped when sessionId provided)
     const ralph = readStateFileWithSession(
       stateDir,
@@ -506,6 +579,12 @@ async function main() {
     const todoCount = countIncompleteTodos(sessionId, directory);
     const totalIncomplete = taskCount + todoCount;
 
+    // Check if cancel is in progress - if so, allow stop immediately
+    if (isSessionCancelInProgress(stateDir, sessionId)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Priority 1: Ralph Loop (explicit persistence mode)
     // Skip if state is stale (older than 2 hours) - prevents blocking new sessions
     if (
@@ -535,6 +614,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -550,6 +630,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
+            continue: false,
             decision: "block",
             reason: `[RALPH LOOP - EXTENDED] Max iterations reached; extending to ${ralph.state.max_iterations} and continuing. When FULLY complete (after Architect verification), run /oh-my-claudecode:cancel (or --force).`,
           }),
@@ -586,6 +667,7 @@ async function main() {
 
             console.log(
               JSON.stringify({
+                continue: false,
                 decision: "block",
                 reason,
               }),
@@ -626,6 +708,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -662,6 +745,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -699,6 +783,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -737,6 +822,7 @@ async function main() {
 
             console.log(
               JSON.stringify({
+                continue: false,
                 decision: "block",
                 reason,
               }),
@@ -773,6 +859,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
+            continue: false,
             decision: "block",
             reason,
           }),
@@ -830,7 +917,7 @@ async function main() {
         reason = errorGuidance + reason;
       }
 
-      console.log(JSON.stringify({ decision: "block", reason }));
+      console.log(JSON.stringify({ continue: false, decision: "block", reason }));
       return;
     }
 
@@ -868,7 +955,7 @@ async function main() {
             reason = errorGuidance + reason;
           }
 
-          console.log(JSON.stringify({ decision: "block", reason }));
+          console.log(JSON.stringify({ continue: false, decision: "block", reason }));
           return;
         } else {
           // Reinforcement limit reached - clear state and allow stop

package/templates/hooks/pre-tool-use.mjs

@@ -63,6 +63,27 @@ const FILE_MODIFY_PATTERNS = [
 
 // Source file pattern for command inspection
 const SOURCE_EXT_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|py|pyw|go|rs|java|kt|scala|c|cpp|cc|h|hpp|rb|php|svelte|vue|graphql|gql|sh|bash|zsh)/i;
+const WORKER_BLOCKED_TMUX_PATTERN = /\btmux\s+(split-window|new-session|new-window|join-pane)\b/i;
+const WORKER_BLOCKED_TEAM_CLI_PATTERN = /\bom[cx]\s+team\b(?!\s+api\b)/i;
+const WORKER_BLOCKED_SKILL_PATTERN = /\$(team|ultrawork|autopilot|ralph)\b/i;
+
+function teamWorkerIdentity() {
+  return (process.env.OMC_TEAM_WORKER || process.env.OMX_TEAM_WORKER || '').trim();
+}
+
+function workerCommandViolation(command) {
+  if (!command) return null;
+  if (WORKER_BLOCKED_TMUX_PATTERN.test(command)) {
+    return 'Team worker cannot run tmux pane/session orchestration commands.';
+  }
+  if (WORKER_BLOCKED_TEAM_CLI_PATTERN.test(command)) {
+    return 'Team worker cannot run team orchestration commands (except `omc team api ...`).';
+  }
+  if (WORKER_BLOCKED_SKILL_PATTERN.test(command)) {
+    return 'Team worker cannot invoke orchestration skills (`$team`, `$ultrawork`, `$autopilot`, `$ralph`).';
+  }
+  return null;
+}
 
 function checkBashCommand(command) {
   // Check if command might modify files
@@ -94,6 +115,27 @@ async function main() {
 
   // Extract tool name (handle both cases)
   const toolName = data.tool_name || data.toolName || '';
+  const worker = teamWorkerIdentity();
+
+  if (worker) {
+    if (toolName === 'Task' || toolName === 'task') {
+      console.log(JSON.stringify({
+        continue: false,
+        reason: 'team-worker-task-blocked',
+        message: `Worker ${worker} cannot spawn/delegate Task calls in worker mode.`
+      }));
+      return;
+    }
+
+    if (toolName === 'Skill' || toolName === 'skill') {
+      console.log(JSON.stringify({
+        continue: false,
+        reason: 'team-worker-skill-blocked',
+        message: `Worker ${worker} cannot invoke Skill tool in worker mode.`
+      }));
+      return;
+    }
+  }
 
   // Handle Agent/Task tool - strip oh-my-claudecode: prefix from subagent_type
   if (toolName === 'Agent' || toolName === 'Task' || toolName === 'agent' || toolName === 'task') {
@@ -125,6 +167,17 @@ async function main() {
   if (toolName === 'Bash' || toolName === 'bash') {
     const toolInput = data.tool_input || data.toolInput || {};
     const command = toolInput.command || '';
+    if (worker) {
+      const violation = workerCommandViolation(command);
+      if (violation) {
+        console.log(JSON.stringify({
+          continue: false,
+          reason: 'team-worker-bash-blocked',
+          message: `${violation}\nCommand blocked: ${command}`
+        }));
+        return;
+      }
+    }
     const warning = checkBashCommand(command);
     if (warning) {
       console.log(JSON.stringify({

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-claude-sisyphus/latest', {
+    const response = await fetch('https://registry.npmjs.org/claudecode-omc/latest', {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
@@ -200,7 +200,7 @@ async function main() {
     for (let i = 1; i <= 4; i++) {
       const candidate = join(__dirname, ...Array(i).fill('..'), 'package.json');
       const pkg = readJsonFile(candidate);
-      if (pkg?.name === 'oh-my-claudecode' && pkg?.version) {
+      if (pkg?.name === 'claudecode-omc' && pkg?.version) {
         currentVersion = pkg.version;
         break;
       }
@@ -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-claude-sisyphus@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 claudecode-omc@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
 

package/skills/pipeline/SKILL.md

@@ -1,434 +0,0 @@
----
-name: pipeline
-description: Chain agents together in sequential or branching workflows with data passing
----
-
-# Pipeline Skill
-
-## Overview
-
-The pipeline skill enables chaining multiple agents together in defined workflows where the output of one agent becomes the input to the next. This creates powerful agent pipelines similar to Unix pipes but designed for AI agent orchestration.
-
-## Core Concepts
-
-### 1. Sequential Pipelines
-
-The simplest form: Agent A's output flows to Agent B, which flows to Agent C.
-
-```
-explore -> architect -> executor
-```
-
-**Flow:**
-1. Explore agent searches codebase and produces findings
-2. Architect receives findings and produces analysis/recommendations
-3. Executor receives recommendations and implements changes
-
-### 2. Branching Pipelines
-
-Route to different agents based on output conditions.
-
-```
-explore -> {
-  if "complex refactoring" -> architect -> executor-high
-  if "simple change" -> executor-low
-  if "UI work" -> designer -> executor
-}
-```
-
-### 3. Parallel-Then-Merge Pipelines
-
-Run multiple agents in parallel, merge their outputs.
-
-```
-parallel(explore, document-specialist) -> architect -> executor
-```
-<!-- NOTE: document-specialist spawns a Claude Task agent for external documentation lookup. -->
-
-## Built-in Pipeline Presets
-
-### Review Pipeline
-**Purpose:** Comprehensive code review and implementation
-
-```
-/pipeline review <task>
-```
-
-**Stages:**
-1. `explore` - Find relevant code and patterns
-2. `architect` - Analyze architecture and design implications
-3. `critic` - Review and critique the analysis
-4. `executor` - Implement with full context
-
-**Use for:** Major features, refactorings, complex changes
-
----
-
-### Implement Pipeline
-**Purpose:** Planned implementation with testing
-
-```
-/pipeline implement <task>
-```
-
-**Stages:**
-1. `planner` - Create detailed implementation plan
-2. `executor` - Implement the plan
-3. `test-engineer` - Add/verify tests
-
-**Use for:** New features with clear requirements
-
----
-
-### Debug Pipeline
-**Purpose:** Systematic debugging workflow
-
-```
-/pipeline debug <issue>
-```
-
-**Stages:**
-1. `explore` - Locate error locations and related code
-2. `architect` - Analyze root cause
-3. `build-fixer` - Apply fixes and verify
-
-**Use for:** Bugs, build errors, test failures
-
----
-
-### Research Pipeline
-**Purpose:** External research + internal analysis
-
-```
-/pipeline research <topic>
-```
-
-**Stages:**
-1. `parallel(document-specialist, explore)` - External docs + internal code
-   <!-- NOTE: document-specialist spawns a Claude Task agent for external documentation lookup. -->
-2. `architect` - Synthesize findings
-3. `writer` - Document recommendations
-
-**Use for:** Technology decisions, API integrations
-
----
-
-### Refactor Pipeline
-**Purpose:** Safe, verified refactoring
-
-```
-/pipeline refactor <target>
-```
-
-**Stages:**
-1. `explore` - Find all usages and dependencies
-2. `architect-medium` - Design refactoring strategy
-3. `executor-high` - Execute refactoring
-4. `qa-tester` - Verify no regressions
-
-**Use for:** Architectural changes, API redesigns
-
----
-
-### Security Pipeline
-**Purpose:** Security audit and fixes
-
-```
-/pipeline security <scope>
-```
-
-**Stages:**
-1. `explore` - Find potential vulnerabilities
-2. `security-reviewer` - Audit and identify issues
-3. `executor` - Implement fixes
-4. `security-reviewer-low` - Re-verify
-
-**Use for:** Security reviews, vulnerability fixes
-
----
-
-## Custom Pipeline Syntax
-
-### Basic Sequential
-
-```
-/pipeline agent1 -> agent2 -> agent3 "task description"
-```
-
-**Example:**
-```
-/pipeline explore -> architect -> executor "add authentication"
-```
-
-### With Model Specification
-
-```
-/pipeline explore:haiku -> architect:opus -> executor:sonnet "optimize performance"
-```
-
-### With Branching
-
-```
-/pipeline explore -> (
-  complexity:high -> architect:opus -> executor-high:opus
-  complexity:medium -> executor:sonnet
-  complexity:low -> executor-low:haiku
-) "fix reported issues"
-```
-
-### With Parallel Stages
-
-```
-/pipeline [explore, document-specialist] -> architect -> executor "implement OAuth"
-```
-<!-- NOTE: document-specialist spawns a Claude Task agent for external documentation lookup. -->
-
-## Data Passing Protocol
-
-Each agent in the pipeline receives structured context from the previous stage:
-
-```json
-{
-  "pipeline_context": {
-    "original_task": "user's original request",
-    "previous_stages": [
-      {
-        "agent": "explore",
-        "model": "haiku",
-        "findings": "...",
-        "files_identified": ["src/auth.ts", "src/user.ts"]
-      }
-    ],
-    "current_stage": "architect",
-    "next_stage": "executor"
-  },
-  "task": "specific task for this agent"
-}
-```
-
-## Error Handling
-
-### Retry Logic
-
-When an agent fails, the pipeline can:
-
-1. **Retry** - Re-run the same agent (up to 3 times)
-2. **Skip** - Continue to next stage with partial output
-3. **Abort** - Stop entire pipeline
-4. **Fallback** - Route to alternative agent
-
-**Configuration:**
-
-```
-/pipeline explore -> architect -> executor --retry=3 --on-error=abort
-```
-
-### Error Recovery Patterns
-
-**Pattern 1: Fallback to Higher Tier**
-```
-executor-low -> on-error -> executor:sonnet
-```
-
-**Pattern 2: Consult Architect**
-```
-executor -> on-error -> architect -> executor
-```
-
-**Pattern 3: Human-in-the-Loop**
-```
-any-stage -> on-error -> pause-for-user-input
-```
-
-## Pipeline State Management
-
-Pipelines maintain state in `.omc/pipeline-state.json`:
-
-```json
-{
-  "pipeline_id": "uuid",
-  "name": "review",
-  "active": true,
-  "current_stage": 2,
-  "stages": [
-    {
-      "name": "explore",
-      "agent": "explore",
-      "model": "haiku",
-      "status": "completed",
-      "output": "..."
-    },
-    {
-      "name": "architect",
-      "agent": "architect",
-      "model": "opus",
-      "status": "in_progress",
-      "started_at": "2026-01-23T10:30:00Z"
-    },
-    {
-      "name": "executor",
-      "agent": "executor",
-      "model": "sonnet",
-      "status": "pending"
-    }
-  ],
-  "task": "original user task",
-  "created_at": "2026-01-23T10:25:00Z"
-}
-```
-
-## Verification Rules
-
-Before pipeline completion, verify:
-
-- [ ] All stages completed successfully
-- [ ] Output from final stage addresses original task
-- [ ] No unhandled errors in any stage
-- [ ] All files modified pass lsp_diagnostics
-- [ ] Tests pass (if applicable)
-
-## Advanced Features
-
-### Conditional Branching
-
-Based on agent output, route to different paths:
-
-```
-explore -> {
-  if files_found > 5 -> architect:opus -> executor-high:opus
-  if files_found <= 5 -> executor:sonnet
-}
-```
-
-### Loop Constructs
-
-Repeat stages until condition met:
-
-```
-repeat_until(tests_pass) {
-  executor -> qa-tester
-}
-```
-
-### Merge Strategies
-
-When parallel agents complete:
-
-- **concat**: Concatenate all outputs
-- **summarize**: Use architect to summarize findings
-- **vote**: Use critic to choose best output
-
-## Usage Examples
-
-### Example 1: Feature Implementation
-```
-/pipeline review "add rate limiting to API"
-```
-→ Triggers: explore → architect → critic → executor
-
-### Example 2: Bug Fix
-```
-/pipeline debug "login fails with OAuth"
-```
-→ Triggers: explore → architect → build-fixer
-
-### Example 3: Custom Chain
-```
-/pipeline explore:haiku -> architect:opus -> executor:sonnet -> test-engineer:sonnet "refactor auth module"
-```
-
-### Example 4: Research-Driven Implementation
-```
-/pipeline research "implement GraphQL subscriptions"
-```
-→ Triggers: parallel(document-specialist, explore) → architect → writer
-<!-- NOTE: document-specialist spawns a Claude Task agent for external documentation lookup. -->
-
-## Cancellation
-
-Stop active pipeline:
-
-```
-/pipeline cancel
-```
-
-Or use the general cancel command which detects active pipeline.
-
-## Integration with Other Skills
-
-Pipelines can be used within other skills:
-
-- **Ralph**: Loop pipelines until verified complete
-- **Ultrawork**: Run multiple pipelines in parallel
-- **Autopilot**: Use pipelines as building blocks
-
-## Best Practices
-
-1. **Start with presets** - Use built-in pipelines before creating custom ones
-2. **Match model to complexity** - Don't waste opus on simple tasks
-3. **Keep stages focused** - Each agent should have one clear responsibility
-4. **Use parallel stages** - Run independent work simultaneously
-5. **Verify at checkpoints** - Use architect or critic to verify progress
-6. **Document custom pipelines** - Save successful patterns for reuse
-
-## Troubleshooting
-
-### Pipeline Hangs
-
-**Check:** `.omc/pipeline-state.json` for current stage
-**Fix:** Resume with `/pipeline resume` or cancel and restart
-
-### Agent Fails Repeatedly
-
-**Check:** Retry count and error messages
-**Fix:** Route to higher-tier agent or add architect consultation
-
-### Output Not Flowing
-
-**Check:** Data passing structure in agent prompts
-**Fix:** Ensure each agent is prompted with `pipeline_context`
-
-## Technical Implementation
-
-The pipeline orchestrator:
-
-1. **Parses pipeline definition** - Validates syntax and agent names
-2. **Initializes state** - Creates pipeline-state.json
-3. **Executes stages sequentially** - Spawns agents with Task tool
-4. **Passes context between stages** - Structures output for next agent
-5. **Handles branching logic** - Evaluates conditions and routes
-6. **Manages parallel execution** - Spawns concurrent agents and merges
-7. **Persists state** - Updates state file after each stage
-8. **Enforces verification** - Runs checks before completion
-
-## STATE CLEANUP ON COMPLETION
-
-**IMPORTANT: Delete state files on completion - do NOT just set `active: false`**
-
-When pipeline completes (all stages done or cancelled):
-
-```bash
-# Delete pipeline state file
-rm -f .omc/state/pipeline-state.json
-```
-
-This ensures clean state for future sessions. Stale state files with `active: false` should not be left behind.
-
-## Skill Invocation
-
-This skill activates when:
-
-- User types `/pipeline` command
-- User mentions "agent chain", "workflow", "pipe agents"
-- Pattern detected: "X then Y then Z" with agent names
-
-**Explicit invocation:**
-```
-/oh-my-claudecode:pipeline review "task"
-```
-
-**Auto-detection:**
-```
-"First explore the codebase, then architect should analyze it, then executor implements"
-```
-→ Automatically creates pipeline: explore → architect → executor