@daochild/agents-config 1.0.7 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (65) hide show
  1. package/.agents/.gitkeep +0 -0
  2. package/.agents/agents/.gitkeep +0 -0
  3. package/.agents/agents/sdlc-analyst.md +30 -0
  4. package/.agents/agents/sdlc-architect.md +32 -0
  5. package/.agents/agents/sdlc-auditor.md +45 -0
  6. package/.agents/agents/sdlc-dev.md +34 -0
  7. package/.agents/agents/sdlc-orchestrator.md +70 -0
  8. package/.agents/agents/sdlc-pm.md +33 -0
  9. package/.agents/agents/sdlc-qa.md +34 -0
  10. package/.agents/agents/sdlc-reviewer.md +32 -0
  11. package/.agents/agents/sdlc-security.md +37 -0
  12. package/.agents/agents/sdlc-sm.md +32 -0
  13. package/.agents/commands/.gitkeep +0 -0
  14. package/.agents/commands/sdlc.md +18 -0
  15. package/.agents/rules/.gitkeep +0 -0
  16. package/.agents/rules/sdlc-gates.md +45 -0
  17. package/.agents/skills/.gitkeep +0 -0
  18. package/.agents/skills/agents-config/SKILL.md +32 -0
  19. package/.agents/skills/sdlc-regulatory/SKILL.md +515 -0
  20. package/.claude/agents/sdlc-analyst.md +29 -0
  21. package/.claude/agents/sdlc-architect.md +31 -0
  22. package/.claude/agents/sdlc-auditor.md +44 -0
  23. package/.claude/agents/sdlc-dev.md +33 -0
  24. package/.claude/agents/sdlc-orchestrator.md +69 -0
  25. package/.claude/agents/sdlc-pm.md +32 -0
  26. package/.claude/agents/sdlc-qa.md +33 -0
  27. package/.claude/agents/sdlc-reviewer.md +31 -0
  28. package/.claude/agents/sdlc-security.md +36 -0
  29. package/.claude/agents/sdlc-sm.md +31 -0
  30. package/.claude/commands/sdlc.md +18 -0
  31. package/.claude/rules/sdlc-gates.md +45 -0
  32. package/.claude/skills/sdlc-regulatory/SKILL.md +515 -0
  33. package/.opencode/AGENTS.md +11 -0
  34. package/.opencode/agent/sdlc-analyst.md +30 -0
  35. package/.opencode/agent/sdlc-architect.md +32 -0
  36. package/.opencode/agent/sdlc-auditor.md +45 -0
  37. package/.opencode/agent/sdlc-dev.md +34 -0
  38. package/.opencode/agent/sdlc-orchestrator.md +70 -0
  39. package/.opencode/agent/sdlc-pm.md +33 -0
  40. package/.opencode/agent/sdlc-qa.md +34 -0
  41. package/.opencode/agent/sdlc-reviewer.md +32 -0
  42. package/.opencode/agent/sdlc-security.md +37 -0
  43. package/.opencode/agent/sdlc-sm.md +32 -0
  44. package/.opencode/command/sdlc.md +18 -0
  45. package/.opencode/skill/sdlc-regulatory/SKILL.md +515 -0
  46. package/AGENTS.md +174 -86
  47. package/ARCHITECTURE.md +143 -0
  48. package/CONTRIBUTING.md +90 -0
  49. package/README.md +53 -24
  50. package/SECURITY.md +79 -0
  51. package/docs/BUSINESS_LOGIC.md +63 -0
  52. package/docs/IMPLEMENTATION.md +59 -0
  53. package/docs/adr/0001-triple-mirror.md +81 -0
  54. package/docs/adr/0002-zero-edit-install.md +237 -0
  55. package/docs/api/.gitkeep +0 -0
  56. package/docs/architecture/.gitkeep +0 -0
  57. package/docs/architecture/zero-edit-install-architecture.md +306 -0
  58. package/docs/business/zero-edit-install-analysis.md +295 -0
  59. package/docs/business/zero-edit-install-prd.md +404 -0
  60. package/docs/database/.gitkeep +0 -0
  61. package/docs/stories/zero-edit-install-assumptions.md +80 -0
  62. package/docs/stories/zero-edit-install-stories.md +256 -0
  63. package/opencode.json +54 -2
  64. package/package.json +14 -4
  65. package/scripts/postinstall.js +163 -0
@@ -0,0 +1,515 @@
1
+ ---
2
+ name: sdlc-regulatory
3
+ description: AI-driven SDLC governance framework with quality gates, risk-based autonomy caps, change traceability, Definition of Done, and a compliance crosswalk (EU AI Act, NIST AI RMF, ISO/IEC 42001, SOC 2, GDPR). Use when running or reviewing work through the BMad-style subagent SDLC, enforcing gates, classifying risk, or mapping SDLC stages to external regulatory regimes.
4
+ metadata:
5
+ scope: repo-level
6
+ version: "1.1"
7
+ supersedes: SOW.md (deleted; content fully absorbed into this skill)
8
+ ---
9
+
10
+ # AI-Driven SDLC Regulatory Framework
11
+
12
+ > **AI accelerates execution, SDLC controls correctness, risk, and accountability.**
13
+ > Source of truth: **this skill**. It supersedes and absorbs the deleted `SOW.md`
14
+ > (AI-Driven Software Development Lifecycle); the `SOW §…` section labels below are
15
+ > historical provenance from that document, kept to trace each control to its origin.
16
+
17
+ This skill is the methodology layer consumed by the `sdlc-*` subagents (BMad-style role agents) and enforced by the
18
+ `sdlc-gates` always-on rule. It encodes: stages, quality gates, risk-based autonomy caps, AI vs human responsibility
19
+ split, change traceability, Definition of Done, key risks, success metrics, and a compliance crosswalk.
20
+
21
+ ## Anti-pattern (SOW §Why We Need This)
22
+
23
+ The failure mode this framework exists to prevent:
24
+
25
+ **Requirement → AI → Code → Merge**
26
+
27
+ That flow has no analysis, no validation, no review, and no accountability. AI-driven development adds risks beyond
28
+ human mistakes: hallucinations, architectural drift, inconsistent implementations, AI-generated technical debt, missing
29
+ edge cases, security vulnerabilities, over-engineering, incorrect database changes, AI modifying unrelated components,
30
+ **AI reviewing/validating its own incorrect implementation**, and code volume outpacing human review capacity. Every
31
+ gate below exists to block one or more of these failure modes. If a proposed shortcut skips a gate, it is regressing
32
+ toward this anti-pattern — refuse it.
33
+
34
+ ## AI across the SDLC (SOW §1 — Integrate AI Across the SDLC)
35
+
36
+ AI must participate in **all** appropriate engineering stages, not just coding. The 13 SOW activities map as follows.
37
+
38
+ ### Linear stages (owned by one BMad role each → one gate)
39
+
40
+ | SOW activity | Owner | Gate |
41
+ |-------------------------|---------------------------------|----------------|
42
+ | Requirements analysis | `sdlc-analyst` | Requirement |
43
+ | Technical specification | `sdlc-pm` | Requirement |
44
+ | Architecture analysis | `sdlc-architect` | Architecture |
45
+ | Implementation planning | `sdlc-sm` | Architecture |
46
+ | Code generation | `sdlc-dev` | Implementation |
47
+ | Test generation | `sdlc-qa` | Testing |
48
+ | Code review | `sdlc-reviewer` | Code Review |
49
+ | Security analysis | `sdlc-security` | Security |
50
+ | Documentation | every role (artifact per stage) | DoD |
51
+
52
+ ### Ongoing / non-linear activities (not a gate; run as needed)
53
+
54
+ | SOW activity | Owner / trigger | Notes |
55
+ |----------------------|----------------------------------------------|---------------------------------------------------------------------------------------------------|
56
+ | Debugging | `sdlc-dev` (on a failing test or CI failure) | Use the CI failure path below; keep within story scope or BLOCK to `sdlc-sm`. |
57
+ | Refactoring | `sdlc-dev` (internal, autonomy 80–100%) | Still passes Implementation → Testing → Review gates. "Internal" = no public API/contract change. |
58
+ | Incident analysis | `sdlc-qa` + `sdlc-security` (post-incident) | Produces `docs/reviews/{slug}-incident.md`; feeds the feedback loop (see below). |
59
+ | Knowledge management | `sdlc-auditor` + continuous | Maintains the 9 knowledge-base doc types (see Documentation & Knowledge Management). |
60
+
61
+ These do not advance the linear chain but their artifacts are still traceable to the same `{slug}`.
62
+
63
+ ## How to use
64
+
65
+ - **Subagents** load this skill implicitly; they implement one stage each and hand off to the next role.
66
+ - **Main agent / orchestrator** uses the gate checklist below to decide whether a stage may advance.
67
+ - **Reviewers** use the Definition of Done and risk classification to set required approvals.
68
+ - **Humans** retain final approval for any change above the autonomy cap (see Risk-Based AI Autonomy).
69
+
70
+ ## SDLC Stages → BMad Role Agents
71
+
72
+ | # | SDLC Stage (SOW) | BMad role agent | Gate enforced | Human decision? |
73
+ |----|------------------------------|------------------|--------------------|-----------------------------|
74
+ | 1 | Requirements analysis | `sdlc-analyst` | Requirement | Business decision |
75
+ | 2 | Technical specification | `sdlc-pm` | Requirement | Prioritize |
76
+ | 3 | Architecture analysis | `sdlc-architect` | Architecture | Approve architecture |
77
+ | 4 | Implementation planning | `sdlc-sm` | Architecture | Prioritize |
78
+ | 5 | AI implementation | `sdlc-dev` | Implementation | Supervise |
79
+ | 6 | Automated validation + tests | `sdlc-qa` | Testing | Define quality expectations |
80
+ | 7 | Security analysis | `sdlc-security` | Security | High-risk approval |
81
+ | 8 | AI code review | `sdlc-reviewer` | Code Review | Final approval |
82
+ | 9 | Audit / Definition of Done | `sdlc-auditor` | Definition of Done | n/a (gate result) |
83
+ | 10 | Deployment | (CI/CD pipeline) | Deployment | Production authorization |
84
+ | 11 | Observability / feedback | (monitoring) | n/a | Incident decisions |
85
+
86
+ The `sdlc-orchestrator` subagent is the entry point: it routes a product requirement through stages 1–9 in order and
87
+ stops at any failed gate.
88
+
89
+ ## Handoff protocol (BMad-style)
90
+
91
+ Each role subagent MUST:
92
+
93
+ 1. Read this skill and the relevant gate checklist.
94
+ 2. Produce its stage artifact in the agreed location (see Artifacts below).
95
+ 3. Self-check its own gate. If any gate item fails, return the artifact to the previous role with a `BLOCKED` note; do
96
+ NOT advance.
97
+ 4. On pass, emit a `HANDOFF: <next-role>` line stating the next role, the artifact path, and the traceability id.
98
+ 5. Never review/validate its own implementation for the *next* gate — that is the next role's job. AI must not be the
99
+ sole validator of AI-generated work.
100
+
101
+ ## Artifacts
102
+
103
+ | Artifact | Owner | Location (relative to repo root) |
104
+ |-------------------------------------------------------------|------------------|----------------------------------------------------------|
105
+ | Market/vision analysis | `sdlc-analyst` | `docs/business/{slug}-analysis.md` |
106
+ | PRD (product requirements, acceptance criteria, edge cases) | `sdlc-pm` | `docs/business/{slug}-prd.md` |
107
+ | Architecture proposal + ADR | `sdlc-architect` | `docs/architecture/{slug}.md`, `docs/adr/NNNN-{slug}.md` |
108
+ | Story breakdown + risk classification + AI autonomy cap | `sdlc-sm` | `docs/stories/{slug}-stories.md` |
109
+ | Implementation (code + AI assumptions log) | `sdlc-dev` | feature branch + `docs/stories/{slug}-assumptions.md` |
110
+ | Test plan + test code | `sdlc-qa` | `tests/` + `docs/stories/{slug}-tests.md` |
111
+ | Security report (SAST/deps/secrets/auth) | `sdlc-security` | `docs/security/{slug}-security.md` |
112
+ | Code review report | `sdlc-reviewer` | `docs/reviews/{slug}-review.md` |
113
+ | Definition-of-Done audit | `sdlc-auditor` | `docs/reviews/{slug}-dod.md` |
114
+
115
+ `{slug}` is derived from the requirement/epic title by the orchestrator and reused across all artifacts for
116
+ traceability.
117
+
118
+ ## Quality Gates (verbatim from SOW §2)
119
+
120
+ Every AI-generated change MUST pass all gates before production. Gate items are checklists; any unchecked item blocks
121
+ advancement.
122
+
123
+ ### Requirement Gate — `sdlc-analyst` / `sdlc-pm`
124
+
125
+ - [ ] Requirement is clearly defined
126
+ - [ ] Acceptance criteria exist
127
+ - [ ] Edge cases are identified
128
+ - [ ] Business requirements are understood
129
+
130
+ ### Architecture Gate — `sdlc-architect`
131
+
132
+ - [ ] Existing architecture has been analyzed
133
+ - [ ] Impacted modules are identified
134
+ - [ ] Dependencies are understood
135
+ - [ ] ADR is created/updated when required
136
+
137
+ ### Implementation Gate — `sdlc-dev`
138
+
139
+ - [ ] Existing project patterns are followed
140
+ - [ ] No unnecessary dependencies are introduced
141
+ - [ ] Changes remain within the intended scope
142
+ - [ ] AI assumptions are documented
143
+
144
+ ### Testing Gate — `sdlc-qa`
145
+
146
+ - [ ] Unit tests
147
+ - [ ] Integration tests
148
+ - [ ] Regression tests
149
+ - [ ] Edge-case tests
150
+ - [ ] Existing test suite passes
151
+
152
+ ### Security Gate — `sdlc-security`
153
+
154
+ - [ ] SAST
155
+ - [ ] Dependency scanning
156
+ - [ ] Secrets scanning
157
+ - [ ] Security-focused AI review
158
+ - [ ] Authentication/authorization validation where applicable
159
+
160
+ ### Code Review Gate — `sdlc-reviewer`
161
+
162
+ - [ ] AI code review
163
+ - [ ] Human engineering review
164
+ - [ ] Additional senior/security review for high-risk changes
165
+
166
+ ### Deployment Gate — CI/CD pipeline
167
+
168
+ - [ ] CI passes
169
+ - [ ] Staging validation
170
+ - [ ] Smoke tests
171
+ - [ ] Canary deployment where applicable
172
+ - [ ] Production monitoring
173
+
174
+ ### Definition of Done — `sdlc-auditor`
175
+
176
+ - [ ] Requirement understood
177
+ - [ ] Acceptance criteria satisfied
178
+ - [ ] Architecture impact analyzed
179
+ - [ ] Implementation completed
180
+ - [ ] Tests generated where appropriate
181
+ - [ ] Unit tests passing
182
+ - [ ] Integration tests passing
183
+ - [ ] Regression tests passing
184
+ - [ ] Security checks passing
185
+ - [ ] AI code review completed
186
+ - [ ] Human review completed
187
+ - [ ] Documentation updated
188
+ - [ ] Observability added where required
189
+ - [ ] No unresolved AI assumptions
190
+ - [ ] Deployment successfully validated
191
+
192
+ A change is NOT done just because the code works.
193
+
194
+ ## AI vs Human Responsibilities (SOW §AI vs Human)
195
+
196
+ | Area | AI Responsibility | Human Responsibility |
197
+ |---------------|----------------------------|-----------------------------|
198
+ | Requirements | Analyze and structure | Business decision |
199
+ | Architecture | Propose solutions | Approve architecture |
200
+ | Planning | Break work into tasks | Prioritize |
201
+ | Coding | Generate implementation | Supervise |
202
+ | Testing | Generate and execute tests | Define quality expectations |
203
+ | Code Review | Technical analysis | Final approval |
204
+ | Security | Automated analysis | High-risk approval |
205
+ | Deployment | Automation | Production authorization |
206
+ | Monitoring | Detect anomalies | Incident decisions |
207
+ | Documentation | Generate/update | Validate |
208
+ | Maintenance | Diagnose/propose fixes | Approve critical changes |
209
+
210
+ ## Risk-Based AI Autonomy (SOW §Risk-Based AI Autonomy)
211
+
212
+ Classify every change on these axes before implementation:
213
+
214
+ - Business impact
215
+ - Technical complexity
216
+ - Security sensitivity
217
+ - Data sensitivity
218
+ - Infrastructure impact
219
+ - Financial impact
220
+ - Breaking-change probability
221
+
222
+ Default autonomy caps (override per-project, never relax without human sign-off):
223
+
224
+ | Change Type | Suggested AI Autonomy |
225
+ |---------------------------|----------------------:|
226
+ | Documentation | 100% |
227
+ | Test generation | 100% |
228
+ | Internal refactoring | 80–100% |
229
+ | Simple API changes | 70–90% |
230
+ | Database migrations | 30–50% |
231
+ | Authentication | 20–40% |
232
+ | Payments | 10–30% |
233
+ | Smart contracts | 0–20% |
234
+ | Production infrastructure | 0–20% |
235
+
236
+ **Rule:** any change above ~50% autonomy cap (or any High/Critical security finding) requires explicit human approval.
237
+ `sdlc-sm` assigns the cap per story; `sdlc-auditor` verifies it was respected before DoD sign-off.
238
+
239
+ ## Change Traceability (SOW §AI Change Traceability)
240
+
241
+ Chain: **Business Requirement → Task → AI Plan → Pull Request → Tests → Review → Deployment**
242
+
243
+ Capture, per change (stored in the DoD audit artifact):
244
+
245
+ - Requirement / ticket id
246
+ - AI agent (role) and model used
247
+ - Repository + changed modules
248
+ - Validation results (per gate)
249
+ - Security checks
250
+ - Reviewers (AI + human)
251
+ - Deployment info
252
+
253
+ Objective: engineering traceability and accountability, not storing full prompts.
254
+
255
+ ## Key Risks to Control (SOW §Key Risks)
256
+
257
+ The framework MUST explicitly protect against:
258
+
259
+ - AI hallucinations and incorrect assumptions
260
+ - Architectural drift / degradation
261
+ - Inconsistent implementations
262
+ - AI-generated technical debt
263
+ - Missing edge cases
264
+ - Security vulnerabilities
265
+ - Over-engineering
266
+ - Scope creep
267
+ - Breaking changes
268
+ - Incorrect database migrations
269
+ - Insufficient test coverage
270
+ - AI self-validation failures — **AI must not be the only validator of AI-generated code.** (Hence separate reviewer +
271
+ auditor roles.)
272
+
273
+ ## Success Metrics (SOW §Success Metrics)
274
+
275
+ Measure engineering outcomes, not raw AI code volume. These metrics are NOT gate items — they are telemetry the
276
+ `sdlc-auditor` should record per change (where available) in the audit trail, and the team should trend over time:
277
+
278
+ - Lead Time for Changes
279
+ - Deployment Frequency
280
+ - Change Failure Rate
281
+ - Mean Time to Recovery (MTTR)
282
+ - AI-generated PR acceptance rate
283
+ - AI-generated defect rate
284
+ - Defect escape rate
285
+ - AI review escape rate
286
+ - Test coverage
287
+ - Security findings
288
+ - Human review time
289
+ - AI autonomy rate
290
+ - Cost per feature / per successful deployment
291
+ - Percentage of changes passing automated quality gates
292
+
293
+ The DoD audit artifact (see Audit Trail format) includes a `metrics` block capturing the per-change subset:
294
+ `lead_time_hours`, `test_coverage_pct`, `security_findings`, `autonomy_cap_pct`, `ai_pr_accepted` (true/false),
295
+ `human_review_minutes`. Metrics the change cannot supply are left `null`, not invented.
296
+
297
+ ## Documentation & Knowledge Management (SOW §Documentation & Knowledge Management)
298
+
299
+ Documentation is a first-class part of the SDLC, not an afterthought. AI must help maintain these 9 knowledge-base doc
300
+ types. The DoD "Documentation updated" item is not satisfied by "we wrote code comments" — it requires the relevant
301
+ knowledge-base surface below to be current for the change.
302
+
303
+ | # | Knowledge doc | Location | Owner per change | Updated when |
304
+ |---|----------------------------|------------------------------------------------------------------|---------------------------------|-----------------------------------------|
305
+ | 1 | Architecture documentation | `ARCHITECTURE.md`, `docs/architecture/{slug}.md` | `sdlc-architect` | architecture impact > none |
306
+ | 2 | ADRs | `docs/adr/NNNN-{slug}.md` | `sdlc-architect` | any non-trivial decision |
307
+ | 3 | API documentation | `docs/api/` (+ OpenAPI/Protobuf/schema alongside code) | `sdlc-dev` | any API contract change |
308
+ | 4 | Database documentation | `docs/database/` (schema, ERD, data dictionary, migration notes) | `sdlc-dev` / `sdlc-architect` | any DB migration or schema change |
309
+ | 5 | Module documentation | per-module README / doc comments | `sdlc-dev` | module behaviour changed |
310
+ | 6 | Runbooks | `docs/runbooks/` | `sdlc-qa` / `sdlc-security` | new operational surface or failure mode |
311
+ | 7 | Troubleshooting guides | `docs/troubleshooting/` | `sdlc-qa` (+ incident analysis) | new failure mode discovered |
312
+ | 8 | Deployment documentation | `docs/deployment/` (+ `infrastructure/` IaC comments) | `sdlc-architect` / CI | deployment process or env changed |
313
+ | 9 | Engineering standards | `AGENTS.md`, `CONTRIBUTING.md`, `SECURITY.md`, lint/test configs | `sdlc-reviewer` / humans | standard added/changed |
314
+
315
+ This is the continuously updated engineering knowledge base that AI agents also consume — keeping it current is what
316
+ keeps the codebase AI-readable (see AI-Readable Codebase above) across iterations.
317
+
318
+ ## Key Benefits (SOW §Key Benefits — rationale, not a gate)
319
+
320
+ These are the outcomes the framework targets; they are rationale, not gate items:
321
+
322
+ - **Increased development velocity** — less boilerplate/repetitive implementation/testing/docs/refactoring/debugging.
323
+ - **Improved engineering consistency** — coding standards, architecture patterns, security rules, naming, tests, docs
324
+ enforced uniformly.
325
+ - **Better code quality** — AI analysis + deterministic CI + human review find issues earlier.
326
+ - **Reduced human review cost** — humans focus on architecture, business correctness, security, maintainability,
327
+ trade-offs.
328
+ - **Faster onboarding** — AI uses AGENTS.md, ADRs, code, tests to explain existing systems.
329
+ - **Institutional knowledge** — embedded in code, tests, docs, ADRs, architecture, AI-readable context, not just in
330
+ engineers' heads.
331
+ - **Improved traceability** — every change connects Requirement → Implementation → Validation → Approval → Deployment.
332
+
333
+ Do not use these as gate-pass criteria; use them to explain *why* the gates exist.
334
+
335
+ ## AI-Readable Codebase (SOW §AI-Readable Codebase)
336
+
337
+ Repositories MUST provide sufficient context for AI agents to understand the system. This is a precondition for the
338
+ Architecture Gate (the architect cannot analyze existing architecture that is not documented) and for the
339
+ `sdlc-orchestrator` to route work reliably.
340
+
341
+ ### Required documentation structure
342
+
343
+ ```text
344
+ /project
345
+ ├── AGENTS.md # Layout, conventions, cross-tool linking (source of truth)
346
+ ├── ARCHITECTURE.md # How the system works, stack, diagrams, constraints
347
+ ├── CONTRIBUTING.md # How to contribute, workflow, branch/commit conventions
348
+ ├── SECURITY.md # Security policy, threat model, reporting, secrets handling
349
+ ├── docs/
350
+ │ ├── architecture/ # Architecture docs and design deep-dives
351
+ │ ├── adr/ # Architecture Decision Records (NNNN-slug.md)
352
+ │ ├── api/ # API contracts (OpenAPI/Protobuf/graphql schemas)
353
+ │ └── database/ # Schema, migrations, ERDs, data dictionary
354
+ ├── services/ # Deployable services
355
+ ├── packages/ # Shared libraries
356
+ ├── tests/ # Test suites
357
+ └── infrastructure/ # IaC, deployment, config
358
+ ```
359
+
360
+ Missing files are allowed at project start, but each `sdlc-*` run MUST flag which required files are absent in the
361
+ analyst/architect artifacts so they get backfilled. `AGENTS.md` and `ARCHITECTURE.md` are the minimum required for any
362
+ SDLC run; the rest become required as the project grows the corresponding surface.
363
+
364
+ ### What the AI must be able to understand from the codebase
365
+
366
+ The repository must let an AI agent determine:
367
+
368
+ - How the system works
369
+ - Architectural rules
370
+ - Coding standards
371
+ - Security requirements
372
+ - Testing strategy
373
+ - Deployment process
374
+ - Important constraints
375
+ - Existing architectural decisions (via ADRs)
376
+ - What must NOT be changed without human approval
377
+
378
+ ### Where this binds into the gates
379
+
380
+ - **Requirement Gate** (`sdlc-analyst`): note which required AI-readable files are missing; surface as an
381
+ assumption/unknown.
382
+ - **Architecture Gate** (`sdlc-architect`): verify the repo is AI-readable before claiming "existing architecture has
383
+ been analyzed". If `ARCHITECTURE.md` or the relevant `docs/adr/` entries are missing, the architect MUST create/update
384
+ them as part of passing the gate (this is already a gate checklist item: "ADR is created/updated when required").
385
+ - **Implementation Gate** (`sdlc-dev`): follow the patterns documented in `AGENTS.md` + `ARCHITECTURE.md`; if those
386
+ files are absent, treat it as an assumption and BLOCK back to `sdlc-architect`.
387
+ - **DoD Gate** (`sdlc-auditor`): verify "Documentation updated" covers any AI-readable file that this change should have
388
+ touched.
389
+
390
+ ### When applying to a non-conforming repo
391
+
392
+ If a target repository does not yet have `AGENTS.md` / `ARCHITECTURE.md`, the orchestrator should run a **bootstrap
393
+ pass** first (out of band): have `sdlc-analyst` + `sdlc-architect` seed the missing AI-readable files from the existing
394
+ code before routing the actual feature work. Do not silently proceed on an illegible codebase — that is how
395
+ architectural drift and AI self-validation failures start.
396
+
397
+ ## CI/CD progressive validation (SOW §AI-Driven CI/CD)
398
+
399
+ ```
400
+ Git Push → Build → Lint → Unit Tests → Integration Tests
401
+ → SAST → Dependency Scan → AI Code Review
402
+ → Architecture Validation → Risk Classification
403
+ → Human Approval → Staging → Production
404
+ ```
405
+
406
+ CI failure path:
407
+
408
+ ```
409
+ CI Failure → AI Log Analysis → Root Cause → Proposed Fix
410
+ → Automated Tests → Pull Request
411
+ ```
412
+
413
+ Production changes always subject to the approval policy above.
414
+
415
+ ## Compliance Crosswalk (extensible overlay)
416
+
417
+ Maps each SDLC gate to external regulatory/AI-management regimes. Use when the project must demonstrate compliance;
418
+ otherwise treat as informative.
419
+
420
+ | SDLC Gate / Control | EU AI Act (Regulation (EU) 2024/1689) | NIST AI RMF 1.0 | ISO/IEC 42001:2023 | SOC 2 (TSC) | GDPR (Regulation (EU) 2016/679) |
421
+ |-------------------------------------|------------------------------------------------------------------------------------|--------------------------|---------------------------------------------------------------|---------------------------|----------------------------------------------------------|
422
+ | Requirement Gate | Art. 9 (high-risk system purpose, intended use, risk mgmt plan) | GOVERN-1.1, MAP-1.1 | Clauses 6.1, 8.1 (context, risk) | CC1.1–CC1.3 | Art. 5 (principles), Art. 25 (data protection by design) |
423
+ | Architecture Gate | Art. 9(2), Art. 15 (accuracy, robustness, cybersecurity) | MAP-2.1, MAP-3.1 | Clause 8.2 (AI system impact), 8.3 | CC7.1, CC7.2 | Art. 25 (DPIA, by design & by default) |
424
+ | Implementation Gate | Art. 9(4) (data governance, traceability), Art. 12 (technical documentation) | MEASURE-1.1, MEASURE-2.2 | Clause 8.4 (design), 8.5 (development) | CC7.1, CC8.1 | Art. 30 (records), Art. 32 (security of processing) |
425
+ | Testing Gate | Art. 9(3)(c), Art. 15 (resilience, fallback) | MEASURE-1.2, MEASURE-2.3 | Clause 8.6 (verification) | CC7.1 | Art. 25, Art. 32 |
426
+ | Security Gate | Art. 15 (cybersecurity), Art. 14 (human oversight) | MEASURE-1.3, MANAGE-1.1 | Clause 8.8 (security), 8.9 (disclosure) | CC6.1–CC6.8, CC7.1 | Art. 32 (security), Art. 34 (breach notification) |
427
+ | Code Review Gate | Art. 14 (human oversight, right to intervene) | MANAGE-2.1, MANAGE-4.1 | Clause 8.7 (deployment), 8.10 (human oversight) | CC7.1, CC8.1 | Art. 22 (human-in-the-loop for automated decisions) |
428
+ | Deployment Gate | Art. 26 (obligations of deployers), Art. 27 (fundamental rights impact assessment) | MANAGE-1.3, MANAGE-3.1 | Clause 8.7 (deployment), 10 (improvement) | CC8.1, CC8.2 | Art. 35 (DPIA for high-risk processing) |
429
+ | DoD Audit | Art. 12 (technical documentation), Art. 72 (post-market monitoring) | MANAGE-4.2, MANAGE-5.1 | Clause 9 (performance evaluation), 10 (continual improvement) | CC4.1, CC4.2 (monitoring) | Art. 5(2) (accountability), Art. 35 |
430
+ | Traceability | Art. 9(4)(b) (automatic traceability/logging), Art. 12 | MAP-1.3, MEASURE-2.9 | Clause 7.5 (documented info), 8.5 | CC2.1, CC2.2 | Art. 5(2), Art. 30, Art. 35(7) |
431
+ | Risk classification & autonomy caps | Art. 6 (classification), Annex III | GOVERN-2.1, MAP-2.2 | Clause 6.1 (risk), 8.1 | CC3.1–CC3.4 (risk mgmt) | Art. 35 (DPIA threshold) |
432
+
433
+ Notes:
434
+
435
+ - EU AI Act: obligations differ by risk tier (unacceptable / high-risk / limited / minimal). The above assumes a
436
+ **high-risk** system. For limited-risk systems, only transparency (Art. 50) applies; for minimal-risk, voluntary
437
+ codes. Confirm the tier per system before applying.
438
+ - NIST AI RMF functions: **GOVERN** (cross-cutting), **MAP** (context & risk identification), **MEASURE**
439
+ (assess/track), **MANAGE** (prioritize/respond).
440
+ - ISO/IEC 42001 is an AI management system standard (clauses ~ISO 9001-style: context, leadership, plan, support,
441
+ operation, performance evaluation, improvement).
442
+ - SOC 2: Trust Services Criteria (TSC) 2017, with the 2018 Points of Focus. CC = Common Criteria; plus optional
443
+ Security/Availability/Confidentiality/Processing Integrity/Privacy categories.
444
+ - GDPR applies whenever personal data is processed, regardless of AI use; DPIA (Art. 35) mandatory for high-risk
445
+ processing including large-scale profiling, automated decisions (Art. 22).
446
+ - **This crosswalk is a planning aid, not legal advice.** Confirm applicability and exact article numbering with current
447
+ official sources — numbering/paragraphs can shift between trilogue and consolidated versions. For EU AI Act, reference
448
+ the version published in the OJEU; for GDPR, Regulation (EU) 2016/679.
449
+
450
+ ## Audit Trail format (for `sdlc-auditor`)
451
+
452
+ Each DoD audit artifact must end with a `## Traceability` block:
453
+
454
+ ```yaml
455
+ traceability:
456
+ requirement_id: <Jira/issue id or slug>
457
+ ai_agents: [ { role: analyst, model: <id> }, { role: dev, model: <id> }, ... ]
458
+ repository: <org/repo>
459
+ changed_modules: [ src/foo, src/bar ]
460
+ gate_results:
461
+ requirement: pass
462
+ architecture: pass
463
+ implementation: pass
464
+ testing: pass
465
+ security: pass
466
+ code_review: pass
467
+ deployment: pending
468
+ security_findings: { critical: 0, high: 0, medium: 1, low: 2 }
469
+ risk_class: medium
470
+ autonomy_cap_pct: 70
471
+ human_approvals: [ { gate: architecture, approver: @handle, date: YYYY-MM-DD } ]
472
+ deployment: { env: staging, ref: <commit>, artifacts: [ ] }
473
+ metrics: # per-change subset of Success Metrics; null if unavailable, never invented
474
+ lead_time_hours: 18
475
+ test_coverage_pct: 87
476
+ security_findings: { critical: 0, high: 0, medium: 1, low: 2 }
477
+ autonomy_cap_pct: 70
478
+ ai_pr_accepted: true
479
+ human_review_minutes: 35
480
+ ```
481
+
482
+ ## Feedback loop to the next iteration (SOW §Expected Outcome)
483
+
484
+ The SDLC is a cycle, not a line. The SOW operating model ends with:
485
+
486
+ ```
487
+ ... → Deployment → Observability → Production Data → Knowledge / Feedback → Next Iteration
488
+ ```
489
+
490
+ After the DoD audit passes and the change deploys:
491
+
492
+ 1. **Observability** — production metrics, logs, traces, and any canary/rollout signals must be watched for the change's
493
+ blast radius. This is the Deployment Gate's "Production monitoring" item, extended in time.
494
+ 2. **Production data** — real-world behaviour of the change feeds back as evidence. If it causes incidents,
495
+ `sdlc-qa` + `sdlc-security` run the **incident analysis** non-linear activity and produce
496
+ `docs/reviews/{slug}-incident.md`.
497
+ 3. **Knowledge / feedback** — the DoD audit + any incident analysis + production signals are folded back into the
498
+ knowledge base (the 9 doc types above). `sdlc-auditor` opens a follow-up: update ADRs, runbooks, troubleshooting
499
+ guides, and engineering standards as needed. The metrics block in the audit trail is the input to trend analysis.
500
+ 4. **Next iteration** — the next `/sdlc` run starts from the updated, AI-readable codebase, with the prior change's
501
+ lessons already embedded. The orchestrator treats this as a hard precondition: do not start a new run on a repo whose
502
+ prior change's knowledge-base updates are still pending (it would be illegible again).
503
+
504
+ The chain therefore closes: **requirement → … → audit → deploy → observability → feedback → knowledge → next run.**
505
+
506
+ ## Quick reference
507
+
508
+ - Stuck at a gate? → re-run the owning role subagent with the BLOCKED note; do not skip.
509
+ - Unsure of autonomy cap? → `sdlc-sm` classifies; default to the stricter (lower) cap.
510
+ - High-risk change? → human approval required at Architecture, Security, and Code Review gates; `sdlc-auditor` will
511
+ reject DoD if missing.
512
+ - New external regime? → add a column to the Compliance Crosswalk; do not fork the gates.
513
+
514
+ *Load this skill whenever you run, review, or govern work through the BMad-style subagent SDLC, or when mapping SDLC
515
+ controls to external AI/security/privacy regimes.*
@@ -21,3 +21,14 @@ Read the root `AGENTS.md` first for: directory layout, where skills / agents
21
21
  - Skills may be shared with Claude Code: `opencode.json` lists
22
22
  `.claude/skills` under `skills.paths`, so a Claude-format skill in
23
23
  `.claude/skills/<name>/SKILL.md` is auto-discovered by opencode.
24
+
25
+ ## SDLC subagents
26
+
27
+ The `sdlc-*` role subagents (orchestrator + 9 roles) are registered under
28
+ `agent` in `opencode.json` and dispatched via the `/sdlc` command. They use
29
+ the opencode frontmatter (`mode: subagent`). The Claude Code mirrors in
30
+ `.claude/agents/` omit the `mode:` field per Claude Code's format. The
31
+ `.agents/agents/` mirrors keep the opencode frontmatter verbatim for any
32
+ Agent-Skills-compatible client. The methodology lives in the
33
+ `sdlc-regulatory` skill (triple-mirrored); the `sdlc-gates` rule is
34
+ always-on via `opencode.json` instructions and `.claude/rules/`.
@@ -0,0 +1,30 @@
1
+ ---
2
+ description: Requirements analyst for the AI-driven SDLC. Translates a raw product idea or change request into a market/context analysis and confirms the requirement is well-formed. First role in the BMad-style chain.
3
+ mode: subagent
4
+ ---
5
+
6
+ You are the **SDLC Analyst**. Load the `sdlc-regulatory` skill first.
7
+
8
+ ## Job
9
+
10
+ Take a raw product idea or change request and produce `docs/business/{slug}-analysis.md` containing:
11
+ - Problem / opportunity statement
12
+ - Stakeholders and intended users
13
+ - Market or internal context (brief)
14
+ - Known constraints, assumptions, unknowns
15
+ - A crisp, testable restatement of the requirement
16
+
17
+ You own the **first half of the Requirement Gate**. Do not yet produce acceptance criteria — that is the PM's job, but you must hand off a requirement clear enough for the PM to write criteria.
18
+
19
+ ## Gate self-check (Requirement Gate, partial)
20
+
21
+ - [ ] Requirement is clearly defined
22
+ - [ ] Business requirements are understood
23
+ - [ ] Unknowns and assumptions surfaced
24
+
25
+ ## Handoff
26
+
27
+ On pass: `HANDOFF: sdlc-pm | artifact: docs/business/{slug}-analysis.md | gate: pass`
28
+ On fail: `HANDOFF: BLOCKED | reason: <one-line> | return_to: <previous role or user>`
29
+
30
+ You do NOT write code, tests, or architecture. You do NOT advance past the PM role.
@@ -0,0 +1,32 @@
1
+ ---
2
+ description: Architect for the AI-driven SDLC. Analyzes existing architecture, identifies impacted modules and dependencies, proposes a solution, and creates/updates the ADR. Owns the Architecture Gate.
3
+ mode: subagent
4
+ ---
5
+
6
+ You are the **SDLC Architect**. Load the `sdlc-regulatory` skill first.
7
+
8
+ ## Job
9
+
10
+ Read `docs/business/{slug}-prd.md` and the existing repo (`AGENTS.md`, `ARCHITECTURE.md`, `docs/architecture/`, `docs/adr/`, source tree) and produce:
11
+ - `docs/architecture/{slug}.md` — proposed solution, impacted modules, dependencies, alternatives considered, trade-offs
12
+ - `docs/adr/NNNN-{slug}.md` — Architectural Decision Record when the decision is non-trivial, breaks prior architecture, or introduces a new dependency/pattern
13
+
14
+ You own the **Architecture Gate**.
15
+
16
+ ## Gate self-check (Architecture Gate)
17
+
18
+ - [ ] Existing architecture has been analyzed (cite the files you read)
19
+ - [ ] Impacted modules are identified
20
+ - [ ] Dependencies are understood (added/removed/changed)
21
+ - [ ] ADR is created/updated when required
22
+
23
+ ## Human approval
24
+
25
+ If the change is high-risk (per `sdlc-sm`'s later classification, or your own estimate — database, auth, payments, smart contracts, prod infra), request human approval of the architecture before handing off. Record approver + date in the artifact.
26
+
27
+ ## Handoff
28
+
29
+ On pass: `HANDOFF: sdlc-sm | artifact: docs/architecture/{slug}.md, docs/adr/NNNN-{slug}.md | gate: pass`
30
+ On fail: `HANDOFF: BLOCKED | reason: <one-line> | return_to: sdlc-pm`
31
+
32
+ You do NOT write implementation code or tests.
@@ -0,0 +1,45 @@
1
+ ---
2
+ description: Auditor for the AI-driven SDLC. Verifies the Definition of Done across all prior gates, confirms traceability, and produces the final audit artifact. Owns the DoD Gate. Must be a different agent from those who produced the work.
3
+ mode: subagent
4
+ ---
5
+
6
+ You are the **SDLC Auditor**. Load the `sdlc-regulatory` skill first.
7
+
8
+ ## Job
9
+
10
+ Read every prior artifact (analysis, PRD, architecture, ADR, stories, assumptions, tests, security, review) and produce `docs/reviews/{slug}-dod.md` containing:
11
+ - The full Definition-of-Done checklist with pass/fail per item
12
+ - The traceability block (see the `sdlc-regulatory` skill's Audit Trail format — requirement_id, ai_agents, changed_modules, gate_results, security_findings, risk_class, autonomy_cap_pct, human_approvals, deployment)
13
+ - A final verdict: DOD PASS / DOD FAIL
14
+
15
+ You own the **Definition-of-Done Gate**.
16
+
17
+ ## Gate self-check (Definition of Done)
18
+
19
+ - [ ] Requirement understood
20
+ - [ ] Acceptance criteria satisfied
21
+ - [ ] Architecture impact analyzed
22
+ - [ ] Implementation completed
23
+ - [ ] Tests generated where appropriate
24
+ - [ ] Unit tests passing
25
+ - [ ] Integration tests passing
26
+ - [ ] Regression tests passing
27
+ - [ ] Security checks passing
28
+ - [ ] AI code review completed
29
+ - [ ] Human review completed
30
+ - [ ] Documentation updated
31
+ - [ ] Observability added where required
32
+ - [ ] No unresolved AI assumptions
33
+ - [ ] Deployment successfully validated (this item is typically pending until post-deploy; mark it as such and require a follow-up audit after deploy)
34
+
35
+ ## Hard rules
36
+
37
+ - You MUST be a different agent/model from the ones who produced the work. This is the AI-self-validation control.
38
+ - Any unchecked item = DOD FAIL. No partial credit.
39
+ - Any high-risk change missing a recorded human approval at Architecture/Security/Code Review = DOD FAIL, even if the technical work is sound.
40
+ - A change is NOT done because the code works. DoD is the gate.
41
+
42
+ ## Handoff
43
+
44
+ On pass: `HANDOFF: deploy | artifact: docs/reviews/{slug}-dod.md | gate: pass` (the orchestrator or CI/CD pipeline handles actual deployment, subject to the Deployment Gate)
45
+ On fail: `HANDOFF: BLOCKED | reason: <which DoD item(s) failed> | return_to: <owning role>`