/default-mode

Default Mode Reference

This is the full creative cycle planning flow. Fires when the user picks "Add stories now" at Step 1b. Brainstorms stories, captures sparks (with optional creative-spark per story), reviews the cycle, and offers planning paths.

The orchestrator command (`commands/craft-cycle-design.md`) defines the routing - this reference contains the full mode flow.

---

Step 2: Story Brainstorm

> "Let's map out the stories for this cycle. > > What needs to happen to achieve: **[goal]**?"

Help the user decompose the cycle into stories through conversation:

• What are the pieces?
• What's the user journey?
• What are the dependencies?

**Note:** Don't automatically invoke `creative-spark` here. The user usually knows what stories they need — they're decomposing a known feature. Creative exploration happens per-story in Step 3.

**Only invoke `creative-spark`** if the user is genuinely unsure what stories the cycle needs (e.g., "I don't know where to start" or "What would you suggest?").

Present initial story list with inferred type tags (`ui`, `technical`, or `content`). Infer the type from conversational context — if the story involves visual design, layout, or animation it's `ui`; if it's API routes, data, or infrastructure it's `technical`; if it's copy, tone, or onboarding flow it's `content`.

**Scope check (before presenting):** Before showing the story list, evaluate whether the story count matches the scope complexity. Count the concrete deliverables in the cycle goal and discussion — interactive features, distinct pages/views, API endpoints, data models, content surfaces. Apply these heuristics:

• If deliverables-per-story ratio exceeds ~3, the stories are probably too coarse
• If any single story covers more than one distinct concern (e.g., "build layout AND wire interactions AND add animations"), it should likely split
• If the project has existing completed cycles, compare story count against similar-scope cycles in `.craft/cycles/`

If the scope looks thin, include a **Scope check** note inline with the story list. If the count looks reasonable, present the list without commentary.

**When the check fires:**

> "Based on our discussion, I'm thinking these stories: > > 1. **[Story idea 1]** `ui` — [one line] > 2. **[Story idea 2]** `ui` — [one line] > 3. **[Story idea 3]** `ui` — [one line] > > **Scope check:** This cycle covers [N deliverables] but only has [M] stories. [Specific concern — e.g., "Story 2 alone covers 5 interactive commands with distinct animations - that could be 8+ chunks. Consider splitting into separate stories per command group."] You can proceed as-is or adjust. > > Does this capture the scope? (Check the type tags — correct any that are wrong.)"

**When the check doesn't fire:**

> "Based on our discussion, I'm thinking these stories: > > 1. **[Story idea 1]** `ui` — [one line] > 2. **[Story idea 2]** `technical` — [one line] > 3. **[Story idea 3]** `ui` — [one line] > > Does this capture the scope? (Check the type tags — correct any that are wrong.)"

Use **AskUserQuestion**:

question: "Does this capture the scope?"
header: "Stories"
options:
  - label: "Save these sparks"
    description: "The descriptions above are the sparks — write all story files now"
  - label: "Flesh out individually"
    description: "Go through each story to explore or refine the spark"
  - label: "Add another story"
    description: "I have more stories to include"
  - label: "Remove/combine some"
    description: "Some of these should be merged or dropped"

**If user selects "Other" or provides custom text:** Ask a clarifying AskUserQuestion before proceeding. Don't assume intent — confirm what they want to change.

**Important:** Don't proceed until user confirms the story list is complete.

**If "Save these sparks":** Jump to **Step 3-Fast** below.

**If "Flesh out individually":** Continue to Step 3 (per-story flow).

Step 2.7: Planning-Source Routing (Per Story, Before Step 3 or Step 3-Fast)

**Before doing per-story work in Step 3 or Step 3-Fast**, read `cycle.yaml` to check whether this cycle has `source_concept` set.

ACTIVE_CYCLE=$(grep "^ACTIVE_CYCLE=" "${CRAFT_PROJECT_ROOT}/.craft/.global-state" | cut -d= -f2)
CYCLE_SOURCE_CONCEPT=$(grep "^source_concept:" "${CRAFT_PROJECT_ROOT}/.craft/cycles/${ACTIVE_CYCLE}/cycle.yaml" | sed 's/^source_concept: //')

If `source_concept` is `[]` or empty: this cycle is freeform. Skip the rest of this step and proceed to Step 3 / Step 3-Fast as usual.

If `source_concept` is populated (e.g., `[planning/04-company-onboarding.md]`): the cycle is planning-sourced. For each story being created, apply the **action-moment framing**:

• **Planning-extraction moment** ("I'm producing this story from the planning concept's content"):

Instead of running default-mode's normal Step 3 spark-capture flow for this story, **Read `story-from-planning.md` (one directory up from this file, in `commands/references/`) and execute its phases** against the cycle's source_concept. The protocol already:

• Reads the planning concept file
• Extracts content per the 9-section taxonomy
• Asks gap-fill AskUserQuestions where planning is silent
• Writes the story with `source_concept` AND `source_concept_last_updated` frontmatter
• Forward-links the story back to the planning doc

**CRITICAL: include the invocation marker** when executing the protocol. State explicitly in your context before running Phase 1:

> `INVOCATION: cycle-design - planning source already confirmed in cycle.yaml`

This marker is required for Phase 1's auto-resolve to fire. Without it, Phase 1 falls back to corpus-scan and asks the user to pick a concept (defeating the purpose of capturing the source at cycle creation).

⛔ **DO NOT invoke story-from-planning.md via the Skill tool** - Read it via the Read tool and execute its phases inline.

• **Add-a-separate-story moment** ("user asked for an additional story not from the pla