sdlc-workflow 1.2.2 → 1.2.6

package/bin/cli.js

@@ -254,14 +254,16 @@ globs: docs/sdlc/**/*, **/*.md
 
 **On idea/feature request:** Trigger full pipeline (PO → … → Deploy). One role per phase; run phases in sequence. (Single agent = simulate by switching role each phase.) See docs/sdlc/SDLC-WORKFLOW.md and docs/sdlc/agents/.
 
+**Memory requirement:** Before executing any new action, recall relevant memories (project context, user preferences, past decisions) to ensure continuity and avoid repeating mistakes.
+
 1. **PO** — PRD, user stories → docs/sdlc/po/{epic-slug}/ (one folder per epic)
 2. **Business BA** — FRS, process flows → docs/sdlc/ba/business/{epic-slug}/ (one folder per epic)
 3. **Design (if app/web)** — Design specs + wireframes → docs/sdlc/design/{epic-slug}/; **PO + BA review** → loop until approved
 4. **Architect** — ADRs, diagrams → docs/sdlc/architecture/
 5. **Technical BA** — API specs, team breakdown → docs/sdlc/ba/technical/
 6. **QE (docs)** — Test plan, test cases → docs/sdlc/qe/{epic-slug}/ (one folder per epic)
-7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead + implementation roles → docs/sdlc/dev/{role}/
-8. **QE (testing + UAT)** — QE Lead + Senior QE + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/
+7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead (highest model: planning, logic, review) + implementation roles (cost-efficient model: code execution) → docs/sdlc/dev/{role}/
+8. **QE (testing + UAT)** — QE Lead (highest model: strategy, review) + Senior QE (cost-efficient model: test execution) + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/
 9. **Security** — Audit security risk → docs/sdlc/security/
 10. **Principle Engineer** — Audit logic, architecture → docs/sdlc/principle-engineer/
 11. **Deploy** — Docker Compose + K8s → docs/sdlc/deploy/ (after Security + PE sign-off; fix → retest → re-audit loop until 0 issues)
@@ -283,8 +285,9 @@ Sequential workflow; **each role runs as a sub-agent**. Each phase produces docs
 ## Trigger and orchestration (mandatory)
 
 **When the user sends an idea, feature request, or new requirement:**
-1. **Trigger the pipeline** and run it **continuously through deployment** (Phase 1 → 2 → … → 7).
-2. **One role per phase.** For each phase, act **only** as that role (e.g. only PO in phase 1, only Business BA in phase 2). Produce that phase's outputs into the correct folder, then **continue to the next phase** without waiting for the user.
+1. **Recall memory** — Before executing any new action, recall relevant memories (project context, user preferences, past decisions) to ensure continuity and avoid repeating mistakes.
+2. **Trigger the pipeline** and run it **continuously through deployment** (Phase 1 → 2 → … → 7).
+3. **One role per phase.** For each phase, act **only** as that role (e.g. only PO in phase 1, only Business BA in phase 2). Produce that phase's outputs into the correct folder, then **continue to the next phase** without waiting for the user.
 3. **Run in order:** PO → Business BA → **Design (if app/web, PO+BA review loop)** → Architect → Technical BA → QE (docs) → Dev → QE (testing + UAT) → **QE bug-fix loop until 0 bugs → Security + Principle Engineer audit → fix → retest → re-audit loop until 0 issues** → Deploy → Maintenance. Do not stop after one phase unless the user explicitly asks to stop.
 
 **Note:** In Cursor and similar tools there is a single agent per conversation. "Sub-agent" means **one role per phase** — the same agent must adopt exactly one role per phase and run phases in sequence (do not mix roles in one step). If the platform later supports spawning separate agents per phase, use that; otherwise this single agent simulates the pipeline by switching role each phase.
@@ -357,8 +360,8 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 **Trigger**: After docs are done (Technical BA + QE docs). **Dev runs implementation immediately.**
 
 **Roles** (vary by project — use only what applies; see \`docs/sdlc/dev/implementation-roles.template.md\`). All implementation roles are **Senior (10+ yrs)**:
-- **Tech Lead (15+ yrs)**: Tech stack, review & merge. Docs: \`docs/sdlc/dev/tech-lead/\`
-- **Senior Developer (10+ yrs)**: Implement per spec (generic). Docs: \`docs/sdlc/dev/senior-developer/\`
+- **Tech Lead (15+ yrs)** — **highest model** (e.g. Opus): Planning, logic analysis, architecture decisions, tech stack, code review & merge. Docs: \`docs/sdlc/dev/tech-lead/\`
+- **Senior Developer (10+ yrs)** — **cost-efficient model** (e.g. Haiku): Implement per Tech Lead's spec. Docs: \`docs/sdlc/dev/senior-developer/\`
 - **Senior Frontend (10+ yrs)**: Web UI. Docs: \`docs/sdlc/dev/frontend/\`
 - **Senior Backend (10+ yrs)**: API, services. Docs: \`docs/sdlc/dev/backend/\`
 - **Senior Mobile (10+ yrs)**: iOS/Android/cross-platform. Docs: \`docs/sdlc/dev/mobile/\`
@@ -366,7 +369,9 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 - **Senior Data/ML (10+ yrs)**: ETL, models. Docs: \`docs/sdlc/dev/data-ml/\`
 - **Senior Platform (10+ yrs)**: Infra, CI/CD. Docs: \`docs/sdlc/dev/platform/\`
 
-**Requirements**: Unit Test coverage **≥ 90%** (TDD/BDD); Clean Code, SOLID, DRY, KISS, SoC, POLS.
+**Model optimization**: Tech Lead uses the **highest-tier model** (e.g. Claude Opus) for planning, architecture decisions, logic analysis, and code review. Implementation roles use a **cost-efficient model** (e.g. Claude Haiku) to execute code from Tech Lead's specs. This maximizes quality on critical thinking while reducing cost on execution.
+
+**Requirements**: Unit Test coverage **100%** (TDD/BDD); Clean Code, SOLID, DRY, KISS, SoC, POLS.
 
 **Output**: Code + unit tests. **Handoff to QE (testing + UAT).**
 
@@ -376,8 +381,8 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 **Role**: Write and run **automation tests** + **UAT**, sign-off.
 
 **Roles**:
-- **QE Lead (15+ yrs automation)**: Test strategy, framework choice, automation architecture, review test code. Output per epic: \`docs/sdlc/qe/{epic-slug}/\`
-- **Senior QE (10+ yrs)**: Write automation tests per QE Lead's strategy. Output per epic: \`docs/sdlc/qe/{epic-slug}/\` (e.g. automation/ or test files there)
+- **QE Lead (15+ yrs automation)** — **highest model** (e.g. Opus): Test strategy, framework choice, automation architecture, review test code. Output per epic: \`docs/sdlc/qe/{epic-slug}/\`
+- **Senior QE (10+ yrs)** — **cost-efficient model** (e.g. Haiku): Write automation tests per QE Lead's strategy. Output per epic: \`docs/sdlc/qe/{epic-slug}/\` (e.g. automation/ or test files there)
 - **UAT**: Verify implementation against original user stories and acceptance criteria from PO.
 
 **Bug-fix loop**: If QE finds bugs or test failures → **Dev fixes** → **QE retests**. **Repeat until all tests pass and UAT approved (0 open bugs).** Only then → **Handoff to Security + Principle Engineer.**
@@ -408,7 +413,7 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 | 4 | Architect | ADRs, system diagrams, security by design |
 | 5 | Technical BA | API specs, tech breakdown |
 | 6 | QE (docs) | Test plan, test cases |
-| 7 | Dev | Code, unit tests (≥90%), security shift-left |
+| 7 | Dev | Code, unit tests (100%), security shift-left |
 | 8 | QE (testing + UAT) | Automation, UAT; **bug-fix loop** (QE finds bugs → Dev fix → QE retest) until 0 open bugs |
 | 9 | Security + PE | Audit; **fix → retest → re-audit loop** (Dev fix → QE retest → re-audit) until 0 issues; sign-off → Deploy |
 | 10 | Deploy | Docker Compose + K8s |
@@ -447,13 +452,13 @@ Design specs (Markdown) + optional HTML wireframes from idea + PO + BA (before A
 TC-001: [Scenario] — Precondition, Steps, Expected, Links to AC
 
 ## QE Team (one folder per epic: qe/{epic-slug}/)
-- QE Lead (15+ yrs automation): test strategy, framework, automation architecture, review → docs/sdlc/qe/{epic-slug}/
-- Senior QE (10+ yrs): write automation tests → docs/sdlc/qe/{epic-slug}/
+- QE Lead (15+ yrs automation) — **highest model** (e.g. Opus): test strategy, framework, automation architecture, review → docs/sdlc/qe/{epic-slug}/
+- Senior QE (10+ yrs) — **cost-efficient model** (e.g. Haiku): write automation tests per QE Lead's strategy → docs/sdlc/qe/{epic-slug}/
 
 ## Dev Team
-- Tech Lead (15+ yrs): tech stack, review & merge → docs/sdlc/dev/tech-lead/
-- Senior Dev (10+ yrs): implement, Unit Test ≥90% → docs/sdlc/dev/senior-developer/
-- By project (all Senior 10+ yrs): Senior Frontend, Backend, Mobile, Embedded, Data/ML, Platform → docs/sdlc/dev/{role}/
+- Tech Lead (15+ yrs) — **highest model** (e.g. Opus): planning, logic, architecture decisions, code review → docs/sdlc/dev/tech-lead/
+- Senior Dev (10+ yrs) — **cost-efficient model** (e.g. Haiku): execute code from Tech Lead specs, Unit Test 100% → docs/sdlc/dev/senior-developer/
+- By project (all Senior 10+ yrs, cost-efficient model): Senior Frontend, Backend, Mobile, Embedded, Data/ML, Platform → docs/sdlc/dev/{role}/
 
 ## Security + Principle Engineer (after implementation)
 - Security team: audit security risk → docs/sdlc/security/
@@ -471,6 +476,8 @@ const AGENTS_MD_CONTENT = `## SDLC Workflow
 
 **Trigger:** When the user sends an **idea**, **feature request**, or **requirement**, run the full pipeline (Phase 1 → 7) in sequence. One role (sub-agent) per phase; produce outputs then continue to the next. Do not stop after one phase until deployment unless the user asks to stop.
 
+**Memory requirement:** Before executing any new action, recall relevant memories (project context, user preferences, past decisions) to ensure continuity and avoid repeating mistakes.
+
 When working on requirements, features, or handoffs, follow these phases:
 
 1. **PO** — PRD, user stories → docs/sdlc/po/{epic-slug}/ (one folder per epic)
@@ -479,8 +486,8 @@ When working on requirements, features, or handoffs, follow these phases:
 4. **Architect** — ADRs, diagrams → docs/sdlc/architecture/
 5. **Technical BA** — API specs, team breakdown → docs/sdlc/ba/technical/
 6. **QE (docs)** — Test plan, test cases → docs/sdlc/qe/{epic-slug}/ (one folder per epic)
-7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead + Senior Dev → docs/sdlc/dev/{role}/
-8. **QE (testing + UAT)** — QE Lead + Senior QE + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/ (same folder per epic)
+7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead (highest model: planning, logic, review) + Senior Dev (cost-efficient model: code execution) → docs/sdlc/dev/{role}/
+8. **QE (testing + UAT)** — QE Lead (highest model: strategy, review) + Senior QE (cost-efficient model: test execution) + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/ (same folder per epic)
 9. **Security + Principle Engineer** — Security + logic audit; **fix → retest → re-audit loop** (Dev fixes → QE retests → re-audit) until 0 issues; sign-off before Deploy
 10. **Deploy** — Docker Compose + K8s → docs/sdlc/deploy/
 11. **Maintenance** — Monitoring, bug fixes, patches, dependency updates → docs/sdlc/maintenance/
@@ -492,14 +499,16 @@ const CLAUDE_SDLC_CONTENT = `## SDLC Workflow
 
 **Trigger on idea:** When the user sends an idea, feature request, or requirement, run the pipeline continuously: Phase 1 (PO) → 2 → … → Deploy → Maintenance. One role per phase (single agent = switch role each phase). Do not stop after one phase unless the user asks.
 
+**Memory requirement:** Before executing any new action, recall relevant memories (project context, user preferences, past decisions) to ensure continuity and avoid repeating mistakes.
+
 1. **PO** — PRD, user stories, feasibility assessment → docs/sdlc/po/{epic-slug}/ (one folder per epic)
 2. **Business BA** — FRS, NFR, process flows → docs/sdlc/ba/business/{epic-slug}/ (one folder per epic)
 3. **Design (if app/web)** — Design specs + wireframes (**Anti AI**: no AI-looking designs) → docs/sdlc/design/{epic-slug}/; **PO + BA review** until approved
 4. **Architect** — ADRs, diagrams, security by design, engineering principles (SOLID, DRY, KISS, CQRS, Zero Trust, EDA, HA) → docs/sdlc/architecture/
 5. **Technical BA** — API specs, team breakdown → docs/sdlc/ba/technical/
 6. **QE (docs)** — Test plan, test cases → docs/sdlc/qe/{epic-slug}/ (one folder per epic)
-7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead + Senior Dev → docs/sdlc/dev/{role}/. Clean Code, SOLID, DRY, KISS, TDD/BDD. Security shift-left: OWASP checks, dependency audit in CI
-8. **QE (testing + UAT)** — QE Lead + Senior QE + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/ (same folder per epic)
+7. **Dev** — After docs phase → **run implementation immediately**. Tech Lead (highest model: planning, logic, review) + Senior Dev (cost-efficient model: code execution) → docs/sdlc/dev/{role}/. Clean Code, SOLID, DRY, KISS, TDD/BDD. Security shift-left: OWASP checks, dependency audit in CI
+8. **QE (testing + UAT)** — QE Lead (highest model: strategy, review) + Senior QE (cost-efficient model: test execution) + UAT; **bug-fix loop** (bugs → Dev fix → QE retest) until 0 bugs → docs/sdlc/qe/{epic-slug}/ (same folder per epic)
 9. **Security + Principle Engineer** — Security + logic audit; **fix → retest → re-audit loop** (Dev fixes → QE retests → re-audit) until 0 issues; sign-off before Deploy
 10. **Deploy** — Docker Compose + K8s → docs/sdlc/deploy/
 11. **Maintenance** — Monitoring, bug fixes, patches, dependency updates → docs/sdlc/maintenance/
@@ -515,6 +524,7 @@ For Cursor, see .cursor/rules/sdlc-workflow.mdc
 ## Trigger and orchestration
 
 - **When the user sends an idea, feature request, or requirement:** Start the pipeline and run it **continuously through deployment** (Phase 1 → 2 → … → 7). Do not handle everything in one main-agent response.
+- **Memory requirement:** Before executing any new action, recall relevant memories (project context, user preferences, past decisions) to ensure continuity and avoid repeating mistakes.
 - **One role per phase:** Execute each phase as that role only; write artifacts to the right folder; then continue to the next phase. In Cursor there is one agent — it simulates the pipeline by adopting one role per phase in sequence.
 - **Do not stop** after PO or any single phase unless the user explicitly asks to stop. Run through to Deploy.
 
@@ -535,7 +545,7 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 | 4 | Architect | ADRs, system diagrams, security by design |
 | 5 | Technical BA | API specs, tech breakdown |
 | 6 | QE (docs) | Test plan, test cases |
-| 7 | Dev | Code, unit tests (≥90%), security shift-left |
+| 7 | Dev | Code, unit tests (100%), security shift-left |
 | 8 | QE (testing + UAT) | Automation, UAT; **bug-fix loop** (QE finds bugs → Dev fix → QE retest) until 0 open bugs |
 | 9 | Security + PE | Audit; **fix → retest → re-audit loop** (Dev fix → QE retest → re-audit) until 0 issues; sign-off → Deploy |
 | 10 | Deploy | Docker Compose + K8s |
@@ -575,7 +585,7 @@ User Request → PO → Business BA → Design (if app/web) → Architect → Te
 ### Phase 5b: Dev Teams
 - **Tech Lead (15+ yrs)**: Tech stack, review & merge, **security review (Shift Left)**: OWASP check, dependency audit, SAST in CI. Output: \`docs/sdlc/dev/tech-lead/\`
 - **Implementation roles** (all Senior 10+ yrs; use only what applies): Senior Dev, Senior Frontend, Senior Backend, Senior Mobile, Senior Embedded, Senior Data/ML, Senior Platform → \`docs/sdlc/dev/{role}/\`. See \`implementation-roles.template.md\`.
-- **Requirement**: Unit Test coverage **≥ 90%** (TDD/BDD); Clean Code, SOLID, DRY, KISS, SoC, POLS; security practices (input validation, no hardcoded secrets)
+- **Requirement**: Unit Test coverage **100%** (TDD/BDD); Clean Code, SOLID, DRY, KISS, SoC, POLS; security practices (input validation, no hardcoded secrets)
 - **Then**: QE starts testing phase
 
 ### Phase 6: QE (Testing — automation + UAT) → bug-fix loop
@@ -665,7 +675,7 @@ Every role in the SDLC runs as a **sub-agent**. Each phase is assigned to a corr
 | Technical BA | technical-ba | docs/sdlc/architecture/ + design (if any) | docs/sdlc/ba/technical/ |
 | QE (docs) | qe-docs | docs/sdlc/ba/technical/ (+ design if any) | docs/sdlc/qe/{epic-slug}/ (one folder per epic) |
 | Tech Lead | tech-lead | Technical spec | Review, merge, docs/sdlc/dev/tech-lead/ |
-| Senior Dev | senior-dev | Spec + test plan | After docs → run implementation immediately. Code, unit tests (≥90%) |
+| Senior Dev | senior-dev | Spec + test plan | After docs → run implementation immediately. Code, unit tests (100%) |
 | Senior Frontend | frontend | UI spec, API contract | Web UI, docs/sdlc/dev/frontend/ |
 | Senior Backend | backend | API spec, DB schema | API, services, docs/sdlc/dev/backend/ |
 | Senior Mobile | mobile | API contract, design | App (iOS/Android), docs/sdlc/dev/mobile/ |
@@ -1142,6 +1152,8 @@ Use test-case.template.md for test cases.
 
 const QE_LEAD_README = `# QE Lead (15+ years exp in test automation)
 
+> **Model**: Use the **highest-tier model** (e.g. Claude Opus) for this role. QE Lead handles test strategy, framework decisions, automation architecture, and review — tasks that require maximum reasoning capability.
+
 **Profile**: 15+ years of experience in test automation, test strategy, and quality engineering. Owns test automation strategy, framework selection, and quality gates across the project.
 
 **Responsibilities**:
@@ -1165,6 +1177,8 @@ const QE_LEAD_README = `# QE Lead (15+ years exp in test automation)
 
 const QE_SENIOR_README = `# Senior QE (10+ years exp)
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute test implementation from QE Lead's strategy and specs.
+
 **Responsibilities**:
 - Write automation tests per test plan
 - Implement E2E, integration, regression tests
@@ -1289,8 +1303,11 @@ App
 
 const DEV_TECH_LEAD_README = `# Tech Lead (15+ years exp)
 
+> **Model**: Use the **highest-tier model** (e.g. Claude Opus) for this role. Tech Lead handles planning, logic analysis, architecture decisions, and code review — tasks that require maximum reasoning capability.
+
 **Responsibilities**:
 - Decide tech stack, frameworks, libraries
+- Define implementation plan, critical logic, and technical specs for implementation roles
 - Review and merge code
 - Ensure architecture alignment
 
@@ -1298,6 +1315,7 @@ const DEV_TECH_LEAD_README = `# Tech Lead (15+ years exp)
 
 - [ ] **Read architecture and Technical BA spec**: ADRs, API spec, team breakdown
 - [ ] **Tech stack decision**: Languages, frameworks, libraries; document in ADR
+- [ ] **Implementation plan**: Define step-by-step tasks, critical logic, edge cases, and technical specs that implementation roles will execute
 - [ ] **Project setup**: Repo structure, tooling, lint, format, CI baseline
 - [ ] **Code review**: Architecture alignment, patterns, test coverage, security
 - [ ] **Security review (Shift Left)**: OWASP Top 10 check, input validation, auth/authz, secrets not hardcoded, dependency audit (npm audit / pip audit / etc.), SAST scan in CI
@@ -1309,9 +1327,11 @@ const DEV_TECH_LEAD_README = `# Tech Lead (15+ years exp)
 
 const DEV_SENIOR_README = `# Senior Developer (10+ years exp)
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku) for this role. Implementation is executed from Tech Lead's detailed specs — optimizing cost while maintaining quality through clear instructions.
+
 **Responsibilities**:
-- Implement features per Technical BA spec
-- Write code with Unit Test coverage **≥ 90%**
+- Implement features per Tech Lead's implementation plan and Technical BA spec
+- Write code with Unit Test coverage **100%**
 - Follow Tech Lead's tech decisions
 
 ## Detailed tasks
@@ -1319,7 +1339,7 @@ const DEV_SENIOR_README = `# Senior Developer (10+ years exp)
 - [ ] **Read Technical BA spec**: API, schema, team breakdown
 - [ ] **Implement feature**: Code per spec; follow Tech Lead stack. Adhere to: Clean Code, SOLID, DRY, KISS, SoC, LoD, CoI, GRASP, POLS
 - [ ] **Security practices (Shift Left)**: Input validation, parameterized queries, no hardcoded secrets, follow Architect's security ADR
-- [ ] **Unit tests (TDD/BDD)**: Coverage **≥ 90%**; TDD (write tests first) or BDD (behavior specs); edge cases, error paths, BSR (Behavior-Structure-Result)
+- [ ] **Unit tests (TDD/BDD)**: Coverage **100%**; TDD (write tests first) or BDD (behavior specs); edge cases, error paths, BSR (Behavior-Structure-Result)
 - [ ] **PR**: Lint, tests, security scan passing; request Tech Lead review
 - [ ] **Output**: Code + implementation notes in \`dev/senior-developer/\`
 `;
@@ -1328,6 +1348,15 @@ const DEV_IMPLEMENTATION_ROLES_TEMPLATE = `# Implementation roles by project typ
 
 Use only the roles that apply. Remove or ignore the rest. Tech Lead is cross-cutting; add discipline roles as needed.
 
+## Model optimization strategy
+
+| Role | Model tier | Why |
+|------|-----------|-----|
+| Tech Lead | **Highest** (e.g. Opus) | Planning, logic analysis, architecture decisions, code review |
+| All implementation roles | **Cost-efficient** (e.g. Haiku) | Execute code from Tech Lead's detailed specs |
+
+Tech Lead defines all critical steps, logic, and specs first → implementation roles execute them. This maximizes quality on thinking while reducing cost on execution.
+
 ## By project type
 
 | Project type        | Roles to use (all Senior 10+ except Tech Lead 15+) |
@@ -1356,9 +1385,11 @@ Use only the roles that apply. Remove or ignore the rest. Tech Lead is cross-cut
 
 const DEV_FRONTEND_README = `# Senior Frontend (10+ years exp) — Web UI
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement web UI per design and API contract
-- Unit Test coverage **≥ 90%**
+- Unit Test coverage **100%**
 - Follow Tech Lead's stack (e.g. React, Vue, Angular)
 
 ## Detailed tasks
@@ -1366,16 +1397,18 @@ const DEV_FRONTEND_README = `# Senior Frontend (10+ years exp) — Web UI
 - [ ] **Read Technical BA spec**: API contract, design (if any)
 - [ ] **Implement components/screens**: Per spec; responsive, accessible
 - [ ] **API integration**: Fetch, state, error handling
-- [ ] **Unit tests (TDD/BDD)**: Components, hooks, utils — coverage **≥ 90%**; follow Clean Code, SOLID, DRY, KISS
+- [ ] **Unit tests (TDD/BDD)**: Components, hooks, utils — coverage **100%**; follow Clean Code, SOLID, DRY, KISS
 - [ ] **PR**: Lint, tests; Tech Lead review
 - [ ] **Output**: Code + component/integration docs in \`dev/frontend/\`
 `;
 
 const DEV_BACKEND_README = `# Senior Backend (10+ years exp) — API, services
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement API, services, DB layer per Technical BA spec
-- Unit Test coverage **≥ 90%**
+- Unit Test coverage **100%**
 - Follow Tech Lead's stack
 
 ## Detailed tasks
@@ -1383,16 +1416,18 @@ const DEV_BACKEND_README = `# Senior Backend (10+ years exp) — API, services
 - [ ] **Read Technical BA spec**: API spec, DB schema
 - [ ] **Implement endpoints**: Per spec; validation, auth, error responses
 - [ ] **Implement DB layer**: Migrations, queries, transactions
-- [ ] **Unit tests (TDD/BDD)**: Services, controllers, DB — coverage **≥ 90%**; follow Clean Code, SOLID, DRY, KISS
+- [ ] **Unit tests (TDD/BDD)**: Services, controllers, DB — coverage **100%**; follow Clean Code, SOLID, DRY, KISS
 - [ ] **PR**: Lint, tests; Tech Lead review
 - [ ] **Output**: Code + API/DB implementation notes in \`dev/backend/\`
 `;
 
 const DEV_MOBILE_README = `# Senior Mobile (10+ years exp) — iOS / Android / cross-platform
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement app UI and API integration per spec
-- Unit Test coverage **≥ 90%**
+- Unit Test coverage **100%**
 - Follow Tech Lead's stack (e.g. React Native, Flutter, native)
 
 ## Detailed tasks
@@ -1400,13 +1435,15 @@ const DEV_MOBILE_README = `# Senior Mobile (10+ years exp) — iOS / Android / c
 - [ ] **Read Technical BA spec**: API contract, screen flows
 - [ ] **Implement screens/modules**: Per spec; platform parity (iOS/Android)
 - [ ] **API integration**: Auth, state, offline (if required)
-- [ ] **Unit tests (TDD/BDD)**: Components, logic — coverage **≥ 90%**; follow Clean Code, SOLID, DRY, KISS
+- [ ] **Unit tests (TDD/BDD)**: Components, logic — coverage **100%**; follow Clean Code, SOLID, DRY, KISS
 - [ ] **PR**: Lint, tests; Tech Lead review
 - [ ] **Output**: Code + screen/module docs in \`dev/mobile/\`
 `;
 
 const DEV_EMBEDDED_README = `# Senior Embedded (10+ years exp) — firmware, IoT
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement firmware, drivers, hardware interfaces per spec
 - Tests as appropriate for target (unit, HW-in-loop)
@@ -1423,6 +1460,8 @@ const DEV_EMBEDDED_README = `# Senior Embedded (10+ years exp) — firmware, IoT
 
 const DEV_DATA_ML_README = `# Senior Data/ML (10+ years exp)
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement ETL, models, analytics pipelines per spec
 - Tests and validation for data and model quality
@@ -1440,6 +1479,8 @@ const DEV_DATA_ML_README = `# Senior Data/ML (10+ years exp)
 
 const DEV_PLATFORM_README = `# Senior Platform (10+ years exp) — infra, CI/CD
 
+> **Model**: Use a **cost-efficient model** (e.g. Claude Haiku). Execute from Tech Lead's specs.
+
 **Responsibilities**:
 - Implement CI/CD, infra as code, observability per spec
 - Follow Tech Lead's stack and security requirements

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdlc-workflow",
-  "version": "1.2.2",
+  "version": "1.2.6",
   "description": "Scaffold SDLC workflow docs and templates for Cursor, Claude, and dev teams",
   "type": "module",
   "bin": {