Deep Interview

<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 which demonstrated that specification quality is the primary bottleneck in AI-assisted development. </Why_This_Exists>

<Execution_Policy>

• Default is ONE question at a time -- never batch multiple questions. The only exception is Frontier Rounds Mode (--frontier), which asks the whole settled frontier per round (see Frontier Rounds Mode below)
• 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)

1. 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).

1. Emit the required first line to the user before any other interview announcement:

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

1. 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

1. For brownfield: Build the first-round context before designing Round 1 questions: