deep-interview

What this skill does

<Purpose>
Deep Interview implements Ouroboros-inspired Socratic questioning with mathematical ambiguity scoring. It replaces vague ideas with crystal-clear specifications by asking targeted questions that expose hidden assumptions, measuring clarity across weighted dimensions, and refusing to proceed until ambiguity drops below the resolved threshold for this run. The output feeds into a gated pipeline: **deep-interview → omc-plan consensus refinement → pending approval → explicitly approved execution**, ensuring maximum clarity before any mutation starts.
</Purpose>

<Use_When>
- User has a vague idea and wants thorough requirements gathering before execution
- User says "deep interview", "interview me", "ask me everything", "don't assume", "make sure you understand"
- User says "ouroboros", "socratic", "I have a vague idea", "not sure exactly what I want"
- User wants to avoid "that's not what I meant" outcomes from autonomous execution
- Task is complex enough that jumping to code would waste cycles on scope discovery
- User wants mathematically-validated clarity before committing to execution
</Use_When>

<Do_Not_Use_When>
- User has a detailed, specific request with file paths, function names, or acceptance criteria -- execute directly
- User wants to explore options or brainstorm -- use `omc-plan` skill instead
- User wants a quick fix or single change -- delegate to executor or ralph
- User says "just do it" or "skip the questions" without an explicit execution path -- respect their intent by ending interview and writing a `pending approval` spec, not by mutating files or delegating execution
- User already has a PRD or plan file and explicitly asks to execute it -- use the requested execution skill with that plan
</Do_Not_Use_When>

<Why_This_Exists>
AI can build anything. The hard part is knowing what to build. OMC's autopilot Phase 0 expands ideas into specs via analyst + architect, but this single-pass approach struggles with genuinely vague inputs. It asks "what do you want?" instead of "what are you assuming?" Deep Interview applies Socratic methodology to iteratively expose assumptions and mathematically gate readiness, ensuring the AI has genuine clarity before spending execution cycles.

Inspired by the [Ouroboros project](https://github.com/Q00/ouroboros) which demonstrated that specification quality is the primary bottleneck in AI-assisted development.
</Why_This_Exists>

<Execution_Policy>
- Ask ONE question at a time -- never batch multiple questions
- Target the WEAKEST clarity dimension with each question
- Before Round 1 ambiguity scoring, run a one-time Round 0 topology enumeration gate that confirms the top-level component list and locks it into state
- Make weakest-dimension targeting explicit every round: name the weakest dimension, state its score/gap, and explain why the next question is aimed there
- Gather codebase facts via `explore` agent BEFORE asking the user about them
- For brownfield confirmation questions, cite the repo evidence that triggered the question (file path, symbol, or pattern) instead of asking the user to rediscover it
- Score ambiguity after every answer -- display the score transparently
- When the locked topology has multiple active components, score and target each component explicitly so depth-first clarity on one component cannot hide ambiguity in siblings
- Keep prompt payloads budgeted: summarize or trim oversized initial context/history before composing question, scoring, spec, or handoff prompts
- If the user's initial context is oversized, create a concise prompt-safe summary first and wait for that summary before ambiguity scoring, question generation, or downstream execution handoff
- Do not proceed to execution until ambiguity ≤ the resolved threshold for this run and the user explicitly approves a scoped execution path
- Allow early exit with a clear warning if ambiguity is still high
- Persist interview state for resume across session interruptions
- Challenge agents activate at specific round thresholds to shift perspective
</Execution_Policy>

<Autoresearch_Mode>
When arguments include `--autoresearch`, Deep Interview becomes the zero-learning-curve setup lane for the stateful `autoresearch` skill.

- If no usable mission brief is present yet, start by asking: **"What should autoresearch improve or prove for this repo?"**
- After the mission is clear, collect an evaluator command. If the user leaves it blank, infer one only when repo evidence is strong; otherwise keep interviewing until an evaluator is explicit enough to launch safely.
- Keep the usual one-question-per-round rule, but treat **mission clarity** and **evaluator clarity** as hard readiness gates in addition to the normal ambiguity threshold.
- Once ready, do **not** bridge into `omc-plan`, `autopilot`, `ralph`, `team`, or the hard-deprecated `omc autoresearch` CLI. Instead write the mission/evaluator setup artifacts and invoke:
  - `Skill("oh-my-claudecode:autoresearch")`
- This handoff enters the real stateful autoresearch skill. After a successful handoff, announce the mission slug, evaluator command/script, max-runtime ceiling, and artifact location.
</Autoresearch_Mode>

<Steps>

## Native Plugin Invocation Guard (Issue #3030)

If this raw bundled skill is loaded by Claude Code's native plugin skill loader through `/oh-my-claudecode:deep-interview` or `Skill("oh-my-claudecode:deep-interview")`, do not treat that path as permission to skip rendered OMC setup. The user-facing preferred invocation is `/deep-interview`; do not recommend or advertise `/oh-my-claudecode:deep-interview` as the deep-interview entrypoint. Regardless of invocation path, Phase 0 below remains blocking and must resolve `omc.deepInterview.ambiguityThreshold` from settings before any announcement, state write, question, or ambiguity score.

## Phase 0: Resolve Ambiguity Threshold (blocking prerequisite)

Complete this phase before Phase 1, before brownfield exploration, before `state_write`, before Round 0, and before any ambiguity scoring. Do not continue if the resolved threshold and source are unknown.

1. **Read threshold settings in precedence order**:
   - User settings: `[$CLAUDE_CONFIG_DIR|~/.claude]/settings.json`
   - Project settings: `./.claude/settings.json` (overrides user settings)
2. **Resolve threshold and source**:
   - Read `omc.deepInterview.ambiguityThreshold` from both files when present.
   - Use the project value when valid; otherwise use the user value when valid; otherwise use the default `0.2`.
   - Set these run variables exactly: `<resolvedThreshold>`, `<resolvedThresholdPercent>`, and `<resolvedThresholdSource>` (for example `./.claude/settings.json`, `[$CLAUDE_CONFIG_DIR|~/.claude]/settings.json`, or `default`).
3. **Emit the required first line to the user before any other interview announcement**:

```
Deep Interview threshold: <resolvedThresholdPercent> (source: <resolvedThresholdSource>)
```

4. **Carry threshold source forward mechanically**:
   - Substitute `<resolvedThreshold>`, `<resolvedThresholdPercent>`, and `<resolvedThresholdSource>` throughout the remaining instructions before continuing.
   - Include `threshold_source` in the first `state_write(mode="deep-interview")` state payload and preserve it on later state updates.
   - Include both threshold and source in the final spec metadata.

## Phase 1: Initialize

1. **Parse the user's idea** from `{{ARGUMENTS}}`
2. **Detect brownfield vs greenfield**:
   - Run `explore` agent (haiku): check if cwd has existing source code, package files, or git history
   - If source files exist AND the user's idea references modifying/extending something: **brownfield**
   - Otherwise: **greenfield**
3. **For brownfield**: Build the first-round context before designing Round 1 questions:
   - Run `explore` agent to map relevant codebase areas, store as `codebase_context`.
   - Consult accumulated local planning knowledge: glob `.omc/specs/deep-*.md` and `.omc/plans