learnship 1.9.24 → 2.0.1

package/learnship/workflows/ideate.md

@@ -0,0 +1,182 @@
+---
+description: Codebase-grounded divergent thinking — discover what is worth working on
+---
+
+# Ideate
+
+Codebase-grounded divergent ideation. Scans the actual codebase for hotspots, TODOs, test gaps, and friction points, then generates 15-25 improvement ideas across multiple thinking frames. Adversarial filter eliminates weak ideas. Presents top 5-7 ranked survivors.
+
+**Usage:** `ideate` — open-ended ideation on the current project
+**Usage:** `ideate [focus]` — focused ideation on a specific area, concept, or constraint
+
+**Sequencing:** Run before `/new-project`, `/challenge`, or `/discuss-milestone` to discover what's worth building.
+
+## Step 1: Scope
+
+If a focus argument was provided, use it as the ideation lens.
+If no argument, proceed with open-ended ideation.
+
+Check for recent ideation work:
+```bash
+find .planning/ -name "*-ideation-*.md" -mtime -30 2>/dev/null
+```
+
+If recent ideation exists, ask: "Found recent ideation work. Resume from it, or start fresh?"
+
+## Step 2: Codebase Scan
+
+Gather grounding context before generating ideas:
+
+```bash
+# Project shape
+cat AGENTS.md 2>/dev/null || cat CLAUDE.md 2>/dev/null || cat README.md 2>/dev/null
+
+# TODOs and FIXMEs in codebase
+grep -rn "TODO\|FIXME\|HACK\|XXX" --include="*.ts" --include="*.js" --include="*.py" --include="*.rb" --include="*.go" --include="*.rs" . 2>/dev/null | head -30
+
+# Test coverage gaps (files without corresponding test files)
+find . -name "*.ts" -not -name "*.test.*" -not -name "*.spec.*" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -20
+
+# Recent git activity (hotspots)
+git log --oneline -20 --format="%s" 2>/dev/null
+git log --since="30 days ago" --format="" --name-only 2>/dev/null | sort | uniq -c | sort -rn | head -15
+```
+
+**Brownfield enhancement:** If `.planning/codebase/` exists, also read:
+```bash
+cat .planning/codebase/ARCHITECTURE.md 2>/dev/null
+cat .planning/codebase/CONCERNS.md 2>/dev/null
+cat .planning/codebase/TESTING.md 2>/dev/null
+```
+
+Read compounded solutions and knowledge:
+```bash
+ls .planning/solutions/ 2>/dev/null
+cat .planning/KNOWLEDGE.md 2>/dev/null
+```
+
+## Step 3: Divergent Ideation
+
+Read `parallelization` from `.planning/config.json` (defaults to `false`).
+
+**If `parallelization` is `true` (subagent mode):**
+
+Spawn 3-4 ideation agents in parallel, each with a different thinking frame:
+
+```
+Task(
+  subagent_type="learnship-ideation-agent",
+  prompt="
+    <objective>
+    Generate 6-8 improvement ideas for this project using the [FRAME] lens.
+    Ground every idea in the codebase scan results — no abstract advice.
+    Return: title, summary, why_it_matters, evidence (specific files/patterns)
+
+    Frame: [one of the frames below]
+    Focus: [focus hint if provided]
+    </objective>
+
+    <context>
+    [codebase scan results]
+    [solutions and knowledge if available]
+    </context>
+  "
+)
+```
+
+**Thinking frames:**
+1. **User/operator pain** — friction, confusion, error-prone workflows
+2. **Inversion/removal** — what could be automated, eliminated, or simplified
+3. **Assumption-breaking** — what if the current approach is wrong?
+4. **Leverage/compounding** — what would make all future work easier?
+
+**If `parallelization` is `false` (sequential mode):**
+
+Using `@./agents/ideation-agent.md`, generate 15-25 ideas across all four frames sequentially.
+
+## Step 4: Deduplicate & Filter
+
+Merge ideas from all frames:
+
+1. **Deduplicate** — merge ideas that describe the same improvement from different angles
+2. **Adversarial filter** — for each idea, ask:
+   - Is this grounded in the actual codebase, or generic advice?
+   - Is this actionable within a reasonable scope?
+   - Does the evidence support the claimed impact?
+   - Would a senior engineer roll their eyes at this suggestion?
+3. **Eliminate** weak ideas with explicit reasons
+
+## Step 5: Rank Survivors
+
+Rank the surviving ideas (target: 5-7) by:
+
+| Factor | Weight |
+|--------|--------|
+| **Impact** — how much does this improve the project? | High |
+| **Evidence** — how grounded is the idea in codebase data? | High |
+| **Feasibility** — can this be done in a reasonable scope? | Medium |
+| **Compounding** — does this make future work easier? | Medium |
+
+## Step 6: Present Results
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ learnship ► IDEATION COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Focus: [focus or "open-ended"]
+Scanned: [N] files, [M] TODOs, [K] hotspots
+Generated: [total] ideas → [filtered] eliminated → [survivors] survivors
+
+## Top Ideas
+
+### 1. [Title]
+**Impact:** high | medium | low
+**Evidence:** [specific files/patterns from codebase]
+**Summary:** [2-3 sentences]
+**Scope:** [estimated effort — small/medium/large]
+
+### 2. [Title]
+[...]
+
+---
+
+Eliminated ideas (with reasons):
+- [idea]: [why eliminated]
+[...]
+```
+
+Save the ideation artifact:
+```bash
+DATE=$(date +%Y%m%d)
+node -e "require('fs').mkdirSync('.planning',{recursive:true})"
+# Write ideation results to .planning/[DATE]-ideation-[slug].md
+git add .planning/[DATE]-ideation-[slug].md
+git commit -m "docs: ideation — [focus or 'open-ended'] ([N] survivors)"
+```
+
+## Step 7: Route to Action
+
+Present the "What's next?" options using the platform's blocking question tool:
+
+- **Deep-dive an idea** → expand on the selected idea with more detail
+- **Start a new project** → feed selected idea into `/new-project`
+- **Add to current milestone** → feed into `/add-phase`
+- **Challenge an idea** → run `/challenge [idea]` to stress-test it
+- **Save and return later** → already saved to `.planning/`
+
+---
+
+## Learning Checkpoint
+
+Read `learning_mode` from `.planning/config.json`.
+
+**If `auto`:** After ideation, offer:
+
+> 💡 **Learning moment:** Ideation is where divergent thinking gets practiced:
+>
+> `@agentic-learning brainstorm [top idea]` — Take the #1 idea and brainstorm collaboratively. Explore variations, edge cases, and alternative approaches.
+>
+> `@agentic-learning either-or [idea A] vs [idea B]` — Compare two competing ideas. Which is worth pursuing? Log the reasoning.
+
+**If `manual`:** Add quietly: *"Tip: `@agentic-learning brainstorm [idea]` to explore the top idea collaboratively."*

package/learnship/workflows/knowledge-base.md

@@ -32,6 +32,9 @@ find .planning/ -name "*-RESEARCH.md" | sort
 
 # AGENTS.md regressions
 grep -A 5 "### 20" AGENTS.md 2>/dev/null
+
+# Compounded solutions
+find .planning/solutions/ -name "*.md" -type f 2>/dev/null | sort
 ```
 
 ## Step 3: Extract Knowledge
@@ -53,6 +56,11 @@ From each source, extract structured knowledge items:
 - "Don't Hand-Roll" entries → Knowledge item: `library`
 - "Common Pitfalls" entries → Knowledge item: `pitfall`
 
+**From compounded solutions (`.planning/solutions/`):**
+- Bug track solutions → Knowledge item: `lesson` (root cause + prevention)
+- Knowledge track solutions → Knowledge item: `pattern` or `anti-pattern`
+- Read YAML frontmatter for classification (module, problem_type, severity, tags)
+
 Deduplicate: if the same concept appears multiple times, merge into one entry with multiple `sources`.
 
 ## Step 4: Write / Update KNOWLEDGE.md

package/learnship/workflows/ls.md

@@ -119,10 +119,14 @@ Determine the next action (same logic as `progress`):
 5. **Plans = 0, no CONTEXT.md** → needs discussion
    - Next: `discuss-phase [X]`
 
-6. **All plans have summaries, more phases remain** → move forward
+6. **All plans have summaries, UAT not done** → verify before moving on
+   - Next: `verify-work [X]`
+
+7. **All plans have summaries, UAT passed, more phases remain** → move forward
    - Next: `discuss-phase [X+1]`
+   - Suggest: `/review` → `/ship` → `/compound` before starting next phase
 
-7. **All phases done** → ready to ship
+8. **All phases done** → ready to ship
    - Next: `audit-milestone`
 
 Display clearly, then **ask**:
@@ -142,4 +146,4 @@ If the user says yes (or "go", "do it", "run it", "proceed") — immediately inv
 
 - `/ls` is an alias for the status + routing logic in `progress`. Use either.
 - For full auto-pilot (no prompt), use `/next` instead.
-- To see all 40+ available commands: `/help`
+- To see all 49 available commands: `/help`

package/learnship/workflows/milestone-retrospective.md

@@ -67,6 +67,51 @@ Ask each question and wait for a real answer before moving to the next. These ar
 **Question 5: What should carry forward?**
 "Any patterns, decisions, or lessons from this milestone that should explicitly inform the next one? What goes into the decision register?"
 
+## Step 2b: Quantitative Summary
+
+Gather data-driven metrics for this milestone:
+
+```bash
+# Commits per phase
+for dir in .planning/phases/*/; do
+  PHASE=$(basename "$dir")
+  COUNT=$(git log --oneline --all -- "$dir" 2>/dev/null | wc -l | tr -d ' ')
+  echo "$PHASE: $COUNT commits"
+done
+
+# Total LOC changed
+git log --oneline --format="" --numstat $(git log --all --oneline .planning/ 2>/dev/null | tail -1 | cut -d' ' -f1)..HEAD 2>/dev/null | awk '{add+=$1; del+=$2} END {print "+" add " -" del " lines"}'
+
+# Test file ratio
+TOTAL_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.rb" -o -name "*.go" 2>/dev/null | grep -v node_modules | grep -v .git | wc -l | tr -d ' ')
+TEST_FILES=$(find . -name "*.test.*" -o -name "*.spec.*" -o -name "*_test.*" 2>/dev/null | grep -v node_modules | grep -v .git | wc -l | tr -d ' ')
+echo "Test ratio: $TEST_FILES test files / $TOTAL_FILES total files"
+
+# Debug sessions count
+DEBUG_COUNT=$(ls .planning/debug/resolved/ 2>/dev/null | wc -l | tr -d ' ')
+echo "Debug sessions resolved: $DEBUG_COUNT"
+
+# Velocity (days from first to last commit in milestone)
+FIRST_DATE=$(git log --reverse --format="%ai" .planning/ 2>/dev/null | head -1 | cut -d' ' -f1)
+LAST_DATE=$(git log --format="%ai" .planning/ 2>/dev/null | head -1 | cut -d' ' -f1)
+echo "Duration: $FIRST_DATE to $LAST_DATE"
+```
+
+Present the quantitative summary before the qualitative questions:
+
+```
+## Quantitative Summary
+
+| Metric | Value |
+|--------|-------|
+| Phases completed | [N] |
+| Total commits | [N] |
+| LOC changed | +[N] / -[N] |
+| Test file ratio | [N]% |
+| Debug sessions | [N] |
+| Duration | [N] days |
+```
+
 ## Step 3: Synthesize Themes
 
 After all five answers, synthesize the key themes:

package/learnship/workflows/next.md

@@ -67,7 +67,8 @@ Evaluate in order:
 | Plans exist, summaries < plans | `execute-phase [X]` |
 | Plans = 0, CONTEXT.md exists | `plan-phase [X]` |
 | Plans = 0, no CONTEXT.md | `discuss-phase [X]` |
-| All summaries complete, more phases remain | `discuss-phase [X+1]` |
+| All summaries complete, UAT not done | `verify-work [X]` |
+| All summaries complete, UAT passed, more phases remain | `discuss-phase [X+1]` |
 | All phases complete | `audit-milestone` |
 
 ---
@@ -97,4 +98,4 @@ If no — show `/ls` output so the user can choose manually.
 
 - `/next` always confirms before acting (never fully silent).
 - For status-only with manual choice, use `/ls` instead.
-- To see all available commands: `/help`
+- To see all 49 available commands: `/help`

package/learnship/workflows/plan-phase.md

@@ -53,6 +53,29 @@ Ask: "No CONTEXT.md found for Phase [X]. Plans will use research and requirement
 
 **If CONTEXT.md exists:** Load it and confirm: "Using phase context from: [path]"
 
+## Step 2b: Search Solutions for Prior Art
+
+**Skip if:** `workflow.solutions_search` is `false` in config (defaults to `true`).
+
+Search `.planning/solutions/` for prior art matching this phase's keywords:
+
+```bash
+# Check if solutions directory exists
+ls .planning/solutions/ 2>/dev/null
+
+# Search for matching solutions by phase keywords
+grep -ril "[phase_keyword1]\|[phase_keyword2]\|[phase_keyword3]" .planning/solutions/ 2>/dev/null
+```
+
+If matches found, read the frontmatter (first 30 lines) of each match. Surface relevant prior solutions to the planner:
+
+```
+Solutions prior art found:
+- .planning/solutions/[category]/[file].md — [title] (relevant: [why])
+```
+
+These solutions provide context for planning — the planner should reference them to avoid reinventing known solutions.
+
 ## Step 3: Research Phase
 
 **Skip if:** `--skip-research` flag, or `workflow.research` is `false` in config, or RESEARCH.md already exists (unless `--research` flag forces re-research).

package/learnship/workflows/progress.md

@@ -101,9 +101,15 @@ Context: [✓ CONTEXT.md exists | — not yet]
    - If CONTEXT.md exists: `▶ Next: plan-phase [X]`
    - If no CONTEXT.md: `▶ Next: discuss-phase [X]` (recommended) or `plan-phase [X]`
 
-5. **Summaries = plans AND plans > 0** → phase complete
-   - If more phases remain: `▶ Next: discuss-phase [X+1]`
-   - If all phases done: `▶ Next: audit-milestone`
+5. **Summaries = plans AND plans > 0, UAT not done** → verify first
+   - `▶ Next: verify-work [X]`
+
+6. **Summaries = plans, UAT passed, more phases remain** → move forward
+   - `▶ Next: discuss-phase [X+1]`
+   - Suggest: `/review` → `/ship` → `/compound` before starting next phase
+
+7. **All phases done** → ready to ship
+   - `▶ Next: audit-milestone`
 
 After presenting the recommended next step, ask:
 

package/learnship/workflows/review.md

@@ -0,0 +1,226 @@
+---
+description: Multi-persona code review — correctness, testing, security, performance, maintainability
+---
+
+# Review
+
+Multi-persona code review that examines changes through six lenses: correctness, testing, security, performance, maintainability, and adversarial. Produces a severity-ranked findings report with confidence scores.
+
+**Usage:** `review` — review current branch changes
+**Usage:** `review [mode]` — modes: `interactive` (default), `report-only`, `autofix`
+
+**Sequencing:** Run after `verify-work` (spec compliance) and before `/ship` (deploy pipeline).
+
+## Step 1: Determine Scope
+
+Compute the diff:
+
+```bash
+# Detect base branch
+BASE_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||')
+[ -z "$BASE_BRANCH" ] && BASE_BRANCH="main"
+
+# Get current branch
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+
+# Compute diff
+git fetch origin "$BASE_BRANCH" --quiet 2>/dev/null
+BASE=$(git merge-base "origin/$BASE_BRANCH" HEAD 2>/dev/null || echo "origin/$BASE_BRANCH")
+echo "FILES:" && git diff --name-only $BASE
+echo "DIFF:" && git diff -U10 $BASE
+echo "STATS:" && git diff --stat $BASE
+```
+
+If no diff found: "Nothing to review — no changes against $BASE_BRANCH." Stop.
+
+## Step 2: Discover Intent
+
+Understand what the change is trying to accomplish:
+
+```bash
+echo "BRANCH:" && git rev-parse --abbrev-ref HEAD
+echo "COMMITS:" && git log --oneline ${BASE}..HEAD
+```
+
+Combined with conversation context and any SUMMARY.md files from the current phase, write a 2-3 line intent summary:
+
+```
+Intent: [what the changes are trying to accomplish]
+```
+
+## Step 3: Select Personas
+
+Read the diff and file list. Select which review personas to activate:
+
+**Always-on (every review):**
+
+| Persona | Focus |
+|---------|-------|
+| **correctness** | Logic errors, edge cases, state bugs, error propagation |
+| **testing** | Coverage gaps, weak assertions, brittle tests |
+| **maintainability** | Coupling, complexity, naming, dead code, abstraction debt |
+
+**Conditional (selected per diff):**
+
+| Persona | Select when diff touches... |
+|---------|---------------------------|
+| **security** | Auth, public endpoints, user input, permissions, secrets |
+| **performance** | DB queries, data transforms, caching, async, loops |
+| **adversarial** | Diff ≥50 changed non-test lines, or auth/payments/data mutations |
+
+**Brownfield enhancement:** If `.planning/codebase/CONVENTIONS.md` exists, the maintainability persona reads it for project-specific patterns.
+
+Announce the review team:
+```
+Review team:
+- correctness (always)
+- testing (always)
+- maintainability (always)
+- security — [justification if selected]
+- performance — [justification if selected]
+- adversarial — [justification if selected]
+```
+
+## Step 4: Run Review
+
+Read `parallelization` from `.planning/config.json` (defaults to `false`).
+
+**If `parallelization` is `true` (subagent mode — Claude Code, OpenCode, Codex):**
+
+Spawn a dedicated code-reviewer agent for each selected persona:
+
+```
+Task(
+  subagent_type="learnship-code-reviewer",
+  prompt="
+    <objective>
+    Review the following diff as the [PERSONA] reviewer.
+    Focus: [persona-specific focus areas]
+    Return findings as structured text with severity (P0-P3) and confidence (0.0-1.0).
+    Do NOT edit any files. Read-only review.
+    </objective>
+
+    <context>
+    Intent: [intent summary]
+    Files: [file list]
+    Diff: [diff content]
+    [If maintainability + CONVENTIONS.md exists: include conventions]
+    </context>
+  "
+)
+```
+
+Wait for all personas to complete.
+
+**If `parallelization` is `false` (sequential mode):**
+
+Using `@./agents/code-reviewer.md` as your review persona, run each selected persona sequentially. For each persona:
+
+1. Adopt the persona's focus lens
+2. Read the diff through that lens
+3. Record findings with severity and confidence
+
+## Step 5: Merge & Deduplicate Findings
+
+Combine findings from all personas:
+
+1. **Confidence gate** — suppress findings below 0.60 confidence. Exception: P0 findings at 0.50+ survive.
+2. **Deduplicate** — when multiple personas flag the same issue (same file + nearby lines + similar title), merge: keep highest severity, keep highest confidence, note which personas flagged it.
+3. **Cross-persona agreement** — when 2+ personas flag the same issue, boost confidence by 0.10 (capped at 1.0).
+4. **Sort** — order by severity (P0 first) → confidence (descending) → file path → line number.
+
+## Step 6: Present Report
+
+### Severity Scale
+
+| Level | Meaning | Action |
+|-------|---------|--------|
+| **P0** | Critical breakage, exploitable vulnerability, data loss | Must fix before merge |
+| **P1** | High-impact defect likely hit in normal usage | Should fix |
+| **P2** | Moderate issue — edge case, perf regression, maintainability trap | Fix if straightforward |
+| **P3** | Low-impact, minor improvement | Discretion |
+
+Display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ learnship ► CODE REVIEW COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Intent: [intent summary]
+Reviewers: [list]
+Mode: [interactive | report-only | autofix]
+
+## Findings
+
+### P0 — Critical
+| # | File | Issue | Reviewer(s) | Confidence |
+|---|------|-------|-------------|------------|
+| 1 | [file:line] | [issue] | [personas] | [0.XX] |
+
+### P1 — High
+[table or "None"]
+
+### P2 — Moderate
+[table or "None"]
+
+### P3 — Low
+[table or "None"]
+
+---
+
+## Verdict
+
+[PASS — no P0/P1 findings]
+[PASS WITH CONCERNS — P1 findings present but manageable]
+[FAIL — P0 findings must be resolved before merge]
+
+Total: [N] findings ([P0 count] critical, [P1 count] high, [P2 count] moderate, [P3 count] low)
+```
+
+## Step 7: Handle Mode
+
+**Interactive (default):**
+For each P0/P1 finding, ask: "Fix this now, or defer?"
+- **Fix now** → apply the fix, commit
+- **Defer** → note in report
+
+**Report-only:**
+Display the report. No edits, no commits. Stop.
+
+**Autofix:**
+Apply fixes for P0/P1 findings automatically where the fix is deterministic and safe. Commit each fix:
+```bash
+git add [files]
+git commit -m "fix([scope]): [description from finding]"
+```
+
+## Step 8: Suggest Next Steps
+
+```
+▶ Next steps:
+- /ship — run the ship pipeline (test → lint → commit → push → PR)
+- /compound — capture any notable patterns from the review
+```
+
+---
+
+## Config Options
+
+- `"workflow.review": true` — enable/disable the review workflow
+- `"review.auto_after_verify": false` — automatically run review after verify-work passes
+
+---
+
+## Learning Checkpoint
+
+Read `learning_mode` from `.planning/config.json`.
+
+**If `auto`:** After review, offer:
+
+> 💡 **Learning moment:** Code review is one of the highest-signal learning activities:
+>
+> `@agentic-learning learn [finding domain]` — Active retrieval on the concept behind the most significant finding. Why did it happen? How would you catch it earlier?
+>
+> `@agentic-learning quiz [codebase area]` — Test your understanding of the code area that had the most findings. Gaps in recall predict future bugs.
+
+**If `manual`:** Add quietly: *"Tip: `@agentic-learning learn [domain]` to turn review findings into lasting patterns."*

package/learnship/workflows/set-profile.md

@@ -15,9 +15,9 @@ If no argument provided:
 Usage: set-profile [profile]
 
 Profiles:
-  quality   — Opus for all agents (highest quality, highest cost)
-  balanced  — Opus for planning, Sonnet for execution (recommended)
-  budget    — Sonnet for writing, Haiku for research/verification (lowest cost)
+  quality   — large-tier models for all agents (highest quality, highest cost)
+  balanced  — large for planning, medium for execution (recommended)
+  budget    — medium for writing, small for research/verification (lowest cost)
 
 Current profile: [read from .planning/config.json]
 ```
@@ -70,9 +70,9 @@ git commit -m "chore(config): set model profile to [profile]"
 ```
 Profile updated: [old] → [profile]
 
-[quality]  — Opus agents for all tasks. Use for production milestones.
-[balanced] — Opus for planning, Sonnet for execution. Best default.
-[budget]   — Sonnet/Haiku. Use for prototyping or exploration.
+[quality]  — Large-tier agents for all tasks. Use for production milestones.
+[balanced] — Large for planning, medium for execution. Best default.
+[budget]   — Medium/small tier. Use for prototyping or exploration.
 
 Takes effect immediately on the next workflow run.
 ```

package/learnship/workflows/settings.md

@@ -30,7 +30,7 @@ cp templates/config.json .planning/config.json 2>/dev/null || cat > .planning/co
     "research": true,
     "plan_check": true,
     "verifier": true,
-    "nyquist_validation": true
+    "validation": true
   },
   "git": {
     "branching_strategy": "none",
@@ -67,7 +67,7 @@ Current configuration:
 [5] Research agent:    [on/off]
 [6] Plan check agent:  [on/off]
 [7] Verifier agent:    [on/off]
-[8] Nyquist validation:[on/off]
+[8] Test validation:  [on/off]
 [9] Git branching:     [current] (none | phase | milestone)
 [10] Commit docs:      [on/off]
 
@@ -102,9 +102,9 @@ Current: [current]. New value?
 **[3] Model profile:**
 ```
 Model profile controls which model tier each agent uses:
-- quality: Opus for all decision-making agents (highest cost, best results)
-- balanced: Opus for planning, Sonnet for execution (default — good balance)
-- budget: Sonnet for writing code, Haiku for research/verification (lowest cost)
+- quality: large-tier for all decision-making agents (highest cost, best results)
+- balanced: large for planning, medium for execution (default — good balance)
+- budget: medium for writing code, small for research/verification (lowest cost)
 
 Current: [current]. New value?
 ```
@@ -127,9 +127,9 @@ Current: [current]. New value?
 Current: [current]. New value? (on/off)
 ```
 
-**[8] Nyquist validation:**
+**[8] Test validation:**
 ```
-Nyquist validation maps automated test coverage to requirements during plan-phase.
+Test validation maps automated test coverage to requirements during plan-phase.
 - on: plans include automated verify commands per task (recommended)
 - off: skip validation research (good for rapid prototyping)
 
@@ -174,7 +174,7 @@ cat > .planning/config.json << EOF
     "research": [true/false],
     "plan_check": [true/false],
     "verifier": [true/false],
-    "nyquist_validation": [true/false]
+    "validation": [true/false]
   },
   "git": {
     "branching_strategy": "[value]",