videoclaw 3.0.0-alpha.1

package/skills/deep-interview/SKILL.md

@@ -0,0 +1,358 @@
+---
+name: deep-interview
+description: Socratic deep interview with mathematical ambiguity gating before execution
+argument-hint: "[--quick|--standard|--deep] [--autoresearch] <idea or vague description>"
+---
+
+<Purpose>
+Deep Interview is an intent-first Socratic clarification loop before planning or implementation. It turns vague ideas into execution-ready specifications by asking targeted questions about why the user wants a change, how far it should go, what should stay out of scope, and what OMX may decide without confirmation.
+</Purpose>
+
+<Use_When>
+- The request is broad, ambiguous, or missing concrete acceptance criteria
+- The user says "deep interview", "interview me", "ask me everything", "don't assume", or "ouroboros"
+- The user wants to avoid misaligned implementation from underspecified requirements
+- You need a requirements artifact before handing off to `ralplan`, `autopilot`, `ralph`, or `team`
+</Use_When>
+
+<Do_Not_Use_When>
+- The request already has concrete file/symbol targets and clear acceptance criteria
+- The user explicitly asks to skip planning/interview and execute immediately
+- The user asks for lightweight brainstorming only (use `plan` instead)
+- A complete PRD/plan already exists and execution should start
+</Do_Not_Use_When>
+
+<Why_This_Exists>
+Execution quality is usually bottlenecked by intent clarity, not just missing implementation detail. A single expansion pass often misses why the user wants a change, where the scope should stop, which tradeoffs are unacceptable, and which decisions still require user approval. This workflow applies Socratic pressure + quantitative ambiguity scoring so orchestration modes begin with an explicit, testable, intent-aligned spec.
+</Why_This_Exists>
+
+<Depth_Profiles>
+- **Quick (`--quick`)**: fast pre-PRD pass; target threshold `<= 0.30`; max rounds 5
+- **Standard (`--standard`, default)**: full requirement interview; target threshold `<= 0.20`; max rounds 12
+- **Deep (`--deep`)**: high-rigor exploration; target threshold `<= 0.15`; max rounds 20
+- **Autoresearch (`--autoresearch`)**: same interview rigor as Standard, but specialized for `omx autoresearch` launch readiness and `.omx/specs/` mission/sandbox artifact handoff
+
+If no flag is provided, use **Standard**.
+
+<Mode_Flags>
+- **`--autoresearch`**: switch the interview into autoresearch-intake mode for `omx autoresearch` handoff. In this mode, the interview should converge on a launch-ready research mission, write canonical artifacts under `.omx/specs/`, and preserve the explicit `refine further` vs `launch` boundary for downstream CLI intake.
+</Mode_Flags>
+</Depth_Profiles>
+
+<Execution_Policy>
+- Ask ONE question per round (never batch)
+- Ask about intent and boundaries before implementation detail
+- Target the weakest clarity dimension each round after applying the stage-priority rules below
+- Treat every answer as a claim to pressure-test before moving on: the next question should usually demand evidence or examples, expose a hidden assumption, force a tradeoff or boundary, or reframe root cause vs symptom
+- Do not rotate to a new clarity dimension just for coverage when the current answer is still vague; stay on the same thread until one layer deeper, one assumption clearer, or one boundary tighter
+- Before crystallizing, complete at least one explicit pressure pass that revisits an earlier answer with a deeper, assumption-focused, or tradeoff-focused follow-up
+- Gather codebase facts via `explore` before asking user about internals
+- When session guidance enables `USE_OMX_EXPLORE_CMD`, prefer `omx explore` for simple read-only brownfield fact gathering; keep prompts narrow and concrete, and keep ambiguous or non-shell-only investigation on the richer normal path and fall back normally if `omx explore` is unavailable.
+- Always run a preflight context intake before the first interview question
+- Reduce user effort: ask only the highest-leverage unresolved question, and never ask the user for codebase facts that can be discovered directly
+- For brownfield work, prefer evidence-backed confirmation questions such as "I found X in Y. Should this change follow that pattern?"
+- In Codex CLI, prefer `request_user_input` when available; if unavailable, fall back to concise plain-text one-question turns
+- Re-score ambiguity after each answer and show progress transparently
+- Do not hand off to execution while ambiguity remains above threshold unless user explicitly opts to proceed with warning
+- Do not crystallize or hand off while `Non-goals` or `Decision Boundaries` remain unresolved, even if the weighted ambiguity threshold is met
+- Treat early exit as a safety valve, not the default success path
+- Persist mode state for resume safety (`state_write` / `state_read`)
+</Execution_Policy>
+
+<Steps>
+
+## Phase 0: Preflight Context Intake
+
+1. Parse `{{ARGUMENTS}}` and derive a short task slug.
+2. Attempt to load the latest relevant context snapshot from `.omx/context/{slug}-*.md`.
+3. If no snapshot exists, create a minimum context snapshot with:
+   - Task statement
+   - Desired outcome
+   - Stated solution (what the user asked for)
+   - Probable intent hypothesis (why they likely want it)
+   - Known facts/evidence
+   - Constraints
+   - Unknowns/open questions
+   - Decision-boundary unknowns
+   - Likely codebase touchpoints
+4. Save snapshot to `.omx/context/{slug}-{timestamp}.md` (UTC `YYYYMMDDTHHMMSSZ`) and reference it in mode state.
+
+## Phase 1: Initialize
+
+1. Parse `{{ARGUMENTS}}` and depth profile (`--quick|--standard|--deep`).
+2. Detect project context:
+   - Run `explore` to classify **brownfield** (existing codebase target) vs **greenfield**.
+   - For brownfield, collect relevant codebase context before questioning.
+3. Initialize state via `state_write(mode="deep-interview")`:
+
+```json
+{
+  "active": true,
+  "current_phase": "deep-interview",
+  "state": {
+    "interview_id": "<uuid>",
+    "profile": "quick|standard|deep",
+    "type": "greenfield|brownfield",
+    "initial_idea": "<user input>",
+    "rounds": [],
+    "current_ambiguity": 1.0,
+    "threshold": 0.3,
+    "max_rounds": 5,
+    "challenge_modes_used": [],
+    "codebase_context": null,
+    "current_stage": "intent-first",
+    "current_focus": "intent",
+    "context_snapshot_path": ".omx/context/<slug>-<timestamp>.md"
+  }
+}
+```
+
+4. Announce kickoff with profile, threshold, and current ambiguity.
+
+## Phase 2: Socratic Interview Loop
+
+Repeat until ambiguity `<= threshold`, the pressure pass is complete, the readiness gates are explicit, the user exits with warning, or max rounds are reached.
+
+### 2a) Generate next question
+Use:
+- Original idea
+- Prior Q&A rounds
+- Current dimension scores
+- Brownfield context (if any)
+- Activated challenge mode injection (Phase 3)
+
+Target the lowest-scoring dimension, but respect stage priority:
+- **Stage 1 — Intent-first:** Intent, Outcome, Scope, Non-goals, Decision Boundaries
+- **Stage 2 — Feasibility:** Constraints, Success Criteria
+- **Stage 3 — Brownfield grounding:** Context Clarity (brownfield only)
+
+Follow-up pressure ladder after each answer:
+1. Ask for a concrete example, counterexample, or evidence signal behind the latest claim
+2. Probe the hidden assumption, dependency, or belief that makes the claim true
+3. Force a boundary or tradeoff: what would you explicitly not do, defer, or reject?
+4. If the answer still describes symptoms, reframe toward essence / root cause before moving on
+
+Prefer staying on the same thread for multiple rounds when it has the highest leverage. Breadth without pressure is not progress.
+
+Detailed dimensions:
+- Intent Clarity — why the user wants this
+- Outcome Clarity — what end state they want
+- Scope Clarity — how far the change should go
+- Constraint Clarity — technical or business limits that must hold
+- Success Criteria Clarity — how completion will be judged
+- Context Clarity — existing codebase understanding (brownfield only)
+
+`Non-goals` and `Decision Boundaries` are mandatory readiness gates. Ask about them early and keep revisiting them until they are explicit.
+
+### 2b) Ask the question
+Use structured user-input tooling available in the runtime (`AskUserQuestion` / equivalent) and present:
+
+```
+Round {n} | Target: {weakest_dimension} | Ambiguity: {score}%
+
+{question}
+```
+
+### 2c) Score ambiguity
+Score each weighted dimension in `[0.0, 1.0]` with justification + gap.
+
+Greenfield: `ambiguity = 1 - (intent × 0.30 + outcome × 0.25 + scope × 0.20 + constraints × 0.15 + success × 0.10)`
+
+Brownfield: `ambiguity = 1 - (intent × 0.25 + outcome × 0.20 + scope × 0.20 + constraints × 0.15 + success × 0.10 + context × 0.10)`
+
+Readiness gate:
+- `Non-goals` must be explicit
+- `Decision Boundaries` must be explicit
+- A pressure pass must be complete: at least one earlier answer has been revisited with an evidence, assumption, or tradeoff follow-up
+- If either gate is unresolved, or the pressure pass is incomplete, continue interviewing even when weighted ambiguity is below threshold
+
+### 2d) Report progress
+Show weighted breakdown table, readiness-gate status (`Non-goals`, `Decision Boundaries`), and the next focus dimension.
+
+### 2e) Persist state
+Append round result and updated scores via `state_write`.
+
+### 2f) Round controls
+- Do not offer early exit before the first explicit assumption probe and one persistent follow-up have happened
+- Round 4+: allow explicit early exit with risk warning
+- Soft warning at profile midpoint (e.g., round 3/6/10 depending on profile)
+- Hard cap at profile `max_rounds`
+
+## Phase 3: Challenge Modes (assumption stress tests)
+
+Use each mode once when applicable. These are normal escalation tools, not rare rescue moves:
+
+- **Contrarian** (round 2+ or immediately when an answer rests on an untested assumption): challenge core assumptions
+- **Simplifier** (round 4+ or when scope expands faster than outcome clarity): probe minimal viable scope
+- **Ontologist** (round 5+ and ambiguity > 0.25, or when the user keeps describing symptoms): ask for essence-level reframing
+
+Track used modes in state to prevent repetition.
+
+## Phase 4: Crystallize Artifacts
+
+When threshold is met (or user exits with warning / hard cap):
+
+1. Write interview transcript summary to:
+   - `.omx/interviews/{slug}-{timestamp}.md`  
+     (kept for ralph PRD compatibility)
+2. Write execution-ready spec to:
+   - `.omx/specs/deep-interview-{slug}.md`
+
+Spec should include:
+- Metadata (profile, rounds, final ambiguity, threshold, context type)
+- Context snapshot reference/path (for ralplan/team reuse)
+- Clarity breakdown table
+- Intent (why the user wants this)
+- Desired Outcome
+- In-Scope
+- Out-of-Scope / Non-goals
+- Decision Boundaries (what OMX may decide without confirmation)
+- Constraints
+- Testable acceptance criteria
+- Assumptions exposed + resolutions
+- Pressure-pass findings (which answer was revisited, and what changed)
+- Brownfield evidence vs inference notes for any repository-grounded confirmation questions
+- Technical context findings
+- Full or condensed transcript
+
+### Autoresearch specialization
+
+When the clarified task is specifically about `omx autoresearch`, or the skill is invoked with `--autoresearch`, keep the interview domain-specific and emit launch-consumable artifacts without skipping clarification.
+
+- **Accepted seed inputs:** `topic`, `evaluator`, `keep-policy`, `slug`, existing mission draft text, and prior evaluator examples/templates
+- **Required interview focus:** mission clarity, evaluator readiness, keep policy, slug/session naming, and whether the draft is ready to launch now or should refine further
+- **Canonical artifact path:** `.omx/specs/deep-interview-autoresearch-{slug}.md`
+- **Launch artifact bundle:** `.omx/specs/autoresearch-{slug}/mission.md`, `.omx/specs/autoresearch-{slug}/sandbox.md`, and `.omx/specs/autoresearch-{slug}/result.json`
+- **Launch artifact directory:** `.omx/specs/autoresearch-{slug}/`
+- **Required artifact sections:**
+  - `Mission Draft`
+  - `Evaluator Draft`
+  - `Launch Readiness`
+  - `Seed Inputs`
+  - `Confirmation Bridge`
+- **Required launch artifacts under `.omx/specs/autoresearch-{slug}/`:**
+  - `mission.md`
+  - `sandbox.md`
+  - `result.json`
+- **Launch-readiness rule:** mark the draft as **not launch-ready** while the evaluator command still contains placeholder markers such as `<...>`, `TODO`, `TBD`, `REPLACE_ME`, `CHANGEME`, or `your-command-here`
+- **Structured result contract:** `result.json` should point to the draft + mission/sandbox artifacts and carry the finalized `topic`, `evaluatorCommand`, `keepPolicy`, `slug`, `launchReady`, and `blockedReasons` fields so `omx autoresearch` can consume it directly
+- **Confirmation bridge:** after artifact generation, offer at least `refine further` and `launch`; do not launch detached tmux until the user explicitly confirms `launch`
+- **Handoff rule:** downstream execution must preserve the clarified mission intent, evaluator expectations, decision boundaries, and launch-readiness status from this artifact rather than bypassing the draft review step
+
+## Phase 5: Execution Bridge
+
+Present execution options after artifact generation using explicit handoff contracts. Treat the deep-interview spec as the current requirements source of truth and preserve intent, non-goals, decision boundaries, acceptance criteria, and any residual-risk warnings across the handoff.
+
+### 1. **`$ralplan` (Recommended)**
+- **Input Artifact:** `.omx/specs/deep-interview-{slug}.md` (optionally accompanied by the transcript/context snapshot for traceability)
+- **Invocation:** `$plan --consensus --direct <spec-path>`
+- **Consumer Behavior:** Treat the deep-interview spec as the requirements source of truth. Do not repeat the interview by default; refine architecture/feasibility around the clarified intent and boundaries instead.
+- **Skipped / Already-Satisfied Stages:** Requirements discovery, ambiguity clarification, and early intent-boundary elicitation
+- **Expected Output:** Canonical planning artifacts under `.omx/plans/`, especially `prd-*.md` and `test-spec-*.md`
+- **Best When:** Requirements are clear enough to stop interviewing, but architectural validation / consensus planning is still desirable
+- **Next Recommended Step:** Use the approved planning artifacts with `$autopilot`, `$ralph`, or `$team` depending on the desired execution style
+
+### 2. **`$autopilot`**
+- **Input Artifact:** `.omx/specs/deep-interview-{slug}.md`
+- **Invocation:** `$autopilot <spec-path>`
+- **Consumer Behavior:** Use the deep-interview spec as the clarified execution brief. Preserve intent, non-goals, decision boundaries, and acceptance criteria as binding context for planning/execution.
+- **Skipped / Already-Satisfied Stages:** Initial requirement discovery and ambiguity reduction
+- **Expected Output:** Planning/execution progress, QA evidence, and validation artifacts produced by autopilot
+- **Best When:** The clarified spec is already strong enough for direct planning + execution without an additional consensus gate
+- **Next Recommended Step:** Continue through autopilot's execution/QA/validation flow; if coordination-heavy execution emerges, prefer a follow-up `$team` or `$ralph` lane as appropriate
+
+### 3. **`$ralph`**
+- **Input Artifact:** `.omx/specs/deep-interview-{slug}.md`
+- **Invocation:** `$ralph <spec-path>`
+- **Consumer Behavior:** Use the spec's acceptance criteria and boundary constraints as the persistence target. Do not reopen requirements discovery unless the user explicitly asks to refine further.
+- **Skipped / Already-Satisfied Stages:** Requirement interview, ambiguity clarification, and initial scope-definition work
+- **Expected Output:** Iterative execution progress and verification evidence tracked against the clarified criteria
+- **Best When:** The task benefits from persistent sequential completion pressure and the user wants execution to keep moving until the criteria are satisfied or a real blocker exists
+- **Next Recommended Step:** Continue Ralph's persistence loop; if work expands into coordination-heavy lanes, hand off to `$team` and keep Ralph for verification continuity
+
+### 4. **`$team`**
+- **Input Artifact:** `.omx/specs/deep-interview-{slug}.md`
+- **Invocation:** `$team <spec-path>`
+- **Consumer Behavior:** Treat the spec as shared execution context for coordinated parallel work. Preserve the clarified intent, non-goals, decision boundaries, and acceptance criteria as common lane constraints.
+- **Skipped / Already-Satisfied Stages:** Requirement clarification and early ambiguity reduction
+- **Expected Output:** Coordinated multi-agent execution against the shared spec, with evidence that can later feed a Ralph verification pass when appropriate
+- **Best When:** The task is large, multi-lane, or blocker-sensitive enough to justify coordinated parallel execution instead of a single persistent loop
+- **Next Recommended Step:** Follow the team verification path when the coordinated execution phase finishes; escalate to a separate Ralph loop only when a later persistent verification/fix owner is still needed
+
+### 5. **Refine further**
+- **Input Artifact:** Existing transcript, context snapshot, and current spec draft
+- **Invocation:** Continue the interview loop
+- **Consumer Behavior:** Re-enter questioning to resolve the highest-leverage remaining uncertainty
+- **Skipped / Already-Satisfied Stages:** None beyond already-captured context
+- **Expected Output:** A lower-ambiguity spec with tighter boundaries and fewer unresolved assumptions
+- **Best When:** Residual ambiguity is still too high, the user wants stronger clarity, or the above-threshold / early-exit warning indicates too much risk to proceed cleanly
+- **Next Recommended Step:** Return to one of the execution handoff contracts above once the spec is sufficiently clarified
+
+**Residual-Risk Rule:** If the interview ended via early exit, hard-cap completion, or above-threshold proceed-with-warning, explicitly preserve that residual-risk state in the handoff so the downstream skill knows it inherited a partially clarified brief.
+
+**IMPORTANT:** Deep-interview is a requirements mode. On handoff, invoke the selected skill using the contract above. **Do NOT implement directly** inside deep-interview.
+
+</Steps>
+
+<Tool_Usage>
+- Use `explore` for codebase fact gathering
+- Use `request_user_input` / structured user-input tool for each interview round when available
+- If structured question tools are unavailable, use plain-text single-question rounds and keep the same stage order
+- Use `state_write` / `state_read` for resumable mode state
+- Read/write context snapshots under `.omx/context/`
+- Save transcript/spec artifacts under `.omx/interviews/` and `.omx/specs/`
+</Tool_Usage>
+
+<Escalation_And_Stop_Conditions>
+- User says stop/cancel/abort -> persist state and stop
+- Ambiguity stalls for 3 rounds (+/- 0.05) -> force Ontologist mode once
+- Max rounds reached -> proceed with explicit residual-risk warning
+- All dimensions >= 0.9 -> allow early crystallization even before max rounds
+</Escalation_And_Stop_Conditions>
+
+<Final_Checklist>
+- [ ] Preflight context snapshot exists under `.omx/context/{slug}-{timestamp}.md`
+- [ ] Ambiguity score shown each round
+- [ ] Intent-first stage priority used before implementation detail
+- [ ] Weakest-dimension targeting used within the active stage
+- [ ] At least one explicit assumption probe happened before crystallization
+- [ ] At least one persistent follow-up / pressure pass deepened a prior answer
+- [ ] Challenge modes triggered at thresholds (when applicable)
+- [ ] Transcript written to `.omx/interviews/{slug}-{timestamp}.md`
+- [ ] Spec written to `.omx/specs/deep-interview-{slug}.md`
+- [ ] Brownfield questions use evidence-backed confirmation when applicable
+- [ ] Handoff options provided (`$ralplan`, `$autopilot`, `$ralph`, `$team`)
+- [ ] No direct implementation performed in this mode
+</Final_Checklist>
+
+<Advanced>
+## Suggested Config (optional)
+
+```toml
+[omx.deepInterview]
+defaultProfile = "standard"
+quickThreshold = 0.30
+standardThreshold = 0.20
+deepThreshold = 0.15
+quickMaxRounds = 5
+standardMaxRounds = 12
+deepMaxRounds = 20
+enableChallengeModes = true
+```
+
+## Resume
+
+If interrupted, rerun `$deep-interview`. Resume from persisted mode state via `state_read(mode="deep-interview")`.
+
+## Recommended 3-Stage Pipeline
+
+```
+deep-interview -> ralplan -> autopilot
+```
+
+- Stage 1 (deep-interview): clarity gate
+- Stage 2 (ralplan): feasibility + architecture gate
+- Stage 3 (autopilot): execution + QA + validation gate
+</Advanced>
+
+Task: {{ARGUMENTS}}

package/skills/deepsearch/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: deepsearch
+description: Thorough codebase search
+---
+
+# Deep Search Mode
+
+[DEEPSEARCH MODE ACTIVATED]
+
+## Objective
+
+Perform thorough search of the codebase for the specified query, pattern, or concept.
+
+## Search Strategy
+
+1. **Broad Search**
+   - Search for exact matches
+   - Search for related terms and variations
+   - Check common locations (components, utils, services, hooks)
+
+2. **Deep Dive**
+   - Read files with matches
+   - Check imports/exports to find connections
+   - Follow the trail (what imports this? what does this import?)
+
+3. **Synthesize**
+   - Map out where the concept is used
+   - Identify the main implementation
+   - Note related functionality
+
+## Output Format
+
+- **Primary Locations** (main implementations)
+- **Related Files** (dependencies, consumers)
+- **Usage Patterns** (how it's used across the codebase)
+- **Key Insights** (patterns, conventions, gotchas)
+
+Focus on being comprehensive but concise. Cite file paths and line numbers.

package/skills/doctor/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: doctor
+description: Diagnose and fix oh-my-codex installation issues
+---
+
+# Doctor Skill
+
+Note: All `~/.codex/...` paths in this guide respect `CODEX_HOME` when that environment variable is set.
+
+## Task: Run Installation Diagnostics
+
+You are the OMX Doctor - diagnose and fix installation issues.
+
+### Step 1: Check Plugin Version
+
+```bash
+# Get installed version
+INSTALLED=$(ls ~/.codex/plugins/cache/omc/oh-my-codex/ 2>/dev/null | sort -V | tail -1)
+echo "Installed: $INSTALLED"
+
+# Get latest from npm
+LATEST=$(npm view oh-my-codex version 2>/dev/null)
+echo "Latest: $LATEST"
+```
+
+**Diagnosis**:
+- If no version installed: CRITICAL - plugin not installed
+- If INSTALLED != LATEST: WARN - outdated plugin
+- If multiple versions exist: WARN - stale cache
+
+### Step 2: Check Hook Configuration (config.toml + legacy settings.json)
+
+Check `~/.codex/config.toml` first (current Codex config), then check legacy `~/.codex/settings.json` only if it exists.
+
+Look for hook entries pointing to removed scripts like:
+- `bash $HOME/.codex/hooks/keyword-detector.sh`
+- `bash $HOME/.codex/hooks/persistent-mode.sh`
+- `bash $HOME/.codex/hooks/session-start.sh`
+
+**Diagnosis**:
+- If found: CRITICAL - legacy hooks causing duplicates
+
+### Step 3: Check for Legacy Bash Hook Scripts
+
+```bash
+ls -la ~/.codex/hooks/*.sh 2>/dev/null
+```
+
+**Diagnosis**:
+- If `keyword-detector.sh`, `persistent-mode.sh`, `session-start.sh`, or `stop-continuation.sh` exist: WARN - legacy scripts (can cause confusion)
+
+### Step 4: Check AGENTS.md
+
+```bash
+# Check if AGENTS.md exists
+ls -la ~/.codex/AGENTS.md 2>/dev/null
+
+# Check for OMX marker
+grep -q "oh-my-codex Multi-Agent System" ~/.codex/AGENTS.md 2>/dev/null && echo "Has OMX config" || echo "Missing OMX config"
+```
+
+**Diagnosis**:
+- If missing: CRITICAL - AGENTS.md not configured
+- If missing OMX marker: WARN - outdated AGENTS.md
+
+### Step 5: Check for Stale Plugin Cache
+
+```bash
+# Count versions in cache
+ls ~/.codex/plugins/cache/omc/oh-my-codex/ 2>/dev/null | wc -l
+```
+
+**Diagnosis**:
+- If > 1 version: WARN - multiple cached versions (cleanup recommended)
+
+### Step 6: Check for Legacy Curl-Installed Content
+
+Check for legacy agents, commands, and historical legacy skill roots from older installs/migrations:
+
+```bash
+# Check for legacy agents directory
+ls -la ~/.codex/agents/ 2>/dev/null
+
+# Check for legacy commands directory
+ls -la ~/.codex/commands/ 2>/dev/null
+
+# Check canonical current skills directory
+ls -la ${CODEX_HOME:-~/.codex}/skills/ 2>/dev/null
+
+# Check historical legacy skill directory
+ls -la ~/.agents/skills/ 2>/dev/null
+```
+
+**Diagnosis**:
+- If `~/.codex/agents/` exists with oh-my-codex-related files: WARN - legacy agents (now provided by plugin)
+- If `~/.codex/commands/` exists with oh-my-codex-related files: WARN - legacy commands (now provided by plugin)
+- If `${CODEX_HOME:-~/.codex}/skills/` exists with OMX skills: OK - canonical current user skill root
+- If `~/.agents/skills/` exists: WARN - historical legacy skill root that can overlap with `${CODEX_HOME:-~/.codex}/skills/` and cause duplicate Enable/Disable Skills entries
+
+Look for files like:
+- `architect.md`, `researcher.md`, `explore.md`, `executor.md`, etc. in agents/
+- `ultrawork.md`, `deepsearch.md`, etc. in commands/
+- Any oh-my-codex-related `.md` files in skills/
+
+---
+
+## Report Format
+
+After running all checks, output a report:
+
+```
+## OMX Doctor Report
+
+### Summary
+[HEALTHY / ISSUES FOUND]
+
+### Checks
+
+| Check | Status | Details |
+|-------|--------|---------|
+| Plugin Version | OK/WARN/CRITICAL | ... |
+| Hook Config (config.toml / legacy settings.json) | OK/CRITICAL | ... |
+| Legacy Scripts (~/.codex/hooks/) | OK/WARN | ... |
+| AGENTS.md | OK/WARN/CRITICAL | ... |
+| Plugin Cache | OK/WARN | ... |
+| Legacy Agents (~/.codex/agents/) | OK/WARN | ... |
+| Legacy Commands (~/.codex/commands/) | OK/WARN | ... |
+| Skills (${CODEX_HOME:-~/.codex}/skills) | OK/WARN | ... |
+| Legacy Skill Root (~/.agents/skills) | OK/WARN | ... |
+
+### Issues Found
+1. [Issue description]
+2. [Issue description]
+
+### Recommended Fixes
+[List fixes based on issues]
+```
+
+---
+
+## Auto-Fix (if user confirms)
+
+If issues found, ask user: "Would you like me to fix these issues automatically?"
+
+If yes, apply fixes:
+
+### Fix: Legacy Hooks in legacy settings.json
+If `~/.codex/settings.json` exists, remove the legacy `"hooks"` section (keep other settings intact).
+
+### Fix: Legacy Bash Scripts
+```bash
+rm -f ~/.codex/hooks/keyword-detector.sh
+rm -f ~/.codex/hooks/persistent-mode.sh
+rm -f ~/.codex/hooks/session-start.sh
+rm -f ~/.codex/hooks/stop-continuation.sh
+```
+
+### Fix: Outdated Plugin
+```bash
+rm -rf ~/.codex/plugins/cache/omc/oh-my-codex
+echo "Plugin cache cleared. Restart Codex CLI to fetch latest version."
+```
+
+### Fix: Stale Cache (multiple versions)
+```bash
+# Keep only latest version
+cd ~/.codex/plugins/cache/omc/oh-my-codex/
+ls | sort -V | head -n -1 | xargs rm -rf
+```
+
+### Fix: Missing/Outdated AGENTS.md
+Fetch latest from GitHub and write to `~/.codex/AGENTS.md`:
+```
+WebFetch(url: "https://raw.githubusercontent.com/Yeachan-Heo/oh-my-codex/main/docs/AGENTS.md", prompt: "Return the complete raw markdown content exactly as-is")
+```
+
+### Fix: Legacy Curl-Installed Content
+
+Remove legacy agents/commands plus the historical `~/.agents/skills` tree if it overlaps with the canonical `${CODEX_HOME:-~/.codex}/skills` install:
+
+```bash
+# Backup first (optional - ask user)
+# mv ~/.codex/agents ~/.codex/agents.bak
+# mv ~/.codex/commands ~/.codex/commands.bak
+# mv ~/.agents/skills ~/.agents/skills.bak
+
+# Or remove directly
+rm -rf ~/.codex/agents
+rm -rf ~/.codex/commands
+rm -rf ~/.agents/skills
+```
+
+**Note**: Only remove if these contain oh-my-codex-related files. If user has custom agents/commands/skills, warn them and ask before removing.
+
+---
+
+## Post-Fix
+
+After applying fixes, inform user:
+> Fixes applied. **Restart Codex CLI** for changes to take effect.