claudecode-omc 4.4.10 → 4.7.4

package/skills/team/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: team
 description: N coordinated agents on shared task list using Claude Code native teams
-aliases: [swarm]
+aliases: []
 ---
 
 # Team Skill
 
 Spawn N coordinated agents working on a shared task list using Claude Code's native team tools. Replaces the legacy `/swarm` skill (SQLite-based) with built-in team management, inter-agent messaging, and task dependencies -- no external dependencies required.
 
-`swarm` is the compatibility alias for this canonical skill entrypoint.
+The `swarm` compatibility alias was removed in #1131.
 
 ## Usage
 
@@ -439,6 +439,7 @@ When spawning teammates, include this preamble in the prompt to establish the wo
 ```
 You are a TEAM WORKER in team "{team_name}". Your name is "{worker_name}".
 You report to the team lead ("team-lead").
+You are not the leader and must not perform leader orchestration actions.
 
 == WORK PROTOCOL ==
 
@@ -474,11 +475,23 @@ Do NOT mark the task as completed. Leave it in_progress so the lead can reassign
 
 == RULES ==
 - NEVER spawn sub-agents or use the Task tool
+- NEVER run tmux pane/session orchestration commands (for example `tmux split-window`, `tmux new-session`)
+- NEVER run team spawning/orchestration skills or commands (for example `$team`, `$ultrawork`, `$autopilot`, `$ralph`, `omc team ...`, `omx team ...`)
 - ALWAYS use absolute file paths
 - ALWAYS report progress via SendMessage to "team-lead"
 - Use SendMessage with type "message" only -- never "broadcast"
 ```
 
+### Agent-Type Prompt Injection (Worker-Specific Addendum)
+
+When composing teammate prompts, append a short addendum based on worker type:
+
+- `claude_worker`: Emphasize strict TaskList/TaskUpdate/SendMessage loop and no orchestration commands.
+- `codex_worker`: Emphasize CLI API lifecycle (`omc team api ... --json`) and explicit failure ACKs with stderr.
+- `gemini_worker`: Emphasize bounded file ownership and milestone ACKs after each completed sub-step.
+
+This addendum must preserve the core rule: **worker = executor only, never leader/orchestrator**.
+
 ## Communication Patterns
 
 ### Teammate to Lead (task completion report)
@@ -834,6 +847,27 @@ When team is linked to ralph, cancellation follows dependency order:
 
 If teammates are unresponsive, `TeamDelete` may fail. In that case, the cancel skill should wait briefly and retry, or inform the user to manually clean up `~/.claude/teams/{team_name}/` and `~/.claude/tasks/{team_name}/`.
 
+## Runtime V2 (Event-Driven)
+
+When `OMC_RUNTIME_V2=1` is set, the team runtime uses an event-driven architecture instead of the legacy done.json polling watchdog:
+
+- **No done.json**: Task completion is detected via CLI API lifecycle transitions (claim-task, transition-task-status)
+- **Snapshot-based monitoring**: Each poll cycle takes a point-in-time snapshot of tasks and workers, computes deltas, and emits events
+- **Event log**: All team events are appended to `.omc/state/team/{teamName}/events.jsonl`
+- **Worker status files**: Workers write status to `.omc/state/team/{teamName}/workers/{name}/status.json`
+- **Preserved**: Sentinel gate (blocks premature completion), circuit breaker (dead worker detection), failure sidecars
+
+The v2 runtime is feature-flagged and can be enabled per-session. The legacy v1 runtime remains the default.
+
+## Dynamic Scaling
+
+When `OMC_TEAM_SCALING_ENABLED=1` is set, the team supports mid-session scaling:
+
+- **scale_up**: Add workers to a running team (respects max_workers limit)
+- **scale_down**: Remove idle workers with graceful drain (workers finish current task before removal)
+- File-based scaling lock prevents concurrent scale operations
+- Monotonic worker index counter ensures unique worker names across scale events
+
 ## Configuration
 
 Optional settings via `.omc-config.json`:

package/skills/ultrawork/SKILL.md

@@ -50,9 +50,9 @@ Sequential task execution wastes time when tasks are independent. Ultrawork enab
 </Steps>
 
 <Tool_Usage>
-- Use `Task(subagent_type="oh-my-claudecode:executor-low", model="haiku", ...)` for simple changes
+- Use `Task(subagent_type="oh-my-claudecode:executor", model="haiku", ...)` for simple changes
 - Use `Task(subagent_type="oh-my-claudecode:executor", model="sonnet", ...)` for standard work
-- Use `Task(subagent_type="oh-my-claudecode:executor-high", model="opus", ...)` for complex work
+- Use `Task(subagent_type="oh-my-claudecode:executor", model="opus", ...)` for complex work
 - Use `run_in_background: true` for package installs, builds, and test suites
 - Use foreground execution for quick status checks and file operations
 </Tool_Usage>
@@ -61,7 +61,7 @@ Sequential task execution wastes time when tasks are independent. Ultrawork enab
 <Good>
 Three independent tasks fired simultaneously:
 ```
-Task(subagent_type="oh-my-claudecode:executor-low", model="haiku", prompt="Add missing type export for Config interface")
+Task(subagent_type="oh-my-claudecode:executor", model="haiku", prompt="Add missing type export for Config interface")
 Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="Implement the /api/users endpoint with validation")
 Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="Add integration tests for the auth middleware")
 ```
@@ -72,7 +72,7 @@ Why good: Independent tasks at appropriate tiers, all fired at once.
 Correct use of background execution:
 ```
 Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="npm install && npm run build", run_in_background=true)
-Task(subagent_type="oh-my-claudecode:executor-low", model="haiku", prompt="Update the README with new API endpoints")
+Task(subagent_type="oh-my-claudecode:executor", model="haiku", prompt="Update the README with new API endpoints")
 ```
 Why good: Long build runs in background while short task runs in foreground.
 </Good>
@@ -80,7 +80,7 @@ Why good: Long build runs in background while short task runs in foreground.
 <Bad>
 Sequential execution of independent work:
 ```
-result1 = Task(executor-low, "Add type export")  # wait...
+result1 = Task(executor, "Add type export")  # wait...
 result2 = Task(executor, "Implement endpoint")     # wait...
 result3 = Task(executor, "Add tests")              # wait...
 ```
@@ -90,9 +90,9 @@ Why bad: These tasks are independent. Running them sequentially wastes time.
 <Bad>
 Wrong tier selection:
 ```
-Task(subagent_type="oh-my-claudecode:executor-high", model="opus", prompt="Add a missing semicolon")
+Task(subagent_type="oh-my-claudecode:executor", model="opus", prompt="Add a missing semicolon")
 ```
-Why bad: Opus is expensive overkill for a trivial fix. Use executor-low with Haiku instead.
+Why bad: Opus is expensive overkill for a trivial fix. Use executor with Haiku instead.
 </Bad>
 </Examples>
 

package/templates/hooks/keyword-detector.mjs

@@ -226,21 +226,10 @@ function resolveConflicts(matches) {
 
   let resolved = [...matches];
 
-  // Team beats autopilot (legacy ultrapilot semantics)
-  if (names.includes('team') && names.includes('autopilot')) {
-    resolved = resolved.filter(m => m.name !== 'autopilot');
-  }
-
-  // Team beats ultrapilot (team is the canonical implementation)
-  if (names.includes('team') && names.includes('ultrapilot')) {
-    resolved = resolved.filter(m => m.name !== 'ultrapilot');
-  }
-
-  // Ralph + Team coexist (team-ralph linked mode)
-  // Both keywords are preserved so the skill can detect the composition.
+  // Team keyword detection removed — team is now explicit-only via /team skill.
 
   // Sort by priority order
-const priorityOrder = ['cancel','ralph','autopilot','team','ultrawork',
+const priorityOrder = ['cancel','ralph','autopilot','ultrawork',
     'pipeline','ccg','ralplan','plan','tdd','research','ultrathink','deepsearch','analyze'];
   resolved.sort((a, b) => priorityOrder.indexOf(a.name) - priorityOrder.indexOf(b.name));
 
@@ -289,6 +278,20 @@ function isTeamEnabled() {
 
 // Main
 async function main() {
+  // Skip guard: check OMC_SKIP_HOOKS env var (see issue #838)
+  const _skipHooks = (process.env.OMC_SKIP_HOOKS || '').split(',').map(s => s.trim());
+  if (process.env.DISABLE_OMC === '1' || _skipHooks.includes('keyword-detector')) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Team worker guard: prevent keyword detection inside team workers to avoid
+  // infinite spawning loops (worker detects "team" -> invokes team skill -> spawns more workers)
+  if (process.env.OMC_TEAM_WORKER) {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    return;
+  }
+
   try {
     const input = await readStdin();
     if (!input.trim()) {
@@ -326,13 +329,8 @@ async function main() {
       matches.push({ name: 'autopilot', args: '' });
     }
 
-    // Team keywords (intent-gated to prevent false positives on bare "team")
-    // Uses negative lookbehind to exclude possessive/article contexts like "my team", "the team"
-    const hasTeamKeyword = /(?<!\b(?:my|the|our|a|his|her|their|its)\s)\bteam\b/i.test(cleanPrompt) ||
-      /\bcoordinated\s+team\b/i.test(cleanPrompt);
-    if (hasTeamKeyword && isTeamEnabled()) {
-      matches.push({ name: 'team', args: '' });
-    }
+    // Team keyword detection removed — team mode is now explicit-only via /team skill.
+    // This prevents infinite spawning when Claude workers receive prompts containing "team".
 
     // Ultrawork keywords
     if (/\b(ultrawork|ulw)\b/i.test(cleanPrompt)) {
@@ -398,14 +396,14 @@ async function main() {
 
     // Handle cancel specially - clear states and emit
     if (resolved.length > 0 && resolved[0].name === 'cancel') {
-      clearStateFiles(directory, ['ralph', 'autopilot', 'team', 'ultrawork', 'pipeline']);
+      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork', 'pipeline']);
       console.log(JSON.stringify(createHookOutput(createSkillInvocation('cancel', prompt))));
       return;
     }
 
     // Activate states for modes that need them
     const sessionId = data.sessionId || data.session_id || data.sessionid || '';
-    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'team', 'ultrawork'].includes(m.name));
+    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'ultrawork'].includes(m.name));
     for (const mode of stateModes) {
       activateState(directory, prompt, mode.name, sessionId);
     }
@@ -413,16 +411,10 @@ async function main() {
     // Special: Ralph with ultrawork (ralph always includes ultrawork)
     const hasRalph = resolved.some(m => m.name === 'ralph');
     const hasUltrawork = resolved.some(m => m.name === 'ultrawork');
-    const hasTeam = resolved.some(m => m.name === 'team');
     if (hasRalph && !hasUltrawork) {
       activateState(directory, prompt, 'ultrawork', sessionId);
     }
 
-    // Link ralph + team if both detected (team-ralph composition)
-    if (hasRalph && hasTeam) {
-      linkRalphTeam(directory, sessionId);
-    }
-
     // Handle ultrathink specially - prepend message instead of skill invocation
     const ultrathinkIndex = resolved.findIndex(m => m.name === 'ultrathink');
     if (ultrathinkIndex !== -1) {

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,11 +115,69 @@ 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') {
+    const toolInput = data.tool_input || data.toolInput || {};
+    const subagentType = toolInput.subagent_type || toolInput.subagentType || '';
+
+    // Strip oh-my-claudecode: prefix if present
+    if (subagentType.startsWith('oh-my-claudecode:')) {
+      const strippedType = subagentType.replace(/^oh-my-claudecode:/, '');
+      const modifiedInput = {
+        ...toolInput,
+        subagent_type: strippedType
+      };
+
+      console.log(JSON.stringify({
+        continue: true,
+        modifiedInput: modifiedInput,
+        suppressOutput: true
+      }));
+      return;
+    }
+
+    // No prefix to strip, continue as-is
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    return;
+  }
 
   // Handle Bash tool separately - check for file modification patterns
   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