mindsystem-cc 3.11.0 → 3.13.0

package/mindsystem/references/scope-estimation.md

@@ -32,10 +32,10 @@ Why 50% not 80%?
 | Task Complexity | Tasks/Plan | Context/Task | Total |
 |-----------------|------------|--------------|-------|
 | Simple (CRUD, config) | 3 | ~10-15% | ~30-45% |
-| Complex (auth, payments) | 2 | ~20-30% | ~40-50% |
+| Complex (auth, payments) | 2-3 | ~15-25% | ~40-50% |
 | Very complex (migrations, refactors) | 1-2 | ~30-40% | ~30-50% |
 
-**When in doubt: Default to 2 tasks.** Better to have an extra plan than degraded quality.
+**Default to 3 tasks for simple-medium work, 2 for complex.** Executor overhead reduction creates headroom for the third task.
 </task_rule>
 
 <tdd_plans>
@@ -108,24 +108,23 @@ Plan 03: Visualization components
 </splitting_strategies>
 
 <dependency_awareness>
-**Plans declare dependencies explicitly via frontmatter.**
+**Dependencies centralized in EXECUTION-ORDER.md.**
 
-```yaml
-# Independent plan (Wave 1 candidate)
-depends_on: []
-files_modified: [src/features/user/model.ts, src/features/user/api.ts]
-
-
-# Dependent plan (later wave)
-depends_on: ["03-01"]
-files_modified: [src/integration/stripe.ts]
+```markdown
+## Wave 1 (parallel)
+- 03-01-PLAN.md — User feature
+- 03-02-PLAN.md — Product feature
 
+## Wave 2
+- 03-03-PLAN.md — Integration (after: 01, 02)
 ```
 
+Plans declare files in `**Files:**` lines within `## Changes` subsections. EXECUTION-ORDER.md tracks wave groups and dependencies.
+
 **Wave assignment rules:**
-- `depends_on: []` + no file conflicts → Wave 1 (parallel)
-- `depends_on: ["XX"]` → runs after plan XX completes
-- Shared `files_modified` with sibling → sequential (by plan number)
+- No dependencies + no file conflicts with other Wave 1 plans → Wave 1 (parallel)
+- Depends on earlier plan → later wave (runs after dependency completes)
+- Shared files with sibling plan → sequential (by plan number)
 
 **SUMMARY references:**
 - Only reference prior SUMMARY if genuinely needed (imported types, decisions affecting this plan)
@@ -134,17 +133,21 @@ files_modified: [src/integration/stripe.ts]
 </dependency_awareness>
 
 <file_ownership>
-**Exclusive file ownership prevents conflicts:**
+**Exclusive file ownership prevents conflicts.**
+
+File ownership is determined from `**Files:**` lines in each plan's `## Changes` section and validated in EXECUTION-ORDER.md wave assignments.
 
-```yaml
-# Plan 01 frontmatter
-files_modified: [src/models/user.ts, src/api/users.ts, src/components/UserList.tsx]
+```markdown
+# Plan 01 Changes
+### 1. Create User model
+**Files:** `src/models/user.ts`, `src/api/users.ts`, `src/components/UserList.tsx`
 
-# Plan 02 frontmatter
-files_modified: [src/models/product.ts, src/api/products.ts, src/components/ProductList.tsx]
+# Plan 02 Changes
+### 1. Create Product model
+**Files:** `src/models/product.ts`, `src/api/products.ts`, `src/components/ProductList.tsx`
 ```
 
-No overlap → can run parallel.
+No overlap → can run parallel (same wave in EXECUTION-ORDER.md).
 
 **If file appears in multiple plans:** Later plan depends on earlier (by plan number).
 **If file cannot be split:** Plans must be sequential for that file.
@@ -202,39 +205,9 @@ Waves: [01, 02, 03] (all parallel)
 
 **2 tasks:** Simple ~30%, Medium ~50%, Complex ~80% (split)
 **3 tasks:** Simple ~45%, Medium ~75% (risky), Complex 120% (impossible)
-</estimating_context>
-
-<depth_calibration>
-**Depth controls compression tolerance, not artificial inflation.**
-
-| Depth | Typical Phases | Typical Plans/Phase | Tasks/Plan |
-|-------|----------------|---------------------|------------|
-| Quick | 3-5 | 1-3 | 2-3 |
-| Standard | 5-8 | 3-5 | 2-3 |
-| Comprehensive | 8-12 | 5-10 | 2-3 |
 
-Tasks/plan is CONSTANT at 2-3. The 50% context rule applies universally.
-
-**Key principle:** Derive from actual work. Depth determines how aggressively you combine things, not a target to hit.
-
-- Comprehensive auth = 8 plans (because auth genuinely has 8 concerns)
-- Comprehensive "add favicon" = 1 plan (because that's all it is)
-
-Don't pad small work to hit a number. Don't compress complex work to look efficient.
-
-**Comprehensive depth example:**
-Auth system at comprehensive depth = 8 plans (not 3 big ones):
-- 01: DB models (2 tasks)
-- 02: Password hashing (2 tasks)
-- 03: JWT generation (2 tasks)
-- 04: JWT validation middleware (2 tasks)
-- 05: Login endpoint (2 tasks)
-- 06: Register endpoint (2 tasks)
-- 07: Protected route patterns (2 tasks)
-- 08: Auth UI components (3 tasks)
-
-Each plan: fresh context, peak quality. More plans = more thoroughness, same quality per plan.
-</depth_calibration>
+**Executor overhead:** ~2,400 tokens (down from ~6,900 in previous versions), freeing ~4,500 tokens per plan for code quality.
+</estimating_context>
 
 <summary>
 **2-3 tasks, 50% context target:**
@@ -246,11 +219,10 @@ Each plan: fresh context, peak quality. More plans = more thoroughness, same qua
 
 **The rules:**
 - If in doubt, split. Quality over consolidation.
-- Depth increases plan COUNT, never plan SIZE.
 - Vertical slices over horizontal layers.
-- Explicit dependencies via `depends_on` frontmatter.
+- Dependencies centralized in EXECUTION-ORDER.md.
 - Autonomous plans get parallel execution.
 
-**Commit rule:** Each plan produces 3-4 commits total (2-3 task commits + 1 docs commit).
+**Commit rule:** Each plan produces 3-4 commits total (2-3 change commits + 1 docs commit).
 </summary>
 </scope_estimation>

package/mindsystem/references/tdd-execution.md

@@ -0,0 +1,70 @@
+<tdd_execution>
+
+## RED-GREEN-REFACTOR Cycle
+
+Lazy-loaded by executor when plan metadata says `**Type:** tdd`.
+
+### RED — Write failing test
+
+1. Create test file following project conventions
+2. Write test describing expected behavior (from plan's behavior specification)
+3. Run test — MUST fail (if passes, feature exists or test is wrong — investigate)
+4. Commit: `test({phase}-{plan}): add failing test for [feature]`
+
+### GREEN — Implement to pass
+
+1. Write minimal code to make test pass — no cleverness, no optimization
+2. Run test — MUST pass
+3. Commit: `feat({phase}-{plan}): implement [feature]`
+
+### REFACTOR (if needed)
+
+1. Clean up implementation if obvious improvements exist
+2. Run tests — MUST still pass
+3. Commit only if changes made: `refactor({phase}-{plan}): clean up [feature]`
+
+Result: Each TDD plan produces 2-3 atomic commits (test/feat/refactor).
+
+---
+
+## Test Framework Setup
+
+When no test framework is configured, set it up as part of the RED phase:
+
+| Project | Framework | Install |
+|---------|-----------|---------|
+| Node.js | Jest | `npm install -D jest @types/jest ts-jest` |
+| Node.js (Vite) | Vitest | `npm install -D vitest` |
+| Python | pytest | `pip install pytest` |
+| Go | testing | Built-in |
+| Rust | cargo test | Built-in |
+| Flutter/Dart | flutter_test | Built-in |
+
+Detect project type from package.json / requirements.txt / go.mod / pubspec.yaml. Create config if needed. Verify with empty test run.
+
+---
+
+## Commit Pattern
+
+TDD plans use dedicated commit types per phase:
+
+```
+test(08-02): add failing test for email validation
+feat(08-02): implement email validation
+refactor(08-02): extract regex to constant  # optional
+```
+
+Comparison: Standard plans produce 1 commit per task. TDD plans produce 2-3 commits for single feature.
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Test doesn't fail in RED | Feature may exist or test is wrong — investigate before proceeding |
+| Test doesn't pass in GREEN | Debug implementation, keep iterating until green |
+| Tests fail in REFACTOR | Undo refactor — commit was premature, refactor in smaller steps |
+| Unrelated tests break | Stop and investigate — may indicate coupling issue |
+
+</tdd_execution>

package/mindsystem/references/tdd.md

@@ -1,12 +1,13 @@
-<overview>
+# TDD Reference for Plan Writers
+
 TDD is about design quality, not coverage metrics. The red-green-refactor cycle forces you to think about behavior before implementation, producing cleaner interfaces and more testable code.
 
 **Principle:** If you can describe the behavior as `expect(fn(input)).toBe(output)` before writing `fn`, TDD improves the result.
 
-**Key insight:** TDD work is fundamentally heavier than standard tasks—it requires 2-3 execution cycles (RED → GREEN → REFACTOR), each with file reads, test runs, and potential debugging. TDD features get dedicated plans to ensure full context is available throughout the cycle.
-</overview>
+**Key insight:** TDD work is fundamentally heavier than standard tasks — it requires 2-3 execution cycles (RED -> GREEN -> REFACTOR), each with file reads, test runs, and potential debugging. TDD features get dedicated plans to ensure full context is available throughout the cycle.
+
+---
 
-<when_to_use_tdd>
 ## When TDD Improves Quality
 
 **TDD candidates (create a TDD plan):**
@@ -18,7 +19,7 @@ TDD is about design quality, not coverage metrics. The red-green-refactor cycle
 - State machines and workflows
 - Utility functions with clear specifications
 
-**Skip TDD (use standard plan with `type="auto"` tasks):**
+**Skip TDD (use standard plan):**
 - UI layout, styling, visual components
 - Configuration changes
 - Glue code connecting existing components
@@ -27,92 +28,65 @@ TDD is about design quality, not coverage metrics. The red-green-refactor cycle
 - Exploratory prototyping
 
 **Heuristic:** Can you write `expect(fn(input)).toBe(output)` before writing `fn`?
-→ Yes: Create a TDD plan
-→ No: Use standard plan, add tests after if needed
-</when_to_use_tdd>
+- Yes: Create a TDD plan
+- No: Use standard plan, add tests after if needed
+
+---
 
-<tdd_plan_structure>
 ## TDD Plan Structure
 
-Each TDD plan implements **one feature** through the full RED-GREEN-REFACTOR cycle.
+Each TDD plan implements **one feature** through the full RED-GREEN-REFACTOR cycle. Use the same pure markdown format as all other plans:
 
 ```markdown
----
-phase: XX-name
-plan: NN
-type: tdd
----
+# Plan NN: Feature name
 
-<objective>
-[What feature and why]
-Purpose: [Design benefit of TDD for this feature]
-Output: [Working, tested feature]
-</objective>
-
-<context>
-@.planning/PROJECT.md
-@.planning/ROADMAP.md
-@relevant/source/files.ts
-</context>
-
-<feature>
-  <name>[Feature name]</name>
-  <files>[source file, test file]</files>
-  <behavior>
-    [Expected behavior in testable terms]
-    Cases: input → expected output
-  </behavior>
-  <implementation>[How to implement once tests pass]</implementation>
-</feature>
-
-<verification>
-[Test command that proves feature works]
-</verification>
-
-<success_criteria>
-- Failing test written and committed
-- Implementation passes test
-- Refactor complete (if needed)
-- All 2-3 commits present
-</success_criteria>
-
-<output>
-After completion, create SUMMARY.md with:
-- RED: What test was written, why it failed
-- GREEN: What implementation made it pass
-- REFACTOR: What cleanup was done (if any)
-- Commits: List of commits produced
-</output>
-```
+**Subsystem:** validation | **Type:** tdd
+
+## Context
+Why TDD benefits this feature. Clear inputs/outputs that make test-first
+design valuable. Reference any prior work.
+
+## Changes
+
+### 1. RED — Write failing tests
+**Files:** `src/lib/__tests__/validate-email.test.ts`
+
+Test cases:
+- Valid: `user@example.com`, `name+tag@domain.co.uk` -> returns true
+- Invalid: `@domain.com`, `user@`, empty string -> returns false
+- Edge: very long local part (>64 chars) -> returns false
 
-**One feature per TDD plan.** If features are trivial enough to batch, they're trivial enough to skip TDD—use a standard plan and add tests after.
-</tdd_plan_structure>
+Import `validateEmail` from `src/lib/validate-email.ts` (does not exist yet).
+Run tests — all must fail with import/function error.
 
-<execution_flow>
-## Red-Green-Refactor Cycle
+### 2. GREEN — Implement minimal validation
+**Files:** `src/lib/validate-email.ts`
 
-**RED - Write failing test:**
-1. Create test file following project conventions
-2. Write test describing expected behavior (from `<behavior>` element)
-3. Run test - it MUST fail
-4. If test passes: feature exists or test is wrong. Investigate.
-5. Commit: `test({phase}-{plan}): add failing test for [feature]`
+Export `validateEmail(email: string): boolean`. Use regex matching RFC 5322
+simplified pattern. Handle null/undefined input by returning false. No
+optimization — just make tests pass.
 
-**GREEN - Implement to pass:**
-1. Write minimal code to make test pass
-2. No cleverness, no optimization - just make it work
-3. Run test - it MUST pass
-4. Commit: `feat({phase}-{plan}): implement [feature]`
+### 3. REFACTOR — Extract regex constant
+**Files:** `src/lib/validate-email.ts`
 
-**REFACTOR (if needed):**
-1. Clean up implementation if obvious improvements exist
-2. Run tests - MUST still pass
-3. Only commit if changes made: `refactor({phase}-{plan}): clean up [feature]`
+Extract regex to `EMAIL_REGEX` constant at module level. Add JSDoc with
+examples. Run tests — all must still pass. Only commit if changes improve
+readability.
 
-**Result:** Each TDD plan produces 2-3 atomic commits.
-</execution_flow>
+## Verification
+- `npm test -- --grep "validate-email"` passes all cases
+- Import works from other modules without errors
+
+## Must-Haves
+- [ ] Valid email addresses return true
+- [ ] Invalid email addresses return false
+- [ ] Edge cases (length limits, null input) handled correctly
+```
+
+**One feature per TDD plan.** If features are trivial enough to batch, they're trivial enough to skip TDD — use a standard plan and add tests after.
+
+---
 
-<test_quality>
 ## Good Tests vs Bad Tests
 
 **Test behavior, not implementation:**
@@ -131,123 +105,9 @@ After completion, create SUMMARY.md with:
 **No implementation details:**
 - Good: Test public API, observable behavior
 - Bad: Mock internals, test private methods, assert on internal state
-</test_quality>
-
-<framework_setup>
-## Test Framework Setup (If None Exists)
-
-When executing a TDD plan but no test framework is configured, set it up as part of the RED phase:
-
-**1. Detect project type:**
-```bash
-# JavaScript/TypeScript
-if [ -f package.json ]; then echo "node"; fi
-
-# Python
-if [ -f requirements.txt ] || [ -f pyproject.toml ]; then echo "python"; fi
-
-# Go
-if [ -f go.mod ]; then echo "go"; fi
-
-# Rust
-if [ -f Cargo.toml ]; then echo "rust"; fi
-```
-
-**2. Install minimal framework:**
-| Project | Framework | Install |
-|---------|-----------|---------|
-| Node.js | Jest | `npm install -D jest @types/jest ts-jest` |
-| Node.js (Vite) | Vitest | `npm install -D vitest` |
-| Python | pytest | `pip install pytest` |
-| Go | testing | Built-in |
-| Rust | cargo test | Built-in |
-
-**3. Create config if needed:**
-- Jest: `jest.config.js` with ts-jest preset
-- Vitest: `vitest.config.ts` with test globals
-- pytest: `pytest.ini` or `pyproject.toml` section
-
-**4. Verify setup:**
-```bash
-# Run empty test suite - should pass with 0 tests
-npm test  # Node
-pytest    # Python
-go test ./...  # Go
-cargo test    # Rust
-```
-
-**5. Create first test file:**
-Follow project conventions for test location:
-- `*.test.ts` / `*.spec.ts` next to source
-- `__tests__/` directory
-- `tests/` directory at root
-
-Framework setup is a one-time cost included in the first TDD plan's RED phase.
-</framework_setup>
-
-<error_handling>
-## Error Handling
-
-**Test doesn't fail in RED phase:**
-- Feature may already exist - investigate
-- Test may be wrong (not testing what you think)
-- Fix before proceeding
-
-**Test doesn't pass in GREEN phase:**
-- Debug implementation
-- Don't skip to refactor
-- Keep iterating until green
-
-**Tests fail in REFACTOR phase:**
-- Undo refactor
-- Commit was premature
-- Refactor in smaller steps
-
-**Unrelated tests break:**
-- Stop and investigate
-- May indicate coupling issue
-- Fix before proceeding
-</error_handling>
-
-<commit_pattern>
-## Commit Pattern for TDD Plans
-
-TDD plans produce 2-3 atomic commits (one per phase):
 
-```
-test(08-02): add failing test for email validation
-
-- Tests valid email formats accepted
-- Tests invalid formats rejected
-- Tests empty input handling
-
-feat(08-02): implement email validation
-
-- Regex pattern matches RFC 5322
-- Returns boolean for validity
-- Handles edge cases (empty, null)
-
-refactor(08-02): extract regex to constant (optional)
-
-- Moved pattern to EMAIL_REGEX constant
-- No behavior changes
-- Tests still pass
-```
-
-**Comparison with standard plans:**
-- Standard plans: 1 commit per task, 2-4 commits per plan
-- TDD plans: 2-3 commits for single feature
-
-Both follow same format: `{type}({phase}-{plan}): {description}`
-
-**Benefits:**
-- Each commit independently revertable
-- Git bisect works at commit level
-- Clear history showing TDD discipline
-- Consistent with overall commit strategy
-</commit_pattern>
+---
 
-<context_budget>
 ## Context Budget
 
 TDD plans target **~40% context usage** (lower than standard plans' ~50%).
@@ -260,4 +120,3 @@ Why lower:
 Each phase involves reading files, running commands, analyzing output. The back-and-forth is inherently heavier than linear task execution.
 
 Single feature focus ensures full quality throughout the cycle.
-</context_budget>

package/mindsystem/templates/config.json

@@ -1,16 +1,5 @@
 {
   "subsystems": [],
-  "depth": "standard",
-  "parallelization": {
-    "enabled": true,
-    "plan_level": true,
-    "max_concurrent_agents": 3,
-    "min_plans_for_parallel": 2
-  },
-  "safety": {
-    "always_confirm_destructive": true,
-    "always_confirm_external_services": true
-  },
   "code_review": {
     "adhoc": null,
     "phase": null,