deep-interview · git:20261105.f70265c · 2026-11-05 · sha256 fabac22a58a63e78

deep-interview git:20261105.f70265cA

Immutable. This exact content never changes and is served at /api/v1/blob/fabac22a58a63e78.

No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_65ju542o4odsk5mc/fabac22a58a63e78540657db0e31fb1f1a79462b95d7dda3515ca954481838d5.json

Then /plugin install deep-interview@markdownregistry-65ju542o4odsk5mc in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.

---
name: deep-interview
description: "[oh-my-agy] Socratic deep interview with quantitative ambiguity gating before planning or execution. Use when a request is broad, ambiguous, or missing acceptance criteria, or when the user says 'deep interview', 'interview me', 'ask me everything', 'don't assume', or 'ouroboros'. Supports --quick, --standard (default), --deep, and --autoresearch."
---

<Purpose>
Deep Interview is an intent-first Socratic clarification loop that runs before planning or implementation. It turns vague ideas into execution-ready specifications by asking targeted questions: why the user wants the change, how far it should go, what stays out of scope, and what the agent 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.
- A requirements artifact is needed before handing off to `$ralplan`, `$autopilot`, `$ultragoal`, 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 only wants lightweight brainstorming (use `$plan`).
- A complete PRD/plan already exists and execution should start.
</Do_Not_Use_When>

<Depth_Profiles>
- **Quick (`--quick`)**: fast pre-PRD pass; threshold `<= 0.30`; max 5 rounds.
- **Standard (`--standard`, default)**: full requirement interview; threshold `<= 0.20`; max 12 rounds.
- **Deep (`--deep`)**: high-rigor exploration; threshold `<= 0.15`; max 20 rounds.
- **Autoresearch (`--autoresearch`)**: Standard rigor, specialized for `$autoresearch` mission readiness (see below).

`max rounds` is a hard cap, not a target. Do not continue only to reach a round count. If no flag is given, use Standard. Optional per-repo overrides may live in `.omagy/config.json` under `deepInterview` (`defaultProfile`, `quickThreshold`, `standardThreshold`, `deepThreshold`, `quickMaxRounds`, `standardMaxRounds`, `deepMaxRounds`, `enableChallengeModes`). Ignore a malformed config. Explicit flags win.
</Depth_Profiles>

<Execution_Policy>
- Ask ONE question per round. Never batch several interview rounds into one form.
- 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. 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 dimension just for coverage while the current answer is still vague. Go one layer deeper first.
- Before crystallizing, complete at least one explicit pressure pass that revisits an earlier answer with a deeper assumption- or tradeoff-focused follow-up.
- Gather codebase facts yourself (or via the `explore` subagent) before asking the user about internals. Never ask the user for facts the repository can answer.
- Always run preflight context intake before the first question. For brownfield work, it includes doc/context grounding: governing `AGENTS.md`/`GEMINI.md` files, README/getting-started docs, relevant `docs/` contracts/plans/ADRs, existing `.omagy/context/` snapshots, and glossary/context files such as `CONTEXT.md`.
- Treat existing repo language as evidence, not authority. If the user's term is fuzzy, overloaded, or conflicts with docs/code, surface the exact wording and ask which meaning governs.
- Cross-check user claims about current behavior against code or documented contracts. If docs and code disagree, ask a confirmation question that names both sources.
- Use scenario-based edge-case grilling when a boundary or handoff is unclear: invent one concrete scenario that stresses it, then ask one focused question about the expected outcome.
- Durable doc/glossary/ADR updates are opt-in and public-safe only. Recommend them in the handoff; never auto-create them from interview transcripts.
- If initial context is oversized, do not paste it into prompts. Make the first round a request for a prompt-safe summary (goals, constraints, success criteria, non-goals, decision boundaries, references to full sources). This gate blocks scoring, crystallizing, and handoff.
- Route facts before judgment. Before each round, classify the needed information as a discoverable fact, a fact needing confirmation, or a human decision. The interview with the human is for judgment.
- **Two-Filter Question Gate + Owner-Decision Survival (ported from OmO `ulw-plan` & `obra/superpowers` `v7.0.2` `#2644`)**:
  - **Filter 1 (Material Fork)**: Does the answer change architecture, scope, schema, or file boundaries?
  - **Filter 2 (Unresolvable by Repo/Docs)**: Can this be answered by inspecting the repo or official docs? If yes, inspect—do not ask.
  - **Owner-Decision Survival**: Unless the user explicitly asked for a deep Socratic grilling ("interview me", "ask me everything"), ask only decisions that are irreversible, destructive, spend-bearing, scope-defining, or change a public/external contract. For reversible engineering defaults, propose the recommended default and record it under `[adopted-default]` if the user says "you decide" / "use best practices".
  - **Open "Why" First & Process Proposals (`superpowers` `v7.0.2` `#2644`)**: when the user hasn't stated *why* they want something, ask an open question first without steering option menus (`ask_question` with concrete choices is used once intent/"why" is known and a named fork exists). Process steps (where files go, doing recon, writing docs) are agent calls stated as proposals rather than questions. When nothing material is open on the first turn, present a short design/spec for approval immediately.
- When ambiguity depends on current external best practices or version-aware behavior, use `$best-practice-research` before crystallizing.
- Transcript/spec labels:
  - `[from-code][auto-confirmed]`: exact, high-confidence codebase facts with no prescription attached. Record them as context, not interview rounds.
  - `[from-code]`: inferred or pattern-based findings that need a confirmation-style round.
  - `[from-research]`: externally sourced facts (limits, compatibility, docs). Facts only, never decisions.
  - `[from-user]`: goals, preferences, scope, non-goals, acceptance criteria, tradeoffs, and any decision-bearing interpretation.
- Auto-confirm only descriptive facts. If a finding implies what the feature should do, which pattern to follow, or what is in/out of scope, route the whole decision to the user as `[from-user]`.
- Re-score ambiguity after each answer and show progress transparently.
- Once ambiguity is at or below threshold, stop ordinary questioning and run the closure audit.
- Do not hand off while ambiguity is above threshold unless the user explicitly opts to proceed with a warning.
- Do not crystallize or hand off while `Non-goals` or `Decision Boundaries` remain unresolved, even if the score meets threshold.
- Deep-interview is a requirements mode. Do not implement.
</Execution_Policy>

<Asking_Questions>
Use Antigravity's `ask_question` tool for every interview round. It replaces `omx question`.

- **No-Questions Override (ported from OmO `v5.1.52` `#11556`)**: do not call `ask_question` or ask the user when they have explicitly said not to (`"don't ask"`, `"no questions"`, `"do not ask me"`, `"hands-off"`). Instead, adopt best-practice defaults, record them as `[adopted-default]`, and crystallize the spec directly.
- One question per `ask_question` call. Header line in the question text:
  `Round {n} | Target: {weakest_dimension} | Ambiguity: {score}%`, then the question.
- `is_multi_select: false` (single-answer) when exactly one answer should drive the next branch or the options are mutually exclusive: lane selection, primary failure mode, competing interpretations.
- `is_multi_select: true` when several options can all hold at once: all out-of-scope items, all success metrics, all deployment constraints.
- If one selected option would immediately need a follow-up to disambiguate the others, ask a single-answer round now and the follow-up next. Do not hide a branching tree inside one multi-select.
- Options: 2-6 concrete, bounded choices written as the user's answer, formatted `Label — short description`. Put the recommended option first with the `(Recommended)` prefix. Do not add an "Other" option: the UI always provides a write-in.
- If `ask_question` is unavailable (for example in a headless run), ask exactly one concise plain-text question and wait for the answer.
- If the user skips a question, record that as `[from-user] skipped`, lower confidence for that dimension, and choose the next-highest-leverage question rather than re-asking verbatim.
</Asking_Questions>

<Steps>

## Phase 0: Preflight context intake

1. Derive a short task slug from the user's request.
2. Load the latest relevant snapshot from `.omagy/context/{slug}-*.md` if one exists.
3. Check whether the initial context or loaded snapshot is too large for safe prompt use. If so, round 1 must request a prompt-safe summary.
4. If no snapshot exists, create one containing: task statement; desired outcome; stated solution; probable intent hypothesis; known facts/evidence; constraints; unknowns; decision-boundary unknowns; likely codebase touchpoints; repo docs/rules/context inspected; terminology or doc/code conflicts; prompt-safe summary status (`not_needed` | `needed` | `recorded`).
5. For brownfield tasks, inspect the applicable documentation/rule surface before the first user-facing round. Prefer exact, nearby sources over broad scans.
6. Save to `.omagy/context/{slug}-{YYYYMMDDTHHMMSSZ}.md` (UTC).

## Phase 1: Initialize

1. Parse the depth profile flag.
2. Classify **brownfield** (existing codebase target) vs **greenfield**. For brownfield, collect relevant code context first (directly or via `explore`).
3. Persist state. Standalone: write `.omagy/state/deep-interview-state.json`. Inside Autopilot: do not create this file. Store the same fields under `state.deep_interview` in `autopilot-state.json`.

```json
{
  "mode": "deep-interview",
  "active": true,
  "current_phase": "interview",
  "started_at": "<ISO>",
  "updated_at": "<ISO>",
  "state": {
    "slug": "<slug>",
    "profile": "quick|standard|deep|autoresearch",
    "type": "greenfield|brownfield",
    "initial_idea": "<user input>",
    "rounds": [],
    "current_ambiguity": 1.0,
    "threshold": 0.2,
    "max_rounds": 12,
    "challenge_modes_used": [],
    "current_stage": "intent-first",
    "current_focus": "intent",
    "context_snapshot_path": ".omagy/context/<slug>-<ts>.md"
  }
}
```

4. Announce the kickoff with profile, threshold, and current ambiguity, and surface `[oh-my-agy HUD](sidecar://oh-my-agy/hud/)` once so the user can monitor the live `Interview` tab (ambiguity gauge, dimension bars, and readiness gates) in the Auxiliary Pane.

## Phase 2: Socratic interview loop

Repeat until: ambiguity `<= threshold` and the readiness gates pass, the user exits with a warning, or max rounds are reached. Below threshold, do not open a new ordinary branch. Read [scoring-and-templates.md](./references/scoring-and-templates.md) for the full stage-priority ladder, ledgers, challenge modes, and spec templates.

### 2a) Generate the next question
If oversized context has no recorded summary, the only allowed question is the summary request.

Target the lowest-scoring dimension, respecting stage priority (**Stage 1**: Intent, Outcome, Scope, Non-goals, Decision Boundaries -> **Stage 2**: Constraints, Success Criteria -> **Stage 3**: Context Clarity for brownfield). Apply the 6-step follow-up pressure ladder and maintain the **Breadth Ledger** and brownfield **Docs/Terminology Ledger** defined in [scoring-and-templates.md](./references/scoring-and-templates.md). `Non-goals` and `Decision Boundaries` are mandatory readiness gates.

### 2b) Ask the question
Use `ask_question` as described in `<Asking_Questions>`.

### 2c) Score ambiguity
Score each dimension in `[0.0, 1.0]` with a justification and 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)`

Enforce all readiness gates (`Non-goals`, `Decision Boundaries`, pressure pass complete, practical closure audit, and zero-context `Builder Check` triage) and round controls (Dialectic Rhythm Guard after 3 consecutive non-user entries; early exit from round 4 with risk warning; hard cap at `max_rounds`) per [scoring-and-templates.md](./references/scoring-and-templates.md). If `ambiguity <= 0.10` and gates pass, crystallize immediately.

### 2d) Report progress & persist state
Show the weighted breakdown table, readiness-gate status, and next focus dimension. Append the round (question, answer, label, scores) to state and refresh `updated_at`.

## Phase 3: Challenge modes

Use each mode at most once when triggered (`Contrarian`, `Terminologist`, `Simplifier`, `Ontologist`; force `Ontologist` once if ambiguity stalls `±0.05` for 3 rounds) and record usage in `state.challenge_modes_used`. See [scoring-and-templates.md](./references/scoring-and-templates.md) for trigger rules.

## Phase 4: Crystallize artifacts

When threshold is met (or on early exit with a warning, or at the hard cap):

0. **Configurable Custom Quality Gates (`qualityGates["deep-interview"]`, ported from OMX `v0.21.41` `#3956` & OMC `v5.7.22` `#4670`/`#4671`)**: after writing the spec in step 2, if `.omagy/config.json` defines `qualityGates["deep-interview"]` (strict no-op when absent/empty; reserved controller skills like `deep-interview`, `ralplan`, `code-review`, `ai-slop-cleaner` are rejected to prevent self-recursion), run each configured gate skill in an independent subagent (`Model: gate.model || "inherit"`). Any `blocking` gate returning `reject`/`iterate` requires revising the spec before step 3; `advisory` or `unavailable` gates are recorded without blocking.
1. Write the transcript summary to `.omagy/interviews/{slug}-{timestamp}.md`.
2. Write the execution-ready spec to `.omagy/specs/deep-interview-{slug}.md` following the 9-section template (including the **Affected User Ideal State & Gap Table**, `[adopted-default]` decision boundaries, and pressure/terminology audits) in [scoring-and-templates.md](./references/scoring-and-templates.md).
   - For **`--autoresearch`**, also generate `.omagy/specs/deep-interview-autoresearch-{slug}.md` (with the locked `## Fidelity` block: `as of`, `meaning check`, `source floor`, `derived numbers`) and the launch bundle under `.omagy/specs/autoresearch-{slug}/` (`mission.md`, `sandbox.md`, `result.json`), marking `launchReady: false` if placeholders or undecided fidelity fields remain, per [scoring-and-templates.md](./references/scoring-and-templates.md).
3. Standalone: write state `current_phase:"complete"`, `active:false`, `completed_at`. Inside Autopilot: set `handoff_artifacts.deep_interview` to the spec path and advance Autopilot to `ralplan`.

## Phase 5: Execution bridge

Present handoff options with `ask_question` (single-answer, recommended option first). The spec is the requirements source of truth. Preserve intent, non-goals, decision boundaries, acceptance criteria, terminology grounding, and residual-risk warnings across the handoff.

1. **`$ultragoal`** (default durable execution): input is the spec. Convert it into durable goals with sequential completion tracking. It skips requirements discovery.
2. **`$ralplan`** (recommended when architecture/test-shape review is still needed): treat the spec as requirements truth and do not repeat the interview. Output goes to `.omagy/plans/`.
3. **`$autopilot`**: planning plus execution from the clarified brief.
4. **`$team`**: coordinated parallel execution against the shared spec.
5. **Refine further**: continue the interview loop.

Context-sensitive goal-mode suggestions: `$autoresearch` for research projects, `$performance-goal` for measurable optimization work.

Optional stride contract: when the downstream workflow needs an explicit stop condition, store it as structured data under `handoff_artifacts.deep_interview.execution_contract` in Autopilot state, e.g. `{"version":1,"execution_stride":"task|deliverable|milestone","selected_by":"user","completion_unit":"...","stop_condition":"..."}`. Do not infer stride from task length.

**Do NOT implement inside deep-interview.** On handoff, activate the selected skill.

</Steps>

<Escalation_And_Stop_Conditions>
- User says stop/cancel/abort: persist state and stop.
- Ambiguity stalls for 3 rounds: force Ontologist once.
- Max rounds reached: proceed with an explicit residual-risk warning.
- All dimensions >= 0.9: early crystallization is allowed.
</Escalation_And_Stop_Conditions>

<Final_Checklist>
- [ ] Preflight snapshot exists under `.omagy/context/`.
- [ ] Oversized context (if any) has a recorded prompt-safe summary before scoring or handoff.
- [ ] Ambiguity was shown each round, with intent-first priority and weakest-dimension targeting.
- [ ] At least one assumption probe and one pressure pass happened.
- [ ] Challenge modes fired when applicable.
- [ ] Transcript written to `.omagy/interviews/` and spec to `.omagy/specs/deep-interview-{slug}.md`.
- [ ] Brownfield questions used evidence-backed confirmation; terminology conflicts were resolved.
- [ ] Handoff options were offered. No direct implementation was performed.
</Final_Checklist>