claudecode-omc 4.5.7 → 4.7.4

package/scripts/run-provider-advisor.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { spawnSync } from 'child_process';
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import process from 'process';
+
+const PROVIDER_BINARIES = {
+  claude: 'claude',
+  codex: 'codex',
+  gemini: 'gemini',
+};
+
+/**
+ * Build CLI args for a given provider.
+ * - claude: `claude -p <prompt>`
+ * - codex: `codex exec --dangerously-bypass-approvals-and-sandbox <prompt>`
+ * - gemini: `gemini -p <prompt> --yolo`
+ */
+function buildProviderArgs(provider, prompt) {
+  if (provider === 'codex') {
+    return ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt];
+  }
+  if (provider === 'gemini') {
+    return ['-p', prompt, '--yolo'];
+  }
+  return ['-p', prompt];
+}
+
+const ASK_ORIGINAL_TASK_ENV = 'OMC_ASK_ORIGINAL_TASK';
+const ASK_ORIGINAL_TASK_ENV_ALIAS = 'OMX_ASK_ORIGINAL_TASK';
+
+function usage() {
+  console.error('Usage: omc ask <claude|codex|gemini> "<prompt>"');
+  console.error('Legacy direct usage: node scripts/run-provider-advisor.js <claude|codex|gemini> <prompt...>');
+  console.error('                 or: node scripts/run-provider-advisor.js claude --print "<prompt>"');
+  console.error('                 or: node scripts/run-provider-advisor.js gemini --prompt "<prompt>"');
+}
+
+function slugify(value) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'task';
+}
+
+function timestampToken(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function parseArgs(argv) {
+  const [providerRaw, ...rest] = argv;
+  const provider = (providerRaw || '').toLowerCase();
+
+  if (!provider || !(provider in PROVIDER_BINARIES)) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest.length === 0) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest[0] === '-p' || rest[0] === '--print' || rest[0] === '--prompt') {
+    const prompt = rest.slice(1).join(' ').trim();
+    if (!prompt) {
+      usage();
+      process.exit(1);
+    }
+    return { provider, prompt };
+  }
+
+  return { provider, prompt: rest.join(' ').trim() };
+}
+
+function ensureBinary(binary) {
+  const probe = spawnSync(binary, ['--version'], {
+    stdio: 'ignore',
+    encoding: 'utf8',
+  });
+
+  if (probe.error && probe.error.code === 'ENOENT') {
+    const verify = `${binary} --version`;
+    console.error(`[ask-${binary}] Missing required local CLI binary: ${binary}`);
+    console.error(`[ask-${binary}] Install/configure ${binary} CLI, then verify with: ${verify}`);
+    process.exit(1);
+  }
+}
+
+function buildSummary(exitCode, output) {
+  if (exitCode === 0) {
+    return 'Provider completed successfully. Review the raw output for details.';
+  }
+
+  const firstLine = output
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean);
+
+  return firstLine
+    ? `Provider command failed (exit ${exitCode}): ${firstLine}`
+    : `Provider command failed with exit code ${exitCode}.`;
+}
+
+function buildActionItems(exitCode) {
+  if (exitCode === 0) {
+    return [
+      'Review the response and extract decisions you want to apply.',
+      'Capture follow-up implementation tasks if needed.',
+    ];
+  }
+
+  return [
+    'Inspect the raw output error details.',
+    'Fix CLI/auth/environment issues and rerun the command.',
+  ];
+}
+
+function resolveOriginalTask(prompt) {
+  const canonical = process.env[ASK_ORIGINAL_TASK_ENV];
+  if (canonical && canonical.trim()) {
+    return canonical;
+  }
+
+  const alias = process.env[ASK_ORIGINAL_TASK_ENV_ALIAS];
+  if (alias && alias.trim()) {
+    console.error(`[ask] DEPRECATED: ${ASK_ORIGINAL_TASK_ENV_ALIAS} is deprecated; use ${ASK_ORIGINAL_TASK_ENV} instead.`);
+    return alias;
+  }
+
+  return prompt;
+}
+
+async function writeArtifact({ provider, originalTask, finalPrompt, rawOutput, exitCode }) {
+  const root = process.cwd();
+  const artifactDir = join(root, '.omc', 'artifacts', 'ask');
+  const slug = slugify(originalTask);
+  const timestamp = timestampToken();
+  const artifactPath = join(artifactDir, `${provider}-${slug}-${timestamp}.md`);
+
+  const summary = buildSummary(exitCode, rawOutput);
+  const actionItems = buildActionItems(exitCode);
+
+  const body = [
+    `# ${provider} advisor artifact`,
+    '',
+    `- Provider: ${provider}`,
+    `- Exit code: ${exitCode}`,
+    `- Created at: ${new Date().toISOString()}`,
+    '',
+    '## Original task',
+    '',
+    originalTask,
+    '',
+    '## Final prompt',
+    '',
+    finalPrompt,
+    '',
+    '## Raw output',
+    '',
+    '```text',
+    rawOutput || '(no output)',
+    '```',
+    '',
+    '## Concise summary',
+    '',
+    summary,
+    '',
+    '## Action items',
+    '',
+    ...actionItems.map((item) => `- ${item}`),
+    '',
+  ].join('\n');
+
+  await mkdir(artifactDir, { recursive: true });
+  await writeFile(artifactPath, body, 'utf8');
+  return artifactPath;
+}
+
+async function main() {
+  const { provider, prompt } = parseArgs(process.argv.slice(2));
+  const binary = PROVIDER_BINARIES[provider];
+
+  ensureBinary(binary);
+
+  const providerArgs = buildProviderArgs(provider, prompt);
+  const run = spawnSync(binary, providerArgs, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  const stdout = run.stdout || '';
+  const stderr = run.stderr || '';
+  const rawOutput = [stdout, stderr].filter(Boolean).join(stdout && stderr ? '\n\n' : '');
+  const exitCode = typeof run.status === 'number' ? run.status : 1;
+
+  const artifactPath = await writeArtifact({
+    provider,
+    originalTask: resolveOriginalTask(prompt),
+    finalPrompt: prompt,
+    rawOutput,
+    exitCode,
+  });
+
+  console.log(artifactPath);
+
+  if (run.error) {
+    console.error(`[ask-${provider}] ${run.error.message}`);
+  }
+
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+main().catch((error) => {
+  console.error(`[run-provider-advisor] ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/scripts/session-start.mjs

@@ -207,9 +207,9 @@ async function checkNpmUpdate(currentVersion) {
 // Check if HUD is properly installed (with retry for race conditions)
 async function checkHudInstallation(retryCount = 0) {
   const hudDir = join(configDir, 'hud');
-  // Support both legacy (omc-hud.mjs) and current (omc-hud.mjs) naming
+  // Support current and legacy script names
   const hudScriptOmc = join(hudDir, 'omc-hud.mjs');
-  const hudScriptLegacy = join(hudDir, 'omc-hud.mjs');
+  const hudScriptLegacy = join(hudDir, 'omc-hud.js');
   const settingsFile = join(configDir, 'settings.json');
 
   const MAX_RETRIES = 2;
@@ -243,6 +243,35 @@ async function checkHudInstallation(retryCount = 0) {
         }
         return { installed: false, reason: 'statusLine not configured' };
       }
+
+      const statusLineCommand = typeof settings.statusLine === 'string'
+        ? settings.statusLine
+        : (typeof settings.statusLine === 'object' && settings.statusLine && typeof settings.statusLine.command === 'string'
+          ? settings.statusLine.command
+          : null);
+
+      // If OMC HUD wrapper is configured, ensure at least one plugin cache version is built.
+      if (statusLineCommand?.includes('omc-hud')) {
+        const pluginCacheBase = join(configDir, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
+        if (existsSync(pluginCacheBase)) {
+          const versions = readdirSync(pluginCacheBase)
+            .filter(version => !version.startsWith('.'))
+            .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))
+            .reverse();
+          if (versions.length > 0) {
+            const hasBuiltHud = versions.some(version =>
+              existsSync(join(pluginCacheBase, version, 'dist', 'hud', 'index.js'))
+            );
+            if (!hasBuiltHud) {
+              const latestVersionDir = join(pluginCacheBase, versions[0]);
+              return {
+                installed: false,
+                reason: `HUD plugin cache is not built. Run: cd "${latestVersionDir}" && npm install && npm run build`,
+              };
+            }
+          }
+        }
+      }
     } else {
       return { installed: false, reason: 'settings.json missing' };
     }
@@ -498,6 +527,17 @@ ${cleanContent}
           projectPath: directory,
           timestamp: new Date().toISOString(),
         }).catch(() => {}); // swallow errors silently
+
+        // Start reply listener daemon if notification reply config is available
+        try {
+          const { startReplyListener, buildDaemonConfig } = await import(pathToFileURL(join(pluginRoot, 'dist', 'notifications', 'reply-listener.js')).href);
+          const replyConfig = await buildDaemonConfig();
+          if (replyConfig) {
+            startReplyListener(replyConfig);
+          }
+        } catch {
+          // Reply listener not available or not configured, skip silently
+        }
       }
     } catch {
       // Notification module not available, skip silently

package/skills/AGENTS.md

@@ -1,9 +1,9 @@
 <!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-01-28 | Updated: 2026-03-03 -->
+<!-- Generated: 2026-01-28 | Updated: 2026-03-02 -->
 
 # skills
 
-41 skill directories for workflow automation and specialized behaviors (43 runtime skill names including compatibility aliases).
+37 skill directories for workflow automation and specialized behaviors.
 
 ## Purpose
 
@@ -21,18 +21,16 @@ Skills are reusable workflow templates that can be invoked via `/oh-my-claudecod
 | `autopilot/SKILL.md` | autopilot | Full autonomous execution from idea to working code |
 | `ultrawork/SKILL.md` | ultrawork | Maximum parallel agent execution |
 | `ralph/SKILL.md` | ralph | Persistence until verified complete |
-| `ultrapilot/SKILL.md` | ultrapilot | Parallel autopilot with file ownership |
-| `team/SKILL.md` | team (+ `swarm` alias) | N coordinated agents with task claiming |
-| `pipeline/SKILL.md` | pipeline | Sequential agent chaining |
+| `team/SKILL.md` | team | N coordinated agents with task claiming |
 | `ultraqa/SKILL.md` | ultraqa | QA cycling until goal met |
 
 ### Planning Skills
 
 | File | Skill | Purpose |
 |-----------|-------|---------|
-| `plan/SKILL.md` | plan | Strategic planning with interview workflow |
+| `plan/SKILL.md` | omc-plan | Strategic planning with interview workflow |
 | `ralplan/SKILL.md` | ralplan | Iterative planning (Planner+Architect+Critic) with RALPLAN-DR structured deliberation (`--deliberate` for high-risk) |
-| `review/SKILL.md` | review | Review plan with Critic |
+| `deep-interview/SKILL.md` | deep-interview | Socratic deep interview with mathematical ambiguity gating (Ouroboros-inspired) |
 | `analyze/SKILL.md` | analyze | Deep analysis and investigation |
 | `ralph-init/SKILL.md` | ralph-init | Initialize PRD for structured ralph |
 | `quick-init-project/SKILL.md` | quick-init-project | Intelligent project bootstrap with mode selection (fullstack/frontend/backend/demo) and data-driven tech stack recommendations |
@@ -51,7 +49,6 @@ Skills are reusable workflow templates that can be invoked via `/oh-my-claudecod
 
 | File | Skill | Purpose |
 |-----------|-------|---------|
-| `deepsearch/SKILL.md` | deepsearch | Thorough codebase search |
 | `deepinit/SKILL.md` | deepinit | Generate hierarchical AGENTS.md |
 | `sciomc/SKILL.md` | sciomc | Parallel scientist orchestration |
 
@@ -59,23 +56,22 @@ Skills are reusable workflow templates that can be invoked via `/oh-my-claudecod
 
 | File | Skill | Purpose |
 |-----------|-------|---------|
-| `orchestrate/SKILL.md` | orchestrate | Core multi-agent orchestration (always active) |
 | `learner/SKILL.md` | learner | Extract reusable skill from session |
+| `ask-codex/SKILL.md` | ask-codex | Ask Codex via `omc ask codex` and capture an artifact |
+| `ask-gemini/SKILL.md` | ask-gemini | Ask Gemini via `omc ask gemini` and capture an artifact |
 | `note/SKILL.md` | note | Save notes for compaction resilience |
 | `cancel/SKILL.md` | cancel | Cancel any active OMC mode |
 | `hud/SKILL.md` | hud | Configure HUD display |
-| `doctor/SKILL.md` | doctor | Diagnose installation issues |
+| `omc-doctor/SKILL.md` | omc-doctor | Diagnose installation issues |
 | `omc-setup/SKILL.md` | omc-setup | One-time setup wizard |
+| `omc-help/SKILL.md` | omc-help | Usage guide |
 | `mcp-setup/SKILL.md` | mcp-setup | Configure MCP servers |
-| `help/SKILL.md` | help | Usage guide |
 | `skill/SKILL.md` | skill | Manage local skills |
 
 ### Domain Skills
 
 | File | Skill | Purpose |
 |-----------|-------|---------|
-| `frontend-ui-ux/SKILL.md` | frontend-ui-ux | Designer-developer aesthetic |
-| `git-master/SKILL.md` | git-master | Git expertise, atomic commits |
 | `project-session-manager/SKILL.md` | project-session-manager (+ `psm` alias) | Isolated dev environments |
 | `writer-memory/SKILL.md` | writer-memory | Agentic memory for writers |
 | `release/SKILL.md` | release | Automated release workflow |
@@ -178,12 +174,12 @@ None - pure markdown files.
 
 | Category | Skills | Trigger Keywords |
 |----------|--------|------------------|
-| Execution | autopilot, ultrawork, ralph, ultrapilot, swarm, pipeline | "autopilot", "ulw", "ralph", "swarm", "eco" |
-| Planning | plan, ralplan, review, analyze, ralph-init | "plan this", "analyze" |
+| Execution | autopilot, ultrawork, ralph, team, ultraqa | "autopilot", "ulw", "ralph", "team" |
+| Planning | omc-plan, ralplan, deep-interview, analyze, ralph-init | "plan this", "analyze", "interview me", "ouroboros" |
 | Quality | code-review, security-review, tdd, build-fix | "review", "security", "tdd" |
-| Exploration | deepsearch, deepinit, research | "search", "research" |
-| Utility | learner, note, cancel, hud, doctor, omc-setup, mcp-setup, help | "stop", "cancel" |
-| Domain | frontend-ui-ux, git-master, psm, writer-memory, release | UI context, git context |
+| Exploration | deepinit, sciomc, external-context | "deepinit", "research" |
+| Utility | learner, note, cancel, hud, omc-doctor, omc-setup, omc-help, mcp-setup | "stop", "cancel" |
+| Domain | psm, writer-memory, release | psm context |
 
 ## Auto-Activation
 
@@ -194,8 +190,7 @@ Some skills activate automatically based on context:
 | autopilot | "autopilot", "build me", "I want a" |
 | ultrawork | "ulw", "ultrawork" |
 | ralph | "ralph", "don't stop until" |
-| frontend-ui-ux | UI/component work detected |
-| git-master | Git operations detected |
+| deep-interview | "deep interview", "interview me", "ouroboros", "don't assume" |
 | cancel | "stop", "cancel", "abort" |
 
 <!-- MANUAL:

package/skills/ask-codex/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: ask-codex
+description: Ask Codex via local CLI and capture a reusable artifact
+---
+
+# Ask Codex
+
+Use Codex as an external advisor through OMC's ask command.
+
+## Usage
+
+```bash
+/oh-my-claudecode:ask-codex <question or task>
+```
+
+## Routing
+
+Preferred path:
+
+```bash
+omc ask codex "{{ARGUMENTS}}"
+```
+
+Wrapper alias (compatibility):
+
+```bash
+bash "${CLAUDE_PLUGIN_ROOT}/scripts/ask-codex.sh" "{{ARGUMENTS}}"
+```
+
+## Requirements
+
+- Local Codex CLI must be installed and authenticated.
+- Verify with:
+
+```bash
+codex --version
+```
+
+## Artifacts
+
+`omc ask` writes artifacts to:
+
+```text
+.omc/artifacts/ask/codex-<slug>-<timestamp>.md
+```
+
+Task: {{ARGUMENTS}}

package/skills/ask-gemini/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: ask-gemini
+description: Ask Gemini via local CLI and capture a reusable artifact
+---
+
+# Ask Gemini
+
+Use Gemini as an external advisor through OMC's ask command.
+
+## Usage
+
+```bash
+/oh-my-claudecode:ask-gemini <question or task>
+```
+
+## Routing
+
+Preferred path:
+
+```bash
+omc ask gemini "{{ARGUMENTS}}"
+```
+
+Wrapper alias (compatibility):
+
+```bash
+bash "${CLAUDE_PLUGIN_ROOT}/scripts/ask-gemini.sh" "{{ARGUMENTS}}"
+```
+
+## Requirements
+
+- Local Gemini CLI must be installed and authenticated.
+- Verify with:
+
+```bash
+gemini --version
+```
+
+## Artifacts
+
+`omc ask` writes artifacts to:
+
+```text
+.omc/artifacts/ask/gemini-<slug>-<timestamp>.md
+```
+
+Task: {{ARGUMENTS}}

package/skills/autopilot/SKILL.md

@@ -36,18 +36,22 @@ Most non-trivial software tasks require coordinated phases: understanding requir
 
 <Steps>
 1. **Phase 0 - Expansion**: Turn the user's idea into a detailed spec
-   - Analyst (Opus): Extract requirements
-   - Architect (Opus): Create technical specification
+   - **If ralplan consensus plan exists** (`.omc/plans/ralplan-*.md` or `.omc/plans/consensus-*.md` from the 3-stage pipeline): Skip BOTH Phase 0 and Phase 1 — jump directly to Phase 2 (Execution). The plan has already been Planner/Architect/Critic validated.
+   - **If deep-interview spec exists** (`.omc/specs/deep-interview-*.md`): Skip analyst+architect expansion, use the pre-validated spec directly as Phase 0 output. Continue to Phase 1 (Planning).
+   - **If input is vague** (no file paths, function names, or concrete anchors): Offer redirect to `/deep-interview` for Socratic clarification before expanding
+   - **Otherwise**: Analyst (Opus) extracts requirements, Architect (Opus) creates technical specification
    - Output: `.omc/autopilot/spec.md`
 
 2. **Phase 1 - Planning**: Create an implementation plan from the spec
+   - **If ralplan consensus plan exists**: Skip — already done in the 3-stage pipeline
    - Architect (Opus): Create plan (direct mode, no interview)
    - Critic (Opus): Validate plan
    - Output: `.omc/plans/autopilot-impl.md`
 
 3. **Phase 2 - Execution**: Implement the plan using Ralph + Ultrawork
-   - Executor (Sonnet): Standard implementation tasks
-   - Deep-executor (Opus): Complex autonomous tasks
+   - Executor (Haiku): Simple tasks
+   - Executor (Sonnet): Standard tasks
+   - Executor (Opus): Complex tasks
    - Run independent tasks in parallel
 
 4. **Phase 3 - QA**: Cycle until all tests pass (UltraQA mode)
@@ -97,7 +101,7 @@ Why bad: This is an exploration/brainstorming request. Respond conversationally
 - Stop and report when the same QA error persists across 3 cycles (fundamental issue requiring human input)
 - Stop and report when validation keeps failing after 3 re-validation rounds
 - Stop when the user says "stop", "cancel", or "abort"
-- If requirements were too vague and expansion produces an unclear spec, pause and ask the user for clarification before proceeding
+- If requirements were too vague and expansion produces an unclear spec, offer redirect to `/deep-interview` for Socratic clarification, or pause and ask the user for clarification before proceeding
 </Escalation_And_Stop_Conditions>
 
 <Final_Checklist>
@@ -144,4 +148,34 @@ If autopilot was cancelled or failed, run `/oh-my-claudecode:autopilot` again to
 **QA cycles exhausted?** The same error 3 times indicates a fundamental issue. Review the error pattern; manual intervention may be needed.
 
 **Validation keeps failing?** Review the specific issues. Requirements may have been too vague -- cancel and provide more detail.
+
+## Deep Interview Integration
+
+When autopilot is invoked with a vague input, Phase 0 can redirect to `/deep-interview` for Socratic clarification:
+
+```
+User: "autopilot build me something cool"
+Autopilot: "Your request is open-ended. Would you like to run a deep interview first?"
+  [Yes, interview first (Recommended)] [No, expand directly]
+```
+
+If a deep-interview spec already exists at `.omc/specs/deep-interview-*.md`, autopilot uses it directly as Phase 0 output (the spec has already been mathematically validated for clarity).
+
+### 3-Stage Pipeline: deep-interview → ralplan → autopilot
+
+The recommended full pipeline chains three quality gates:
+
+```
+/deep-interview "vague idea"
+  → Socratic Q&A → spec (ambiguity ≤ 20%)
+  → /ralplan --direct → consensus plan (Planner/Architect/Critic approved)
+  → /autopilot → skips Phase 0+1, starts at Phase 2 (Execution)
+```
+
+When autopilot detects a ralplan consensus plan (`.omc/plans/ralplan-*.md` or `.omc/plans/consensus-*.md`), it skips both Phase 0 (Expansion) and Phase 1 (Planning) because the plan has already been:
+- Requirements-validated (deep-interview ambiguity gate)
+- Architecture-reviewed (ralplan Architect agent)
+- Quality-checked (ralplan Critic agent)
+
+Autopilot starts directly at Phase 2 (Execution via Ralph + Ultrawork).
 </Advanced>