<purpose>
Socratic ideation workflow. Guides the developer through exploring an idea via probing questions,
offers mid-conversation research when useful, then routes crystallized outputs to rcode artifacts.
</purpose>


## Step 0 — Usage check

If `$ARGUMENTS` is empty or contains only `--help` or `-h`:

```
/rcode-explore <argument-here>
```

**Examples:**
```
/rcode-explore example 1
/rcode-explore example 2
```

STOP — do not proceed.

<required_reading>
Read all files referenced by the invoking prompt's execution_context before starting.

@.rcode/references/questioning.md
@.rcode/references/domain-probes.md
</required_reading>

<available_agent_types>
Valid rcode subagent types (use exact names — do not fall back to 'general-purpose'):
- rcode-phase-researcher — Researches specific questions and returns concise findings
</available_agent_types>

<process>

## Step 1: Open the conversation

If a topic was provided, acknowledge it and begin exploring:
```
## Explore: {topic}

Let's think through this together. I'll ask questions to help clarify the idea
before we commit to any artifacts.
```

If no topic, ask:
```
## Explore

What's on your mind? This could be a feature idea, an architectural question,
a problem you're trying to solve, or something you're not sure about yet.
```

## Step 2: Socratic conversation (2-5 exchanges)

Guide the conversation using principles from `questioning.md` and `domain-probes.md`:

- Ask **one question at a time** (never a list of questions)
- Questions should probe: constraints, tradeoffs, users, scope, dependencies, risks
- Use domain-specific probes contextually when the topic touches a known domain
- Listen for signals: "or" / "versus" / "tradeoff" indicate competing priorities worth exploring
- Reflect back what you hear to confirm understanding before moving forward

**Conversation should feel natural, not formulaic.** Avoid rigid sequences. Follow the developer's energy — if they're excited about one aspect, go deeper there.

## Step 3: Mid-conversation research offer (after 2-3 exchanges)

If the conversation surfaces factual questions, technology comparisons, or unknowns that research could resolve, offer:

```
This touches on [specific question]. Want me to do a quick research pass before we continue?
This would take ~30 seconds and might surface useful context.

[Yes, research this] / [No, let's keep exploring]
```

If yes, spawn a research agent:
```
Task(
  prompt="Quick research: {specific_question}. Return 3-5 key findings, no more than 200 words.",
  subagent_type="rcode-phase-researcher"
)
```

Share findings and continue the conversation.

If the topic doesn't warrant research, skip this step entirely. **Don't force it.**

## Step 4: Crystallize outputs (after 3-6 exchanges)

When the conversation reaches natural conclusions or the developer signals readiness, propose outputs. Analyze the conversation to identify what was discussed and suggest **up to 4 outputs** from:

| Type | Destination | When to suggest |
|------|-------------|-----------------|
| Note | `.planning/notes/{slug}.md` | Observations, context, decisions worth remembering |
| Todo | `.planning/todos/pending/{slug}.md` | Concrete actionable tasks identified |
| Seed | `.planning/seeds/{slug}.md` | Forward-looking ideas with trigger conditions |
| Research question | `.planning/research/questions.md` (append) | Open questions that need deeper investigation |
| Requirement | `REQUIREMENTS.md` (append) | Clear requirements that emerged from discussion |
| New phase | `ROADMAP.md` (append) | Scope large enough to warrant its own phase |

Present suggestions:
```
Based on our conversation, I'd suggest capturing:

1. **Note:** "Authentication strategy decisions" — your reasoning about JWT vs sessions
2. **Todo:** "Evaluate Passport.js vs custom middleware" — the comparison you want to do
3. **Seed:** "OAuth2 provider support" — trigger: when user management phase starts

Create these? You can select specific ones or modify them.

[Create all] / [Let me pick] / [Skip — just exploring]
```

**Never write artifacts without explicit user selection.**

## Step 5: Write selected outputs

For each selected output, write the file:

- **Notes:** Create `.planning/notes/{slug}.md` with frontmatter (title, date, context)
- **Todos:** Create `.planning/todos/pending/{slug}.md` with frontmatter (title, date, priority)
- **Seeds:** Create `.planning/seeds/{slug}.md` with frontmatter (title, trigger_condition, planted_date)
- **Research questions:** Append to `.planning/research/questions.md`
- **Requirements:** Append to `.planning/REQUIREMENTS.md` with next available REQ ID
- **Phases:** Use existing `/rcode-add-phase` command via SlashCommand

Commit if `commit_docs` is enabled:
```bash
node "$PROJECT_ROOT/.rcode/bin/rcode-tools.cjs" commit "docs: capture exploration — {topic_slug}" --files {file_list}
```

## Step 6: Close

```
## Exploration Complete

**Topic:** {topic}
**Outputs:** {count} artifact(s) created
{list of created files}

Continue exploring with `/rcode-explore` or start working with `/rcode-next`.
```

</process>

<success_criteria>
- [ ] Socratic conversation follows questioning.md principles
- [ ] Questions asked one at a time, not in batches
- [ ] Research offered contextually (not forced)
- [ ] Up to 4 outputs proposed from conversation
- [ ] User explicitly selects which outputs to create
- [ ] Files written to correct destinations
- [ ] Commit respects commit_docs config
</success_criteria>

## Success Criteria

- [ ] Socratic conversation conducted question-by-question — questions asked one at a time, not batched
- [ ] Contextual research offered at least once during conversation when a knowledge gap is identified
- [ ] Up to 4 concrete outputs (PRD, epic, architecture doc, etc.) proposed from crystallized ideas
- [ ] User explicitly selected which outputs to create before any file was written
- [ ] Selected output files written to the correct rcode destination paths (e.g., `.planning/PROJECT.md`, `.planning/epics/`)
- [ ] Commit created when `commit_docs` config is enabled

## On Error

If arguments are invalid, missing files, or subagent fails:
- Validate inputs match expected format
- Check that required files exist
- Retry with clearer arguments or report the specific error to the user


## Next Up

- `/rcode-create-prd` — formalize the crystallized idea into a PRD
- `/rcode-brainstorm` — continue structured brainstorming on the concept
- `/rcode-prfaq` — stress-test the idea with Working Backwards
