wtf-p 0.3.0 → 0.5.0

package/vendors/claude/commands/wtfp/create-outline.md

@@ -1,21 +1,16 @@
 ---
 name: wtfp:create-outline
-description: Create document outline, section roadmap, and state tracking
+description: Build section outline, argument map, and word budgets
 allowed-tools:
   - Read
   - Bash
   - Write
+  - Glob
+  - Grep
+  - Task
   - AskUserQuestion
 ---
 
-<objective>
-Create the document outline and section roadmap for an initialized paper.
-
-Creates ROADMAP.md (section breakdown), STATE.md (writing memory), and section directories.
-
-This establishes the structure before section-by-section planning begins.
-</objective>
-
 <execution_context>
 @~/.claude/write-the-f-paper/workflows/create-outline.md
 @~/.claude/write-the-f-paper/templates/roadmap.md
@@ -23,221 +18,148 @@ This establishes the structure before section-by-section planning begins.
 @~/.claude/write-the-f-paper/references/imrad-structure.md
 </execution_context>
 
+<objective>
+Create the document outline and section roadmap for an initialized paper.
+
+**Orchestrator role:** Validate environment, load project context, resolve model profile, spawn outliner agent to produce structure artifacts, create STATE.md, create section directories, commit, present results.
+
+**Why subagent:** Outlining requires significant reasoning about document structure, argument decomposition, and wave assignment. A fresh outliner agent gets peak quality for these creative decisions.
+</objective>
+
+<context>
+No arguments. Requires `.planning/PROJECT.md` to exist.
+</context>
+
 <process>
 
-<step name="verify">
-**Verify project exists:**
+## 1. Validate Environment and Resolve Model Profile
 
 ```bash
-[ ! -f .planning/PROJECT.md ] && echo "ERROR: No project found. Run /wtfp:new-paper first" && exit 1
-[ -f .planning/ROADMAP.md ] && echo "ERROR: Outline already exists. Use /wtfp:progress" && exit 1
+[ ! -f .planning/PROJECT.md ] && echo "ERROR: No project. Run /wtfp:new-paper" && exit 1
+[ -f .planning/ROADMAP.md ] && echo "ERROR: Outline exists. Use /wtfp:progress" && exit 1
+ls .planning/ 2>/dev/null
 ```
 
-</step>
-
-<step name="load">
-**Load project context:**
-
-- Read `.planning/PROJECT.md` for paper vision, core argument, requirements
-- Read `.planning/config.json` for document type and workflow mode
-- Read `.planning/structure/outline.md` for initial structure sketch
-- Read `.planning/structure/argument-map.md` for logical structure
-</step>
-
-<step name="structure">
-**Determine document structure:**
-
-Based on document type from config.json:
-
-**Research Paper (IMRaD):**
-- Abstract
-- Introduction
-- Methods (or Materials and Methods)
-- Results
-- Discussion
-- Conclusion (sometimes combined with Discussion)
-- References
-
-**Grant Proposal (NSF-style):**
-- Specific Aims
-- Background and Significance
-- Preliminary Data
-- Research Design and Methods
-- Timeline
-- Budget Justification
-
-**Grant Proposal (NIH-style):**
-- Specific Aims
-- Significance
-- Innovation
-- Approach
-- Timeline and Milestones
-
-**Thesis Chapter:**
-- Introduction
-- Literature Review
-- Methodology
-- Results/Findings
-- Discussion
-- Conclusion
-
-Use AskUserQuestion if structure needs customization:
-- header: "Structure"
-- question: "The standard structure for [type] is [list]. Any modifications?"
-- options:
-  - "Use standard structure" — Apply typical [type] structure
-  - "Customize sections" — I have specific sections in mind
-  - "Show me options" — What alternatives exist?
-
-</step>
-
-<step name="roadmap">
-**Create ROADMAP.md:**
-
-```markdown
-# Document Roadmap
-
-## Document: [Paper Title]
-## Type: [Paper Type]
-## Target: [Venue if known]
-
-## Sections
-
-### 1. [Section Name]
-- **Goal:** [What this section accomplishes]
-- **Word Target:** [X words]
-- **Status:** Not started
-- **Dependencies:** [Any prerequisites]
-
-### 2. [Section Name]
-- **Goal:** [What this section accomplishes]
-- **Word Target:** [X words]
-- **Status:** Not started
-- **Dependencies:** [Section 1 must establish X]
-
-[... continue for all sections ...]
-
-## Progress
-
-| # | Section | Goal | Words | Status |
-|---|---------|------|-------|--------|
-| 1 | [Name] | [1-liner] | 0/[target] | - |
-| 2 | [Name] | [1-liner] | 0/[target] | - |
-| ... | | | | |
-
-## Word Budget
-
-| Section | Target | Current | % |
-|---------|--------|---------|---|
-| [Name] | [X] | 0 | 0% |
-| ... | | | |
-| **Total** | **[X]** | **0** | **0%** |
+**Resolve model profile:**
 
----
-*Last updated: [date] after outline creation*
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
 ```
 
-</step>
+**Model lookup table:**
 
-<step name="state">
-**Create STATE.md:**
+| Agent | quality | balanced | budget |
+|-------|---------|----------|--------|
+| outliner | opus | sonnet | sonnet |
 
-```markdown
-# Writing State
+**Resolve gate flag:**
+```bash
+GATE_CONFIRM_OUTLINE=$(cat .planning/config.json 2>/dev/null | grep -o '"confirm_outline"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+```
 
-## Project Reference
-- Project: .planning/PROJECT.md
-- Roadmap: .planning/ROADMAP.md
-- Config: .planning/config.json
+## 2. Read Context Files
 
-## Current Position
-- Section: 1 of [total]
-- Plan: 0 (not yet planned)
-- Status: Ready to plan first section
+```bash
+PROJECT_CONTENT=$(cat .planning/PROJECT.md)
+CONFIG_CONTENT=$(cat .planning/config.json 2>/dev/null)
+EXISTING_STRUCTURE=$(cat .planning/structure/*.md 2>/dev/null)
+```
 
-## Progress
-- Sections: 0/[total] complete
-- Words: 0/[target] ([0]%)
-- Plans executed: 0
+## 3. Ensure Structure Directory
 
-## Argument Strength
-- Core claim: [from PROJECT.md]
-- Supporting claims: [from argument-map.md]
-- Evidence status: Not yet written
+```bash
+mkdir -p .planning/structure
+mkdir -p .planning/sections
+```
 
-## Key Decisions
-| Decision | Rationale | Section |
-|----------|-----------|---------|
+## 4. Gate Check: Confirm Before Outlining
 
-## Open Questions
-- [Questions from PROJECT.md that need resolution]
+**If GATE_CONFIRM_OUTLINE is "true" (default):**
+Present project summary to user via AskUserQuestion and wait for confirmation before proceeding.
 
-## Deferred
-- [Nothing yet]
+**If GATE_CONFIRM_OUTLINE is "false":**
+Skip confirmation and proceed directly to outlining.
 
-## Session Continuity
-- Last session: [date]
-- Handoff: None
+## 5. Spawn wtfp-outliner Agent
 
----
-*Living document — updated after each writing session*
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► OUTLINING DOCUMENT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-</step>
-
-<step name="directories">
-**Create section directories:**
+Fill prompt with inlined content and spawn:
 
-```bash
-mkdir -p .planning/sections
+```
+Task(
+  prompt="First, read ~/.claude/agents/wtfp/outliner.md for your role and instructions.\n\n" + filled_outlining_prompt,
+  subagent_type="general-purpose",
+  model="{outliner_model}",
+  description="Create Document Outline"
+)
 ```
 
-For each section in ROADMAP.md, create directory:
+Outlining prompt includes: `<project_context>` with PROJECT.md content, config.json settings, any existing structure files.
 
-```bash
-mkdir -p .planning/sections/01-[section-name-slug]
-mkdir -p .planning/sections/02-[section-name-slug]
-# ... for all sections
-```
+## 6. Handle Outliner Return
 
-Use lowercase, hyphenated names (e.g., `01-introduction`, `02-methods`, `03-results`).
+**`## OUTLINING COMPLETE`:** Proceed to STATE.md creation and directory setup.
 
-</step>
+**`## CHECKPOINT REACHED`:** Present to user, get response, re-spawn outliner with decision.
 
-<step name="commit">
-**Commit outline:**
+**`## OUTLINING BLOCKED`:** Show blocker, offer options.
 
-```bash
-git add .planning/ROADMAP.md .planning/STATE.md .planning/sections/
-git commit -m "$(cat <<'EOF'
-docs: create document outline
+## 7. Post-Outliner Setup
+
+After successful outlining, the orchestrator handles:
 
-[N] sections, [X] word target
+**Create STATE.md** using template from `~/.claude/write-the-f-paper/templates/state.md`:
+- Initialize position (section 1 of N), word count (0)
+- Set argument strength from outliner's argument-map
+- Set open questions from PROJECT.md
 
-Sections: [list section names]
-EOF
-)"
+**Create section directories** from ROADMAP.md sections:
+```bash
+mkdir -p .planning/sections/01-[section-slug]
+mkdir -p .planning/sections/02-[section-slug]
+# ... for all sections listed in ROADMAP.md
 ```
 
-</step>
+## 8. Commit (with commit_docs Guard)
 
-<step name="done">
-**Present completion:**
+```bash
+COMMIT_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+```
 
+**If commit_docs = "true" (default):**
+```bash
+git add .planning/ROADMAP.md .planning/STATE.md .planning/sections/ .planning/structure/
+git commit -m "docs: create document outline -- [N] sections, [X] words target"
 ```
-Outline created:
 
-- Roadmap: .planning/ROADMAP.md ([N] sections, [X] words target)
+**If commit_docs = "false":**
+Skip git add and commit for planning docs. Log: "Skipping planning docs commit (commit_docs: false)"
+
+## 9. Present Final Status
+
+</process>
+
+<offer_next>
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► OUTLINE CREATED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Roadmap: .planning/ROADMAP.md ([N] sections, [X] words)
 - State: .planning/STATE.md
+- Structure: .planning/structure/ (outline, argument-map, narrative-arc)
 - Sections: .planning/sections/ ([N] directories)
 
-## Section Structure
-
-| # | Section | Words |
-|---|---------|-------|
+| # | Section | Words | Wave |
+|---|---------|-------|------|
 [table from ROADMAP.md]
 
----
+───────────────────────────────────────────
 
 ## ▶ Next Up
 
@@ -247,29 +169,21 @@ Outline created:
 
 <sub>`/clear` first → fresh context window</sub>
 
----
+───────────────────────────────────────────
 
 **Also available:**
 - `/wtfp:discuss-section 1` — gather context first
 - `/wtfp:research-gap 1` — investigate literature needs
+- `/wtfp:execute-outline` — write all sections in wave-based parallel execution
 
----
-```
-
-</step>
-
-</process>
-
-<output>
-- `.planning/ROADMAP.md`
-- `.planning/STATE.md`
-- `.planning/sections/XX-name/` directories
-</output>
+</offer_next>
 
 <success_criteria>
-- [ ] ROADMAP.md has all sections with goals and word targets
+- [ ] Outliner agent spawned with full project context
+- [ ] 4 artifacts created (outline.md, argument-map.md, narrative-arc.md, ROADMAP.md)
 - [ ] STATE.md initialized with correct position
 - [ ] Section directories created
 - [ ] Word budget totals match target
 - [ ] All committed to git
+- [ ] User knows next steps
 </success_criteria>

package/vendors/claude/commands/wtfp/create-poster.md

@@ -1,6 +1,6 @@
 ---
 name: wtfp:create-poster
-description: Full workflow for creating an academic poster from project content
+description: Generate academic poster from paper content
 allowed-tools:
   - Read
   - Write

package/vendors/claude/commands/wtfp/create-slides.md

@@ -1,6 +1,6 @@
 ---
 name: wtfp:create-slides
-description: Full workflow for creating presentation slides from project content
+description: Generate presentation slides from paper content
 allowed-tools:
   - Read
   - Write

package/vendors/claude/commands/wtfp/discuss-section.md

@@ -1,6 +1,6 @@
 ---
 name: wtfp:discuss-section
-description: Gather section context through adaptive questioning before planning
+description: Discuss your vision for a section before planning it
 argument-hint: "[section-number]"
 allowed-tools:
   - Read

package/vendors/claude/commands/wtfp/execute-outline.md

@@ -0,0 +1,257 @@
+---
+name: wtfp:execute-outline
+description: Write all sections in parallel, then check coherence
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+
+<execution_context>
+@~/.claude/write-the-f-paper/workflows/execute-outline.md
+@~/.claude/write-the-f-paper/references/checkpoints.md
+@~/.claude/write-the-f-paper/references/ui-brand.md
+</execution_context>
+
+<objective>
+Execute all sections of a paper in wave-based parallel execution, then verify cross-section coherence.
+
+**Orchestrator role:** Load roadmap and all plans, group sections by wave, spawn parallel write-section Task() calls per wave, collect results, handle checkpoints between waves, spawn coherence-checker after final wave, present results.
+
+**Why wave execution:** Sections within the same wave have no dependencies and can be written in parallel. Sections in later waves depend on earlier waves completing. This maximizes throughput while respecting logical ordering.
+</objective>
+
+<context>
+No arguments. Requires `.planning/ROADMAP.md` and PLAN.md files to exist.
+</context>
+
+<process>
+
+## 1. Validate Environment and Resolve Model Profile
+
+```bash
+[ ! -f .planning/ROADMAP.md ] && echo "ERROR: No outline. Run /wtfp:create-outline" && exit 1
+ls .planning/sections/*/  2>/dev/null
+ls .planning/sections/*/*-PLAN.md 2>/dev/null
+```
+
+**Resolve model profile:**
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+**Model lookup table:**
+
+| Agent | quality | balanced | budget |
+|-------|---------|----------|--------|
+| section-writer | opus | sonnet | sonnet |
+| coherence-checker | sonnet | sonnet | haiku |
+
+**Resolve config flags:**
+```bash
+WORKFLOW_VERIFIER=$(cat .planning/config.json 2>/dev/null | grep -o '"verifier"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+```
+
+## 2. Read Context Files
+
+```bash
+ROADMAP_CONTENT=$(cat .planning/ROADMAP.md)
+STATE_CONTENT=$(cat .planning/STATE.md)
+PROJECT_CONTENT=$(cat .planning/PROJECT.md)
+ARGMAP_CONTENT=$(cat .planning/structure/argument-map.md 2>/dev/null)
+OUTLINE_CONTENT=$(cat .planning/structure/outline.md 2>/dev/null)
+NARRATIVE_CONTENT=$(cat .planning/structure/narrative-arc.md 2>/dev/null)
+```
+
+## 3. Build Wave Execution Plan
+
+Parse ROADMAP.md and all PLAN.md files to build wave groups:
+
+```bash
+# Find all plans and their wave assignments
+for plan in .planning/sections/*/*-PLAN.md; do
+  section=$(basename $(dirname "$plan"))
+  wave=$(grep -o 'wave:.*' "$plan" | head -1)
+  echo "$wave $section $plan"
+done | sort
+```
+
+Group sections by wave number:
+- Wave 1: [sections with wave: 1] (independent, no dependencies)
+- Wave 2: [sections with wave: 2] (depend on wave 1)
+- ...
+- Wave N: [final sections] (depend on all previous)
+
+Present execution plan:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► EXECUTING OUTLINE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Execution plan:
+  Wave 1: [sections] (parallel)
+  Wave 2: [sections] (after wave 1)
+  Wave 3: [sections] (after wave 2)
+  ...
+
+Total: [N] sections, [W] words target
+```
+
+## 4. Wave Execution Loop
+
+For each wave (1 to max_wave):
+
+**4a. Display wave banner:**
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► WRITING WAVE {N}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**4b. Spawn parallel writers:**
+
+For each section in the current wave, for each PLAN.md in that section:
+
+```
+Task(
+  prompt="First, read ~/.claude/agents/wtfp/section-writer.md for your role and instructions.\n\n" + filled_writing_prompt,
+  subagent_type="general-purpose",
+  model="{writer_model}",
+  description="Write Section {X}: {Name}"
+)
+```
+
+Sections within the same wave are spawned in parallel (multiple Task() calls).
+
+**4c. Collect all returns:**
+
+For each completed writer, check return:
+- `## WRITING COMPLETE` -- Record success, update STATE.md
+- `## CHECKPOINT REACHED` -- Queue for user presentation
+- `## WRITING BLOCKED` -- Queue for user presentation
+
+**4d. Handle checkpoints between waves:**
+
+If any CHECKPOINT returns from this wave:
+- Present each checkpoint to user sequentially
+- Get user response for each
+- If checkpoint was blocking and user provides direction, note for re-execution
+
+If any BLOCKED returns:
+- Present blocker to user
+- Options: retry section, skip section (continue to next wave without it), abort execution
+
+**4e. Update progress:**
+
+```bash
+# Update STATE.md with wave completion
+# Update ROADMAP.md section statuses
+```
+
+**4f. Continue to next wave** (only if all sections in current wave are COMPLETE or user chose to skip blocked ones).
+
+## 5. Post-Execution Summary
+
+After all waves complete:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► ALL WAVES COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Sections written: [N]/[total]
+Words written: [W]
+Skipped: [list if any]
+```
+
+## 6. Spawn wtfp-coherence-checker
+
+After the final wave, spawn coherence-checker with explicit inline context:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► VERIFYING COHERENCE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Read all written content:
+```bash
+ALL_PAPER_CONTENT=$(cat paper/*.md 2>/dev/null)
+```
+
+Spawn with inline context (NOT file references -- provide actual content):
+
+```
+Task(
+  prompt="First, read ~/.claude/agents/wtfp/coherence-checker.md for your role and instructions.\n\n" +
+    "<paper_content>\n" + ALL_PAPER_CONTENT + "\n</paper_content>\n" +
+    "<argument_map>\n" + ARGMAP_CONTENT + "\n</argument_map>\n" +
+    "<narrative_arc>\n" + NARRATIVE_CONTENT + "\n</narrative_arc>\n" +
+    "<outline>\n" + OUTLINE_CONTENT + "\n</outline>\n" +
+    "Run all 5 verification passes and return structured results.",
+  subagent_type="general-purpose",
+  model="{checker_model}",
+  description="Verify Cross-Section Coherence"
+)
+```
+
+## 7. Handle Coherence Check Return
+
+**`## COHERENT`:** All sections pass. Present success summary.
+
+**`## GAPS FOUND`:** Present gaps to user with options:
+- Fix now: Re-spawn writers for affected sections with gap context
+- Accept: Note gaps, proceed to review
+- Plan revision: Create revision plans for affected sections
+
+## 8. Present Final Status
+
+</process>
+
+<offer_next>
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► OUTLINE EXECUTED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Document: {Title}** — {N} sections, {W} words
+
+Coherence: {Verified | Gaps found | Skipped}
+
+───────────────────────────────────────────
+
+## ▶ Next Up
+
+**Verify sections** — acceptance testing
+
+`/wtfp:verify-work [section]`
+
+<sub>`/clear` first → fresh context window</sub>
+
+───────────────────────────────────────────
+
+**Also available:**
+- `/wtfp:review-section [N]` — detailed section review
+- `/wtfp:polish-prose [N]` — improve prose quality
+- `/wtfp:submit-draft` — prepare for submission
+
+</offer_next>
+
+<success_criteria>
+- [ ] Roadmap and plans validated
+- [ ] Wave execution plan built from section dependencies
+- [ ] Parallel writers spawned per wave
+- [ ] All waves executed in order
+- [ ] Checkpoints handled between waves
+- [ ] Coherence-checker spawned after final wave with inline content
+- [ ] Coherence result handled (COHERENT or GAPS FOUND)
+- [ ] STATE.md and ROADMAP.md updated
+- [ ] User knows next steps
+</success_criteria>

package/vendors/claude/commands/wtfp/export-latex.md

@@ -1,6 +1,6 @@
 ---
 name: wtfp:export-latex
-description: Export paper to LaTeX format
+description: Export paper to LaTeX with bibliography and formatting
 allowed-tools:
   - Read
   - Bash