User's idea
    ↓
[Stage 1: INITIATE]   → Parse topic, declare role, launch interviewer agent
    ↓
[Stage 2: INTERVIEW]  → Interviewer agent asks questions + Ambiguity Scoring loop
    ↓
[Stage 3: SYNTHESIZE]  → Insights summary + Clarity Assessment + next steps

"I'll run a structured interview to clarify your requirements. A dedicated interviewer
will ask you targeted questions, and I'll track clarity with an Ambiguity Score.
When your requirements are clear enough (score ≤ 0.2), we'll wrap up."

AskUserQuestion(
  question: "What kind of help do you need?",
  header: "Intent",
  options: [
    { label: "Interview me", description: "Clarify requirements through structured questioning" },
    { label: "Already clear", description: "Skip interview — I know what I need" },
    { label: "Just discuss", description: "Free-form exploration without scoring" }
  ]
)

Agent(subagent_type="Explore",
     prompt="Find: existing patterns, architecture, and code related to [topic].
             Report relevant files as file:line format. Keep findings concise.")

Agent(subagent_type="interviewer",
     prompt="Topic: [parsed topic]
             Context: [any context signals, proposed solution, deep-mode findings]
 
             Ask a sharp opening question to start clarifying requirements.
             Use the appropriate probe type based on context:
             - If proposed solution present → Consequential probe
             - If vague problem → Clarifying probe
             - If architecture topic → Challenging probe
             - If comparison → Perspective probe")

AskUserQuestion(
  question: "Which direction should we dig into?",
  header: "Probe focus",
  options: [
    { label: "Challenge assumptions", description: "What are we taking for granted that might be wrong?" },
    { label: "Failure scenarios", description: "How could this go wrong? What are the failure modes?" },
    { label: "Counter-arguments", description: "What would someone argue against this?" },
    { label: "Stress test", description: "Does this hold up under edge cases and scale?" },
    { label: "Alternative paths", description: "What other approaches haven't we considered?" }
  ],
  multiSelect: true
)

Agent(subagent_type="interviewer",
     prompt="Topic: [topic]
             Probe direction: [selected direction(s)]
             Round: [N] of 10
 
             Conversation so far:
             [summary of key points from previous rounds]
 
             User's latest answer:
             [user's answer]
 
             Ask the next question. Target the area with least clarity.
             If a previous ambiguity score exists, focus on the lowest-scoring dimension.")

weighted_sum = (goal × 0.4) + (constraints × 0.3) + (criteria × 0.3)
ambiguity = 1 - weighted_sum

📊 Ambiguity: [score] (Goal: [g], Constraints: [c], Criteria: [s])
   [progress bar ████████░░ ]

if ambiguity ≤ 0.2:
  → "Requirements are clear enough. Ready to synthesize?"
  → AskUserQuestion: "Wrap up" / "Keep refining"
 
if ambiguity > 0.2 AND round < 10:
  → Identify lowest-scoring dimension
  → Feed it to next interviewer prompt as focus area
  → Continue loop
 
if round == 10 (hard cap):
  → "We've reached the interview limit. Let me synthesize what we have."
  → Proceed to Stage 3 regardless of score

AskUserQuestion(
  question: "We've explored [current direction] for a few rounds. Continue or shift?",
  header: "Direction",
  options: [
    { label: "Keep going", description: "Continue in this direction" },
    { label: "Switch direction", description: "Pick a new probe focus" },
    { label: "Wrap up", description: "Synthesize what we have so far" }
  ]
)

### Clarity Assessment
Ambiguity Score: [score] [✅ if ≤ 0.2, ⚠️ if 0.2-0.5, ❌ if > 0.5]
-Goal Clarity: [score] (40%)
-Constraint Clarity: [score] (30%)
-Success Criteria: [score] (30%)
 
Maturity: [level] — [1-line justification]

## Deep Interview Insights: [Topic]
 
### Core Problem
[1-sentence distillation of the actual problem, as refined through interview]
 
### Key Insights & Decisions
-[Insight or decision that emerged from dialogue]
-[Another insight]
 
### Defined Requirements
-[Concrete requirement surfaced during interview]
-[Another requirement]
 
### Identified Risks & Failure Modes
-[Risk surfaced during probing]
-[Failure mode identified]
 
### Open Questions & Unknowns
-[Question neither of us could answer — including "I don't know" moments]
-[Area that needs more investigation]
 
### Clarity Assessment
Ambiguity Score: [score] [emoji]
-Goal Clarity: [score] (40%)
-Constraint Clarity: [score] (30%)
-Success Criteria: [score] (30%)
 
Maturity: [level] — [justification]

AskUserQuestion(
  question: "What would you like to do with these insights?",
  header: "Next step",
  options: [
    { label: "Save insights", description: "Save to deep-interview-outputs/[topic]/insights.md" },
    { label: "Keep talking", description: "Continue the interview — return to probing" },
    { label: "Done", description: "End the interview" }
  ]
)

Write("deep-interview-outputs/[topic-slug]/insights.md", insights_content)

# Deep Interview Insights: [Topic]
> Date: [YYYY-MM-DD]
> Rounds: [N]
> Final Ambiguity Score: [score]
 
## Core Problem
[1-sentence summary]
 
## Key Insights & Decisions
-[Insight 1]
-[Insight 2]
 
## Defined Requirements
-[Requirement 1]
-[Requirement 2]
 
## Identified Risks & Failure Modes
-[Risk 1]
 
## Open Questions & Unknowns
-[Unresolved question 1]
 
## Clarity Assessment
Ambiguity Score: [score]
-Goal Clarity: [score] (40%)
-Constraint Clarity: [score] (30%)
-Success Criteria: [score] (30%)
 
Maturity: [level] — [justification]

# Basic interview
/deep-interview I want to build a todo management CLI
 
# With codebase context
/deep-interview --deep Our auth system needs improvement
 
# Not sure what to build
/deep-interview not sure what to build, I have a side project idea
 
# Requirement clarification
/deep-interview requirements are unclear — notification system refactoring

User: "/deep-interview I want to build a todo management CLI"
 
[Stage 1: INITIATE]
1. Parse: Core problem = todo management CLI, Proposed solution = CLI tool
2. Declare role: "I'll run a structured interview..."
3. Early gate → User selects "Interview me"
4. Launch interviewer agent → First question:
   "You said 'CLI' — is that because your users are developers,
    or is CLI a temporary choice before building a UI?"
 
[Stage 2: INTERVIEW]
5. User: "It's for developers, I want to use it from the terminal"
6. Direction selection → User picks "Challenge assumptions" + "Stress test"
7. Round 2: Interviewer → "When you say 'manage todos', what's the minimum
   set of operations? Create-Read-Update-Delete, or something beyond CRUD?"
8. User: "CRUD + priorities, due dates, tags"
9. Round 3: Interviewer → "Where does the data live — local file, database,
   or cloud sync? Each forces a very different architecture."
   📊 Ambiguity: 0.55 (Goal: 0.6, Constraints: 0.4, Criteria: 0.3)
10. User: "Local JSON file, keep it simple"
11. Round 4: Interviewer → "What does 'done' look like for v1? If you ship
    tomorrow, what's the one thing it absolutely must do?"
    📊 Ambiguity: 0.35 (Goal: 0.75, Constraints: 0.7, Criteria: 0.5)
12. User: "Add a todo, list them, mark as done"
13. Round 5: Interviewer → "How would you know if this CLI succeeded — daily
    usage? Replaced another tool? Specific task completion rate?"
    📊 Ambiguity: 0.18 ✅ (Goal: 0.85, Constraints: 0.8, Criteria: 0.85)
14. "Requirements are clear enough. Ready to synthesize?"
    → User selects "Wrap up"
 
[Stage 3: SYNTHESIZE]
15. Clarity Assessment: Ambiguity 0.18 ✅, Maturity: Solid
16. Insights summary with all sections
17. Next steps → User selects "Save insights"
18. Save to deep-interview-outputs/todo-cli/insights.md