claudecode-omc 4.4.4 → 4.4.6

package/scripts/build-runtime-cli.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import * as esbuild from 'esbuild';
+import { mkdir } from 'fs/promises';
+
+const outfile = 'bridge/runtime-cli.cjs';
+await mkdir('bridge', { recursive: true });
+
+await esbuild.build({
+  entryPoints: ['src/team/runtime-cli.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node18',
+  format: 'cjs',
+  outfile,
+  // Note: platform:'node' auto-externalizes all Node built-in subpaths (fs/promises, etc.)
+  external: [
+    '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',
+  ],
+});
+console.log(`Built ${outfile}`);

package/scripts/build-team-server.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/**
+ * Build script for the Team MCP server bundle.
+ * Bundles src/mcp/team-server.ts into bridge/team-mcp.cjs for plugin distribution.
+ */
+
+import * as esbuild from 'esbuild';
+import { mkdir } from 'fs/promises';
+
+const outfile = 'bridge/team-mcp.cjs';
+await mkdir('bridge', { recursive: true });
+
+await esbuild.build({
+  entryPoints: ['src/mcp/team-server.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node18',
+  format: 'cjs',
+  outfile,
+  external: [
+    'fs', 'fs/promises', 'path', 'os', 'util', 'stream', 'events',
+    'buffer', 'crypto', 'http', 'https', 'url',
+    'child_process', 'assert', 'module', 'net', 'tls',
+    'dns', 'readline', 'tty', 'worker_threads',
+  ],
+});
+
+console.log(`Built ${outfile}`);

package/scripts/cleanup-orphans.mjs

@@ -48,11 +48,8 @@ function findOrphanProcesses(filterTeam) {
 
   try {
     if (process.platform === 'win32') {
-      // Windows: use WMIC to find node/claude processes
-      const output = execSync(
-        'wmic process where "name like \'%node%\' or name like \'%claude%\'" get processid,commandline /format:csv',
-        { encoding: 'utf-8', timeout: 10000 }
-      ).trim();
+      const output = getWindowsProcessListOutput();
+      if (!output) return orphans;
 
       for (const line of output.split('\n')) {
         if (line.includes('--team-name') || line.includes('team_name')) {
@@ -100,6 +97,26 @@ function findOrphanProcesses(filterTeam) {
   return orphans;
 }
 
+function getWindowsProcessListOutput() {
+  try {
+    // Primary path: WMIC (legacy but still available on some systems).
+    return execSync(
+      'wmic process where "name like \'%node%\' or name like \'%claude%\'" get processid,commandline /format:csv',
+      { encoding: 'utf-8', timeout: 10000 }
+    ).trim();
+  } catch {
+    // Fallback: PowerShell CIM query for command line + PID.
+    try {
+      return execSync(
+        'powershell -NoProfile -NonInteractive -Command "$procs = Get-CimInstance Win32_Process -ErrorAction Stop | Where-Object { $_.Name -like \'*node*\' -or $_.Name -like \'*claude*\' }; $procs | ForEach-Object { [string]$_.CommandLine + \',\' + [string]$_.ProcessId }"',
+        { encoding: 'utf-8', timeout: 10000 }
+      ).trim();
+    } catch {
+      return '';
+    }
+  }
+}
+
 /**
  * Check if a team's config still exists (i.e., team is still active).
  */

package/scripts/context-safety.mjs

@@ -19,7 +19,11 @@ import { statSync, openSync, readSync, closeSync } from 'node:fs';
 import { readStdin } from './lib/stdin.mjs';
 
 const THRESHOLD = parseInt(process.env.OMC_CONTEXT_SAFETY_THRESHOLD || '55', 10);
-const BLOCKED_TOOLS = new Set(['TeamCreate', 'ExitPlanMode']);
+// TeamCreate was removed from BLOCKED_TOOLS in issue #1006.
+// Blocking TeamCreate at high context caused silent fallback to regular subagents,
+// defeating the team orchestration pipeline. TeamCreate is lightweight infrastructure
+// setup, not expensive model inference, so context pressure is not a concern.
+const BLOCKED_TOOLS = new Set(['ExitPlanMode']);
 
 /**
  * Estimate context usage percentage from the transcript file.

package/scripts/demo-team.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Quick demo: spawn a 2-worker tmux team and show the split panes.
+ * Usage: node scripts/demo-team.mjs
+ */
+import { startTeam } from '../dist/team/runtime.js';
+
+const config = {
+  teamName: 'demo',
+  workerCount: 2,
+  agentTypes: ['claude', 'claude'],
+  tasks: [
+    { subject: 'Write a haiku about tmux', description: 'Write a short haiku (3 lines, 5-7-5 syllables) about tmux split panes. Output it and exit.' },
+    { subject: 'Write a haiku about Claude', description: 'Write a short haiku (3 lines, 5-7-5 syllables) about AI assistants. Output it and exit.' },
+  ],
+  cwd: process.cwd(),
+};
+
+console.log('Starting team "demo" with 2 Claude workers...');
+const runtime = await startTeam(config);
+console.log('\nTeam started!');
+console.log(`  tmux session: ${runtime.sessionName}`);
+console.log(`  workers: ${runtime.workerNames.join(', ')}`);
+console.log(`  pane IDs: ${runtime.workerPaneIds.join(', ')}`);
+console.log('\nAttach with:');
+console.log(`  tmux attach -t ${runtime.sessionName}`);

package/scripts/keyword-detector.mjs

@@ -20,8 +20,6 @@
  * 13. ultrathink/think: Extended reasoning
  * 14. deepsearch: Codebase search (restricted patterns)
  * 15. analyze: Analysis mode (restricted patterns)
- * 16. codex/gpt: Delegate to Codex MCP (ask_codex)
- * 17. gemini: Delegate to Gemini MCP (ask_gemini)
  */
 
 import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
@@ -235,59 +233,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. Write a prompt file to \`.omc/prompts/${provider}-{purpose}-{timestamp}.md\` containing clear task instructions derived from the user's request
-2. Determine the appropriate agent_role from: ${config.roles}
-3. 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>
-
-User request:
-${originalPrompt}
-
-IMPORTANT: Do NOT invoke a skill. Delegate to the MCP tool 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.`;
 }
 
@@ -320,8 +273,7 @@ function resolveConflicts(matches) {
 
   // Sort by priority order
   const priorityOrder = ['cancel','ralph','autopilot','team','ultrawork',
-    '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;
@@ -463,16 +415,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 }));
@@ -554,20 +496,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/scripts/openclaw-gateway-demo.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * OpenClaw Gateway Demo
+ *
+ * A minimal HTTP gateway that receives OpenClaw payloads and wakes
+ * a clawdbot agent session via /hooks/agent. The agent processes the
+ * instruction and delivers its response to the configured Discord channel.
+ *
+ * Usage:
+ *   node scripts/openclaw-gateway-demo.mjs [--port 19876]
+ *
+ * Environment:
+ *   CLAWDBOT_GATEWAY_URL   - Clawdbot gateway base URL (default: http://127.0.0.1:18789)
+ *   CLAWDBOT_HOOKS_TOKEN   - Hooks auth token (required)
+ *   OPENCLAW_GATEWAY_PORT  - Port to listen on (default: 19876)
+ *   OPENCLAW_DISCORD_CHANNEL - Discord channel ID for delivery (default: #omc-dev)
+ */
+
+import { createServer } from "node:http";
+
+// Parse args
+const args = process.argv.slice(2);
+function getArg(name, env, fallback) {
+  const idx = args.indexOf(name);
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  return process.env[env] || fallback;
+}
+
+const PORT = Number(getArg("--port", "OPENCLAW_GATEWAY_PORT", "19876"));
+const CLAWDBOT_URL = getArg("--clawdbot-url", "CLAWDBOT_GATEWAY_URL", "http://127.0.0.1:18789");
+const HOOKS_TOKEN = process.env.CLAWDBOT_HOOKS_TOKEN;
+const CHANNEL_ID = getArg("--channel-id", "OPENCLAW_DISCORD_CHANNEL", "1468539002985644084");
+
+if (!HOOKS_TOKEN) {
+  console.error("[openclaw-gateway] CLAWDBOT_HOOKS_TOKEN is required");
+  process.exit(1);
+}
+
+/**
+ * Wake clawdbot agent via /hooks/agent.
+ *
+ * The agent receives the instruction as its prompt, processes it,
+ * and delivers the response to the target Discord channel.
+ */
+async function wakeClawdbotAgent(payload) {
+  const agentPayload = {
+    message: buildAgentMessage(payload),
+    name: "OpenClaw",
+    wakeMode: "now",
+    sessionKey: `openclaw:${payload.sessionId || "unknown"}`,
+    channel: "discord",
+    to: CHANNEL_ID,
+    deliver: true,
+  };
+
+  const url = `${CLAWDBOT_URL}/hooks/agent`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${HOOKS_TOKEN}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(agentPayload),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Clawdbot hooks ${res.status}: ${text}`);
+  }
+
+  return await res.json();
+}
+
+/**
+ * Build an agent message from the OpenClaw payload.
+ *
+ * The agent receives this as its prompt and can respond intelligently
+ * based on the event type, project context, and instruction.
+ */
+function buildAgentMessage(payload) {
+  const parts = [];
+  parts.push(`[OpenClaw Event: ${payload.event}]`);
+
+  if (payload.instruction) {
+    parts.push(`Instruction: ${payload.instruction}`);
+  }
+
+  if (payload.projectName) {
+    parts.push(`Project: ${payload.projectName}`);
+  }
+
+  if (payload.sessionId) {
+    parts.push(`Session: ${payload.sessionId}`);
+  }
+
+  // Add context fields if available
+  const ctx = payload.context || {};
+  if (ctx.contextSummary) {
+    parts.push(`Summary: ${ctx.contextSummary}`);
+  }
+  if (ctx.reason) {
+    parts.push(`Reason: ${ctx.reason}`);
+  }
+  if (ctx.toolName) {
+    parts.push(`Tool: ${ctx.toolName}`);
+  }
+
+  parts.push(`Timestamp: ${payload.timestamp || new Date().toISOString()}`);
+
+  parts.push("");
+  parts.push("Please acknowledge this OMC session event and provide a brief status update to #omc-dev.");
+
+  return parts.join("\n");
+}
+
+/** Read JSON body from request */
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+const server = createServer(async (req, res) => {
+  // Health check
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, gateway: "openclaw-demo", clawdbot: CLAWDBOT_URL }));
+    return;
+  }
+
+  // Only accept POST
+  if (req.method !== "POST") {
+    res.writeHead(405, { "Content-Type": "text/plain" });
+    res.end("Method Not Allowed");
+    return;
+  }
+
+  try {
+    const payload = await readBody(req);
+    const sid = (payload.sessionId || "unknown").slice(0, 8);
+    console.log(`[openclaw-gateway] Received: ${payload.event} from session ${sid}`);
+
+    const result = await wakeClawdbotAgent(payload);
+    console.log(`[openclaw-gateway] Woke clawdbot agent (runId: ${result.runId})`);
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, runId: result.runId }));
+  } catch (err) {
+    console.error(`[openclaw-gateway] Error:`, err.message);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: err.message }));
+  }
+});
+
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`[openclaw-gateway] Listening on http://127.0.0.1:${PORT}`);
+  console.log(`[openclaw-gateway] Clawdbot: ${CLAWDBOT_URL}/hooks/agent`);
+  console.log(`[openclaw-gateway] Target channel: ${CHANNEL_ID}`);
+});

package/scripts/persistent-mode.cjs

@@ -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
  */
 
 const {
@@ -18,7 +18,7 @@ const {
 const { join, dirname, resolve, normalize } = require("path");
 const { homedir } = require("os");
 
-async function readStdin(timeoutMs = 5000) {
+async function readStdin(timeoutMs = 2000) {
   return new Promise((resolve) => {
     const chunks = [];
     let settled = false;
@@ -406,6 +406,7 @@ async function main() {
     const ultrawork = readStateFileWithSession(stateDir, "ultrawork-state.json", sessionId);
     const ultraqa = readStateFileWithSession(stateDir, "ultraqa-state.json", sessionId);
     const pipeline = readStateFileWithSession(stateDir, "pipeline-state.json", sessionId);
+    const team = readStateFileWithSession(stateDir, "team-state.json", sessionId);
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
@@ -541,7 +542,32 @@ async function main() {
       }
     }
 
-    // Priority 6: UltraQA (QA cycling)
+    // Priority 6: Team (omc-teams / staged pipeline)
+    if (team.state?.active && !isStaleState(team.state) && isSessionMatch(team.state, sessionId)) {
+      const phase = team.state.current_phase || "executing";
+      const terminalPhases = ["completed", "complete", "failed", "cancelled"];
+      if (!terminalPhases.includes(phase)) {
+        const newCount = (team.state.reinforcement_count || 0) + 1;
+        if (newCount <= 20) {
+          team.state.reinforcement_count = newCount;
+          team.state.last_checked_at = new Date().toISOString();
+          writeJsonFile(team.path, team.state);
+
+          // Fire-and-forget notification
+          sendStopNotification('team', team.state, sessionId, directory).catch(() => {});
+
+          console.log(
+            JSON.stringify({
+              decision: "block",
+              reason: `[TEAM - Phase: ${phase}] Team mode active. Continue working. When all team tasks complete, run /oh-my-claudecode:cancel to cleanly exit. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
+            }),
+          );
+          return;
+        }
+      }
+    }
+
+    // Priority 7: UltraQA (QA cycling)
     if (ultraqa.state?.active && !isStaleState(ultraqa.state) && isSessionMatch(ultraqa.state, sessionId)) {
       const cycle = ultraqa.state.cycle || 1;
       const maxCycles = ultraqa.state.max_cycles || 10;
@@ -563,7 +589,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)
     // Project isolation: only block if state belongs to this project

package/scripts/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 {
@@ -444,6 +444,12 @@ 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
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
@@ -654,7 +660,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) &&
@@ -688,7 +733,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.

package/scripts/plugin-setup.mjs

@@ -59,7 +59,9 @@ async function main() {
   const home = homedir();
 
   // 1. Try plugin cache first (marketplace: omc, plugin: oh-my-claudecode)
-  const pluginCacheBase = join(home, ".claude/plugins/cache/omc/oh-my-claudecode");
+  // Respect CLAUDE_CONFIG_DIR so installs under a custom config dir are found
+  const configDir = process.env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+  const pluginCacheBase = join(configDir, "plugins", "cache", "omc", "oh-my-claudecode");
   if (existsSync(pluginCacheBase)) {
     try {
       const versions = readdirSync(pluginCacheBase);
@@ -90,7 +92,7 @@ async function main() {
   for (const devPath of devPaths) {
     if (existsSync(devPath)) {
       try {
-        await import(devPath);
+        await import(pathToFileURL(devPath).href);
         return;
       } catch { /* continue */ }
     }
@@ -121,7 +123,7 @@ try {
   const nodeBin = process.execPath || 'node';
   settings.statusLine = {
     type: 'command',
-    command: `${nodeBin} ${hudScriptPath.replace(/\\/g, "/")}`
+    command: `"${nodeBin}" "${hudScriptPath.replace(/\\/g, "/")}"`
   };
   writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
   console.log('[OMC] Configured HUD statusLine in settings.json');
@@ -145,4 +147,65 @@ try {
   console.log('[OMC] Warning: Could not configure settings.json:', e.message);
 }
 
+// Patch hooks.json to use the absolute node binary path so hooks work on all
+// platforms: Windows (no `sh`), nvm/fnm users (node not on PATH in hooks), etc.
+//
+// The source hooks.json uses `node run.cjs` as a portable template; this step
+// substitutes the real process.execPath so Claude Code always invokes the same
+// Node binary that ran this setup script.
+//
+// Two patterns are handled:
+//  1. New format  – node "${CLAUDE_PLUGIN_ROOT}/scripts/run.cjs" ... (all platforms)
+//  2. Old format  – sh  "${CLAUDE_PLUGIN_ROOT}/scripts/find-node.sh" ... (Windows
+//     backward-compat: migrates old installs to the new run.cjs chain)
+//
+// Fixes issues #909, #899, #892, #869.
+try {
+  const hooksJsonPath = join(__dirname, '..', 'hooks', 'hooks.json');
+  if (existsSync(hooksJsonPath)) {
+    const data = JSON.parse(readFileSync(hooksJsonPath, 'utf-8'));
+    let patched = false;
+
+    // Pattern 1 (new): node "${CLAUDE_PLUGIN_ROOT}/scripts/run.cjs" <rest>
+    const runCjsPattern =
+      /^node ("\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/run\.cjs".*)$/;
+
+    // Pattern 2 (old, Windows backward-compat): sh find-node.sh <target> [args]
+    const findNodePattern =
+      /^sh "\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/find-node\.sh" "(\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/[^"]+)"(.*)$/;
+
+    for (const groups of Object.values(data.hooks ?? {})) {
+      for (const group of groups) {
+        for (const hook of (group.hooks ?? [])) {
+          if (typeof hook.command !== 'string') continue;
+
+          // New run.cjs format — replace bare `node` with absolute path (all platforms)
+          const m1 = hook.command.match(runCjsPattern);
+          if (m1) {
+            hook.command = `"${nodeBin}" ${m1[1]}`;
+            patched = true;
+            continue;
+          }
+
+          // Old find-node.sh format — migrate to run.cjs + absolute path (Windows only)
+          if (process.platform === 'win32') {
+            const m2 = hook.command.match(findNodePattern);
+            if (m2) {
+              hook.command = `"${nodeBin}" "\${CLAUDE_PLUGIN_ROOT}/scripts/run.cjs" "${m2[1]}"${m2[2]}`;
+              patched = true;
+            }
+          }
+        }
+      }
+    }
+
+    if (patched) {
+      writeFileSync(hooksJsonPath, JSON.stringify(data, null, 2) + '\n');
+      console.log(`[OMC] Patched hooks.json with absolute node path (${nodeBin}), fixes issues #909, #899, #892`);
+    }
+  }
+} catch (e) {
+  console.log('[OMC] Warning: Could not patch hooks.json:', e.message);
+}
+
 console.log('[OMC] Setup complete! Restart Claude Code to activate HUD.');