wtf-p 0.4.0 → 0.5.0

package/vendors/opencode/commands/wtfp/insert-section.md

@@ -0,0 +1,124 @@
+---
+name: wtfp:insert-section
+description: Insert a new section between existing sections
+---
+
+<objective>
+Insert a new section between existing sections as a decimal phase.
+
+Creates intermediate section (e.g., 3.1 between sections 3 and 4).
+
+Useful for discovered gaps that must be addressed mid-draft.
+
+Maintains section ordering without renumbering.
+</objective>
+
+<process>
+
+<step name="parse">
+**Parse arguments:**
+
+Expect: `<after> <description>`
+- after: Section number to insert after (e.g., 3)
+- description: Brief description of new section
+
+Example: `/wtfp:insert-section 3 "Add methodology validation subsection"`
+</step>
+
+<step name="verify">
+**Verify project exists:**
+
+```bash
+[ ! -f .planning/ROADMAP.md ] && echo "ERROR: No roadmap found. Run /wtfp:create-outline first" && exit 1
+```
+
+Check that "after" section exists in ROADMAP.md.
+</step>
+
+<step name="determine_number">
+**Determine new section number:**
+
+Check for existing decimal sections after the target:
+- If 3.1 doesn't exist → new section is 3.1
+- If 3.1 exists but 3.2 doesn't → new section is 3.2
+- Continue until finding available slot
+</step>
+
+<step name="confirm">
+**Confirm with user:**
+
+Use the question tool:
+- header: "Insert Section"
+- question: "Insert Section [X.Y]: [description] after Section [X]?"
+- options:
+  - "Yes, create it" — Insert the section
+  - "Different position" — Let me specify another location
+  - "Cancel" — Don't insert
+
+</step>
+
+<step name="create">
+**Create section:**
+
+1. Create directory:
+```bash
+mkdir -p ".planning/sections/[XX.Y]-[section-name-slug]"
+```
+
+2. Update ROADMAP.md:
+- Insert new section entry after section [X]
+- Include goal, word target, status
+
+3. Update STATE.md if needed.
+
+</step>
+
+<step name="commit">
+```bash
+git add .planning/ROADMAP.md .planning/sections/
+git commit -m "$(cat <<'EOF'
+docs: insert Section [X.Y] - [name]
+
+[Description]
+
+Inserted between Section [X] and Section [X+1]
+EOF
+)"
+```
+
+</step>
+
+<step name="done">
+**Present completion:**
+
+```
+Section inserted:
+
+- Section [X.Y]: [Name]
+- Directory: .planning/sections/[XX.Y]-[name]/
+- ROADMAP.md updated
+
+---
+
+## ▶ Next Up
+
+**Plan new section** — create writing plan
+
+`/wtfp:plan-section [X.Y]`
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+```
+
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] New section number determined (no conflicts)
+- [ ] Directory created
+- [ ] ROADMAP.md updated with new section
+- [ ] Ordering preserved
+- [ ] Committed to git
+</success_criteria>

package/vendors/opencode/commands/wtfp/list-assumptions.md

@@ -0,0 +1,105 @@
+---
+name: wtfp:list-assumptions
+description: Preview intended approach for a section before writing
+---
+
+<objective>
+Show Claude's intended approach for a section before planning begins.
+
+Lets you course-correct if Claude misunderstood your vision.
+
+No files created - conversational output only.
+</objective>
+
+<process>
+
+<step name="verify">
+**Verify project exists:**
+
+```bash
+[ ! -f .planning/PROJECT.md ] && echo "ERROR: No project found. Run /wtfp:new-paper first" && exit 1
+[ ! -f .planning/ROADMAP.md ] && echo "ERROR: No outline found. Run /wtfp:create-outline first" && exit 1
+```
+
+</step>
+
+<step name="load">
+**Load all relevant context:**
+
+- Read PROJECT.md for paper vision
+- Read ROADMAP.md for section goal
+- Read argument-map.md for relevant claims
+- Read outline.md for structure expectations
+- Read narrative-arc.md for story context
+- Read any prior SUMMARY.md files
+- Check for CONTEXT.md or RESEARCH.md in section directory
+</step>
+
+<step name="present">
+**Present assumptions in 5 areas:**
+
+```
+# Assumptions for Section [N]: [Name]
+
+## 1. Content Approach
+Based on the section goal and argument map, I plan to:
+- [Main point 1]
+- [Main point 2]
+- [Main point 3]
+
+Key claims I'll develop:
+- [Claim from argument-map]
+- [Claim from argument-map]
+
+## 2. Structure
+I'm planning to organize this section as:
+1. [Opening approach]
+2. [Body structure]
+3. [Closing approach]
+
+Word allocation:
+- [Part 1]: ~[X] words
+- [Part 2]: ~[Y] words
+- [Part 3]: ~[Z] words
+
+## 3. Writing Mode
+Based on the section type, I recommend:
+- Mode: [Co-Author/Scaffold/Reviewer]
+- Reason: [Why this mode fits]
+
+## 4. Dependencies
+This section relies on:
+- Prior sections: [What must be established first]
+- Citations needed: [Key references]
+- Evidence: [Data/figures to reference]
+
+This section sets up:
+- Following sections: [What this enables]
+
+## 5. Potential Challenges
+I anticipate:
+- [Challenge 1]: [How I'd address it]
+- [Challenge 2]: [How I'd address it]
+
+## Questions for You
+- [Any clarifications needed]
+- [Decisions that need your input]
+
+---
+
+**Does this match your vision?**
+- If yes: Run `/wtfp:plan-section [section]`
+- If concerns: Tell me what to adjust
+- If major changes: Run `/wtfp:discuss-section [section]`
+```
+
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] All 5 assumption areas covered
+- [ ] Based on actual project context
+- [ ] Clear path to course-correct
+- [ ] No files created (conversational only)
+</success_criteria>

package/vendors/opencode/commands/wtfp/map-project.md

@@ -0,0 +1,100 @@
+---
+name: wtfp:map-project
+description: Index existing drafts, data, and references for a project
+---
+
+<execution_context>
+@~/.opencode/write-the-f-paper/workflows/map-project.md
+</execution_context>
+
+<objective>
+Index existing source materials (literature, data, prior drafts) for a writing project.
+
+**Orchestrator role:** Detect existing materials, resolve model profile, create `.planning/sources/` with organized references, commit.
+
+Use before `/wtfp:new-paper` on existing writing projects.
+</objective>
+
+<context>
+No arguments. Scans current directory for existing materials.
+</context>
+
+<process>
+
+## 1. Validate Environment and 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")
+```
+
+## 2. Detect Existing Materials
+
+```bash
+find . -name "*.bib" -o -name "references.md" -o -name "bibliography.md" 2>/dev/null | head -20
+find . -name "*.tex" -o -name "*.md" -o -name "*.docx" 2>/dev/null | grep -v node_modules | grep -v .planning | head -20
+find . -name "*.csv" -o -name "*.json" -o -name "*.xlsx" 2>/dev/null | head -20
+find . -name "*.png" -o -name "*.pdf" -o -name "*.svg" -o -name "*.jpg" 2>/dev/null | head -20
+```
+
+## 3. Create Sources Directory
+
+```bash
+mkdir -p .planning/sources
+```
+
+## 4. Index Literature
+
+If .bib files found, parse via `node ~/.opencode/bin/bib-index.js index [file]`.
+
+Write `.planning/sources/literature.md`: Core References table (key, citation, relevance, status), Background Reading, To Find list, source paths.
+
+## 5. Index Data and Evidence
+
+Scan for figures, tables, data files.
+
+Write `.planning/sources/data.md`: Figures table (ID, file, description, status, target section), Tables, Data Files, Statistics.
+
+## 6. Index Prior Drafts
+
+Scan for existing writing.
+
+Write `.planning/sources/prior-drafts.md`: Existing Documents table (file, type, description, usable, target section), Key Passages, Material to Avoid.
+
+## 7. Commit
+
+```bash
+git add .planning/sources/
+git commit -m "docs: index source materials"
+```
+
+</process>
+
+<offer_next>
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ WTF-P ► SOURCES INDEXED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Literature: .planning/sources/literature.md ([N] references)
+- Data: .planning/sources/data.md ([N] figures, [N] tables)
+- Prior Drafts: .planning/sources/prior-drafts.md ([N] documents)
+
+───────────────────────────────────────────
+
+## ▶ Next Up
+
+**Initialize paper** — capture vision and structure
+
+`/wtfp:new-paper`
+
+───────────────────────────────────────────
+
+</offer_next>
+
+<success_criteria>
+- [ ] All existing materials discovered
+- [ ] literature.md indexes all citations
+- [ ] data.md inventories figures and evidence
+- [ ] prior-drafts.md catalogs existing writing
+- [ ] All committed to git
+</success_criteria>

package/vendors/opencode/commands/wtfp/new-paper.md

@@ -0,0 +1,161 @@
+---
+name: wtfp:new-paper
+description: Initialize a new paper with deep context gathering and PROJECT.md
+---
+
+<execution_context>
+@~/.opencode/write-the-f-paper/references/principles.md
+@~/.opencode/write-the-f-paper/references/questioning.md
+@~/.opencode/write-the-f-paper/templates/project.md
+@~/.opencode/write-the-f-paper/templates/config.json
+@~/.opencode/write-the-f-paper/venues/
+</execution_context>
+
+<objective>
+Initialize a new academic paper through comprehensive context gathering.
+
+**Orchestrator role:** Check preconditions, detect brownfield projects, gather paper vision through batched questioning, synthesize PROJECT.md + config.json + structure documents, commit.
+
+Creates `.planning/` with PROJECT.md, config.json, and structure documents.
+</objective>
+
+<context>
+No arguments. Runs in current directory.
+</context>
+
+<process>
+
+## 1. Validate Environment
+
+```bash
+[ -f .planning/PROJECT.md ] && echo "ERROR: Paper already initialized. Use /wtfp:progress" && exit 1
+```
+
+Initialize git if needed:
+```bash
+[ -d .git ] || [ -f .git ] || git init
+```
+
+## 2. Brownfield Detection
+
+```bash
+WRITING_FILES=$(find . -name "*.tex" -o -name "*.md" -o -name "*.bib" -o -name "*.docx" 2>/dev/null | grep -v node_modules | grep -v .git | grep -v .planning | head -20)
+HAS_SOURCES=$([ -d sources ] || [ -d references ] || [ -d literature ] && echo "yes")
+HAS_SOURCE_MAP=$([ -d .planning/sources ] && echo "yes")
+```
+
+**If materials detected and no source map:** Offer `/wtfp:map-project` first via the question tool.
+
+## 3. Gather Core Context (Batched)
+
+Use the question tool -- collect foundations in one turn:
+- header: "Paper Foundations"
+- question: "1. **Type** (Research paper, Grant, Thesis)\n2. **Venue** (NeurIPS, CHI, Nature, etc.)\n3. **Core Argument** (one thing you're proving)\n4. **Audience** (who is this for?)"
+- options: "I provided the details" | "Guide me step-by-step"
+
+If step-by-step selected, ask Type -> Venue -> Argument sequentially.
+
+## 4. Venue Template Selection
+
+If ambiguous, ask via the question tool:
+- header: "Venue Structure"
+- options: "ACM CS" | "IEEE CS" | "ML/AI" | "Nature/Science" | "Thesis"
+
+Load corresponding YAML from `~/.opencode/write-the-f-paper/venues/`.
+
+## 5. Sharpen Core Argument
+
+If core_argument was weak, drill down:
+- header: "Refine Core"
+- question: "If reviewers remember ONE thing, what is it?"
+- options: "The Method" | "The Findings" | "The Theory" | "The System"
+
+## 6. Gather Constraints
+
+- header: "Scope & Limits"
+- question: "1. **Out of Scope?** 2. **Hard Constraints?** (page limits, deadlines)"
+- options: "Provided details" | "No constraints"
+
+## 7. Synthesize PROJECT.md
+
+Write `.planning/PROJECT.md` using template from `~/.opencode/write-the-f-paper/templates/project.md`.
+
+Populate: What This Is, Core Argument, Requirements (Must/Should/Out of Scope), Target Audience, Constraints, Key Decisions.
+
+## 8. Create Structure Documents
+
+Create `.planning/structure/` with:
+- **argument-map.md** -- Central thesis, supporting claims, logical flow, gaps
+- **outline.md** -- Venue template sections, word budget table
+- **narrative-arc.md** -- Problem/Journey/Resolution, reader experience
+
+## 9. Workflow Mode & Config
+
+Ask mode (Interactive / Flow) and depth (Quick / Standard / Comprehensive) via the question tool.
+
+## 9b. Git & Planning Settings
+
+Ask about git tracking via the question tool:
+- header: "Git & Planning"
+- question: "Track planning documents in git?"
+- options:
+  - "Yes (default)" -- commit_docs: true, planning artifacts are version-controlled
+  - "No" -- commit_docs: false, only paper content is committed
+
+Use the answer to set `planning.commit_docs` in config.json.
+
+Ask about branching strategy via the question tool:
+- header: "Git Branching"
+- question: "Branch strategy for git history?"
+- options:
+  - "None (default)" -- all commits on current branch, git.branching_strategy: "none"
+  - "Section branches" -- one branch per section, merged on review pass, git.branching_strategy: "section"
+  - "Submission branches" -- branch per milestone/submission target, git.branching_strategy: "submission"
+
+Use the answer to set `git.branching_strategy` in config.json.
+
+## 9c. Write Config
+
+Write `.planning/config.json` with the full v0.5.0 schema: mode, depth, document_type, output_format, model_profile ("balanced"), venue_template, gates (8 gate types: confirm_outline, confirm_plan, confirm_write, confirm_review, execute_next_section, issues_review, confirm_transition, confirm_submission), writing, workflow, verification, planning (commit_docs, search_gitignored), parallelization, safety (always_confirm_destructive, always_confirm_external_services, backup_before_major_edits), git (branching_strategy, section_branch_template, submission_branch_template, squash_on_merge).
+
+## 10. Commit
+
+```bash
+git add .planning/PROJECT.md .planning/config.json .planning/structure/
+git commit -m "docs: initialize [paper-title]"
+```
+
+</process>
+
+<offer_next>
+
+---
+ WTF-P > PAPER INITIALIZED
+---
+
+- Project: .planning/PROJECT.md
+- Config: .planning/config.json (mode: [chosen])
+- Structure: .planning/structure/
+
+---
+
+## > Next Up
+
+**Create section outline**
+
+`/wtfp:create-outline`
+
+<sub>`/clear` first -> fresh context window</sub>
+
+---
+
+</offer_next>
+
+<success_criteria>
+- [ ] Deep questioning completed (not rushed)
+- [ ] PROJECT.md captures paper vision with core argument
+- [ ] Structure documents created (argument-map, outline, narrative-arc)
+- [ ] config.json has gates, safety, planning, and git sections
+- [ ] config.json has workflow mode and model_profile
+- [ ] All committed to git
+</success_criteria>

package/vendors/opencode/commands/wtfp/pause-writing.md

@@ -0,0 +1,141 @@
+---
+name: wtfp:pause-writing
+description: Save current progress so you can resume later
+---
+
+<objective>
+Create context handoff file when pausing work mid-section.
+
+Captures current state so next session can resume seamlessly.
+
+Creates .continue-here.md with current state and updates STATE.md.
+</objective>
+
+<process>
+
+<step name="verify">
+**Verify project exists:**
+
+```bash
+[ ! -f .planning/STATE.md ] && echo "ERROR: No project state found" && exit 1
+```
+
+</step>
+
+<step name="gather">
+**Gather current state:**
+
+- Read STATE.md for current position
+- Find any in-progress PLAN.md files
+- Check for uncommitted changes
+- Identify what was being worked on
+</step>
+
+<step name="handoff">
+**Create .continue-here.md:**
+
+In the current section directory:
+
+```markdown
+---
+section: XX-name
+task: [current task number]
+total_tasks: [total]
+status: [in_progress/blocked/almost_done]
+last_updated: [ISO timestamp]
+---
+
+# Continue Here: [Section Name]
+
+## Current State
+[What's currently happening - in progress, waiting for input, etc.]
+
+## Completed Work
+- [Task 1]: [done]
+- [Task 2]: [done]
+- [Task 3]: [in progress - description of where stopped]
+
+## Remaining Work
+- [Task 4]: [not started]
+- [Task 5]: [not started]
+
+## Decisions Made
+| Decision | Rationale |
+|----------|-----------|
+| [choice] | [why] |
+
+## Blockers (if any)
+- [What's blocking progress]
+
+## Context Notes
+[Any important context for resuming:
+- Why work was paused
+- What was being figured out
+- Any insights not yet captured elsewhere]
+
+## Next Action
+[Exactly what to do when resuming]
+
+---
+*Paused: [timestamp]*
+```
+
+</step>
+
+<step name="update_state">
+**Update STATE.md:**
+
+Add to Session Continuity section:
+```markdown
+## Session Continuity
+- Last session: [timestamp]
+- Handoff: .planning/sections/XX-name/.continue-here.md
+- Status: [in_progress/blocked]
+```
+
+</step>
+
+<step name="commit">
+```bash
+git add .planning/sections/XX-name/.continue-here.md .planning/STATE.md
+git commit -m "$(cat <<'EOF'
+wip: pause [section name]
+
+Task [X] of [Y] in progress
+EOF
+)"
+```
+
+</step>
+
+<step name="done">
+**Present completion:**
+
+```
+Work paused:
+
+- Handoff: .planning/sections/XX-name/.continue-here.md
+- State: .planning/STATE.md updated
+- Position: Task [X] of [Y]
+
+## To Resume
+
+`/wtfp:resume-writing`
+
+This will restore full context and continue from task [X].
+
+---
+```
+
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] .continue-here.md captures current state
+- [ ] Completed work documented
+- [ ] Remaining work listed
+- [ ] Next action is clear and actionable
+- [ ] STATE.md updated with handoff reference
+- [ ] All committed to git
+</success_criteria>