claudecode-omc 4.5.7 → 4.8.0

package/scripts/ask-gemini.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+LOCAL_CLI="$SCRIPT_DIR/../bridge/cli.cjs"
+FALLBACK_ADVISOR="$SCRIPT_DIR/run-provider-advisor.js"
+
+if [[ -f "$LOCAL_CLI" ]]; then
+  node "$LOCAL_CLI" ask gemini "$@"
+  status=$?
+  if [[ $status -ne 126 && $status -ne 127 ]]; then
+    exit $status
+  fi
+
+  >&2 echo "[ask-gemini] DEPRECATED fallback: local OMC CLI launch failed (exit $status); falling back to run-provider-advisor.js"
+elif [[ ! -f "$FALLBACK_ADVISOR" ]]; then
+  >&2 echo "[ask-gemini] Error: local OMC CLI and fallback advisor script are both unavailable."
+  exit 1
+else
+  >&2 echo "[ask-gemini] DEPRECATED fallback: local OMC CLI entrypoint not found; using run-provider-advisor.js"
+fi
+
+node "$FALLBACK_ADVISOR" gemini "$@"
+exit $?

package/scripts/build-cli.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import * as esbuild from 'esbuild';
+import { mkdir } from 'fs/promises';
+
+const outfile = 'bridge/cli.cjs';
+await mkdir('bridge', { recursive: true });
+
+const sharedExternal = [
+  'fs', 'fs/promises', 'path', 'os', 'util', 'stream', 'events',
+  'buffer', 'crypto', 'http', 'https', 'url',
+  'child_process', 'assert', 'module', 'net', 'tls',
+  'dns', 'readline', 'tty', 'worker_threads',
+  '@ast-grep/napi', 'better-sqlite3',
+  // Avoid bundling jsonc-parser's UMD internals
+  'jsonc-parser',
+];
+
+await esbuild.build({
+  entryPoints: ['src/cli/index.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node18',
+  format: 'cjs',
+  outfile,
+  // Inject import.meta.url polyfill for CJS format
+  banner: {
+    js: 'const importMetaUrl = require("url").pathToFileURL(__filename);',
+  },
+  define: {
+    'import.meta.url': 'importMetaUrl',
+  },
+  external: sharedExternal,
+});
+console.log(`Built ${outfile}`);
+
+// Build team CLI module separately (dynamically imported by cli.cjs)
+const teamOutfile = 'bridge/team.js';
+await esbuild.build({
+  entryPoints: ['src/cli/team.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node18',
+  format: 'esm',
+  outfile: teamOutfile,
+  external: sharedExternal,
+});
+console.log(`Built ${teamOutfile}`);

package/scripts/build-runtime-cli.mjs

@@ -19,6 +19,8 @@ await esbuild.build({
     'child_process', 'assert', 'module', 'net', 'tls',
     'dns', 'readline', 'tty', 'worker_threads',
     '@ast-grep/napi', 'better-sqlite3',
+    // jsonc-parser has dynamic requires that don't bundle well; we use a custom parser
+    'jsonc-parser',
   ],
 });
 console.log(`Built ${outfile}`);

package/scripts/context-guard-stop.mjs

@@ -20,8 +20,9 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, openSync, readSync, closeSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { tmpdir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { tmpdir, homedir } from 'node:os';
+import { execSync } from 'node:child_process';
 import { readStdin } from './lib/stdin.mjs';
 
 const THRESHOLD = parseInt(process.env.OMC_CONTEXT_GUARD_THRESHOLD || '75', 10);
@@ -63,6 +64,67 @@ function isUserAbort(data) {
   );
 }
 
+/**
+ * Resolve a transcript path that may be mismatched in worktree sessions (issue #1094).
+ * When Claude Code runs inside .claude/worktrees/X, the encoded project directory
+ * contains `--claude-worktrees-X` which doesn't exist. Strip it to find the real path.
+ */
+function resolveTranscriptPath(transcriptPath, cwd) {
+  if (!transcriptPath) return transcriptPath;
+  try {
+    if (existsSync(transcriptPath)) return transcriptPath;
+  } catch { /* fallthrough */ }
+
+  // Strategy 1: Strip Claude worktree segment from encoded project directory
+  const worktreePattern = /--claude-worktrees-[^/\\]+/;
+  if (worktreePattern.test(transcriptPath)) {
+    const resolved = transcriptPath.replace(worktreePattern, '');
+    try {
+      if (existsSync(resolved)) return resolved;
+    } catch { /* fallthrough */ }
+  }
+
+  // Strategy 2: Detect native git worktree via git-common-dir.
+  // When CWD is a linked worktree (created by `git worktree add`), the
+  // transcript path encodes the worktree CWD, but the file lives under
+  // the main repo's encoded path.
+  const effectiveCwd = cwd || process.cwd();
+  try {
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const absoluteCommonDir = resolve(effectiveCwd, gitCommonDir);
+    const mainRepoRoot = dirname(absoluteCommonDir);
+
+    const worktreeTop = execSync('git rev-parse --show-toplevel', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    if (mainRepoRoot !== worktreeTop) {
+      const lastSep = transcriptPath.lastIndexOf('/');
+      const sessionFile = lastSep !== -1 ? transcriptPath.substring(lastSep + 1) : '';
+      if (sessionFile) {
+        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+        const projectsDir = join(configDir, 'projects');
+        if (existsSync(projectsDir)) {
+          const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
+          const resolvedPath = join(projectsDir, encodedMain, sessionFile);
+          try {
+            if (existsSync(resolvedPath)) return resolvedPath;
+          } catch { /* fallthrough */ }
+        }
+      }
+    }
+  } catch { /* not in a git repo or git not available — skip */ }
+
+  return transcriptPath;
+}
+
 /**
  * Estimate context usage percentage from the transcript file.
  */
@@ -148,7 +210,8 @@ async function main() {
     }
 
     const sessionId = data.session_id || data.sessionId || '';
-    const transcriptPath = data.transcript_path || data.transcriptPath || '';
+    const rawTranscriptPath = data.transcript_path || data.transcriptPath || '';
+    const transcriptPath = resolveTranscriptPath(rawTranscriptPath, data.cwd);
     const pct = estimateContextPercent(transcriptPath);
 
     if (pct >= THRESHOLD) {

package/scripts/context-safety.mjs

@@ -15,9 +15,73 @@
  *   - Allow ({ continue: true, suppressOutput: true }) otherwise
  */
 
-import { statSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
 import { readStdin } from './lib/stdin.mjs';
 
+/**
+ * Resolve a transcript path that may be mismatched in worktree sessions (issue #1094).
+ * When Claude Code runs inside .claude/worktrees/X, the encoded project directory
+ * contains `--claude-worktrees-X` which doesn't exist. Strip it to find the real path.
+ */
+function resolveTranscriptPath(transcriptPath, cwd) {
+  if (!transcriptPath) return transcriptPath;
+  try {
+    if (existsSync(transcriptPath)) return transcriptPath;
+  } catch { /* fallthrough */ }
+
+  // Strategy 1: Strip Claude worktree segment from encoded project directory
+  const worktreePattern = /--claude-worktrees-[^/\\]+/;
+  if (worktreePattern.test(transcriptPath)) {
+    const resolved = transcriptPath.replace(worktreePattern, '');
+    try {
+      if (existsSync(resolved)) return resolved;
+    } catch { /* fallthrough */ }
+  }
+
+  // Strategy 2: Detect native git worktree via git-common-dir.
+  // When CWD is a linked worktree (created by `git worktree add`), the
+  // transcript path encodes the worktree CWD, but the file lives under
+  // the main repo's encoded path.
+  const effectiveCwd = cwd || process.cwd();
+  try {
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const absoluteCommonDir = resolve(effectiveCwd, gitCommonDir);
+    const mainRepoRoot = dirname(absoluteCommonDir);
+
+    const worktreeTop = execSync('git rev-parse --show-toplevel', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    if (mainRepoRoot !== worktreeTop) {
+      const lastSep = transcriptPath.lastIndexOf('/');
+      const sessionFile = lastSep !== -1 ? transcriptPath.substring(lastSep + 1) : '';
+      if (sessionFile) {
+        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+        const projectsDir = join(configDir, 'projects');
+        if (existsSync(projectsDir)) {
+          const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
+          const resolvedPath = join(projectsDir, encodedMain, sessionFile);
+          try {
+            if (existsSync(resolvedPath)) return resolvedPath;
+          } catch { /* fallthrough */ }
+        }
+      }
+    }
+  } catch { /* not in a git repo or git not available — skip */ }
+
+  return transcriptPath;
+}
+
 const THRESHOLD = parseInt(process.env.OMC_CONTEXT_SAFETY_THRESHOLD || '55', 10);
 // TeamCreate was removed from BLOCKED_TOOLS in issue #1006.
 // Blocking TeamCreate at high context caused silent fallback to regular subagents,
@@ -79,7 +143,8 @@ async function main() {
       return;
     }
 
-    const transcriptPath = data.transcript_path || data.transcriptPath || '';
+    const rawTranscriptPath = data.transcript_path || data.transcriptPath || '';
+    const transcriptPath = resolveTranscriptPath(rawTranscriptPath, data.cwd);
     const pct = estimateContextPercent(transcriptPath);
 
     if (pct >= THRESHOLD) {

package/scripts/keyword-detector.mjs

@@ -258,18 +258,7 @@ 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',
@@ -302,6 +291,13 @@ async function main() {
     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()) {
@@ -346,14 +342,7 @@ async function main() {
       matches.push({ name: 'autopilot', args: '' });
     }
 
-    // Ultrapilot keywords (legacy names, routes to team via compatibility facade)
-    if (/\b(ultrapilot|ultra-pilot)\b/i.test(cleanPrompt) ||
-        /\bparallel\s+build\b/i.test(cleanPrompt) ||
-        /\bswarm\s+build\b/i.test(cleanPrompt) ||
-        /\bswarm\s+\d+\s+agents?\b/i.test(cleanPrompt) ||
-        /\bcoordinated\s+agents\b/i.test(cleanPrompt)) {
-      matches.push({ name: 'ultrapilot', args: '' });
-    }
+    // Ultrapilot keywords removed — routed to team which is now explicit-only (/team).
 
     // Ultrawork keywords
     if (/\b(ultrawork|ulw|uw)\b/i.test(cleanPrompt)) {
@@ -361,13 +350,8 @@ async function main() {
     }
 
 
-    // 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".
 
     // Pipeline keywords
     if (/\b(pipeline)\b/i.test(cleanPrompt) || /\bchain\s+agents\b/i.test(cleanPrompt)) {
@@ -447,13 +431,13 @@ async function main() {
 
     // Handle cancel specially - clear states and emit
     if (resolved.length > 0 && resolved[0].name === 'cancel') {
-      clearStateFiles(directory, ['ralph', 'autopilot', 'team', 'ultrawork', 'swarm', 'pipeline'], sessionId);
+      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork', 'swarm', 'pipeline'], sessionId);
       console.log(JSON.stringify(createHookOutput(createSkillInvocation('cancel', prompt))));
       return;
     }
 
-    // Activate states for modes that need them
-    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'team', 'ultrawork'].includes(m.name));
+    // Activate states for modes that need them (team removed — explicit-only via /team skill)
+    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'ultrawork'].includes(m.name));
     for (const mode of stateModes) {
       activateState(directory, prompt, mode.name, sessionId);
     }
@@ -468,16 +452,10 @@ async function main() {
     // Special: Ralph with 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/scripts/persistent-mode.cjs

@@ -150,6 +150,41 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+/**
+ * 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.
  */
@@ -373,6 +408,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();
@@ -399,6 +466,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 with legacy fallback)
     const ralph = readStateFileWithSession(stateDir, "ralph-state.json", sessionId);
     const autopilot = readStateFileWithSession(stateDir, "autopilot-state.json", sessionId);
@@ -407,6 +480,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 omcTeams = readStateFileWithSession(stateDir, "omc-teams-state.json", sessionId);
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
@@ -417,6 +491,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 (ralph.state?.active && !isStaleState(ralph.state) && isSessionMatch(ralph.state, sessionId)) {
@@ -542,7 +622,7 @@ async function main() {
       }
     }
 
-    // Priority 6: Team (omc-teams / staged pipeline)
+    // 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"];
@@ -567,6 +647,31 @@ 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;
+        if (newCount <= 20) {
+          omcTeams.state.reinforcement_count = newCount;
+          omcTeams.state.last_checked_at = new Date().toISOString();
+          writeJsonFile(omcTeams.path, omcTeams.state);
+
+          // Fire-and-forget notification
+          sendStopNotification('omc-teams', omcTeams.state, sessionId, directory).catch(() => {});
+
+          console.log(
+            JSON.stringify({
+              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.`,
+            }),
+          );
+          return;
+        }
+      }
+    }
+
     // Priority 7: UltraQA (QA cycling)
     if (ultraqa.state?.active && !isStaleState(ultraqa.state) && isSessionMatch(ultraqa.state, sessionId)) {
       const cycle = ultraqa.state.cycle || 1;