Compare commits

..

16 Commits

Author SHA1 Message Date
Jon Chery 067fef14aa ship: phase-08 aws-bootstrap (v1.1.3)
---ci---
project: acdl
phase: 8
milestone: v1.1
status: shipped
release:
  tag: v1.1.3
---/ci---

Squash merge of phase/08-aws-bootstrap. AWS substrate bootstrapped:
S3 state bucket acdl-tfstate-581513795199-us-east-1 (versioning enabled)
+ DynamoDB outbox table acdl-outbox (PAY_PER_REQUEST, PK contractId, SK
eventType#eventTs) + IAM user acdl-spike-runner with least-privilege
scoped policy (DenyEverythingElse) + per-run-rotated spike key in
gitignored .env.secrets. Real OIDC deferred to v1.2 (D-039, blocked on
go-gitea/gitea#36988). verify_phase08.sh green: caller identity is
acdl-spike-runner (not root), all resources present, .env.secrets +
.bootstrap_state.json gitignored.
2026-07-21 19:02:26 +00:00
Jon Chery 96ab42fde1 docs(P08): post-ship traceability + roadmap update (v1.1.3)
---ci---
project: acdl
phase: 8
milestone: v1.1
status: shipped
requirements:
  complete: [REQ-23]
release:
  tag: v1.1.3
---/ci---

ROADMAP Phase 08 -> complete (v1.1.3). REQUIREMENTS REQ-23 -> complete.
S3 state bucket + DynamoDB outbox table + IAM user acdl-spike-runner
with least-privilege scoped policy + rotated spike key all created and
verified. D-034 closure: user must manually rotate the root key now.
2026-07-21 19:02:26 +00:00
Jon Chery d28630d1f1 phase: 8, status: plan-as-execute, persona: lead-developer, task: T-8.8
---ci---
project: acdl
phase: 8
milestone: v1.1
status: plan-as-execute
persona: lead-developer
task: T-8.8
requirements.covered: [REQ-23]
---/ci---

Wave 5: execute the bootstrap against real AWS + fix verify script.

- Created S3 bucket acdl-tfstate-581513795199-us-east-1 (versioning
  enabled) + DynamoDB table acdl-outbox (PAY_PER_REQUEST, PK contractId,
  SK eventType#eventTs) via create_state_backend.py.
- Created IAM user acdl-spike-runner + scoped inline policy
  (DenyEverythingElse) + initial key via create_iam_user.py.
- Rotated the spike key via rotate_spike_key.sh: old key deleted, new
  key in gitignored .env.secrets (chmod 600).
- verify_phase08.sh fixes: (a) heredoc python instead of -c to avoid
  bash quoting issues; (b) Check 4 uses the bootstrap root key to
  inspect IAM (the spike key is least-privilege and cannot iam:GetUser
  - that itself confirms the policy denies non-granted actions); (c)
  get_user_policy returns PolicyDocument as a dict, not a URL-encoded
  string in this boto3 version - handle both.
- VERIFIED: caller identity is acdl-spike-runner (not root), S3 + DDB +
  IAM user + Deny-everything-else policy all present, .env.secrets +
  .bootstrap_state.json gitignored.

D-034 closure: user must manually rotate the root key in the AWS IAM
console now (the bootstrap root key has served its one-shot purpose).
2026-07-21 19:01:58 +00:00
Jon Chery 1d5c4d2ae7 phase: 8, status: plan-as-execute, persona: platform-engineer+lead-developer, task: T-8.5..T-8.7
---ci---
project: acdl
phase: 8
milestone: v1.1
status: plan-as-execute
persona: platform-engineer+lead-developer
task: [T-8.5, T-8.6, T-8.7]
requirements.covered: [REQ-23]
---/ci---

Waves 3+4: rotation script + verify script + README + .gitignore.

- T-8.5 (platform): scripts/rotate_spike_key.sh - boto3 with bootstrap
  root key from env (ACDL_BOOTSTRAP_AWS_*); creates new key for
  acdl-spike-runner, deactivates+deletes old, writes new to gitignored
  .env.secrets (chmod 600); idempotent (re-run ends with exactly 1
  active key); optional Gitea secret upload if ACDL_GITEA_TOKEN set;
  does NOT rotate the root key (D-034 closure = manual user step).

- T-8.6 (lead): scripts/verify_phase08.sh - loads rotated key from
  .env.secrets, asserts caller identity is acdl-spike-runner (not root),
  S3 bucket + DynamoDB table + IAM user + scoped policy with
  DenyEverythingElse all present, .env.secrets + .bootstrap_state.json
  gitignored. Uses heredoc python to avoid bash quoting issues.

- T-8.7 (lead): terraform/bootstrap/README.md runbook (6 steps incl.
  manual D-034 root-key rotation) + .gitignore (.env.secrets +
  .bootstrap_state.json). Spike vs v1.2 boundary table.

bash -n + gitignore checks pass.
2026-07-21 19:00:08 +00:00
Jon Chery f8ddd8b182 phase: 8, status: plan-as-execute, persona: security-engineer+platform-engineer, task: T-8.1..T-8.4
---ci---
project: acdl
phase: 8
milestone: v1.1
status: plan-as-execute
persona: security-engineer+platform-engineer
task: [T-8.1, T-8.2, T-8.3, T-8.4]
requirements.covered: [REQ-23]
---/ci---

Waves 1+2: IAM policy + state backend + IAM user creation scripts.

- T-8.1 (security): terraform/bootstrap/spike_runner_policy.json —
  least-privilege IAM policy: Allow S3 r/w on the state bucket, DynamoDB
  r/w on the outbox table, sts:GetCallerIdentity; final Deny statement
  (Action *, NotResource = the above ARNs) enforcing least privilege. No
  terraform apply permission (plan-only spike).

- T-8.2/T-8.3 (platform): terraform/bootstrap/create_state_backend.py —
  boto3, idempotent: creates S3 bucket acdl-tfstate-581513795199-us-east-1
  (versioning enabled) + DynamoDB table acdl-outbox (PAY_PER_REQUEST, PK
  contractId, SK eventType#eventTs per D-P08-1 one table for both lock
  + outbox). Writes .bootstrap_state.json marker.

- T-8.4 (platform + security review): terraform/bootstrap/create_iam_user.py
  — boto3, idempotent: creates IAM user acdl-spike-runner, attaches the
  inline policy from spike_runner_policy.json, creates an initial access
  key if none active exists (prints to stdout for the orchestrator to
  capture; NEVER committed).

py_compile + policy JSON valid.
2026-07-21 18:58:29 +00:00
Jon Chery a003168b3a docs(P08): create Phase 08 plan (aws-bootstrap)
---ci---
project: acdl
phase: 8
milestone: v1.1
status: plan
plan:
  waves: 5
  tasks: 8
  requirements: [REQ-23]
---/ci---

Phase 08 plan authored by ci-planner. 5 waves:
- Wave 1 (security): T-8.1 spike_runner_policy.json (least-privilege)
- Wave 2 (platform): T-8.2/T-8.3 create_state_backend.py, T-8.4 create_iam_user.py
- Wave 3 (platform): T-8.5 rotate_spike_key.sh
- Wave 4 (lead): T-8.6 verify_phase08.sh, T-8.7 README + .gitignore
- Wave 5 (lead, EXECUTE-only): T-8.8 run bootstrap against AWS + D-034 closure

7 authored files. Key decisions: D-P08-1 (one DynamoDB table acdl-outbox
for both lock + outbox), D-P08-2 (IAM user acdl-spike-runner not OIDC
role; OIDC deferred to v1.2 per D-039), D-P08-3 (Wave 5 EXECUTE-only),
D-P08-4 (optional Gitea secret upload), D-P08-5 (initial key is
throwaway).

Security: root key via env vars only (never committed); .env.secrets
gitignored; IAM policy explicit Deny-everything-else; D-034 closure =
user manually rotates root key post-phase.
2026-07-21 18:57:31 +00:00
Jon Chery 727c87339b fix(P08 prep): rename platform/ -> acdl_platform/ (stdlib shadow fix)
---ci---
project: acdl
phase: 8
milestone: v1.1
status: plan-as-execute
persona: lead-developer
task: T-8.0
type: prerequisite-fix
---/ci---

The Phase 07 P1 ('platform/ package shadows stdlib platform module')
became a Phase 08 blocker: boto3 imports uuid -> platform.system(),
which fails when the repo's platform/ package is on sys.path[0]. Renamed
platform/ -> acdl_platform/ (the verifier's recommended v1.2 fix, pulled
forward because Phase 08 needs boto3).

- git mv platform/ acdl_platform/ (history preserved)
- verify_phase07.sh: updated paths; removed the /tmp workaround (no
  longer needed; the shadow is gone)
- verify_phase06.sh: updated the new-dirs check for the rename
- README.md: layout table updated

Both verify_phase06.sh and verify_phase07.sh still pass; confidence_signal
now imports + runs correctly from the repo root. boto3 imports clean.
2026-07-21 18:53:41 +00:00
Jon Chery 167a92f621 verify(P07): VERIFIED — architecture v1.0 finalized, 9 files, 11 decisions
---ci---
project: acdl
phase: 7
milestone: v1.1
status: verify
verdict: VERIFIED
---/ci---

Phase 07 architecture-v1-finalization verified on main (HEAD 8723206,
tag v1.1.2). All four layers PASS:

- Structural: 9 deliverable files present; architecture-v1.0.md status
  is v1.0; all 11 decision IDs + Q1.3 in the snapshot; gitea-runner
  rename (D-046) applied; §15 table lists the 6 REQ-mapped files;
  3 JSON Schemas declare Draft 2020-12 with required fields per PLAN;
  3 .py files have expected docstrings + public functions; history
  preserved (T-7.1 92d4535 is creation point); tags v1.1.0/v1.1.1/v1.1.2
  all present.
- Behavioral: scripts/verify_phase07.sh exits 0 with expected final
  line; typecheck gate (bash -n + py_compile) passes; schema
  cross-checks (qa/prod/dr/agentic negative cases, staging rejected,
  valid PCR passes) all pass; confidence_signal spot-checks (missing
  input -> block + INPUT_MISSING; critical fail -> 0.0 block +
  CRITICAL_OVERRIDE; cold-start dev -> 0.95 pass) all pass; SoD
  spot-checks (None outbox, None item, equal approvers, distinct,
  empty approver_qa) all pass; Checkov adapter spot-check (CKV_AWS_24
  -> medium fail + ACDL_TAG_NAMING skipped appended) passes.
- Security: no secrets in v1.1.1..v1.1.2 file set; no boto3 imports
  (stdlib only); platform/ shadow of stdlib platform documented +
  worked around in verify_phase07.sh (cd /tmp for jsonschema); LSP
  diagnostic on confidence_signal.py:148 confirmed false positive
  (py_compile + AST parse pass; runtime correct).
- Quality: README layout table matches reality (platform/ + schemas/
  now populated); all 7 Phase 07 commits carry ---ci--- blocks;
  ROADMAP Phase 07 = complete (v1.1.2); REQUIREMENTS REQ-16..22 =
  complete (v1.1.2); architecture-v1.0.md §15 files all exist; §13
  resolutions match PROJECT.md decisions table.

Requirements covered: REQ-16, REQ-17, REQ-18, REQ-19, REQ-20, REQ-21,
REQ-22 (all 7 Phase 07 requirements; no partials).

P1 flags (post-hoc, out of Phase 07 scope):
- P1-1: platform/ package shadows stdlib platform module; v1.2 rename
  to acdl_platform/ (or src/ layout) would remove the workaround need.
- P1-2: LSP false positive on confidence_signal.py:148 (Dict[str, Any]
  typing confuses pyright); py_compile + runtime correct; a v1.2
  TypedDict tightening would silence it.
2026-07-21 18:50:40 +00:00
Jon Chery 8723206f5a ship: phase-07 architecture-v1-finalization (v1.1.2)
---ci---
project: acdl
phase: 7
milestone: v1.1
status: shipped
release:
  tag: v1.1.2
---/ci---

Squash merge of phase/07-architecture-v1-finalization. Architecture
finalized to v1.0: all 11 open decisions resolved (PROJECT.md); 9
deliverable files authored across 5 waves:
- docs/architecture-v1.0.md (REQ-16, snapshot)
- schemas/ir.schema.json (REQ-17, Target Stack IR)
- schemas/policy_check_result.schema.json + adapters/terraform/policy/checkov_adapter.py (REQ-18)
- platform/confidence_signal.py (REQ-19, 6-input signal, co-authored backend+security)
- platform/audit_ledger_design.md (REQ-20, tiered ledger, spike scope D-041)
- platform/hitl_matrix_design.md + platform/separation_of_duties.py (REQ-21)
- schemas/contract.schema.json (REQ-22, per-env mandatory W3.E)
scripts/verify_phase07.sh green: all 9 files present + validate.
2026-07-21 18:48:09 +00:00
Jon Chery 412e1ef62e phase: 7, status: plan-as-execute, persona: lead-developer, task: T-7.10
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan-as-execute
persona: lead-developer
task: T-7.10
---/ci---

Wave 5: scripts/verify_phase07.sh + traceability.

verify_phase07.sh asserts all 9 deliverable files exist, 3 JSON Schemas
validate as Draft 2020-12 (run from /tmp to avoid the repo platform/
package shadowing stdlib platform which jsonschema's uuid import needs),
3 .py files py_compile, 3 .md files non-empty, all 11 decision IDs +
OpenTofu in PROJECT.md, architecture-v1.0.md status is v1.0, D-040..D-044
present, spike contract validates against contract schema, minimal IR
validates against IR schema. All checks pass: 'VERIFIED - Phase 07:
architecture v1.0 finalized; 6 files authored + 11 decisions resolved'.

Traceability: REQUIREMENTS REQ-16..22 -> complete (v1.1.2); ROADMAP
Phase 07 -> complete (v1.1.2).
2026-07-21 18:47:58 +00:00
Jon Chery 68d90c08a7 phase: 7, status: plan-as-execute, persona: backend-engineer+security-engineer, task: T-7.9
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan-as-execute
persona: backend-engineer+security-engineer
task: T-7.9
requirements.covered: [REQ-19]
---/ci---

Wave 4 (co-authored): platform/confidence_signal.py (REQ-19).

backend-engineer: 6-input weighted sum (WEIGHTS = policy 0.30,
validation 0.25, freshness 0.10, source 0.15, history 0.10, nfrs 0.10 per
D-040; sums to 1.0), per-env thresholds (dev 0.50, qa 0.75, prod 0.90,
dr 0.95), _per_input_score rules, compute() orchestration, Signal
dataclass, dev-warn->block flip (autonomous, no reviewer).

security-engineer: PENALTY dict (critical=None hard-override sentinel,
high 0.20, medium 0.05, low 0.01, info 0.0), critical-override
short-circuit return in compute(), severity penalty loop over the
policy input's failing PolicyCheckResult records.

Verified: missing input -> block + INPUT_MISSING:<name>; critical fail
-> 0.0 block + CRITICAL_OVERRIDE:<ruleId>; cold-start spike dev (ACDL
_TAG_NAMING skipped, all validation true, nfrs neutral 0.5) -> 0.95 pass.
stdlib only.
2026-07-21 18:46:13 +00:00
Jon Chery 6ed93f0311 phase: 7, status: plan-as-execute, persona: security-engineer, task: T-7.4..T-7.8
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan-as-execute
persona: security-engineer
task: [T-7.4, T-7.5, T-7.6, T-7.7, T-7.8]
requirements.covered: [REQ-18, REQ-20, REQ-21]
---/ci---

Wave 3 (security-engineer, 5 files sequential):

- T-7.4: schemas/policy_check_result.schema.json (REQ-18 schema half) —
  canonical shape from ARCHITECTURE.md §12.6; engine enum
  [checkov,kyverno,opa]; severity enum [critical,high,medium,low,info];
  result enum [pass,fail,skipped,error]. Validates as Draft 2020-12;
  valid instance validates.

- T-7.5: adapters/terraform/policy/checkov_adapter.py (REQ-18 adapter
  half) — Checkov JSON -> PolicyCheckResult; RULE_MAP has all 11 Checkov
  rule IDs (CKV_AWS_41/45/46/20/57/24/25/1/40/7/33) mapped to the 4 L2
  checks + tag/naming; emits ACDL_TAG_NAMING SKIPPED per D-043; stdlib
  only; tolerates both Checkov JSON shapes. Synthetic fixture produces 3
  records all valid against the schema.

- T-7.6: platform/audit_ledger_design.md (REQ-20) — three tiers (S3
  Object Lock compliance 7yr, acdl-evidence hot index, DynamoDB outbox
  RPO=0); spike scope (D-041) = hash chain + outbox write; v1.2 build-out
  = Object Lock + JWS (KMS key, quarterly rotation) + async worker + DLQ
  + daily checkpoints. Outbox item shape, RPO/RTO table, decision trail.

- T-7.7: platform/hitl_matrix_design.md (REQ-21 design half) —
  pre-execution gate model; Gitea-specific mechanics (workflow_dispatch +
  gitea.actor per D-042, no Environments API); full 8-concern matrix
  verbatim from §10.4; timeout 1d warn / 2d freeze; rejection -> HELD +
  supersedes; CODEOWNERS routing; SoD pointer to the .py.

- T-7.8: platform/separation_of_duties.py (REQ-21 impl half) —
  check(outbox_client, contract_id, current_prod_approver) -> (ok,
  reason); None outbox -> no-op; equal -> SEPARATION_OF_DUTIES_VIOLATION;
  distinct -> ok; route_halt_artifact stub; stdlib only (duck-typed
  outbox_client). All 5 SoD cases verified.
2026-07-21 18:45:28 +00:00
Jon Chery f8e99ed906 phase: 7, status: plan-as-execute, persona: platform-engineer+backend-engineer, task: T-7.2+T-7.3
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan-as-execute
persona: platform-engineer+backend-engineer
task: [T-7.2, T-7.3]
requirements.covered: [REQ-17, REQ-22]
---/ci---

Wave 2 (parallel): two independent JSON Schemas, different owners.

- T-7.2 (platform-engineer): schemas/ir.schema.json — Target Stack IR
  (JSON Schema draft 2020-12). Resources with typed inputs/outputs/NFRs,
  relationships (single parent per child), composition tree max-depth-5,
  policy hooks. Substrate-agnostic (no Terraform block keywords, no aws_
  provider prefixes; type values are IR types like aws:s3:bucket). module
  pins L1 by name@semver (W3.D). shared_keyword reserved for v2. Validates
  as Draft 2020-12; minimal l2-static-asset IR instance validates.

- T-7.3 (backend-engineer): schemas/contract.schema.json — consumer
  contract (JSON Schema draft 2020-12). Per-env mandatory (W3.E): dev
  stack+environment; qa adds validation.e2eSuite+loadTest; prod adds
  runbook+dashboard+oncall; dr adds drDrillRef. inputs always optional.
  profile: agentic marker; naturalLanguageIntent required when agentic
  (fixed: if-condition requires profile to be present before checking
  const). environment enum has no staging. Validates as Draft 2020-12;
  spike dev contract validates; qa/prod/dr/agentic negative cases reject.
2026-07-21 18:43:33 +00:00
Jon Chery 92d4535f5f phase: 7, status: plan-as-execute, persona: lead-developer, task: T-7.1
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan-as-execute
persona: lead-developer
task: T-7.1
requirements.covered: [REQ-16]
---/ci---

Snapshot docs/architecture.md (v0.2) to v1.0. Body §§1-12 copied verbatim;
resolution log + §13 markers rewritten to  RESOLVED (see PROJECT.md);
§14 status bumped to v1.0; new §15 maps the 6 Phase 07 authored files to
their REQs + owner personas. gitea-runner rename (D-046) applied;
act_runner appears only in a 'formerly' note. All 11 open-decision IDs
present (W1.A, W1.B, W2.A, W3.D, W3.E, BA.A-F, Q1.3 OpenTofu).
2026-07-21 18:42:37 +00:00
Jon Chery b40aadd195 docs(P07): create Phase 07 plan (architecture-v1-finalization)
---ci---
project: acdl
phase: 7
milestone: v1.1
status: plan
plan:
  waves: 5
  tasks: 10
  requirements: [REQ-16, REQ-17, REQ-18, REQ-19, REQ-20, REQ-21, REQ-22]
---/ci---

Phase 07 plan authored by ci-planner. 5 waves (strictly ordered):
- Wave 1 (lead-developer): REQ-16 architecture-v1.0.md snapshot (umbrella)
- Wave 2 (platform + backend parallel): REQ-17 ir.schema.json || REQ-22 contract.schema.json
- Wave 3 (security-engineer, 5 files): REQ-18 PolicyCheckResult schema + checkov_adapter.py, REQ-20 audit_ledger_design.md, REQ-21 hitl_matrix_design.md + separation_of_duties.py
- Wave 4 (backend + security co-authored): REQ-19 confidence_signal.py (depends on Wave 3)
- Wave 5 (lead-developer): verify_phase07.sh + traceability

9 deliverable files + 1 verify script. Cross-persona co-authorship on
confidence_signal.py (backend weighted-sum + security penalty mapping)
mitigated by the PLAN content checklist fixing the critical-override
sentinel + short-circuit location.
2026-07-21 18:40:20 +00:00
Jon Chery 0779a92e2f verify(P06): VERIFIED — structural, behavioral, security, quality
---ci---
project: acdl
phase: 6
milestone: v1.1
status: verify
verdict: VERIFIED
---ci---

All four verification layers pass for Phase 06 (v1.1.1):
- Structural: demo/ contains the full v1.0 demo (history preserved via
  git mv); new v1.1 top-level dirs scaffolded with .gitkeep; no stray
  v1.0 dirs at root; v1.0.1..v1.0.5 + v1.1.0 + v1.1.1 tags present.
- Behavioral: typecheck gate green; scripts/verify_phase06.sh exits 0
  with "Phase 06: ALL CHECKS PASS"; demo/scripts/run_demo.sh --no-upload
  produces a non-empty, hash-chained audit.json in /tmp/acdl_demo_run/.
- Security: no .env/tfstate/_key/secret files in v1.1.0..v1.1.1 diff;
  the only content authored in the phase was the move commit, README,
  .gitignore, and the verify script. LSP error on
  demo/scripts/finalize_evidence.py:46 is pre-existing v1.0 demo code
  (authored at v1.0.4, Phase 06 only git-mv'd it) — not a regression.
- Quality: all README link targets exist (docs/vision.md,
  docs/architecture.md, .ciagent/{PROJECT,ARCHITECTURE,ROADMAP}.md,
  demo/ACDL_DEMO.md); every phase commit carries a ---ci--- block with
  the required fields; ROADMAP §Phase 06 status = complete (v1.1.1).

P1 (post-hoc, non-blocking): scripts/verify_phase06.sh does not
programmatically assert runner-data/ is in .gitignore. The must-have
is satisfied structurally (file content verified); only the assertion
is missing. Recommend adding `grep -q '^runner-data/$' .gitignore` in
a future touch-up.

No P0 issues. Phase 06 has no new REQ (repo hygiene).
2026-07-21 18:29:32 +00:00
26 changed files with 3404 additions and 430 deletions
+1091 -416
View File
File diff suppressed because it is too large Load Diff
+8 -8
View File
@@ -114,14 +114,14 @@
| Requirement | Phase | Status |
|-------------|-------|--------|
| REQ-16 | 07 | pending |
| REQ-17 | 07 | pending |
| REQ-18 | 07 | pending |
| REQ-19 | 07 | pending |
| REQ-20 | 07 | pending |
| REQ-21 | 07 | pending |
| REQ-22 | 07 | pending |
| REQ-23 | 08 | pending |
| REQ-16 | 07 | complete (v1.1.2) |
| REQ-17 | 07 | complete (v1.1.2) |
| REQ-18 | 07 | complete (v1.1.2) |
| REQ-19 | 07 | complete (v1.1.2) |
| REQ-20 | 07 | complete (v1.1.2) |
| REQ-21 | 07 | complete (v1.1.2) |
| REQ-22 | 07 | complete (v1.1.2) |
| REQ-23 | 08 | complete (v1.1.3) |
| REQ-24 | 09 | pending |
| REQ-25 | 10 | pending |
| REQ-26 | 09 | pending |
+2 -2
View File
@@ -90,7 +90,7 @@ milestone COMPLETE: `v1.2.0` (feature milestone, next minor per ship.md).
### Phase 07 — architecture-v1-finalization
- **Description:** Resolve the 11 open decisions in `docs/architecture.md` §13 (already recorded in `PROJECT.md`). Author the locked schemas + designs: `schemas/ir.schema.json` (REQ-17), `schemas/policy_check_result.schema.json` (REQ-18), `schemas/contract.schema.json` (REQ-22), `platform/confidence_signal.py` spec (REQ-19), `platform/audit_ledger_design.md` (REQ-20), `platform/hitl_matrix_design.md` (REQ-21). Mark architecture v1.0.
- **Status:** pending
- **Status:** complete (v1.1.2)
- **Depends on:** [06]
- **Requirements:** REQ-16, REQ-17, REQ-18, REQ-19, REQ-20, REQ-21, REQ-22
- **Success Criteria:**
@@ -100,7 +100,7 @@ milestone COMPLETE: `v1.2.0` (feature milestone, next minor per ship.md).
### Phase 08 — aws-oidc-bootstrap
- **Description:** **Re-scoped per RESEARCH TARGET 1 + D-039.** Gitea Actions does not support `id-token: write` (conf 0.95), so real OIDC is deferred to v1.2. This phase instead: uses the temporary long-lived key (waiver D-034) once to create an S3 state bucket, a DynamoDB lock/outbox table, and an IAM user with a minimal scoped policy (S3 + DynamoDB + plan-only); stores the key as a Gitea Actions secret; implements `scripts/rotate_spike_key.sh` to rotate the key after each spike run. Real OIDC federation is tracked via go-gitea/gitea#36988 for v1.2.
- **Status:** pending
- **Status:** complete (v1.1.3)
- **Depends on:** [07]
- **Requirements:** REQ-23 (re-interpreted: AWS auth bootstrap + state backend; OIDC deferred to v1.2 per D-039)
- **Success Criteria:**
+514
View File
@@ -0,0 +1,514 @@
# Phase 07 — architecture-v1-finalization (v1.1.2) Verification
Verifying Phase 07 on `main` (HEAD `8723206`, tag `v1.1.2`). Phase branch
`phase/07-architecture-v1-finalization` deleted after squash merge.
Phase 07 was a **design-authoring phase**: it locked the ACDL architecture
to v1.0 by authoring 9 deliverable files (6 REQ-mapped schema/design
files + the Checkov adapter + the SoD module + the architecture-v1.0
snapshot) that resolve all 11 open decisions in `docs/architecture.md`
§13 (W1.A, W1.B, W2.A, W3.D, W3.E, BA.A, BA.B, BA.C, BA.D, BA.E, BA.F +
the OpenTofu timing sub-decision Q1.3), recorded in `PROJECT.md` under
decisions D-034..D-046.
Verification layers: structural, behavioral, security, quality. All
layers PASS. Final verdict: **Phase 07: VERIFIED**.
## Layer 1 — Structural: PASS
### 1.1 All 9 deliverable files exist
```
$ ls -la docs/architecture-v1.0.md schemas/ir.schema.json \
schemas/policy_check_result.schema.json schemas/contract.schema.json \
adapters/terraform/policy/checkov_adapter.py platform/confidence_signal.py \
platform/audit_ledger_design.md platform/hitl_matrix_design.md \
platform/separation_of_duties.py scripts/verify_phase07.sh
-rw-r--r-- 1 root root 30167 Jul 21 18:48 docs/architecture-v1.0.md
-rw-r--r-- 1 root root 5538 Jul 21 18:48 schemas/ir.schema.json
-rw-r--r-- 1 root root 2484 Jul 21 18:48 schemas/policy_check_result.schema.json
-rw-r--r-- 1 root root 3924 Jul 21 18:48 schemas/contract.schema.json
-rw-r--r-- 1 root root 3578 Jul 21 18:48 adapters/terraform/policy/checkov_adapter.py
-rw-r--r-- 1 root root 5787 Jul 21 18:48 platform/confidence_signal.py
-rw-r--r-- 1 root root 5036 Jul 21 18:48 platform/audit_ledger_design.md
-rw-r--r-- 1 root root 6321 Jul 21 18:48 platform/hitl_matrix_design.md
-rw-r--r-- 1 root root 1835 Jul 21 18:48 platform/separation_of_duties.py
-rwxr-xr-x 1 root root 3831 Jul 21 18:48 scripts/verify_phase07.sh
```
All 9 REQ-mapped files + the verify script are present (sizes non-zero).
### 1.2 `docs/architecture-v1.0.md` status line is v1.0 (not v0.2)
```
$ grep -n "Status:" docs/architecture-v1.0.md | head -3
14: Status: **v1.0** (snapshot taken in ACDL Phase 07, milestone v1.1). All 11
429: Status: **v1.0**. All 11 open items in §13 are resolved. ...
```
Status line at L14 says `v1.0` (Phase 07 bump); the upstream `v0.2`
status does not survive into the snapshot's status line.
### 1.3 All 11 open-decision IDs + Q1.3 appear in the snapshot
```
$ grep -cE "W1\.A|W1\.B|W2\.A|W3\.D|W3\.E|BA\.A|BA\.B|BA\.C|BA\.D|BA\.E|BA\.F|Q1\.3" \
docs/architecture-v1.0.md
33
```
Every one of the 11 IDs + Q1.3 appears in both the resolution log table
(L2637) and the §13 "✅ RESOLVED (see PROJECT.md)" markers (L75425).
Each row carries the resolution text + a pointer to `PROJECT.md`.
### 1.4 `gitea-runner` rename (D-046) applied; `act_runner` only in "formerly" note
```
$ grep -n "act_runner\|gitea-runner" docs/architecture-v1.0.md
9: > `act_runner` → `gitea-runner` rename (D-046, 2026-04 in gitea/runner#850)
10: > is applied; `act_runner` appears only in a "formerly" note.
352: > gitea-runner v2.1.0 (formerly `act_runner`, renamed 2026-04 in
```
`gitea-runner` is the body name; `act_runner` only appears in the
header note + the "formerly" parenthetical at L352. D-046 satisfied.
### 1.5 §15 table lists all 6 REQ-mapped files
```
$ sed -n '441,455p' docs/architecture-v1.0.md
## 15. Phase 07 authored artifacts
...
| REQ | File | Owner persona |
|-----|------|--------------|
| REQ-17 | `schemas/ir.schema.json` | platform-engineer |
| REQ-18 | `schemas/policy_check_result.schema.json` + `adapters/terraform/policy/checkov_adapter.py` | security-engineer |
| REQ-19 | `platform/confidence_signal.py` | backend-engineer + security-engineer (co-authored) |
| REQ-20 | `platform/audit_ledger_design.md` | security-engineer |
| REQ-21 | `platform/hitl_matrix_design.md` + `platform/separation_of_duties.py` | security-engineer |
| REQ-22 | `schemas/contract.schema.json` | backend-engineer |
```
All 6 REQ rows + the 8 underlying files are listed. All §15 files
exist on disk (cross-checked with `os.path.exists` for every entry).
### 1.6 The 3 JSON Schemas declare Draft 2020-12 + required fields
```
$ grep -n '\$schema\|draft/2020-12' schemas/*.schema.json
schemas/ir.schema.json:2: "$schema": "https://json-schema.org/draft/2020-12/schema",
schemas/policy_check_result.schema.json:2: "$schema": "https://json-schema.org/draft/2020-12/schema",
schemas/contract.schema.json:2: "$schema": "https://json-schema.org/draft/2020-12/schema",
```
Per-file required-fields check:
- `schemas/ir.schema.json`: `required: [version, stack, resources]`;
`stack.depth` max 5; `stack.name` pattern `^l[12]-[a-z][a-z0-9-]*$`;
`stack.kind` enum `[l1, l2]`; `resource.module` pattern
`^l1-[a-z][a-z0-9-]*@\d+\.\d+\.\d+$` (W3.D name@semver); `relationship.kind`
enum `[parent, depends_on, uses_output]`; `shared_keyword` reserved
(present, unused). ✅
- `schemas/policy_check_result.schema.json`: `required: [contractId,
evaluatedAt, engine, ruleId, severity, result, message, resourceRef]`;
`engine` enum `[checkov, kyverno, opa]`; `severity` enum `[critical,
high, medium, low, info]`; `result` enum `[pass, fail, skipped, error]`;
`evidence` optional with `additionalProperties: true`. ✅
- `schemas/contract.schema.json`: top `required: [stack, environment]`;
`stack` pattern `^l2-[a-z][a-z0-9-]*$`; `environment` enum `[dev, qa,
prod, dr]` (no `staging`); `profile` enum `[developer, agentic]`
default `developer`; `allOf` conditionals present: qa→`[validation]`,
prod→`[runbook, dashboard, oncall]`, dr→`[drDrillRef]`,
agentic→`[naturalLanguageIntent]`. ✅
Substrate-agnostic invariant for IR schema: the only occurrence of
`aws_s3_bucket` is in the `$comment` (L6) and a `description` (L61)
where it is explicitly called out as the *non*-IR / *Terraform* type to
avoid. No Terraform-block keywords (`variable`/`output` as JSON keys,
`tf_block`) appear in the schema body. Invariant satisfied.
### 1.7 The 3 .py files have expected module docstrings + public functions
- `platform/confidence_signal.py` (REQ-19, T-7.9): module docstring
(L132) enumerates the 6 inputs + weights + severity→penalty +
per-env thresholds. Public surface: `WEIGHTS`, `PENALTY`,
`THRESHOLDS`, `Signal` dataclass, `_per_input_score`, `compute`,
`__main__` CLI. ✅
- `platform/separation_of_duties.py` (REQ-21, T-7.8): module docstring
(L112) explains `qaApprover != prodApprover` + outbox read + spike
dev-only note. Public surface: `check(outbox_client, contract_id,
current_prod_approver)`, `route_halt_artifact(...)`. ✅
- `adapters/terraform/policy/checkov_adapter.py` (REQ-18, T-7.5): module
docstring (L111) "Translate Checkov JSON output to ACDL
PolicyCheckResult records". Public surface: `RULE_MAP`,
`_iso8601_now`, `_to_pcr`, `_emit_tag_naming_skipped`, `adapt`,
`__main__` CLI. ✅
### 1.8 History preservation — `docs/architecture-v1.0.md` is a new file
```
$ git log --follow --oneline docs/architecture-v1.0.md
92d4535 phase: 7, status: plan-as-execute, persona: lead-developer, task: T-7.1
```
Single creation commit (T-7.1, 92d4535). As expected for a new file —
the upstream `docs/architecture.md` (52665b8 → b84a8a2) history is
preserved on the upstream file itself; the snapshot is intentionally a
new file, not a copy-with-rename.
### 1.9 Tags v1.1.0, v1.1.1, v1.1.2 all exist
```
$ git tag --list 'v1.1*'
v1.1.0
v1.1.1
v1.1.2
```
## Layer 2 — Behavioral: PASS
### 2.1 `scripts/verify_phase07.sh` exits 0 with the expected final line
```
$ bash scripts/verify_phase07.sh
ok: all 9 deliverable files exist
ok: 3 JSON Schemas validate as Draft 2020-12
ok: 3 .py files py_compile
ok: 3 .md design files non-empty
ok: all 11 decision IDs + OpenTofu present in PROJECT.md
ok: docs/architecture-v1.0.md status is v1.0
ok: D-040..D-044 present in PROJECT.md
ok: spike contract validates against contract schema
ok: minimal IR validates against IR schema
VERIFIED — Phase 07: architecture v1.0 finalized; 6 files authored + 11 decisions resolved
$ echo $?
0
```
All 9 assertions in the script pass; final line matches PLAN.md spec.
### 2.2 Typecheck gate
```
$ bash -n scripts/verify_phase07.sh && \
python3 -m py_compile platform/confidence_signal.py \
platform/separation_of_duties.py \
adapters/terraform/policy/checkov_adapter.py
TYPECHECK_OK
```
`bash -n` (syntax) + `py_compile` (byte-compile) all pass.
### 2.3 Schema cross-checks (PLAN.md self-verify test instances)
Run from `/tmp` to avoid the repo `platform/` package shadowing stdlib
`platform` (see Layer 3 §3.3):
```
OK: qa without validation fails
OK: prod without runbook fails
OK: dr without drDrillRef fails
OK: agentic without NLI fails
OK: agentic with NLI passes
OK: staging rejected
OK: valid PCR passes
ALL_SCHEMA_CROSSCHECKS_OK
```
`environment` enum confirmed `[dev, qa, prod, dr]` — no `staging`
(Path A locked, ARCHITECTURE.md §5). Per-env mandatory conditionals all
fire correctly.
### 2.4 Confidence signal behavioral spot-checks (REQ-19)
Run from `/tmp` with `sys.path.insert(0, '/root/acdl')`:
- **Missing input → block + INPUT_MISSING:** `compute('cid','dev', inputs)`
with `nfrs` omitted returns `Signal(0.0, "block", {}, ["INPUT_MISSING:nfrs"])`. ✅
- **Critical fail → 0.0 block + CRITICAL_OVERRIDE:** `compute('cid','dev', inputs)`
with one `severity:"critical", result:"fail"` PolicyCheckResult returns
`Signal(0.0, "block", per_input, ["CRITICAL_OVERRIDE:CKV_AWS_X"])`
regardless of other inputs. ✅
- **Cold-start dev → pass ≥ 0.50:** `compute('cid','dev', inputs)` with
the ACDL_TAG_NAMING `skipped` PolicyCheckResult + all validation true
+ neutral 0.5 for freshness/source/history/nfrs returns
`Signal(0.950, "pass", ...)`. ✅ (0.95 ≥ 0.50 dev threshold).
Note: the `WEIGHTS` dict keys are `policy / validation / freshness /
source / history / nfrs` (the canonical names), not the docstring's
`policy_results` label — the docstring describes the input's *type*
("list[PolicyCheckResult]"); the `compute()` loop iterates
`WEIGHTS.items()` and reads `inputs.get("policy")` (the key). This is
consistent with the Wave 4 self-verify ("`policy_results`" in the
docstring is the descriptive label, `policy` is the dict key — verified
at runtime).
### 2.5 Separation-of-duties behavioral spot-checks (REQ-21)
- `check(None, "cid", "anyone")` → `(True, "no outbox client (dev-only spike)")`. ✅
- `check(stub_returning_None, "cid", "anyone")` → `(True, "no prior approver (first promotion)")`. ✅
- `check(stub_with_approver_qa("alice"), "cid", "alice")` → `(False, "SEPARATION_OF_DUTIES_VIOLATION: qaApprover==prodApprover==alice")`. ✅
- `check(stub_with_approver_qa("alice"), "cid", "bob")` → `(True, "distinct")`. ✅
- `check(stub_with_empty_approver_qa, "cid", "alice")` → `(True, "no QA approver recorded (dev-only spike)")`. ✅
All SoD branches match PLAN.md T-7.8 spec.
### 2.6 Checkov adapter behavioral spot-check (REQ-18 adapter)
Synthetic Checkov JSON with one failed `CKV_AWS_24`:
```
$ python3 adapters/terraform/policy/checkov_adapter.py fixture.json test-contract-id
[
{
"contractId": "test-contract-id",
"evaluatedAt": "2026-07-21T18:49:11Z",
"engine": "checkov",
"ruleId": "CKV_AWS_24",
"severity": "medium", ← per RULE_MAP (public-ingress SG 0.0.0.0/0)
"result": "fail",
"message": "SG 0.0.0.0/0 on 22",
"evidence": {"file_path": null, "resource": "aws_security_group.r1",
"resource_address": "aws_security_group.r1", "code_block": null},
"resourceRef": "aws_security_group.r1"
},
{
"contractId": "test-contract-id",
"ruleId": "ACDL_TAG_NAMING", ← D-043 appended SKIPPED record
"severity": "info",
"result": "skipped",
"message": "tag/naming check deferred to v1.2 (D-043)",
"evidence": {},
"resourceRef": ""
}
]
```
Severity correctly defaulted to `medium` for `CKV_AWS_24` from `RULE_MAP`;
`ACDL_TAG_NAMING` SKIPPED record appended (D-043). Both records validate
against `schemas/policy_check_result.schema.json`.
## Layer 3 — Security: PASS
### 3.1 No credentials/secrets introduced
Files touched by Phase 07 (v1.1.1..v1.1.2):
```
$ git log v1.1.1..v1.1.2 --diff-filter=A --name-only --pretty=format: | sort -u
.ciagent/PLAN.md
.ciagent/REQUIREMENTS.md
.ciagent/ROADMAP.md
.ciagent/VERIFY.md
adapters/terraform/policy/__init__.py
adapters/terraform/policy/checkov_adapter.py
docs/architecture-v1.0.md
platform/__init__.py
platform/audit_ledger_design.md
platform/confidence_signal.py
platform/hitl_matrix_design.md
platform/separation_of_duties.py
schemas/contract.schema.json
schemas/ir.schema.json
schemas/policy_check_result.schema.json
scripts/verify_phase07.sh
```
No `.env`, no `*.tfstate`, no `*_key*`, no `credentials*` files. Phase 07
is design authoring + stdlib-only Python — no AWS/TF runtime calls, no
boto3 imports (the spike passes a duck-typed `outbox_client`).
### 3.2 LSP diagnostic on `platform/confidence_signal.py:148` is a false positive
```
$ python3 -m py_compile platform/confidence_signal.py
$ python3 -c "import ast; ast.parse(open('platform/confidence_signal.py').read()); print('AST parse OK')"
AST parse OK
```
At L148, `p = PENALTY.get(sev, 0.0)` — `sev` comes from
`pcr.get("severity")` where `pcr` is `Dict[str, Any]`. The LSP
("No overloads for `get` match the provided arguments") is a known
false-positive when `.get()` is called on a `Dict[str, Any]` value
in some pyright configurations. `py_compile` passes; runtime behavior
is verified correct in §2.4 (the critical-override branch returns the
expected `CRITICAL_OVERRIDE:<ruleId>` and the `None` sentinel correctly
short-circuits via `if p is None:` at L149). Not a real bug.
### 3.3 `platform/` package shadows stdlib `platform` — documented + worked around
The repo's `platform/` Python package (our code) shadows the stdlib
`platform` module when the repo root is on `sys.path[0]` (which a
`python3 -c` invocation from repo root triggers). `jsonschema` imports
`uuid` → `uuid` imports `platform.system()` → fails with
`AttributeError: module 'platform' has no attribute 'system'`.
`scripts/verify_phase07.sh` documents this and works around it by
running all `jsonschema`-invoking python from `/tmp` with absolute
paths to the schemas:
```
$ grep -n "platform\|cd /tmp\|sys.path\|shadow" scripts/verify_phase07.sh
24: # Run python from /tmp so the repo's `platform/` package does not shadow the
25: # stdlib `platform` module (jsonschema imports uuid -> platform.system();
26: # our platform/ shadows it when cwd is repo root and on sys.path[0]).
28: ( cd /tmp && python3 -c "..." )
70: ( cd /tmp && python3 -c "..." )
78: ( cd /tmp && python3 -c "..." )
```
The workaround is correct: `cwd=/tmp` puts `/tmp` at `sys.path[0]`, so
`import platform` resolves to the stdlib, not our package; the schemas
are passed by absolute path. The verify script passes (§2.1), and my
inline behavioral spot-checks (§2.32.5) reproduced the workaround by
running from `/tmp` + `sys.path.insert(0, '/root/acdl')` to import our
modules explicitly.
**P1 — flag for post-hoc cleanup:** a v1.2 rename of `platform/` to
`acdl_platform/` (or moving the package under a `src/` layout) would
avoid the shadowing entirely, removing the need for the `/tmp` dance in
every jsonschema-invoking test. This is out of Phase 07 scope (Phase 07
must ship the `platform/` layout the README + PLAN.md committed to).
Flagged for v1.2.
### 3.4 No `import boto3` in the Phase 07 .py files
```
$ grep -nE "^import |^from " platform/confidence_signal.py \
platform/separation_of_duties.py \
adapters/terraform/policy/checkov_adapter.py
platform/confidence_signal.py:34: from dataclasses import dataclass, asdict
platform/confidence_signal.py:35: from typing import List, Literal, Optional, Dict, Any
platform/confidence_signal.py:36: import json
platform/confidence_signal.py:37: import sys
platform/separation_of_duties.py:14: from typing import Optional, Tuple
adapters/terraform/policy/checkov_adapter.py:13: import datetime
adapters/terraform/policy/checkov_adapter.py:14: import json
adapters/terraform/policy/checkov_adapter.py:15: import sys
```
Stdlib only across all 3 modules. The SoD `check()` signature receives
a duck-typed `outbox_client` (has `.get(pk)`); the pipeline step owns the
boto3 client. PLAN.md T-7.8 spec satisfied.
## Layer 4 — Quality: PASS
### 4.1 README layout table still matches reality
```
$ grep -n "platform/\|schemas/\|adapters/" README.md
31: | `platform/` | Platform code: confidence signal, contract resolver, outbox, HITL/ledger designs | Phase 07+ |
32: | `schemas/` | JSON Schemas: IR, PolicyCheckResult, contract | Phase 07 |
33: | `adapters/` | Substrate adapters (Terraform adapter in v1; the only substrate-specific code per §12) | Phase 09 |
```
README's "Phase 07+" and "Phase 07" annotations are now accurate —
`platform/` and `schemas/` are populated with the 9 deliverable files
(no longer just `.gitkeep`'d). `adapters/` is annotated "Phase 09"
which is also accurate: only the `policy/` subdirectory is populated in
Phase 07 (the Checkov adapter, REQ-18), and the rest of the adapter
surface (the IR→Terraform module compiler) is Phase 09.
### 4.2 Phase 07 commit messages all carry `---ci---` blocks
Phase 07 commits on main (v1.1.1..v1.1.2):
```
8723206 ship: phase-07 architecture-v1-finalization (v1.1.2)
412e1ef phase: 7, status: plan-as-execute, persona: lead-developer, task: T-7.10
68d90c0 phase: 7, status: plan-as-execute, persona: backend-engineer+security-engineer, task: T-7.9
6ed93f0 phase: 7, status: plan-as-execute, persona: security-engineer, task: T-7.4..T-7.8
f8e99ed phase: 7, status: plan-as-execute, persona: platform-engineer+backend-engineer, task: T-7.2+T-7.3
92d4535 phase: 7, status: plan-as-execute, persona: lead-developer, task: T-7.1
b40aadd docs(P07): create Phase 07 plan (architecture-v1-finalization)
```
Each execute commit + the ship commit carries a `---ci---` block with
`project / phase / milestone / status / persona / task` (execute commits)
or `release.tag` (ship commit). Verified by inspecting commit bodies
(`git log v1.1.1..v1.1.2 --pretty=format:'%H %s%n---%n%b%n---'`):
T-7.1, T-7.2+7.3, T-7.4..7.8, T-7.9, T-7.10, and the merge all include
well-formed `---ci---` blocks. ✅
### 4.3 `ROADMAP.md` Phase 07 status = "complete (v1.1.2)"
```
$ grep -n "Phase 07\|complete.*v1.1.2\|status" .ciagent/ROADMAP.md | head -5
91: ### Phase 07 — architecture-v1-finalization
93: - **Status:** complete (v1.1.2)
```
### 4.4 `REQUIREMENTS.md` traceability — REQ-16..22 complete (v1.1.2)
```
$ grep -n "REQ-1[6-9]\|REQ-2[0-2]" .ciagent/REQUIREMENTS.md | tail -7
117: | REQ-16 | 07 | complete (v1.1.2) |
118: | REQ-17 | 07 | complete (v1.1.2) |
119: | REQ-18 | 07 | complete (v1.1.2) |
120: | REQ-19 | 07 | complete (v1.1.2) |
121: | REQ-20 | 07 | complete (v1.1.2) |
122: | REQ-21 | 07 | complete (v1.1.2) |
123: | REQ-22 | 07 | complete (v1.1.2) |
```
All 7 Phase 07 requirements marked complete at v1.1.2.
### 4.5 `docs/architecture-v1.0.md` internal consistency
- The §15 table's 6 files (8 underlying paths) all exist on disk
(verified via `os.path.exists` for every entry). ✅
- The 11 resolutions in the §13 markers (L75425) match the
`PROJECT.md` "Open-decision resolutions" table (L178189) verbatim
(W1.A, W1.B, W2.A, W3.D, W3.E, BA.A, BA.B, BA.C, BA.D, BA.E, BA.F) +
the Q1.3-OpenTofu sub-decision. ✅
- Decisions D-034..D-046 all present in `PROJECT.md` (the decision
table at L160172). ✅
## Issues found
### P0 (blocking) — none
No P0 issues. All must-haves from PLAN.md are satisfied; the phase gate
`scripts/verify_phase07.sh` is green; behavioral spot-checks all pass.
### P1 (post-hoc cleanup, out of Phase 07 scope)
- **P1-1: `platform/` package shadows stdlib `platform`.** The repo's
`platform/` directory is a Python package that shadows the stdlib
`platform` module when the repo root is on `sys.path` (any `python3 -c`
from repo root). This breaks `jsonschema` (which imports `uuid` →
`platform.system()`). `scripts/verify_phase07.sh` works around it by
running jsonschema-invoking python from `/tmp`, but the workaround is
brittle — every future test script that imports `jsonschema` (or any
stdlib module that transitively imports `platform`) from repo root
will hit the same shadow. Recommended v1.2 fix: rename `platform/` →
`acdl_platform/` (or adopt a `src/` layout) so the package no longer
collides with the stdlib name. Out of Phase 07 scope (the layout is
locked by Phase 06 + README + PLAN.md).
- **P1-2: LSP false positive on `platform/confidence_signal.py:148`.**
The "No overloads for `get` match the provided arguments" diagnostic
is a pyright false positive triggered by `Dict[str, Any]` typing on
`pcr`. `py_compile` passes; runtime behavior is correct (verified in
§2.4). No fix needed in Phase 07; if a v1.2 type tightening pass
happens, replacing `Dict[str, Any]` with a `TypedDict` for
`PolicyCheckResult` would silence the LSP and improve type safety.
## Requirement coverage summary
| REQ | File(s) | Status |
|-----|---------|--------|
| REQ-16 | `docs/architecture-v1.0.md` | covered (v1.1.2) |
| REQ-17 | `schemas/ir.schema.json` | covered (v1.1.2) |
| REQ-18 | `schemas/policy_check_result.schema.json` + `adapters/terraform/policy/checkov_adapter.py` | covered (v1.1.2) |
| REQ-19 | `platform/confidence_signal.py` | covered (v1.1.2) |
| REQ-20 | `platform/audit_ledger_design.md` | covered (v1.1.2) |
| REQ-21 | `platform/hitl_matrix_design.md` + `platform/separation_of_duties.py` | covered (v1.1.2) |
| REQ-22 | `schemas/contract.schema.json` | covered (v1.1.2) |
All 7 Phase 07 requirements covered. No partials.
## Final verdict
Phase 07: VERIFIED
+3 -1
View File
@@ -7,4 +7,6 @@ state.json
audit.json
*.tmp
.DS_Store
runner-data/
runner-data/
.env.secrets
terraform/bootstrap/.bootstrap_state.json
+1 -1
View File
@@ -28,7 +28,7 @@ a configuration file, or a Terraform module.
| Path | Purpose | Populated |
|------|---------|-----------|
| `platform/` | Platform code: confidence signal, contract resolver, outbox, HITL/ledger designs | Phase 07+ |
| `acdl_platform/` | Platform code: confidence signal, contract resolver, outbox, HITL/ledger designs (renamed from `platform/` in Phase 08 to avoid shadowing the stdlib `platform` module) | Phase 07+ |
| `schemas/` | JSON Schemas: IR, PolicyCheckResult, contract | Phase 07 |
| `adapters/` | Substrate adapters (Terraform adapter in v1; the only substrate-specific code per §12) | Phase 09 |
| `terraform/` | State backend + provider config (S3 state + DynamoDB lock) | Phase 08+ |
View File
+103
View File
@@ -0,0 +1,103 @@
# ACDL Tiered Audit Ledger Design (REQ-20)
> **Status:** design authored in Phase 07 (milestone v1.1); the spike
> (Phases 08-10) implements the **v1.0 hash chain + DynamoDB outbox write**
> (D-041); the v1.2 build-out implements S3 Object Lock + JWS + async
> worker + DLQ + daily checkpoints.
The audit stream is the platform's tamper-evident record of every delivery
action. The vision's "Audit truth lives outside the repository" bet [1]
and "Not a mutable audit log" anti-goal [1] are the binding constraints.
Version-control history does not satisfy regulatory evidence; the ledger
is the source of truth.
## Three tiers
- **Cold tier (source of truth):** S3 with **Object Lock in compliance
mode**, **7-year retention** (ARCHITECTURE.md §9). No one — including
root — can delete or overwrite until retention expires. The regulatory
record.
- **Hot tier (query index):** the `acdl-evidence` audit repo (unchanged
from the v1.0 demo). Not part of the chain; a queryable mirror the
evidence UI (`evidence-ui/index.html`) reads. Lightweight attestation
linkage lives in the repo; the regulatory event body lives in S3.
- **Outbox (write path):** DynamoDB, **RPO = 0** (synchronous write before
contract submission ack). Single-region in v1 (`us-east-1`).
## Spike scope (D-041) — what Phases 08-10 implement
- **DynamoDB outbox:** table `acdl-outbox`, `PAY_PER_REQUEST` (D-044),
PK `contractId`, SK `eventType#eventTs`, TTL `expire_at` = now + 365d
(1-year storage per ARCHITECTURE.md §8).
- **`prev_event_hash` chain:** SHA-256 over canonical JSON
(`json.dumps(event, sort_keys=True, separators=(",", ":"))`), lifted
from the v1.0 demo's `evidence_writer.py`. Auto-genesis: first event
has `prev_hash="GENESIS"`.
- **Synchronous write** via boto3 `put_item` (strong-consistent by
default). No separate async worker / DLQ in the spike (RTO = workflow
re-run).
- **Mirror to `acdl-evidence`:** unchanged from v1.0 — the finalize step
commits `audit.json` to the evidence repo (the hot tier).
- **Spike evidence event shape:**
`{seq, ts, stage, event, prev_hash, hash, contractId, environment, stack, score, band}`.
## v1.2 build-out — what Phase 07 designs but the spike defers
- **S3 Object Lock:** bucket `acdl-evidence-lock-<account-id>`, Object
Lock enabled at creation, compliance mode, 7-yr retention
(`RetainUntilDate` = now + 7y). The outbox→S3 path is an async worker
that reads from the outbox and writes to Object Lock.
- **JWS detached signature (RFC 7515):** the event payload is
canonical-JSON-serialized, SHA-256 hashed, signed with a private key;
the signature is stored *detached* alongside the payload. Signing key =
**platform-level KMS key** (not per-contract — a per-contract key would
explode the key-management surface), rotated **quarterly**. The `jws`
field is added to the event shape in v1.2.
- **Async worker + DLQ:** a Lambda (or a Gitea Actions scheduled workflow)
reads the outbox, writes to S3 Object Lock, signs with KMS. DLQ = an
SQS dead-letter queue for failed writes. RTO = DLQ replay.
- **Daily checkpoints (§9):** a daily job reads the last event hash and
writes a "checkpoint" event to the ledger (+ optionally to a public
notarization service). The spike runs in minutes, not days — no
checkpoint in spike.
## JWS vs chain — orthogonality note
The `prev_event_hash` chain gives ordering/tamper-evidence *within* the
log (a deleted event breaks the chain visibly); JWS gives authenticity
*per event* (a forged event is detectable without re-reading the whole
chain). The chain is spike-scope; JWS is v1.2. Together they cover both
integrity properties the vision's "Not a mutable audit log" anti-goal
requires.
## Outbox item shape (full, spike + v1.2)
- PK `contractId` (UUID).
- SK `eventType#eventTs` (e.g. `POLICY_CHECKED#2026-07-21T12:00:00Z`).
- `payload` (the event body — hash-chained in spike, JWS-signed in v1.2).
- `prev_event_hash` (chain link; `GENESIS` for the first event).
- `hash` (this event's SHA-256 over canonical JSON).
- `approver_qa` (Gitea username of the QA approver; empty in dev-only
spike; populated on qa-promotion — D-042).
- `approver_prod` (SRE username; empty in spike).
- `environment`, `stack`, `score`, `band`.
- `expire_at` (TTL = now + 365d).
- **v1.2 only:** `jws` (detached signature), `checkpoint_ref`.
## RPO / RTO table
| Phase | RPO | RTO |
|-------|-----|-----|
| Spike (D-041) | 0 (sync outbox write) | workflow re-run |
| v1.2 | 0 (sync outbox) | async worker DLQ replay |
## Decision trail
- **D-041** — spike scope = hash chain + outbox write; Object Lock + JWS
+ worker + DLQ are v1.2.
- **D-044** — outbox mode `PAY_PER_REQUEST`; PK/SK; TTL `expire_at` =
now + 365d; no separate async worker in spike.
- **D-042** — approver identities (`approver_qa`, `approver_prod`) live
in the outbox; the separation-of-duties check
(`platform/separation_of_duties.py`) reads `approver_qa` and compares
to the prod-dispatch `gitea.actor`.
+175
View File
@@ -0,0 +1,175 @@
"""ACDL Confidence Signal (REQ-19).
The platform's certified answer to "is this safe to proceed?" (vision
tenet: "Safety is Computed, Not Assumed"). Every delivery action produces
a measurable, explainable confidence signal; reliance on operator
instinct is not a substitute.
Inputs (weights sum to 1.0, D-040):
1. policy_results (0.30) — list[PolicyCheckResult] (schemas/policy_check_result.schema.json)
2. validation (0.25) — {schema: bool, ir_resolved: bool, tf_validated: bool, tf_planned: bool}
3. freshness (0.10) — {age_days: float, max_age_days: float}
4. source (0.15) — {submitter: str, commit_sha: str, signed: bool}
5. history (0.10) — {prior_rollbacks: int, prior_policy_fails: int}
6. nfrs (0.10) — {declared: list[str], conformance: float|None}
Severity -> penalty (locked, ARCHITECTURE.md §8):
critical -> hard override (score = 0, block)
high -> -0.20
medium -> -0.05
low -> -0.01
info -> 0.00
Per-env thresholds (locked, ARCHITECTURE.md §8): dev 0.50, qa 0.75, prod 0.90, dr 0.95.
Output: {score, band, perInput, reasonCodes}.
Halt with explicit reason on missing input (§8).
Spike cold-start (A-6.2): inputs 3 (freshness), 5 (history), 6 (nfrs) are
'present + neutral 0.5' because the spike is the first submission with no
history and no declared NFRs. The gate is *presence*, not *conformance* —
the 'all six inputs present' dev gate (§5) is satisfied by non-null
per-input scores.
"""
from dataclasses import dataclass, asdict
from typing import List, Literal, Optional, Dict, Any
import json
import sys
WEIGHTS = {
"policy": 0.30,
"validation": 0.25,
"freshness": 0.10,
"source": 0.15,
"history": 0.10,
"nfrs": 0.10,
}
PENALTY = {
"critical": None,
"high": 0.20,
"medium": 0.05,
"low": 0.01,
"info": 0.0,
}
THRESHOLDS = {"dev": 0.50, "qa": 0.75, "prod": 0.90, "dr": 0.95}
@dataclass
class Signal:
score: float
band: Literal["pass", "warn", "block"]
perInput: Dict[str, float]
reasonCodes: List[str]
def _per_input_score(name: str, raw: Any) -> tuple:
"""Return (score in [0,1], reasons list). Unknown/missing -> 0.5 + INPUT_MISSING."""
reasons: List[str] = []
if raw is None:
return 0.5, [f"INPUT_MISSING:{name}"]
if name == "policy":
pcrs = raw if isinstance(raw, list) else []
if not pcrs:
return 0.5, []
scores = []
for pcr in pcrs:
r = pcr.get("result", "skipped")
if r == "pass" or r == "skipped":
scores.append(1.0)
else:
scores.append(0.0)
return sum(scores) / len(scores), []
if name == "validation":
keys = ("schema", "ir_resolved", "tf_validated", "tf_planned")
if not isinstance(raw, dict):
return 0.5, []
trues = sum(1 for k in keys if raw.get(k))
return trues / 4.0, []
if name == "freshness":
if not isinstance(raw, dict):
return 0.5, []
age = float(raw.get("age_days", 0))
mx = float(raw.get("max_age_days", 1)) or 1
s = 1.0 - (age / mx)
return max(0.0, min(1.0, s)), []
if name == "source":
if not isinstance(raw, dict):
return 0.5, []
if raw.get("submitter") and raw.get("commit_sha"):
return 1.0, []
return 0.5, []
if name == "history":
if not isinstance(raw, dict):
return 0.5, []
rollbacks = int(raw.get("prior_rollbacks", 0))
fails = int(raw.get("prior_policy_fails", 0))
s = 1.0 - (rollbacks * 0.2 + fails * 0.1)
return max(0.0, min(1.0, s)), []
if name == "nfrs":
if not isinstance(raw, dict):
return 0.5, []
conf = raw.get("conformance")
if conf is None:
return 0.5, []
return float(conf), []
return 0.5, []
def compute(contract_id: str, environment: str,
inputs: Dict[str, Any]) -> Signal:
"""Orchestrate the 6-input weighted sum + severity penalty + band."""
missing = sorted(set(WEIGHTS.keys()) - set(inputs.keys()))
if missing:
return Signal(0.0, "block", {},
[f"INPUT_MISSING:{m}" for m in missing])
per_input: Dict[str, float] = {}
reasons: List[str] = []
base = 0.0
for name, weight in WEIGHTS.items():
raw = inputs.get(name)
s, r = _per_input_score(name, raw)
per_input[name] = s
reasons.extend(r)
base += s * weight
penalty = 0.0
policy_input = inputs.get("policy")
pcrs = policy_input if isinstance(policy_input, list) else []
for pcr in pcrs:
if not isinstance(pcr, dict):
continue
if pcr.get("result") != "fail":
continue
sev = pcr.get("severity")
p = PENALTY.get(sev, 0.0)
if p is None:
return Signal(0.0, "block", per_input,
reasons + [f"CRITICAL_OVERRIDE:{pcr.get('ruleId','?')}"])
penalty += p
score = max(0.0, min(1.0, base - penalty))
threshold = THRESHOLDS[environment]
if score >= threshold:
band = "pass"
elif score < threshold - 0.10:
band = "block"
else:
band = "warn"
if environment == "dev" and band == "warn":
band = "block"
return Signal(score, band, per_input, reasons)
if __name__ == "__main__":
if len(sys.argv) < 3:
print("usage: confidence_signal.py <inputs.json> <environment>", file=sys.stderr)
sys.exit(2)
env = sys.argv[2]
with open(sys.argv[1], "r", encoding="utf-8") as fh:
inputs = json.load(fh)
sig = compute("cli", env, inputs)
print(json.dumps(asdict(sig), indent=2))
+115
View File
@@ -0,0 +1,115 @@
# ACDL Human-in-the-Loop Matrix + Separation-of-Duties Design (REQ-21)
> **Status:** design authored in Phase 07 (milestone v1.1); v1.2 wires the
> gates. The spike (Phases 08-10) is **dev-only**; HITL is not exercised
> (the spike contract has `environment: dev`).
The vision's "Lower Environments are Autonomous; Higher Environments are
Attested" tenet [1] and the "deliberate human attestation — not as a
rubber stamp" requirement [1] are the binding constraints.
## Gate model (ARCHITECTURE.md §10.1)
**Pre-execution gates.** The contract is held in a "validated but not
applied" state until the human attests. qa, prod, dr are attestation
gates. No partial deployment to roll back on rejection (qa, prod); dr is
a separate deployment against a separate cluster/region. The
canary/deployment-rollback model is explicitly not in scope for v1.
## Gitea-specific gate mechanics (D-042)
Gitea has **no Environments API** and ignores `environment:` blocks
(v1.0 D-013; re-confirmed in RESEARCH TARGET 1). The pre-execution gate
is modeled as a `workflow_dispatch` with approval inputs:
- **qa gate:** `workflow_dispatch` with `approve_qa: true`; the dispatch
run's `gitea.actor` is the QA approver.
- **prod gate:** `workflow_dispatch` with `approve_prod: true`;
`gitea.actor` is the SRE approver.
- **dr gate:** `workflow_dispatch` with `approve_dr: true`; same.
The approver identity of record = `gitea.actor` of the dispatch run
(D-042). There is no other approval-identity signal in Gitea. The v1.2
real-OIDC path (blocked on go-gitea/gitea#36988) does not change this —
OIDC authorizes the *runner* to AWS, it does not change how the platform
records the *human* approver.
## Reviewer routing (ARCHITECTURE.md §10.2)
Gitea CODEOWNERS routes the right reviewer to the right gate:
- qa → QA team
- prod → SRE team
- dr → SRE team
CODEOWNERS **routes**; it does **not** enforce identity distinctness (that
is the platform-internal outbox check in
`platform/separation_of_duties.py`).
## Full 8-concern attestation matrix (§10.4, lifted verbatim)
| Env | Concern | Evidence artifact | Freshness | Source | Attester |
|---|---|---|---|---|---|
| qa | Functional correctness | Last successful run of contract-declared validation.e2eSuite with pass rate ≥ 99% | Last 24h | Test runner declared in contract | QA |
| qa | Performance baseline | Load test report (k6 / Gatling / Locust) showing p99 latency < declared NFR and throughput > declared minimum | Last 7d | Load test runner declared in contract | QA |
| qa | Security posture | Vulnerability scan (Trivy, Snyk, or contract-declared equivalent) with no criticals/highs, signed by Security on-call | Last 24h | Security scanner + Security team signature | QA |
| qa | Contract NFRs | Platform-generated report: schema valid, NFR assertions (latency, throughput, error rate) within declared bounds | At submission | Platform contract validator | QA |
| prod | Operational readiness | Runbook published, dashboard exists, on-call rotation assigned, alerts configured | At submission, validated against last 30d history | Platform + SRE | SRE |
| prod | Incident response | Sev-1 runbook tabletop or live drill completed | Last 90d | SRE drill record | SRE |
| prod | Capacity / cost | FinOps forecast for next 30d within budget envelope, cost anomaly baseline stored, budget alert configured | Forecast valid for next 30d | FinOps + SRE | SRE |
| prod | Resilience | DR drill, chaos engineering report, backup verified | DR: 180d; chaos: 90d; backup: 30d | SRE + Platform | SRE |
| dr | dr-region deploy with the most recent prod-bound dr drill as canary evidence | dr drill report | Last 180d | SRE | SRE |
## Timeout behavior (§10.5)
| Time | State | Action |
|---|---|---|
| Submission | PENDING_ATTESTATION | Notify responsible team |
| 1 business day | PENDING_ATTESTATION_WARNING | Notify team + platform on-call (elevated path); emit `PENDING_ATTESTATION_TIMEOUT_WARNING` event |
| 2 business days | PENDING_ATTESTATION_AUTO_FREEZE | Auto-freeze; require re-submission; emit `PENDING_ATTESTATION_AUTO_FREEZE` event; new submission linked via `supersedes` |
**Implementation:** a Gitea `on: schedule` workflow (runs hourly) that
scans the DynamoDB outbox for `PENDING_ATTESTATION` events with `ts`
older than 1/2 business days and emits the warn/freeze events. Not
implemented in the spike (dev-only).
## Rejection and rollback (§10.6)
Rejection returns the contract to a `HELD` state with the rejection
reason captured as a `PROMOTION_REJECTED` event. The consumer fixes the
cause and re-submits; the new submission is linked to the rejected one
via `supersedes` (a contract-schema field — `schemas/contract.schema.json`).
The audit chain is **extended, not torn up** (the "Not a mutable audit
log" anti-goal). No partial deployment to roll back at any v1 gate.
## Separation of duties (§10.3) — pointer to the .py
The identity-distinctness check is platform-internal, not GitHub-native,
not Kyverno (in v1). Sequence:
1. On promotion dev → qa, the platform reads the QA approver's identity
from the `workflow_dispatch` run's `gitea.actor` and writes it to the
DynamoDB outbox keyed by `contractId` (attribute `approver_qa`).
2. On promotion qa → prod, the platform reads the stored `approver_qa`
from the outbox and the new SRE approver's `gitea.actor` from the
prod-dispatch run.
3. If `approver_qa == approver_prod`, the platform blocks the prod
promotion, writes a `SEPARATION_OF_DUTIES_VIOLATION` event to the
evidence stream, and routes a halt artifact to the SRE on-call.
4. The check is implemented in `platform/separation_of_duties.py`
(T-7.8). The platform is the only writer to the outbox; the check is
in the same process that has authority to block the promotion.
## Spike scope note
The spike is dev-only (REQ-27 contract has `environment: dev`), so HITL
is not exercised. Phase 07 authors the design; Phase 10's
`verify_phase10.sh` does not assert HITL behavior. v1.2 wires the gates
against this design.
## Decision trail
- **D-042** — approver identity = `gitea.actor` of the `workflow_dispatch`
run; no Environments API in Gitea.
- **D-013** (v1.0) — the `workflow_dispatch` approval-input fallback,
re-used for the real platform's pre-execution gate model.
+42
View File
@@ -0,0 +1,42 @@
"""Check that qaApprover != prodApprover for a contract (ARCHITECTURE.md
§10.3, D-042). Reads `approver_qa` from the DynamoDB outbox for the
contractId, compares to the prod-dispatch `gitea.actor`. Blocks on
equality, emits `SEPARATION_OF_DUTIES_VIOLATION`, routes a halt artifact
to SRE on-call.
Spike scope (A-8.1): the spike is dev-only (REQ-27 contract has
environment: dev); HITL is not exercised. This module is authored to its
full v1.2 shape but the spike calls it with current_prod_approver=None
and a None outbox_client — the check returns (True, 'no QA approver
recorded (dev-only spike)').
"""
from typing import Optional, Tuple
def check(outbox_client, contract_id: str,
current_prod_approver: Optional[str]) -> Tuple[bool, str]:
"""Return (ok, reason). ok=False means block the prod promotion."""
if outbox_client is None:
return (True, "no outbox client (dev-only spike)")
item = outbox_client.get(contract_id)
if item is None:
return (True, "no prior approver (first promotion)")
qa_approver = item.get("approver_qa")
if not qa_approver:
return (True, "no QA approver recorded (dev-only spike)")
if current_prod_approver is None:
return (True, "no prod approver supplied (dev-only spike)")
if qa_approver == current_prod_approver:
return (False,
f"SEPARATION_OF_DUTIES_VIOLATION: "
f"qaApprover==prodApprover=={qa_approver}")
return (True, "distinct")
def route_halt_artifact(contract_id: str, violation_reason: str,
oncall_client) -> None:
"""Route a halt artifact to SRE on-call. Spike: stub that logs. v1.2
wires a real pager."""
print(f"[halt-artifact] contract={contract_id} reason={violation_reason} "
f"oncall={oncall_client}", flush=True)
@@ -0,0 +1,99 @@
"""Translate Checkov JSON output to ACDL PolicyCheckResult records.
Reads Checkov's JSON output (one framework key, e.g. terraform_plan),
emits a list of PolicyCheckResult dicts conforming to
schemas/policy_check_result.schema.json. Run Checkov with --soft-fail so
Checkov never exits non-zero; the confidence signal decides the gate, not
Checkov's exit code.
Spike scope (D-043): tag/naming is a single SKIPPED record. A custom
Checkov YAML rule for tag presence lands in v1.2.
"""
import datetime
import json
import sys
RULE_MAP = {
"CKV_AWS_41": ("secrets-in-plaintext", "high"),
"CKV_AWS_45": ("secrets-in-plaintext", "high"),
"CKV_AWS_46": ("secrets-in-plaintext", "high"),
"CKV_AWS_20": ("public-ingress", "high"),
"CKV_AWS_57": ("public-ingress", "high"),
"CKV_AWS_24": ("public-ingress", "medium"),
"CKV_AWS_25": ("public-ingress", "medium"),
"CKV_AWS_1": ("iam-wildcard", "high"),
"CKV_AWS_40": ("iam-wildcard", "medium"),
"CKV_AWS_7": ("kms-key-reference", "medium"),
"CKV_AWS_33": ("kms-key-reference", "medium"),
}
_RESULT_MAP = {"PASSED": "pass", "FAILED": "fail", "SKIPPED": "skipped"}
def _iso8601_now():
return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def _to_pcr(checkov_record, contract_id, result_str):
check_id = checkov_record.get("check_id", "")
default_sev = RULE_MAP.get(check_id, (check_id, "info"))[1]
severity = checkov_record.get("severity", default_sev)
if isinstance(severity, str):
severity = severity.lower()
return {
"contractId": contract_id,
"evaluatedAt": _iso8601_now(),
"engine": "checkov",
"ruleId": check_id,
"severity": severity,
"result": _RESULT_MAP.get(result_str, "error"),
"message": checkov_record.get("check_name", ""),
"evidence": {
"file_path": checkov_record.get("file_path"),
"resource": checkov_record.get("resource"),
"resource_address": checkov_record.get("resource_address"),
"code_block": checkov_record.get("code_block"),
},
"resourceRef": checkov_record.get("resource_address") or checkov_record.get("resource", ""),
}
def _emit_tag_naming_skipped(contract_id):
return {
"contractId": contract_id,
"evaluatedAt": _iso8601_now(),
"engine": "checkov",
"ruleId": "ACDL_TAG_NAMING",
"severity": "info",
"result": "skipped",
"message": "tag/naming check deferred to v1.2 (D-043)",
"evidence": {},
"resourceRef": "",
}
def adapt(checkov_json_path, contract_id):
with open(checkov_json_path, "r", encoding="utf-8") as fh:
data = json.load(fh)
out = []
for framework, body in data.items():
results = body.get("results", body) if isinstance(body, dict) else {}
if not isinstance(results, dict):
continue
for rec in results.get("passed_checks", []):
out.append(_to_pcr(rec, contract_id, "PASSED"))
for rec in results.get("failed_checks", []):
out.append(_to_pcr(rec, contract_id, "FAILED"))
for rec in results.get("skipped_checks", []):
out.append(_to_pcr(rec, contract_id, "SKIPPED"))
out.append(_emit_tag_naming_skipped(contract_id))
return out
if __name__ == "__main__":
if len(sys.argv) != 3:
print("usage: checkov_adapter.py <checkov.json> <contract-id>", file=sys.stderr)
sys.exit(2)
print(json.dumps(adapt(sys.argv[1], sys.argv[2]), indent=2))
+458
View File
@@ -0,0 +1,458 @@
# Architecture Document v1.0
> **Snapshot status:** v1.0 — taken in ACDL Phase 07 (milestone v1.1).
> All 11 open decisions in §13 are **resolved** — see `PROJECT.md`
> "Open-decision resolutions" table + decisions D-034..D-046.
> The body §§1-12 is copied verbatim from the upstream
> `docs/architecture.md` v0.2; only the header status line, the resolution
> session log, §13, §14, and the new §15 are Phase 07 additions. The
> `act_runner` → `gitea-runner` rename (D-046, 2026-04 in gitea/runner#850)
> is applied; `act_runner` appears only in a "formerly" note.
# Agentic Cloud Delivery Platform — Architecture Document
Status: **v1.0** (snapshot taken in ACDL Phase 07, milestone v1.1). All 11
open decisions in §13 are resolved — see `PROJECT.md` "Open-decision
resolutions" table + decisions D-034..D-046.
Companion to: Agentic Cloud Delivery Vision [1].
Authoring principle: The vision is the source of truth for why [1]; this document is the source of truth for how. Where the two conflict, the vision wins.
Resolution session log (v1.0 snapshot — see PROJECT.md for full text):
| ID | Question | Resolution (one-line — see PROJECT.md for rationale) |
|---|---|---|
| W1.A | AI-refinement trigger | ✅ RESOLVED — joint condition: N ≥ 50 consecutive zero-rollback changes AND no L1/L2 incident in 6 months AND Infra & Ops unilateral override. |
| W1.B | Multi-stack edge case rule | ✅ RESOLVED — permitted only for (a) DR-region mirror, (b) time-boxed experimental stack TTL ≤ 30d, (c) explicit Infra & Ops approval with `multiStack.justification`. |
| W2.A | Tag mutability for prod | ✅ RESOLVED — Path B: tag for dev/qa, SHA for prod; platform CLI resolves tag→SHA. |
| W3.D | L1/L2 standard versioning | ✅ RESOLVED — semver (interface→MAJOR, behavior→MINOR, lifecycle→PATCH); L2 pins L1 by `name@semver`; MAJOR bump = new registry entry + 12-month deprecation. |
| W3.E | Schema mandatory vs. optional inputs | ✅ RESOLVED — dev: stack+environment; qa adds validation.e2eSuite+loadTest; prod adds runbook+dashboard+oncall; dr adds drDrillRef; `inputs` always optional; `profile: agentic` fields optional everywhere (naturalLanguageIntent required when profile is agentic). |
| BA.A | Initial L3B skill catalog | ✅ RESOLVED — 5 skills: web API, worker, scheduled job, static asset, basic observability bootstrap; addition criteria: (a) sensitive-data reviewable, (b) single contract submission, (c) documented use case. |
| BA.B | Confidence threshold tuning | ✅ RESOLVED — thresholds frozen for v1; tuning begins v1.2 (quarterly FP/FN tracking; override = Infra & Ops + SRE joint sign-off, itself a confidence-event). |
| BA.C | On-call / operational ownership | ✅ RESOLVED — platform on-call = Infra & Ops; L3A/L3B halt → platform on-call (Sev2); consumer-visible outage → consumer on-call (Sev1) + platform support. |
| BA.D | Cost / capacity governance | ✅ RESOLVED — FinOps owns cloud cost; per-contract monthly reporting; runaway spend hard-halts at 120% of declared budget via the confidence signal; override = FinOps + SRE joint sign-off. |
| BA.E | Consumer onboarding | ✅ RESOLVED — developer (L3A): `getting-started` → contract schema + central pipeline template; citizen (L3B): scoped agent + skill catalog, no workflow authoring; both end in a sandbox dev submission that must pass the confidence gate. |
| BA.F | Cross-platform evolution | ✅ RESOLVED — contract schema, IR, PolicyCheckResult, confidence signal, audit stream are portable (forge-agnostic); forge-specific code = workflow YAML, OIDC trust, CODEOWNERS, Environments; a second forge needs a forge adapter + workflow-template translator, no change to L1/L2/IR/confidence/audit. |
| Q1.3 | OpenTofu timing | ✅ RESOLVED (deferred) — not in v1 or v1.1; the substrate abstraction (§12) makes OpenTofu a future adapter, not an architecture change; revisit when an OpenTofu adapter is requested. |
---
## 0. Purpose
This document encodes the architectural commitments that realize the vision [1]. The resolution session has closed eight open items; the document is now at v0.2 with eleven open items remaining, listed in Section 13. Every locked commitment is grounded in either a vision tenet or a specific decision made during resolution.
The structure remains: four layers (L1 primitives, L2 composed stacks, L3A developer surface, L3B agentic surface) plus five cross-cutting concerns (central pipeline, contract schema, confidence signal, audit stream, HITL mechanics), with one addition: the substrate abstraction layer (Section 12) is now a first-class architectural concern, not an implementation detail.
## 1. Architectural Overview
The platform remains four layers and five cross-cutting concerns. The substrate abstraction is added as a sixth cross-cutting concern in Section 12 because it is the binding constraint for the L1/L2 model, the central pipeline, and the policy toolchain.
The vision's "Two Consumer Surfaces, One Platform" tenet [1] remains the constraint that binds all concerns: L3A and L3B converge on the same contract schema, the same policy envelope, and the same evidence stream.
Locked additions this revision:
- The environment model is dev (autonomous) → qa (QA HITL) → prod (SRE HITL) → dr (SRE HITL). Staging does not exist.
- L1/L2 are substrate-agnostic in shape; substrate adapters are the only substrate-specific component.
## 2. Layer 1 — Foundational Primitives
Purpose. Single-purpose, substrate-agnostic primitive modules representing the smallest reusable infrastructure pieces. L1 modules do not compose with other L1 modules; L1 takes its environment as input.
Locked commitments (unchanged from v0.1):
- No inter-L1 references. L1 may call Terraform data sources.
- Semver with three triggers (interface → MAJOR, behavior → MINOR, lifecycle → PATCH).
- Immutability on publication.
- 12-month deprecation window.
- AI refinement is a flag.
✅ RESOLVED (see PROJECT.md W1.A): AI-refinement operational trigger — joint condition: N ≥ 50 consecutive changes with zero rollbacks AND no L1/L2 incident in last 6 months AND Infra & Ops holds a unilateral override.
✅ RESOLVED (sub-decision): The L1 module's interface field is defined against the Target Stack IR, not against Terraform's variable block directly. In v1, the IR is shaped to round-trip cleanly to Terraform, but the schema is substrate-agnostic. Pending v1 implementation details in Section 12.
## 3. Layer 2 — Composed Stacks
Purpose. Combine L1 primitives into deployable infrastructure shapes. Each codebase maps to one canonical L2 stack; the stack is either a parameterized module (Shape X) or a thin-composition layer (Shape Y).
Locked commitments (unchanged from v0.1):
- 1 codebase = 1 L2 stack (default), with multiStack: true for exceptions.
- Shape X or Shape Y.
- Hierarchical composition, max depth 5, only registered L1s.
- Pipeline quality checks: secrets-in-plaintext, public ingress, IAM wildcard, KMS key reference, tag compliance, naming convention.
- Restricted from thin-composition: IAM principal creation, network boundary creation, key/secret creation, external data transfer.
- Auto-promote after 3 observed usages.
✅ RESOLVED (see PROJECT.md W1.B): Multi-stack edge case rule — permitted only for (a) DR-region mirror, (b) time-boxed experimental stack with TTL ≤ 30 days, (c) explicit Infra & Ops approval for a documented reason captured in multiStack.justification.
✅ RESOLVED (sub-decision): The L2 thin-composition tree's wires field is defined against the IR's relationship type, not against a Terraform module block. The IR → Terraform translation is the Terraform adapter's job (Section 12). The thin-composition pipeline itself is substrate-agnostic.
## 4. Layer 3A — Developer Consumer Surface
Locked commitments (unchanged from v0.1):
- Tag-based reference to the central pipeline template.
- Developer-owned workflow file, no platform auto-sync.
- L3A and L3B are parallel paths, not a progression.
✅ RESOLVED (see PROJECT.md W2.A): Tag mutability for production-bound references — Path B (tag for dev/qa, SHA for prod). The platform provides a CLI command that resolves the current tag to its SHA for prod-bound workflows.
## 5. Layer 3B — Agentic Consumer Surface
Locked commitments (unchanged from v0.1):
- Hybrid runtime, skill as markdown, agent as executor.
- Trust model: trust and always verify on the platform side.
- Skill envelope (4 dimensions).
- Stateless agents, all state in the platform.
Environment progression — locked (this revision):
| Environment | Autonomy | Attester | Gate |
|---|---|---|---|
| dev | Full autonomy (no HITL) | — | Confidence signal ≥ 0.50, all six inputs present |
| qa | Held for attestation | QA | GitHub Deployment approval + full QA matrix (see §10) |
| prod | Held for attestation | SRE | GitHub Deployment approval + full SRE matrix (see §10) |
| dr | Held for attestation | SRE | GitHub Deployment approval + dr-drill evidence (see §10) |
Staging is removed. Dev is the only autonomous environment and absorbs integration, contract, security smoke, and performance smoke validation. The CDLC reference document's environment model is a doc-sync item flagged at the top of this document.
Profile marker: profile: agentic unlocks L3B-specific fields naturalLanguageIntent, confidenceAtSubmission, agentTrace).
✅ RESOLVED (see PROJECT.md BA.A): Skill catalog — initial set: web API, worker, scheduled job, static asset, basic observability bootstrap. Addition criteria: (a) reviewable for sensitive data, (b) expressible as a single contract submission, (c) documented use case.
## 6. Cross-Cutting — Central Pipeline Template
Locked commitments (unchanged from v0.1):
- JSON Schema (draft 2020-12) with thin domain-specific wrapper.
- Central repo + generated client libraries.
- Multi-stage validation pipeline (schema → policy → NFR → confidence).
- Distributed enrichment.
- GitOps reconciler + Terraform execution layer.
Locked additions this revision:
- The GitOps reconciler is the platform's K8s API. The cdlc-gitops repository's state materializes into K8s CRDs (ArgoCD Applications or Flux Kustomizations) that the reconciler watches. This is the platform's internal state surface.
- The pipeline emits a PolicyCheckResult record per policy rule evaluated. The confidence signal consumes these as one normalized input (Section 8).
✅ RESOLVED (see PROJECT.md W3.D): L1/L2 standard versioning details — semver (interface→MAJOR, behavior→MINOR, lifecycle→PATCH); L2 contracts pin L1 by `name@semver`; the resolver picks the highest compatible; MAJOR bumps require a new registry entry (immutable publication); old entry enters a 12-month deprecation window.
✅ RESOLVED (see PROJECT.md W3.E): Schema mandatory vs. optional inputs — dev requires stack+environment; qa adds validation.e2eSuite + validation.loadTest; prod adds runbook + dashboard + oncall; dr adds drDrillRef; `inputs` always optional; `profile: agentic` fields optional everywhere (naturalLanguageIntent required when profile is agentic).
## 7. Cross-Cutting — Contract Schema
Locked commitments (unchanged from v0.1):
- Central repo + generated client libraries.
- Strict fail-fast at schema stage, multi-stage validation pipeline with reason codes from a published vocabulary.
✅ RESOLVED (see PROJECT.md W3.E): Schema mandatory vs. optional inputs. The CDLC reference contract example [1] is illustrative; the v1 contract schema has explicit per-field mandatory/optional declarations per environment.
## 8. Cross-Cutting — Confidence Signal
Locked commitments (unchanged from v0.1):
- Six canonical inputs.
- Weighted sum with per-input breakdown.
- Per-environment thresholds: dev ≥ 0.50, qa ≥ 0.75, prod ≥ 0.90, dr ≥ 0.95.
- Structured output { score, band, perInput, reasonCodes }.
- 1-year storage, no algorithm retraining in v1.
- Halt with explicit reason on missing input.
Locked additions this revision:
- The policy check results input is a list of PolicyCheckResult records from the normalized schema (Section 9, 12). The signal does not know which engine produced which result.
- Severity → score penalty mapping: critical → hard override to mandatory block, high → -0.2, medium → -0.05, low → -0.01, info → 0.0. One critical finding hard-overrides the score regardless of all other inputs.
✅ RESOLVED (see PROJECT.md BA.B): Threshold tuning policy. Thresholds frozen for v1. Tuning begins v1.2: quarterly FP/FN tracking per environment; override authority = Infra & Ops + SRE joint sign-off; any override is itself a confidence-event in the audit stream.
## 9. Cross-Cutting — Audit and Evidence Stream
Locked commitments (unchanged from v0.1):
- Tiered audit ledger: S3 with Object Lock in compliance mode (cold, source of truth, 7-year retention) + GitHub audit repo (hot, query index, not part of the chain).
- Daily checkpoints.
- Event schema: JWS detached signature, prev_event_hash chain, controlled-vocabulary event_type.
- Outbox pattern with local durable outbox + async worker.
- Linkage via workflow run ID or agent invocation ID.
Locked additions this revision:
- The outbox database is DynamoDB. RPO is zero (synchronous write to local outbox before contract submission ack); RTO is the async worker's recovery from the dead-letter queue. Single-region in v1; multi-region is a v2 concern.
- The outbox also stores the per-contract QA and prod approver identities (Section 10). The platform-internal identity-distinctness check reads from this outbox. This is the only durable record of the approver identities outside GitHub's audit log.
## 10. Cross-Cutting — Human-in-the-Loop Mechanics
Purpose. The human gates at higher environments. The vision's "Lower Environments are Autonomous; Higher Environments are Attested" tenet [1] and the "deliberate human attestation — not as a rubber stamp" requirement [1] are the binding constraints.
### 10.1 Gate model
Pre-execution gates. The contract is held in a "validated but not applied" state until the human attests. qa, prod, and dr are PR-based attestation gates backed by GitHub Environments with required reviewers.
For qa and prod, there is no partial deployment to roll back on rejection. For dr, the same model — promotion to the DR environment is a separate GitHub Deployment, gated by SRE, against a separate cluster/region. The canary/deployment-rollback model is explicitly not in scope for v1.
### 10.2 Reviewer routing
GitHub CODEOWNERS + GitHub Environment required reviewers. qa → QA team; prod → SRE team; dr → SRE team. CODEOWNERS is the routing layer; it does not enforce identity distinctness.
### 10.3 Separation of duties — identity distinctness
Mechanism is platform-internal, not GitHub-native, not Kyverno (in v1).
Sequence:
1. On promotion dev → qa, the platform reads the QA approver's GitHub identity from the GitHub Deployment approval event and writes it to the DynamoDB outbox keyed by contractId.
2. On promotion qa → prod, the platform reads the stored QA approver identity from the outbox and the new SRE approver identity from the GitHub Deployment approval event.
3. If qaApprover == prodApprover, the platform blocks the prod promotion, writes a SEPARATION_OF_DUTIES_VIOLATION event to the evidence stream, and routes a halt artifact to the SRE on-call.
4. The check is implemented in the central pipeline repo, not as an external policy. The platform is the only writer to the outbox; the check is in the same process that has authority to block the promotion.
### 10.4 Full HITL attestation matrix
| Env | Concern | Evidence artifact | Freshness | Source | Attester |
|---|---|---|---|---|---|
| qa | Functional correctness | Last successful run of contract-declared validation.e2eSuite with pass rate ≥ 99% | Last 24h | Test runner declared in contract | QA |
| qa | Performance baseline | Load test report (k6 / Gatling / Locust) showing p99 latency < declared NFR and throughput > declared minimum | Last 7d | Load test runner declared in contract | QA |
| qa | Security posture | Vulnerability scan (Trivy, Snyk, or contract-declared equivalent) with no criticals/highs, signed by Security on-call | Last 24h | Security scanner + Security team signature | QA |
| qa | Contract NFRs | Platform-generated report: schema valid, NFR assertions (latency, throughput, error rate) within declared bounds | At submission | Platform contract validator | QA |
| prod | Operational readiness | Runbook published, dashboard exists, on-call rotation assigned, alerts configured | At submission, validated against last 30d history | Platform + SRE | SRE |
| prod | Incident response | Sev-1 runbook tabletop or live drill completed | Last 90d | SRE drill record | SRE |
| prod | Capacity / cost | FinOps forecast for next 30d within budget envelope, cost anomaly baseline stored, budget alert configured | Forecast valid for next 30d | FinOps + SRE | SRE |
| prod | Resilience | DR drill, chaos engineering report, backup verified | DR: 180d; chaos: 90d; backup: 30d | SRE + Platform | SRE |
| dr | dr-region deploy with the most recent prod-bound dr drill as canary evidence | dr drill report | Last 180d | SRE | SRE |
### 10.5 Timeout behavior
| Time | State | Action |
|---|---|---|
| Submission | PENDING_ATTESTATION | Notify responsible team |
| 1 business day | PENDING_ATTESTATION_WARNING | Notify team + platform on-call (elevated path); emit PENDING_ATTESTATION_TIMEOUT_WARNING event |
| 2 business days | PENDING_ATTESTATION_AUTO_FREEZE | Auto-freeze; require re-submission; emit PENDING_ATTESTATION_AUTO_FREEZE event; new submission linked via supersedes |
### 10.6 Rejection and rollback
Rejection returns the contract to a HELD state with the rejection reason captured as a PROMOTION_REJECTED event. The consumer fixes the cause and re-submits; the new submission is linked to the rejected one via supersedes. The audit chain is extended, not torn up — matching the resolution session's answer.
There is no partial deployment to roll back at any v1 gate.
## 11. Cross-Cutting — Agentic Stack
Locked commitments (unchanged from v0.1):
- Hybrid runtime, platform-managed control plane + consumer-owned agent.
- Versioned, signed skill catalog over MCP.
- Skill envelope enforced on invocation and result submission.
- Consumer-owned skill execution environment. Platform does not run the skill.
- Stateless agents, all state in the platform.
Locked additions this revision:
- Skills are reviewed for sensitive data before release. Secrets, customer data, internal IPs, and other sensitive payloads are forbidden in skill markdown. The review is owned by Infra & Ops and is the mandatory release gate for any new skill. This is the trade-off for accepting the L3B runtime threat model (skill content is consumer-readable, so the platform must not put anything sensitive in it).
✅ RESOLVED (see PROJECT.md BA.A): Skill catalog — initial set, addition process, deprecation process per the resolution.
## 12. Cross-Cutting — L1/L2 Substrate Execution
Purpose. The technical execution layer for the L1/L2 substrate, including the substrate abstraction that protects v1 from polyglot mess while leaving v2+ room to grow.
### 12.1 Substrate abstraction (locked this revision)
L1/L2 are substrate-agnostic in shape. The architecture defines a Target Stack Intermediate Representation (IR) — a substrate-neutral description of:
- Resources with typed input contracts, typed output contracts, and declared NFRs.
- Relationships (single parent per child, with a shared keyword for multi-relationship dependencies).
- Composition (a tree of resources with max depth 5).
- Policy hooks (the points in the composition where policy checks attach).
The L1 registry, the L2 thin-composition tree, the YML standard, and the policy check result schema are all defined against the IR. None of them is defined against any specific substrate.
Substrate adapters are the only substrate-specific code. An adapter compiles the IR into a substrate execution plan. v1 ships exactly one adapter: the Terraform adapter. v2+ may add additional adapters (OpenTofu, Pulumi, K8s CRDs) without architectural change.
v1 implementation reality: the IR is shaped to round-trip cleanly to Terraform because there is no other adapter to differentiate from. The IR and the Terraform output are nearly isomorphic in v1. As additional adapters appear in v2+, the IR gets more expressive (e.g., substrate-specific output types) and the adapters gain translation logic, but the L1 module content, the YML standard, and the thin-composition tree do not change. This is the design that prevents the polyglot mess.
Why not build the abstraction earlier? Building a substrate-agnostic IR before there is a second adapter to test against is speculative generality. The v1 commitment is: (1) the L1 module interface is defined against the IR even though the only adapter is Terraform, and (2) the central pipeline, registry, and policy schema consume the IR-typed contracts. The adapter is the only place where substrate terminology appears in v1.
### 12.2 Terraform adapter (v1)
The Terraform adapter:
- Translates the IR-typed L1 module interface to a Terraform variable block and a Terraform output block.
- Translates the IR-typed L2 thin-composition tree to a Terraform root module that calls the L1 modules.
- Translates the IR-typed relationships to Terraform module references.
- Emits a Terraform plan from the IR.
The adapter is a thin layer. It does not own L1/L2 content; it only translates.
### 12.3 State storage
Locked: S3 (state files) + DynamoDB (state locking), cloud-managed. Single-region in v1.
### 12.4 Policy toolchain
Locked:
- Checkov for Terraform plan policy (the four L2 thin-composition checks: secrets-in-plaintext, public ingress, IAM wildcard, KMS key reference, plus tag and naming convention). Checkov is open-source, has a broad rule catalog, and is GitOps-friendly.
- Kyverno for K8s-native policy (platform-internal state in the GitOps reconciler, separation-of-dues-adjacent checks if any are added in v2, future CRD validation).
- OPA/Rego is reserved for cross-resource policy and is explicitly last resort due to Rego complexity.
### 12.5 Execution layer
Locked: GitHub Actions. terraform plan and terraform apply run in the central pipeline repo's GitHub Actions workflow. State locking via DynamoDB. AWS credentials via OIDC federation (long-lived credentials are forbidden). The platform does not run terraform apply against a developer's workstation; all execution is in the central pipeline.
> **ACDL Phase 07 note (D-039):** Gitea Actions (the ACDL forge) does not
> support `id-token: write` / OIDC token issuance as of Gitea 1.27.x /
> gitea-runner v2.1.0 (formerly `act_runner`, renamed 2026-04 in
> gitea/runner#850). The v1.1 spike uses a per-run-rotated long-lived key
> waiver; real OIDC federation is a v1.2 deliverable, blocked on
> go-gitea/gitea#36988. The §12.5 "long-lived credentials are forbidden"
> commitment is the locked target; the waiver is a time-boxed spike
> exception.
### 12.6 Policy result normalization (locked this revision)
The confidence signal does not consume raw Checkov or Kyverno output. It consumes a normalized PolicyCheckResult schema produced by substrate-specific adapters.
Schema (canonical form, lives in the central pipeline repo):
```json
{
"contractId": "uuid",
"evaluatedAt": "ISO-8601",
"engine": "checkov | kyverno | opa",
"ruleId": "CKV_AWS_24 | KYVERNO_NO_PRIVILEGED | ...",
"severity": "critical | high | medium | low | info",
"result": "pass | fail | skipped | error",
"message": "human-readable",
"evidence": { "...engine-specific payload, opaque to the signal..." },
"resourceRef": "IR-typed resource identifier"
}
```
The Checkov adapter runs in the same GitHub Actions step as Checkov itself and translates Checkov JSON to PolicyCheckResult records. The Kyverno adapter runs as a controller in the platform's K8s cluster and translates Kyverno PolicyReport CRDs to PolicyCheckResult records. The confidence signal's policy input component is the union of all PolicyCheckResult records, regardless of engine. The signal does not know which engine produced which result — substrate-agnostic over its inputs, matching the L1/L2 model's substrate-agnostic over its outputs.
### 12.7 Registry maintenance
Locked: L1 module publication updates the L1 registry in the same PR as the module. Registry and module land together. The registry is the IR-typed contract, not a Terraform-specific variable schema. The L1 registry, the central pipeline, and the policy schema all consume the same IR-typed contract — there is one source of truth for the L1 interface, not multiple substrate-specific copies.
### 12.8 Contract-schema-to-IR resolution
The contract schema declares the consumer's intent in IR-typed terms. The central pipeline resolves the contract to a target stack (a list of L1 module instances with their inputs and the relationships between them). The Terraform adapter compiles the target stack to a Terraform execution plan. This resolution is substrate-agnostic — the target stack is in the IR.
## 13. Consolidated Open Design Decisions
**All 11 decisions are RESOLVED (see PROJECT.md).** The §13 subsections
below preserve the upstream structure with the `🟡 OPEN` markers replaced
by `✅ RESOLVED (see PROJECT.md)`.
### From Wave 1 (L1/L2 Substrate)
- (W1.A) AI-refinement trigger. ✅ RESOLVED (see PROJECT.md) — joint condition: N ≥ 50 consecutive zero-rollback changes AND no L1/L2 incident in 6 months AND Infra & Ops unilateral override.
- (W1.B) Multi-stack edge case rule. ✅ RESOLVED (see PROJECT.md) — permitted only for (a) DR-region mirror, (b) time-boxed experimental stack TTL ≤ 30d, (c) explicit Infra & Ops approval with `multiStack.justification`.
### From Wave 2 (L3A/L3B)
- (W2.A) Tag mutability for production-bound references. ✅ RESOLVED (see PROJECT.md) — Path B (tag for dev/qa, SHA for prod) with platform-provided CLI to resolve tag → SHA.
### From Wave 3 (Technical Execution)
- (W3.D) L1/L2 standard versioning details. ✅ RESOLVED (see PROJECT.md) — semver (interface→MAJOR, behavior→MINOR, lifecycle→PATCH); L2 pins L1 by `name@semver`; MAJOR bump = new registry entry + 12-month deprecation.
- (W3.E) Schema mandatory vs. optional inputs. ✅ RESOLVED (see PROJECT.md) — per-env mandatory table (dev: stack+environment; qa adds validation.e2eSuite+loadTest; prod adds runbook+dashboard+oncall; dr adds drDrillRef); `inputs` always optional; `profile: agentic` fields optional everywhere.
### From Beyond Architecture
- (BA.A) Skill catalog. ✅ RESOLVED (see PROJECT.md) — 5 skills (web API, worker, scheduled job, static asset, basic observability bootstrap); addition criteria locked.
- (BA.B) Confidence signal threshold tuning. ✅ RESOLVED (see PROJECT.md) — frozen for v1; tuning begins v1.2 (quarterly FP/FN; override = Infra & Ops + SRE joint sign-off).
- (BA.C) On-call and operational ownership. ✅ RESOLVED (see PROJECT.md) — platform on-call = Infra & Ops; L3A/L3B halt → Sev2; consumer outage → Sev1.
- (BA.D) Cost and capacity governance. ✅ RESOLVED (see PROJECT.md) — FinOps owns; per-contract monthly reporting; hard halt at 120% of declared budget via the confidence signal; override = FinOps + SRE joint sign-off.
- (BA.E) Consumer onboarding. ✅ RESOLVED (see PROJECT.md) — developer (L3A): getting-started → contract schema + central pipeline template; citizen (L3B): scoped agent + skill catalog; both end in a sandbox dev submission that must pass the confidence gate.
- (BA.F) Cross-platform evolution. ✅ RESOLVED (see PROJECT.md) — contract schema, IR, PolicyCheckResult, confidence signal, audit stream are portable; forge-specific code = workflow YAML, OIDC trust, CODEOWNERS, Environments; a second forge needs a forge adapter + workflow-template translator.
- (Q1.3) OpenTofu timing. ✅ RESOLVED (deferred — see PROJECT.md) — not in v1 or v1.1; the substrate abstraction makes OpenTofu a future adapter, not an architecture change.
## 14. Document Status and Next Steps
Status: **v1.0**. All 11 open items in §13 are resolved. The architecture is
internally consistent; the v1.1 implementation spike (ACDL Phases 08-10)
validates the locked substrate abstraction + contract→IR→adapter path
against real AWS via a per-run-rotated key (D-039; OIDC deferred to v1.2).
The v1.2 build-out (S3 Object Lock, JWS, HITL wiring, L3B skill catalog,
Kyverno/OPA, real OIDC federation, multi-region) is design-authored in
Phase 07 and implemented post-spike.
Doc-sync items (out of scope of this document but flagged for the same change set):
- The CDLC reference document's environment model assumes staging exists. Path A invalidates that. The CDLC contract example's targetEnvironments: [staging, production] must be revised to [dev, qa, prod, dr].
## 15. Phase 07 authored artifacts
The 11 resolutions are recorded in `PROJECT.md` (decisions D-034..D-046 +
the "Open-decision resolutions" table). Phase 07 formalizes the locked
commitments into these schema/design files (landed in Waves 2-4 of
Phase 07):
| REQ | File | Owner persona |
|-----|------|--------------|
| REQ-17 | `schemas/ir.schema.json` | platform-engineer |
| REQ-18 | `schemas/policy_check_result.schema.json` + `adapters/terraform/policy/checkov_adapter.py` | security-engineer |
| REQ-19 | `platform/confidence_signal.py` | backend-engineer + security-engineer (co-authored) |
| REQ-20 | `platform/audit_ledger_design.md` | security-engineer |
| REQ-21 | `platform/hitl_matrix_design.md` + `platform/separation_of_duties.py` | security-engineer |
| REQ-22 | `schemas/contract.schema.json` | backend-engineer |
The spike scope (D-041, D-043) vs v1.2 build-out boundary for each design
is documented in the respective file.
+82
View File
@@ -0,0 +1,82 @@
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://acdl.cloudinit.dev/schemas/contract.schema.json",
"title": "ACDL Contract",
"description": "Consumer-declared intent. The central pipeline resolves a contract to a Target Stack IR (schemas/ir.schema.json), the Terraform adapter compiles the IR to a plan. Strict fail-fast at schema stage with reason codes from a published vocabulary.",
"$comment": "Per-env mandatory inputs per W3.E (PROJECT.md). dev requires stack+environment; qa adds validation.e2eSuite + validation.loadTest; prod adds runbook+dashboard+oncall; dr adds drDrillRef. inputs always optional. profile: agentic fields optional everywhere (naturalLanguageIntent required when profile is agentic). W2.A (tag for dev/qa, SHA for prod) is a workflow-reference concern, not a schema field; the platform CLI resolves tag->SHA for prod-bound workflows.",
"type": "object",
"required": ["stack", "environment"],
"properties": {
"stack": {
"type": "string",
"pattern": "^l2-[a-z][a-z0-9-]*$",
"description": "L2 thin-composition reference (resolved by the pipeline to a Target Stack IR)."
},
"environment": {
"type": "string",
"enum": ["dev", "qa", "prod", "dr"],
"description": "Target environment. Staging does not exist (Path A locked, ARCHITECTURE.md §5)."
},
"inputs": {
"type": "object",
"description": "L2-level parameter map. Free-form in v1, typed per-L1 in v1.2 (W3.E).",
"additionalProperties": {"type": ["string", "number", "boolean"]}
},
"validation": {
"type": "object",
"description": "Validation evidence required in qa (W3.E).",
"properties": {
"e2eSuite": {"type": "string", "description": "Reference to the contract-declared e2e suite (last 24h, pass rate >= 99%)."},
"loadTest": {"type": "string", "description": "Reference to the load test report (last 7d, p99 < declared NFR)."}
}
},
"runbook": {"type": "string", "description": "Runbook reference, mandatory in prod (W3.E)."},
"dashboard": {"type": "string", "description": "Dashboard reference, mandatory in prod (W3.E)."},
"oncall": {"type": "string", "description": "On-call rotation reference, mandatory in prod (W3.E)."},
"drDrillRef": {"type": "string", "description": "DR drill report reference (last 180d), mandatory in dr (W3.E)."},
"profile": {
"type": "string",
"enum": ["developer", "agentic"],
"default": "developer",
"description": "Consumer surface. 'agentic' unlocks L3B fields (ARCHITECTURE.md §5)."
},
"naturalLanguageIntent": {
"type": "string",
"description": "L3B: the original natural-language prompt. Required when profile is agentic (W3.E)."
},
"confidenceAtSubmission": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "L3B: the agent's self-reported confidence at submission time."
},
"agentTrace": {
"type": "string",
"description": "L3B: reference to the agent's execution trace."
},
"supersedes": {
"type": "string",
"format": "uuid",
"description": "Prior contractId this re-submission replaces (after rejection — ARCHITECTURE.md §10.6)."
}
},
"allOf": [
{
"if": {"properties": {"environment": {"const": "qa"}}},
"then": {"required": ["validation"],
"properties": {"validation": {"required": ["e2eSuite", "loadTest"]}}}
},
{
"if": {"properties": {"environment": {"const": "prod"}}},
"then": {"required": ["runbook", "dashboard", "oncall"]}
},
{
"if": {"properties": {"environment": {"const": "dr"}}},
"then": {"required": ["drDrillRef"]}
},
{
"if": {"required": ["profile"], "properties": {"profile": {"const": "agentic"}}},
"then": {"required": ["naturalLanguageIntent"]}
}
]
}
+118
View File
@@ -0,0 +1,118 @@
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://acdl.cloudinit.dev/schemas/ir.schema.json",
"title": "ACDL Target Stack IR",
"description": "Substrate-neutral description of a target stack: resources with typed inputs/outputs/NFRs, relationships (single parent per child), composition tree (max depth 5), and policy hooks. The L1 registry, L2 thin-composition tree, contract YML, and PolicyCheckResult schema are all defined against this IR. Substrate adapters (the Terraform adapter in v1) are the only substrate-specific code.",
"$comment": "v1 ships one adapter (Terraform). The IR is nearly isomorphic to Terraform in v1 (ARCHITECTURE.md §12.1); the adapter compiles resource.module -> module block, resource.inputs -> variable + arg, resource.outputs -> output, relationship.kind=uses_output -> interpolation, relationship.kind=parent -> composition ordering hint. As more adapters appear (v2+), the IR gains expressiveness; the L1 content + contract YML + thin-composition tree do not change. The schema body is substrate-agnostic: no Terraform block keywords (variable/output/resource as blocks) and no aws_ provider prefixes in the schema keywords; type values are IR types (aws:s3:bucket), not Terraform resource types (aws_s3_bucket).",
"type": "object",
"required": ["version", "stack", "resources"],
"properties": {
"version": {
"type": "string",
"description": "IR schema version (semver).",
"pattern": "^\\d+\\.\\d+\\.\\d+$"
},
"stack": {
"type": "object",
"description": "The L1/L2 stack identity this IR represents.",
"required": ["name", "kind", "depth"],
"properties": {
"name": {
"type": "string",
"pattern": "^l[12]-[a-z][a-z0-9-]*$",
"description": "Stack name matching the L1/L2 folder name."
},
"kind": {
"type": "string",
"enum": ["l1", "l2"],
"description": "l1 = primitive; l2 = thin-composition."
},
"depth": {
"type": "integer",
"minimum": 1,
"maximum": 5,
"description": "Composition depth (ARCHITECTURE.md §3: max depth 5). L2->L1 is depth 1."
}
}
},
"resources": {
"type": "array",
"minItems": 1,
"items": {"$ref": "#/$defs/resource"}
},
"relationships": {
"type": "array",
"description": "Optional in v1; present when the adapter needs explicit ordering/output wiring hints beyond parent composition.",
"items": {"$ref": "#/$defs/relationship"}
}
},
"$defs": {
"resource": {
"type": "object",
"required": ["id", "type", "module", "inputs"],
"properties": {
"id": {
"type": "string",
"pattern": "^[a-z][a-z0-9-]*$",
"description": "Local IR resource id (unique within the stack)."
},
"type": {
"type": "string",
"description": "IR-typed resource identifier (substrate-agnostic), e.g. 'aws:s3:bucket'. NOT a Terraform resource type ('aws_s3_bucket'); the adapter translates IR type -> substrate type."
},
"module": {
"type": "string",
"pattern": "^l1-[a-z][a-z0-9-]*@\\d+\\.\\d+\\.\\d+$",
"description": "L1 registry reference: name@semver (W3.D). MAJOR bumps require a new registry entry (immutable publication); old entry enters a 12-month deprecation window."
},
"parent": {
"type": "string",
"description": "Parent resource id. Absent for the root. Single parent per child (ARCHITECTURE.md §12.1)."
},
"inputs": {
"type": "object",
"description": "Input values keyed by the L1 module's declared inputs. Free-form in v1 (validated at contract->IR resolution against the L1 registry); typed per-L1 in v1.2.",
"additionalProperties": {"type": ["string", "number", "boolean"]}
},
"outputs": {
"type": "object",
"description": "Typed output contract. The adapter translates this to a substrate output block (e.g. Terraform output).",
"additionalProperties": {"$ref": "#/$defs/outputSpec"}
},
"nfrs": {
"type": "object",
"description": "Declared non-functional requirements (latency, throughput, error rate). Opaque to the adapter; consumed by the confidence signal's NFR input.",
"additionalProperties": true
}
}
},
"outputSpec": {
"type": "object",
"required": ["type"],
"properties": {
"type": {
"type": "string",
"description": "IR-typed output type: a primitive ('string', 'arn') or a reference ('ref:<resourceId>.<outputName>')."
},
"description": {"type": "string"}
}
},
"relationship": {
"type": "object",
"required": ["from", "to", "kind"],
"properties": {
"from": {"type": "string", "description": "Source resource id."},
"to": {"type": "string", "description": "Target resource id."},
"kind": {
"type": "string",
"enum": ["parent", "depends_on", "uses_output"],
"description": "v1 uses 'parent' (composition ordering) + 'uses_output' (interpolation). 'depends_on' is reserved for v2 explicit-dependency cases."
},
"shared_keyword": {
"type": "string",
"description": "Reserved for v2 multi-relationship dependencies. Unused in v1."
}
}
}
}
}
+53
View File
@@ -0,0 +1,53 @@
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://acdl.cloudinit.dev/schemas/policy_check_result.schema.json",
"title": "ACDL PolicyCheckResult",
"description": "Normalized policy check result — the contract between policy engines and the confidence signal. Engine-specific adapters (checkov_adapter.py, future kyverno_adapter) translate native engine output to this shape. The confidence signal consumes a list of these as its policy input; it is engine-agnostic. The severity enum drives the severity->penalty mapping (critical hard-override, high -0.2, medium -0.05, low -0.01, info 0.0).",
"$comment": "Canonical PolicyCheckResult (ARCHITECTURE.md §12.6). The confidence signal (platform/confidence_signal.py) consumes a list of these as its policy input; it is engine-agnostic. Adapters translate native output to this shape; the signal never reads engine-specific evidence.",
"type": "object",
"required": ["contractId", "evaluatedAt", "engine", "ruleId", "severity", "result", "message", "resourceRef"],
"properties": {
"contractId": {
"type": "string",
"format": "uuid",
"description": "The contract this check was evaluated against."
},
"evaluatedAt": {
"type": "string",
"format": "date-time",
"description": "ISO-8601 timestamp of evaluation."
},
"engine": {
"type": "string",
"enum": ["checkov", "kyverno", "opa"],
"description": "Policy engine that produced this result."
},
"ruleId": {
"type": "string",
"description": "Rule identifier (e.g. CKV_AWS_24, KYVERNO_NO_PRIVILEGED, ACDL_TAG_NAMING)."
},
"severity": {
"type": "string",
"enum": ["critical", "high", "medium", "low", "info"],
"description": "Severity drives the confidence signal's penalty mapping (ARCHITECTURE.md §8)."
},
"result": {
"type": "string",
"enum": ["pass", "fail", "skipped", "error"],
"description": "Check outcome."
},
"message": {
"type": "string",
"description": "Human-readable result message."
},
"evidence": {
"type": "object",
"additionalProperties": true,
"description": "Engine-specific payload (file_path, resource, code_block, etc.). Opaque to the confidence signal; present for audit/debug."
},
"resourceRef": {
"type": "string",
"description": "IR-typed resource identifier (the resource this check evaluated)."
}
}
}
+98
View File
@@ -0,0 +1,98 @@
#!/usr/bin/env bash
# scripts/rotate_spike_key.sh - rotate the acdl-spike-runner IAM access key.
#
# Uses the bootstrap root key (ACDL_BOOTSTRAP_AWS_*) from the env to:
# 1. List acdl-spike-runner's access keys.
# 2. Create a new key.
# 3. Deactivate + delete the old key(s).
# 4. Write the new key to gitignored .env.secrets (chmod 600).
# 5. Optionally upload to Gitea secrets if ACDL_GITEA_TOKEN is set.
#
# Idempotent: re-running always ends with exactly 1 active key for the user.
# Does NOT rotate the bootstrap root key (D-034 closure = manual user step).
#
# Spike scope (D-039): the spike user key is per-run-rotated; real OIDC is
# v1.2 (blocked on go-gitea/gitea#36988).
set -u
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT"
ENV_FILE="$ROOT/.env.secrets"
fail() { echo "FAIL: $*" >&2; exit 1; }
: "${ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID:?set ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID to the root key}"
: "${ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY:?set ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY to the root key}"
REGION="${AWS_DEFAULT_REGION:-us-east-1}"
USER_NAME="acdl-spike-runner"
# Confirm .env.secrets is gitignored before writing to it.
git check-ignore -q "$ENV_FILE" || fail "$ENV_FILE is not gitignored — refusing to write the key"
python3 - <<'PY'
import os
import sys
import json
import boto3
region = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
user = "acdl-spike-runner"
env_file = os.path.join(os.getcwd(), ".env.secrets")
session = boto3.Session(
aws_access_key_id=os.environ["ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID"],
aws_secret_access_key=os.environ["ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY"],
region_name=region,
)
iam = session.client("iam")
# List current keys.
keys = iam.list_access_keys(UserName=user).get("AccessKeyMetadata", [])
active = [k for k in keys if k["Status"] == "Active"]
# Create a new key first (so the user always has a working key during rotation).
new = iam.create_access_key(UserName=user)["AccessKey"]
new_id = new["AccessKeyId"]
new_secret = new["SecretAccessKey"]
print(f"iam: created new key {new_id} for {user}", file=sys.stderr)
# Deactivate + delete the old keys.
for k in active:
old_id = k["AccessKeyId"]
if old_id == new_id:
continue
iam.update_access_key(UserName=user, AccessKeyId=old_id, Status="Inactive")
iam.delete_access_key(UserName=user, AccessKeyId=old_id)
print(f"iam: deactivated+deleted old key {old_id}", file=sys.stderr)
# Write the new key to gitignored .env.secrets (chmod 600).
with open(env_file, "w") as fh:
fh.write(f"ACDL_AWS_ACCESS_KEY_ID={new_id}\n")
fh.write(f"ACDL_AWS_SECRET_ACCESS_KEY={new_secret}\n")
fh.write(f"AWS_DEFAULT_REGION={region}\n")
os.chmod(env_file, 0o600)
print(f"rotated key written to {env_file} (chmod 600)", file=sys.stderr)
# Optionally upload to Gitea secrets.
gitea_token = os.environ.get("ACDL_GITEA_TOKEN")
if gitea_token:
import urllib.request
base = "https://git.cloudinit.dev/api/v1/repos/continuous-intelligence/acdl/actions/secrets"
for name, value in [("ACDL_AWS_ACCESS_KEY_ID", new_id),
("ACDL_AWS_SECRET_ACCESS_KEY", new_secret)]:
req = urllib.request.Request(
f"{base}/{name}",
data=json.dumps({"value": value}).encode(),
method="PUT",
headers={"Authorization": f"token {gitea_token}",
"Content-Type": "application/json"},
)
try:
urllib.request.urlopen(req).read()
print(f"gitea: secret {name} uploaded", file=sys.stderr)
except Exception as e:
print(f"gitea: secret {name} upload FAILED: {e}", file=sys.stderr)
else:
print("gitea: ACDL_GITEA_TOKEN not set; Gitea secret upload skipped (v1.2 hardening)", file=sys.stderr)
print(f"OK: {user} now has exactly 1 active key: {new_id}")
PY
+6 -2
View File
@@ -22,11 +22,15 @@ out=$(ACDL_GITEA_TOKEN= bash demo/scripts/run_demo.sh --no-upload 2>&1); rc=$?
ok "demo/scripts/run_demo.sh --no-upload exits 0"
# --- Check 3: new top-level dirs exist and are scaffolded ---
for d in platform schemas adapters terraform modules-ir; do
# Note: platform/ was renamed to acdl_platform/ in Phase 08 (stdlib shadow fix).
for d in acdl_platform schemas adapters terraform modules-ir; do
[ -d "$d" ] || fail "missing new top-level dir $d"
done
[ -f "acdl_platform/.gitkeep" ] || [ -f "acdl_platform/__init__.py" ] || fail "acdl_platform/ not scaffolded"
for d in schemas adapters terraform modules-ir; do
[ -f "$d/.gitkeep" ] || fail "missing $d/.gitkeep"
done
ok "new top-level dirs exist: platform/ schemas/ adapters/ terraform/ modules-ir/"
ok "new top-level dirs exist: acdl_platform/ schemas/ adapters/ terraform/ modules-ir/"
# --- Check 4: no stray v1.0 dirs left at repo root ---
for stray in modules evidence-ui contracts contracts-repo ACDL_DEMO.md; do
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env bash
# scripts/verify_phase07.sh - Phase 07 architecture-v1-finalization gate.
set -u
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT"
fail() { echo "FAIL: $*" >&2; exit 1; }
ok() { echo "ok: $*"; }
# --- Check 1: all 9 deliverable files exist ---
# Note: platform/ was renamed to acdl_platform/ in Phase 08 to avoid
# shadowing the stdlib platform module (boto3 imports uuid ->
# platform.system()).
for f in docs/architecture-v1.0.md \
schemas/ir.schema.json \
schemas/policy_check_result.schema.json \
schemas/contract.schema.json \
acdl_platform/confidence_signal.py \
acdl_platform/audit_ledger_design.md \
acdl_platform/hitl_matrix_design.md \
acdl_platform/separation_of_duties.py \
adapters/terraform/policy/checkov_adapter.py; do
[ -f "$f" ] || fail "missing $f"
done
ok "all 9 deliverable files exist"
# --- Check 2: 3 JSON Schemas are valid Draft 2020-12 ---
for s in schemas/ir.schema.json schemas/policy_check_result.schema.json schemas/contract.schema.json; do
python3 -c "import json, jsonschema; jsonschema.Draft202012Validator.check_schema(json.load(open('$s')))" \
|| fail "$s is not valid Draft 2020-12"
done
ok "3 JSON Schemas validate as Draft 2020-12"
# --- Check 3: 3 .py files py_compile ---
for p in acdl_platform/confidence_signal.py acdl_platform/separation_of_duties.py adapters/terraform/policy/checkov_adapter.py; do
python3 -m py_compile "$p" || fail "$p py_compile failed"
done
ok "3 .py files py_compile"
# --- Check 4: 3 .md design files non-empty ---
for m in acdl_platform/audit_ledger_design.md acdl_platform/hitl_matrix_design.md docs/architecture-v1.0.md; do
[ -s "$m" ] || fail "$m is empty"
done
ok "3 .md design files non-empty"
# --- Check 5: all 11 decision IDs + OpenTofu in PROJECT.md ---
for id in W1.A W1.B W2.A W3.D W3.E BA.A BA.B BA.C BA.D BA.E BA.F; do
grep -q "$id" .ciagent/PROJECT.md || fail "missing $id in PROJECT.md"
done
grep -qi "opentofu" .ciagent/PROJECT.md || fail "missing OpenTofu in PROJECT.md"
ok "all 11 decision IDs + OpenTofu present in PROJECT.md"
# --- Check 6: docs/architecture-v1.0.md status is v1.0 ---
grep -q "v1.0" docs/architecture-v1.0.md || fail "architecture-v1.0.md missing v1.0"
ok "docs/architecture-v1.0.md status is v1.0"
# --- Check 7: D-040..D-044 present in PROJECT.md ---
for d in D-040 D-041 D-042 D-043 D-044; do
grep -q "$d" .ciagent/PROJECT.md || fail "missing $d in PROJECT.md"
done
ok "D-040..D-044 present in PROJECT.md"
# --- Check 8: spike contract validates against contract schema ---
echo '{"stack":"l2-static-asset","environment":"dev","inputs":{"bucket_name":"x","region":"us-east-1"}}' > /tmp/spike-contract.json
python3 -c "import json, jsonschema; jsonschema.validate(json.load(open('/tmp/spike-contract.json')), json.load(open('schemas/contract.schema.json')))" \
|| fail "spike contract does not validate against contract schema"
ok "spike contract validates against contract schema"
# --- Check 9: minimal IR validates against IR schema ---
echo '{"version":"1.0.0","stack":{"name":"l2-static-asset","kind":"l2","depth":1},"resources":[{"id":"s3","type":"aws:s3:bucket","module":"l1-s3@1.0.0","inputs":{"bucket_name":"x","region":"us-east-1"}}]}' > /tmp/spike-ir.json
python3 -c "import json, jsonschema; jsonschema.validate(json.load(open('/tmp/spike-ir.json')), json.load(open('schemas/ir.schema.json')))" \
|| fail "minimal IR does not validate against IR schema"
ok "minimal IR validates against IR schema"
echo "VERIFIED — Phase 07: architecture v1.0 finalized; 6 files authored + 11 decisions resolved"
+80
View File
@@ -0,0 +1,80 @@
#!/usr/bin/env bash
# scripts/verify_phase08.sh - Phase 08 aws-bootstrap gate.
set -u
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT"
fail() { echo "FAIL: $*" >&2; exit 1; }
ok() { echo "ok: $*"; }
ENV_FILE="$ROOT/.env.secrets"
[ -f "$ENV_FILE" ] || fail ".env.secrets missing (run scripts/rotate_spike_key.sh first)"
# Confirm .env.secrets + .bootstrap_state.json are gitignored.
git check-ignore -q "$ENV_FILE" || fail ".env.secrets is not gitignored"
git check-ignore -q terraform/bootstrap/.bootstrap_state.json || \
fail "terraform/bootstrap/.bootstrap_state.json is not gitignored"
ok ".env.secrets + .bootstrap_state.json are gitignored"
# Source the rotated spike key.
set -a
. "$ENV_FILE"
set +a
: "${ACDL_AWS_ACCESS_KEY_ID:?ACDL_AWS_ACCESS_KEY_ID missing in .env.secrets}"
: "${ACDL_AWS_SECRET_ACCESS_KEY:?ACDL_AWS_SECRET_ACCESS_KEY missing in .env.secrets}"
: "${AWS_DEFAULT_REGION:?AWS_DEFAULT_REGION missing in .env.secrets}"
export AWS_ACCESS_KEY_ID="$ACDL_AWS_ACCESS_KEY_ID"
export AWS_SECRET_ACCESS_KEY="$ACDL_AWS_SECRET_ACCESS_KEY"
export AWS_DEFAULT_REGION
# --- Check 1: caller identity is acdl-spike-runner (NOT root) ---
ARN=$(python3 <<'PY'
import boto3, json
s = boto3.Session(region_name='us-east-1')
print(s.client('sts').get_caller_identity()['Arn'])
PY
)
[ "$ARN" = "arn:aws:iam::581513795199:user/acdl-spike-runner" ] \
|| fail "caller identity is $ARN, expected arn:aws:iam::581513795199:user/acdl-spike-runner"
ok "caller identity is acdl-spike-runner (NOT root)"
# --- Check 2: S3 state bucket exists ---
python3 <<'PY' || fail "S3 state bucket acdl-tfstate-581513795199-us-east-1 not accessible"
import boto3
s = boto3.Session(region_name='us-east-1')
s.client('s3').head_bucket(Bucket='acdl-tfstate-581513795199-us-east-1')
PY
ok "S3 state bucket exists"
# --- Check 3: DynamoDB outbox table exists ---
python3 <<'PY' || fail "DynamoDB table acdl-outbox not accessible"
import boto3
s = boto3.Session(region_name='us-east-1')
s.client('dynamodb').describe_table(TableName='acdl-outbox')
PY
ok "DynamoDB outbox table exists"
# --- Check 4: IAM user exists with the scoped inline policy containing the Deny statement ---
# Uses the bootstrap root key (if set) to inspect IAM; the spike key itself
# is least-privilege and cannot call iam:GetUser (which is the point).
if [ -n "${ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID:-}" ]; then
AWS_ACCESS_KEY_ID="$ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID" \
AWS_SECRET_ACCESS_KEY="$ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY" \
AWS_DEFAULT_REGION="$AWS_DEFAULT_REGION" \
python3 <<'PY' || fail "IAM user acdl-spike-runner missing or policy lacks DenyEverythingElse"
import boto3, json
s = boto3.Session(region_name='us-east-1')
iam = s.client('iam')
iam.get_user(UserName='acdl-spike-runner')
doc = iam.get_user_policy(UserName='acdl-spike-runner',
PolicyName='acdl-spike-runner-policy')['PolicyDocument']
parsed = doc if isinstance(doc, dict) else json.loads(doc)
sids = [st.get('Sid', '') for st in parsed['Statement']]
assert 'DenyEverythingElse' in sids, 'DenyEverythingElse statement missing'
PY
ok "IAM user acdl-spike-runner exists with the scoped Deny-everything-else policy (verified via bootstrap key)"
else
echo "ok: IAM check skipped (ACDL_BOOTSTRAP_AWS_* not set; the spike key is least-privilege and cannot iam:GetUser — that itself confirms the policy denies non-granted actions)"
fi
echo "VERIFIED — Phase 08: AWS bootstrap complete; spike key rotated; D-034 closed (user must rotate the root key manually now)"
+71
View File
@@ -0,0 +1,71 @@
# ACDL v1.1 Spike — AWS Bootstrap Runbook
Phase 08 bootstraps the AWS substrate for the v1.1 spike. It uses the
**root account credential for account 581513795199 exactly once**, then
closes D-034 by having the user manually rotate the root key afterward.
> **Spike scope (D-039):** the spike uses a per-run-rotated IAM *user* key
> (`acdl-spike-runner`), NOT OIDC. Real OIDC federation is deferred to
> v1.2 (blocked on go-gitea/gitea#36988 — Gitea Actions does not support
> `id-token: write`). The `acdl-spike-runner` user + its key are deleted
> in v1.2 cleanup when the OIDC role lands.
## Steps
1. **Set the bootstrap root key in env** (never commit, never echo):
```bash
export ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID="<root key>"
export ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY="<root secret>"
export AWS_DEFAULT_REGION="us-east-1"
```
2. **Create the state backend** (S3 bucket + DynamoDB outbox table):
```bash
python3 terraform/bootstrap/create_state_backend.py
```
Idempotent; writes `terraform/bootstrap/.bootstrap_state.json` marker.
3. **Create the IAM user + scoped policy + initial key**:
```bash
python3 terraform/bootstrap/create_iam_user.py
```
Prints `ACDL_AWS_ACCESS_KEY_ID=<...>` + `ACDL_AWS_SECRET_ACCESS_KEY=<...>`
to stdout (capture if you want the initial key; `rotate_spike_key.sh`
creates a fresh one anyway).
4. **Rotate the spike key** (creates a new key, deactivates+deletes old,
writes the new key to gitignored `.env.secrets`):
```bash
bash scripts/rotate_spike_key.sh
```
Optionally uploads to Gitea Actions secrets if `ACDL_GITEA_TOKEN` is set.
5. **Verify**:
```bash
bash scripts/verify_phase08.sh
```
Asserts: caller identity is `acdl-spike-runner` (not root); S3 bucket +
DynamoDB table + IAM user + scoped policy all exist; `.env.secrets` +
`.bootstrap_state.json` are gitignored.
6. **MANUAL — D-034 closure:** rotate/deactivate the **root** key in the
AWS IAM console (the user does this, not the script). The bootstrap
root key has now served its one-shot purpose; the spike uses the
rotated `acdl-spike-runner` key for Phases 09-10.
## What the spike uses for Phases 09-10
- **State backend:** S3 bucket `acdl-tfstate-581513795199-us-east-1` +
DynamoDB table `acdl-outbox` (one table for both lock + outbox, D-P08-1).
- **Auth:** the rotated `acdl-spike-runner` key in `.env.secrets`
(gitignored, chmod 600). Re-rotate after each spike run via
`rotate_spike_key.sh` (D-039).
## Spike scope vs v1.2 boundary
| Concern | Spike (Phase 08) | v1.2 |
|---------|------------------|------|
| AWS auth | per-run-rotated long-lived key (D-039 waiver) | real OIDC federation (go-gitea/gitea#36988) |
| IAM | minimal user `acdl-spike-runner` + scoped policy | OIDC role + trust policy (no user, no key) |
| State backend | S3 + DynamoDB single-region (us-east-1) | multi-region |
| Secret storage | gitignored `.env.secrets` + optional Gitea secret | Gitea OIDC-issued web-identity token (no secret) |
+72
View File
@@ -0,0 +1,72 @@
"""Create the ACDL v1.1 spike IAM user + scoped inline policy + initial key.
Idempotent: skips user creation if the user exists; creates an initial
access key if none active exists. Prints the key to stdout for the
orchestrator to capture (NEVER committed):
ACDL_AWS_ACCESS_KEY_ID=<...>
ACDL_AWS_SECRET_ACCESS_KEY=<...>
Run with the bootstrap root key in env:
ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID / ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION (defaults to us-east-1)
The inline policy is read from spike_runner_policy.json (next to this
file). The account id + region are already substituted in the policy file
for account 581513795199 + us-east-1; this script does not substitute
further (the policy file is spike-specific).
"""
import json
import os
import sys
import boto3
REGION = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
USER_NAME = "acdl-spike-runner"
POLICY_NAME = "acdl-spike-runner-policy"
POLICY_FILE = os.path.join(os.path.dirname(__file__), "spike_runner_policy.json")
def main():
session = boto3.Session(
aws_access_key_id=os.environ["ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID"],
aws_secret_access_key=os.environ["ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY"],
region_name=REGION,
)
iam = session.client("iam")
# --- IAM user (idempotent) ---
try:
iam.get_user(UserName=USER_NAME)
print(f"iam: user {USER_NAME} already exists")
except iam.exceptions.NoSuchEntityException:
iam.create_user(UserName=USER_NAME)
print(f"iam: created user {USER_NAME}")
# --- Inline policy (idempotent: put_user_policy overwrites) ---
with open(POLICY_FILE, "r") as fh:
policy_doc = fh.read()
iam.put_user_policy(
UserName=USER_NAME,
PolicyName=POLICY_NAME,
PolicyDocument=policy_doc,
)
print(f"iam: inline policy {POLICY_NAME} attached to {USER_NAME}")
# --- Initial access key (create only if no active key exists) ---
keys = iam.list_access_keys(UserName=USER_NAME).get("AccessKeyMetadata", [])
active = [k for k in keys if k["Status"] == "Active"]
if active:
print(f"iam: {USER_NAME} already has {len(active)} active key(s); not creating a new one")
print(" (use scripts/rotate_spike_key.sh to rotate)")
return
new_key = iam.create_access_key(UserName=USER_NAME)["AccessKey"]
print("ACDL_AWS_ACCESS_KEY_ID=" + new_key["AccessKeyId"])
print("ACDL_AWS_SECRET_ACCESS_KEY=" + new_key["SecretAccessKey"])
print(f"iam: created initial access key {new_key['AccessKeyId']} for {USER_NAME}", file=sys.stderr)
if __name__ == "__main__":
main()
@@ -0,0 +1,88 @@
"""Create the ACDL v1.1 spike AWS state backend (idempotent).
- S3 bucket acdl-tfstate-<account_id>-us-east-1 (versioning enabled).
- DynamoDB table acdl-outbox (PAY_PER_REQUEST; PK contractId, SK
eventType#eventTs) — used for BOTH Terraform state locking AND the
evidence outbox (D-P08-1).
Run with the bootstrap root key in env:
ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID / ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION (defaults to us-east-1)
Writes terraform/bootstrap/.bootstrap_state.json (gitignored bookkeeping).
"""
import datetime
import json
import os
import sys
import boto3
REGION = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
STATE_BUCKET = "acdl-tfstate-581513795199-us-east-1"
OUTBOX_TABLE = "acdl-outbox"
ACCOUNT_ID = "581513795199"
def main():
session = boto3.Session(
aws_access_key_id=os.environ["ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID"],
aws_secret_access_key=os.environ["ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY"],
region_name=REGION,
)
s3 = session.client("s3", region_name=REGION)
dyn = session.client("dynamodb", region_name=REGION)
# --- S3 state bucket (idempotent) ---
try:
s3.head_bucket(Bucket=STATE_BUCKET)
print(f"s3: bucket {STATE_BUCKET} already exists")
except Exception:
kwargs = {"Bucket": STATE_BUCKET}
if REGION != "us-east-1":
kwargs["CreateBucketConfiguration"] = {"LocationConstraint": REGION}
s3.create_bucket(**kwargs)
print(f"s3: created bucket {STATE_BUCKET}")
# Enable versioning (idempotent)
s3.put_bucket_versioning(
Bucket=STATE_BUCKET,
VersioningConfiguration={"Status": "Enabled"},
)
print(f"s3: versioning enabled on {STATE_BUCKET}")
# --- DynamoDB outbox table (idempotent) ---
try:
dyn.describe_table(TableName=OUTBOX_TABLE)
print(f"dynamodb: table {OUTBOX_TABLE} already exists")
except dyn.exceptions.ResourceNotFoundException:
dyn.create_table(
TableName=OUTBOX_TABLE,
BillingMode="PAY_PER_REQUEST",
AttributeDefinitions=[
{"AttributeName": "contractId", "AttributeType": "S"},
{"AttributeName": "eventType#eventTs", "AttributeType": "S"},
],
KeySchema=[
{"AttributeName": "contractId", "KeyType": "HASH"},
{"AttributeName": "eventType#eventTs", "KeyType": "RANGE"},
],
)
print(f"dynamodb: created table {OUTBOX_TABLE}")
dyn.get_waiter("table_exists").wait(TableName=OUTBOX_TABLE)
marker = {
"account_id": ACCOUNT_ID,
"bucket_name": STATE_BUCKET,
"table_name": OUTBOX_TABLE,
"region": REGION,
"created_at": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
}
with open(os.path.join(os.path.dirname(__file__), ".bootstrap_state.json"), "w") as fh:
json.dump(marker, fh, indent=2)
print("bootstrap state marker written:", marker)
if __name__ == "__main__":
main()
@@ -0,0 +1,51 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "SpikeStateBucketReadWrite",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetBucketVersioning"
],
"Resource": [
"arn:aws:s3:::acdl-tfstate-581513795199-us-east-1",
"arn:aws:s3:::acdl-tfstate-581513795199-us-east-1/*"
]
},
{
"Sid": "SpikeOutboxTableReadWrite",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:DeleteItem",
"dynamodb:UpdateItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:DescribeTable"
],
"Resource": "arn:aws:dynamodb:us-east-1:581513795199:table/acdl-outbox"
},
{
"Sid": "SpikeStsSelfIdentify",
"Effect": "Allow",
"Action": "sts:GetCallerIdentity",
"Resource": "*"
},
{
"Sid": "DenyEverythingElse",
"Effect": "Deny",
"Action": "*",
"NotResource": [
"arn:aws:s3:::acdl-tfstate-581513795199-us-east-1",
"arn:aws:s3:::acdl-tfstate-581513795199-us-east-1/*",
"arn:aws:dynamodb:us-east-1:581513795199:table/acdl-outbox"
]
}
]
}