@sienklogic/plan-build-run 2.11.0 → 2.12.1

package/plan-build-run/skills/do/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: do
+description: "Route freeform text to the right PBR skill automatically."
+allowed-tools: Read, Skill, AskUserQuestion
+argument-hint: "<freeform description of what you want to do>"
+---
+
+**STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes ~3,000 tokens. Begin executing Step 1 immediately.**
+
+# /pbr:do -- Freeform Task Router
+
+You are running the **do** skill. Your job is to analyze freeform text from the user and route it to the most appropriate PBR skill. You are a dispatcher, not an executor -- you never do the work yourself.
+
+## Step 0 -- Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► DO                                        ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Then proceed to Step 1.
+
+## Step 1 -- Validate Input
+
+If `$ARGUMENTS` is empty, ask the user what they want to do via AskUserQuestion:
+
+```
+What would you like to do? Describe the task, bug, or idea and I'll route it to the right skill.
+```
+
+## Step 2 -- Analyze and Route
+
+### Step 2a -- Gather Context
+
+1. Read `.planning/STATE.md` to get `current_phase`, `status`, `phase_slug`.
+2. Check if `.planning/ROADMAP.md` exists (set `hasRoadmap`).
+3. Build context object: `{ activePhase: phase_slug, hasRoadmap: boolean }`.
+
+### Step 2b -- Check Config
+
+1. Read `.planning/config.json` if it exists.
+2. Check `features.natural_language_routing` (default: `true` if absent).
+3. Check `features.adaptive_ceremony` (default: `true` if absent).
+4. Check `ceremony_level` (default: `"auto"` if absent).
+
+### Step 2c -- Intent Classification
+
+**When NL routing is enabled** (`features.natural_language_routing` is true or absent):
+
+Score `$ARGUMENTS` against these route keyword groups:
+
+| Route | Keywords | Weight |
+|-------|----------|--------|
+| debug | bug, error, crash, fix, broken, failing, exception, stacktrace, debug | 1.0 |
+| explore | explore, research, investigate, how does, how do, understand, analyze, compare | 1.0 |
+| plan-phase | plan, architect, design, migrate, refactor across, redesign, system, new | 0.9 |
+| quick | add, create, update, change, rename, remove, write test, implement, feature, refactor | 0.85 |
+| note | remember, note, todo, idea, later, don't forget, remind | 1.0 |
+| validate-phase | validate, coverage gaps, test gaps, missing tests, untested, requirement coverage | 1.0 |
+| verify-work | review, check, verify, quality, looks right | 0.9 |
+
+**Scoring algorithm:**
+
+1. Count how many keywords from each route appear in the lowercased input.
+2. Calculate confidence per route: `(0.5 + 0.5 * (1 - 1/(matches+1))) * weight`.
+3. Apply context boosters:
+   - If there's a recent error in context: boost debug by +0.3.
+   - If an active phase exists: boost plan-phase by +0.1.
+   - If no roadmap exists: reduce plan-phase by -0.2.
+4. Clamp all scores to 0-1.
+
+**Routing decision:**
+
+- If top confidence >= 0.7: proceed with that route.
+- If top confidence < 0.7: present top 2-3 candidates to user via AskUserQuestion. Example:
+
+```
+Your request could match several skills:
+- /pbr:quick (confidence: 0.65) -- Self-contained task execution
+- /pbr:debug (confidence: 0.55) -- Systematic bug investigation
+Which would you prefer?
+```
+
+**When NL routing is disabled** (`features.natural_language_routing` is false):
+
+Fall back to the original static table -- apply the **first matching** rule:
+
+| If the text describes... | Route to |
+|--------------------------|----------|
+| A bug, error, crash, failure, or something broken | `/pbr:debug` |
+| Exploration, research, comparison, or "how does X work" | `/pbr:explore` |
+| A complex task: refactoring, migration, multi-file architecture, system redesign | `/pbr:plan-phase add` |
+| Validation, coverage gaps, missing tests, or untested requirements | `/pbr:validate-phase` |
+| A review or quality concern about existing work | `/pbr:verify-work` |
+| A note, idea, or "remember to..." | `/pbr:note` |
+| A specific, actionable task (add feature, fix typo, update config, write test) | `/pbr:quick` |
+
+### Step 2d -- Risk Classification
+
+**When adaptive ceremony is enabled** (`features.adaptive_ceremony` is true or absent):
+
+Analyze `$ARGUMENTS` for risk signals:
+
+| Risk Level | Signal Keywords |
+|------------|----------------|
+| HIGH | migrate, redesign, refactor across, architecture, security, database schema, breaking change, entire, across |
+| MEDIUM | implement, create, integrate, add feature, new endpoint, write test, add, endpoint, api |
+| LOW | typo, rename, config, update, fix typo, comment, readme, docs |
+
+**Scoring:** HIGH signals add +3, MEDIUM signals add +1, LOW signals add -1 each. Additional context factors: 8+ files affected (+3), 3+ files (+1), 3+ subsystems (+5), no existing tests (+1).
+
+**Risk thresholds:** score >= 4 is HIGH, score >= 1 is MEDIUM, otherwise LOW.
+
+**Ceremony override:** If `ceremony_level` is NOT `"auto"`, skip risk classification and use the override directly:
+
+| ceremony_level | Ceremony |
+|----------------|----------|
+| low | inline |
+| medium | lightweight-plan |
+| high | full-plan-build-verify |
+
+**Risk-to-ceremony mapping** (when `ceremony_level` is `"auto"`):
+
+| Risk | Ceremony | Dispatch |
+|------|----------|----------|
+| low | inline | Route to `/pbr:quick` (inline execution, no plan file) |
+| medium | lightweight-plan | Route to `/pbr:quick` (with note to create a lightweight plan) |
+| high | full-plan-build-verify | Route to `/pbr:plan-phase add` (full plan-build-verify cycle) |
+
+**When adaptive ceremony is disabled** (`features.adaptive_ceremony` is false):
+
+Use the route from Step 2c without ceremony adjustment.
+
+## Step 3 -- Confirm and Dispatch
+
+Display the routing decision:
+
+```
+**Input:** {first 80 chars of arguments}
+**Intent:** {skill} (confidence: {score})
+**Risk:** {low|medium|high} -- {top signal}
+**Ceremony:** {inline|lightweight-plan|full-plan-build-verify}
+**Routing to:** {chosen skill}
+```
+
+Then invoke the chosen skill via the Skill tool, passing `$ARGUMENTS` as the args.
+
+**Special case for `/pbr:plan-phase add`**: When routing to plan, check if `.planning/ROADMAP.md` exists first (via Read). If it doesn't, suggest `/pbr:new-project` instead -- the user needs to set up the project before they can add phases.
+
+## Step 4 -- No Follow-Up
+
+After invoking the skill, your job is done. The dispatched skill handles everything from here (execution, commits, state updates). Do not add any additional output after the Skill tool call.
+
+## Feature Toggles
+
+These config properties in `.planning/config.json` control routing behavior:
+
+- `features.natural_language_routing: false` -- disables smart intent detection, falls back to static keyword table.
+- `features.adaptive_ceremony: false` -- disables risk-based ceremony selection, uses intent route directly.
+- `ceremony_level: "high"` -- forces full ceremony on everything (overrides risk classification).
+- `ceremony_level: "low"` -- forces inline ceremony on everything.
+- `ceremony_level: "auto"` -- (default) uses risk classification to determine ceremony.

package/plan-build-run/skills/explore/SKILL.md

@@ -0,0 +1,449 @@
+---
+name: explore
+description: "Explore ideas, think through approaches, and route insights to the right artifacts."
+allowed-tools: Read, Write, Glob, Grep, Task, AskUserQuestion
+argument-hint: "[topic]"
+---
+
+**STOP — DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes ~7,600 tokens. Begin executing Step 1 immediately.**
+
+## Step 0 — Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► EXPLORING                                  ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Then proceed to Step 1.
+
+# /pbr:explore — Idea Exploration
+
+You are running the **explore** skill. Your job is to help the user think through ideas that might become a todo, requirement, phase, decision, or nothing yet. This is Socratic conversation, not requirements gathering. No phase number is needed.
+
+This skill runs **inline** (no Task delegation), with optional Task() spawns for context loading, upfront research, and mid-conversation research.
+
+**CRITICAL: Agent type rule** — When spawning ANY research or analysis Task(), ALWAYS use `subagent_type: "pbr:researcher"`. NEVER use `general-purpose`, `Explore`, or other non-PBR agent types. The PreToolUse hook will block non-PBR agents.
+
+---
+
+## References
+
+- `references/questioning.md` — Questioning philosophy, progressive depth layers, Socratic patterns, anti-patterns (checklist walking, corporate speak)
+- `references/ui-brand.md` — Status symbols, banners, checkpoint boxes, progress display
+
+---
+
+## Context Budget
+
+Reference: `skills/shared/context-budget.md` for the universal orchestrator rules.
+Reference: `skills/shared/agent-type-resolution.md` for agent type fallback when spawning Task() subagents.
+
+Additionally for this skill:
+- **Minimize** file reads — this is a thinking skill, not a code analysis skill
+- **Delegate** deep research to a researcher subagent if investigation exceeds the read threshold:
+  - At context_window_tokens < 500000 (200k model): delegate after 3-4 file reads
+  - At context_window_tokens >= 500000 (1M model): delegate after 12 file reads
+  Check `context_window_tokens` in `.planning/config.json` to determine which limit applies.
+
+---
+
+## How /pbr:explore Differs from /pbr:discuss-phase
+
+| | /pbr:discuss-phase | /pbr:explore |
+|---|---|---|
+| Purpose | Make decisions for a phase | Discover what you actually want |
+| Structure | Pre-computed gray areas with options | Open-ended Socratic conversation |
+| Requires | Phase number | Nothing |
+| Output | CONTEXT.md (locked decisions) | Routes to the right artifact |
+| Feels like | Making decisions | Thinking with a partner |
+
+---
+
+## Invocation
+
+- `/pbr:explore` — Open-ended: "I have an idea"
+- `/pbr:explore auth` — Topic-specific exploration
+- `/pbr:explore "should we add caching?"` — Specific question
+
+Parse `$ARGUMENTS` for an optional topic. If provided, use it to seed the opening question. If empty, start fully open-ended.
+
+---
+
+## Pre-Conversation Context Loader
+
+Reference: `skills/shared/context-loader-task.md` for the full briefing Task() pattern.
+
+**Only runs if `.planning/` directory exists.** Fresh explores with no project skip this entirely.
+
+When a project exists, spawn a briefing Task() per the context-loader-task pattern with `skill_purpose` = "exploring new ideas". If a topic was provided, use the topic-scoped variation with that topic.
+
+Use the briefing to inform your conversation — reference existing decisions, avoid re-litigating settled questions, and connect new ideas to the existing project structure.
+
+---
+
+## Conversation Design
+
+The conversation is Socratic, not extractive. You are a thinking partner, not an interviewer.
+
+### Principles
+
+1. **Open with curiosity.** Start with "What are you thinking about?" or "What's on your mind?" — not "Please describe the feature you want."
+
+2. **Follow their energy.** Dig into what excites or concerns them. If they light up about a technical approach, explore it. If they hesitate, probe why.
+
+3. **Surface implications.** "If you go with X, that usually means Y and Z. Is that intentional?" Connect their idea to downstream consequences they may not see yet.
+
+4. **Challenge with alternatives.** "You mentioned X, but have you considered Y?" Don't be adversarial — offer genuine alternatives that might fit better.
+
+5. **Present trade-offs, not options.** "A gives you speed but locks you into a vendor. B is slower but keeps options open." Frame choices as trade-offs with real consequences, not a menu.
+
+6. **Know when to research.** "I'm not sure about the best approach here. Want me to research it?" Don't fake knowledge — admit gaps and offer to investigate.
+
+7. **Don't rush to outputs.** Explore until understanding is genuinely deep. The user will know when they're ready to wrap up.
+
+### Domain-Aware Probing
+
+Reference `skills/shared/domain-probes.md` for technology-specific follow-up questions. When the user mentions a domain (auth, caching, search, etc.), pick the 2-3 most relevant probes from that domain's table. Do NOT run through the table as a checklist.
+
+### Conversation Starters by Invocation
+
+| Invocation | Opening |
+|---|---|
+| `/pbr:explore` | "What are you thinking about?" |
+| `/pbr:explore auth` | "What's your thinking on auth? Are you starting from scratch or rethinking something?" |
+| `/pbr:explore "should we add caching?"` | "Caching for what specifically? What's feeling slow or what do you expect to be slow?" |
+
+---
+
+## Upfront Research Delegation
+
+When the user's initial request is research-heavy (e.g., "explore best practices for X", "research how other projects do Y", "compare approaches to Z"), delegate immediately to `pbr:researcher` agents rather than doing inline research.
+
+**Detection**: If `$ARGUMENTS` contains words like "research", "compare", "explore examples", "best practices", "how do others", or describes gathering external information — this is an upfront research task.
+
+**Pattern**: Spawn one or more `pbr:researcher` agents in parallel, then synthesize their findings inline:
+
+```
+Task({
+  subagent_type: "pbr:researcher",
+  prompt: "<research_assignment>
+    Topic: {specific research question from user's request}
+    Output: Return findings as structured markdown in your response.
+    Mode: external-research
+
+    {detailed research instructions}
+  </research_assignment>"
+})
+```
+
+After researchers complete, synthesize findings inline and continue the Socratic conversation with the user about what was discovered.
+
+---
+
+## Mid-Conversation Research
+
+When a knowledge gap emerges during the conversation — you're unsure about a library, pattern, or approach — surface it explicitly.
+
+**Ask the user** using the **yes-no** pattern from `skills/shared/gate-prompts.md`:
+  question: "I'm not sure about the best approach for {topic}. Research it now?"
+  options:
+    - label: "Research now"   description: "Spawn a researcher agent to investigate"
+    - label: "Save for later" description: "Add as a research question for future investigation"
+
+**If research now:**
+
+Display to the user: `◆ Spawning researcher...`
+
+**Learnings injection (opt-in):** Check for relevant tech stack learnings:
+
+```bash
+node {resolved_plugin_root}/scripts/pbr-tools.cjs learnings query --tags "stack,tech" 2>/dev/null
+```
+
+If non-empty JSON array returned:
+
+- Write to temp file: `node {resolved_plugin_root}/scripts/pbr-tools.cjs learnings query --tags "stack,tech" > /tmp/pbr-learnings-$$.md`
+- Note path as `{learnings_temp_path}`; add as item 3 in the researcher's `files_to_read` block below
+
+If no learnings or command fails: omit the extra files_to_read entry.
+
+```
+Task({
+  subagent_type: "pbr:researcher",
+  prompt: "<files_to_read>
+    CRITICAL: Read these files BEFORE any other action:
+    1. .planning/CONTEXT.md — locked decisions and constraints (if exists)
+    2. .planning/STATE.md — current project state (if exists)
+    {if learnings_temp_path exists}3. {learnings_temp_path} — cross-project learnings (tech stack patterns from past PBR projects){/if}
+  </files_to_read>
+  <research_assignment>
+    Topic: {specific research question}
+    Output file: .planning/research/{topic-slug}.md
+    Mode: project-research
+
+    Research this specific question: {the question}
+
+    Write findings to the output file.
+  </research_assignment>"
+})
+```
+
+If `{learnings_temp_path}` was produced above, replace `{if...}{/if}` with the actual line. If no learnings were found, omit item 3 entirely.
+
+After the researcher completes, check for completion markers in the Task() output:
+
+- If `## RESEARCH COMPLETE` is present: proceed normally
+- If `## RESEARCH BLOCKED` is present: display the blocker reason and offer to retry:
+  `⚠ Research blocked: {reason}. Try a different angle or continue without research.`
+
+Display: `✓ Research complete — results in .planning/research/{topic-slug}.md`
+
+Then:
+- Read ONLY the frontmatter and summary section of the research file (not the full document)
+- Incorporate the 2-3 key findings into the conversation
+- Main context gets ~200 tokens of research insight, not the full document
+
+**If save for later:**
+- Note it as a research question to include in output routing
+
+---
+
+## Context Pressure Awareness
+
+After approximately 10 exchanges or when the conversation has been substantial, mention:
+
+"We've been exploring for a while. Want to wrap up with outputs, or keep going?"
+
+Don't force a conclusion — some explorations legitimately need extended conversation. But surface the option so the user can choose.
+
+---
+
+## Output Routing
+
+This is the key innovation of `/pbr:explore`. At conversation end, the agent summarizes key insights and routes them to the right artifacts.
+
+### Step 1: Summarize
+
+Provide a concise summary of the key insights from the conversation:
+- What was the core idea or question?
+- What did we discover or decide?
+- What remains uncertain?
+
+### Step 2: Propose Outputs
+
+Suggest specific outputs with reasoning. Present no more than 4 suggestions — focus on what matters most.
+
+| Output Type | When to Suggest | Where It Goes |
+|---|---|---|
+| Todo | Small, actionable item discovered | `.planning/todos/pending/{id}.md` |
+| Requirement | New project feature identified | Append to `REQUIREMENTS.md` with REQ-ID |
+| Phase decision | Clarifies an existing phase | Write/append to phase `CONTEXT.md` |
+| Research question | Needs deeper investigation | `.planning/research/questions.md` |
+| New phase | Big enough for its own phase | Append to `ROADMAP.md` |
+| Note | Not actionable yet, worth remembering | `.planning/notes/{YYYY-MM-DD}-{slug}.md` |
+| Quick capture | One-liner idea, no context needed | Suggest `/pbr:note <text>` to the user |
+| Seed | Idea with trigger conditions | `.planning/seeds/SEED-{NNN}-{slug}.md` |
+
+**Format for proposals:**
+
+```
+Based on our conversation, here's what I'd suggest capturing:
+
+1. **Todo**: "{title}" — {why this is a todo and not something bigger}
+2. **Seed**: "{title}" — {why this should wait for a trigger condition}
+3. **Research question**: "{question}" — {why we need to investigate this}
+
+Want to adjust, add, or remove any of these?
+```
+
+### Step 3: Confirm
+
+Use the **output-routing** pattern from `skills/shared/gate-prompts.md`:
+  question: "How do you want to handle these proposed outputs?"
+
+Handle responses:
+- "Approve all": Create all suggested artifacts (proceed to Step 4)
+- "Adjust": The user wants to modify proposals. Have a freeform conversation to adjust, then re-present with another AskUserQuestion.
+- "Add more": The user has additional outputs. Gather them conversationally, add to the list, then re-present.
+- "Skip": End the session without creating artifacts. This is fine — sometimes exploring is enough.
+
+Do NOT create any artifacts until the user selects "Approve all" on the final set.
+
+### Step 4: Create Artifacts
+
+**CRITICAL (no hook) -- DO NOT SKIP: Create target directories and write artifact files.**
+
+**Directory creation:** Before writing any artifact, ensure the target directory exists. Create `.planning/notes/`, `.planning/seeds/`, `.planning/research/`, or `.planning/todos/pending/` as needed if they don't already exist.
+
+Create only the approved artifacts. A single explore session can produce multiple outputs across different types.
+
+### Step 5: Completion
+
+After creating artifacts (or if user chose "Skip"), display:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► EXPLORATION CAPTURED ✓                     ║
+╚══════════════════════════════════════════════════════════════╝
+
+{count} artifacts created: {list of artifact types}
+
+
+
+╔══════════════════════════════════════════════════════════════╗
+║  ▶ NEXT UP                                                   ║
+╚══════════════════════════════════════════════════════════════╝
+
+**{Primary route based on what was created}**
+
+{Smart routing — pick the most relevant primary command:}
+- If a todo was created: **Manage tasks** → `/pbr:todo`
+- If a phase decision was captured: **Plan the phase** → `/pbr:plan-phase {N}`
+- If a new phase was added: **Discuss the new phase** → `/pbr:discuss-phase {N}`
+- If research questions were logged: **Plan with research** → `/pbr:plan-phase {N}`
+- If current milestone is complete (STATE.md status is "milestone-complete"): **Start next milestone** → `/pbr:new-milestone`
+- Default: **See project status** → `/pbr:progress`
+
+`{primary command}`
+
+<sub>`/clear` first → fresh context window</sub>
+
+
+
+**Also available:**
+- `/pbr:progress` — see project status
+- `/pbr:continue` — execute next logical step
+- `/pbr:new-milestone` — start a new milestone with new phases
+
+
+```
+
+---
+
+## Output Formats
+
+### Todo
+
+Write to `.planning/todos/pending/{NNN}-{slug}.md` where NNN is a zero-padded 3-digit sequential number (001, 002, 003...). Scan both `.planning/todos/pending/` and `.planning/todos/done/` for the highest existing number, increment by 1, and zero-pad. Follow the format used by the existing todo skill.
+
+### Requirement
+
+Append to `.planning/REQUIREMENTS.md` with the next available REQ-ID in the appropriate category. If the category doesn't exist, create it.
+
+### Phase Decision
+
+Append to `.planning/phases/{NN}-{slug}/CONTEXT.md`. If CONTEXT.md doesn't exist for that phase, create it with the standard header. Mark the decision as coming from `/pbr:explore`.
+
+### Research Question
+
+Append to `.planning/research/questions.md`. Create the file if it doesn't exist:
+
+```markdown
+# Research Questions
+
+Questions identified during exploration that need deeper investigation.
+
+## Open
+
+- [ ] {Question} — Source: /pbr:explore session ({date})
+
+## Answered
+
+(none yet)
+```
+
+### New Phase
+
+Append to `.planning/ROADMAP.md` following the existing phase format. Assign the next available phase number.
+
+### Note
+
+Write to `.planning/notes/{YYYY-MM-DD}-{slug}.md` where the date prefix is today's date in ISO format. Scan `.planning/notes/` to avoid filename collisions — if a file with the same date and slug exists, append `-2` (or increment).
+
+```markdown
+---
+created: {ISO date}
+source: "/pbr:explore session"
+topic: "{topic}"
+---
+# {Title}
+
+{Content from the conversation — key insights, reasoning, context}
+```
+
+### Seed
+
+Write to `.planning/seeds/SEED-{NNN}-{slug}.md` where NNN is a zero-padded 3-digit sequential number (001, 002, 003...). Scan `.planning/seeds/` for the highest existing SEED number, increment by 1, and zero-pad.
+
+```markdown
+---
+id: SEED-{NNN}
+status: dormant
+planted: {ISO date}
+trigger: "{phase-slug}"
+scope_estimate: "small|medium|large"
+source: "/pbr:explore session"
+---
+# {Title}
+
+## Context
+{Why this idea came up}
+
+## Breadcrumbs
+{Related phases, technologies, user preferences}
+```
+
+---
+
+## Git Integration
+
+Reference: `skills/shared/commit-planning-docs.md` for the standard commit pattern.
+
+If `planning.commit_docs: true` in config.json, commit created artifacts:
+
+```
+docs(planning): capture explore session outputs
+```
+
+Stage only the files created during this session. Do not stage unrelated changes.
+
+---
+
+## Error Handling
+
+Reference: `skills/shared/error-reporting.md` for branded error output patterns.
+
+### Researcher agent fails
+If a mid-conversation researcher Task() fails, display:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+Research agent failed for topic: {topic}.
+
+**To fix:** Continue the conversation without research, or try `/pbr:explore` again with a more specific topic.
+```
+
+### Context loader fails
+If the briefing Task() fails:
+- Display: `⚠ Context loading failed. Proceeding without project context.`
+- Continue with the exploration — the conversation can still be valuable without project context.
+
+---
+
+## Anti-Patterns
+
+Additionally for this skill:
+
+1. **DO NOT** act like an interviewer — be a thinking partner
+2. **DO NOT** cycle through a checklist of questions
+3. **DO NOT** rush to outputs before understanding is deep
+4. **DO NOT** auto-research without asking (unless config mode is autonomous)
+5. **DO NOT** present more than 4 output suggestions — focus on what matters
+6. **DO NOT** create artifacts the user didn't approve
+7. **DO NOT** re-litigate decisions that are already locked in CONTEXT.md
+8. **DO NOT** force the user to produce outputs — sometimes exploring is enough