bmad-method-test-architecture-enterprise 1.3.2 → 1.4.0

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -22,7 +22,7 @@ Please check all that apply:
 
 - [ ] Workflows (test-design, automate, atdd, test-review, trace, nfr-assess, ci, framework)
 - [ ] Knowledge Base (new testing patterns or fragments)
-- [ ] Subprocess Architecture (parallel execution)
+- [ ] Subagent Architecture (parallel execution)
 - [ ] Configuration (module variables or settings)
 - [ ] Documentation (guides, tutorials, or references)
 - [ ] Integrations (Playwright Utils, MCP, or other tools)

package/CHANGELOG.md

@@ -31,8 +31,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `true` -> `"auto"` (recommended), `false` -> `"none"`
 - All workflow preflight steps updated to read `tea_browser_automation`
 - All browser-touching workflow steps updated with CLI/MCP/auto branching
-- Subprocess context passes `browser_automation` instead of `use_mcp_enhancements`
+- Subagent context passes `browser_automation` instead of `use_mcp_enhancements`
 - Module subheader updated to reference Playwright CLI
+- **Breaking**: Orchestration terminology standardized to `subagent` / `agent-team` (removed `subprocess` wording)
+  - Renamed worker step files from `*-subprocess-*` to `*-subagent-*` in `automate`, `atdd`, `nfr-assess`, and `test-review`
+  - Updated orchestration mode resolution examples to use `subagent` only
+  - Renamed architecture docs: `subprocess-architecture.md` -> `subagent-architecture.md`, `subprocess-implementation-status.md` -> `subagent-implementation-status.md`
+  - Updated docs navigation, troubleshooting references, and workflow/resource indexes to new names
+  - Updated workflow contract labels/examples from `subprocess` to `subagent` (for example `subagent_execution`, `subagentType`)
 
 ### Deprecated
 
@@ -83,17 +89,17 @@ All workflows implement the **trivariate step pattern** (Create/Edit/Validate):
 
 4. **ATDD (`AT` / `/bmad:tea:atdd`)**
    - Generate failing acceptance tests (TDD red phase)
-   - **Subprocess Architecture**: Parallel API + E2E test generation
+   - **Subagent Architecture**: Parallel API + E2E test generation
    - Acceptance criteria validation checklist
 
 5. **Test Automation (`TA` / `/bmad:tea:automate`)**
    - Expand automation coverage systematically
-   - **Subprocess Architecture**: Parallel API + E2E test generation
+   - **Subagent Architecture**: Parallel API + E2E test generation
    - Coverage gap analysis and prioritization
 
 6. **Test Review (`RV` / `/bmad:tea:test-review`)**
    - Comprehensive test quality audit (0-100 scoring)
-   - **Subprocess Architecture**: Parallel evaluation across 5 quality dimensions
+   - **Subagent Architecture**: Parallel evaluation across 5 quality dimensions
      - Determinism
      - Isolation
      - Maintainability
@@ -108,24 +114,24 @@ All workflows implement the **trivariate step pattern** (Create/Edit/Validate):
 
 8. **NFR Assessment (`NR` / `/bmad:tea:nfr-assess`)**
    - Non-functional requirements evaluation
-   - **Subprocess Architecture**: Parallel assessment across 4 NFR domains
+   - **Subagent Architecture**: Parallel assessment across 4 NFR domains
      - Security
      - Performance
      - Reliability
      - Scalability
    - Evidence-based scoring with recommendations
 
-#### Subprocess Architecture (Phase 5)
+#### Subagent Architecture (Phase 5)
 
-- **19 Subprocess Step Files** for parallel execution:
-  - `automate`: 3 subprocess files (2 parallel + aggregate)
-  - `atdd`: 3 subprocess files (2 parallel + aggregate)
-  - `test-review`: 6 subprocess files (5 parallel + aggregate)
-  - `nfr-assess`: 5 subprocess files (4 parallel + aggregate)
+- **19 Subagent Step Files** for parallel execution:
+  - `automate`: 3 subagent files (2 parallel + aggregate)
+  - `atdd`: 3 subagent files (2 parallel + aggregate)
+  - `test-review`: 6 subagent files (5 parallel + aggregate)
+  - `nfr-assess`: 5 subagent files (4 parallel + aggregate)
   - `trace`: Two-phase separation (coverage → gate decision)
-- **Temp File Outputs**: Each subprocess writes to `/tmp/bmad-tea-*` files
-- **Aggregation Step**: Consolidates subprocess results into final output
-- **Documentation**: Complete subprocess architecture documentation in `docs/explanation/`
+- **Temp File Outputs**: Each subagent writes to `/tmp/bmad-tea-*` files
+- **Aggregation Step**: Consolidates subagent results into final output
+- **Documentation**: Complete subagent architecture documentation in `docs/explanation/`
 
 #### Knowledge Base System
 
@@ -197,7 +203,7 @@ All workflows implement the **trivariate step pattern** (Create/Edit/Validate):
   - `steps-v/` (Validate mode) - 1 step per workflow
 - **Validation Reports**: Comprehensive validation with checklist scoring
 - **Documentation Links**: All internal links validated and fixed (309 → 0 broken links)
-- **Subprocess Optimization**: Parallel execution for faster workflow completion
+- **Subagent Optimization**: Parallel execution for faster workflow completion
 
 ### Fixed
 
@@ -238,7 +244,7 @@ For users migrating from BMM-embedded TEA, see [`docs/MIGRATION.md`](docs/MIGRAT
 
 - **1.0.0** (2026-01-XX) - TEA Module Independence Release
   - Standalone module extraction from BMAD Method
-  - 9 workflows with subprocess architecture
+  - 9 workflows with subagent architecture
   - 34 knowledge base fragments
   - Complete documentation suite
 

package/README.md

@@ -60,7 +60,7 @@ flowchart LR
 4. **Step-by-step execution** — Only the current step file is in context (just-in-time loading). Each step explicitly names the next one (`nextStepFile: './step-02-...'`). The LLM reads, executes, saves output, then loads the next step. No future steps are ever preloaded.
 5. **Knowledge injection** — Step-01 reads `tea-index.csv` and selectively loads fragments by **tier** (core = always, extended = on-demand, specialized = only when relevant) and **config flags** (e.g., `tea_use_pactjs_utils`). This is deliberate context engineering: a backend project loads ~1,800 lines of fragments; a fullstack project loads ~4,500 lines. Conditional loading cuts context usage by 40-50%.
 6. **Templates** — When a step produces output (e.g., a traceability matrix or test review report), it reads the `*-template.md` file and fills in the `{PLACEHOLDER}` values with computed results. The template provides consistent structure; the step provides the content.
-7. **Subprocess isolation** — Heavy workflows (e.g., `automate`) spawn parallel subprocesses that each run in an isolated context. Subprocesses write structured JSON to temp files. An aggregation step reads the JSON outputs — only the results enter the main context, not the full subprocess history.
+7. **Subagent isolation** — Heavy workflows (e.g., `automate`) spawn parallel subagents that each run in an isolated context. Subagents write structured JSON to temp files. An aggregation step reads the JSON outputs — only the results enter the main context, not the full subagent history.
 8. **Progress tracking** — Each step appends to an output file with YAML frontmatter (`stepsCompleted`, `lastStep`, `lastSaved`). Resume mode reads this frontmatter and routes to the next incomplete step.
 9. **Validation** — The `steps-v/` mode reads `checklist.md` and evaluates the workflow's output against its criteria, producing a pass/fail validation report.
 
@@ -73,7 +73,7 @@ BMad workflows and Claude Code Skills solve different problems at different scal
 | **Execution**     | Single prompt, one shot     | 5-9 sequential steps with explicit handoffs                                  |
 | **State**         | Stateless                   | YAML frontmatter tracking (`stepsCompleted`, `lastStep`) with resume         |
 | **Knowledge**     | Whatever fits in one prompt | Tiered index (40 fragments), conditional loading by config + stack detection |
-| **Context mgmt**  | Everything in one shot      | Just-in-time step loading, subprocess isolation (separate contexts)          |
+| **Context mgmt**  | Everything in one shot      | Just-in-time step loading, subagent isolation (separate contexts)            |
 | **Output**        | Freeform                    | Templates with `{PLACEHOLDER}` vars filled by specific steps                 |
 | **Validation**    | None                        | Dedicated mode (`steps-v/`) evaluating against checklists                    |
 | **Configuration** | None                        | `module.yaml` with prompted config flags driving conditional behavior        |

package/docs/explanation/step-file-architecture.md

@@ -72,7 +72,7 @@ workflow/
 - Granular instructions → LLM focuses on one task
 - Clear exit conditions → LLM knows when to stop
 - Repeated context → LLM has all necessary info
-- Subprocess support → Parallel execution possible
+- Subagent support → Parallel execution possible
 
 ---
 
@@ -153,19 +153,19 @@ Example:
 - ❌ Do NOT add features not requested
 ```
 
-### 5. Subprocess Support
+### 5. Subagent Support
 
-**Independent steps can run in parallel subprocesses** - massive performance gain.
+**Independent steps can run in parallel subagents** - massive performance gain.
 
 Example (automate workflow):
 
 ```
 Step 1-2: Sequential (setup)
-Step 3: Subprocess A (API tests) + Subprocess B (E2E tests) - PARALLEL
+Step 3: Subagent A (API tests) + Subagent B (E2E tests) - PARALLEL
 Step 4: Sequential (aggregate)
 ```
 
-See [subprocess-architecture.md](./subprocess-architecture.md) for details.
+See [subagent-architecture.md](./subagent-architecture.md) for details.
 
 ---
 
@@ -193,8 +193,8 @@ Step 1: Setup → Step 2: Configure → Step 3: Generate → Step 4: Validate
 Step 1: Setup
 Step 2: Load knowledge
 Step 3: PARALLEL
-  ├── Subprocess A: Generate API tests
-  └── Subprocess B: Generate E2E tests
+  ├── Subagent A: Generate API tests
+  └── Subagent B: Generate E2E tests
 Step 4: Aggregate + validate
 ```
 
@@ -211,9 +211,9 @@ Step 4: Aggregate + validate
 ```
 Step 1: Load context
 Step 2: PARALLEL
-  ├── Subprocess A: Check dimension 1
-  ├── Subprocess B: Check dimension 2
-  ├── Subprocess C: Check dimension 3
+  ├── Subagent A: Check dimension 1
+  ├── Subagent B: Check dimension 2
+  ├── Subagent C: Check dimension 3
   └── (etc.)
 Step 3: Aggregate scores
 ```
@@ -237,7 +237,7 @@ Phase 2: Read matrix → Apply decision tree → Generate gate decision
 
 - Phase 2 depends on Phase 1 output
 - Not parallel, but clean separation of concerns
-- Subprocess-like phase isolation
+- Subagent-like phase isolation
 
 ### Pattern 5: Risk-Based Planning (Design Workflows)
 
@@ -354,7 +354,7 @@ Load `steps/step-[N+1]-[action].md` and execute.
 ### Example: Step File for API Test Generation
 
 ````markdown
-# Step 3A: Generate API Tests (Subprocess)
+# Step 3A: Generate API Tests (Subagent)
 
 ## Context (from previous steps)
 
@@ -397,7 +397,7 @@ Generate API tests for the 3 features identified above.
 
 ## What You MUST NOT Do
 
-- ❌ Do NOT generate E2E tests (that's Step 3B - parallel subprocess)
+- ❌ Do NOT generate E2E tests (that's Step 3B - parallel subagent)
 - ❌ Do NOT generate fixtures yet (that's Step 4)
 - ❌ Do NOT run tests yet (that's Step 5)
 - ❌ Do NOT use custom fetch/axios (use apiRequest helper)
@@ -425,14 +425,14 @@ Output JSON to `/tmp/automate-api-tests-{timestamp}.json`:
 
 ## Exit Condition
 
-You may finish this subprocess when:
+You may finish this subagent when:
 
 - ✅ All 3 features have API test files
 - ✅ All tests use Playwright Utils helpers
 - ✅ All tests use data factories
 - ✅ JSON output file written to /tmp/
 
-Subprocess complete. Main workflow will read output and proceed.
+Subagent complete. Main workflow will read output and proceed.
 
 ````
 
@@ -450,7 +450,7 @@ All 9 TEA workflows score **100%** on BMad Builder validation. Validation report
 - ✅ Explicit exit conditions (LLM knows when to stop)
 - ✅ Context injection (each step self-contained)
 - ✅ Strict action boundaries (prevents improvisation)
-- ✅ Subprocess support (where applicable)
+- ✅ Subagent support (where applicable)
 
 ### Real-Project Testing
 
@@ -479,7 +479,7 @@ Update step files when:
 1. **Knowledge fragments change**: Update fragment loading instructions
 2. **New patterns emerge**: Add new requirements/patterns to steps
 3. **LLM improvises**: Add stricter boundaries to prevent improvisation
-4. **Performance issues**: Split steps further or add subprocesses
+4. **Performance issues**: Split steps further or add subagents
 5. **User feedback**: Clarify ambiguous instructions
 
 ### Best Practices
@@ -510,7 +510,7 @@ Update step files when:
 - test-review: ~5 minutes (5 quality checks sequentially)
 - nfr-assess: ~12 minutes (4 NFR domains sequentially)
 
-**After Step Files (Parallel Subprocesses)**:
+**After Step Files (Parallel Subagents)**:
 
 - automate: ~5 minutes (API + E2E in parallel) - **50% faster**
 - test-review: ~2 minutes (all checks in parallel) - **60% faster**
@@ -538,9 +538,9 @@ When running workflows, users see:
 ```
 ✓ Step 1: Setup complete
 ✓ Step 2: Knowledge fragments loaded
-⟳ Step 3: Generating tests (2 subprocesses running)
-  ├── Subprocess A: API tests... ✓
-  └── Subprocess B: E2E tests... ✓
+⟳ Step 3: Generating tests (2 subagents running)
+  ├── Subagent A: API tests... ✓
+  └── Subagent B: E2E tests... ✓
 ✓ Step 4: Aggregating results
 ✓ Step 5: Validation complete
 ```
@@ -556,7 +556,7 @@ When running workflows, users see:
 - **Diagnosis**: Step instructions too vague
 - **Fix**: Add more explicit requirements and forbidden actions
 
-**Issue**: Subprocess output not aggregating correctly
+**Issue**: Subagent output not aggregating correctly
 
 - **Diagnosis**: Temp file path mismatch or JSON parsing error
 - **Fix**: Check temp file naming convention, verify JSON format
@@ -566,16 +566,16 @@ When running workflows, users see:
 - **Diagnosis**: Fragment loading instructions unclear
 - **Fix**: Make fragment usage requirements more explicit
 
-**Issue**: Workflow too slow despite subprocesses
+**Issue**: Workflow too slow despite subagents
 
 - **Diagnosis**: Not enough parallelization
-- **Fix**: Identify more independent steps for subprocess pattern
+- **Fix**: Identify more independent steps for subagent pattern
 
 ---
 
 ## References
 
-- **Subprocess Architecture**: [subprocess-architecture.md](./subprocess-architecture.md)
+- **Subagent Architecture**: [subagent-architecture.md](./subagent-architecture.md)
 - **Knowledge Base System**: [knowledge-base-system.md](./knowledge-base-system.md)
 - **BMad Builder Validation Reports**: `src/workflows/testarch/*/validation-report-*.md`
 - **TEA Workflow Examples**: `src/workflows/testarch/*/steps/*.md`
@@ -595,5 +595,5 @@ When running workflows, users see:
 **Status**: Production-ready, 100% LLM compliance achieved
 **Validation**: All 9 workflows score 100% on BMad Builder validation
 **Testing**: All 9 workflows tested with real projects, zero improvisation issues
-**Next Steps**: Implement subprocess patterns (see subprocess-architecture.md)
+**Next Steps**: Implement subagent patterns (see subagent-architecture.md)
 ````

package/docs/explanation/{subprocess-architecture.md → subagent-architecture.md}

@@ -1,9 +1,9 @@
 ---
-title: Subprocess Architecture
+title: Subagent Architecture
 description: Parallel execution pattern for TEA workflows
 ---
 
-# Subprocess Architecture for TEA Workflows
+# Subagent Architecture for TEA Workflows
 
 **Version**: 1.0
 **Date**: 2026-01-27
@@ -13,7 +13,7 @@ description: Parallel execution pattern for TEA workflows
 
 ## Overview
 
-TEA workflows use **subprocess patterns** to parallelize independent tasks, improving performance and maintaining clean separation of concerns. Five workflows benefit from this architecture:
+TEA workflows use **subagent patterns** to parallelize independent tasks, improving performance and maintaining clean separation of concerns. Five workflows benefit from this architecture:
 
 1. **automate** - Parallel test generation (API + E2E)
 2. **atdd** - Parallel failing test generation (API + E2E)
@@ -23,17 +23,17 @@ TEA workflows use **subprocess patterns** to parallelize independent tasks, impr
 
 ---
 
-## Core Subprocess Pattern
+## Core Subagent Pattern
 
 ### Architecture
 
 ```
 Main Workflow (Orchestrator)
 ├── Step 1: Setup & Context Loading
-├── Step 2: Launch Subprocesses
-│   ├── Subprocess A → temp-file-a.json
-│   ├── Subprocess B → temp-file-b.json
-│   ├── Subprocess C → temp-file-c.json
+├── Step 2: Launch Subagents
+│   ├── Subagent A → temp-file-a.json
+│   ├── Subagent B → temp-file-b.json
+│   ├── Subagent C → temp-file-c.json
 │   └── (All run in parallel, isolated 200k containers)
 └── Step 3: Aggregate Results
     ├── Read all temp files
@@ -43,11 +43,11 @@ Main Workflow (Orchestrator)
 
 ### Key Principles
 
-1. **Independence**: Each subprocess is completely independent (no shared state)
-2. **Isolation**: Each subprocess runs in separate 200k context container
-3. **Output Format**: All subprocesses output structured JSON to temp files
+1. **Independence**: Each subagent is completely independent (no shared state)
+2. **Isolation**: Each subagent runs in separate 200k context container
+3. **Output Format**: All subagents output structured JSON to temp files
 4. **Aggregation**: Main workflow reads temp files and synthesizes final output
-5. **Error Handling**: Each subprocess reports success/failure in JSON output
+5. **Error Handling**: Each subagent reports success/failure in JSON output
 
 ---
 
@@ -64,8 +64,8 @@ automate workflow
 ├── Step 1: Analyze codebase & identify features
 ├── Step 2: Load relevant knowledge fragments
 ├── Step 3: Launch parallel test generation
-│   ├── Subprocess A: Generate API tests → /tmp/api-tests-{timestamp}.json
-│   └── Subprocess B: Generate E2E tests → /tmp/e2e-tests-{timestamp}.json
+│   ├── Subagent A: Generate API tests → /tmp/api-tests-{timestamp}.json
+│   └── Subagent B: Generate E2E tests → /tmp/e2e-tests-{timestamp}.json
 ├── Step 4: Aggregate tests
 │   ├── Read API tests JSON
 │   ├── Read E2E tests JSON
@@ -74,7 +74,7 @@ automate workflow
 └── Step 6: Generate DoD summary
 ```
 
-#### Subprocess A: API Tests
+#### Subagent A: API Tests
 
 **Input** (passed via temp file):
 
@@ -106,7 +106,7 @@ automate workflow
 }
 ```
 
-#### Subprocess B: E2E Tests
+#### Subagent B: E2E Tests
 
 **Input** (passed via temp file):
 
@@ -141,7 +141,7 @@ automate workflow
 #### Step 4: Aggregation Logic
 
 ```javascript
-// Read both subprocess outputs
+// Read both subagent outputs
 const apiTests = JSON.parse(fs.readFileSync('/tmp/api-tests-{timestamp}.json', 'utf8'));
 const e2eTests = JSON.parse(fs.readFileSync('/tmp/e2e-tests-{timestamp}.json', 'utf8'));
 
@@ -174,8 +174,8 @@ atdd workflow
 ├── Step 1: Load story acceptance criteria
 ├── Step 2: Load relevant knowledge fragments
 ├── Step 3: Launch parallel test generation
-│   ├── Subprocess A: Generate failing API tests → /tmp/atdd-api-{timestamp}.json
-│   └── Subprocess B: Generate failing E2E tests → /tmp/atdd-e2e-{timestamp}.json
+│   ├── Subagent A: Generate failing API tests → /tmp/atdd-api-{timestamp}.json
+│   └── Subagent B: Generate failing E2E tests → /tmp/atdd-e2e-{timestamp}.json
 ├── Step 4: Aggregate tests
 ├── Step 5: Verify tests fail (red phase)
 └── Step 6: Output ATDD checklist
@@ -183,7 +183,7 @@ atdd workflow
 
 **Key Difference from automate**: Tests must be written to **fail** before implementation exists.
 
-#### Subprocess Outputs
+#### Subagent Outputs
 
 Same JSON structure as automate, but:
 
@@ -202,20 +202,20 @@ Same JSON structure as automate, but:
 test-review workflow
 ├── Step 1: Load test files & context
 ├── Step 2: Launch parallel quality checks
-│   ├── Subprocess A: Determinism check → /tmp/determinism-{timestamp}.json
-│   ├── Subprocess B: Isolation check → /tmp/isolation-{timestamp}.json
-│   ├── Subprocess C: Maintainability check → /tmp/maintainability-{timestamp}.json
-│   ├── Subprocess D: Coverage check → /tmp/coverage-{timestamp}.json
-│   └── Subprocess E: Performance check → /tmp/performance-{timestamp}.json
+│   ├── Subagent A: Determinism check → /tmp/determinism-{timestamp}.json
+│   ├── Subagent B: Isolation check → /tmp/isolation-{timestamp}.json
+│   ├── Subagent C: Maintainability check → /tmp/maintainability-{timestamp}.json
+│   ├── Subagent D: Coverage check → /tmp/coverage-{timestamp}.json
+│   └── Subagent E: Performance check → /tmp/performance-{timestamp}.json
 └── Step 3: Aggregate findings
     ├── Calculate weighted score (0-100)
     ├── Synthesize violations
     └── Generate review report with suggestions
 ```
 
-#### Subprocess Output Format
+#### Subagent Output Format
 
-Each quality dimension subprocess outputs:
+Each quality dimension subagent outputs:
 
 ```json
 {
@@ -281,19 +281,19 @@ const report = {
 nfr-assess workflow
 ├── Step 1: Load system context
 ├── Step 2: Launch parallel NFR assessments
-│   ├── Subprocess A: Security assessment → /tmp/nfr-security-{timestamp}.json
-│   ├── Subprocess B: Performance assessment → /tmp/nfr-performance-{timestamp}.json
-│   ├── Subprocess C: Reliability assessment → /tmp/nfr-reliability-{timestamp}.json
-│   └── Subprocess D: Scalability assessment → /tmp/nfr-scalability-{timestamp}.json
+│   ├── Subagent A: Security assessment → /tmp/nfr-security-{timestamp}.json
+│   ├── Subagent B: Performance assessment → /tmp/nfr-performance-{timestamp}.json
+│   ├── Subagent C: Reliability assessment → /tmp/nfr-reliability-{timestamp}.json
+│   └── Subagent D: Scalability assessment → /tmp/nfr-scalability-{timestamp}.json
 └── Step 3: Aggregate NFR report
     ├── Synthesize domain assessments
     ├── Identify cross-domain risks
     └── Generate compliance documentation
 ```
 
-#### Subprocess Output Format
+#### Subagent Output Format
 
-Each NFR domain subprocess outputs:
+Each NFR domain subagent outputs:
 
 ```json
 {
@@ -377,7 +377,7 @@ trace workflow
     └── Step 7: Generate gate decision (PASS/CONCERNS/FAIL/WAIVED)
 ```
 
-**Note**: This isn't parallel subprocesses, but subprocess-like **phase separation** where Phase 2 depends on Phase 1 output.
+**Note**: This isn't parallel subagents, but subagent-like **phase separation** where Phase 2 depends on Phase 1 output.
 
 #### Phase 1 Output Format
 
@@ -446,7 +446,7 @@ const report = {
 **Naming Convention**:
 
 ```
-/tmp/{workflow}-{subprocess-name}-{timestamp}.json
+/tmp/{workflow}-{subagent-name}-{timestamp}.json
 ```
 
 **Examples**:
@@ -463,7 +463,7 @@ const report = {
 
 ### Error Handling
 
-Each subprocess JSON output must include:
+Each subagent JSON output must include:
 
 ```json
 {
@@ -475,51 +475,53 @@ Each subprocess JSON output must include:
 
 Main workflow aggregation step must:
 
-1. Check `success` field for each subprocess
-2. If any subprocess failed, aggregate error messages
-3. Decide whether to continue (partial success) or fail (critical subprocess failed)
+1. Check `success` field for each subagent
+2. If any subagent failed, aggregate error messages
+3. Decide whether to continue (partial success) or fail (critical subagent failed)
 
 ### Performance Considerations
 
-**Subprocess Isolation**:
+**Subagent Isolation**:
 
-- Each subprocess runs in separate 200k context container
+- Each subagent runs in separate 200k context container
 - No shared memory or state
 - Communication only via JSON files
 
 **Parallelization**:
 
-- Use Claude Code's subprocess/agent launching capabilities
+- Resolve execution mode via config (`tea_execution_mode`, `tea_capability_probe`)
+- Probe runtime support for agent-team and subagent launch before dispatch
+- Fallback order in `auto` mode: `agent-team` → `subagent` → `sequential`
 - Ensure temp file paths are unique (timestamp-based)
-- Implement proper synchronization (wait for all subprocesses to complete)
+- Implement proper synchronization (wait for all subagents to complete)
 
 ---
 
-## Testing Subprocess Workflows
+## Testing Subagent Workflows
 
 ### Test Checklist
 
-For each workflow with subprocesses:
+For each workflow with subagents:
 
-- [ ] **Unit Test**: Test each subprocess in isolation
+- [ ] **Unit Test**: Test each subagent in isolation
   - Provide mock input JSON
   - Verify output JSON structure
   - Test error scenarios
 
 - [ ] **Integration Test**: Test full workflow
-  - Launch all subprocesses
+  - Launch all subagents
   - Verify parallel execution
   - Verify aggregation logic
   - Test with real project data
 
 - [ ] **Performance Test**: Measure speedup
   - Benchmark sequential vs parallel
-  - Measure subprocess overhead
+  - Measure subagent overhead
   - Verify memory usage acceptable
 
 - [ ] **Error Handling Test**: Test failure scenarios
-  - One subprocess fails
-  - Multiple subprocesses fail
+  - One subagent fails
+  - Multiple subagents fail
   - Temp file read/write errors
   - Timeout scenarios
 
@@ -547,32 +549,32 @@ For each workflow with subprocesses:
 
 ## Documentation for Users
 
-Users don't need to know about subprocess implementation details, but they should know:
+Users don't need to know about subagent implementation details, but they should know:
 
 1. **Performance**: Certain workflows are optimized for parallel execution
 2. **Temp Files**: Workflows create temporary files during execution (cleaned up automatically)
-3. **Progress**: When running workflows, they may see multiple "subprocess" indicators
+3. **Progress**: When running workflows, they may see multiple "subagent" indicators
 4. **Debugging**: If workflow fails, temp files may be preserved for troubleshooting
 
 ---
 
 ## Future Enhancements
 
-1. **Subprocess Pooling**: Reuse subprocess containers for multiple operations
+1. **Subagent Pooling**: Reuse subagent containers for multiple operations
 2. **Adaptive Parallelization**: Dynamically decide whether to parallelize based on workload
-3. **Progress Reporting**: Real-time progress updates from each subprocess
-4. **Caching**: Cache subprocess outputs for identical inputs (idempotent operations)
-5. **Distributed Execution**: Run subprocesses on different machines for massive parallelization
+3. **Progress Reporting**: Real-time progress updates from each subagent
+4. **Caching**: Cache subagent outputs for identical inputs (idempotent operations)
+5. **Distributed Execution**: Run subagents on different machines for massive parallelization
 
 ---
 
 ## References
 
-- BMad Builder subprocess examples: `_bmad/bmb/workflows/*/subprocess-*.md`
-- Claude Code agent/subprocess documentation
+- BMad Builder subagent examples: `_bmad/bmb/workflows/*/subagent-*.md`
+- Runtime-specific agent/subagent documentation (Codex, Claude Code, etc.)
 - TEA Workflow validation reports (proof of 100% compliance)
 
 ---
 
 **Status**: Ready for implementation across 5 workflows
-**Next Steps**: Implement subprocess patterns in workflow step files, test, document
+**Next Steps**: Implement subagent patterns in workflow step files, test, document