deep-dive

What it does

Orchestrates a two-stage pipeline that first investigates why something happened (trace) and then defines what to do about it (deep-interview). It runs three parallel causal lanes in Phase 3, feeding results into the interview via a 3-point injection mechanism to enrich initialization, provide context, and seed initial questions. The process ends by handing off to a later execution stage via an Execution Bridge.

How it works

• Phase 1 (Initialize): parses user idea, generates a kebab-case slug from the first five words, detects brownfield vs greenfield using a codebase explore step, generates three trace lane hypotheses, and initializes a deep-interview state with trace_lanes and metadata.
• Phase 2 (Lane Confirmation): presents three hypotheses to the user for confirmation and then moves to trace-executing.
• Phase 3 (Trace Execution): runs three parallel tracer lanes (one per hypothesis) using a team-mode orchestration. Each lane gathers supporting and opposing evidence, identifies a critical unknown, and suggests a discriminating probe. The output is saved to a markdown file and the path stored in state; phase advances to trace-complete.
• Phase 4 (Interview with Trace Injection): follows the base deep-interview protocol but adds three initialization overrides via a 3-point injection:
  1. enriches initial_idea with trace findings wrapped in trace-context delimiters;
  2. replaces brownfield codebase_context with the trace synthesis wrapped in delimiters;
  3. injects per-lane critical unknowns as the first interview questions. If trace is inconclusive, overrides still provide contextual trace data and all per-lane unknowns. The interview proceeds one question at a time, with ambiguity scoring and ontology tracking.
• Phase 5 (Execution Bridge): reads spec_path and trace_path from state to present execution options, then invokes the chosen downstream skill (e.g., omc-plan, autopilot, ralph, team) via Skill() with an explicit spec_path. This phase does not implement execution itself.

When to use it

• The user has a problem but lacks root cause clarity and needs investigation before requirements.
• The user says one of: "deep dive", "deep-dive", "trace and interview", or "investigate deeply".
• The goal is to understand system behavior before changes, perform bug investigation, or explore feature changes when the problem is ambiguous and evidence-heavy.

What it can touch

• Tools: claude-code is declared, but this skill mainly orchestrates and stores state, interacting with downstream skills via Skill() calls. It uses state_write to persist across phases.
• Artifacts: saves trace results to .omc/specs/deep-dive-trace-{slug}.md and, upon completion, a spec to .omc/specs/deep-dive-{slug}.md

Caveats

• State persistence and exact sequencing rely on the deep-interview protocol; it overrides initialization in three places to inject trace context.
• If trace lacks a clear most likely explanation, the skill preserves original user input but still injects trace synthesis and all per-lane unknowns.
• The 3-point injection uses explicit trace-context delimiters to separate injected data from agent directives.