@open-agent-toolkit/cli 0.0.10

package/assets/skills/oat-idea-ideate/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: oat-idea-ideate
+version: 1.2.0
+description: Use when continuing brainstorming for an existing idea or starting from a scratchpad entry. Guides conversational ideation and refinement.
+argument-hint: '[--global]'
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Write, Bash, Glob, AskUserQuestion
+---
+
+# Ideate
+
+Resume brainstorming on an existing idea, or pick one from the scratchpad to start exploring.
+
+## Mode Assertion
+
+**OAT MODE: Ideation**
+
+**Purpose:** Lightweight brainstorming through natural, exploratory conversation. Capture the essence of an idea without formal structure or implementation detail.
+
+**BLOCKED Activities:**
+
+- No code writing or implementation details
+- No formal requirements or specifications
+- No technical designs or architecture
+- No task breakdowns or plans
+- No forced structure — let the idea breathe
+
+**ALLOWED Activities:**
+
+- Free-form discussion and exploration
+- Asking open-ended questions
+- Capturing thoughts and observations
+- Exploring "what if" scenarios
+- Noting related ideas and references
+- Identifying open questions organically
+
+**Self-Correction Protocol:**
+If you catch yourself:
+
+- Writing implementation details → STOP (capture as an Open Question instead)
+- Formalizing requirements → STOP (keep it conversational)
+- Creating structured deliverables → STOP (save for project workflow)
+
+**Recovery:**
+
+1. Acknowledge the deviation
+2. Return to exploratory questioning
+3. Capture the insight as a note or open question
+
+## Progress Indicators (User-Facing)
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ IDEATE [project]
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Replace `[project]` with `[global]` when operating at user level.
+
+- Before multi-step work, print step indicators, e.g.:
+  - `[1/3] Resolving active idea…`
+  - `[2/3] Loading discovery document…`
+  - `[3/3] Starting brainstorming session…`
+
+## Process
+
+### Step 0: Resolve Ideas Level
+
+Determine whether to operate at project level or user (global) level.
+
+**Resolution order:**
+
+1. If `$ARGUMENTS` contains `--global` → use **user level**
+2. If `.oat/config.local.json` has `activeIdea` pointing to a valid directory → use **project level**
+3. If `~/.oat/config.json` has `activeIdea` pointing to a valid directory → use **user level**
+4. If BOTH `.oat/ideas/` AND `~/.oat/ideas/` exist →
+   ask: "Ideas exist at both project and user level. Where should this idea go?"
+   options: "Project (.oat/ideas/)" / "Global (~/.oat/ideas/)"
+5. If `.oat/ideas/` exists → use **project level**
+6. If `~/.oat/ideas/` exists → use **user level**
+7. Otherwise → ask: "Project-level or global (user-level) ideas?"
+
+**Set variables:**
+
+| Variable         | Project Level          | User Level               |
+| ---------------- | ---------------------- | ------------------------ |
+| `IDEAS_ROOT`     | `.oat/ideas`           | `~/.oat/ideas`           |
+| `TEMPLATES_ROOT` | `.oat/templates/ideas` | `~/.oat/templates/ideas` |
+
+### Step 1: Resolve Active Idea
+
+Read `activeIdea` from config:
+
+```bash
+IDEA_PATH=$(oat config get activeIdea 2>/dev/null || true)
+```
+
+**If valid (directory exists with discovery.md):**
+
+- Show the idea name and current state to the user
+- Ask: "Continue with **{idea-name}**, or switch to a different idea?"
+- If continuing, proceed to Step 2
+
+**If missing or invalid:**
+
+- List existing idea directories:
+  ```bash
+  ls -d {IDEAS_ROOT}/*/  2>/dev/null
+  ```
+- Read `{IDEAS_ROOT}/scratchpad.md` and extract unchecked entries (`- [ ]`), including any nested notes for context
+- Present combined list to the user:
+  - Existing ideas (with state: brainstorming/summarized)
+  - Scratchpad entries marked as "not yet started"
+- If user picks an existing idea → run `oat config set activeIdea "{idea-path}"` and proceed to Step 2
+- If user picks a scratchpad entry → scaffold the idea inline by reading the **`oat-idea-new`** skill (`.agents/skills/oat-idea-new/SKILL.md`) and executing its Steps 3-7 (Initialize Ideas Directory, Scaffold Discovery Document, Update Backlog, Check Scratchpad, Set Active Idea Pointer). Then proceed to Step 2 with the new idea.
+- If no ideas and no scratchpad entries exist → tell the user: "No ideas found. Run the `oat-idea-new` skill to create one, or run the `oat-idea-scratchpad` skill to capture a quick idea seed." Then stop.
+
+### Step 2: Load Discovery Document
+
+Read `{IDEAS_ROOT}/{idea-name}/discovery.md`.
+
+Show the user a brief summary of the current state:
+
+- Idea name
+- State (brainstorming/summarized)
+- Last updated date
+- Key sections that have content vs. are still template placeholders
+
+### Step 3: Handle Summarized State
+
+If `oat_idea_state: summarized`:
+
+- Warn: "This idea has already been summarized."
+- Offer options:
+  - **Reopen brainstorming** — set state back to `brainstorming`, continue to Step 4
+  - **View summary** — read and display `summary.md`, then stop
+  - **Start a different idea** — go back to Step 1
+
+### Step 4: Start New Session
+
+Add a new session header to the **Notes & Discussion** section:
+
+```markdown
+### Session: YYYY-MM-DD
+```
+
+Update frontmatter: `oat_idea_last_updated: YYYY-MM-DD`
+
+### Step 5: Conversational Brainstorming
+
+Enter a free-form conversational flow:
+
+1. **Read current content** to understand where the idea stands
+2. **Ask exploratory questions** based on what's been discussed so far:
+   - If early stage: "What sparked this idea?", "What problem does this solve?"
+   - If mid-stage: "What's changed since last time?", "Any new angles?"
+   - If sections are thin: ask questions that naturally fill them out
+3. **Capture responses** in the discovery document:
+   - Update "What's the Idea?" if the core concept evolves
+   - Update "Why Is It Interesting?" as motivations emerge
+   - Update "What Would It Look Like?" as the vision takes shape
+   - Add to "Open Questions" as unknowns surface
+   - Add to "Related Ideas" as connections are made
+   - Append detailed notes to the current session under "Notes & Discussion"
+4. **Follow the user's energy** — explore tangents, let ideas evolve naturally
+5. **Don't force completion** — ideation can be open-ended
+
+### Step 6: Session Close
+
+When the user signals they're done (or the conversation reaches a natural pause):
+
+1. Update `oat_idea_last_updated` in frontmatter
+2. Save all changes to `discovery.md`
+3. Tell the user their progress is saved, then suggest these next steps (these are prompts for the user to run later — do **not** auto-invoke them):
+   - **Continue later** — "Run the `oat-idea-ideate` skill to pick up where you left off"
+   - **Summarize** — "Run the `oat-idea-summarize` skill to finalize this idea"
+   - **Switch ideas** — "Run the `oat-idea-ideate` skill and pick a different idea"
+   - **Quick capture** — "Run the `oat-idea-scratchpad` skill to jot down a new idea seed"
+
+## Success Criteria
+
+- ✅ Active idea resolved (or user guided to create one)
+- ✅ New session header added to Notes & Discussion
+- ✅ Discovery document updated with conversation content
+- ✅ `oat_idea_last_updated` reflects today's date
+- ✅ User offered clear next steps on session close

package/assets/skills/oat-idea-new/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: oat-idea-new
+version: 1.2.0
+description: Use when starting ideation for a new concept or problem. Creates an idea directory for lightweight capture and handoff to ongoing ideation.
+argument-hint: '<idea-name> [--global]'
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Write, Bash, Glob, AskUserQuestion
+---
+
+# New Idea
+
+Create a new idea directory, scaffold a discovery document, verify setup, and hand off to `oat-idea-ideate` for brainstorming.
+
+## Progress Indicators (User-Facing)
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ NEW IDEA [project]
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Replace `[project]` with `[global]` when operating at user level.
+
+- Before multi-step work, print step indicators, e.g.:
+  - `[1/4] Validating idea name…`
+  - `[2/4] Scaffolding idea directory…`
+  - `[3/4] Updating backlog + scratchpad…`
+  - `[4/4] Handing off to ideation…`
+
+## Process
+
+### Step 0: Resolve Ideas Level
+
+Determine whether to operate at project level or user (global) level.
+
+**Resolution order:**
+
+1. If `$ARGUMENTS` contains `--global` → use **user level**
+2. If `.oat/config.local.json` has `activeIdea` pointing to a valid directory → use **project level**
+3. If `~/.oat/config.json` has `activeIdea` pointing to a valid directory → use **user level**
+4. If BOTH `.oat/ideas/` AND `~/.oat/ideas/` exist →
+   ask: "Ideas exist at both project and user level. Where should this idea go?"
+   options: "Project (.oat/ideas/)" / "Global (~/.oat/ideas/)"
+5. If `.oat/ideas/` exists → use **project level**
+6. If `~/.oat/ideas/` exists → use **user level**
+7. Otherwise → ask: "Project-level or global (user-level) ideas?"
+
+**Set variables:**
+
+| Variable         | Project Level          | User Level               |
+| ---------------- | ---------------------- | ------------------------ |
+| `IDEAS_ROOT`     | `.oat/ideas`           | `~/.oat/ideas`           |
+| `TEMPLATES_ROOT` | `.oat/templates/ideas` | `~/.oat/templates/ideas` |
+
+### Step 1: Get Idea Name
+
+If not provided in `$ARGUMENTS`, ask the user for an idea name.
+
+**Validation:** Slug format only — alphanumeric, dashes, and underscores. No spaces or special characters.
+
+### Step 2: Check for Existing Idea
+
+```bash
+test -d "{IDEAS_ROOT}/$IDEA_NAME"
+```
+
+**If exists:** Tell the user this idea already exists and suggest: "Run the `oat-idea-ideate` skill to resume brainstorming on it." Stop here unless they want a different name.
+
+### Step 3: Initialize Ideas Directory
+
+Create the ideas directory structure if it doesn't exist:
+
+```bash
+mkdir -p "{IDEAS_ROOT}/$IDEA_NAME"
+```
+
+If `{IDEAS_ROOT}/backlog.md` doesn't exist, copy from template:
+
+- Source: `{TEMPLATES_ROOT}/ideas-backlog.md`
+- Target: `{IDEAS_ROOT}/backlog.md`
+
+If `{IDEAS_ROOT}/scratchpad.md` doesn't exist, copy from template:
+
+- Source: `{TEMPLATES_ROOT}/ideas-scratchpad.md`
+- Target: `{IDEAS_ROOT}/scratchpad.md`
+
+### Step 4: Scaffold Discovery Document
+
+Copy template and apply replacements:
+
+- Source: `{TEMPLATES_ROOT}/idea-discovery.md`
+- Target: `{IDEAS_ROOT}/$IDEA_NAME/discovery.md`
+
+Replacements:
+
+- `{Idea Name}` → actual idea name (title case from slug)
+- `YYYY-MM-DD` → today's date (ISO format)
+
+### Step 5: Update Backlog
+
+Add an entry to `{IDEAS_ROOT}/backlog.md` under the **Active Brainstorming** section:
+
+```markdown
+- **{idea-name}** — {placeholder: to be filled during brainstorming} _(Created: YYYY-MM-DD)_
+```
+
+### Step 6: Check Scratchpad
+
+Read `{IDEAS_ROOT}/scratchpad.md` and look for an unchecked entry matching the idea name.
+
+If found, check it off and append a note. Preserve any nested bullet notes beneath the entry:
+
+```markdown
+- [x] **{idea-name}** - {original note} _(YYYY-MM-DD)_ → started (`{IDEAS_ROOT}/{idea-name}/`)
+  - {preserved quick note 1}
+  - {preserved quick note 2}
+```
+
+### Step 7: Set Active Idea Pointer
+
+Write the active idea path to config:
+
+```bash
+oat config set activeIdea "{IDEAS_ROOT}/{idea-name}"
+```
+
+### Step 8: Verify and Hand Off
+
+Verify all success criteria are met, then tell the user:
+
+```
+Idea "{Idea Name}" created successfully.
+
+Level:     {project | global}
+Directory: {IDEAS_ROOT}/{idea-name}/
+Backlog:   {IDEAS_ROOT}/backlog.md (entry added)
+Active:    config activeIdea (set)
+
+Starting brainstorming...
+```
+
+Then immediately invoke the **`oat-idea-ideate`** skill (located at `.agents/skills/oat-idea-ideate/SKILL.md`) to begin the first brainstorming session. Read that skill file and follow its process from Step 1. The ideate skill owns all conversational brainstorming behavior — do not duplicate it here.
+
+## Success Criteria
+
+- ✅ `{IDEAS_ROOT}/{idea-name}/` directory exists
+- ✅ `discovery.md` scaffolded with correct name and date
+- ✅ `{IDEAS_ROOT}/backlog.md` exists and includes the new idea
+- ✅ `{IDEAS_ROOT}/scratchpad.md` exists (initialized if first idea)
+- ✅ `activeIdea` config value points to the new idea
+- ✅ `oat-idea-ideate` skill invoked and brainstorming started

package/assets/skills/oat-idea-scratchpad/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: oat-idea-scratchpad
+version: 1.2.0
+description: Use when you need quick idea capture or want to review scratchpad entries. Manages lightweight idea seeds and optional notes.
+argument-hint: '[review | capture] [--global]'
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Write, Bash, Glob, AskUserQuestion
+---
+
+# Scratchpad
+
+Review your ideas scratchpad or quick-capture a new idea seed.
+
+## Progress Indicators (User-Facing)
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ SCRATCHPAD [project]
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Replace `[project]` with `[global]` when operating at user level.
+
+- Before multi-step work, print step indicators, e.g.:
+  - `[1/2] Resolving ideas level…`
+  - `[2/2] Reading scratchpad…` (review mode) or `[2/2] Capturing new idea…` (capture mode)
+
+## Process
+
+### Step 0: Resolve Ideas Level
+
+Determine whether to operate at project level or user (global) level. The scratchpad does not require an active idea.
+
+**Resolution order:**
+
+1. If `$ARGUMENTS` contains `--global` → use **user level**
+2. If `.oat/config.local.json` has `activeIdea` pointing to a valid directory → use **project level**
+3. If `~/.oat/config.json` has `activeIdea` pointing to a valid directory → use **user level**
+4. If BOTH `.oat/ideas/` AND `~/.oat/ideas/` exist →
+   ask: "Ideas exist at both project and user level. Where should this idea go?"
+   options: "Project (.oat/ideas/)" / "Global (~/.oat/ideas/)"
+5. If `.oat/ideas/` exists → use **project level**
+6. If `~/.oat/ideas/` exists → use **user level**
+7. Otherwise → ask: "Project-level or global (user-level) ideas?"
+
+**Set variables:**
+
+| Variable         | Project Level          | User Level               |
+| ---------------- | ---------------------- | ------------------------ |
+| `IDEAS_ROOT`     | `.oat/ideas`           | `~/.oat/ideas`           |
+| `TEMPLATES_ROOT` | `.oat/templates/ideas` | `~/.oat/templates/ideas` |
+
+### Step 1: Determine Mode
+
+If `$ARGUMENTS` contains `review`, go to Step 2.
+If `$ARGUMENTS` contains `capture`, go to Step 3.
+Otherwise, ask the user: "Would you like to **review** what's on the scratchpad, or **capture** a new idea?"
+
+### Step 2: Review Mode
+
+1. Read `{IDEAS_ROOT}/scratchpad.md`
+2. If the file does not exist or contains only the template placeholder entry, tell the user: "Scratchpad is empty. Would you like to capture your first idea?" If yes, go to Step 3. Otherwise, stop.
+3. Parse entries and display grouped by status:
+   - **Open ideas** (`- [ ]`): show count and list with summaries and any nested notes
+   - **Started** (`- [x]`): show count and list (collapsed summary)
+4. Offer next actions (suggest to the user — do **not** auto-invoke):
+   - "Capture a new idea" → go to Step 3
+   - "Start brainstorming on one" → "Run the `oat-idea-new` skill with the idea name"
+   - "Done" → stop
+
+### Step 3: Capture Mode
+
+1. Ask for idea name if not provided in `$ARGUMENTS`. **Validation:** slug format only — alphanumeric, dashes, and underscores.
+2. Ask for a one-liner summary (required, 1 sentence).
+3. Ask: "Any quick notes? (optional — press enter to skip)"
+   - If the user provides notes, capture them. Ask "Another note?" until the user declines or provides an empty response.
+4. Initialize scratchpad if needed:
+   - Create `{IDEAS_ROOT}/` directory if it does not exist (`mkdir -p`)
+   - If `{IDEAS_ROOT}/scratchpad.md` does not exist, copy from template:
+     - Source: `{TEMPLATES_ROOT}/ideas-scratchpad.md`
+     - Target: `{IDEAS_ROOT}/scratchpad.md`
+   - If `{IDEAS_ROOT}/backlog.md` does not exist, copy from template:
+     - Source: `{TEMPLATES_ROOT}/ideas-backlog.md`
+     - Target: `{IDEAS_ROOT}/backlog.md`
+5. Append entry to `{IDEAS_ROOT}/scratchpad.md` under the `## Ideas` section:
+
+   ```markdown
+   - [ ] **{idea-name}** - {one-liner summary} _(YYYY-MM-DD)_
+     - {note 1}
+     - {note 2}
+   ```
+
+   Include nested bullets only if the user provided notes.
+
+6. Confirm capture:
+
+   ```
+   Captured "{idea-name}" on the scratchpad.
+
+   Scratchpad: {IDEAS_ROOT}/scratchpad.md
+   ```
+
+7. Ask: "Capture another idea, or done for now?"
+   - If another → repeat from step 1 of Capture Mode
+   - If done → suggest next steps (suggest to the user — do **not** auto-invoke):
+     - "Start brainstorming: run the `oat-idea-new` skill with the idea name"
+     - "Review scratchpad: run the `oat-idea-scratchpad` skill with `review`"
+
+## Success Criteria
+
+- ✅ Scratchpad reviewed or new entry captured
+- ✅ `{IDEAS_ROOT}/scratchpad.md` exists (initialized from template if first use)
+- ✅ New entries use nested-bullet format (name + summary + optional notes)
+- ✅ User informed of next steps

package/assets/skills/oat-idea-summarize/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: oat-idea-summarize
+version: 1.2.0
+description: Use when an idea is mature enough to move from brainstorming into the backlog. Generates a summary document and adds the idea to the backlog.
+argument-hint: '[--global]'
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Write, Grep, AskUserQuestion
+---
+
+# Summarize Idea
+
+Read the brainstorming discovery document, synthesize a clean summary, and update the ideas backlog.
+
+## Prerequisites
+
+- An active idea must exist (`activeIdea` set in config, with a `discovery.md` that has meaningful content)
+
+## Progress Indicators (User-Facing)
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ SUMMARIZE IDEA [project]
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Replace `[project]` with `[global]` when operating at user level.
+
+- Before multi-step work, print step indicators, e.g.:
+  - `[1/4] Resolving active idea…`
+  - `[2/4] Reading discovery document…`
+  - `[3/4] Generating summary…`
+  - `[4/4] Updating backlog…`
+
+## Process
+
+### Step 0: Resolve Ideas Level
+
+Determine whether to operate at project level or user (global) level.
+
+**Resolution order:**
+
+1. If `$ARGUMENTS` contains `--global` → use **user level**
+2. If `.oat/config.local.json` has `activeIdea` pointing to a valid directory → use **project level**
+3. If `~/.oat/config.json` has `activeIdea` pointing to a valid directory → use **user level**
+4. If BOTH `.oat/ideas/` AND `~/.oat/ideas/` exist →
+   ask: "Ideas exist at both project and user level. Where should this idea go?"
+   options: "Project (.oat/ideas/)" / "Global (~/.oat/ideas/)"
+5. If `.oat/ideas/` exists → use **project level**
+6. If `~/.oat/ideas/` exists → use **user level**
+7. Otherwise → ask: "Project-level or global (user-level) ideas?"
+
+**Set variables:**
+
+| Variable         | Project Level          | User Level               |
+| ---------------- | ---------------------- | ------------------------ |
+| `IDEAS_ROOT`     | `.oat/ideas`           | `~/.oat/ideas`           |
+| `TEMPLATES_ROOT` | `.oat/templates/ideas` | `~/.oat/templates/ideas` |
+
+### Step 1: Resolve Active Idea
+
+Read `activeIdea` from config (`oat config get activeIdea`) to get `IDEA_PATH`.
+
+**If missing or invalid:**
+
+- Use the Glob tool to list idea directories: `{IDEAS_ROOT}/*/discovery.md`
+- Ask the user to pick one
+- Run `oat config set activeIdea "{chosen-idea-path}"`
+
+Derive `IDEA_NAME` from the directory basename.
+
+### Step 2: Read Discovery Document
+
+Read `{IDEAS_ROOT}/$IDEA_NAME/discovery.md`.
+
+**Validate content:** Check that the document has meaningful content beyond the template placeholders. Look for:
+
+- "What's the Idea?" section has real content (not just `{Brief description...}`)
+- At least one session in "Notes & Discussion"
+
+**If mostly empty:**
+
+- Warn: "This idea hasn't been explored much yet. Consider running the `oat-idea-ideate` skill first to flesh it out."
+- Ask: continue with summarization anyway, or brainstorm more? If user chooses to brainstorm, read the **`oat-idea-ideate`** skill (`.agents/skills/oat-idea-ideate/SKILL.md`) and follow its process from Step 4.
+
+### Step 3: Generate Summary
+
+Copy the summary template and synthesize content from the discovery document:
+
+- Source: `{TEMPLATES_ROOT}/idea-summary.md`
+- Target: `{IDEAS_ROOT}/$IDEA_NAME/summary.md`
+
+**Synthesis guidelines:**
+
+- **Overview:** 2-4 sentence synthesis drawn from "What's the Idea?" and "Why Is It Interesting?"
+- **Key Points:** 3-5 bullets capturing the most important insights from the entire discovery
+- **Why This Matters:** Value proposition from "Why Is It Interesting?" and session discussions
+- **What It Would Take:** High-level effort sense from "What Would It Look Like?" and discussions (if discussed)
+- **Next Steps:** Actionable items if the idea were to be pursued
+- **Open Questions:** Carry over unresolved questions from discovery
+- **References:** Carry over from "Related Ideas"
+
+Apply replacements:
+
+- `{Idea Name}` → actual idea name
+- `oat_idea_created` → original creation date from discovery frontmatter
+- `oat_idea_summarized` → today's date
+
+### Step 4: Show Summary for Review
+
+Display the generated summary to the user. Ask:
+
+- **Accept** — finalize and update backlog
+- **Refine** — edit the summary (make changes, then re-confirm)
+- **Continue brainstorming** — discard summary and resume brainstorming
+
+If user chooses to continue brainstorming, do not update state or backlog. Read the **`oat-idea-ideate`** skill (`.agents/skills/oat-idea-ideate/SKILL.md`) and follow its process from Step 4 (Start New Session) to resume the conversation.
+
+### Step 5: Update Discovery State
+
+Update `{IDEAS_ROOT}/$IDEA_NAME/discovery.md` frontmatter:
+
+```yaml
+oat_idea_state: summarized
+oat_idea_last_updated: YYYY-MM-DD
+```
+
+### Step 6: Update Backlog
+
+In `{IDEAS_ROOT}/backlog.md`:
+
+1. **Remove** the idea's entry from the **Active Brainstorming** section
+2. **Add** an entry to the **Captured Ideas** section with the overview from the summary:
+
+```markdown
+- **{idea-name}** — {1-2 sentence overview from summary} _(Created: YYYY-MM-DD, Summarized: YYYY-MM-DD)_
+```
+
+### Step 7: Confirm Completion
+
+Print a confirmation:
+
+```
+Idea "{Idea Name}" has been summarized.
+
+Level:   {project | global}
+Summary: {IDEAS_ROOT}/{idea-name}/summary.md
+Backlog: {IDEAS_ROOT}/backlog.md (updated)
+
+Next steps (suggest to the user — do not auto-invoke):
+- Start a new idea: run the `oat-idea-new` skill
+- Browse ideas: check {IDEAS_ROOT}/backlog.md
+- Quick capture: run the `oat-idea-scratchpad` skill to jot down a new idea seed
+- Promote to project: run the `oat-project-new` skill, then seed its
+  discovery phase with this idea's summary as the initial request
+```
+
+**Promotion contract (v1):** To promote an idea to a full OAT project:
+
+1. Run `oat-project-new {idea-name}` to scaffold the project
+2. Run `oat-project-discover` — use the idea's `summary.md` as the initial request input
+3. The idea's discovery and summary documents remain in `{IDEAS_ROOT}/` as reference
+4. Update the ideas backlog entry to `Archived` with reason: `promoted to project`
+
+Future: a dedicated `oat-idea-promote` skill can automate steps 1-4.
+
+## Success Criteria
+
+- ✅ `summary.md` created with synthesized content
+- ✅ `discovery.md` frontmatter updated to `oat_idea_state: summarized`
+- ✅ Backlog entry moved from Active Brainstorming to Captured Ideas
+- ✅ User reviewed and accepted the summary