oh-my-codex 0.7.5 → 0.8.0

package/skills/configure-openclaw/SKILL.md

@@ -10,248 +10,245 @@ triggers:
 
 # Configure OpenClaw Notifications
 
-Set up OpenClaw as a notification gateway so OMX can route session events through your own HTTP endpoint or CLI command.
+Set up OpenClaw as a notification gateway so OMX can route notification events to your OpenClaw hook endpoints (or a local command gateway).
 
-## What is OpenClaw?
+## Runtime Schema Requirement (must match OMX)
 
-OpenClaw is a self-hosted notification gateway that lets you receive OMX events however you want — HTTP webhooks to your own server, shell commands, or any integration you build. Unlike platform-specific notifiers (Discord, Slack), OpenClaw gives you full control over message routing and format.
+Always write OpenClaw config under:
+- `notifications.openclaw.enabled`
+- `notifications.openclaw.gateways`
+- `notifications.openclaw.hooks`
 
-**Two gateway modes:**
-- **HTTP Gateway** — OMX POSTs JSON events to your HTTP endpoint
-- **CLI Command Gateway** — OMX runs a shell command with event data as arguments or stdin
+Do **not** use legacy keys like `gatewayType`, `endpoint`, or top-level `command`.
 
 ## How This Skill Works
 
-This is an interactive, natural-language configuration skill. Walk the user through setup by asking questions with AskUserQuestion. Write the result to `~/.codex/.omx-config.json`.
+This is an interactive setup wizard. Ask questions with AskUserQuestion, merge changes into `~/.codex/.omx-config.json`, and then run a verification flow with explicit pass/fail diagnostics.
 
-## Step 1: Detect Existing Configuration
+## Step 1: Detect Existing OpenClaw Configuration
 
 ```bash
 CONFIG_FILE="$HOME/.codex/.omx-config.json"
 
 if [ -f "$CONFIG_FILE" ]; then
-  HAS_OPENCLAW=$(jq -r '.notifications.openclaw.enabled // false' "$CONFIG_FILE" 2>/dev/null)
-  GATEWAY_TYPE=$(jq -r '.notifications.openclaw.gatewayType // empty' "$CONFIG_FILE" 2>/dev/null)
-  ENDPOINT=$(jq -r '.notifications.openclaw.endpoint // empty' "$CONFIG_FILE" 2>/dev/null)
-  COMMAND=$(jq -r '.notifications.openclaw.command // empty' "$CONFIG_FILE" 2>/dev/null)
-
-  if [ "$HAS_OPENCLAW" = "true" ]; then
-    echo "EXISTING_CONFIG=true"
-    echo "GATEWAY_TYPE=$GATEWAY_TYPE"
-    [ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT"
-    [ -n "$COMMAND" ] && echo "COMMAND=$COMMAND"
-  else
-    echo "EXISTING_CONFIG=false"
-  fi
+  OPENCLAW_ENABLED=$(jq -r '.notifications.openclaw.enabled // false' "$CONFIG_FILE" 2>/dev/null)
+  GATEWAYS=$(jq -r '.notifications.openclaw.gateways // {} | keys | join(", ")' "$CONFIG_FILE" 2>/dev/null)
+  HOOKS=$(jq -r '.notifications.openclaw.hooks // {} | keys | join(", ")' "$CONFIG_FILE" 2>/dev/null)
+
+  echo "OPENCLAW_ENABLED=$OPENCLAW_ENABLED"
+  echo "GATEWAYS=${GATEWAYS:-none}"
+  echo "HOOKS=${HOOKS:-none}"
 else
   echo "NO_CONFIG_FILE"
 fi
 ```
 
-If existing config is found, show the user what's currently configured and ask if they want to update or reconfigure.
+If existing config is found, show current gateways/hooks and ask whether to update or replace.
 
-## Step 2: Choose Gateway Type
+## Step 2: Choose Gateway Mode
 
 Use AskUserQuestion:
 
-**Question:** "Which OpenClaw gateway mode do you want to use?"
+**Question:** "Which OpenClaw gateway mode do you want to configure?"
 
 **Options:**
-1. **HTTP Gateway** - OMX sends a POST request with JSON to your endpoint. Good for web servers, n8n, Zapier webhooks, or any HTTP-capable service.
-2. **CLI Command Gateway** - OMX runs a shell command you specify. Good for local scripts, custom notification tools, or anything shell-scriptable.
+1. **HTTP Gateway (Recommended)** - OMX POSTs JSON to your OpenClaw hook endpoint
+2. **CLI Command Gateway** - OMX executes a local command template
 
 ## Step 3A: HTTP Gateway Setup
 
-If user chose HTTP:
-
-Use AskUserQuestion:
+Collect three values:
+1. Gateway name (default: `local`)
+2. Hook base URL (example: `http://127.0.0.1:18789`)
+3. OpenClaw hooks token
 
-**Question:** "Enter your OpenClaw HTTP endpoint URL. OMX will POST JSON event data to this URL."
+Build the endpoint URL as:
+- Delivery endpoint: `${BASE_URL%/}/hooks/agent`
+- Optional wake smoke endpoint: `${BASE_URL%/}/hooks/wake`
 
-The user types their URL in the "Other" field.
+### Required validation checks
 
-**Validate** the URL:
-- Must start with `http://` or `https://`
-- If invalid, explain the format and ask again
+Run these checks and report each result:
 
-### Optional: Secret Header
+1) **Hook token present**
+```bash
+[ -n "$HOOKS_TOKEN" ] && echo "PASS token provided" || echo "FAIL token missing"
+```
 
-Use AskUserQuestion:
+2) **Gateway URL format and reachability**
+```bash
+case "$BASE_URL" in
+  http://*|https://*) echo "PASS URL format" ;;
+  *) echo "FAIL URL must start with http:// or https://" ;;
+esac
 
-**Question:** "Add an authorization header to secure requests? (Optional)"
+curl -sS -o /dev/null -w "HTTP %{http_code}\n" "$BASE_URL" || echo "FAIL cannot reach base URL"
+```
 
-**Options:**
-1. **Yes, add Bearer token** - Sends `Authorization: Bearer <token>`
-2. **Yes, add custom header** - Specify header name and value
-3. **No auth header** - Open endpoint (use firewall rules or IP allowlist instead)
+3) **Delivery endpoint probe (`/hooks/agent`)**
+```bash
+curl -sS -o /tmp/omx-openclaw-agent.json -w "HTTP %{http_code}\n" \
+  -X POST "${BASE_URL%/}/hooks/agent" \
+  -H "Authorization: Bearer $HOOKS_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"instruction":"OMX OpenClaw setup probe","event":"session-end","sessionId":"setup-smoke"}'
+```
 
-If they want a Bearer token or custom header, collect the values.
+If probe is non-2xx or network fails, treat as setup failure and continue with diagnostics.
 
 ## Step 3B: CLI Command Gateway Setup
 
-If user chose CLI Command:
+Collect:
+- Gateway name (default: `local-command`)
+- Command template (supports `{{event}}`, `{{instruction}}`, `{{sessionId}}`, `{{projectPath}}`)
 
-Use AskUserQuestion:
-
-**Question:** "Enter the shell command OMX should run for each notification event. Use these placeholders:
-- `{event}` — event name (e.g. session-end)
-- `{session_id}` — session identifier
-- `{project}` — project name/path
-- `{message}` — formatted notification message
-
-Example: `notify-send 'OMX: {event}' '{message}'`
-Example: `~/.local/bin/my-notifier --event {event} --msg '{message}'`"
-
-The user types their command in the "Other" field.
+Example:
+```bash
+~/.local/bin/my-notifier --event {{event}} --text {{instruction}}
+```
 
-**IMPORTANT: Dual activation gate for CLI Command gateways**
+### Dual env gate (must be explained)
 
-CLI command gateways require TWO environment variables to be set:
-- `OMX_OPENCLAW=1` — enables the OpenClaw gateway
-- `OMX_OPENCLAW_COMMAND=1` — specifically enables CLI command execution
+CLI command gateways only run when **both** are set:
 
-This two-gate design prevents accidental command execution when only the config file is present. Remind the user to set both in their shell profile.
+```bash
+export OMX_OPENCLAW=1
+export OMX_OPENCLAW_COMMAND=1
+```
 
-## Step 4: Map Events
+If `OMX_OPENCLAW_COMMAND` is missing, command gateway dispatch is blocked by design.
 
-Use AskUserQuestion with multiSelect:
+## Step 4: Select Hook Event Mappings
 
-**Question:** "Which events should be routed through OpenClaw?"
+Use AskUserQuestion with multiSelect.
 
-**Options (multiSelect: true):**
-1. **Session end (Recommended)** - When a Codex session finishes
-2. **Input needed** - When Codex is waiting for your response
-3. **Session start** - When a new session begins
-4. **Session continuing** - When a persistent mode keeps the session alive
+**Question:** "Which OMX events should trigger OpenClaw hooks?"
 
-Default selection: session-end + ask-user-question.
+Recommended defaults:
+- `session-end`
+- `ask-user-question`
 
-## Step 5: Write Configuration
+Optional:
+- `session-start`
+- `session-idle`
+- `stop`
 
-Read the existing config, merge the OpenClaw settings, and write back:
+For each selected event, collect a short instruction template.
 
-```bash
-CONFIG_FILE="$HOME/.codex/.omx-config.json"
-mkdir -p "$(dirname "$CONFIG_FILE")"
+## Step 5: Write Schema-Aligned Config
 
-if [ -f "$CONFIG_FILE" ]; then
-  EXISTING=$(cat "$CONFIG_FILE")
-else
-  EXISTING='{}'
-fi
-```
+Always merge into `~/.codex/.omx-config.json`.
 
-### For HTTP Gateway:
+### HTTP gateway example
 
 ```bash
-# ENDPOINT, AUTH_HEADER_NAME, AUTH_HEADER_VALUE are collected from user
-echo "$EXISTING" | jq \
-  --arg endpoint "$ENDPOINT" \
-  --arg headerName "$AUTH_HEADER_NAME" \
-  --arg headerValue "$AUTH_HEADER_VALUE" \
+jq \
+  --arg gatewayName "$GATEWAY_NAME" \
+  --arg url "${BASE_URL%/}/hooks/agent" \
+  --arg token "$HOOKS_TOKEN" \
   '.notifications = (.notifications // {enabled: true}) |
    .notifications.enabled = true |
-   .notifications.openclaw = {
-     enabled: true,
-     gatewayType: "http",
-     endpoint: $endpoint,
-     headers: (if $headerName == "" then null else {($headerName): $headerValue} end)
-   }' > "$CONFIG_FILE"
+   .notifications.openclaw = (.notifications.openclaw // {}) |
+   .notifications.openclaw.enabled = true |
+   .notifications.openclaw.gateways = (.notifications.openclaw.gateways // {}) |
+   .notifications.openclaw.gateways[$gatewayName] = {
+     type: "http",
+     url: $url,
+     headers: {"Authorization": ("Bearer " + $token)}
+   }' "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
 ```
 
-### For CLI Command Gateway:
+### Command gateway example
 
 ```bash
-# COMMAND is collected from user
-echo "$EXISTING" | jq \
-  --arg command "$COMMAND" \
+jq \
+  --arg gatewayName "$GATEWAY_NAME" \
+  --arg command "$COMMAND_TEMPLATE" \
   '.notifications = (.notifications // {enabled: true}) |
    .notifications.enabled = true |
-   .notifications.openclaw = {
-     enabled: true,
-     gatewayType: "command",
+   .notifications.openclaw = (.notifications.openclaw // {}) |
+   .notifications.openclaw.enabled = true |
+   .notifications.openclaw.gateways = (.notifications.openclaw.gateways // {}) |
+   .notifications.openclaw.gateways[$gatewayName] = {
+     type: "command",
      command: $command
-   }' > "$CONFIG_FILE"
+   }' "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
 ```
 
-### Add event-specific config if user didn't select all events:
+### Hook mapping example
 
 ```bash
-# Example: disable session-start if not selected
-echo "$(cat "$CONFIG_FILE")" | jq \
-  '.notifications.events = (.notifications.events // {}) |
-   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"
+jq \
+  --arg gatewayName "$GATEWAY_NAME" \
+  '.notifications.openclaw.hooks = (.notifications.openclaw.hooks // {}) |
+   .notifications.openclaw.hooks["session-end"] = {
+     enabled: true,
+     gateway: $gatewayName,
+     instruction: "OMX task completed for {{projectPath}}"
+   } |
+   .notifications.openclaw.hooks["ask-user-question"] = {
+     enabled: true,
+     gateway: $gatewayName,
+     instruction: "OMX needs input: {{question}}"
+   }' "$CONFIG_FILE" > "$CONFIG_FILE.tmp" && mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
 ```
 
 ## Step 6: Explain Activation Gates
 
-Regardless of gateway type, explain the activation model:
+Show this exactly:
 
-```
-OpenClaw Activation Gates
-─────────────────────────
-OpenClaw requires environment variables to be set before it activates.
-This prevents accidental notifications in shared or CI environments.
-
-For HTTP Gateway:
-  export OMX_OPENCLAW=1
-
-For CLI Command Gateway (requires both):
-  export OMX_OPENCLAW=1
-  export OMX_OPENCLAW_COMMAND=1
+```bash
+# Required for OpenClaw integration
+export OMX_OPENCLAW=1
 
-Add these to your ~/.zshrc or ~/.bashrc.
+# Required in addition for command gateways
+export OMX_OPENCLAW_COMMAND=1
 ```
 
-## Step 7: Test the Configuration
+## Step 7: Verification Flow (required)
 
-After writing config, offer to test:
+Run both checks for HTTP gateways:
 
-Use AskUserQuestion:
-
-**Question:** "Send a test notification through OpenClaw to verify the setup?"
-
-**Options:**
-1. **Yes, test now (Recommended)** - Run a test dispatch
-2. **No, I'll test later** - Skip testing
-
-### If testing HTTP Gateway:
+### A) Wake smoke test (`/hooks/wake`)
 
 ```bash
-curl -s -o /dev/null -w "%{http_code}" \
+curl -sS -X POST "${BASE_URL%/}/hooks/wake" \
+  -H "Authorization: Bearer $HOOKS_TOKEN" \
   -H "Content-Type: application/json" \
-  ${AUTH_HEADER_NAME:+-H "$AUTH_HEADER_NAME: $AUTH_HEADER_VALUE"} \
-  -d '{"event":"test","message":"OMX OpenClaw test notification","session_id":"test"}' \
-  "$ENDPOINT"
+  -d '{"text":"OMX wake smoke test","mode":"now"}'
 ```
 
-### If testing CLI Command Gateway:
-
-Replace placeholders in the command with test values and run it.
+Expected pass signal: JSON includes `"ok":true`.
 
-Report success or failure. If it fails, help debug (check URL accessibility, command path, permissions).
-
-## Step 8: Confirm
-
-Display the final configuration summary:
+### B) Delivery verification (`/hooks/agent`) — not wake-only
 
+```bash
+curl -sS -o /tmp/omx-openclaw-delivery.json -w "HTTP %{http_code}\n" \
+  -X POST "${BASE_URL%/}/hooks/agent" \
+  -H "Authorization: Bearer $HOOKS_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"instruction":"OMX delivery verification","event":"session-end","sessionId":"verify-setup"}'
 ```
-OpenClaw Gateway Configured!
 
-  Type:     HTTP / CLI Command
-  Endpoint: https://your-server/omx-hook  (HTTP only)
-  Command:  notify-send 'OMX' '{message}'  (CLI only)
-  Events:   session-end, ask-user-question
+Expected pass signal: HTTP 2xx and response body confirms acceptance.
 
-Config saved to: ~/.codex/.omx-config.json
+## Step 8: Pass/Fail Diagnostics Guidance
 
-Activation (add to ~/.zshrc or ~/.bashrc):
-  export OMX_OPENCLAW=1
-  export OMX_OPENCLAW_COMMAND=1   # CLI Command gateways only
+If verification fails, guide with this checklist:
+- **401/403** → token missing/invalid; rotate token and update `Authorization` header.
+- **404** → wrong path; verify `/hooks/agent` and `/hooks/wake` are enabled by OpenClaw hooks config.
+- **5xx** → OpenClaw gateway runtime issue; check gateway logs and retry.
+- **Timeout / connection refused** → gateway URL unreachable; confirm host/port and local firewall.
+- **Command gateway disabled** → set both `OMX_OPENCLAW=1` and `OMX_OPENCLAW_COMMAND=1`.
 
-To reconfigure: /configure-openclaw
-To configure other platforms: /configure-notifications
-```
+## Step 9: Final Summary
+
+Show:
+- gateway mode + gateway name
+- mapped events
+- whether smoke test passed
+- whether `/hooks/agent` delivery test passed
+- exact env vars user still needs to export in shell profile
 
 ## Environment Variable Reference
 
@@ -259,9 +256,9 @@ To configure other platforms: /configure-notifications
 # Required for all OpenClaw gateways
 export OMX_OPENCLAW=1
 
-# Required additionally for CLI Command gateways
+# Required additionally for CLI command gateways
 export OMX_OPENCLAW_COMMAND=1
 
-# HTTP gateway: override endpoint URL
-export OMX_OPENCLAW_URL="https://your-server/omx-hook"
+# Optional debug logs
+export OMX_OPENCLAW_DEBUG=1
 ```

package/skills/deep-interview/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: deep-interview
+description: Socratic deep interview with mathematical ambiguity gating before execution
+argument-hint: "<idea or vague description>"
+---
+
+<Purpose>
+Deep Interview implements an Ouroboros-inspired Socratic clarification loop before planning or implementation. It turns vague ideas into explicit specifications by asking targeted questions, scoring ambiguity across weighted dimensions, and gating execution until clarity reaches a configurable threshold.
+</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 requirement clarity. A single expansion pass often misses hidden assumptions. This workflow applies Socratic pressure + quantitative ambiguity scoring so orchestration modes begin with an explicit, testable spec.
+
+Inspired by Ouroboros (https://github.com/Q00/ouroboros) and adapted for OMX conventions.
+</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
+
+If no flag is provided, use **Standard**.
+</Depth_Profiles>
+
+<Execution_Policy>
+- Ask ONE question per round (never batch)
+- Target the weakest clarity dimension each round
+- Gather codebase facts via `explore` before asking user about internals
+- Always run a preflight context intake before the first interview question
+- 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
+- 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
+   - Known facts/evidence
+   - Constraints
+   - Unknowns/open questions
+   - 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,
+    "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`, user exits with warning, or max rounds 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:
+- Goal Clarity
+- Constraint Clarity
+- Success Criteria Clarity
+- Context Clarity (brownfield only)
+
+### 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 dimension in `[0.0, 1.0]` with justification + gap.
+
+Greenfield: `ambiguity = 1 - (goal × 0.40 + constraints × 0.30 + criteria × 0.30)`
+
+Brownfield: `ambiguity = 1 - (goal × 0.35 + constraints × 0.25 + criteria × 0.25 + context × 0.15)`
+
+### 2d) Report progress
+Show weighted breakdown table and next focus dimension.
+
+### 2e) Persist state
+Append round result and updated scores via `state_write`.
+
+### 2f) Round controls
+- Round 3+: 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:
+
+- **Contrarian** (round 4+): challenge core assumptions
+- **Simplifier** (round 6+): probe minimal viable scope
+- **Ontologist** (round 8+ and ambiguity > 0.30): 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
+- Goal / Constraints / Non-goals
+- Testable acceptance criteria
+- Assumptions exposed + resolutions
+- Technical context findings
+- Full or condensed transcript
+
+## Phase 5: Execution Bridge
+
+Present execution options after artifact generation:
+
+1. **`$ralplan` (Recommended)**
+   - Run consensus refinement on the spec:
+   - `$plan --consensus --direct <spec-path>`
+2. **`$autopilot`**
+   - Use spec as high-clarity execution input
+3. **`$ralph`**
+   - Sequential persistence loop using spec/criteria
+4. **`$team`**
+   - Parallel coordinated execution using shared spec
+5. **Refine further**
+   - Continue interview loop for lower ambiguity
+
+**IMPORTANT:** Deep-interview is a requirements mode. On handoff, invoke the selected skill. **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
+- [ ] Weakest-dimension targeting used
+- [ ] Challenge modes triggered at thresholds (when applicable)
+- [ ] Transcript written to `.omx/interviews/{slug}-{timestamp}.md`
+- [ ] Spec written to `.omx/specs/deep-interview-{slug}.md`
+- [ ] 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/doctor/SKILL.md

@@ -152,7 +152,7 @@ rm -f ~/.codex/hooks/stop-continuation.sh
 
 ### Fix: Outdated Plugin
 ```bash
-rm -rf ~/.codex/plugins/cache/oh-my-codex
+rm -rf ~/.codex/plugins/cache/omc/oh-my-codex
 echo "Plugin cache cleared. Restart Codex CLI to fetch latest version."
 ```