Nine documents, one unbroken chain
Every phase's last artifact is the next phase's name
A phase does not end with a feeling that the work is done. It ends by writing a handoff — a named file that the next phase's first step opens and reads. Follow the chain and you have followed the engagement.
The chain is what makes a phase gate meaningful. Phase 2 cannot start by guessing what Design should
address — its very first step opens phase2-handoff.md and pulls out every
architectural question Phase 1 left behind. An unanswered question at the end of the week is a gate
failure, not an oversight. The handoff is the contract between two phases.
Every one of these files lives under .sdlc/artifacts/<slug>/ in the client's own
repository, committed alongside their code. Their visibility, their record — not a deck on our
laptops.
Every artifact the gate requires, by phase
What each phase must produce before it can close
These are the files check_gates.py actually verifies: they must exist, be
non-empty, and contain no placeholder text. Anything not on this list can be missing and the automated
gate will still report green.
| Phase | Directory | Required artifacts | Hands forward |
|---|---|---|---|
| 0 · Discovery | .sdlc/artifacts/00-discovery/ |
constitution.md problem-statement.md success-criteria.md constraints.md | phase1-handoff.md |
| 1 · Requirements | .sdlc/artifacts/01-requirements/ |
requirements.md non-functional-requirements.md epics.md | phase2-handoff.md — carries the AQ-NN architectural questions |
| 2 · Design | .sdlc/artifacts/02-design/ |
design-doc.md api-contracts.md adrs/ adr-registry.md | phase3-handoff.md |
| 3 · Foundation | .sdlc/artifacts/03-foundation/ |
foundation-report.md risk-tier-map.md cadence-plan.md | build-handoff.md |
| The Build loop | .sdlc/artifacts/build/ |
none — the loop is flagged continuous: true and has no batch artifact gate. Checking happens per change, at the merge bar. It ends when a human declares the backlog feature-complete, not when a count passes. |
phase7-handoff.md |
| 7 · Documentation | .sdlc/artifacts/07-documentation/ |
README.md api-docs.md RUNBOOK.md | phase8-handoff.md |
| 8 · Deployment | .sdlc/artifacts/08-deployment/ |
release-notes.md deployment-checklist.md smoke-test-results.md | phase9-handoff.md |
| 9 · Monitoring | .sdlc/artifacts/09-monitoring/ |
monitoring-config.md alert-definitions.md incident-response.md project-retrospective.md | close-handoff.md |
| C · Close & Transfer | .sdlc/artifacts/close/ |
final-handoff-report.md harness-audit.md close-gate-evidence.md access-revocation-checklist.md | terminal — nothing follows |
Three of Phase C's four artifacts are highlighted for a reason. They are receipts for human rituals — the client's own engineer shipping one real change alone with the pod silent in the room; the audit of everything still living in our heads; the proof that our access was actually revoked. No command can perform any of them. A person does the work, a file records that it happened, and the gate checks the file. Phase C is the only phase that does this. Hold that pattern in mind for the next two sections.
Real files, produced on every engagement, mentioned in no phase document
The other half of .sdlc/
The phase artifacts are what people talk about. Alongside them, the harness writes a running record of its own behavior — the state of the engagement, the result of every gate, the life of every spec. It is the most honest description of what actually happened, and no page in this standard has ever named it.
| Path | What it holds | Written when |
|---|---|---|
.sdlc/state.yaml | Which phase the engagement is in. The single source of truth that advance_phase.py moves — and only ever with --confirmed | Every phase advance |
.sdlc/constitution.md | The principles and protected futures agreed in Phase 0. The forward-compatibility check reads this | Phase 0, then amended by ADR |
.sdlc/profile.yaml | The client's compliance profile — which extra gates apply, and how changes must be approved | Phase 3 setup |
.sdlc/context/intake/ | Every client document taken in at Phase 0, catalogued as DOC-NNN, with the contradictions between them | Phase 0 intake |
.sdlc/reports/phaseNN-report.html | The self-contained gate report. This is the document a sponsor reads before signing | Every gate run |
.sdlc/metrics/gate-log.jsonl | One line per gate check: what passed, what failed, when | Every gate run |
.sdlc/metrics/spec-log.jsonl | One line per spec through the Build loop — its risk tier, its author, its checker | Every merge |
.sdlc/metrics/loop-events.jsonl | The Build loop's own telemetry: how long Intent, Delegate and Discern each took | Every loop iteration |
.sdlc/metrics/findings-log.jsonl | Every review finding, its severity, and whether it was fixed or accepted by a named human | Every review |
These files are the engagement's evidence. When a client asks in month nine why a decision was made,
adr-registry.md answers it. When they ask whether the process was actually followed,
gate-log.jsonl and findings-log.jsonl answer that — with dates and
names, not assurances. They are committed to the client's repository and they leave with the client.
The gap between what the method demands and what the harness records
The work that leaves no receipt
This standard asks a pod to do a great deal that no command performs: spike an integration against the live system, walk the attack surface with the client's security lead, trace requirements against design in both directions, hand a stranger the README and watch them fail. That human work is the point — it is what separates this from generated code with a plausible shape.
But most of it currently ends when the meeting ends. On each phase's Example tab, those artifacts are marked in amber: the method requires it — no command writes it. The automated gate cannot see them, the phase report does not list them, and a year later nobody can prove they happened.
The human gate itself is real and enforced: advance_phase.py will not move an
engagement forward without --confirmed, a named person's sign-off. The problem is not
that humans are trusted. The problem is what they are asked to vouch for. Each
phase's exit-gate checklist is declared in phase-registry.yaml, and no code opens it.
The human is stopped at the gate, shown a list of files that exist and do not contain the word
"TODO", and asked to sign.
The fix is not to automate judgment. A spike cannot be run by a machine — the whole point is a person touching a live system. A threat review is an argument in a room. The fix is the pattern Phase C already demonstrates three times over: the human does the work, and the work leaves a file. Then the gate can see it, the phase report can list it, and the client can audit it in month nine.
That is the difference between the green chips and the amber ones above. Not who does the work — a person does it either way. Only whether anything is left behind.