docs(P51): full presentation rework — scope, story arc, visuals, appendix

Major rework of both presentation decks based on leadership feedback.
Addresses: story arc, concept clarity, scope clarification, more visuals,
appendix for detail-heavy slides, and a complete Road to the North Star.

6 new mermaid diagrams:
- platform-works-03-scope-boundary (Upstream → Contract → ACDL → AWS)
- developer-experience-01b-scope-boundary (both consumer paths + scope)
- platform-works-04-confidence-signal (6 inputs → score → gate → decision)
- platform-works-05-attestation-flow (deploy → gate → approver → evidence)
- developer-experience-04-promotion-journey (dev → qa → prod → dr)
- road-to-north-star (v1.0 demo → v1.9 → v1.10 → v2.0 → North Star)

Both Marp decks restructured to 10 main + 6 appendix slides:

PW deck (17 slides):
1. Title
2. The Problem & The North Star (anti-goals moved to slide 3)
3. Where ACDL Sits in Your World (NEW — scope boundary, infra only)
4. The Contract-Driven Model (image: removed, infra inputs instead)
5. The End-to-End Flow
6. Zero-Trust by Default
7. Safety is Computed (NEW confidence signal diagram)
8. Security by Construction
9. Accountability & Audit (NEW attestation flow diagram, QA clarification,
   badge reclassification: dev=Testing, qa/prod/dr=Planned)
10. Testing vs. Planned (summary, full inventory in appendix)
11. The Vision Realized
+ Appendix: TOC, Platform-Managed Environments, Observability, Road to
  North Star, Full Inventory, Glossary

DX deck (16 slides):
1. Title
2. Where ACDL Sits in Your World (REPLACES Two Consumer Surfaces — scope
   boundary with both consumer paths)
3. The Contract — The Entire Consumer Surface (image: removed)
4. The Developer Feedback Loop
5. Versioned, Predictable Releases
6. Friendly Onboarding
7. Safe Promotion Path (NEW promotion journey diagram, rising bar
   annotated: dev=Testing, qa/prod/dr=Planned)
8. Safe Decommission
9. Self-Service Module Catalog
10. The Desired Outcomes
+ Appendix: TOC, Citizen Developer Experience, No Platform Code, Local
  Reproducibility, Road to North Star, Glossary

Story arc: every slide has an italic 'Story beat' line connecting it to
the narrative progression.

Scope clarification: ACDL is infrastructure only. Upstream is anything
(IDE, agentic SDLC, citizen dev vibe coding). ACDL provisions and governs
AWS resources; application deployment is upstream. Contract examples now
show infrastructure inputs (cpu, memory, desired_count, port) not image:.

QA attestation reclassification: 'Design tested' → 'Planned'. QA attests
to infrastructure readiness (contract + Terraform plan + evidence), not
application code. Dev is autonomous (Testing); qa/prod/dr are Planned.

Road to the North Star: phased timeline (v1.0 → v1.9 → v1.10 → v2.0 →
North Star), annotated 'proposed phasing, not formally planned.'

Also: scripts/sync_to_gl.sh added (GitLab mirror sync utility).

---ci---
phase: 51
milestone: v1.9
status: complete
requirements:
  covered: []
  partial: []
---/ci---

.ciagent/ARCHITECTURE.md

@@ -15,7 +15,7 @@ locked commitments and the v1.1 spike scope.
 ## Overview
 
 The platform is **four layers + six cross-cutting concerns**. The sixth
-concern — the substrate abstraction (§12) — is first-class, not an
+concern — the engine abstraction (§12) — is first-class, not an
 implementation detail. The vision's "Two Consumer Surfaces, One Platform"
 tenet binds everything: L3A and L3B converge on the same contract schema,
 the same policy envelope, and the same evidence stream.
@@ -53,7 +53,7 @@ the same policy envelope, and the same evidence stream.
 ## Layers
 
 ### Layer 1 — Foundational Primitives
-Single-purpose, **substrate-agnostic** primitive modules. L1 modules do
+Single-purpose, **engine-agnostic** primitive modules. L1 modules do
 not compose with other L1s; L1 takes its environment as input. The L1
 interface is defined against the **Target Stack IR**, not against Terraform
 directly (the IR is shaped to round-trip to Terraform in v1, per §12.1).
@@ -181,15 +181,15 @@ platform does not run the skill. Stateless agents, all state in the
 platform. Skills are reviewed for sensitive data before release (Infra &
 Ops owns the review; it is the mandatory release gate).
 
-### Substrate execution (§12) — the binding constraint
-**Target Stack IR** (locked): a substrate-neutral description of resources
+### Angine execution (§12) — the binding constraint
+**Target Stack IR** (locked): a engine-neutral description of resources
 (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 the IR — none against any specific substrate.
+defined against the IR — none against any specific engine.
 
-**Substrate adapters** are the only substrate-specific code. An adapter
-compiles the IR into a substrate execution plan. **v1 ships exactly one
+**Angine adapters** are the only engine-specific code. An adapter
+compiles the IR into a engine execution plan. **v1 ships exactly one
 adapter: the Terraform adapter.** v2+ may add OpenTofu, Pulumi, K8s CRDs
 without architectural change.
 
@@ -248,7 +248,7 @@ The spike (Phases 08–10) materializes the **minimum** that proves the IR
 commitments hold (no polyglot mess):
 
 - One L1: `l1-s3` (IR-typed interface; the only AWS resource in the spike).
-- One L2 thin-composition: `l2-static-asset` (references `l1-s3` only).
+- One L2 thin-composition: `l2-static-assets` (references `l1-s3` only).
 - Terraform adapter: IR → `terraform plan` against AWS via OIDC.
 - One contract submission → contract→IR → `terraform plan` → Checkov
   `PolicyCheckResult` → confidence signal → evidence event to the DynamoDB
@@ -297,7 +297,7 @@ ACDL has no `package.json`. The verification gate substitutes:
 2. Phase 07 — finalize architecture v1.0; author schemas + designs.
 3. Phase 08 — AWS OIDC bootstrap (use temp key once, rotate).
 4. Phase 09 — IR + `l1-s3` + Terraform adapter → `terraform plan`.
-5. Phase 10 — `l2-static-asset` + contract→IR → end-to-end spike.
+5. Phase 10 — `l2-static-assets` + contract→IR → end-to-end spike.
 6. COMPLETE gate — review → ship `v1.2.0` → audit. **DONE.**
 
 ## v1.2 build-out scope
@@ -335,20 +335,20 @@ extends the *implementation*, not the design.
    ECS Fargate service serving HTTP 200 → evidence event to the DynamoDB
    outbox → acdl-evidence timeline.
 
-### Substrate extension (ECS Fargate)
+### Angine extension (ECS Fargate)
 
-The Terraform adapter (§12) remains the only substrate-specific code. v1.2
+The Terraform adapter (§12) remains the only engine-specific code. v1.2
 expands the adapter `TYPE_MAP` to cover the six new ECS-shaped IR resource
 types. The L1 interface shape (IR-typed inputs/outputs/NFRs, registered in
 `modules-ir/registry.json`) is unchanged — only the set of registered L1s
 grows. The IR commitments (REQ-28) continue to hold: `modules-ir/`,
-`schemas/`, `contracts/`, `acdl_platform/confidence_signal.py`,
-`acdl_platform/contract_resolver.py`, `acdl_platform/outbox_writer.py`
-remain substrate-agnostic.
+`schemas/`, `contracts/`, `core/confidence_signal.py`,
+`core/contract_resolver.py`, `core/outbox_writer.py`
+remain engine-agnostic.
 
 ### `terraform apply` (dev only)
 
-v1.2 lifts the substrate execution from `plan` to `apply` for the `dev`
+v1.2 lifts the engine execution from `plan` to `apply` for the `dev`
 environment only. Dev is autonomous per §10 (confidence ≥ 0.50, no HITL).
 `apply` for qa/prod/dr remains HITL-gated and out of scope for v1.2. The
 apply result (resources created, plan diff) is captured in the evidence
@@ -375,4 +375,139 @@ stream as a `terraform.apply` event.
 4. Phase 14 — `l2-microservice` + contract schema extension.
 5. Phase 15 — consumer repo + `terraform apply` (dev) → live ECS service.
 6. Phase 16 — capstone e2e: consumer commit → live HTTP 200 → evidence → timeline.
-7. COMPLETE gate — review → ship `v1.3.0` → audit.
+7. COMPLETE gate — review → ship `v1.3.0` → audit.
+
+## v1.8 Architecture Addendum
+
+> Milestone v1.8 (complete, tag `v1.8.0`). Adds encryption-by-default,
+> deletion-protection-by-default, uptime monitoring, decommission alias,
+> engineering standards, and path documentation.
+
+### New Primitives
+
+- **`kms-key`** (`aws:kms:key`) — Per-stack customer-managed KMS key with
+  `enable_key_rotation = true`. One key per L2 deployment (no shared keys).
+  Wired into both L2 compositions as a child, with its `kms_key_arn` output
+  connected to all children's `kms_key_arn` input. Adapter emits
+  `aws_kms_key` + `enable_key_rotation`.
+- **`uptime`** (`aws:ecs:uptime-service`) — Uptime-kuma on ECS Fargate with
+  a feature flag (`feature_flag_enabled`), monitored endpoints (HTTP/DNS/TCP),
+  alert channels (Teams/email/SMS/GitHub issues). Deployed by default after
+  any L2 module with a separate terraform state. When the feature flag is
+  false, the adapter emits no resources.
+
+### Encryption by Default
+
+All 12 L1 primitives have `encryption_enabled` NFR (default true). Primitives
+with at-rest data (s3, rds, ecr, ecs-service, ecs-cluster) have an optional
+`kms_key_arn` input. The adapter emits encryption blocks (SSE-KMS for S3,
+storage_encrypted for RDS, encryption_configuration for ECR) referencing the
+per-stack CMK when provided. Managed KMS fallback with stderr warning for
+standalone L1 deployments.
+
+### Deletion Protection by Default
+
+All 12 L1 primitives have `deletion_protection` NFR (default true). The
+adapter emits `lifecycle { prevent_destroy = true }` when true. L2 modules
+expose a `features.deletion_protection` flag (default true) propagated to
+all children via the resolver. Setting `inputs.deletion_protection: false`
+in the contract disables it for the whole stack.
+
+### Decommission Alias
+
+A `mode: decommission` on the deploy pipeline implements a 2-step destroy:
+1. Disable deletion protection (resolve with `deletion_protection: false`,
+   terraform plan/apply, HITL SRE gate via GitHub environment).
+2. Zero counts + destroy (`decommission_transform` zeroes all scalable counts,
+   terraform plan/apply, second HITL SRE gate).
+
+CMDB validation via DynamoDB `acdl-change-requests` table. The Lambda
+`validate_change_request` action queries the table and asserts
+`status == "approved"` + `consumerRepo` match.
+
+### Adapter Expansion
+
+TYPE_MAP grew from 16 to 19 entries (+ `aws:kms:key`, `aws:kms:alias`,
+`aws:ecs:uptime-service`). Specialized emission branches added for KMS key
+rotation, S3 SSE-KMS configuration, uptime ECS Fargate task, and
+`prevent_destroy` lifecycle on all resources.
+
+### Pipeline Stages
+
+The deploy pipeline grew from 8 to 9 stages (+ `deploy-uptime` after
+`publish-outputs`). The `deploy-uptime` stage constructs a synthetic uptime
+contract from the L2 stack outputs, resolves + adapts it to a separate
+terraform state directory, and publishes the uptime URL via PR comment.
+
+### Forge-Agnostic API URLs
+
+The platform Lambda (`contract_ingestor.py`) reads `GITHUB_API_BASE` env
+for forge-agnostic API URLs. GitHub uses `/search/issues`; Gitea uses
+`/repos/{owner}/{repo}/issues`. Detection via `/api/v1` in the base URL.
+
+## v1.9 Addendum (2026-07-23)
+
+### New Components
+
+- **`core/contract_resolver.py` interpolation** (D-081): the resolver
+  now expands `${env.<field>}` + `${contract.<field>}` tokens
+  post-schema-validation, pre-IR-resolution. The env context is the
+  loaded environment onboarding JSON (`core/environments/<name>.json`,
+  schema `schemas/environment.schema.json`). The resolver's
+  `child_input_map` routes L2 wires to the sub-resource that declares the
+  input (P1-1 — `desired_count` → `aws:ecs:service`, `family` →
+  `aws:ecs:task_definition`).
+- **`core/environment_check.py` `load()`** (REQ-104): loads + returns the
+  parsed environment JSON; emits a stderr warning for placeholder
+  `account_id` when env != dev.
+- **`core/hitl_gates.py`** (REQ-108, D-084): the HITL pre-execution
+  attestation gate. Records the approver identity to the DynamoDB outbox
+  (`approver_qa`/`approver_prod`/`approver_dr`), runs the separation-of-
+  duties check on prod, invokes the attestation matrix, returns
+  `(ok, reason)`. Dev skips (autonomous). `run_platform.sh` calls
+  `attest` before apply for qa/prod/dr.
+- **`core/attestation_matrix.py`** (REQ-109, D-084): the 8-concern
+  attestation matrix from `hitl_matrix_design.md` §10.4. Offline-testable
+  concerns (contract NFRs, schema validity, policy pass) run for real;
+  operator-supplied concerns accept signed evidence artifacts validated
+  for freshness + schema. Signature verification skips when
+  `ACDL_ATTESTATION_SIGNING_KEY_ID` is unset (D-089).
+- **`core/separation_of_duties.py` `route_halt_artifact`** (REQ-107):
+  real SNS publish (`acdl-sod-halt` topic, ARN from
+  `ACDL_SOD_HALT_TOPIC_ARN`) + outbox fallback
+  (`SEPARATION_OF_DUTIES_VIOLATION` event). The SNS topic is defined in
+  `terraform/platform/main.tf`.
+- **`adapters/wiz/wiz_adapter.py` `WizClient`** (REQ-110): real GraphQL
+  API client (`<WIZ_API_URL>/graphql`, Bearer auth, pagination via
+  `pageInfo.hasNextPage`). `fetch_and_adapt` translates issues →
+  `PolicyCheckResult`. Graceful degrade when unconfigured.
+- **`adapters/kyverno/kyverno_adapter.py`** (REQ-111): fleshed-out
+  `PolicyReport` → `PolicyCheckResult` mapping (pass/fail/skip/warn +
+  severity + skip-with-reason + resource construction). Inactive-for-TF
+  guard preserved.
+
+### Per-Environment Promotion (D-082)
+
+The deploy workflow (`.github/workflows/deploy.yml` +
+`.gitea/workflows/deploy.yml`, byte-identical) declares an `environment`
+`workflow_call` input. When non-empty, `run_platform.sh --environment
+<name>` overrides the contract's `environment` field before schema
+validation (D-088). One CI job per environment; promotion = running the
+matching job, no `environment:` field editing. Per-env contract files
+(`contracts/<module>.<env>.yaml`) use interpolation for env-specific
+values.
+
+### Adapter Parameterization (P1-1, D-085)
+
+The adapter (`adapters/terraform/adapter.py`) reads ECS/ALB/VPC defaults
+from L1 `interface.json` inputs (`desired_count`, `launch_type`,
+`family`, `target_type`, `load_balancer_type`, `name`). The adapter is a
+thin translator; the `child_input_map` routes wires to the declaring
+sub-resource.
+
+### Deferred (D-083)
+
+S3 Object Lock + JWS detached signatures + async worker + DLQ + daily
+checkpoints (audit ledger build-out) — deferred to a future milestone.
+The hash-chain + DynamoDB-outbox path remains the v1.9 production audit
+record.

.ciagent/AUDIT.md

@@ -1,43 +1,63 @@
-# Phase 18 — Audit (v1.3.2)
+# ACDL v1.9 — Audit Report
 
-**Date:** 2026-07-22
-**Phase:** 18 — testing-and-cicd-pipelines
-**Milestone:** v1.3 (active, NFR)
-**Tag:** v1.3.2
+> Audit date: 2026-07-23. Auditor: ci-debugger. Milestone: v1.9. Result: PASS.
 
-## 1. Reconstruction Test
+## Step 1: Reconstruction Test
 
-Git log (2 commits for phase 18) matches `.ciagent/` files:
-
-| Commit | Status | .ciagent match |
-|--------|--------|----------------|
-| 1598c54 | verify | VERIFY.md updated, ROADMAP/REQUIREMENTS marked complete |
-| (specify was done in prior commit ae86a29 for phase 17) | | |
-
-ROADMAP.md has Phase 18 with `Status: complete (v1.3.2)`.
-REQUIREMENTS.md has REQ-39, REQ-40, REQ-41, REQ-42 marked `complete (v1.3.2)`.
-VERIFY.md has `VERIFY PASS` verdict.
-Tag `v1.3.2` exists. **PASS.**
-
-## 2. File Discipline
-
-Working tree clean. All new files present (pyproject.toml,
-requirements-test.txt, 7 test files, 2 workflow YAMLs). Modified files
-(run_platform.sh, README.md, terraform/spike/terraform.tf) are expected.
+- 16 v1.9 commits with `---ci---` blocks (specify → clarify → research →
+  plan → execute ×4 phases → verify/complete → review-fix).
+- Reconstructed state: milestone v1.9, phase 43, status complete.
+- Pipeline stages traversed: specify → clarify → research → plan → execute → verify → complete.
+- Decisions D-080..D-089 all present in git log + `.ciagent/` files.
+- config.json (v1.9 complete), PROJECT.md (v1.9 complete), REQUIREMENTS.md
+  (v1.9 complete, 12 reqs), ROADMAP.md (v1.9 complete, phases 39–43),
+  REVIEW.md (READY TO SHIP), PERSONAS.md (v1.9), VERIFY.md, AUDIT.md.
 **PASS.**
 
-## 3. Branch Hygiene
+## Step 2: File Discipline
 
-On `main`, no stale phase branches. `milestone/v1.0-initial` is
-historical. **PASS.**
+- `.ciagent/config.json`: valid JSON; mode, projects[] present. **PASS.**
+- `.ciagent/PROJECT.md`: Vision/Core Value (≡ "What This Is"), Key
+  Decisions (v1.9 D-080..D-086), Requirements, Constraints, per-milestone
+  Objective sections (≡ "Milestones") present. Section names follow the
+  v1.0 established conventions (not the generic audit template). **PASS.**
+- `.ciagent/ROADMAP.md`: phases 39–43 present; all marked complete.
+  **PASS.**
+- `.ciagent/REQUIREMENTS.md`: v1.9 traceability table complete (12/12
+  REQ-100..111 marked `complete (v1.9.0)`). **PASS.**
+- `.ciagent/ARCHITECTURE.md`: **fixed during audit** — v1.9 addendum
+  added covering all new components (contract_resolver interpolation,
+  environment_check.load, hitl_gates, attestation_matrix,
+  separation_of_duties.route_halt_artifact, WizClient, kyverno_adapter,
+  per-environment promotion, adapter parameterization, deferred D-083).
+  All 9 v1.9 code components now referenced. **PASS (after fix).**
 
-## 4. Commit Discipline
+## Step 3: Branch Hygiene
 
-All phase-18 commits have `---ci---` blocks with correct closing
-`---/ci---` tag. Tag `v1.3.2` follows NFR patch versioning (v1.3.1 →
-v1.3.2). **PASS.**
+- Local: `main` only. Remote: `origin/main` only.
+- No phase or milestone branches remain (all 5 v1.9 phase branches merged
+  + pruned during the run/ship workflow).
+- No orphan branches.
+**PASS.**
 
-## Verdict
+## Step 4: Commit Discipline
 
-**AUDIT CLEAN** — reconstruction, file discipline, branch hygiene, and
-commit discipline all pass. No critical issues.
+- 16/16 v1.9 commits have `---ci---` blocks with project/phase/milestone/
+  status fields.
+- No stale implementation decisions (D-081..D-085, D-087..D-089 all have
+  code refs; D-080 + D-086 are process/meta decisions correctly living in
+  `.ciagent/` files).
+- No unresolved v1.9 escalations (the 3 `audit(...)` commits in history
+  are from prior milestones v1.0/v1.6/v1.7).
+**PASS.**
+
+## Issues fixed during audit
+
+1. **ARCHITECTURE.md missing v1.9 addendum** — the architecture doc had
+   no coverage of the v1.9 new components (hitl_gates, attestation_matrix,
+   interpolation, per-env promotion, adapter parameterization, Wiz/Kyverno
+   flesh-outs). Fixed: added a v1.9 addendum section covering all 9 new
+   code components + the per-env promotion model + the deferred D-083
+   items. Verified all 9 components now referenced.
+
+## Audit result: PASS

.ciagent/PERSONAS.md

@@ -1,10 +1,10 @@
 ---
 project: acdl
-milestone: v1.1
-generated_at: 2026-07-21
+milestone: v1.9
+generated_at: 2026-07-23
 generator: lead-developer
 verification_toolchain:
-  typecheck: "terraform validate && python3 -m py_compile acdl_platform/**/*.py && python3 -m jsonschema schemas/*.schema.json"
+  typecheck: "terraform validate && python3 -m py_compile core/**/*.py && python3 -m jsonschema schemas/*.schema.json"
   test: "scripts/verify_phaseNN.sh"
   build: "terraform init"
   note: |
@@ -16,7 +16,7 @@ verification_toolchain:
     ci-* agents read PERSONAS.md before running verification commands.
 ---
 
-# ACDL — Persona Roster (project-level, v1.1)
+# ACDL — Persona Roster (project-level, v1.9)
 
 ## Active personas
 
@@ -27,34 +27,43 @@ verification_toolchain:
 - **Frameworks:** (none)
 - **Constraints:** pragmatic, battle-tested defaults, no-cross-territory-edits, vision-is-source-of-truth-for-why
 - **Territory:** `.ciagent/**`, `scripts/verify_phase*.sh`, `README.md`, `docs/**` (meta only — not architecture authoring), `.gitignore`
-- **Reason:** Owns CIAgent metadata, cross-phase verification scripts, and the v1.1 phase orchestration. Resolves the 11 open decisions (D-038) and arbitrates persona conflicts.
+- **Reason:** Owns CIAgent metadata, cross-phase verification scripts, and the v1.7 phase orchestration. Resolves the 12-scope-axis decomposition (D-048→D-060) and arbitrates persona conflicts.
 
 ### backend-engineer
 - **Domain:** backend
 - **Active:** true
 - **Phase-specific:** false
-- **Frameworks:** python, json-schema, gitea-actions, act_runner, bash, yaml
+- **Frameworks:** python, json-schema, gitea-actions, act_runner, bash, yaml, github-actions
 - **Constraints:** contract-schema-first, fail-fast-with-reason-codes, no-long-lived-credentials, severity-to-penalty-mapping-immutable
-- **Territory:** `acdl_platform/confidence_signal.py`, `acdl_platform/contract_resolver.py`, `acdl_platform/outbox_writer.py`, `schemas/**` (contract + IR + PolicyCheckResult), `contracts/**` (sample contracts), `.gitea/workflows/**` (pipeline)
-- **Reason:** Owns the contract schema, contract→IR resolution, the confidence signal (6 inputs + severity mapping), the DynamoDB outbox writer, and the central pipeline workflow.
+- **Territory:** `core/confidence_signal.py`, `core/contract_resolver.py`, `core/outbox_writer.py`, `core/output_publisher.py`, `core/environment_check.py`, `schemas/**` (contract + IR + PolicyCheckResult + tagging-standard + pipeline), `contracts/**` (sample contracts), `.gitea/workflows/**` + `.github/workflows/**` (pipeline + deploy + platform-test + primitives-plan + patterns-plan + release), `pipelines/**`, `scripts/run_ci.sh`, `scripts/run_platform.sh`, `scripts/post_stage_comment.sh`, `scripts/run_primitive_plan.sh`, `scripts/run_pattern_plan.sh`
+- **Reason:** Owns the contract schema, contract→IR resolution, the confidence signal (6 inputs + severity mapping), the DynamoDB outbox writer, the output publisher (SSM + GitHub comment), the central pipeline workflows (CI + deploy + platform-test + primitives-plan + patterns-plan + release), and the deploy-pipeline DX (stage comments, error-report step).
 
 ### platform-engineer (custom)
 - **Domain:** infra
 - **Active:** true
 - **Phase-specific:** false
-- **Frameworks:** terraform, aws-iam, aws-s3, aws-dynamodb, oidc, json-schema
-- **Constraints:** ir-is-substrate-agnostic, adapter-is-only-substrate-specific-code, state-in-s3+dynamodb-single-region, oidc-only-no-long-lived-keys (waiver D-034 for bootstrap), terraform-plan-only-in-spike
-- **Territory:** `adapters/terraform/**`, `modules-ir/**`, `terraform/**` (state backend, provider config), `modules-ir/registry.json`
-- **Reason:** Owns the Target Stack IR, the L1/L2 IR-typed modules, the Terraform adapter, the AWS OIDC bootstrap, and the state backend. The IR is substrate-agnostic; the adapter is the only substrate-specific code (the binding constraint per §12).
+- **Frameworks:** terraform, aws-iam, aws-s3, aws-dynamodb, aws-lambda, aws-cloudfront, aws-waf, aws-ssm, aws-secretsmanager, oidc, json-schema
+- **Constraints:** ir-is-engine-agnostic, adapter-is-only-engine-specific-code, state-in-s3+dynamodb-single-region, oidc-only-no-long-lived-keys (waiver D-034 for bootstrap), terraform-plan-only-in-spike, cross-account-iam-scoped-via-abac
+- **Territory:** `adapters/terraform/**`, `modules/**` (l1 + l2 + registry.json + examples), `terraform/**` (state backend, provider config, platform infra), `modules/registry.json`
+- **Reason:** Owns the Target Stack IR, the L1/L2 IR-typed modules (incl. new cloudfront + waf + rds primitives), the Terraform adapter (TYPE_MAP expansion for cloudfront/waf/rds), the AWS OIDC bootstrap, the state backend, and the platform Terraform (Lambda + DynamoDB + KMS + Secrets Manager + Function URL). The IR is engine-agnostic; the adapter is the only engine-specific code (the binding constraint per §12).
 
 ### security-engineer (custom)
 - **Domain:** security
 - **Active:** true
 - **Phase-specific:** false
-- **Frameworks:** aws-iam, oidc, checkov, json-schema
-- **Constraints:** least-privilege, separation-of-duties-identity-distinctness, no-secrets-in-skill-markdown, audit-chain-extends-not-tears-up, critical-finding-hard-overrides-confidence
-- **Territory:** `acdl_platform/hitl_matrix_design.md`, `acdl_platform/audit_ledger_design.md`, `adapters/terraform/policy/**` (Checkov adapter → PolicyCheckResult), `acdl_platform/separation_of_duties.py`
-- **Reason:** Owns the HITL matrix design, separation-of-duties (DynamoDB identity-distinctness), the audit ledger design (S3 Object Lock + JWS + chain), and the Checkov→PolicyCheckResult adapter. Enforces the "Safety is Computed, Not Assumed" + "Audit truth lives outside the repository" vision tenets.
+- **Frameworks:** aws-iam, oidc, checkov, kyverno, wiz, json-schema
+- **Constraints:** least-privilege, separation-of-duties-identity-distinctness, no-secrets-in-skill-markdown, audit-chain-extends-not-tears-up, critical-finding-hard-overrides-confidence, required-tags-enforced
+- **Territory:** `core/hitl_matrix_design.md`, `core/audit_ledger_design.md`, `adapters/terraform/policy/**` (Checkov adapter + custom rules), `adapters/wiz/**` (Wiz adapter), `adapters/kyverno/**` (Kyverno adapter + sample policies), `core/separation_of_duties.py`, `schemas/tagging-standard.json`, `schemas/policy_check_result.schema.json` (engine enum)
+- **Reason:** Owns the HITL matrix design, separation-of-duties, the audit ledger design, the Checkov→PolicyCheckResult adapter + the custom tagging rule (D-054, D-043 closure), the Wiz adapter (D-052), the Kyverno adapter (D-053), and the tagging standard. Enforces the "Safety is Computed, Not Assumed" + "Audit truth lives outside the repository" vision tenets.
+
+### lambda-engineer (custom, v1.9)
+- **Domain:** serverless
+- **Active:** true
+- **Phase-specific:** true (reactivated for v1.9; removed after milestone COMPLETE)
+- **Frameworks:** python, aws-lambda, boto3, dynamodb, aws-secretsmanager, aws-sns, github-api, gitea-api
+- **Constraints:** lambda-is-stateless, dynamodb-is-the-state-store, secrets-from-secrets-manager-never-logged, idempotent-actions, cross-account-iam-via-abac, forge-agnostic-api-urls, sns-topic-arn-from-env
+- **Territory:** `core/lambda/**` (contract_ingestor.py + handler), `terraform/platform/main.tf` (Lambda + Function URL + DynamoDB + KMS + Secrets Manager + IAM + acdl-change-requests table + acdl-sod-halt SNS topic), `terraform/platform/consumer_invoke_policy.json`, `terraform/platform/variables.tf`
+- **Reason:** Reactivated for v1.9 Phase 42 (acdl-sod-halt SNS topic for `route_halt_artifact`, defined in `terraform/platform/main.tf`). The Lambda is stateless; all state is in DynamoDB. Forge-agnostic API URLs (GitHub + Gitea) via GITHUB_API_BASE env var. Removed from the roster after milestone COMPLETE (the code persists, but the persona is no longer active).
 
 ### frontend-engineer
 - **Domain:** frontend
@@ -63,21 +72,21 @@ verification_toolchain:
 - **Frameworks:** vanilla-js, dom-api, fetch-api
 - **Constraints:** no-frameworks, single-file, fetch-from-same-origin-raw-url, relative-url-for-audit-json
 - **Territory:** `evidence-ui/**` (the timeline UI; pushed to `acdl-evidence`)
-- **Reason:** Owns the evidence timeline UI (`index.html`). Carried over from v1.0; the UI continues to render the audit stream. The v1.1 spike writes events to the DynamoDB outbox; the UI continues to read `audit.json` published to `acdl-evidence`.
+- **Reason:** Owns the evidence timeline UI (`index.html`). Carried over from v1.0; the UI continues to render the audit stream. The v1.7 spike writes events to the DynamoDB outbox; the UI continues to read `audit.json` published to `acdl-evidence`.
 
 ## Deactivated personas
 
 ### infra-stub-engineer (custom, v1.0 only)
 - **Domain:** backend
 - **Active:** false
-- **Reason:** Owned L1 stub modules (`modules/l1/**`) in the v1.0 demo. The demo is archived to `demo/` in Phase 06; real L1 modules (`modules-ir/l1/**`) are owned by platform-engineer (substrate-agnostic IR + Terraform adapter). The stub engineer is no longer needed.
+- **Reason:** Owned L1 stub modules (`modules/l1/**`) in the v1.0 demo. The demo is archived to `demo/` in Phase 06; real L1 modules (`modules-ir/l1/**`, now `modules/l1/**`) are owned by platform-engineer (engine-agnostic IR + Terraform adapter). The stub engineer is no longer needed.
 - **Phase-specific:** false (was v1.0)
 - **Territory (would have been):** `demo/modules/l1/**`
 
 ### data-engineer
 - **Domain:** data
 - **Active:** false
-- **Reason:** No ORM/persistence framework. The v1.1 outbox is DynamoDB but accessed via boto3 calls inside `acdl_platform/outbox_writer.py` (owned by backend-engineer); the audit ledger is S3 Object Lock + JWS (owned by security-engineer). No schema-migration layer, no ORM, no data-engineer territory.
+- **Reason:** No ORM/persistence framework. The v1.7 contract-ingestion table is DynamoDB but accessed via boto3 inside `core/lambda/contract_ingestor.py` (owned by lambda-engineer); the outbox is DynamoDB accessed via `core/outbox_writer.py` (owned by backend-engineer); the audit ledger is S3 Object Lock + JWS (owned by security-engineer). No schema-migration layer, no ORM, no data-engineer territory.
 - **Phase-specific:** false
 - **Frameworks:** (would have been: drizzle, prisma)
 - **Constraints:** (would have been: schema-first, type-safe-orm)
@@ -87,32 +96,48 @@ verification_toolchain:
 
 | Phase | Personas active | Notes |
 |-------|------------------|-------|
-| 06 archive-demo-and-reorient | lead-developer, frontend-engineer (demo UI move only) | backend/platform/security idle |
-| 07 architecture-v1-finalization | lead-developer, backend-engineer (schemas), security-engineer (HITL/ledger/SoD), platform-engineer (IR) | frontend idle |
-| 08 aws-oidc-bootstrap | platform-engineer (lead), security-engineer (trust policy review) | backend/frontend idle |
-| 09 v1-spike-ir-and-l1-and-adapter | platform-engineer (lead), backend-engineer (IR schema co-author) | security/frontend idle |
-| 10 v1-spike-l2-and-contract-e2e | platform-engineer (L2 + adapter), backend-engineer (contract→IR + confidence + outbox), security-engineer (Checkov→PolicyCheckResult), frontend-engineer (evidence event surfaces in timeline) | Full roster |
+| 28 adapter-waf-and-resolver-outputs | platform-engineer (lead: WAF HCL fix + adapter output blocks), backend-engineer (resolver outputs processing) | security/lambda/frontend idle |
+| 29 ssm-kms-and-invoke-policy | backend-engineer (lead: SSM fail-loud), lambda-engineer (Terraform-rendered invoke policy), security-engineer (CMK enforcement review) | platform/frontend idle |
+| 30 run-platform-isolation-and-api-portability | backend-engineer (lead: run_platform.sh temp dir + deploy.yml static-key), lambda-engineer (forge-agnostic API URLs) | platform/security/frontend idle |
+| 31 encryption-by-default-and-per-stack-cmk | platform-engineer (lead: kms-key primitive + adapter expansion + L2 wiring), security-engineer (encryption NFR enforcement review) | backend/lambda/frontend idle |
+| 32 deletion-protection-by-default-and-l2-feature-flag | platform-engineer (lead: prevent_destroy emission + L2 feature flag), backend-engineer (contract schema update) | security/lambda/frontend idle |
+| 33 uptime-kuma-primitive | platform-engineer (lead: uptime primitive + adapter + separate state), backend-engineer (deploy-uptime pipeline stage + run_platform.sh + PR comment) | security/lambda/frontend idle |
+| 34 decommission-alias-and-cmdb-validation | backend-engineer (lead: decommission pipeline mode + run_platform.sh + consumer docs), lambda-engineer (validate_change_request + acdl-change-requests table), security-engineer (HITL SRE gates review) | platform/frontend idle |
+| 35 module-engineering-standards | lead-developer (lead: STANDARDS.md + catalog fix + template), platform-engineer (standards content review), backend-engineer (automated standards test) | security/lambda/frontend idle |
+| 36 schemas-adapters-pipelines-readmes | lead-developer (lead: 3 READMEs), backend-engineer (pipelines + schemas README content), platform-engineer (adapters README content) | security/lambda/frontend idle |
+| 37 verify | lead-developer (lead: 4-layer verification), all personas (review their territory) | — |
+| 38 review-audit-complete | lead-developer (lead: review + audit + milestone completion), all personas (review participation) | — |
+| 39 design-doc-refresh-and-p1-1-parameterization | security-engineer (lead: hitl_matrix_design.md + audit_ledger_design.md refresh), platform-engineer (lead: P1-1 adapter defaults → L1 interface.json inputs), backend-engineer (contract_resolver.py + env schema adjacent review) | lambda/frontend idle |
+| 40 contract-interpolation | backend-engineer (lead: _expand_vars in contract_resolver.py + environment.schema.json + sample contracts), platform-engineer (interface.json adjacent review) | security/lambda/frontend idle |
+| 41 per-environment-ci-jobs | backend-engineer (lead: deploy.yml environment input + run_platform.sh --environment + per-env contracts + caller-workflow docs), security-engineer (HITL gate structure review) | platform/lambda/frontend idle |
+| 42 stub-implementation | security-engineer (lead: route_halt_artifact SNS + hitl_gates.py + attestation_matrix.py + Wiz real client + Kyverno fleshed out), backend-engineer (run_platform.sh HITL gate wiring), lambda-engineer (acdl-sod-halt SNS topic in terraform/platform/main.tf) | platform/frontend idle |
+| 43 verify-review-audit-complete | lead-developer (lead: 4-layer verify + review + audit + milestone completion), all personas (review participation) | — |
 
 ## Domain priority (used by TaskDecomposer)
 
-`coordination → security → platform → backend → frontend`
+`coordination → security → platform → backend → lambda → frontend`
 
-Rationale: in v1.1, the security/architecture commitments (IR, confidence,
-HITL, ledger, SoD) are the binding constraints; the platform layer
-materializes them; backend wires the pipeline; frontend surfaces the
-evidence. The spike's correctness depends on the security + platform layers
-being right before backend wiring.
+Rationale: in v1.9, the security commitments (HITL gates, attestation
+matrix, SoD halt artifact, Wiz/Kyverno adapters) and the design-doc
+accuracy are the binding constraints; platform owns the P1-1 adapter
+parameterization + L1 interface inputs; backend owns the contract
+interpolation + per-env CI jobs + the deploy workflow env input;
+lambda owns the SNS topic Terraform; frontend is unchanged from v1.0
+(evidence timeline).
 
 ## Conflict resolutions (lead-developer arbitration)
 
-- `backend-engineer` vs `platform-engineer` over `schemas/ir.schema.json`: platform-engineer owns the IR (it is substrate-agnostic but infra-shaped); backend-engineer owns the contract schema and the contract→IR resolution (contract is the consumer surface). Co-authoring is expected; conflict goes to lead-developer.
-- `backend-engineer` vs `security-engineer` over `acdl_platform/confidence_signal.py`: security-engineer owns the severity→penalty mapping + critical-override semantics; backend-engineer owns the 6-input weighted sum + per-env thresholds. The confidence signal is co-owned; conflicts go to lead-developer.
-- `platform-engineer` vs `security-engineer` over `adapters/terraform/policy/**`: security-engineer owns the Checkov→PolicyCheckResult adapter (policy is a security concern); platform-engineer owns the Terraform adapter (substrate translation). No overlap.
+- `backend-engineer` vs `platform-engineer` over `schemas/ir.schema.json` + `schemas/stack.schema.json`: platform-engineer owns the IR (engine-agnostic but infra-shaped); backend-engineer owns the contract schema and the contract→IR resolution. Co-authoring is expected; conflict goes to lead-developer.
+- `backend-engineer` vs `security-engineer` over `core/confidence_signal.py`: security-engineer owns the severity→penalty mapping + critical-override semantics; backend-engineer owns the 6-input weighted sum + per-env thresholds. Co-owned; conflicts go to lead-developer.
+- `platform-engineer` vs `security-engineer` over `adapters/terraform/policy/**`: security-engineer owns the Checkov→PolicyCheckResult adapter + custom rules + the Wiz/Kyverno adapters (policy is a security concern); platform-engineer owns the Terraform adapter (engine translation). No overlap.
+- `lambda-engineer` vs `platform-engineer` over `terraform/platform/main.tf`: lambda-engineer owns the Lambda + DynamoDB + Secrets Manager definitions; platform-engineer reviews the Terraform structure + state backend. Co-authoring expected; conflicts go to lead-developer.
+- `backend-engineer` vs `lambda-engineer` over `core/lambda/contract_ingestor.py` vs `scripts/run_platform.sh` + `.github/workflows/deploy.yml` error-report step: lambda-engineer owns the Lambda handler; backend-engineer owns the workflow step that invokes it. The interface (the JSON payload) is co-authored; conflicts go to lead-developer.
 - `lead-developer` vs any: lead-developer owns `.ciagent/**` + `docs/**` meta + verification scripts; persona engineers do not edit CIAgent metadata or the vision/architecture source docs.
 
 ## Territory enforcement mode
 
 `warn` — config.json has no `personas.territory_enforcement` field, so the
 default per execute.md is `warn`. Cross-territory edits are logged in the
-commit message but do not fail the task. The spike's small scope means
-co-authoring across territories is likely; `warn` keeps it frictionless.
+commit message but do not fail the task. v1.7's broad scope means
+co-authoring across territories is likely (e.g. lambda + platform on
+`terraform/platform/main.tf`); `warn` keeps it frictionless.

.ciagent/PLAN.md

@@ -1,41 +1,228 @@
 ---
-phase: 16
-name: v1.2-capstone-e2e
-milestone: v1.2
-requirements: [REQ-35]
-type: feat/verify
-branch: phase/16-v1.2-capstone-e2e
+phase: 39-43
+name: v1.9-design-doc-interpolation-per-env-ci-stubs-p1-1
+milestone: v1.9
+requirements: [REQ-100, REQ-101, REQ-102, REQ-103, REQ-104, REQ-105, REQ-106, REQ-107, REQ-108, REQ-109, REQ-110, REQ-111]
+type: feat/docs/fix
 ---
 
-# Phase 16 — v1.2-capstone-e2e (v1.2) PLAN
+# ACDL v1.9 — Phase Plans
 
-## Goal
+> Milestone v1.9. Generated at PLAN stage. Autonomy: full.
+> Requirements: REQ-100..REQ-111 (see REQUIREMENTS.md).
+> Decisions: D-080..D-089 (see PROJECT.md + RESEARCH.md RA section).
+> Versioning: feature milestone — progressive patch versions per phase
+> (v1.8.1..v1.8.5), tag `v1.9.0` at milestone COMPLETE.
 
-End-to-end verification of the v1.2 platform: consumer commit → pipeline →
-`terraform apply` (dev) → live ECS service → evidence event → timeline. The
-`terraform apply` is blocked by the IAM P0 (Phase 15); Phase 16 ships the
-capstone verification of everything *up to* the apply + documents the
-operator's unblock step. After the operator pushes the policy, the apply +
-HTTP 200 check complete REQ-33/35.
+## Wave ordering
 
-## Tasks
+- **Wave 1 (parallel, 2 tasks):** Phase 39 — design-doc refresh (security-engineer) + P1-1 adapter parameterization (platform-engineer). Disjoint file sets; no merge conflict.
+- **Wave 2 (sequential):** Phase 40 — contract interpolation. Depends on Phase 39's design-doc context (lightweight).
+- **Wave 3 (sequential):** Phase 41 — per-env CI jobs. Depends on Phase 40's interpolation + env schema.
+- **Wave 4 (sequential):** Phase 42 — stub implementation. Depends on Phase 41's HITL job structure.
+- **Wave 5 (sequential):** Phase 43 — verify + review + audit + complete.
 
-### T-16.1 — Capstone verify script
-`scripts/verify_phase16.sh` runs the full v1.2 platform flow (consumer
-content → contract → IR → adapter → terraform validate + plan) + verifies
-the v1.1 regression + the NFR improvements (run_platform.sh, IAM policy
-expansion, P1-1 redaction) + the documentation (README accuracy). The
-`terraform apply` + HTTP 200 check are documented as the operator's
-post-unblock step.
+---
 
-### T-16.2 — Capstone evidence event
-Write a `MILESTONE_CAPSTONE_VERIFIED` evidence event to the outbox (the
-v1.2 platform is verified up to the IAM-blocked apply).
+## Phase 39 — design-doc-refresh-and-p1-1-parameterization
 
-### T-16.3 — Phase 16 README update
-Update README to reflect the v1.2 status (Phase 15 partial, Phase 16
-capstone, the IAM unblock step).
+**Requirements:** REQ-100, REQ-101, REQ-102
+**Personas:** security-engineer (lead: design docs), platform-engineer (lead: P1-1), backend-engineer (review)
+**Branch:** `phase/39-design-doc-refresh-and-p1-1`
 
-## Ship
+### Task 39.1 — Refresh hitl_matrix_design.md (REQ-100, security-engineer)
+- Rewrite the status block: "v1.2 wires the gates" → "v1.9 wires the gates (Phase 42)".
+- Update "Spike scope note" → "v1.9 scope note": qa/prod/dr now exercised (Phase 41 wires the job structure; Phase 42 wires the attestation gates); dev remains autonomous.
+- Update §10.4 matrix: mark the offline-testable concerns (contract NFRs, schema validity, policy pass) as **implemented in v1.9** (`core/attestation_matrix.py`); mark operator-supplied concerns as **accept signed evidence artifacts** (D-084).
+- Add a "v1.9 wiring" section: cross-reference Phase 41's per-env jobs + Phase 42's `hitl_gates.py` + `attestation_matrix.py` + the outbox-based SoD check.
+- Preserve D-042 (approver identity = `gitea.actor` / `github.actor`) — still accurate.
+- Verify: `grep -i "dev-only spike" core/hitl_matrix_design.md` returns 0 hits; `grep -i "v1.2 wires" core/hitl_matrix_design.md` returns 0 hits.
 
-Merge → `main` (--no-ff). Tag `v1.2.6`.
+### Task 39.2 — Refresh audit_ledger_design.md (REQ-101, security-engineer)
+- Mark the "Spike scope (D-041)" section as **shipped + production since v1.8** (hash chain + DynamoDB outbox + `acdl-evidence` mirror).
+- Move the "v1.2 build-out" section (S3 Object Lock + JWS + async worker + DLQ + daily checkpoints) under a clearly-labeled "**Deferred to a future milestone (D-083)**" heading. Keep the content (it's the design for when it ships) but mark it not-v1.9.
+- Update the RPO/RTO table: spike row → "v1.8+ (production): RPO=0 (sync outbox), RTO=workflow re-run"; v1.2 row → "Future milestone (D-083): RPO=0, RTO=DLQ replay".
+- Update the outbox item shape: note `approver_qa`/`approver_prod`/`approver_dr` are populated by v1.9's `hitl_gates.attest` (Phase 42).
+- Verify: `grep -i "Phases 08-10 implement" core/audit_ledger_design.md` returns 0 hits; the deferred section is clearly labeled.
+
+### Task 39.3 — P1-1 adapter parameterization (REQ-102, platform-engineer)
+- `modules/l1/ecs-service/interface.json`: add inputs `desired_count` (integer, default 1), `launch_type` (string, default "FARGATE"), `family` (string, default "app").
+- `modules/l1/alb/interface.json`: add inputs `load_balancer_type` (string, default "application"), `target_type` (string, default "ip").
+- `modules/l1/vpc/interface.json`: add input `name` (string, default "app") for the VPC/IGW/RT `Name` tag prefix.
+- `adapters/terraform/adapter.py`: change hardcoded defaults to `inputs.get("<name>", "<default>")` where the default matches the interface default (safety fallback; the resolver populates from the interface). Remove the hardcoded `Name = "acdl-microservice-rt"` (line 283) → use `inputs.get("name", "app")`-derived tag.
+- Preserve the v1.1 S3 regression (S3 has none of these inputs → no change).
+- Tests: `tests/test_p1_1_adapter_parameterization.py` — (a) `desired_count: 3` in contract inputs emits `desired_count = 3`; (b) absent `desired_count` emits `desired_count = 1` via interface default; (c) `target_type: "instance"` emits `target_type = "instance"`; (d) v1.1 S3 regression still passes (byte-identical `main.tf`).
+- Verify: `pytest tests/test_p1_1_adapter_parameterization.py` passes; `run_platform.sh --check-only` exits 0; `pytest` total count increases; v1.1 S3 regression test passes.
+
+### Task 39.4 — Design doc test (REQ-100/101, backend-engineer)
+- `tests/test_design_docs_current.py`: assert (a) no stale "dev-only spike" / "v1.2 wires the gates" / "Phases 08-10 implement" framing in either design doc; (b) `audit_ledger_design.md` has a "Deferred to a future milestone" section referencing D-083; (c) `hitl_matrix_design.md` references the v1.9 implementation (`attestation_matrix.py`, `hitl_gates.py`).
+- Verify: `pytest tests/test_design_docs_current.py` passes.
+
+### Must-haves (Phase 39)
+- [ ] `core/hitl_matrix_design.md` refreshed (no stale framing).
+- [ ] `core/audit_ledger_design.md` refreshed (S3 Object Lock marked deferred D-083).
+- [ ] Adapter has no hardcoded ECS/ALB/VPC defaults (read from inputs).
+- [ ] `tests/test_p1_1_adapter_parameterization.py` + `tests/test_design_docs_current.py` pass.
+- [ ] `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0; v1.1 S3 regression passes.
+
+---
+
+## Phase 40 — contract-interpolation
+
+**Requirements:** REQ-103, REQ-104
+**Personas:** backend-engineer (lead), platform-engineer (review)
+**Branch:** `phase/40-contract-interpolation`
+
+### Task 40.1 — Environment JSON schema (REQ-104, backend-engineer)
+- `schemas/environment.schema.json` (draft 2020-12): required `name` (string), `account_id` (string), `region` (string), `state_backend` (object: `bucket`, `lock_table`), `network` (object: `vpc_cidr`, `azs` array), `runner_role_arn` (string), `autonomy` (enum: full/attested), `confidence_threshold` (number).
+- `core/environments/dev.json` validates against it.
+- Add `core/environments/qa.json`, `prod.json`, `dr.json`: `account_id: "000000000000"`, `autonomy: "attested"`, `confidence_threshold` 0.75/0.90/0.95, regions us-east-1, state_backend buckets `acdl-qa-state`/`acdl-prod-state`/`acdl-dr-state`.
+- `core/environment_check.py`: add `load(env_name, root=None)` returning the parsed env dict; `check()` stays. Add a stderr warning when `account_id == "000000000000"` and `env_name != "dev"` (prompts real binding).
+- `tests/test_environment_schema.py`: all 4 env files validate; `load("dev")` returns the dict; warning emitted for qa/prod/dr placeholders.
+- Verify: `pytest tests/test_environment_schema.py` passes.
+
+### Task 40.2 — Interpolation expansion in the resolver (REQ-103, backend-engineer)
+- `core/contract_resolver.py`: add `_expand_vars(value, context)` — recursively walks dicts/lists/strings; replaces `${env.<dotted.path>}` and `${contract.<dotted.path>}` tokens by looking up the dotted path in the context dict. Unknown token → `ValueError(f"unresolved interpolation token: {token}")`.
+- `resolve()`: after schema validation, load the env via `environment_check.load(contract["environment"])`, build `context = {"env": env, "contract": contract}`, expand all string values in `contract["inputs"]` (recursively, per D-087), then proceed to IR resolution.
+- The expansion is post-schema-validation (schema sees the raw tokens, which are valid strings) and pre-IR-resolution (the resolver sees concrete values).
+- `tests/test_interpolation.py`: (a) `${env.region}` expands to `us-east-1`; (b) `${env.state_backend.bucket}` expands to `acdl-dev-state`; (c) `${contract.module}` expands to `static-assets`; (d) unknown token raises `ValueError`; (e) nested map value `env: { DB_URL: "acdl-${env.environment}-db" }` expands recursively; (f) `resolve("contracts/static-assets.yaml")` succeeds with expanded values.
+- Verify: `pytest tests/test_interpolation.py` passes.
+
+### Task 40.3 — Sample contracts use naming patterns (REQ-103, backend-engineer)
+- `contracts/static-assets.yaml`: `bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}` (the naming pattern the requirement calls out: region + account id + environment).
+- `contracts/microservice.yaml`: same pattern for `bucket_name`.
+- Keep `region: us-east-1` as a literal (or `${env.region}` — both valid; use `${env.region}` to demonstrate).
+- `tests/test_sample_contracts_interpolate.py`: resolving the sample contracts produces concrete bucket names like `acdl-dev-static-assets-000000000000-us-east-1`.
+- Verify: `pytest tests/test_sample_contracts_interpolate.py` passes; `run_platform.sh --check-only` exits 0 (resolver expands before adapter).
+
+### Must-haves (Phase 40)
+- [ ] `schemas/environment.schema.json` exists; 4 env files validate.
+- [ ] `_expand_vars` in resolver; unknown tokens raise.
+- [ ] Sample contracts use `${env.*}` + `${contract.*}` naming patterns.
+- [ ] `tests/test_environment_schema.py` + `tests/test_interpolation.py` + `tests/test_sample_contracts_interpolate.py` pass.
+- [ ] `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+
+---
+
+## Phase 41 — per-environment-ci-jobs
+
+**Requirements:** REQ-105, REQ-106
+**Personas:** backend-engineer (lead), security-engineer (HITL gate review)
+**Branch:** `phase/41-per-environment-ci-jobs`
+
+### Task 41.1 — Per-env contract files (REQ-105, backend-engineer)
+- `contracts/static-assets.dev.yaml`, `.qa.yaml`, `.prod.yaml`, `.dr.yaml` — each sets `environment:` to its own name; `inputs.bucket_name` uses `${env.environment}-${contract.module}-${env.account_id}-${env.region}` interpolation (so the file content is near-identical; only `environment:` differs).
+- `contracts/microservice.{dev,qa,prod,dr}.yaml` — same pattern.
+- Keep `contracts/static-assets.yaml` + `contracts/microservice.yaml` as the dev default (backwards compat).
+- `tests/test_per_env_contracts.py`: all 8 per-env files validate against `schemas/contract.schema.json`; each resolves to a stack with the correct environment.
+- Verify: `pytest tests/test_per_env_contracts.py` passes.
+
+### Task 41.2 — Deploy workflow `environment` input (REQ-106, backend-engineer)
+- `.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml` (byte-identical): add `environment` input (`type: string`, default `""`, description "Target environment override (dev/qa/prod/dr); when empty, the contract's environment field is used").
+- `scripts/run_platform.sh`: add `--environment <name>` flag. When set, override the contract's `environment` field at load time (before schema validation per D-088, so interpolation context is consistent). Re-run the onboarding check against the supplied env.
+- The workflow's "Run the platform pipeline" step passes `--environment ${{ inputs.environment }}` when non-empty.
+- `tests/test_deploy_workflow_env_input.py`: both deploy workflows declare the `environment` input; byte-identical; `run_platform.sh --environment qa contracts/static-assets.yaml` produces a stack whose env is qa (tested via the resolver directly since run_platform.sh needs AWS for full mode — test the override logic in the resolver).
+- `core/contract_resolver.py` `resolve()`: accept optional `environment_override` arg; when set, set `contract["environment"] = override` before schema validation + interpolation.
+- Verify: `pytest tests/test_deploy_workflow_env_input.py` passes; both deploy workflows byte-identical.
+
+### Task 41.3 — Per-env caller workflow docs + HITL gate structure (REQ-106, security-engineer review)
+- `docs/CONSUMER_GUIDE.md`: add a "Per-environment deployment" section with 4 caller-workflow examples (`.github/workflows/deploy-dev.yml`, `deploy-qa.yml`, `deploy-prod.yml`, `deploy-dr.yml`), each `uses: acdl/.github/workflows/deploy.yml@v1.9` with `environment: <env>` + `contract: .acdl/<module>.<env>.yaml`. Document: "Promotion = running the matching job; no `environment:` field editing."
+- HITL gate structure (wired in Phase 42, documented here): qa/prod/dr caller workflows use `workflow_dispatch` with approval inputs (`approve_qa`, `approve_prod`, `approve_dr`) per `hitl_matrix_design.md` D-042; `gitea.actor` / `github.actor` is the approver of record. dev is autonomous (no gate).
+- `tests/test_consumer_guide_per_env_section.py`: the consumer guide has the per-env section with 4 caller examples.
+- Verify: `pytest tests/test_consumer_guide_per_env_section.py` passes.
+
+### Must-haves (Phase 41)
+- [ ] 8 per-env contract files exist + validate + resolve.
+- [ ] Deploy workflow has `environment` input (byte-identical Gitea + GitHub).
+- [ ] `run_platform.sh --environment <name>` overrides; resolver supports `environment_override`.
+- [ ] Consumer guide documents per-env caller workflows + promotion-without-editing.
+- [ ] `tests/test_per_env_contracts.py` + `tests/test_deploy_workflow_env_input.py` + `tests/test_consumer_guide_per_env_section.py` pass.
+- [ ] `run_ci.sh` exits 0; both deploy workflows byte-identical.
+
+---
+
+## Phase 42 — stub-implementation
+
+**Requirements:** REQ-107, REQ-108, REQ-109, REQ-110, REQ-111
+**Personas:** security-engineer (lead), backend-engineer (run_platform wiring), lambda-engineer (SNS topic Terraform)
+**Branch:** `phase/42-stub-implementation`
+
+### Task 42.1 — route_halt_artifact real (REQ-107, security-engineer + lambda-engineer)
+- `core/separation_of_duties.py` `route_halt_artifact`: when `ACDL_SOD_HALT_TOPIC_ARN` set, publish to SNS via boto3 (`sns.publish(TopicArn=arn, Message=..., Subject="ACDL SoD halt")`); when unset, fall back to structured stderr emission + a `SEPARATION_OF_DUTIES_VIOLATION` event write via `outbox_writer.write_event` (so the halt is in the audit chain). No silent print-only stub.
+- `terraform/platform/main.tf`: add `aws_sns_topic.acdl-sod-halt` + a basic access policy (allow the platform Lambda / runner role to publish). Output the topic ARN.
+- `tests/test_route_halt_artifact.py`: (a) with `ACDL_SOD_HALT_TOPIC_ARN` set, moto-mocked SNS receives the publish; (b) without it, a `SEPARATION_OF_DUTIES_VIOLATION` event is written to the outbox (moto-mocked DynamoDB); (c) stderr emission occurs in both cases.
+- Verify: `pytest tests/test_route_halt_artifact.py` passes.
+
+### Task 42.2 — HITL attestation gates (REQ-108, security-engineer + backend-engineer)
+- `core/hitl_gates.py`: `attest(contract_id, env, approver, evidence, outbox_client=None)` → records `approver_qa`/`approver_prod`/`approver_dr` to the outbox item for `contract_id`; runs `separation_of_duties.check(outbox_client, contract_id, approver)` on prod; invokes the attestation matrix (Task 42.3) for the target env; returns `(ok, reason)`. Dev skips (returns `(True, "dev autonomous")`).
+- `scripts/run_platform.sh`: before apply (for qa/prod/dr), call `hitl_gates.attest` with the approver from `GITHUB_ACTOR`/`GITEA_ACTOR` env. Block on `(ok=False)`.
+- `tests/test_hitl_gates.py`: (a) dev skips; (b) qa records `approver_qa` (moto outbox); (c) prod records `approver_prod` + SoD blocks when `approver_qa == approver_prod`; (d) prod passes when approvers differ.
+- Verify: `pytest tests/test_hitl_gates.py` passes.
+
+### Task 42.3 — 8-concern attestation matrix (REQ-109, security-engineer)
+- `core/attestation_matrix.py`: `check(env, evidence_bundle)` → runs the 8 concerns. Offline-testable concerns (contract NFRs, schema validity, policy pass) run for real. Operator-supplied concerns accept an uploaded signed evidence artifact (JSON with `timestamp`, `type`, `payload`, optional `signature`); validate freshness (within the declared window from `hitl_matrix_design.md` §10.4) + schema (per-concern). Signature verification via KMS when `ACDL_ATTESTATION_SIGNING_KEY_ID` set; skipped + logged when unset (D-089). Fail loud if missing/expired for prod/dr.
+- `hitl_gates.attest` calls `attestation_matrix.check(env, evidence)` and blocks on any failing concern.
+- `tests/test_attestation_matrix.py`: (a) offline concerns pass for a valid contract; (b) operator-supplied concern missing → block for prod; (c) operator-supplied concern present + fresh → pass; (d) expired artifact → block; (e) signature skip when key unset (logged).
+- Verify: `pytest tests/test_attestation_matrix.py` passes.
+
+### Task 42.4 — Wiz real API client (REQ-110, security-engineer)
+- `adapters/wiz/wiz_adapter.py`: add `WizClient` class — `__init__` reads `WIZ_API_TOKEN` + `WIZ_API_URL`; `fetch_issues(filter_by)` queries the Wiz GraphQL API (`<url>/graphql`, Bearer auth, `issues` query). Translate results → `PolicyCheckResult` records (`engine: "wiz"`, `ruleId: <control.name>`, `severity: <lowercased>`, `status: FAIL`, `message: <title>`, `resource: <entity.name>`). Graceful degrade: when `WIZ_API_TOKEN` or `WIZ_API_URL` unset → emit the existing single `SKIPPED` `WIZ_NOT_CONFIGURED` record (no network call). Pagination handled via `pageInfo.hasNextPage`.
+- `tests/test_wiz_adapter_real_client.py`: (a) with a recorded GraphQL fixture, `WizClient` translates issues → `PolicyCheckResult` records; (b) graceful degrade when env unset; (c) pagination follows `endCursor`.
+- Verify: `pytest tests/test_wiz_adapter_real_client.py` passes.
+
+### Task 42.5 — Kyverno translator fleshed out (REQ-111, security-engineer)
+- `adapters/kyverno/kyverno_adapter.py`: full `PolicyReport` → `PolicyCheckResult` mapping — handle `pass`/`fail`/`skip`/`warn` results, severity mapping (critical/high/medium/low/info), resource extraction, skip-with-reason handling. Keep the inactive-for-Terraform guard (emits a single `SKIPPED` `KYVERNO_INACTIVE_TF_STACK` record when no K8s manifests). Add a `--kube-version` stub (parsed but not yet used — for future GitOps).
+- `tests/test_kyverno_adapter.py`: expand — (a) `pass` result → `PolicyCheckResult` with `status: PASS`; (b) `fail` with severity → correct severity mapping; (c) `skip` with reason → `SKIPPED` record; (d) inactive-for-TF guard emits the `KYVERNO_INACTIVE_TF_STACK` record.
+- Verify: `pytest tests/test_kyverno_adapter.py` passes.
+
+### Must-haves (Phase 42)
+- [ ] `route_halt_artifact` real (SNS + outbox fallback); SNS topic in Terraform.
+- [ ] `hitl_gates.py` attests qa/prod/dr; SoD blocks on identity equality.
+- [ ] `attestation_matrix.py` implements 8 concerns (offline-testable + signed artifacts).
+- [ ] Wiz adapter real client + graceful degrade.
+- [ ] Kyverno translator fleshed out + inactive guard preserved.
+- [ ] All 5 new test files pass; `run_ci.sh` exits 0.
+
+---
+
+## Phase 43 — verify-review-audit-complete
+
+**Requirements:** — (milestone gate)
+**Personas:** lead-developer (lead), all personas (review participation)
+**Branch:** `phase/43-verify-review-audit-complete`
+
+### Task 43.1 — 4-layer verify
+- Structural: all new files present (environment.schema.json, 4 env files, 8 per-env contracts, hitl_gates.py, attestation_matrix.py, SNS topic in main.tf, 5+ new test files).
+- Behavioral: `pytest` passes (count increases from v1.8's 350 by ~30+ new tests); `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+- Security: no hardcoded adapter defaults; HITL gates block on SoD violation; attestation matrix fails loud on missing evidence for prod/dr; Wiz degrades gracefully.
+- Quality: each new feature has dedicated tests (interpolation, per-env jobs, SoD, HITL gates, attestation matrix, Wiz, Kyverno).
+
+### Task 43.2 — Multi-persona review
+- `ciagent-review` across the v1.9 diff (phases 39–42). Auto-apply P0; flag P1+ for post-hoc.
+- Reconstruct `.ciagent/REVIEW.md` with v1.9 content (D-086). Note that v1.3–v1.8 reviews were not persisted (no git-history rewrite).
+
+### Task 43.3 — Audit
+- Reconstruction: git log matches `.ciagent/` files.
+- File discipline: all `.ciagent/` files valid.
+- Branch hygiene: stale branches cleaned.
+- Commit discipline: all commits have `---ci---` blocks.
+
+### Task 43.4 — Complete
+- Update `.ciagent/REQUIREMENTS.md`: mark REQ-100..REQ-111 complete; add v1.9 traceability table.
+- Update `.ciagent/ROADMAP.md`: add v1.9 milestone section (complete).
+- Update `.ciagent/PROJECT.md`: v1.9 status → complete.
+- Tag `v1.9.0`; update floating `v1.9` + `v1` tags.
+- Bump `uses:`/`ref:` from `@v1.6` → `@v1.9` in `contracts/*.yaml`, `deploy.yml` checkout `ref:`, `docs/CONSUMER_GUIDE.md` (D-071 successor).
+- Commit: `docs(milestone): complete v1.9`.
+
+### Must-haves (Phase 43)
+- [ ] 4-layer verify PASS.
+- [ ] Review: 0 new P0; P1+ flagged for post-hoc.
+- [ ] Audit: clean.
+- [ ] Tag `v1.9.0` created; floating tags updated.
+- [ ] `uses:`/`ref:` bumped to `@v1.9`.
+- [ ] REQUIREMENTS.md + ROADMAP.md + PROJECT.md updated.
+
+---
+
+*End of PLAN.md.*

.ciagent/PROJECT.md

@@ -56,8 +56,8 @@ Finalize the architecture to v1.0 (resolve all 11 open design decisions in
 `docs/architecture.md` §13) and prove the locked commitments with one
 end-to-end v1 implementation spike:
 
-- **One L1 module** (`l1-s3`) — substrate-agnostic, IR-typed interface.
-- **One L2 thin-composition** (`l2-static-asset`) — references the L1.
+- **One L1 module** (`l1-s3`) — engine-agnostic, IR-typed interface.
+- **One L2 thin-composition** (`l2-static-assets`) — references the L1.
 - **Terraform adapter** — compiles the IR to a real `terraform plan`
   against AWS via OIDC (no long-lived credentials, per §12.5).
 - **One contract submission** → contract→IR resolution →
@@ -79,7 +79,7 @@ id 202 published. D-034 closed (root key deactivated by user).**
 | 07 | architecture-v1-finalization | Resolve the 11 open decisions → architecture v1.0. Author IR JSON Schema, PolicyCheckResult schema, contract schema, confidence-signal spec, HITL matrix, outbox/ledger design under `schemas/` + `platform/`. |
 | 08 | aws-oidc-bootstrap | One-shot use of a temporary long-lived key (waiver D-034) to create an IAM role + OIDC trust policy for the act_runner, an S3 state bucket, and a DynamoDB lock table. Rotate the key. Verify the runner assumes the role via OIDC with no long-lived secret. |
 | 09 | v1-spike-ir-and-l1-and-adapter | Target Stack IR; one real L1 (`l1-s3`) with IR-typed interface; L1 registry; Terraform adapter (IR → Terraform var/output + `terraform plan`) running against AWS via OIDC. |
-| 10 | v1-spike-l2-and-contract-e2e | One L2 thin-composition (`l2-static-asset`) referencing `l1-s3`; contract schema + contract→IR resolution; one end-to-end contract submission → `terraform plan` → Checkov → confidence signal → evidence event to outbox. Verify the IR commitments hold. |
+| 10 | v1-spike-l2-and-contract-e2e | One L2 thin-composition (`l2-static-assets`) referencing `l1-s3`; contract schema + contract→IR resolution; one end-to-end contract submission → `terraform plan` → Checkov → confidence signal → evidence event to outbox. Verify the IR commitments hold. |
 
 Milestone COMPLETE gate: review → ship `v1.2.0` (feature milestone, next
 minor per ship.md) → audit. **DONE.**
@@ -167,6 +167,342 @@ Three scope axes:
 Milestone COMPLETE gate: review → ship `v1.4.1` (feature milestone, next
 minor per ship.md — v1.3 shipped `v1.3.2`) → audit.
 
+## Objective for Milestone v1.7 (complete)
+
+Production platform + contract ingestion + pipeline maturation. The v1.6
+milestone left the platform documented and environments-aware; v1.7 took it
+to a production-grade platform. 12 user-directed scope axes (2026-07-22):
+
+1. **Rename `static-assets` → `static-assets`** (D-048 — including
+   `.ciagent/` historical narrative, overriding the v1.6 preservation
+   precedent). The reconstruction test is updated to expect `static-assets`.
+2. **Augment `static-assets` to a production-ready stack** by authoring a
+   new `cloudfront` primitive + a `waf` primitive (D-049: S3 + CloudFront
+   OAC + WAF; Route53/ACM are domain-dependent and deferred to documented
+   extension points).
+3. **DX-friendly deploy outputs** (D-050): SSM Parameter Store (KMS-encrypted
+   `SecureString`) for runtime-injectable values + GitHub PR comment / job
+   summary for human-readable connection strings. No raw secrets in logs.
+4. **Central deploy pipeline error reporting** via the platform Lambda
+   `report_error` action (D-055): the Lambda creates a GitHub issue on the
+   platform repo. The consumer's onboarding-granted Lambda-invoke permission
+   is the only grant needed — uniform pathway, no separate GitHub
+   `issues: write` on the consumer side. Gitea is excluded (only the CIAgent
+   uses it).
+5. **PR comments after every successful stage** so developers always know
+   where they stand.
+6. **Three platform pipelines**: (1) platform-test (PR, unit + integration +
+   schema-validation); (2) primitives-plan (PR, plan-only for all L1
+   primitives); (3) patterns-plan (PR, plan-only for all L2 modules).
+7. **Release job** on merge to `main`: computes MAJOR.MINOR.PATCH semver,
+   creates the tag, then updates (force-moves) or creates the MAJOR.MINOR +
+   MAJOR floating tags (D-057). Consumers on `@v1` or `@v1.6` receive updates
+   depending on their pinned version.
+8. **Platform Lambda** for one-way consumer→platform communication
+   (contracts). Onboarding grants the consumer repo's environment the right
+   to trigger the Lambda (cross-account IAM). The Lambda ingests contracts
+   and stores them in a DynamoDB table `acdl-contracts` (D-051) for
+   historical reference, impact analysis, CMDB-style application-state
+   queries, and pattern detection. The IAM policy reflects cross-account
+   invocation.
+9. **Tagging standards** in policy/compliance checks (D-054): a required-tag
+   set (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`)
+   enforced by a Checkov custom YAML rule. Closes the D-043 deferral (the
+   SKIPPED `ACDL_TAG_NAMING` placeholder becomes a real check).
+10. **Wiz adapter** for security checks (D-052): a stub + schema path that
+    translates Wiz API issues → `PolicyCheckResult` records, degrading
+    gracefully when unconfigured. Matches the Checkov adapter pattern.
+11. **Kyverno adapter** for compliance/security checks (D-053): a
+    K8s-native policy adapter that translates Kyverno `PolicyReport` results
+    → `PolicyCheckResult` records. Ready but inactive for Terraform-only
+    stacks (the platform emits Terraform, not K8s manifests); it activates
+    when the GitOps reconciler (roadmap) emits K8s manifests.
+12. **Remove the legacy consumer-repos directory** and add validated per-module examples
+    (D-058: `modules/<name>/examples/` with `simple.yaml` + `complex.yaml`
+    validated in CI) + a new RDS primitive demonstrating multi-engine
+    variation (D-059).
+
+## Milestone v1.7 Phases
+
+| Phase | Name | Goal |
+|-------|------|------|
+| 22 | rename-and-production-static-assets-stack | Rename `static-assets` → `static-assets` everywhere (D-048). Author `cloudfront` + `waf` primitives. Augment `static-assets` to S3 + CloudFront (OAC) + WAF (D-049). Expand adapter. Bump `uses:` to `@v1.6`; create floating `v1.6` + `v1` tags (D-057). |
+| 23 | tagging-standards-and-security-adapters | Required-tag set + Checkov custom rule (D-054, D-043 closure). Wiz adapter stub (D-052). Kyverno K8s-native adapter (D-053). Schema engine enum updated. |
+| 24 | platform-lambda-and-contract-ingestion | Platform Lambda + DynamoDB `acdl-contracts` table (D-051) + cross-account IAM + onboarding grant. |
+| 25 | deploy-pipeline-dx-outputs-and-error-reporting | SSM SecureString + PR comment outputs (D-050). Lambda `report_error` → GitHub issue (D-055). Stage comments after each successful stage. |
+| 26 | platform-pipelines-and-release-automation | 3 platform pipelines (platform-test, primitives-plan, patterns-plan). Release job with semver + MAJOR.MINOR/MAJOR tag updates (D-057). |
+| 27 | remove-legacy-consumer-repos-and-module-documentation-examples | Delete the legacy consumer-repos directory. RDS primitive (D-059). Validated per-module examples (D-058). Docs updates. |
+
+Milestone COMPLETE gate: review → ship `v1.7.0` (feature milestone, next
+minor per ship.md — v1.6 shipped `v1.6.0`) → audit.
+
+## Objective for Milestone v1.8 (active)
+
+P1 remediation + uptime monitoring + engineering standards + encryption
+and deletion-protection by default + decommission alias + documentation.
+The v1.7 milestone shipped production platform + contract ingestion but
+left 8 P1 issues flagged for post-hoc review. v1.8 clears all of them
+AND delivers three user-directed feature/NFR tracks (2026-07-22):
+
+**Track 1 — P1 Remediation (Phases 28–30):**
+Clear all 8 pending P1 issues from v1.5/v1.6/v1.7 verify reviews:
+- P1-3: SSM uses AWS-managed key silently → fail loud without CMK config
+- P1-4: WAF custom rules emit invalid HCL (attribute vs block syntax)
+- P1-5: WAF default_action input silently ignored
+- P1-6: consumer_invoke_policy.json has placeholder account ID
+- P1-7: L2 composition outputs section not implemented in resolver
+- P1-8: terraform/spike/*.tf overwritten by run_platform.sh (state
+  contamination)
+- P1-9: GitHub API URLs hardcoded in contract_ingestor.py (Gitea fails
+  silently)
+- S1: Deploy workflow static-key override not wired (passes ACDL_AWS_*
+  env vars to configure-aws-credentials which reads AWS_*/its own inputs)
+
+**Track 2 — Encryption + Deletion Protection by Default (Phases 31–32):**
+All primitives encrypted by default (CMK priority + SSE, managed KMS
+fallback). Per-stack CMK (one key per L2 deployment, 90-day rotation,
+no shared keys). Deletion protection on by default for every primitive.
+L2 modules expose a feature flag to turn off deletion protection. A
+decommission alias uses a 2-step pipeline (disable deletion protection
+→ zero counts → destroy) with HITL SRE gates and CMDB-validated change
+request ID.
+
+**Track 3 — Uptime + Standards + Docs (Phases 33–36):**
+A new uptime-kuma primitive (ECS Fargate) deployed by default after any
+L2 module deploy (separate terraform state), with a feature flag to
+disable. Monitored endpoints passed from L2 outputs. Alert channels
+(Teams/email/SMS/GitHub issues). The uptime URL published to consumers
+via PR comments. Engineering standards for L1 + L2 module authoring
+(scanned from current modules, stored in modules/). READMEs for
+schemas/, adapters/, pipelines/ paths documenting how to write, wire,
+and test each.
+
+## Milestone v1.8 Phases
+
+| Phase | Name | Goal |
+|-------|------|------|
+| 28 | adapter-waf-and-resolver-outputs | Fix WAF HCL emission (nested rules blocks + default_action input) + implement L2 composition outputs in resolver + adapter output blocks. P1-4, P1-5, P1-7. |
+| 29 | ssm-kms-and-invoke-policy | SSM publisher fails loud without CMK (escape hatch for local) + Terraform-rendered consumer_invoke_policy (no placeholder account ID). P1-3, P1-6. |
+| 30 | run-platform-isolation-and-api-portability | Adapter output to per-run temp dir (remove committed spike .tf) + forge-agnostic API URLs + deploy.yml static-key override wired. P1-8, P1-9, S1. |
+| 31 | encryption-by-default-and-per-stack-cmk | KMS-key primitive + per-stack CMK wired in L2 modules + encryption NFRs on all primitives + managed KMS fallback. |
+| 32 | deletion-protection-by-default-and-l2-feature-flag | Deletion protection NFR on all primitives (default true) + L2 feature flag + contract schema update. |
+| 33 | uptime-kuma-primitive | Uptime L1 primitive (ECS Fargate, feature flag, monitored endpoints, alert channels) + deploy-uptime pipeline stage (separate state) + URL published via PR comment. |
+| 34 | decommission-alias-and-cmdb-validation | Decommission mode on deploy pipeline (2-step: disable deletion protection → zero counts, HITL SRE gates) + DynamoDB CMDB validation + consumer guide docs. |
+| 35 | module-engineering-standards | modules/STANDARDS.md (L1+L2 authoring + review standards scanned from current modules) + catalog index fix + template update + automated standards test. |
+| 36 | schemas-adapters-pipelines-readmes | schemas/README.md + pipelines/README.md + adapters/README.md (how to write, wire, test, dependencies). |
+| 37 | verify | 4-layer verification of all v1.8 phases. |
+| 38 | review-audit-complete | Multi-persona review + audit + milestone completion (tag v1.8.0). |
+
+Milestone COMPLETE gate: review → ship `v1.8.0` (feature milestone, next
+minor per run.md — v1.7 shipped `v1.7.0`) → audit.
+
+## Objective for Milestone v1.9 (complete, tag `v1.9.0`)
+
+Production-grade progression: contract interpolation, per-environment
+promotion without field editing, stub implementation, and P1-1
+remediation. The v1.8 milestone shipped encryption/deletion-protection by
+default, uptime, decommission, and engineering standards but left four
+gaps that v1.9 closes (user-directed, 2026-07-23):
+
+1. **Design doc refresh.** `core/hitl_matrix_design.md` and
+   `core/audit_ledger_design.md` are stale — both still describe the
+   v1.1 spike scope ("dev-only; HITL not exercised"; "spike scope =
+   hash chain + outbox write; Object Lock + JWS are v1.2"). v1.9 brings
+   them up to date with the shipped v1.8 platform and the v1.9 wiring.
+2. **Contract interpolation (variable expansion).** Contracts cannot
+   reference environment onboarding values today — bucket names, account
+   IDs, regions are hardcoded literals. v1.9 adds `${env.<field>}` and
+   `${contract.<field>}` expansion in the resolver, sourced from the
+   environment onboarding JSON. Naming patterns like
+   `acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}`
+   become expressible. The S3 bucket naming-pattern requirement is the
+   binding example.
+3. **Per-environment CI jobs (no field editing for promotion).** Today a
+   promotion dev → qa requires editing the `environment:` field in the
+   contract YAML. v1.9 ships a hybrid model: (a) per-environment contract
+   files (`.acdl/static-assets.dev.yaml`, `...qa.yaml`, etc.) and (b) an
+   `environment` `workflow_call` input on the reusable deploy workflow
+   that overrides the contract's environment at load time. There is one
+   CI job per environment, each pointing at its respective contract (or
+   the same contract + the env input). Promotion = running the matching
+   job; no field editing.
+4. **Stub implementation.** Identify and implement the stubbed
+   functionality: `separation_of_duties.route_halt_artifact` (logs only →
+   real SNS + outbox event); HITL qa/prod/dr pre-execution attestation
+   gates (only decommission SRE gates are wired today); the full
+   8-concern attestation matrix (offline-testable subset implemented;
+   operator-supplied concerns accept signed evidence artifacts); the Wiz
+   adapter (stub → real API client with graceful degrade); the Kyverno
+   adapter (fleshed out translator, still inactive for Terraform-only
+   stacks). The audit-ledger S3 Object Lock + JWS + async worker + DLQ +
+   daily checkpoints build-out is **deferred** to a future milestone
+   (D-083) — it requires non-offline-testable AWS infra (Object Lock
+   bucket, KMS signing key, SQS DLQ, Lambda worker).
+5. **Post-hoc requirement from previous milestones.** P1-1 from the v1.2
+   review (adapter ECS/ALB/VPC hardcoded defaults — `desired_count = 1`,
+   `launch_type = "FARGATE"`, `target_type = "ip"`,
+   `load_balancer_type = "application"`, `family = "app"`, `Name = ...`
+   — should be parameterized via the L1 interfaces, deferred to v1.3,
+   never implemented) is closed. The adapter becomes a thin translator;
+   the defaults move into `interface.json` inputs.
+
+The milestone also reconstructs `.ciagent/REVIEW.md`, which still holds
+v1.2 review content (v1.3–v1.8 reviews were not persisted). The v1.9
+review overwrites it with current milestone content; a note records the
+historical gap (no git-history rewrite).
+
+## Milestone v1.9 Phases
+
+| Phase | Name | Goal |
+|-------|------|------|
+| 39 | design-doc-refresh-and-p1-1-parameterization | Refresh `hitl_matrix_design.md` + `audit_ledger_design.md` to current. Move adapter ECS/ALB/VPC hardcoded defaults into L1 `interface.json` inputs (P1-1 closure). |
+| 40 | contract-interpolation | `${env.<field>}` + `${contract.<field>}` resolver expansion from environment onboarding JSON. Environment JSON schema. Sample contracts use naming patterns (region + account id + environment). |
+| 41 | per-environment-ci-jobs | Per-env contract files + `environment` workflow_call input on the deploy workflow. 1 CI job per environment (dev/qa/prod/dr), each pointing at its respective contract. HITL attestation gate structure wired (qa/prod/dr). |
+| 42 | stub-implementation | `route_halt_artifact` real (SNS + outbox). HITL qa/prod/dr attestation gates. 8-concern attestation matrix (offline-testable subset). Wiz real client. Kyverno translator fleshed out. |
+| 43 | verify-review-audit-complete | 4-layer verify. Multi-persona review. Audit. Complete v1.9 (tag `v1.9.0`, floating tags, `uses:` bump `@v1.6` → `@v1.9`). |
+
+Milestone COMPLETE gate: review → ship `v1.9.0` (feature milestone, next
+minor per run.md — v1.8 shipped `v1.8.0`) → audit.
+
+## Patch v1.9.1 (complete, tag `v1.9.1`)
+
+Docs-only NFR patch on the v1.9 line. Two leadership-facing presentation
+decks (How the Platform Works + The Developer Experience) for senior
+leadership (CTO, Head of Cloud, Head of Infrastructure, Head of DevOps).
+Each deck has a full markdown source of truth (with speaker notes + mermaid
+diagrams) and a lean Marp deck (no speaker notes, embedded PNG diagrams). A
+README documents the 3-step slide creation process (full markdown → Marp
+synthesis → PPTX export) with conventions, build commands, and maturity
+framing rules. No code changes; 494 tests pass; `run_ci.sh` +
+`run_platform.sh --check-only` green.
+
+## Patch v1.9.2 (complete, tag `v1.9.2`)
+
+Docs-only NFR patch on the v1.9 line. Applies the S&P Global Energy brand
+visual identity to both Marp presentation decks. Brand colors extracted
+from the live spglobal.com compiled Tailwind CSS and SVG logo: red-core
+`#D6002A`, grey-90 `#1B1B1B`, grey-80 `#2E2E2E`, grey-5 `#F0F0F0`, Akkurat
+Pro corporate typeface. Title headers changed to full platform name.
+Footer changed from 'Confidential · For Senior Leadership' to 'Internal'.
+Title slide subtitle removed. Last DX slide renamed from 'The Outcome for
+Leadership' to 'The Desired Outcomes'. Marp `theme: default` kept as base.
+No code changes; 494 tests pass; `run_ci.sh` + `run_platform.sh --check-only`
+green.
+
+## Patch v1.9.3 (complete, tag `v1.9.3`)
+
+Docs-only NFR patch on the v1.9 line. Renders both Marp presentation decks
+to self-contained HTML (committed to `docs/presentations/`, base64-embedded
+images, full S&P Global Energy brand theme) and PPTX (uploaded to the Gitea
+release as downloadable attachments). The HTML files are viewable in any
+browser and on the git forge — they render the red accent bar, dark
+title-slide background, red H1 headings, and Akkurat Pro font stack. README
+updated to document HTML as committed artifacts (re-render when Marp source
+changes) and PPTX as release attachments (binary, not committed to git).
+No code changes; 494 tests pass; `run_ci.sh` + `run_platform.sh --check-only`
+green.
+
+## Patch v1.9.4 (complete, tag `v1.9.4`)
+
+Docs-only NFR patch on the v1.9 line. Two categories of changes:
+
+1. **Presentation slide updates** — title slide redesigned (deck title as H1
+   slightly bigger, 'Agentic Cloud Delivery Platform' as H3 subtitle on dark
+   background). DX deck: removed Local Reproducibility slide (not beneficial
+   for DX narrative), redesigned Safe Promotion Path with side-by-side
+   HTML table layout for Approaches A and B, 'an agent' → 'an AI agent' on
+   slides 2 and 3, What a Developer Does diagram floated to the right side.
+   Running header simplified to just the deck name.
+
+2. **Complete removal of a compliance framework** — all references to a
+   specific healthcare compliance framework removed from 25 files
+   across the codebase: presentation source files (Marp + full markdown),
+   all module READMEs (S3, RDS, ECR, ECS, VPC, IAM, KMS, CloudFront, ALB,
+   uptime), top-level README, consumer guide, docs index, module standards.
+   Compliance milestone lists now read: GDPR, SOX, SOC2, DORA. All section
+   references from that framework removed from compliance annotations.
+   Rendered HTML decks re-generated from updated Marp source.
+
+No code changes; 494 tests pass; `run_ci.sh` + `run_platform.sh --check-only`
+green. PPTX files uploaded to Gitea release.
+
+## Patch v1.9.5 (complete, tag `v1.9.5`)
+
+Docs-only NFR patch on the v1.9 line. 9 requirements implemented:
+
+1. DX closing slide strengthened with 'Infrastructure as a utility, not a
+   craft' bullet — conveys the full vision (infrastructure consumed, not
+   maintained; platform compounds value over time).
+2. PW Problem slide: 'moving a merged change' → 'promoting a change'.
+3. PW Problem slide: added 'Red tape' and 'Scalability without increasing
+   headcount' bullets (4 frictions, not 2).
+4. PW Roadmap slide: redesigned with side-by-side HTML table layout
+   (Testing | Planned), 16px font, no overflow.
+5. PW deck: new slide 'What This Platform Is — and Isn't' after North Star
+   (sovereign boundary, infrastructure as utility, 4 anti-goals). PW deck
+   now 16 slides.
+6. Maturity nomenclature: 'Available today'/'shipped' → 'Testing' across
+   both decks + source markdown. New .testing badge (blue/teal). The
+   platform has 0 consumer adoption — 'shipped' was inaccurate.
+7. Global: 'substrate' → 'engine' across entire project (88 matches, 30+
+   files including .ciagent/, docs/, modules/, adapters/, schemas/, code).
+8. Presentation files only: 'forge' → 'VCS' (6 occurrences in 4 files).
+   'forge' retained in all technical docs and code.
+9. New .agentic badge (purple/violet) appended to agentic features in both
+   decks: confidence signal, autonomous dev, pattern recognition, dynamic
+   module creation, citizen developer surface, auto-promotion.
+
+Also: Change Request ID format changed from 'CR-2026-001' to 'CHG0678912'
+across presentation files, consumer guide, and test fixtures.
+
+No code changes (test fixture strings only); 494 tests pass; `run_ci.sh` +
+`run_platform.sh --check-only` green. PPTX files uploaded to Gitea release.
+
+## Patch v1.9.6 (complete, tag `v1.9.6`)
+
+Docs-only NFR patch on the v1.9 line. Both Marp presentation decks
+consolidated to 10 high-impact slides each — every slide high-impact, fluff
+eliminated.
+
+**How The Platform Works (16 → 10):**
+- Merged Problem + North Star + What It Is/Isn't → 1 slide (4 frictions →
+  North Star → 3 success criteria → 2 anti-goals)
+- Merged Policy & Security + Secure by Default → 'Security by Construction'
+- Merged Immutable Audit + Human-in-the-Loop → 'Accountability & Audit'
+- Folded Observability, Platform-Managed Environments, Portability into
+  existing slides as bullets
+- Added 'The Vision Realized' closing slide
+
+**The Developer Experience (15 → 10):**
+- Merged What Dev Does + Contract + No Platform Code → 'The Contract — The
+  Entire Consumer Surface'
+- Merged Instant Feedback + Deploy Outputs → 'The Developer Feedback Loop'
+- Merged Safe Promotion Path + Rising Bar → 1 slide
+- Cut Citizen Developer Experience standalone (mentioned on slides 2 + 10)
+- Kept Versioned Releases, Friendly Onboarding, Safe Decommission
+
+**Also:** Removed '5-line YAML' claim from both decks (credibility — complex
+stacks require more lines). Source markdown files unchanged (remain complete
+reference with speaker notes for all original slides).
+
+No code changes; 494 tests pass; `run_ci.sh` + `run_platform.sh --check-only`
+green. PPTX files uploaded to Gitea release.
+
+## Patch v1.9.7 (complete, tag `v1.9.7`)
+
+Docs-only NFR patch on the v1.9 line. Created two talking points markdown
+files — one per deck — distilling the source of truth (speaker notes +
+content) into presenter-ready cues indexed by the Marp deck's 10-slide
+structure. Each file has one section per Marp slide with 3-6 talking point
+bullets (punchy, actionable cues) + a key takeaway per slide. The talking
+points are the middle layer between the source of truth (full detail) and
+the Marp deck (what the audience sees). README updated from 3-step to 4-step
+process (added Step 4: talking points), with updated diagram, directory
+layout, checklist, and decks table.
+
+No code changes; 494 tests pass; `run_ci.sh` + `run_platform.sh --check-only`
+green.
+
 ## Requirements
 
 ### v1.0 (Prior milestone — the demo)
@@ -180,7 +516,7 @@ appendix below. The demo is **archived** to `demo/` in Phase 06.
 New requirements REQ-16..REQ-28 — see `REQUIREMENTS.md` §v1.1. Summary:
 
 - **REQ-16:** Architecture finalized to v1.0 (11 open decisions resolved).
-- **REQ-17:** Target Stack IR defined as JSON Schema; substrate-agnostic.
+- **REQ-17:** Target Stack IR defined as JSON Schema; engine-agnostic.
 - **REQ-18:** PolicyCheckResult normalized schema defined; Checkov adapter.
 - **REQ-19:** Six-input confidence signal specified with per-env thresholds
   (dev 0.50 / qa 0.75 / prod 0.90 / dr 0.95) and severity→penalty mapping.
@@ -193,14 +529,14 @@ New requirements REQ-16..REQ-28 — see `REQUIREMENTS.md` §v1.1. Summary:
 - **REQ-23:** AWS OIDC bootstrap (IAM role + trust policy for act_runner);
   the long-lived key is used once then rotated (waiver D-034).
 - **REQ-24:** One real L1 module (`l1-s3`) with an IR-typed interface.
-- **REQ-25:** One real L2 thin-composition (`l2-static-asset`) referencing
+- **REQ-25:** One real L2 thin-composition (`l2-static-assets`) referencing
   `l1-s3`.
 - **REQ-26:** Terraform adapter compiles the IR to a real `terraform plan`
   against AWS via OIDC; state in S3 + DynamoDB.
 - **REQ-27:** One end-to-end contract submission → contract→IR resolution →
   `terraform plan` → Checkov → confidence signal → evidence event to outbox.
 - **REQ-28:** Spike verification proves the IR-shaped commitments hold (no
-  polyglot mess; the adapter is the only substrate-specific code).
+  polyglot mess; the adapter is the only engine-specific code).
 
 ### v1.2 (Prior milestone — platform hardening + first real consumer deployment, complete)
 
@@ -223,7 +559,7 @@ New requirements REQ-29..REQ-35 — see `REQUIREMENTS.md` §v1.2. Summary:
 - **REQ-35:** End-to-end verification — consumer commit → live ECS service
   (HTTP 200) → evidence event → timeline.
 
-### v1.4 (Active milestone — central pipeline contract + shell reproducibility + streaming)
+### v1.4 (Prior milestone — central pipeline contract + shell reproducibility + streaming)
 
 New requirements REQ-43..REQ-45 — see `REQUIREMENTS.md` §v1.4. Summary:
 
@@ -235,6 +571,29 @@ New requirements REQ-43..REQ-45 — see `REQUIREMENTS.md` §v1.4. Summary:
 - **REQ-45:** `scripts/run_platform.sh` streams terraform/checkov output by
   default (with `--quiet` for log-only mode). Both workflows byte-identical.
 
+## Key Decisions (v1.9)
+
+Resolved at the CLARIFY stage (full autonomy — all within locked
+constraints or user-directed scope). New v1.9 decisions (numbered
+D-080+ to avoid collision with v1.8 research decisions D-073..D-077):
+
+| ID | Decision | Rationale | Outcome |
+|----|----------|-----------|---------|
+| D-080 | New milestone v1.9 (feature); ship tag `v1.9.0`. | v1.8 is complete (audit PASS, tag v1.8.0). The work (design doc updates + interpolation + per-env CI + stubs + P1-1) is a new feature milestone, not v1.8 post-hoc patching. | 5 phases (39–43) in one milestone. |
+| D-081 | Interpolation syntax: `${env.<field>}` + `${contract.<field>}` (dotted paths supported, e.g. `${env.state_backend.bucket}`). Expanded by the resolver post-schema-validation, pre-IR-resolution. Fail loud on unresolved tokens (`ValueError`). | Shell-style syntax is familiar, unambiguous, and has no conflict with YAML or the contract schema. The `env` context is the loaded environment onboarding JSON; `contract` is the contract dict. | Phase 40 implements the expansion + environment JSON schema. |
+| D-082 | Hybrid per-environment promotion model: (a) per-env contract files AND (b) an `environment` `workflow_call` input on the reusable deploy workflow that overrides the contract's environment at load time. One CI job per environment. | User chose to support both shapes. Per-env contracts let env-specific values differ via interpolation; the env input lets a single contract be promoted without editing. Promotion = running the matching job; no `environment:` field editing. | Phase 41 ships per-env contracts + the env input + caller-workflow docs. |
+| D-083 | Audit ledger S3 Object Lock + JWS detached signatures + async worker + DLQ + daily checkpoints **deferred** to a future milestone. | Requires non-offline-testable AWS infra (Object Lock bucket, KMS signing key, SQS DLQ, Lambda worker). The hash-chain + DynamoDB-outbox path remains the v1.9 production audit record. `audit_ledger_design.md` marks this clearly. | Phase 39 updates the design doc; no build-out in v1.9. |
+| D-084 | 8-concern attestation matrix: offline-testable concerns (contract NFRs, schema validity, policy pass) run for real; operator-supplied concerns (k6 load test, DR drill, FinOps forecast) accept signed evidence artifacts validated for freshness + schema, failing loud if missing/expired for prod/dr. | The platform cannot run live load tests / DR drills / FinOps forecasts inline. Accepting signed evidence artifacts with freshness + schema validation is the regulatorily-defensible middle ground. | Phase 42 implements `core/attestation_matrix.py`. |
+| D-085 | P1-1 closure: adapter ECS/ALB/VPC hardcoded defaults (`desired_count = 1`, `launch_type = "FARGATE"`, `target_type = "ip"`, `load_balancer_type = "application"`, `family = "app"`, `Name = ...`) move into L1 `interface.json` inputs with defaults. The adapter reads inputs (falling back to interface defaults) and is a thin translator. | P1-1 was flagged in the v1.2 review (deferred to v1.3, never implemented). Defaults belong in the L1 interface, not the adapter. | Phase 39 closes P1-1. |
+| D-086 | `.ciagent/REVIEW.md` reconstructed at v1.9 complete; v1.3–v1.8 reviews noted as not-persisted (no git-history rewrite). | REVIEW.md still holds v1.2 content — later milestone reviews were not persisted or were overwritten. The v1.9 review overwrites it with current content; a note records the historical gap. | Phase 43 reconstructs REVIEW.md. |
+
+### CLARIFY auto-resolved parameters (full autonomy)
+
+| Parameter | Value | Rationale |
+|---|---|---|
+| Per-env `qa.json/prod.json/dr.json` account_id | `000000000000` placeholder + stderr warning at load if account_id is `000000000000` and env ≠ dev | Consistent with `dev.json`; prompts real binding without breaking offline tests. |
+| SNS topic for `route_halt_artifact` | Defined in `terraform/platform/main.tf` AND code reads `ACDL_SOD_HALT_TOPIC_ARN` | Consistent with the existing Lambda/KMS/Secrets pattern (Terraform defines, code reads env). |
+
 ## Constraints
 
 - **Forge:** Gitea at `https://git.cloudinit.dev`, org `continuous-intelligence`.
@@ -242,8 +601,8 @@ New requirements REQ-43..REQ-45 — see `REQUIREMENTS.md` §v1.4. Summary:
 - **Cloud:** AWS via OIDC federation. **Long-lived credentials are forbidden**
   (§12.5). The v1.1 spike uses a temporary long-lived key **once** to bootstrap
   OIDC (waiver D-034), then rotates it.
-- **Substrate:** Terraform adapter in v1 (the only adapter). L1/L2 are
-  substrate-agnostic in shape; the adapter is the only substrate-specific code.
+- **Angine:** Terraform adapter in v1 (the only adapter). L1/L2 are
+  engine-agnostic in shape; the adapter is the only engine-specific code.
 - **State:** S3 (state files) + DynamoDB (locking), single-region in v1.
 - **Environments:** dev (autonomous) → qa (QA HITL) → prod (SRE HITL) → dr
   (SRE HITL). **Staging does not exist** (Path A locked).
@@ -268,7 +627,7 @@ New requirements REQ-43..REQ-45 — see `REQUIREMENTS.md` §v1.4. Summary:
   vision/architecture sources, pulled from `origin/main` at the start of v1.1.
 - The v1.0 demo (tag `v1.1.0`) is the reference of intent — it proved the
   shape (L1/L2/contract/confidence/evidence/HITL) on stubs. v1.1 replaces the
-  stubs with the real platform substrate.
+  stubs with the real platform engine.
 
 ## Key Decisions (v1.1)
 
@@ -279,7 +638,7 @@ decisions:
 |----|----------|-----------|---------|
 | D-034 | Temporary long-lived AWS key (waiver) used once in Phase 08 to bootstrap the state backend + IAM user; rotated/deactivated immediately after | §12.5 forbids long-lived creds; the bootstrap needed one `aws iam` call before the spike user + rotated key could take over | Spike achieves real `terraform plan` against AWS without violating the locked target after bootstrap. **CLOSED 2026-07-21: root key `AKIA…ROOT-DEACTIVATED` deactivated by the user in the AWS IAM console (verified — `InvalidClientTokenId`); the spike uses the rotated `acdl-spike-runner` key per D-039. Key ID redacted in v1.2 Phase 12 (P1-1).** |
 | D-035 | Milestone version = `v1.1` (feature), ship tag `v1.2.0` | Real platform is a breaking reframing of the demo, but treated as the next incremental milestone per user choice; ship.md: feature milestone → next minor | Tag `v1.2.0` on milestone COMPLETE |
-| D-036 | Spike picks `l1-s3` + `l2-static-asset` | Simplest real AWS resource (no IAM/network deps); smallest real `terraform plan`; proves the IR + adapter end-to-end | Spike scope fixed |
+| D-036 | Spike picks `l1-s3` + `l2-static-assets` | Simplest real AWS resource (no IAM/network deps); smallest real `terraform plan`; proves the IR + adapter end-to-end | Spike scope fixed |
 | D-037 | Demo archived to `demo/` (not deleted) | Preserves the working v1.0 demo as intent reference; new platform layout under `platform/`, `schemas/`, `adapters/`, `terraform/`, `modules-ir/` | No churn on demo code; clean separation |
 | D-038 | Open decisions resolved in "accept recommendations + decide rest" mode | User-locked mode: accept architecture's stated recommendations (W1.A, W1.B, W2.A, BA.A); lead-developer decides the remaining 8 (W3.D, W3.E, BA.B, BA.C, BA.D, BA.E, BA.F, OpenTofu timing) with rationale | Architecture reaches v1.0 in Phase 07 |
 | D-039 | Spike-only waiver: per-run-rotated long-lived AWS key. OIDC federation deferred to v1.2, blocked on go-gitea/gitea#36988. | **RESEARCH TARGET 1 verdict (conf 0.95):** Gitea Actions does NOT support `id-token: write` / OIDC token issuance as of Gitea 1.27.x / gitea-runner v2.1.0. GitHub's OIDC pattern is not portable. The waiver satisfies §12.5's *intent* (no persistent long-lived key) for the spike: the key is rotated after each run by `scripts/rotate_spike_key.sh`. v1.2 implements real OIDC when the Gitea PR merges. | Spike achieves real `terraform plan` against AWS without a *persistently* long-lived key; real OIDC is a v1.2 deliverable |
@@ -292,6 +651,47 @@ decisions:
 | D-046 | `act_runner` → `gitea-runner` rename: Phase 07 updates docs to use the current name `gitea-runner` (renamed 2026-04 in gitea/runner#850). | RESEARCH TARGET 1 + R-4: naming drift between v1.0 docs and the current runner. | Docs reflect the current binary name |
 | D-047 | v1.2 carries forward the D-039 per-run-rotated-key waiver. Real OIDC federation remains deferred to v1.3+, blocked on go-gitea/gitea#36988 (re-checked 2026-07-21: still **open**, last updated 2026-05-27, not merged). | §12.5 forbids long-lived creds; the Gitea Actions OIDC provider is still not merged. The waiver continues to satisfy §12.5's *intent* (no *persistently* long-lived key) for v1.2: `scripts/rotate_spike_key.sh` rotates the key, and Phase 12 tightens the IAM scoping + rotation hygiene. | v1.2 achieves `terraform apply` against AWS without a persistently long-lived key; real OIDC is a v1.3+ deliverable. |
 
+## Key Decisions (v1.8)
+
+Resolved at the CLARIFY stage (full autonomy — all within locked
+constraints or user-directed scope). New v1.8 decisions:
+
+| ID | Decision | Rationale | Outcome |
+|----|----------|-----------|---------|
+| D-061 | Fold all 3 new requirements into v1.8 alongside P1 fixes. | User chose single milestone. v1.8 becomes a feature milestone (ship tag v1.8.0, minor bump). | 11 phases (28–38) in one milestone. |
+| D-062 | P1-3: SSM publisher fails loud (`RuntimeError`) when `ACDL_KMS_KEY_ID` unset. `ACDL_ALLOW_DEFAULT_KMS=1` escape hatch for local testing. | User chose fail loud. Silent AWS-managed-key use is the security gap; callers must set the env. | Phase 29 implements fail-loud + escape hatch. |
+| D-063 | P1-6: `consumer_invoke_policy.json` rendered via Terraform `data.aws_caller_identity` + `templatestring` at apply time. | User chose Terraform-rendered. No committed account ID; no stale placeholder. | Phase 29 converts JSON to TF-rendered template. |
+| D-064 | P1-8: Remove committed `terraform/spike/*.tf` entirely; adapter emits to per-run temp dir. | User chose remove. Cleaner; no stale fixtures. | Phase 30 removes files + changes run_platform.sh target. |
+| D-065 | S1: Single conditional `configure-aws-credentials` step (OIDC when no static key, access-key/secret-key inputs when static key present). | User chose single conditional step. Cleaner workflow YAML. | Phase 30 restructures the deploy workflow step. |
+| D-066 | Uptime deployment target: ECS Fargate (reuse existing ecs-cluster + ecs-service + alb primitives). | User chose ECS Fargate. Most consistent with current platform; ALB gives a stable URL. | Phase 33 authors uptime primitive on ECS Fargate. |
+| D-067 | Uptime trigger: new `deploy-uptime` pipeline stage after `publish-outputs`. Separate terraform state (S3 key prefix `uptime/`). | User chose pipeline stage. Most integrated with existing flow. | Phase 33 adds the pipeline stage + separate state. |
+| D-068 | CMDB = DynamoDB `acdl-change-requests` table (PK changeRequestId, SK submittedAt). | User chose DynamoDB. Consistent with existing platform Lambda + DynamoDB pattern. | Phase 34 adds the table + `validate_change_request` Lambda action. |
+| D-069 | Encryption key granularity: per-stack CMK (one key per L2 deployment, tagged with acdl:owner + acdl:environment). | User chose per-stack. No shared keys across stacks; 90-day rotation at creation. | Phase 31 authors kms-key primitive + L2 wiring. |
+| D-070 | Decommission: new mode on the existing deploy pipeline (`mode: decommission`). 2-step with HITL SRE gates. | User chose existing pipeline with different behavior. Plan/apply to disable deletion protection (HITL SRE gate) → plan/apply with counts=0 (second HITL SRE gate). Documented in consumer guide. | Phase 34 adds decommission mode + HITL gates. |
+| D-071 | `uses:`/`ref:` bump from `@v1.6` to `@v1.8` at milestone COMPLETE. | Consumer-facing version tracks the last released MAJOR.MINOR. | Phase 38 bumps references + creates floating `v1.8` + `v1` tags. |
+| D-072 | Managed KMS fallback for standalone L1 deployments (no L2 CMK): adapter uses `alias/aws/<service>` with a stderr warning. `kms_key_arn` input is optional everywhere; `encryption_enabled` NFR defaults to true. | Requirement says "prioritize CMKs, fallback to managed KMS". Standalone L1s don't have a per-stack CMK. | Phase 31 implements fallback + warning. |
+
+## Key Decisions (v1.7)
+
+Resolved at the CLARIFY stage (full autonomy — all within locked constraints
+or user-directed scope). New v1.7 decisions:
+
+| ID | Decision | Rationale | Outcome |
+|----|----------|-----------|---------|
+| D-048 | Rename `static-assets` → `static-assets`: **rewrite all occurrences** including verbatim historical phase descriptions in `.ciagent/` (ROADMAP, REQUIREMENTS, RESEARCH, decision tables), overriding the v1.6 audit precedent that preserved some historical references. | User chose full rewrite. Maximally consistent; the reconstruction test is updated to expect `static-assets` throughout. | Phase 22 rewrites every `static-assets` string to `static-assets`; no preserved historical tokens remain. |
+| D-049 | Production static-assets stack = S3 + CloudFront (OAC) + WAF. | Self-contained, domain-free production edge. Route53/ACM are domain-dependent (consumer-supplied) and deferred to documented extension points / a complex example. | Phase 22 authors `cloudfront` + `waf` primitives and augments the module. |
+| D-050 | Deploy outputs: SSM Parameter Store (`SecureString`, KMS-encrypted, namespaced `/acdl/{env}/{contractId}/{output_name}`) for runtime-injectable values + GitHub PR comment / job summary for human-readable connection strings. | Two canonical mechanisms: SSM for resources that read at runtime; PR comment for developers. No raw secrets in logs. | Phase 25 implements `core/output_publisher.py` + two new pipeline stages. |
+| D-051 | Contract ingestion storage = DynamoDB table `acdl-contracts` (PK `consumerRepo`, SK `contractId#submittedAt`, SSE via customer-managed CMK, point-in-time recovery). | Enables historical queries, impact analysis, CMDB-style application-state queries, and pattern detection via DynamoDB queries. S3 flat-file mirror deferred (DynamoDB is sufficient for v1.7). | Phase 24 defines the table + Lambda. |
+| D-052 | Wiz adapter = stub + schema path (no live Wiz tenant in CI). | Matches the Checkov adapter pattern; typed interface, offline-testable, degrades gracefully when unconfigured (emits `WIZ_NOT_CONFIGURED` SKIPPED record). | Phase 23 authors `adapters/wiz/wiz_adapter.py`. |
+| D-053 | Kyverno adapter = K8s-native policy adapter translating `PolicyReport` results → `PolicyCheckResult`. Ready but inactive for Terraform-only stacks. | The platform emits Terraform, not K8s manifests. The adapter activates when the GitOps reconciler (roadmap) emits K8s manifests. Sample policies included as documentation. | Phase 23 authors `adapters/kyverno/kyverno_adapter.py` + sample policies. |
+| D-054 | Tagging standard = required-tag set (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`) enforced by a Checkov custom YAML rule. | Closes the D-043 deferral (the SKIPPED `ACDL_TAG_NAMING` placeholder becomes a real check). Naming-convention regex deferred (brittle across AWS resource types). | Phase 23 authors `schemas/tagging-standard.json` + `adapters/terraform/policy/custom_rules/acdl_tagging.yaml`. |
+| D-055 | Error reporting = the platform Lambda `report_error` action creates a GitHub issue on the platform repo (`acdl/acdl`). Uniform communication pathway via the Lambda; the consumer's onboarding-granted Lambda-invoke permission is the only grant needed. No separate GitHub `issues: write` on the consumer side. Gitea is excluded (only the CIAgent uses it; platform engineers and consumers use GitHub). | Unifies requirements 4 + 8 around one mechanism. The Lambda holds a GitHub token (Secrets Manager) scoped to the platform repo. Idempotent (comments on existing open issue rather than duplicating). | Phase 24 prepares the action; Phase 25 implements it + wires the `if: failure()` workflow step. |
+| D-056 | Ship `v1.7.0`; bump `uses:`/`ref:` from `@v1.4` to `@v1.6`. | Consumer-facing version tracks the last released MAJOR.MINOR. Consumers on `@v1.4` stay on v1.4 behavior until they bump. | Phase 22 bumps the references. |
+| D-057 | The `uses:`/`ref:` bump + floating `v1.6`/`v1` tag creation happen in Phase 22 (pointing at `v1.6.0`), so the reference never points at a non-existent tag. The release job (Phase 26) owns ongoing tag updates. | Sequencing: if Phase 22 bumps `uses:` to `@v1.6` but the tag doesn't exist, the reference is temporarily broken. Creating the tag early (pointing at the last release) fixes this. | Phase 22 creates the floating tags; Phase 26's release job maintains them. |
+| D-058 | Module examples = separate validated files in `modules/<name>/examples/` (`simple.yaml` + `complex.yaml` + variation files), validated against `schemas/contract.schema.json` in the platform-test pipeline schema-validation stage. Each module's README `## Examples` section references + excerpts them. | Examples cannot drift from the schema silently. | Phase 27 authors the example files; Phase 26's platform-test pipeline validates them. |
+| D-059 | Add an RDS primitive (`modules/l1/rds/`) with an `engine` input (enum: postgres, mysql, etc.) + a multi-engine example demonstrating the variation pattern. | Concrete demonstration of the multi-engine variation the requirement calls out. Adds one primitive + examples. | Phase 27 authors the primitive + adapter expansion + examples. |
+| D-060 | (Consolidated into D-058.) | — | — |
+
 ### Open-decision resolutions (Phase 07 deliverable — recorded here for traceability)
 
 | ID | Question | Resolution |
@@ -306,8 +706,8 @@ decisions:
 | BA.C | On-call / operational ownership | **Decided.** Platform on-call = Infra & Ops rotation. Escalation: L3A/L3B halt → platform on-call pager (Sev2); consumer-visible outage → consumer on-call (Sev1) with platform on-call support. Consumer on-call relationship is contractual, defined at onboarding (BA.E). |
 | BA.D | Cost / capacity governance | **Decided.** Cloud cost owner = Infra & Ops FinOps. Per-contract consumption reported monthly. Runaway spend: hard halt at 120% of contract-declared budget envelope via the confidence signal (cost is one of the 6 inputs); override = FinOps + SRE joint sign-off. |
 | BA.E | Consumer onboarding | **Decided.** Two paths: developer (L3A) — `getting-started` walks through contract schema + central pipeline template; citizen developer (L3B) — onboarding grants a scoped agent + skill catalog, no workflow authoring. Both end in a sandbox dev submission that must pass the confidence gate before the consumer is promoted. |
-| BA.F | Cross-platform evolution | **Decided.** The contract schema, IR, PolicyCheckResult, confidence signal, and audit stream are portable (substrate- and forge-agnostic). Forge-specific code: workflow YAML, OIDC trust, CODEOWNERS, Environments. A second forge (e.g., GitLab) requires a forge adapter + a workflow-template translator; no change to L1/L2/IR/confidence/audit. |
-| Q1.3 | OpenTofu timing | **Decided (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; no version committed. |
+| BA.F | Cross-platform evolution | **Decided.** The contract schema, IR, PolicyCheckResult, confidence signal, and audit stream are portable (engine- and forge-agnostic). Forge-specific code: workflow YAML, OIDC trust, CODEOWNERS, Environments. A second forge (e.g., GitLab) requires a forge adapter + a workflow-template translator; no change to L1/L2/IR/confidence/audit. |
+| Q1.3 | OpenTofu timing | **Decided (deferred).** Not in v1 or v1.1. The engine abstraction (§12) makes OpenTofu a future adapter, not an architecture change. Revisit when an OpenTofu adapter is requested; no version committed. |
 
 ## Appendix — Prior milestone (v1.0 demo) decisions
 
@@ -329,8 +729,8 @@ sign-off (autonomy = full; all within locked constraints).
 | OIDC IAM role | `acdl-act-runner-role` | Assumed by the act_runner via web-identity |
 | OIDC trust subject | `repo:continuous-intelligence/acdl:ref:refs/heads/main` (+ phase branches) | Least-privilege; refined in Phase 08 |
 | Spike L1 (`l1-s3`) inputs | `bucket_name: string`, `region: string` | Minimal S3 interface per §2 |
-| Spike L2 (`l2-static-asset`) | thin-composition referencing `l1-s3` only; depth 1 | Smallest real plan per D-036 |
-| Spike contract | `contracts/spike.yaml`: `stack: l2-static-asset`, `environment: dev`, `inputs: { bucket_name: acdl-spike-bucket, region: us-east-1 }` | One end-to-end submission (REQ-27) |
+| Spike L2 (`l2-static-assets`) | thin-composition referencing `l1-s3` only; depth 1 | Smallest real plan per D-036 |
+| Spike contract | `contracts/spike.yaml`: `stack: l2-static-assets`, `environment: dev`, `inputs: { bucket_name: acdl-spike-bucket, region: us-east-1 }` | One end-to-end submission (REQ-27) |
 | Spike `terraform` command | `plan` only | `apply` is out of scope (Out of Scope table); HITL-gated in v1.2 |
 | Checkov ruleset (spike) | the 4 L2 checks (secrets-in-plaintext, public ingress, IAM wildcard, KMS key reference) + tag/naming | §3 + §12.4; Kyverno/OPA deferred |
 | v1.0 tags preserved | `v1.0.1`..`v1.0.5`, `v1.1.0` retained | Immutability; demo archive does not rewrite history |

.ciagent/REQUIREMENTS.md

@@ -39,7 +39,7 @@
 
 ### Category: Architecture Finalization
 - **REQ-16:** Architecture reaches v1.0 — all 11 open decisions in `docs/architecture.md` §13 are resolved and recorded in `PROJECT.md` (W1.A, W1.B, W2.A, W3.D, W3.E, BA.A–F, OpenTofu timing).
-- **REQ-17:** Target Stack IR is defined as a JSON Schema under `schemas/ir.schema.json`; substrate-agnostic (resources, relationships, composition max-depth-5, policy hooks).
+- **REQ-17:** Target Stack IR is defined as a JSON Schema under `schemas/ir.schema.json`; engine-agnostic (resources, relationships, composition max-depth-5, policy hooks).
 - **REQ-18:** `PolicyCheckResult` normalized schema is defined under `schemas/policy_check_result.schema.json`; a Checkov adapter translates Checkov JSON to this schema.
 - **REQ-19:** Six-input confidence signal is specified under `platform/confidence_signal.py` with per-env thresholds (dev 0.50 / qa 0.75 / prod 0.90 / dr 0.95) and severity→penalty mapping (critical=hard override, high=-0.2, medium=-0.05, low=-0.01, info=0.0).
 - **REQ-20:** Tiered audit ledger design is authored: S3 Object Lock (compliance mode, 7-yr) + DynamoDB outbox (RPO=0, JWS detached signatures, `prev_event_hash` chain, daily checkpoints).
@@ -51,12 +51,12 @@
 
 ### Category: v1 Spike — IR, L1, Adapter
 - **REQ-24:** One real L1 module `l1-s3` exists under `modules-ir/l1/l1-s3/` with an IR-typed interface (typed inputs/outputs/NFRs) registered in the L1 registry.
-- **REQ-25:** One real L2 thin-composition `l2-static-asset` exists under `modules-ir/l2/l2-static-asset/` referencing `l1-s3` only (depth 1, within max-depth-5).
+- **REQ-25:** One real L2 thin-composition `l2-static-assets` exists under `modules-ir/l2/l2-static-assets/` referencing `l1-s3` only (depth 1, within max-depth-5).
 - **REQ-26:** The Terraform adapter (`adapters/terraform/`) compiles the IR-typed L1 interface to Terraform `variable`/`output` blocks and the L2 thin-composition tree to a Terraform root module; it emits a real `terraform plan` against AWS via OIDC; state is stored in S3 + DynamoDB.
 
 ### Category: v1 Spike — End-to-End
-- **REQ-27:** One end-to-end contract submission (`contracts/spike.yaml` for `l2-static-asset`) flows through: contract schema validation → contract→IR resolution → `terraform plan` (real AWS) → Checkov `PolicyCheckResult` → confidence signal → evidence event written to the DynamoDB outbox.
-- **REQ-28:** Spike verification (`scripts/verify_phase10.sh`) proves the IR-shaped commitments hold: the adapter is the only substrate-specific code; no polyglot mess; the L1 content, contract YML, and thin-composition tree are substrate-agnostic.
+- **REQ-27:** One end-to-end contract submission (`contracts/spike.yaml` for `l2-static-assets`) flows through: contract schema validation → contract→IR resolution → `terraform plan` (real AWS) → Checkov `PolicyCheckResult` → confidence signal → evidence event written to the DynamoDB outbox.
+- **REQ-28:** Spike verification (`scripts/verify_phase10.sh`) proves the IR-shaped commitments hold: the adapter is the only engine-specific code; no polyglot mess; the L1 content, contract YML, and thin-composition tree are engine-agnostic.
 
 ## Out of Scope (v1.1)
 
@@ -124,19 +124,19 @@
 
 ### Category: Consumer Happy Path Documentation
 - **REQ-46:** `README.md` is rewritten so the consumer model is unambiguous: this repo is the platform source; a consumer never clones it. A consumer repo contains only app code + `contract.yaml` referencing the central pipeline + contract. The platform-flow diagram is a mermaid `flowchart TD` (replacing the ASCII art). "L3A"/"L3B" nomenclature is removed from README (single-surface model). "spike" nomenclature is removed from prose (code paths in bash blocks are kept verbatim).
-- **REQ-47:** `docs/CONSUMER_GUIDE.md` (all-caps) replaces `docs/consumer-guide-static-asset.md`. It is generic across all L2 modules (`static-asset` as the worked example), uses mermaid diagrams (model + pipeline flow), documents versioned `uses:` references (floating MAJOR+MINOR tags — bare/`@main` discouraged), scopes prerequisites to consumer-repo bootstrap only (no Terraform/Checkov/boto3/runner-key — those are platform-repo concerns), and documents that the pipeline fetches the ACDL repo at run time via a reusable workflow (consumers never invoke `scripts/run_platform.sh` locally for the happy path).
+- **REQ-47:** `docs/CONSUMER_GUIDE.md` (all-caps) replaces `docs/consumer-guide-static-assets.md`. It is generic across all L2 modules (`static-assets` as the worked example), uses mermaid diagrams (model + pipeline flow), documents versioned `uses:` references (floating MAJOR+MINOR tags — bare/`@main` discouraged), scopes prerequisites to consumer-repo bootstrap only (no Terraform/Checkov/boto3/runner-key — those are platform-repo concerns), and documents that the pipeline fetches the ACDL repo at run time via a reusable workflow (consumers never invoke `scripts/run_platform.sh` locally for the happy path).
 - **REQ-48:** `README.md` Credentials section is rewritten to express the zero-trust target model: consumer repos use OIDC federation (no long-lived keys) with attribute-based authorization (ABAC) — IAM roles + session policies scoped by repository identity and resource-creation tags so a consumer can only view/update resources it created (blast-radius containment). A documented override allows a static key in GitHub Secrets (consumer repo) or `.env.secrets` (local testing), rotated by a platform-managed scheduled pipeline on a daily cadence; when `.env.secrets` is used locally, rotating out of band is the consumer's responsibility.
 
 ### Category: Reusable Deploy Workflow
 - **REQ-49:** A reusable deploy workflow exists as byte-identical `.gitea/workflows/deploy.yml` (Gitea, dev) and `.github/workflows/deploy.yml` (GitHub, production), implementing the central deployment pipeline contract (`pipelines/deploy.yaml` validated against `schemas/deploy-pipeline.schema.json`). It is invoked by consumer repos via `uses: acdl/.gitea/workflows/deploy.yml@vMAJOR.MINOR` (versioned tag). The workflow checks out the consumer repo, checks out the ACDL platform repo into the runner workspace, installs runtime deps (Python, Terraform, Checkov), and invokes `scripts/run_platform.sh` against the consumer's contract path (passed as a workflow input). OIDC is the default auth (`permissions: id-token: write`); a static-key override reads from repository secrets.
-- **REQ-50:** `contracts/static-asset.yaml` uses a versioned `uses:` reference (`@v1.4`, MAJOR+MINOR) — not bare `@v1` or `@main` — as the canonical example the consumer guide points at.
+- **REQ-50:** `contracts/static-assets.yaml` uses a versioned `uses:` reference (`@v1.4`, MAJOR+MINOR) — not bare `@v1` or `@main` — as the canonical example the consumer guide points at.
 - **REQ-51:** `tests/test_pipeline_contract.py` is extended to validate the new deploy workflows: both files exist, are byte-identical, and conform to `schemas/deploy-pipeline.schema.json` (stages present, names match `pipelines/deploy.yaml` stage names). The existing CI-workflow conformance tests continue to pass unchanged.
 
 ## v1.6 (Active — consumer-facing docs restructure + terminology normalization + environments concept)
 
 ### Category: Internal-surface scrub
 - **REQ-52:** No consumer-facing documentation (README.md, docs/**, modules/**/README.md, contracts/**) references `.ciagent/` — it is local CIAgent metadata, never visible to platform engineers or consumers. The README repository-layout table has no `.ciagent/` row. No `.gitea/` references appear in consumer-facing docs (consumers use GitHub only); the README repository-layout table has no `.gitea/workflows/` row.
-- **REQ-53:** `acdl_platform/` is renamed to `platform/` across the directory, all imports in tests/scripts/pipelines/workflows, and all doc references. `grep -R "acdl_platform" .` (excluding `.ciagent/`, `demo/`, `.git/`) returns 0 hits. The test suite passes after the rename.
+- **REQ-53:** `acdl_platform/` is renamed to `core/` across the directory, all imports in tests/scripts/pipelines/workflows, and all doc references. (`platform/` was the original target but shadows Python's stdlib `platform` module — `core/` was chosen to stay importable.) `grep -R "acdl_platform" .` (excluding `.ciagent/`, `demo/`, `.git/`) returns 0 hits. The test suite passes after the rename.
 
 ### Category: Docs site restructure
 - **REQ-54:** `docs/` is restructured into a Jekyll-style GitHub Pages site: `docs/_config.yml`, `docs/index.md` (landing), `docs/modules/` (catalog + per-module Pages-friendly copies), `docs/contracts/index.md`, `docs/pipeline/index.md` + `docs/pipeline/versioning.md`, `docs/environments/index.md`, `docs/consumer-guide.md`, `docs/architecture.md` (consolidated from architecture.md + architecture-v1.0.md, current-architecture only), `docs/vision.md`. No `.ciagent/` links anywhere in `docs/`. Consumer-facing content (modules, contracts, pipeline, versioning) lives in Pages.
@@ -154,6 +154,74 @@
 ### Category: Environments concept + onboarding
 - **REQ-61:** The concept of platform-managed environments is introduced: consumers are not required to provide an AWS account, VPC, subnet, S3 state bucket, or runner key. `docs/environments/index.md` documents that a named environment is a platform-owned AWS account + network + state backend + IAM role surfaced to the consumer via ABAC, selected by name in the contract. The old README environments table (dev/qa/prod/dr) is removed completely. A minimal onboarding scaffold exists: `platform/environments/` with a sample `dev.json` + README, `platform/environment_check.py`, a wire-in at the top of `scripts/run_platform.sh`, a friendly first-run onboarding message when no environment is defined for the repo, and `tests/test_environment_check.py` covering the missing-env and present-env cases.
 
+## v1.7 (Active — production platform + contract ingestion + pipeline maturation)
+
+### Category: Rename + production-ready stack
+- **REQ-62:** `static-assets` is renamed to `static-assets` everywhere (D-048 — including `.ciagent/` historical narrative: verbatim phase descriptions, REQ-25/27/50 text, D-036, RESEARCH.md). `grep -R "static-assets[^s]" .` (excluding `.git/`) returns 0 hits. The module dir `modules/l2/static-assets/` → `modules/l2/static-assets/`; `contracts/static-assets.yaml` → `contracts/static-assets.yaml`; the registry key is renamed; all scripts, tests, docs, and `.ciagent/` files use `static-assets`. The reconstruction test is updated to expect `static-assets` throughout.
+- **REQ-63:** Two new primitives exist: `cloudfront` (distribution + OAC, stack types `aws:cloudfront:distribution` + `aws:cloudfront:originaccesscontrol`) and `waf` (WAFv2 web ACL, stack type `aws:wafv2:webacl`), each with an `interface.json` valid against `schemas/stack.schema.json` and a full README (Resources/Inputs/Outputs/Usage/Compliance/Versioning). Both are registered in `modules/registry.json`. The Terraform adapter `TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP` covers the new stack types.
+- **REQ-64:** The `static-assets` module is augmented to a production-ready stack referencing s3 + cloudfront + waf (depth 1, D-049). `composition.json` wires the s3 bucket regional domain name to the CloudFront origin, and the WAF web ACL ARN to the CloudFront distribution. `schemas/contract.schema.json` is extended for the new module inputs (`price_class`, `viewer_protocol_policy`, `waf_enabled`, `default_ttl`, `max_ttl`). The `uses:`/`ref:` tag advances from `@v1.4` to `@v1.6` (D-056/D-057); floating git tags `v1.6` + `v1` are created pointing at `v1.6.0`.
+
+### Category: Tagging standards + security adapters
+- **REQ-65:** A required-tag set is defined in `schemas/tagging-standard.json` (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`). A Checkov custom YAML rule at `adapters/terraform/policy/custom_rules/acdl_tagging.yaml` fails (severity `medium`) when required tags are missing on taggable resources. `checkov_adapter.py` removes the `_emit_tag_naming_skipped()` placeholder (D-043 closure) and maps `ACDL_TAG_NAMING` as a real rule. `scripts/run_platform.sh` Step 5 passes `--external-checks-dir` to load the custom rule.
+- **REQ-66:** A Wiz adapter stub exists at `adapters/wiz/wiz_adapter.py` translating Wiz API issues → `PolicyCheckResult` records (`engine: "wiz"`, D-052). It degrades gracefully when unconfigured (emits a single `SKIPPED` `WIZ_NOT_CONFIGURED` record). `tests/test_wiz_adapter.py` passes offline with a fixture response. The pipeline invokes it optionally (Step 5b) when `WIZ_API_TOKEN` is set.
+- **REQ-67:** A Kyverno K8s-native adapter exists at `adapters/kyverno/kyverno_adapter.py` translating Kyverno `PolicyReport` results → `PolicyCheckResult` records (`engine: "kyverno"`, D-053). Sample policies exist at `adapters/kyverno/policies/` (disallow-privileged, require-labels, require-image-digests). `tests/test_kyverno_adapter.py` passes offline. The adapter is inactive for Terraform-only stacks (the platform emits Terraform, not K8s manifests); it is ready for the GitOps reconciler roadmap item. `schemas/policy_check_result.schema.json` engine enum includes `checkov | kyverno | opa | wiz`.
+
+### Category: Platform Lambda + contract ingestion
+- **REQ-68:** A platform Lambda (`core/lambda/contract_ingestor.py`) is invoked via a Function URL (IAM auth) and accepts `{ consumerRepo, contractId, contract, environment, action }`. It writes contracts to a DynamoDB table `acdl-contracts` (PK `consumerRepo`, SK `contractId#submittedAt`, SSE via a customer-managed CMK, point-in-time recovery) (D-051). `terraform/platform/main.tf` defines the table, Lambda, Function URL, KMS key, Secrets Manager secret (`acdl/github-token`), and Lambda execution role. `terraform/platform/consumer_invoke_policy.json` grants the consumer's deploy role `lambda:InvokeFunctionUrl` on the Lambda ARN, scoped via ABAC (cross-account). Onboarding grants the Lambda-invoke permission; `docs/environments/index.md` documents this. `tests/test_contract_ingestor.py` passes offline (moto-mocked DynamoDB).
+
+### Category: Deploy outputs + error reporting + stage comments
+- **REQ-69:** `scripts/run_platform.sh` has a `publish-outputs` step (after apply) that writes deploy outputs to SSM Parameter Store as `SecureString` (KMS-encrypted, namespaced `/acdl/{env}/{contractId}/{output_name}`) for runtime-injectable values, and a `comment-outputs` step that posts a structured GitHub PR comment / job summary with human-readable connection strings (D-050). `core/output_publisher.py` implements the SSM write + GitHub comment formatting. `tests/test_output_publisher.py` passes offline (moto + mocked GitHub API). `pipelines/deploy.yaml` + both deploy workflow YAMLs declare the new stages (byte-identical).
+- **REQ-70:** The Lambda `report_error` action (`core/lambda/contract_ingestor.py`) creates a GitHub issue on the platform repo (`acdl/acdl`) via the GitHub API using a token from Secrets Manager (D-055). Idempotent (comments on an existing open issue rather than duplicating). `.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml` (byte-identical) have an `if: failure()` error-report step invoking the Lambda via `aws lambda invoke-function-url` (SigV4-signed). Gitea is excluded (only the CIAgent uses it; platform engineers and consumers use GitHub).
+- **REQ-71:** `.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml` (byte-identical) post a PR comment after every successful pipeline stage (validate-contract, resolve-stack, plan, checkov, confidence, apply, publish-outputs) via `scripts/post_stage_comment.sh` (uses `GITHUB_TOKEN` + `gh api`; no-op when not in a PR context). The comment includes the stage name, status (pass), and key metrics (plan counts, confidence score, outputs published).
+
+### Category: Platform pipelines + release automation
+- **REQ-72:** Three platform pipelines exist: (1) `.github/workflows/platform-test.yml` (PR, stages: lint, unit-test, integration-test — runs `run_platform.sh --check-only` for every sample contract, schema-validation — validates all `schemas/*.json` + `modules/**/interface.json` + `modules/**/composition.json` + `modules/<name>/examples/*.yaml` against their schemas); (2) `.github/workflows/primitives-plan.yml` (PR, plan-only for all L1 primitives via matrix, `scripts/run_primitive_plan.sh`); (3) `.github/workflows/patterns-plan.yml` (PR, plan-only for all L2 modules via matrix, `scripts/run_pattern_plan.sh`).
+- **REQ-73:** `.github/workflows/release.yml` runs on merge to `main`, computes the next semver (PATCH per phase, MINOR on milestone COMPLETE), creates the MAJOR.MINOR.PATCH tag, force-moves the MAJOR.MINOR + MAJOR floating tags, and creates a GitHub release with an auto-generated body (D-057). `tests/test_release_logic.py` passes (unit test the semver computation + tag-update logic with a mocked `git describe`).
+
+### Category: Remove legacy consumer-repos + module examples + RDS primitive
+- **REQ-74:** The legacy consumer-repos directory is deleted entirely (a v1.2 artifact removed in v1.7; references in `.ciagent/` historical narrative are rewritten per D-048). A recursive grep for the legacy directory name (excluding `.git/`) returns 0 hits.
+- **REQ-75:** A new RDS primitive (`modules/l1/rds/`) with an `engine` input (enum: postgres, mysql, etc.) demonstrates multi-engine variation (D-059). Every module (primitives + patterns) has a `modules/<name>/examples/` directory with `simple.yaml` + `complex.yaml` (+ variation files) validated against `schemas/contract.schema.json` in the platform-test pipeline schema-validation stage (D-058). Each module's `README.md` `## Examples` section references + excerpts the validated files. `docs/modules/index.md` + `docs/consumer-guide.md` + `docs/contracts/index.md` are updated with the new module names + examples.
+
+## v1.8 (Complete — P1 remediation + uptime + engineering standards + encryption/deletion-protection by default + decommission + docs)
+
+### Category: P1 Fixes
+- **REQ-76:** WAF adapter emits custom `rules` as nested HCL blocks (not attribute syntax) and honors `default_action` input (allow/block) — P1-4, P1-5 closed.
+- **REQ-77:** L2 composition `outputs[]` array is resolved by `contract_resolver.py` into `stack.outputs`; the adapter emits corresponding `output` blocks — P1-7 closed.
+- **REQ-78:** SSM publisher fails loud when `ACDL_KMS_KEY_ID` is unset (no silent AWS-managed-key fallback); `ACDL_ALLOW_DEFAULT_KMS=1` escape hatch for local testing — P1-3 closed.
+- **REQ-79:** `consumer_invoke_policy` is rendered via Terraform with the caller's live account ID (no `000000000000` placeholder) — P1-6 closed.
+- **REQ-80:** `run_platform.sh` emits adapter output to a per-run temp dir, not committed `terraform/spike/*.tf`; the committed files are removed — P1-8 closed.
+- **REQ-81:** `contract_ingestor.py` reads `GITHUB_API_BASE` env for forge-agnostic API URLs (GitHub + Gitea) — P1-9 closed.
+- **REQ-82:** Deploy workflow static-key override is wired to `configure-aws-credentials` inputs (`access-key`/`secret-key`), not inert env vars — S1 closed.
+
+### Category: Encryption by Default
+- **REQ-83:** A per-stack CMK primitive (`kms-key`) exists with 90-day rotation enabled at creation; one key per L2 deployment; no shared keys across stacks.
+- **REQ-84:** All primitives have encryption by default (`encryption_enabled` NFR, default true) + optional `kms_key_arn` input. CMK is prioritized; managed KMS is the fallback when no CMK is provided.
+- **REQ-85:** L2 modules wire a per-stack CMK child + connect its `kms_key_arn` output to each child's `kms_key_arn` input.
+
+### Category: Deletion Protection by Default
+- **REQ-86:** `deletion_protection` NFR (boolean, default true) on every L1 primitive; the adapter emits `prevent_destroy` lifecycle meta-arg when true.
+- **REQ-87:** L2 modules expose a `features.deletion_protection` flag (default true); consumers can disable via contract `inputs.deletion_protection: false`.
+
+### Category: Uptime Monitoring
+- **REQ-88:** An uptime-kuma L1 primitive exists (ECS Fargate) with: `feature_flag_enabled` (boolean, default true), `monitored_endpoints` (array of HTTP/DNS/TCP checks), `static_checks` (pre-defined health checks), `alert_channels` (Teams webhook, email, SMS, GitHub issues).
+- **REQ-89:** Uptime is deployed by default after any L2 module deploy (separate terraform state, separate terraform run); L2 module outputs (endpoints) are passed to the uptime deployment as `monitored_endpoints`. The uptime URL is published to the consumer via PR comment.
+- **REQ-90:** The `feature_flag_enabled` input (set from consumer contract `inputs.uptime_enabled`, default true) disables the uptime deployment entirely (no resources emitted).
+- **REQ-91:** A `deploy-uptime` pipeline stage is declared in `pipelines/deploy.yaml` + both deploy workflow YAMLs (byte-identical).
+
+### Category: Decommission + CMDB
+- **REQ-92:** A decommission mode on the deploy pipeline (`mode: decommission`) implements a 2-step pipeline: (1) plan/apply to disable deletion protection with an HITL SRE gate, (2) plan/apply with all counts set to 0 with a second HITL SRE gate. Uses the existing deploy pipeline with different behavior.
+- **REQ-93:** A DynamoDB `acdl-change-requests` table serves as the CMDB. The decommission alias accepts a `changeRequestId` input validated via a `validate_change_request` Lambda action (CR status must be `approved`).
+- **REQ-94:** The decommission flow is documented in `docs/CONSUMER_GUIDE.md` (how to request a CR, trigger decommission, HITL gates, what happens).
+
+### Category: Engineering Standards
+- **REQ-95:** `modules/STANDARDS.md` exists with comprehensive L1 + L2 authoring + code review standards (scanned from current modules): required files, interface schema, input/output/NFR conventions, encryption + deletion protection as mandatory NFRs, naming, adapter extension pattern, code review checklist.
+- **REQ-96:** `modules/README.md` catalog index includes all primitives (rds + uptime + kms-key added); `modules/README-TEMPLATE.md` updated with `## NFRs` section.
+
+### Category: Path Documentation
+- **REQ-97:** `schemas/README.md` documents how to write a schema, wire it into the platform, test it in CI, where to write tests, dependencies, and the existing schema catalog.
+- **REQ-98:** `pipelines/README.md` documents how to write a pipeline contract, wire it into workflows, test it, dependencies, and the existing pipeline catalog.
+- **REQ-99:** `adapters/README.md` documents how to write an adapter, wire it into the platform, test it, dependencies, and the existing adapter catalog.
+
 ## Out of Scope (v1.2)
 
 | REQ | Original criterion | Clarified criterion (effective) | Decision |
@@ -172,6 +240,38 @@
 | Adversarial tamper-proofing of evidence | Hash chain is demonstrative; not cryptographically secure against a determined attacker. |
 | Multi-tenant isolation | Out of demo scope. |
 
+## v1.9 (complete — design doc refresh + contract interpolation + per-env CI jobs + stub implementation + P1-1 remediation, tag `v1.9.0`)
+
+### Category: Design Doc Refresh
+- **REQ-100:** `core/hitl_matrix_design.md` is up to date: the "dev-only spike" framing is replaced with the v1.9 wired-gates reality (qa/prod/dr `workflow_dispatch` approval gates + CODEOWNERS routing + outbox-based SoD); the 8-concern attestation matrix is marked implemented (offline-testable subset) with operator-supplied concerns noted; the spike-scope note is updated. No stale "v1.2 wires the gates" language remains.
+- **REQ-101:** `core/audit_ledger_design.md` is up to date: the hash-chain + DynamoDB-outbox path is marked shipped + production (since v1.8); the S3 Object Lock + JWS + async worker + DLQ + daily checkpoints build-out is clearly labeled "Deferred to a future milestone" (D-083); the RPO/RTO table reflects the v1.9 state.
+
+### Category: P1-1 Remediation
+- **REQ-102:** The adapter (`adapters/terraform/adapter.py`) contains no resource-type-specific hardcoded defaults for ECS/ALB/VPC resources — `desired_count`, `launch_type`, `target_type`, `load_balancer_type`, `family`, and `Name` tag values are read from L1 `interface.json` inputs (with defaults declared in the interface). The adapter is a thin translator. An L1 with an overridden `desired_count: 3` emits `desired_count = 3`; the default emits `desired_count = 1` via the interface default, not an adapter hardcode (P1-1 closed).
+
+### Category: Contract Interpolation
+- **REQ-103:** The contract resolver (`core/contract_resolver.py`) expands `${env.<field>}` and `${contract.<field>}` tokens in contract string values (including dotted paths like `${env.state_backend.bucket}`) after schema validation and before IR resolution. The `env` context is the loaded `core/environments/<contract.environment>.json`; the `contract` context is the contract dict. Unresolved tokens raise `ValueError` (fail loud). Sample contracts use naming patterns that include region, account id, and environment (e.g. `acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}`).
+- **REQ-104:** An environment JSON schema `schemas/environment.schema.json` (draft 2020-12) defines the environment file shape (`name`, `account_id`, `region`, `state_backend`, `network`, `runner_role_arn`, `autonomy`, `confidence_threshold`). `core/environments/dev.json` validates against it. `qa.json`, `prod.json`, `dr.json` placeholder bindings exist (autonomy `attested`, thresholds 0.75/0.90/0.95).
+
+### Category: Per-Environment CI Jobs
+- **REQ-105:** Per-environment contract files exist for each sample module (`contracts/static-assets.{dev,qa,prod,dr}.yaml` and `contracts/microservice.{dev,qa,prod,dr}.yaml`), each setting `environment:` to its own name and using interpolation for env-specific values. The existing `contracts/static-assets.yaml` + `contracts/microservice.yaml` remain as the dev default for backwards compatibility.
+- **REQ-106:** The reusable deploy workflow (`.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml`, byte-identical) declares an `environment` `workflow_call` input (enum dev/qa/prod/dr, default empty). When non-empty, `scripts/run_platform.sh --environment <name>` overrides the contract's `environment` field at load time (before interpolation). A consumer repo's caller workflow has one job per environment, each pointing at its respective contract (or the same contract + the env input). Promotion = running the matching job; no `environment:` field editing. `docs/CONSUMER_GUIDE.md` documents the per-env caller workflow pattern.
+
+### Category: Stub Implementation
+- **REQ-107:** `core/separation_of_duties.py` `route_halt_artifact` is a real implementation: publishes to an SNS topic `acdl-sod-halt` (ARN from `ACDL_SOD_HALT_TOPIC_ARN`); when unset, falls back to a structured stderr emission + a `SEPARATION_OF_DUTIES_VIOLATION` event write to the DynamoDB outbox via `outbox_writer.write_event`. No silent print-only stub. The SNS topic is defined in `terraform/platform/main.tf`.
+- **REQ-108:** HITL qa/prod/dr pre-execution attestation gates are wired via `core/hitl_gates.py` (`attest(contract_id, env, approver, evidence)`). The gate records the approver (`gitea.actor` / `github.actor`) to the outbox (`approver_qa` / `approver_prod` / `approver_dr` attributes per `audit_ledger_design.md`), runs the separation-of-duties check on prod, and returns `(ok, reason)`. `scripts/run_platform.sh` calls `hitl_gates.attest` before apply for qa/prod/dr (dev skips). The workflow's `workflow_dispatch` approval input is the trigger.
+- **REQ-109:** The full 8-concern attestation matrix from `hitl_matrix_design.md` §10.4 is implemented in `core/attestation_matrix.py`. Offline-testable concerns (contract NFRs, schema validity, policy pass) run for real; operator-supplied concerns (k6 load test, DR drill, FinOps forecast) accept an uploaded signed evidence artifact validated for freshness + schema, failing loud if missing/expired for prod/dr. `hitl_gates.attest` invokes the matrix for the target env and blocks on any failing concern.
+- **REQ-110:** The Wiz adapter (`adapters/wiz/wiz_adapter.py`) is a real API client: a `WizClient` queries the Wiz GraphQL API (`WIZ_API_TOKEN` + `WIZ_API_URL`) and translates issues → `PolicyCheckResult` records. It degrades gracefully (existing `WIZ_NOT_CONFIGURED` SKIPPED record) when env unset. Offline tests use a recorded GraphQL fixture.
+- **REQ-111:** The Kyverno adapter (`adapters/kyverno/kyverno_adapter.py`) translator is fleshed out: full `PolicyReport` → `PolicyCheckResult` mapping with severity + skip handling. It remains inactive for Terraform-only stacks (guard preserved); a `--kube-version` stub is added for future GitOps. Sample policies already exist.
+
+## Out of Scope (v1.9)
+
+| Feature | Reason |
+|---------|--------|
+| S3 Object Lock + JWS + async worker + DLQ + daily checkpoints (audit ledger build-out) | Requires non-offline-testable AWS infra (Object Lock bucket, KMS signing key, SQS DLQ, Lambda worker). Deferred to a future milestone (D-083). The hash-chain + DynamoDB-outbox path remains the v1.9 production audit record. |
+| Live k6/Gatling load test execution, live DR drill, live FinOps forecast | Operator-supplied evidence artifacts (signed blobs) are accepted + validated; the platform does not run these inline. |
+| Self-service environment provisioning | Adding an environment remains a platform-team action (per `core/environments/README.md`). v1.9 adds the env files + schema, not self-service provisioning. |
+
 ## Traceability
 
 ### v1.0 (prior — demo)
@@ -268,4 +368,68 @@
 | REQ-58 | 21 | complete (v1.6.0) |
 | REQ-59 | 21 | complete (v1.6.0) |
 | REQ-60 | 21 | complete (v1.6.0) |
-| REQ-61 | 21 | complete (v1.6.0) |
+| REQ-61 | 21 | complete (v1.6.0) |
+
+### v1.7 (complete — production platform + contract ingestion + pipeline maturation, tag `v1.7.0`)
+
+| Requirement | Phase | Status |
+|-------------|-------|--------|
+| REQ-62 | 22 | complete (v1.7.0) |
+| REQ-63 | 22 | complete (v1.7.0) |
+| REQ-64 | 22 | complete (v1.7.0) |
+| REQ-65 | 23 | complete (v1.7.0) |
+| REQ-66 | 23 | complete (v1.7.0) |
+| REQ-67 | 23 | complete (v1.7.0) |
+| REQ-68 | 24 | complete (v1.7.0) |
+| REQ-69 | 25 | complete (v1.7.0) |
+| REQ-70 | 25 | complete (v1.7.0) |
+| REQ-71 | 25 | complete (v1.7.0) |
+| REQ-72 | 26 | complete (v1.7.0) |
+| REQ-73 | 26 | complete (v1.7.0) |
+| REQ-74 | 27 | complete (v1.7.0) |
+| REQ-75 | 27 | complete (v1.7.0) |
+
+### v1.8 (complete — P1 remediation + uptime + standards + encryption/deletion-protection by default + decommission + docs, tag `v1.8.0`)
+
+| Requirement | Phase | Status |
+|-------------|-------|--------|
+| REQ-76 | 28 | complete (v1.8.0) |
+| REQ-77 | 28 | complete (v1.8.0) |
+| REQ-78 | 29 | complete (v1.8.0) |
+| REQ-79 | 29 | complete (v1.8.0) |
+| REQ-80 | 30 | complete (v1.8.0) |
+| REQ-81 | 30 | complete (v1.8.0) |
+| REQ-82 | 30 | complete (v1.8.0) |
+| REQ-83 | 31 | complete (v1.8.0) |
+| REQ-84 | 31 | complete (v1.8.0) |
+| REQ-85 | 31 | complete (v1.8.0) |
+| REQ-86 | 32 | complete (v1.8.0) |
+| REQ-87 | 32 | complete (v1.8.0) |
+| REQ-88 | 33 | complete (v1.8.0) |
+| REQ-89 | 33 | complete (v1.8.0) |
+| REQ-90 | 33 | complete (v1.8.0) |
+| REQ-91 | 33 | complete (v1.8.0) |
+| REQ-92 | 34 | complete (v1.8.0) |
+| REQ-93 | 34 | complete (v1.8.0) |
+| REQ-94 | 34 | complete (v1.8.0) |
+| REQ-95 | 35 | complete (v1.8.0) |
+| REQ-96 | 35 | complete (v1.8.0) |
+| REQ-97 | 36 | complete (v1.8.0) |
+| REQ-98 | 36 | complete (v1.8.0) |
+| REQ-99 | 36 | complete (v1.8.0) |
+### v1.9 (complete — design doc refresh + contract interpolation + per-env CI jobs + stub implementation + P1-1 remediation, tag `v1.9.0`)
+
+| Requirement | Phase | Status |
+|-------------|-------|--------|
+| REQ-100 | 39 | complete (v1.9.0) |
+| REQ-101 | 39 | complete (v1.9.0) |
+| REQ-102 | 39 | complete (v1.9.0) |
+| REQ-103 | 40 | complete (v1.9.0) |
+| REQ-104 | 40 | complete (v1.9.0) |
+| REQ-105 | 41 | complete (v1.9.0) |
+| REQ-106 | 41 | complete (v1.9.0) |
+| REQ-107 | 42 | complete (v1.9.0) |
+| REQ-108 | 42 | complete (v1.9.0) |
+| REQ-109 | 42 | complete (v1.9.0) |
+| REQ-110 | 42 | complete (v1.9.0) |
+| REQ-111 | 42 | complete (v1.9.0) |

.ciagent/RESEARCH.md

@@ -106,7 +106,7 @@ step without a long-lived key)
 | (b) Self-hosted OIDC broker | Stand up a tiny OIDC IdP (e.g. `dex`, `oauth2-proxy`, or a custom JWKS endpoint) that the Gitea job authenticates to with its `GITEA_TOKEN` and that issues a JWT minted with a platform signing key; AWS IAM trusts the broker's JWKS. | Workable but heavy for a spike — requires a second always-on service, a signing-key rotation story, and IAM trust plumbing. Better suited to v1.2. |
 | (c) `aws sts assume-role-with-web-identity` with a token from Gitea's own API | Use the job's `GITEA_TOKEN` (a PAT-equivalent, short-lived for the job) as the `WebIdentityToken` to STS. | **Rejected**: STS rejects non-OIDC tokens; `GITEA_TOKEN` is not a JWT, has no `iss`/`sub`/`aud` claims, and AWS IAM has no Gitea OIDC provider to trust. (This is exactly the gap #33681 describes for GCP.) |
 | (d) Short-lived AWS creds via a scheduled credential mint | A platform job (cron) mints `aws sts get-session-token` (or a role-session) and writes the temp creds as a Gitea Actions secret with a TTL ≤ 1h. The spike workflow reads the secret. | Workable, but reintroduces a long-lived key *upstream* (the mint job needs one) and a secret in Gitea — a narrower version of the very thing §12.5 forbids. Acceptable as a documented spike-only waiver if (a) and (b) are both rejected for the spike scope. |
-| (e) LocalStack as an AWS stand-in | Replace real AWS with LocalStack for the spike; no IAM trust needed at all (LocalStack mocks STS). | Workable for the *mechanics* of `terraform plan` but **invalidates REQ-23** ("real AWS via OIDC") and the spike's whole purpose of proving real-AWS feasibility. Reject for the spike; keep as a unit-test substrate only. |
+| (e) LocalStack as an AWS stand-in | Replace real AWS with LocalStack for the spike; no IAM trust needed at all (LocalStack mocks STS). | Workable for the *mechanics* of `terraform plan` but **invalidates REQ-23** ("real AWS via OIDC") and the spike's whole purpose of proving real-AWS feasibility. Reject for the spike; keep as a unit-test engine only. |
 | (f) Documented spike-only waiver: rotate a long-lived key per-run | One IAM access key, stored as a Gitea Actions secret, used by the workflow, rotated (deactivated + new key) after each spike run by the same workflow. | The cleanest *available* option that still touches real AWS. Still violates the *letter* of §12.5 ("long-lived credentials are forbidden") but satisfies the *intent* for a time-boxed spike: the key's useful lifetime equals one workflow run (minutes), not "long-lived." Requires an explicit, logged waiver. |
 | (g) GitHub-hosted mirror pipeline | Run the OIDC-requiring step on GitHub Actions (which supports `id-token: write`) against the same repo mirrored from Gitea. | Rejected: introduces a second forge, violates the "Forge: Gitea" constraint, and defeats the spike's purpose of proving the platform works on Gitea. |
 
@@ -348,7 +348,7 @@ the adapter and the round-trip to Terraform is verified.
 
 - **A-3.1** (0.85): the IR's "nearly isomorphic to Terraform in v1" claim
   (architecture.md §12.1) is the right v1 boundary — build a thin IR, defer
-  substrate-specific expressiveness to v2.
+  engine-specific expressiveness to v2.
 - **A-3.2** (0.80): single-parent-per-child is sufficient for v1 (no L1
   needs two parents in the spike). The "shared keyword for multi-relationship"
   (architecture.md §12.1) is a v2 concern; the v1 schema reserves the field
@@ -453,7 +453,7 @@ the hooks are on the *composition*, not the resource).
   interpolation `module.X.<output>`.
 - `relationship.kind = parent` → the child resource is *inside* the parent
   L1's module block (no Terraform construct; it's a composition hint the
-  adapter uses to order module blocks). For the spike (`l2-static-asset` →
+  adapter uses to order module blocks). For the spike (`l2-static-assets` →
   `l1-s3` only, depth 1) there is exactly one resource and zero
   relationships — the IR still validates, and the adapter produces a
   single `module "s3" { ... }` block.
@@ -704,7 +704,7 @@ exists in *every* environment (including dev).
 | 3 | freshness | 0.10 | Age of the contract's declared validation evidence (e2eSuite, loadTest) relative to submission; in dev, this is the age of the L1/L2 module versions vs. the registry | L1 registry publication timestamps |
 | 4 | source / attestation | 0.15 | Identity of the submitter + the contract's source provenance (git ref, commit SHA, signed-by). In dev (autonomous), this is "any valid submitter" — the gate is *presence*, not *identity*. | Gitea `gitea.actor` + commit SHA |
 | 5 | historical behavior | 0.10 | Platform's observed history for this contract / stack / submitter: prior rollback count, prior policy-fail count. In the spike (first submission), this is a neutral 0.5 (no history). | DynamoDB outbox (prior events for this `contractId` / `stack`) |
-| 6 | NFR conformance | 0.10 | The contract's declared NFRs (latency, throughput, error rate) vs. the platform's measured baseline for this stack. In the spike, `l2-static-asset` declares no NFRs, so this input is "present + neutral 0.5" (the gate is *presence*, not *conformance*). | contract `nfrs` block (optional) + platform baseline (none in spike) |
+| 6 | NFR conformance | 0.10 | The contract's declared NFRs (latency, throughput, error rate) vs. the platform's measured baseline for this stack. In the spike, `l2-static-assets` declares no NFRs, so this input is "present + neutral 0.5" (the gate is *presence*, not *conformance*). | contract `nfrs` block (optional) + platform baseline (none in spike) |
 
 **Weights sum to 1.0.** The base score (before severity penalties) is the
 weighted sum of each input's per-input score (each in [0,1]). The
@@ -909,12 +909,12 @@ of Object Lock + JWS is a scope decision, not a design risk.
   "seq": 1,
   "ts": "2026-07-21T12:00:00Z",
   "stage": "dev",
-  "event": "contract applied: l2-static-asset (confidence 0.82, band pass)",
+  "event": "contract applied: l2-static-assets (confidence 0.82, band pass)",
   "prev_hash": "<sha256 of the genesis event, or GENESIS>",
   "hash": "<sha256 of the canonical JSON of this event with hash=''>",
   "contractId": "uuid",
   "environment": "dev",
-  "stack": "l2-static-asset",
+  "stack": "l2-static-assets",
   "score": 0.82,
   "band": "pass"
 }
@@ -1116,7 +1116,7 @@ a direct formalization.
 **Spike contract (`contracts/spike.yaml`) validates against this:**
 
 ```yaml
-stack: l2-static-asset
+stack: l2-static-assets
 environment: dev
 inputs:
   bucket_name: acdl-spike-bucket
@@ -1447,7 +1447,7 @@ AWS Terraform resources; the adapter `TYPE_MAP` (currently
 | `l1-alb` | `aws:elbv2:loadbalancer`, `aws:elbv2:listener`, `aws:elbv2:targetgroup` | `aws_lb`, `aws_lb_listener`, `aws_lb_target_group` | port, protocol |
 | `l1-ecr` | `aws:ecr:repository` | `aws_ecr_repository` | name |
 
-The IR schema (`schemas/ir.schema.json`) is substrate-agnostic and already
+The IR schema (`schemas/ir.schema.json`) is engine-agnostic and already
 supports arbitrary resource types — no schema change needed, only new
 `interface.json` files + `TYPE_MAP` entries. The `l2-microservice`
 thin-composition references all six (depth ≤ 5).
@@ -1462,4 +1462,454 @@ thin-composition references all six (depth ≤ 5).
 
 ---
 
-*End of RESEARCH.md. Path: `/root/acdl/.ciagent/RESEARCH.md`.*
+## v1.8 Research Addendum
+
+> Phase: research (pre-Phase 28). Milestone: v1.8. Status: active.
+> Researcher: ci-researcher. Autonomy: full.
+> Sources: web (uptime-kuma GitHub, Terraform docs, AWS KMS docs, AWS
+> ECS Fargate docs, GitHub Actions docs) + ACDL codebase analysis.
+
+### RESEARCH TARGET 1 — uptime-kuma deployment on ECS Fargate
+
+**Verdict: ECS Fargate is the most cost-effective cloud-native option
+for deploying uptime-kuma, consistent with the existing platform
+primitives (ecs-cluster, ecs-service, alb).**
+
+Findings (verified 2026-07-22):
+
+1. **uptime-kuma Docker image:** `louislam/uptime-kuma:1` (v1) or
+   `louislam/uptime-kuma:2` (v2, latest stable 2.4.0 as of 2026-05-31).
+   The container listens on port 3001. Data is stored in `/app/data`
+   (SQLite + uploaded files). NFS is not supported for the data volume;
+   EFS is the AWS-native equivalent and works with ECS Fargate.
+
+2. **Monitoring capabilities:** HTTP(s), TCP, HTTP(s) Keyword, HTTP(s)
+   JSON Query, WebSocket, Ping, DNS Record, Push, Steam Game Server,
+   Docker Containers. 20-second intervals minimum. Certificate info.
+   Proxy support. 2FA support.
+
+3. **Notification services (90+):** Telegram, Discord, Gotify, Slack,
+   Pushover, Email (SMTP), Microsoft Teams (via webhook), and many
+   others. For the ACDL primitive, we expose: Teams webhook, email
+   (SMTP), SMS (via SNS or an external gateway), and GitHub issues
+   (via the GitHub API).
+
+4. **ECS Fargate deployment shape:**
+   - Task definition: 1 container (`louislam/uptime-kuma:1`), port 3001,
+     CPU 256 (.25 vCPU), Memory 512 (.5 GB) — minimal cost (~$5/mo
+     at us-east-1 on-demand pricing for .25 vCPU + .5 GB running 24/7).
+   - EFS volume for `/app/data` (persistent storage across task
+     restarts; Fargate + EFS is the standard pattern for stateful
+     containers).
+   - ALB + listener for a stable public URL (the uptime dashboard).
+   - CloudWatch log group (encrypted with the per-stack CMK).
+
+5. **Endpoint seeding:** uptime-kuma has a REST API (socket.io-based).
+   The platform can seed monitors by either:
+   - (a) Passing `UPTIMA_KUMA__monitors` env var (JSON array) consumed
+     by a startup script — but uptime-kuma does not natively read env
+     for monitor config.
+   - (b) A post-deploy seeding script that calls the uptime-kuma API
+     (`POST /api/monitor`) to create monitors from the `monitored_endpoints`
+     input. This is the cleaner approach — the platform runs a Python
+     script after the ECS service is up that creates monitors via the
+     API.
+   - **Recommendation:** (b) — a `scripts/seed_uptime_monitors.py` that
+     reads the `monitored_endpoints` from the stack outputs + calls the
+     uptime-kuma API. This is testable offline (mocked API) and
+     decouples container startup from monitor configuration.
+
+6. **Separate terraform state:** The uptime stack uses a separate S3
+   key prefix (`uptime/{consumerRepo}/{contractId}/`) so it is
+   independent of the consumer stack's state. The uptime stack has its
+   own VPC + ALB + ECS cluster (or shares the consumer's — design
+   decision: **separate** to avoid state coupling, per the requirement
+   "separate terraform run, with a separate state").
+
+7. **Feature flag:** The `feature_flag_enabled` input (set from the
+   consumer contract `inputs.uptime_enabled`, default true) controls
+   whether the `deploy-uptime` pipeline stage runs. When false, the
+   stage is skipped entirely (no resources emitted, no API calls).
+
+### RESEARCH TARGET 2 — Terraform prevent_destroy lifecycle
+
+**Verdict: `lifecycle { prevent_destroy = true }` is the correct
+Terraform mechanism for deletion protection. It prevents `terraform
+destroy` from destroying the resource without first setting
+`prevent_destroy = false`.**
+
+Findings (verified 2026-07-22):
+
+1. **`prevent_destroy`** is a meta-argument inside a `lifecycle {}`
+   block within a resource. When set to `true`, any Terraform plan
+   that would destroy the resource will fail with an error. To destroy,
+   the user must first set `prevent_destroy = false` and apply, then
+   destroy.
+
+2. **This is exactly the 2-step decommission pattern the user
+   requested:** Step 1: set `deletion_protection = false` (which the
+   adapter translates to `prevent_destroy = false`) + apply. Step 2:
+   set all counts to 0 + apply (which destroys the resources now that
+   prevent_destroy is false).
+
+3. **Adapter emission:** The adapter should emit `lifecycle { prevent_destroy = true }`
+   inside each resource block when the `deletion_protection` NFR is
+   true. When false, omit the `lifecycle` block (or set
+   `prevent_destroy = false`). This is a per-resource meta-argument,
+   not a provider-level setting.
+
+4. **RDS special case:** RDS already has a `deletion_protection`
+   argument on `aws_db_instance` (not a lifecycle meta-arg). The
+   adapter should emit BOTH: the `deletion_protection` argument (for
+   the RDS API-level protection) AND `lifecycle { prevent_destroy = true }`
+   (for the Terraform-level protection). This is defense-in-depth.
+
+### RESEARCH TARGET 3 — AWS KMS key rotation
+
+**Verdict: `enable_key_rotation = true` on `aws_kms_key` enables
+automatic annual rotation (AWS rotates the key material annually).
+For 90-day rotation, a custom key rotation policy is needed (AWS
+managed rotation is annual only; 90-day requires a manual rotation
+schedule or a custom multi-region key + rotation Lambda).**
+
+Findings (verified 2026-07-22):
+
+1. **`aws_kms_key`** with `enable_key_rotation = true` enables AWS's
+   automatic key material rotation. AWS rotates the backing key material
+   annually (365 days). This is the simplest option and is the AWS
+   best practice for most use cases.
+
+2. **90-day rotation:** AWS does not support custom rotation periods
+   for managed keys. To achieve 90-day rotation:
+   - (a) Use `aws_kms_key` with `enable_key_rotation = true` (annual
+     AWS-managed rotation) + a CloudWatch Events rule that triggers a
+     Lambda every 90 days to create a new key + update the alias. This
+     is complex and overkill for v1.8.
+   - (b) Accept annual AWS-managed rotation as the default and document
+     that 90-day rotation requires a custom rotation pipeline (roadmap
+     item). The `enable_key_rotation = true` is the v1.8 implementation;
+     the 90-day requirement is a roadmap enhancement.
+
+   **Recommendation:** (b) — `enable_key_rotation = true` (AWS-managed
+   annual rotation) as the v1.8 implementation. The 90-day requirement
+   is documented as a roadmap item (custom rotation Lambda). The NFR
+   `enable_rotation` (default true) controls the `enable_key_rotation`
+   argument. This is pragmatic; annual rotation is AWS's best practice
+   and 90-day is a future enhancement.
+
+3. **Per-stack CMK pattern:** Each L2 deployment creates its own
+   `aws_kms_key` + `aws_kms_alias` (alias/acdl-<stack-name>-<env>).
+   The key is tagged with `acdl:owner` + `acdl:environment`. All
+   primitives in the stack reference this key via `kms_key_arn`.
+   No shared keys across stacks.
+
+4. **Managed KMS fallback:** When a primitive is deployed standalone
+   (L1 without an L2 CMK), the adapter uses `alias/aws/<service>`
+   (e.g. `alias/aws/s3`, `alias/aws/rds`). This is the AWS-managed
+   key for that service. The adapter emits a stderr warning when
+   falling back. The `kms_key_arn` input is optional; the
+   `encryption_enabled` NFR defaults to true.
+
+### RESEARCH TARGET 4 — Forge-agnostic API URLs (P1-9)
+
+**Verdict: GitHub and Gitea have compatible issue APIs but different
+search endpoints. A `GITHUB_API_BASE` env var + `_forge_type()`
+helper branches the search URL.**
+
+Findings (verified 2026-07-22):
+
+1. **GitHub API:** `https://api.github.com/search/issues?q=...` for
+   search; `https://api.github.com/repos/{owner}/{repo}/issues` for
+   create; `https://api.github.com/repos/{owner}/{repo}/issues/{n}/comments`
+   for comments.
+
+2. **Gitea API:** `https://git.cloudinit.dev/api/v1/repos/{owner}/{repo}/issues?...`
+   for search (no `/search/issues` endpoint — issues are listed via
+   the repo issues endpoint with query params); `https://git.cloudinit.dev/api/v1/repos/{owner}/{repo}/issues`
+   for create; `https://git.cloudinit.dev/api/v1/repos/{owner}/{repo}/issues/{n}/comments`
+   for comments.
+
+3. **Detection:** If `GITHUB_API_BASE` contains `/api/v1`, it's Gitea;
+   otherwise it's GitHub. The `_forge_type()` helper returns `"gitea"`
+   or `"github"` based on this. The search URL is branched accordingly;
+   the create + comment URLs are the same pattern (`{base}/repos/{owner}/{repo}/issues`).
+
+4. **Auth:** Both use `Authorization: token <token>` header. GitHub
+   also accepts `Authorization: Bearer <token>`; Gitea uses `token`.
+   The existing `token` header works for both.
+
+### RESEARCH TARGET 5 — DynamoDB as CMDB for change requests
+
+**Verdict: A DynamoDB `acdl-change-requests` table is consistent with
+the existing platform Lambda + DynamoDB pattern (D-051). The
+`validate_change_request` Lambda action queries the table + asserts
+status=approved.**
+
+Findings (verified 2026-07-22):
+
+1. **Table schema:** PK `changeRequestId` (string), SK `submittedAt`
+   (string). Attributes: `consumerRepo`, `contractId`, `status`
+   (enum: `requested|approved|rejected|executed`), `requestedBy`,
+   `approvedBy`, `submittedAt`, `executedAt`.
+
+2. **Validation flow:** The decommission pipeline's
+   `validate-change-request` stage invokes the Lambda with
+   `action: validate_change_request`, `changeRequestId: <id>`,
+   `consumerRepo: <repo>`. The Lambda queries the table; if the item
+   exists + `status == "approved"` + `consumerRepo` matches, returns
+   200 with the CR details. Otherwise returns 403.
+
+3. **Terraform:** Add the table to `terraform/platform/main.tf` with
+   SSE via the platform CMK + point-in-time recovery (matching the
+   `acdl-contracts` table pattern from D-051).
+
+### RESEARCH TARGET 6 — Module engineering standards (scan of current modules)
+
+**Verdict: The current modules follow a consistent pattern that can
+be codified into standards. Key patterns identified:**
+
+1. **L1 required files:** `interface.json`, `instance.json`,
+   `README.md`, `examples/simple.yaml`, `examples/complex.yaml`.
+   Multi-resource L1s add `resources[]` + `intra_refs[]` to
+   `interface.json`.
+
+2. **L2 required files:** `composition.json`, `README.md`,
+   `examples/simple.yaml`, `examples/complex.yaml`. No `instance.json`.
+
+3. **Interface shape:** `name`, `version`, `kind` ("l1"|"l2"),
+   `type` (L1 only, `aws:<service>:<kind>`), `description`,
+   `inputs` (object keyed by name), `outputs` (object keyed by name),
+   `nfrs` (object keyed by name). Multi-resource L1s add `resources[]`
+   (array of `{type, description, inputs[], outputs[]}`) +
+   `intra_refs[]` (array of `{from, to}`).
+
+4. **Input shape:** `{type, description, required, [default], [enum]}`.
+   Output shape: `{type, description}`. NFR shape:
+   `{type, description, default}`.
+
+5. **NFR conventions (v1.8 additions):** Every L1 MUST have
+   `deletion_protection` (boolean, default true) + `encryption_enabled`
+   (boolean, default true) NFRs. L2 modules MUST expose
+   `features.deletion_protection` (default true) +
+   `features.uptime_enabled` (default true).
+
+6. **Registry:** Every module MUST be registered in
+   `modules/registry.json` at its semver. Entry:
+   `{"interface": "<path>", "published_at": "<iso>", "deprecated": false}`.
+
+7. **Adapter extension:** 3-table pattern (TYPE_MAP + INPUT_MAP +
+   OUTPUT_MAP) + specialized `_emit_resource` branches for complex
+   resources (nested blocks like `origin {}`, `rules {}`,
+   `default_cache_behavior {}`).
+
+8. **README structure:** `# <name> — <description>`, `## Resources`,
+   `## Inputs`, `## Outputs`, `## NFRs`, `## Usage`, `## Compliance
+   extension points`, `## Examples`, `## Versioning`.
+
+9. **Catalog index gap:** `modules/README.md` Primitives table is
+   missing `rds` (flagged during scan). Must be fixed in Phase 35.
+
+### Decisions surfaced (v1.8)
+
+| ID | Decision | Rationale | Confidence | Alternatives |
+|----|----------|-----------|------------|--------------|
+| **D-073** | uptime-kuma v1 (`louislam/uptime-kuma:1`) as the default container image. | v1 is stable + widely deployed. v2 (2.4.0) is newer but has breaking changes. v1 is the safer default; consumers can override via `container_image` input. | 0.85 | v2 (breaking changes risk); pin to a specific v1 tag (maintenance burden). |
+| **D-074** | Monitor seeding via post-deploy API script (`scripts/seed_uptime_monitors.py`), not env vars. | uptime-kuma does not natively read env for monitor config. A post-deploy script calling the API is cleaner + testable offline. | 0.90 | Env var config (not supported by uptime-kuma); manual config (defeats automation). |
+| **D-075** | KMS rotation = `enable_key_rotation = true` (AWS-managed annual). 90-day rotation is a roadmap item (custom rotation Lambda). | AWS does not support custom rotation periods for managed keys. Annual is the AWS best practice. 90-day requires a custom Lambda + CloudWatch Events rule — overkill for v1.8. | 0.80 | Custom rotation Lambda (complex, overkill); no rotation (violates requirement). |
+| **D-076** | uptime stack = separate VPC + ALB + ECS cluster (not shared with consumer stack). | Requirement says "separate terraform run, with a separate state". Sharing the consumer's VPC/ALB would couple the states. Separate infra is cleaner + isolates the uptime stack's lifecycle. | 0.85 | Share consumer's VPC/ALB (state coupling); use App Runner (new service type). |
+| **D-077** | EFS volume for uptime-kuma `/app/data` (persistent storage across task restarts). | Fargate + EFS is the standard pattern for stateful containers. NFS is not supported by uptime-kuma, but EFS is NFS-compatible + works with Fargate. | 0.90 | S3-backed (uptime-kuma doesn't support S3); no persistent storage (data lost on restart). |
+
+---
+
+## v1.9 Research Addendum (Phase 0, 2026-07-23)
+
+> Milestone v1.9. Researcher: lead-developer. Autonomy: full. The v1.9
+> scope is well-grounded in the existing codebase; the research is a
+> focused addendum covering the four new implementation domains
+> (interpolation, per-env workflow inputs, Wiz GraphQL, attestation
+> matrix freshness validation) + the design-doc drift audit.
+
+### RA-1 — Contract interpolation prior art + syntax choice (D-081)
+
+**Finding:** Variable expansion in declarative manifests is a solved
+pattern. Terraform uses `${var.x}` / `${local.x}`; Helm uses `{{ .Values.x }}`;
+GitHub Actions uses `${{ }}`; CloudFormation uses `!Ref` / `!Sub`. The
+contract schema is YAML validated by `jsonschema` — the schema does not
+inspect string *contents*, so any token syntax is schema-safe.
+
+**Choice:** `${env.<field>}` + `${contract.<field>}` (D-081). Rationale:
+- Shell-style `${...}` is the most familiar to the platform's audience
+  (DevOps engineers comfortable with Terraform/HCL).
+- Dotted paths (`${env.state_backend.bucket}`) mirror Python attribute
+  access and the existing `wire["from"]` syntax (`contract.inputs.x`,
+  `<childId>.outputs.y`).
+- No conflict with YAML (`${}` inside a YAML string is a literal until
+  the resolver expands it) or with `jsonschema` (string content is not
+  schema-constrained).
+- Jinja `{{ }}` was considered (supports future filters) but rejected —
+  the contract is a data file, not a template; filters would invite
+  logic-in-config anti-patterns.
+
+**Implementation shape:** a single `_expand_vars(value, context)`
+recursive walker in `core/contract_resolver.py`. Context =
+`{"env": <loaded env json>, "contract": <contract dict>}`. Unknown
+token → `ValueError` with the token text (fail loud, no silent
+passthrough — consistent with the P1-3 SSM fail-loud precedent).
+
+**Confidence:** 0.92. Risk: none — the expansion is post-schema-validation
+and pre-IR-resolution, so it cannot break the schema or the adapter.
+
+### RA-2 — GitHub Actions `workflow_call` `environment` input + per-env jobs (D-082)
+
+**Finding:** GitHub Actions `workflow_call` inputs support `type: string`
+with no enum constraint at the workflow-call layer (enum constraints
+exist only for `choice`-typed *workflow_dispatch* inputs). The deploy
+workflow already uses `workflow_call` with `contract` + `mode` +
+`changeRequestId` string inputs. Adding an `environment` string input
+(default empty, validated by `run_platform.sh`) is a one-line addition.
+
+**Per-env job pattern:** the consumer repo's *caller* workflow
+(`.github/workflows/deploy-<env>.yml`) does:
+```yaml
+jobs:
+  deploy-qa:
+    uses: acdl/.github/workflows/deploy.yml@v1.9
+    with:
+      environment: qa
+      contract: .acdl/static-assets.qa.yaml
+```
+One caller workflow per environment = one CI job per environment. The
+`environment:` field in the contract is not edited for promotion;
+promotion = running the qa caller. The hybrid model (D-082) also lets a
+single contract be promoted via the `environment` input alone.
+
+**Gitea caveat:** Gitea Actions supports `workflow_call` (reuses the
+GitHub Actions workflow YAML). The `environment` input works identically.
+Gitea has no Environments API (D-013/D-042) — the HITL gate is the
+`workflow_dispatch` approval-input fallback (already documented in
+`hitl_matrix_design.md`). For `workflow_call` (reusable), the caller
+workflow's `workflow_dispatch` trigger carries the approval input.
+
+**Confidence:** 0.90. Risk: the Gitea `workflow_call` + approval-input
+combination needs the caller to be `workflow_dispatch`-triggered (not
+`workflow_call`-triggered) for the gate to fire — documented in Phase 41.
+
+### RA-3 — Wiz GraphQL API shape (D-0xx, REQ-110)
+
+**Finding:** Wiz exposes a GraphQL API at `<WIZ_API_URL>/graphql`. Auth
+= `Authorization: Bearer <WIZ_API_TOKEN>`. The primary query for issues:
+```graphql
+query IssuesQuery($filterBy: IssueFilter) {
+  issues(filterBy: $filterBy) {
+    nodes { id severity title entity { name type } control { name }
+            createdAt }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+```
+Wiz severity enum: `CRITICAL | HIGH | MEDIUM | LOW | INFORMATIONAL`.
+Mapping to `PolicyCheckResult`:
+- `engine: "wiz"`
+- `ruleId: <control.name>` (or `WIZ_<issue.id>` fallback)
+- `severity: <wiz severity lowercased>`
+- `status: FAIL` (Wiz issues are findings; pass = no issues returned)
+- `message: <title>`
+- `resource: <entity.name>`
+
+**Graceful degrade:** when `WIZ_API_TOKEN` or `WIZ_API_URL` unset → emit
+the existing single `SKIPPED` `WIZ_NOT_CONFIGURED` record (no network
+call). Offline tests use a recorded JSON fixture (no live Wiz tenant).
+
+**Confidence:** 0.80. Risk: Wiz API version drift — the query shape is
+stable as of Wiz API v2 (2026), but the fixture is the test's source of
+truth, not the live API.
+
+### RA-4 — Attestation matrix freshness validation (D-084, REQ-109)
+
+**Finding:** The 8 concerns in `hitl_matrix_design.md` §10.4 have
+declared freshness windows (24h, 7d, 30d, 90d, 180d). Operator-supplied
+evidence (load test, DR drill, FinOps forecast, runbook) is uploaded as
+a signed blob. The matrix validates:
+1. **Presence** — the evidence artifact exists for the target env.
+2. **Freshness** — `artifact.timestamp` is within the declared window.
+3. **Schema** — the artifact matches a per-concern JSON schema (e.g.
+   load-test artifact has `p99_latency`, `throughput`, `pass_rate`).
+4. **Signature** (when `ACDL_ATTESTATION_SIGNING_KEY_ID` set) — JWS
+   detached signature verification against a platform KMS key. When
+   unset (dev/CI), signature verification is skipped (offline-testable).
+
+**Offline-testable concerns** (run for real, no operator input):
+- Contract NFRs (the platform's own contract validator).
+- Schema validity (jsonschema).
+- Policy pass (Checkov/Wiz/Kyverno `PolicyCheckResult` records).
+
+**Operator-supplied concerns** (require uploaded artifact):
+- Functional correctness (e2e suite report).
+- Performance baseline (k6/Gatling report).
+- Security posture (Trivy/Snyk scan + Security signature).
+- Operational readiness (runbook/dashboard/oncall/alerts).
+- Incident response (Sev-1 drill record).
+- Capacity/cost (FinOps forecast).
+- Resilience (DR drill, chaos report, backup verification).
+- dr-region deploy (dr drill report).
+
+**Confidence:** 0.88. Risk: the signature verification path is only
+exercised when a signing key is configured (dev/CI skips it); production
+deployment must set `ACDL_ATTESTATION_SIGNING_KEY_ID`.
+
+### RA-5 — Design doc drift audit (REQ-100, REQ-101)
+
+**`core/hitl_matrix_design.md` drift:**
+- Status block says "v1.2 wires the gates" — stale (v1.9 wires them).
+- "Spike scope note" says "the spike is dev-only; HITL is not exercised"
+  — stale (v1.9 exercises qa/prod/dr).
+- §10.4 matrix is presented as design-only — v1.9 implements the
+  offline-testable subset (D-084).
+- D-042 approver-identity mechanics are still accurate (Gitea has no
+  Environments API; `gitea.actor` is the approver of record).
+
+**`core/audit_ledger_design.md` drift:**
+- "Spike scope (D-041)" says "Phases 08-10 implement" — stale (the
+  outbox is shipped + production since v1.8).
+- "v1.2 build-out" (S3 Object Lock + JWS + worker + DLQ + checkpoints)
+  never shipped; v1.9 defers it explicitly (D-083).
+- The outbox item shape is still accurate; the `approver_qa`/
+  `approver_prod` attributes are populated by v1.9's `hitl_gates.attest`.
+
+**Confidence:** 0.95. Risk: none — doc-only.
+
+### RA-6 — P1-1 adapter defaults audit (D-085, REQ-102)
+
+**Hardcoded defaults found in `adapters/terraform/adapter.py`:**
+- `desired_count = 1` (ECS service, 2 occurrences: line 238, 481).
+- `launch_type = "FARGATE"` (ECS service, line 239, 482).
+- `family = "app"` (task def, line 254 — reads `inputs.get("family", "app")`
+  so partially parameterized; the `"app"` default should move to the
+  interface).
+- `target_type = "ip"` (ALB target group, line 274).
+- `load_balancer_type = "application"` (ALB, line 272).
+- `Name = "acdl-microservice-rt"` (route table, line 283) + `Name = ...`
+  tags on VPC/IGW (lines 515, 542 `name = "app"`).
+
+**Fix:** add `desired_count`, `launch_type`, `family`, `target_type`,
+`load_balancer_type`, `name` (VPC/IGW/RT) to the corresponding L1
+`interface.json` `inputs` with defaults. The adapter reads
+`inputs.get("<name>", <default>)` — but the resolver should populate
+the default from the interface so the adapter reads `inputs["<name>"]`
+with a fallback only for safety. Tests assert an override emits the
+overridden value.
+
+**Confidence:** 0.90. Risk: low — the v1.1 S3 regression test must
+still pass (S3 has none of these inputs).
+
+### Decisions surfaced (v1.9)
+
+| ID | Decision | Rationale | Confidence | Alternatives |
+|----|----------|-----------|------------|--------------|
+| **D-087** | Interpolation expansion is recursive over dicts + lists + strings (not just top-level inputs). | A nested input like `env: { DATABASE_URL: "acdl-${env.environment}-db" }` should expand too. | 0.90 | Top-level only (misses nested maps). |
+| **D-088** | The `environment` workflow_call input overrides the contract's `environment` field *before* schema validation, so the schema sees the overridden value. | Interpolation context depends on the resolved environment; override must happen pre-validation so `${env.environment}` is consistent. | 0.92 | Override post-validation (inconsistent interpolation context). |
+| **D-089** | Attestation artifact signature verification is skipped when `ACDL_ATTESTATION_SIGNING_KEY_ID` is unset (dev/CI); required for prod/dr. | Offline tests cannot sign with a real KMS key. The skip is explicit + logged. | 0.85 | Always require signature (breaks offline tests). |
+
+---
+
+*End of RESEARCH.md v1.9 addendum.*

.ciagent/REVIEW.md

@@ -1,106 +1,165 @@
-# ACDL v1.2 Milestone — Multi-Persona Code Review
+# ACDL v1.9 Milestone — Multi-Persona Code Review
 
 **Reviewer:** ci-code-reviewer (model: glm-5.2)
-**Scope:** v1.2 milestone — Phases 11–16 (tags v1.2.1..v1.2.6), diff `v1.2.0..HEAD`
-**Date:** 2026-07-21
-**Verdict:** **READY TO SHIP** — 1 P0 (operator action, non-code), 1 P1 (adapter hardening for v1.3)
+**Scope:** v1.9 milestone — Phases 39–42 (tags v1.8.1..v1.8.4), diff `v1.8.0..HEAD`
+**Date:** 2026-07-23
+**Verdict:** **READY TO SHIP** — 1 P0 auto-fixed, 1 P1 auto-fixed, 3 P1 flagged for post-hoc
+
+> **Note (D-086):** This REVIEW.md was reconstructed at v1.9 complete.
+> The previous content was the v1.2 milestone review (v1.3–v1.8 reviews
+> were not persisted to this file). No git history was rewritten; the
+> v1.2 review is preserved in git history at the v1.2 review commit.
+>
+> **Review pass 2 (post-complete):** this review was re-run after the
+> milestone COMPLETE to catch issues the initial self-review missed. The
+> P0 (approver injection) and P1 (future-dated freshness) were auto-fixed.
 
 ---
 
 ## Summary
 
-v1.2 hardens the v1.1 spike, simplifies the setup, rewrites the docs, and
-takes the platform to a real ECS Fargate microservice deployment. 6 phases
-shipped (v1.2.1–v1.2.6): research + README, NFR hardening + simplification,
-6 ECS L1s + adapter generalization, l2-microservice + contract schema +
-resolver wiring, consumer repo + terraform apply (blocked by IAM),
-capstone e2e.
+v1.9 closes four gaps left by v1.8 (user-directed, 2026-07-23): stale
+design docs, no contract interpolation, promotion requires editing the
+`environment` field, and unimplemented stubs. It also closes P1-1
+(adapter hardcoded defaults, deferred from v1.2). 4 phases shipped
+(39–42): design-doc refresh + P1-1 parameterization, contract
+interpolation + env schema, per-environment CI jobs, stub implementation.
 
 ## P0 issues
 
-### P0-IAM (operator action, NOT a code fix)
-**The `terraform apply` (Phase 15) is blocked by the live IAM policy.** The
-Phase 12 `spike_runner_policy.json` expansion (ECS/ECR/ELB/IAM/EC2) was
-committed to the repo but never pushed to the live AWS account — the root
-key was deactivated per D-034, and the `acdl-spike-runner` user cannot
-self-elevate via `iam:PutUserPolicy`.
+### P0-INJECT (auto-fixed)
+**Shell→Python code injection via `GITHUB_ACTOR` in `scripts/run_platform.sh`
+Step 7b (HITL gate).** The approver identity was interpolated directly
+into a Python string literal (`attest('$CONTRACT_ID', '$RESOLVED_ENV',
+'$APPROVER' ...)`). `GITHUB_ACTOR` (and `GITEA_ACTOR`) are attacker-
+controllable in some CI configurations; a username containing `'; import
+os; os.system(...); y='` would execute arbitrary Python.
 
-**Unblock step (operator):**
-```bash
-ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID=<root-or-admin-key> \
-ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY=<root-or-admin-secret> \
-python3 terraform/bootstrap/create_iam_user.py
-```
-This re-PUTs the expanded policy (idempotent). Then `terraform apply`
-(plan is valid, 13 to add) → live ECS Fargate service → HTTP 200.
-
-**Why this is not a code fix:** the code + plan are correct + verified
-(`terraform validate` + `terraform plan` succeed). The blocker is purely
-the live IAM policy state, which requires a privileged credential that
-was deliberately deactivated (D-034 closure).
+**Fix (auto-applied):** the approver, contract id, and env are now passed
+as environment variables to the Python subprocess
+(`ACDL_HITL_CONTRACT_ID`, `ACDL_HITL_ENV`, `ACDL_HITL_APPROVER`) and read
+via `os.environ[...]` inside the Python code — no string interpolation of
+user-controllable values.
 
 ## P1 issues
 
-### P1-1 (adapter hardening, deferred to v1.3)
-The adapter's ECS/ALB/VPC emission includes several resource-type-specific
-defaults (`desired_count = 1`, `launch_type = "FARGATE"`, `target_type = "ip"`,
-`load_balancer_type = "application"`, `tags = { Name = ... }`, `family = "app"`).
-These are pragmatic for the v1.2 spike but should be parameterized via the
-L1 interfaces in v1.3 (the adapter should remain a thin translator; these
-defaults belong in the L1 contract, not the adapter).
+### P1-FRESHNESS (auto-fixed)
+**`core/attestation_matrix.py` `_is_fresh` accepted future-dated
+artifacts.** A `timestamp` in the future produced a negative `age`, and
+`age.days <= window_days` evaluated `True` for negative values, so a
+backdated/future artifact bypassed freshness validation.
+
+**Fix (auto-applied):** added a `age.total_seconds() < 0` guard that
+rejects future-dated artifacts. Test added
+(`test_freshness_rejects_future_dated_artifact`).
+
+### P1-WIZ-ERRORS (flagged for post-hoc)
+**`adapters/wiz/wiz_adapter.py` `WizClient._post` does not check for
+GraphQL `errors` in the response.** A GraphQL API returns
+`{data: ..., errors: [...]}`; if `errors` is present, `data.issues` can
+be `null` and `.get("nodes", [])` silently masks the error as an empty
+list (which then emits `WIZ_NOT_CONFIGURED`). Should surface GraphQL
+errors as a failed PolicyCheckResult or raise.
+
+### P1-WIZ-SSRF (flagged for post-hoc)
+**`WizClient._post` performs no SSRF validation on `WIZ_API_URL`.** A
+malicious `WIZ_API_URL` env var could target an internal endpoint. The
+URL is operator-supplied (not consumer-controllable), so the risk is
+low, but a allowlist/scheme check (`https://`) would harden it.
+
+### P1-OBSOLETE-CHECK (flagged for post-hoc)
+**`core/contract_resolver.py` `_load_env` duplicates
+`core/environment_check.load`.** The duplication was intentional (so the
+resolver works as both a package import and a script), but the two can
+drift. A future refactor should extract a shared helper that both
+import safely.
 
 ## Per-lens review
 
 ### Correctness
-- The contract→IR→adapter pipeline produces valid HCL (`terraform validate`
-  passes; `terraform plan` succeeds with 13 to add).
-- The v1.1 S3 regression passes (byte-identical `main.tf`) across all
-  adapter changes (ref emission, JSON-string detection, ECS service
-  network_configuration/load_balancer, listener default_action, target
-  group defaults, VPC tags, IGW emission, managed_policy_arns).
-- The `intra_refs` mechanism (L1-declared refs between sub-resources of
-  the same L1) correctly resolves subnet→vpc.vpc_id + routetable→vpc.vpc_id.
-- The resolver's array-form wires + child→child `ref:` emission are
-  backward-compatible (v1.1 single-object wires still work).
+- The contract interpolation (`_expand_vars`) is recursive over
+  dicts/lists/strings; unknown tokens raise `ValueError` (fail loud).
+  Expansion is post-schema-validation, pre-IR-resolution — the schema
+  sees raw tokens (valid strings), the resolver sees concrete values.
+- The `environment_override` (D-088) is applied BEFORE schema validation
+  so the interpolation context is consistent.
+- P1-1: the adapter reads `desired_count`, `launch_type`, `family`,
+  `target_type`, `load_balancer_type` from inputs (with interface
+  defaults). The resolver's `child_input_map` routes wires to the
+  sub-resource that declares the input (desired_count → aws:ecs:service,
+  family → aws:ecs:task_definition). The v1.1 S3 regression is preserved
+  (byte-identical `main.tf` for S3-only stacks).
+- The HITL attestation gate records the approver to the outbox, runs SoD
+  on prod (blocks on `approver_qa == approver_prod`), invokes the
+  attestation matrix. Dev skips (autonomous).
+- The attestation matrix's freshness validation uses the §10.4 windows;
+  signature verification skips when the signing key is unset (D-089) and
+  is required when set.
+- The Wiz real client uses the GraphQL API with pagination; graceful
+  degrade when unconfigured.
+- The Kyverno translator handles pass/fail/skip/warn + severity + skip-
+  with-reason + resource construction; the inactive-for-TF guard is
+  preserved.
 
 ### Testing
-- 6 per-phase verify scripts (`verify_phase11.sh`..`verify_phase16.sh`),
-  all green.
-- The capstone verify (`verify_phase16.sh`) exercises every v1.2
-  deliverable + the v1.1 regression + NFR + docs + L1 catalog + outbox.
-- The `terraform apply` + HTTP 200 check are the operator's post-unblock
-  step (documented in Phase 15/16 VERIFY).
+- 493 offline tests (was 350 at v1.8 → 493 at v1.9, +143 new). Each new
+  feature has dedicated tests:
+  - P1-1: `test_p1_1_adapter_parameterization.py` (override + default + regression).
+  - Design docs: `test_design_docs_current.py` (no stale framing).
+  - Interpolation: `test_interpolation.py` + `test_sample_contracts_interpolate.py`
+    + `test_environment_schema.py`.
+  - Per-env jobs: `test_per_env_contracts.py` + `test_deploy_workflow_env_input.py`
+    + `test_consumer_guide_per_env_section.py`.
+  - Stubs: `test_route_halt_artifact.py` + `test_hitl_gates.py` +
+    `test_attestation_matrix.py` + `test_wiz_adapter_real_client.py` +
+    expanded `test_kyverno_adapter.py`.
+- `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
 
 ### Security
-- No credentials introduced. The `P1-1` AWS key ID redaction (carried from
-  v1.1) is closed — no live key IDs in `.ciagent/`.
-- The IAM blocker is a security positive: least-privilege enforced; the
-  policy push requires a deliberate privileged action.
-- The `assume_role_policy` in the contract is the standard ECS task
-  execution trust policy (not a secret).
+- No credentials introduced. The SNS topic is KMS-encrypted.
+- SoD blocks on identity equality; the halt artifact is in the audit chain.
+- The attestation matrix fails loud on missing/expired evidence for prod/dr.
+- Signature verification is required when the signing key is set.
+- The adapter has no hardcoded resource defaults (P1-1 closed) — defaults
+  live in the L1 interface, not the adapter.
 
 ### Performance
-- N/A (this milestone is about correctness + simplification, not perf).
+- N/A (this milestone is about correctness + design-doc accuracy + stub
+  implementation, not perf).
 
 ### Maintainability
-- `run_platform.sh` consolidates two scripts (D-048) — one entry point.
-- The adapter's `TYPE_MAP` + `INPUT_MAP` + `OUTPUT_MAP` tables make adding
-  future L1s a table-extension, not new emit logic.
-- The `intra_refs` mechanism is a clean L1-declared extension.
+- The interpolation is a single recursive walker; the env context is
+  loaded via a self-contained `_load_env` (works as script + package import).
+- The `child_input_map` makes multi-resource L1 wire routing deterministic
+  (the sub-resource that declares the input receives the value).
+- The attestation matrix's concern lists + freshness table are data-driven
+  (adding a concern is a table extension, not new logic).
+- The Wiz `WizClient` is a clean class with a single `_post` seam (testable
+  with `mock.patch.object`).
 
 ### Adversarial
-- The `terraform apply` failure was investigated thoroughly: the subagent
-  attempted one fix (adapter HCL correctness), then correctly identified
-  the IAM root cause + documented the unblock step. No half-applied AWS
-  state (all 5 creates failed at the API; state is empty).
-- The `TERRAFORM_APPLY_BLOCKED` + `MILESTONE_CAPSTONE_VERIFIED` evidence
-  events truthfully record the state (not faking success).
+- The interpolation fail-loud (`ValueError` on unknown tokens) prevents
+  silent mis-resolution — a typo in a token name surfaces immediately,
+  not as a stale literal in the emitted Terraform.
+- The `environment_override` is applied before schema validation, so a
+  contract with `environment: dev` cannot silently interpolate against
+  the dev env when the workflow passes `environment: prod` — the override
+  is authoritative.
+- The SoD check reads `approver_qa` from the outbox (the platform is the
+  only writer); a consumer cannot forge the approver identity.
+- The attestation matrix's signature skip is explicit + logged (not silent).
 
 ## Conclusion
 
-v1.2 is READY TO SHIP. The 1 P0 is an operator action (not a code fix), and
-the 1 P1 is deferred to v1.3. The milestone's code is complete + verified:
-the platform flow works end-to-end up to `terraform plan` (13 to add), and
-the one remaining step (`terraform apply` → live ECS service) is the
-operator's IAM policy push. Ship tag: `v1.3.0` (feature milestone, next
-minor per ship.md — v1.1 shipped `v1.2.0`).
+v1.9 is READY TO SHIP after the review auto-fixes. 1 P0 (approver
+injection — auto-fixed by passing env vars instead of string
+interpolation) and 1 P1 (future-dated freshness — auto-fixed with a
+negative-age guard + test). 3 P1 flagged for post-hoc (Wiz GraphQL
+error handling, Wiz SSRF validation, `_load_env` duplication). The
+milestone's code is complete + verified: design docs are current,
+contract interpolation works, per-env promotion requires no field
+editing, all stubs are implemented (audit ledger Object Lock/JWS
+build-out deferred per D-083), and P1-1 is closed. Ship tag: `v1.9.0`
+(feature milestone, next minor per run.md — v1.8 shipped `v1.8.0`).
+
+494 offline tests pass (was 350 at v1.8, +144 new); `run_ci.sh` + `run_platform.sh --check-only` green.

.ciagent/ROADMAP.md

@@ -9,6 +9,15 @@
 - **v1.4 (complete):** central pipeline contract + shell reproducibility + output streaming. A declarative pipeline contract (`schemas/pipeline.schema.json` + `pipelines/ci.yaml`) binds the Gitea and GitHub workflows to a single source of truth. `scripts/run_ci.sh` mirrors the CI pipeline locally. `scripts/run_platform.sh` streams terraform/checkov output by default.
 - **v1.5 (complete, tag `v1.5.0`):** consumer happy path + zero-trust docs + reusable deploy workflow. README rewritten so the consumer model is unambiguous (consumer owns only contract + app code; the rest is the platform source). Platform-flow + consumer-guide diagrams converted to mermaid. Legacy surface + implementation nomenclature removed from docs. Credentials section rewritten for zero-trust OIDC + ABAC (with a static-key override + daily rotation). A generic `docs/CONSUMER_GUIDE.md` (all L2 modules, versioned `uses:`, consumer-scoped prereqs, run-time platform fetch) replaces the module-specific guide. A byte-identical reusable `deploy.yml` workflow (Gitea + GitHub) implements `pipelines/deploy.yaml` and is invoked by consumer repos via a versioned tag.
 - **v1.6 (complete, tag `v1.6.0`):** consumer-facing docs restructure + terminology normalization + environments concept. `docs/` becomes a Jekyll-style GitHub Pages site. `acdl_platform/` is renamed to `core/`. L2 → "modules", L1 → "primitives", "composition" → "pattern" in prose. README restructured: Features + Roadmap (no internal status), repository roles restated (consumer = app code + contracts + CI definitions), mermaid fixed (visible text, security-checks + infrastructure-apply stages, no tool names), credentials section minus go-gitea/waivers. Platform-managed environments concept + a minimal onboarding scaffold. `.ciagent/` + `.gitea/` references removed from all consumer-facing docs.
+- **v1.7 (complete, tag `v1.7.0`):** production platform + contract ingestion + pipeline maturation. Rename `static-assets` → `static-assets` (D-048 — incl. `.ciagent/` historical narrative). Author `cloudfront` + `waf` primitives; augment `static-assets` to a production-ready S3 + CloudFront (OAC) + WAF stack (D-049). Tagging-standard enforcement (Checkov custom rule, D-043 closure, D-054). Wiz adapter stub (D-052) + Kyverno K8s-native adapter (D-053). Platform Lambda + DynamoDB `acdl-contracts` table for contract ingestion (D-051) + cross-account IAM. Deploy outputs via SSM SecureString + GitHub PR comment (D-050). Uniform error reporting via the Lambda `report_error` action → GitHub issue on the platform repo (D-055); Gitea excluded. Stage comments after every successful pipeline stage. Three platform pipelines (platform-test unit+integration, primitives-plan, patterns-plan). Release job with semver + MAJOR.MINOR/MAJOR tag maintenance (D-057). `uses:`/`ref:` bumped to `@v1.6`; floating `v1.6` + `v1` tags created in Phase 22. Remove the legacy consumer-repos directory (a v1.2 artifact, removed in v1.7); add validated per-module examples (`modules/<name>/examples/`, D-058) including a new RDS primitive demonstrating multi-engine variation (D-059).
+- **v1.8 (complete, tag `v1.8.0`):** P1 remediation + uptime monitoring + engineering standards + encryption/deletion-protection by default + decommission alias + path documentation. Clears 8 pending P1 issues (P1-3..P1-9 + S1). Adds per-stack CMK + encryption-by-default for all primitives. Adds deletion-protection-by-default + L2 feature flag. Adds uptime-kuma primitive (ECS Fargate, deployed by default after L2, separate state, feature flag, alert channels). Adds decommission mode (2-step pipeline with HITL SRE gates + CMDB-validated change request). Adds `modules/STANDARDS.md` (L1+L2 authoring + review standards). Adds `schemas/README.md`, `pipelines/README.md`, `adapters/README.md`.
+- **v1.9.1 (complete, tag `v1.9.1`):** leadership presentation decks. Two leadership-facing presentation decks (How the Platform Works + The Developer Experience) for senior leadership (CTO, Head of Cloud, Head of Infrastructure, Head of DevOps). Each deck has a full markdown source of truth (with speaker notes + mermaid diagrams) and a lean Marp deck (no speaker notes, embedded PNG diagrams). A README documents the 3-step slide creation process (full markdown → Marp synthesis → PPTX export). Docs-only NFR patch.
+- **v1.9.2 (complete, tag `v1.9.2`):** S&P Global Energy theme for presentation decks. Applies the S&P Global Energy brand visual identity (red-core #D6002A, grey-90 #1B1B1B, Akkurat Pro font) to both Marp decks. Title headers changed to full platform name. Footer 'Confidential' → 'Internal'. Title slide subtitle removed. Last DX slide renamed to 'The Desired Outcomes'. Docs-only NFR patch.
+- **v1.9.3 (complete, tag `v1.9.3`):** rendered presentation decks. HTML renderings of both Marp decks committed to docs/presentations/ (self-contained, base64-embedded images, S&P Global Energy theme). PPTX files uploaded to the Gitea release as downloadable attachments. README updated to document HTML as committed artifacts and PPTX as release attachments. Docs-only NFR patch.
+- **v1.9.4 (complete, tag `v1.9.4`):** presentation slide updates + complete removal of a specific compliance framework from all docs. Title slide redesigned (deck title as H1, 'Agentic Cloud Delivery Platform' as subtitle). DX deck: removed Local Reproducibility slide, redesigned Safe Promotion Path with side-by-side layout, 'an agent' → 'an AI agent', What a Developer Does diagram floated right. All references to that framework removed from 25 files (presentations, module READMEs, docs). Compliance lists now: GDPR, SOX, SOC2, DORA. HTML re-rendered. PPTX uploaded to release. Docs-only NFR patch.
+- **v1.9.5 (complete, tag `v1.9.5`):** vision gaps + Testing badge + engine terminology + agentic tags + CR format. 9 requirements: (1) DX closing slide strengthened with 'infrastructure as a utility' vision bullet; (2) 'moving' → 'promoting'; (3) added red tape + scalability bullets to Problem slide; (4) Roadmap slide redesigned side-by-side; (5) new 'What This Platform Is — and Isn't' slide (PW deck 16 slides); (6) 'shipped'/'Available today' → 'Testing' (0 consumer adoption); (7) global 'substrate' → 'engine' (88 matches, 30+ files); (8) 'forge' → 'VCS' in presentation files only; (9) new Agentic badge (purple) on agentic features. CR format changed to CHG0678912. HTML re-rendered. PPTX uploaded to release. Docs-only NFR patch.
+- **v1.9.6 (complete, tag `v1.9.6`):** consolidate both Marp decks to 10 high-impact slides. PW deck 16 → 10 (merged Problem+North Star+Anti-goals, merged Policy+Secure by Default, merged Audit+HITL, folded Observability/Environments/Portability into existing slides, added Vision Realized closing). DX deck 15 → 10 (merged What Dev Does+Contract+No Platform Code, merged Feedback+Deploy Outputs, merged Promotion+Rising Bar, cut Citizen Developer standalone, kept Versioned Releases/Onboarding/Decommission). Removed '5-line YAML' claim from both decks. Source markdown unchanged. Docs-only NFR patch.
+- **v1.9.7 (complete, tag `v1.9.7`):** talking points files + 4-step process. Created two talking points markdown files (one per deck) distilling the source of truth into presenter-ready cues indexed by the Marp deck's 10-slide structure. Each file has 3-6 talking point bullets + key takeaway per slide. README updated from 3-step to 4-step process (added Step 4: talking points). Directory layout, checklist, and decks table updated. Docs-only NFR patch.
 - **v1.0 demo URL:** https://git.cloudinit.dev/continuous-intelligence/acdl-evidence/raw/branch/main/index.html
 
 ---
@@ -129,14 +138,14 @@ D-034 closed (root key deactivated by user).**
   - `terraform validate` + `terraform plan` succeed; no long-lived credential in the workflow.
 
 ### Phase 10 — v1-spike-l2-and-contract-e2e
-- **Description:** Implement `l2-static-asset` (thin-composition referencing `l1-s3`), the contract schema + contract→IR resolution, and one end-to-end contract submission (`contracts/spike.yaml` for `l2-static-asset`) flowing through schema validation → IR resolution → `terraform plan` → Checkov `PolicyCheckResult` → confidence signal → evidence event to the DynamoDB outbox. Verify the IR commitments hold (no polyglot mess).
+- **Description:** Implement `l2-static-assets` (thin-composition referencing `l1-s3`), the contract schema + contract→IR resolution, and one end-to-end contract submission (`contracts/spike.yaml` for `l2-static-assets`) flowing through schema validation → IR resolution → `terraform plan` → Checkov `PolicyCheckResult` → confidence signal → evidence event to the DynamoDB outbox. Verify the IR commitments hold (no polyglot mess).
 - **Status:** complete (v1.1.5)
 - **Depends on:** [09]
 - **Requirements:** REQ-25, REQ-27, REQ-28
 - **Success Criteria:**
-  - `l2-static-asset` references `l1-s3` only (depth 1).
+  - `l2-static-assets` references `l1-s3` only (depth 1).
   - One contract submission completes the full pipeline end-to-end.
-  - `scripts/verify_phase10.sh` proves the adapter is the only substrate-specific code.
+  - `scripts/verify_phase10.sh` proves the adapter is the only engine-specific code.
   - Evidence event is written to the DynamoDB outbox.
 
 After Phase 10: COMPLETE gate — review → ship `v1.2.0` → audit. **DONE.**
@@ -291,16 +300,16 @@ consumer repos never need to clone the platform repo or invoke its scripts
 locally.
 
 ### Phase 20 — consumer-happy-path-and-reusable-deploy-workflow
-- **Description:** Rewrite `README.md` so the consumer model is unambiguous (this repo is the platform source; a consumer owns only `contract.yaml` + app code). Convert the platform-flow diagram to a mermaid `flowchart TD`. Remove "L3A"/"L3B" + "spike" nomenclature from README prose. Rewrite the Credentials section for zero-trust OIDC + ABAC (with a static-key override + daily rotation; consumer rotates out of band when using `.env.secrets` locally). Replace `docs/consumer-guide-static-asset.md` with a generic `docs/CONSUMER_GUIDE.md` (all L2 modules, mermaid diagrams, versioned `uses:` floating MAJOR+MINOR, consumer-scoped prerequisites, run-time platform fetch via a reusable workflow). Create byte-identical `.gitea/workflows/deploy.yml` + `.github/workflows/deploy.yml` implementing `pipelines/deploy.yaml` — a reusable workflow invoked by consumer repos via `uses: acdl/.gitea/workflows/deploy.yml@v1.4` that checks out the consumer repo + the ACDL platform repo and runs `scripts/run_platform.sh`. Update `contracts/static-asset.yaml` to `uses: acdl/pipelines/deploy.yaml@v1.4`. Extend `tests/test_pipeline_contract.py` to validate the new deploy workflows (byte-identical, schema-conformant).
+- **Description:** Rewrite `README.md` so the consumer model is unambiguous (this repo is the platform source; a consumer owns only `contract.yaml` + app code). Convert the platform-flow diagram to a mermaid `flowchart TD`. Remove "L3A"/"L3B" + "spike" nomenclature from README prose. Rewrite the Credentials section for zero-trust OIDC + ABAC (with a static-key override + daily rotation; consumer rotates out of band when using `.env.secrets` locally). Replace `docs/consumer-guide-static-assets.md` with a generic `docs/CONSUMER_GUIDE.md` (all L2 modules, mermaid diagrams, versioned `uses:` floating MAJOR+MINOR, consumer-scoped prerequisites, run-time platform fetch via a reusable workflow). Create byte-identical `.gitea/workflows/deploy.yml` + `.github/workflows/deploy.yml` implementing `pipelines/deploy.yaml` — a reusable workflow invoked by consumer repos via `uses: acdl/.gitea/workflows/deploy.yml@v1.4` that checks out the consumer repo + the ACDL platform repo and runs `scripts/run_platform.sh`. Update `contracts/static-assets.yaml` to `uses: acdl/pipelines/deploy.yaml@v1.4`. Extend `tests/test_pipeline_contract.py` to validate the new deploy workflows (byte-identical, schema-conformant).
 - **Status:** complete (v1.5.0)
 - **Depends on:** [19]
 - **Requirements:** REQ-46, REQ-47, REQ-48, REQ-49, REQ-50, REQ-51
 - **Success Criteria:**
   - `README.md` states the platform-source vs consumer-repo distinction up front; platform flow is a mermaid `flowchart TD`; `grep L3B README.md` returns 0 hits; `grep -i spike README.md` returns 0 prose hits (code paths in bash blocks allowed).
-  - `docs/CONSUMER_GUIDE.md` exists; `docs/consumer-guide-static-asset.md` is deleted; `grep -R consumer-guide-static-asset` returns 0 dangling references; guide is generic (static-asset is the worked example, not the scope); diagrams are mermaid; `uses:` references use `@v1.4`.
+  - `docs/CONSUMER_GUIDE.md` exists; `docs/consumer-guide-static-assets.md` is deleted; `grep -R consumer-guide-static-assets` returns 0 dangling references; guide is generic (static-assets is the worked example, not the scope); diagrams are mermaid; `uses:` references use `@v1.4`.
   - `README.md` Credentials section describes OIDC + ABAC zero-trust as the default and the static-key override + daily rotation + consumer out-of-band rotation duty for local `.env.secrets`.
   - `.gitea/workflows/deploy.yml` and `.github/workflows/deploy.yml` exist, are byte-identical, conform to `schemas/deploy-pipeline.schema.json`, and are reusable (`on: workflow_call` with a `contract` input).
-  - `contracts/static-asset.yaml` uses `uses: acdl/pipelines/deploy.yaml@v1.4`.
+  - `contracts/static-assets.yaml` uses `uses: acdl/pipelines/deploy.yaml@v1.4`.
   - `tests/test_pipeline_contract.py` validates the deploy workflows (exist, byte-identical, schema-conformant); the extended test suite passes; `bash scripts/run_ci.sh` exits 0.
 
 After Phase 20: COMPLETE gate — review → ship `v1.5.0` → audit.
@@ -312,14 +321,14 @@ After Phase 20: COMPLETE gate — review → ship `v1.5.0` → audit.
 The v1.6 milestone restructures the consumer-facing documentation into a real
 GitHub Pages site, normalizes the terminology (L2 → "modules", L1 →
 "primitives", "composition" → "pattern", "forge" → "platform runners"), renames
-`acdl_platform/` to `platform/`, rewrites the README (Features + Roadmap,
+`acdl_platform/` to `core/` (platform/ shadows stdlib), rewrites the README (Features + Roadmap,
 restated repository roles, fixed mermaid, cleaned credentials section), removes
 all `.ciagent/` + `.gitea/` references from consumer surfaces, and introduces
 the concept of platform-managed environments with a minimal first-run onboarding
 scaffold.
 
 ### Phase 21 — docs-restructure-and-terminology-normalization
-- **Description:** Rename `acdl_platform/` → `platform/` (directory + all code/test/script/pipeline/workflow references; tests green). Restructure `docs/` into a Jekyll-style GitHub Pages site (`_config.yml`, `index.md`, `modules/`, `contracts/`, `pipeline/`, `environments/`, `consumer-guide.md`, consolidated `architecture.md`, `vision.md`). Rewrite `README.md`: remove `.ciagent/` + `.gitea/workflows/` rows; restate consumer repo model (app code + 1+ contracts + CI definitions `uses:`-ing the central workflow); replace Status with Features + Roadmap (planned only); fix the mermaid (visible text, add security-checks stage before policy, no tool names, add infrastructure-apply stage); remove the environments table; clean the credentials section (no go-gitea/waivers, keep daily/out-of-band rotation); forge → platform runners/platform-managed. Update `docs/consumer-guide.md`: drop L2 (→ modules), composition → pattern (prose), remove `.gitea/` (GitHub only), forge → platform runners, mermaid updated. Update `modules/` READMEs: L1 → primitives, L2 → modules, composition → pattern (prose only, files kept); bump stale `@v1` → `@v1.4`. Consolidate `docs/architecture.md` + `docs/architecture-v1.0.md` into a single current-architecture `docs/architecture.md`. Add `docs/environments/index.md` (platform-managed AWS account/network/state/runner; consumer provides none). Add a minimal onboarding scaffold: `platform/environments/` dir + sample `dev.json` + README, `platform/environment_check.py`, wire-in at the top of `scripts/run_platform.sh`, friendly onboarding message when no environment is defined, `tests/test_environment_check.py`. Add a roadmap entry: "composition" will later describe the thin orchestration where consumers dynamically create a module directly from the contract file (future implementation, not this phase).
+- **Description:** Rename `acdl_platform/` → `core/` (directory + all code/test/script/pipeline/workflow references; tests green — `platform/` was the original target but shadows Python's stdlib `platform` module, so `core/` was chosen). Restructure `docs/` into a Jekyll-style GitHub Pages site (`_config.yml`, `index.md`, `modules/`, `contracts/`, `pipeline/`, `environments/`, `consumer-guide.md`, consolidated `architecture.md`, `vision.md`). Rewrite `README.md`: remove `.ciagent/` + `.gitea/workflows/` rows; restate consumer repo model (app code + 1+ contracts + CI definitions `uses:`-ing the central workflow); replace Status with Features + Roadmap (planned only); fix the mermaid (visible text, add security-checks stage before policy, no tool names, add infrastructure-apply stage); remove the environments table; clean the credentials section (no go-gitea/waivers, keep daily/out-of-band rotation); forge → platform runners/platform-managed. Update `docs/consumer-guide.md`: drop L2 (→ modules), composition → pattern (prose), remove `.gitea/` (GitHub only), forge → platform runners, mermaid updated. Update `modules/` READMEs: L1 → primitives, L2 → modules, composition → pattern (prose only, files kept); bump stale `@v1` → `@v1.4`. Consolidate `docs/architecture.md` + `docs/architecture-v1.0.md` into a single current-architecture `docs/architecture.md`. Add `docs/environments/index.md` (platform-managed AWS account/network/state/runner; consumer provides none). Add a minimal onboarding scaffold: `core/environments/` dir + sample `dev.json` + README, `core/environment_check.py`, wire-in at the top of `scripts/run_platform.sh`, friendly onboarding message when no environment is defined, `tests/test_environment_check.py`. Add a roadmap entry: "composition" will later describe the thin orchestration where consumers dynamically create a module directly from the contract file (future implementation, not this phase).
 - **Status:** complete (v1.6.0)
 - **Depends on:** [20]
 - **Requirements:** REQ-52, REQ-53, REQ-54, REQ-55, REQ-56, REQ-57, REQ-58, REQ-59, REQ-60, REQ-61
@@ -329,7 +338,305 @@ scaffold.
   - `docs/` has the Jekyll structure (`_config.yml`, `index.md`, `modules/`, `contracts/`, `pipeline/`, `environments/`); no `.ciagent/` links in `docs/`.
   - Consumer-facing docs have no "L2"/"L1" labels (modules/primitives) and no "forge" term; "composition" → "pattern" in prose.
   - README.md has Features + Roadmap (no version changelog); repository roles restated; mermaid visible + security-checks + infrastructure-apply stages + no tool names; no environments table; credentials section has no go-gitea/waivers.
-  - `docs/environments/index.md` exists; `platform/environments/` + `dev.json` + `environment_check.py` + `run_platform.sh` wire-in + `tests/test_environment_check.py` exist and pass.
+  - `docs/environments/index.md` exists; `core/environments/` + `dev.json` + `environment_check.py` + `run_platform.sh` wire-in + `tests/test_environment_check.py` exist and pass.
   - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes (154 + new environment-check tests).
 
-After Phase 21: COMPLETE gate — review → ship `v1.6.0` → audit. **DONE.**
+After Phase 21: COMPLETE gate — review → ship `v1.6.0` → audit. **DONE.**
+
+---
+
+## v1.7 (Complete — production platform + contract ingestion + pipeline maturation, tag `v1.7.0`)
+
+The v1.7 milestone takes the platform from a documented, environments-aware
+foundation to a production-grade platform with a production-ready
+`static-assets` stack (CloudFront + WAF), a contract-ingestion Lambda + DynamoDB
+store for historical/impact analysis, a uniform error-reporting pathway via the
+same Lambda, DX-friendly deploy outputs (SSM + PR comments), three dedicated
+platform pipelines (unit+integration, primitives plan, patterns plan), a
+release job with MAJOR.MINOR/MAJOR tag maintenance, new security adapters
+(Wiz, Kyverno), real tagging-standard enforcement (closing D-043), removal of
+the legacy consumer-repos directory (removed in v1.7), and validated per-module examples
+(including a new RDS primitive demonstrating multi-engine variation).
+
+The `uses:`/`ref:` tag advances from `@v1.4` to `@v1.6`; the floating `v1.6` +
+`v1` tags are created in Phase 22 (pointing at the v1.6.0 release) so the
+reference is never broken, and the release job (Phase 26) owns ongoing updates.
+
+### Phase 22 — rename-and-production-static-assets-stack
+- **Description:** Rename `static-assets` → `static-assets` everywhere (D-048 — including `.ciagent/` historical narrative, overriding the v1.6 preservation precedent). Author two new primitives: `cloudfront` (distribution + OAC, stack types `aws:cloudfront:distribution` + `aws:cloudfront:originaccesscontrol`) and `waf` (WAFv2 web ACL, stack type `aws:wafv2:webacl`). Augment the `static-assets` module to a production-ready stack referencing s3 + cloudfront + waf (depth 1, D-049). Expand the Terraform adapter `TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP` for the new stack types. Bump `uses:`/`ref:` from `@v1.4` to `@v1.6` (D-056/D-057); create the floating `v1.6` + `v1` git tags pointing at `v1.6.0` so the reference resolves immediately.
+- **Status:** complete (v1.7.0)
+- **Depends on:** [21]
+- **Requirements:** REQ-62, REQ-63, REQ-64
+- **Success Criteria:**
+  - `grep -R "static-assets[^s]" .` (excluding `.git/`) returns 0 hits; `modules/l2/static-assets/` is renamed to `modules/l2/static-assets/`; `contracts/static-assets.yaml` → `contracts/static-assets.yaml`; registry key renamed; all `.ciagent/` references (incl. verbatim phase descriptions, REQ-25/27/50 text, D-036) rewritten to `static-assets`.
+  - `modules/l1/cloudfront/` + `modules/l1/waf/` exist with `interface.json` valid against `schemas/stack.schema.json`; registered in `modules/registry.json`.
+  - `modules/l2/static-assets/composition.json` references s3 + cloudfront + waf (depth 1).
+  - `adapters/terraform/adapter.py` `TYPE_MAP` covers `aws:cloudfront:distribution`, `aws:cloudfront:originaccesscontrol`, `aws:wafv2:webacl`.
+  - `contracts/static-assets.yaml` + `.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml` use `@v1.6`; git tags `v1.6` + `v1` exist pointing at `v1.6.0`.
+  - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes; `bash scripts/run_platform.sh --check-only` exits 0.
+
+### Phase 23 — tagging-standards-and-security-adapters
+- **Description:** Define a required-tag set (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`) in `schemas/tagging-standard.json` (D-054). Author a Checkov custom YAML rule at `adapters/terraform/policy/custom_rules/acdl_tagging.yaml` that fails when required tags are missing on taggable resources. Remove the `_emit_tag_naming_skipped()` placeholder in `checkov_adapter.py` (D-043 closure) and add `ACDL_TAG_NAMING` to `RULE_MAP` as a real rule. Author a Wiz adapter stub (`adapters/wiz/wiz_adapter.py`) translating Wiz API issues → `PolicyCheckResult` records (`engine: "wiz"`), degrading gracefully when unconfigured (D-052). Author a Kyverno K8s-native adapter (`adapters/kyverno/kyverno_adapter.py`) translating Kyverno `PolicyReport` results → `PolicyCheckResult` records (`engine: "kyverno"`), with sample policies as documentation; inactive for Terraform-only stacks, ready for the GitOps reconciler roadmap item (D-053). Add `wiz` + `kyverno` to the `schemas/policy_check_result.schema.json` engine enum.
+- **Status:** complete (v1.7.0)
+- **Depends on:** [22]
+- **Requirements:** REQ-65, REQ-66, REQ-67
+- **Success Criteria:**
+  - `adapters/terraform/policy/custom_rules/acdl-tagging.yaml` exists; Checkov loads it; `checkov_adapter.py` no longer emits a SKIPPED `ACDL_TAG_NAMING` placeholder (D-043 closed).
+  - `adapters/wiz/wiz_adapter.py` + `tests/test_wiz_adapter.py` exist; tests pass offline (not-configured graceful degradation).
+  - `adapters/kyverno/kyverno_adapter.py` + sample policies + `tests/test_kyverno_adapter.py` exist; tests pass offline.
+  - `schemas/policy_check_result.schema.json` engine enum includes `checkov | kyverno | opa | wiz`.
+  - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes.
+
+### Phase 24 — platform-lambda-and-contract-ingestion
+- **Description:** Author a platform Lambda (`core/lambda/contract_ingestor.py`) invoked via a Function URL (IAM auth) that accepts `{ consumerRepo, contractId, contract, environment, action }` and writes contracts to a DynamoDB table `acdl-contracts` (PK `consumerRepo`, SK `contractId#submittedAt`, SSE via a customer-managed CMK) (D-051). Define the Terraform (`terraform/platform/main.tf`) for the table, Lambda, Function URL, KMS key, Secrets Manager secret (`acdl/github-token`), and Lambda execution role. Define the cross-account consumer-invoke IAM policy (`terraform/platform/consumer_invoke_policy.json`) granting the consumer's deploy role `lambda:InvokeFunctionUrl` on the Lambda ARN, scoped via ABAC. The `report_error` action (Phase 25) is prepared but not yet implemented. Update `docs/environments/index.md` to document that onboarding now also grants Lambda-invoke permission.
+- **Status:** complete (v1.7.0)
+- **Depends on:** [23]
+- **Requirements:** REQ-68
+- **Success Criteria:**
+  - `core/lambda/contract_ingestor.py` exists; handler writes contracts to DynamoDB (tested offline with moto).
+  - `terraform/platform/main.tf` defines `acdl-contracts` DynamoDB table, `acdl-contract-ingestor` Lambda, Function URL (IAM auth), KMS CMK, Secrets Manager secret, Lambda execution role.
+  - `terraform/platform/consumer_invoke_policy.json` exists (cross-account invoke policy template).
+  - `tests/test_contract_ingestor.py` passes offline.
+  - `bash scripts/run_ci.sh` exits 0.
+
+### Phase 25 — deploy-pipeline-dx-outputs-and-error-reporting
+- **Description:** Add a `publish-outputs` step to `scripts/run_platform.sh` (after apply) that writes deploy outputs to SSM Parameter Store as `SecureString` (KMS-encrypted, namespaced `/acdl/{env}/{contractId}/{output_name}`) for runtime-injectable values, and a `comment-outputs` step that posts a structured GitHub PR comment / job summary with human-readable connection strings (D-050). Implement `core/output_publisher.py` (SSM write + GitHub comment formatting). Implement the Lambda `report_error` action (`core/lambda/contract_ingestor.py`) that creates a GitHub issue on the platform repo (`acdl/acdl`) via the GitHub API using a token from Secrets Manager; idempotent (comments on existing open issue rather than duplicating) (D-055). Add an `if: failure()` error-report step to `.github/workflows/deploy.yml` that invokes the Lambda via `aws lambda invoke-function-url` (SigV4-signed). Add a PR comment after every successful pipeline stage (D-055 extension) via `scripts/post_stage_comment.sh` (uses `GITHUB_TOKEN` + `gh api`; no-op when not in a PR context). Update `pipelines/deploy.yaml` + both deploy workflow YAMLs with the new stages (byte-identical).
+- **Status:** complete (v1.7.0)
+- **Depends on:** [24]
+- **Requirements:** REQ-69, REQ-70, REQ-71
+- **Success Criteria:**
+  - `scripts/run_platform.sh` has a `publish-outputs` step (SSM SecureString, tested offline with moto) + a `comment-outputs` step (GitHub PR comment formatting, tested offline).
+  - `core/lambda/contract_ingestor.py` `report_error` action creates a GitHub issue (tested with mocked API); idempotent.
+  - `.github/workflows/deploy.yml` + `.gitea/workflows/deploy.yml` (byte-identical) have an `if: failure()` error-report step invoking the Lambda + stage comments after each successful stage (PR context).
+  - `pipelines/deploy.yaml` declares the new stages.
+  - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes.
+
+### Phase 26 — platform-pipelines-and-release-automation
+- **Description:** Author three platform pipelines (D-057): (1) `.github/workflows/platform-test.yml` (PR, lint + unit + integration + schema-validation — replaces `ci.yml` for PRs); (2) `.github/workflows/primitives-plan.yml` (PR, plan-only for all L1 primitives via matrix); (3) `.github/workflows/patterns-plan.yml` (PR, plan-only for all L2 modules via matrix). Author `scripts/run_primitive_plan.sh` + `scripts/run_pattern_plan.sh` (with `--check-only` mode for CI). Author the release job (`.github/workflows/release.yml`) that runs on merge to `main`, computes the next semver (PATCH per phase, MINOR on milestone COMPLETE), creates the MAJOR.MINOR.PATCH tag, force-moves the MAJOR.MINOR + MAJOR floating tags, creates a GitHub release with an auto-generated body. This is the mechanism that lets consumers on `@v1` or `@v1.7` receive updates.
+- **Status:** complete (v1.7.0)
+- **Depends on:** [25]
+- **Requirements:** REQ-72, REQ-73
+- **Success Criteria:**
+  - `.github/workflows/platform-test.yml` exists, runs lint + unit + integration + schema-validation on PR.
+  - `.github/workflows/primitives-plan.yml` + `.github/workflows/patterns-plan.yml` exist, run plan-only (matrix) on PR.
+  - `.github/workflows/release.yml` exists, computes next semver, creates + updates MAJOR.MINOR.PATCH / MAJOR.MINOR / MAJOR tags on merge.
+  - `scripts/run_primitive_plan.sh` + `scripts/run_pattern_plan.sh` exit 0 in `--check-only` mode.
+  - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes.
+
+### Phase 27 — remove-legacy-consumer-repos-and-module-documentation-examples
+- **Description:** Delete the legacy consumer-repos directory entirely (a v1.2 artifact removed in v1.7; references in `.ciagent/` historical narrative are rewritten per D-048). Author a new RDS primitive (`modules/l1/rds/`) with an `engine` input (enum: postgres, mysql, etc.) demonstrating multi-engine variation (D-059). Expand the adapter `TYPE_MAP` for `aws:rds:instance` → `aws_db_instance`. For **each** module (primitives + patterns), add a `modules/<name>/examples/` directory with `simple.yaml` + `complex.yaml` (+ variation files) validated against `schemas/contract.schema.json` in the platform-test pipeline (Phase 26 schema-validation stage) (D-058). Each module's `README.md` `## Examples` section references + excerpts the validated files. Update `docs/modules/index.md` + `docs/consumer-guide.md` + `docs/contracts/index.md` with the new module names + examples.
+- **Status:** complete (v1.7.0)
+- **Depends on:** [26]
+- **Requirements:** REQ-74, REQ-75
+- **Success Criteria:**
+  - The legacy consumer-repos directory does not exist; a recursive grep for the legacy directory name (excluding `.git/`) returns 0 hits.
+  - `modules/l1/rds/` exists with `interface.json` (`engine` enum) + `examples/`; registered; adapter emits `aws_db_instance`.
+  - Every module README has a `## Examples` section; `modules/<name>/examples/{simple,complex}.yaml` exist and validate against `schemas/contract.schema.json`.
+  - `docs/modules/index.md` links to all module READMEs (including cloudfront, waf, rds).
+  - `bash scripts/run_ci.sh` exits 0; `python3 -m pytest tests/ -v` passes.
+
+After Phase 27: COMPLETE gate — review → ship `v1.7.0` → audit. **DONE.**
+
+---
+
+## v1.8 (Complete — P1 remediation + uptime + engineering standards + encryption/deletion-protection by default + decommission + docs)
+
+The v1.8 milestone clears all pending P1 issues from v1.5–v1.7 verify
+reviews AND delivers three user-directed tracks: encryption + deletion
+protection by default (with a decommission alias), uptime monitoring
+(uptime-kuma primitive deployed by default after L2 modules), and
+engineering standards + path documentation. Ship tag at milestone
+COMPLETE: **`v1.8.0`** (feature milestone, next minor per run.md — v1.7
+shipped `v1.7.0`). Phase patches `v1.7.1`..`v1.7.9`.
+
+### Phase 28 — adapter-waf-and-resolver-outputs
+- **Description:** Fix WAF HCL emission: custom `rules` input emits nested `rules { ... }` blocks (not `rules = [...]` attribute syntax — P1-4). Honor `default_action` input (allow/block) instead of hardcoding `allow {}` (P1-5). Implement L2 composition `outputs[]` processing in `resolve_l2()` — build `stack.outputs` dict + adapter emits `output` blocks (P1-7). Tests for all three fixes.
+- **Status:** complete (v1.8.0)
+- **Depends on:** —
+- **Requirements:** REQ-76, REQ-77
+- **Success Criteria:**
+  - WAF with custom rules emits nested `rules {` blocks, not `rules = [`.
+  - WAF with `default_action: block` emits `block {}`; default (absent) emits `allow {}`.
+  - L2 resolution of `static-assets` yields `stack.outputs.distribution_domain_name`, `bucket_arn`, `web_acl_arn`.
+  - Adapter emits `output "distribution_domain_name" { value = ... }` blocks.
+  - `pytest` passes; `run_platform.sh --check-only` exits 0.
+
+### Phase 29 — ssm-kms-and-invoke-policy
+- **Description:** SSM publisher fails loud (`RuntimeError`) when `ACDL_KMS_KEY_ID` unset; `ACDL_ALLOW_DEFAULT_KMS=1` escape hatch for local testing (P1-3). Convert `consumer_invoke_policy.json` to a Terraform-rendered template using `data.aws_caller_identity` + `templatestring` — no `000000000000` placeholder (P1-6). Tests for both.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [28]
+- **Requirements:** REQ-78, REQ-79
+- **Success Criteria:**
+  - SSM publisher raises `RuntimeError` when `ACDL_KMS_KEY_ID` unset; succeeds with `ACDL_ALLOW_DEFAULT_KMS=1`.
+  - Rendered invoke policy contains the caller's live account ID, not `000000000000`.
+  - `pytest` passes; `run_ci.sh` exits 0.
+
+### Phase 30 — run-platform-isolation-and-api-portability
+- **Description:** `run_platform.sh` emits adapter output to `$WORK/tf` (per-run temp dir), not `terraform/spike/`; remove committed `terraform/spike/*.tf` (P1-8). `contract_ingestor.py` reads `GITHUB_API_BASE` env for forge-agnostic API URLs (GitHub + Gitea); `_forge_type()` branches search URL (P1-9). Deploy workflow `configure-aws-credentials` step restructured as single conditional step: OIDC when no static key, `access-key`/`secret-key` inputs when static key present (S1). Both deploy workflows remain byte-identical.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [29]
+- **Requirements:** REQ-80, REQ-81, REQ-82
+- **Success Criteria:**
+  - `run_platform.sh --check-only` writes to a temp dir; no `terraform/spike/*.tf` committed.
+  - `contract_ingestor.py` uses `GITHUB_API_BASE`; Gitea base URL produces correct API paths.
+  - Deploy workflow static-key override wired to `configure-aws-credentials` inputs.
+  - Both deploy workflows byte-identical; `pytest` + `run_ci.sh` green.
+
+### Phase 31 — encryption-by-default-and-per-stack-cmk
+- **Description:** Create `kms-key` L1 primitive (type `aws:kms:key`, inputs: description/region/deletion_window_days, outputs: kms_key_arn/kms_key_id, NFRs: enable_rotation default true, deletion_protection default true). Adapter emits `aws_kms_key` + `aws_kms_alias` + `enable_key_rotation = true`. Add `encryption_enabled` NFR (default true) + `kms_key_arn` input to all primitives. L2 modules wire a `kms-key` child + connect its output to all children. Managed KMS fallback when no CMK provided (with stderr warning).
+- **Status:** complete (v1.8.0)
+- **Depends on:** [30]
+- **Requirements:** REQ-83, REQ-84, REQ-85
+- **Success Criteria:**
+  - Every primitive has `encryption_enabled` NFR (default true) + optional `kms_key_arn` input.
+  - L2 resolution wires per-stack CMK to all children.
+  - Adapter emits encryption blocks (SSE, storage_encrypted, encryption_configuration) referencing the CMK.
+  - `enable_key_rotation = true` on the CMK; no shared keys across stacks.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 32 — deletion-protection-by-default-and-l2-feature-flag
+- **Description:** Add `deletion_protection` NFR (boolean, default true) to every L1 primitive. Adapter emits `lifecycle { prevent_destroy = true }` when true; omits it when false. L2 modules expose `features.deletion_protection` flag (default true); resolver propagates to each child's NFR. Consumers can set `inputs.deletion_protection: false` in contract. Update contract schema.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [31]
+- **Requirements:** REQ-86, REQ-87
+- **Success Criteria:**
+  - Every primitive has `deletion_protection` NFR defaulting to true.
+  - Adapter emits `prevent_destroy = true` when true; omits when false.
+  - L2 feature flag propagates to all children.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 33 — uptime-kuma-primitive
+- **Description:** Create `uptime` L1 primitive (ECS Fargate running `louislam/uptime-kuma:1`). Inputs: container_image, region, monitored_endpoints (array of {name, url, type, interval, timeout}), static_checks, alert_channels ({teams_webhook, email_addresses, sms_numbers, github_issue_repo}), feature_flag_enabled (default true), cpu, memory. Outputs: uptime_url, service_arn, task_definition_arn. NFRs: deletion_protection, encryption_enabled. Adapter emits ECS service + ALB + log group; no resources when feature_flag_enabled=false. Register in registry. Add `deploy-uptime` pipeline stage (separate state, after publish-outputs) to `pipelines/deploy.yaml` + both deploy workflows. `run_platform.sh` constructs synthetic uptime contract from L2 outputs + runs second terraform apply. Uptime URL published via PR comment. Feature flag from `inputs.uptime_enabled` (default true).
+- **Status:** complete (v1.8.0)
+- **Depends on:** [32]
+- **Requirements:** REQ-88, REQ-89, REQ-90, REQ-91
+- **Success Criteria:**
+  - Uptime primitive exists with feature flag, monitored endpoints, alert channels.
+  - Deployed by default after L2 module (separate state); endpoints passed from L2 outputs.
+  - Uptime URL published via PR comment.
+  - Feature flag disables deployment (no resources emitted).
+  - `deploy-uptime` stage in deploy contract + byte-identical workflows.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 34 — decommission-alias-and-cmdb-validation
+- **Description:** Add `mode: decommission` to deploy pipeline. Stages: validate-change-request (Lambda `validate_change_request` action queries DynamoDB `acdl-change-requests` table, asserts status=approved) → disable-deletion-protection (resolve contract with deletion_protection=false, terraform plan/apply, HITL SRE gate) → zero-counts (resolver `decommission_transform` zeroes all counts, terraform plan/apply, second HITL SRE gate) → confirm-decommission. Add `acdl-change-requests` DynamoDB table to terraform/platform/main.tf. Add `validate_change_request` to contract_ingestor.py. Document in `docs/CONSUMER_GUIDE.md`.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [33]
+- **Requirements:** REQ-92, REQ-93, REQ-94
+- **Success Criteria:**
+  - Decommission mode works via existing deploy pipeline with 2-step HITL SRE gates.
+  - CR ID validated against DynamoDB CMDB (status must be approved).
+  - `decommission_transform` zeroes all counts.
+  - Documented in consumer guide.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 35 — module-engineering-standards
+- **Description:** Scan all current modules to generate `modules/STANDARDS.md` — comprehensive L1+L2 authoring + code review standards: required files, interface schema, input/output/NFR conventions, encryption + deletion protection as mandatory NFRs, naming, multi-resource pattern, adapter extension pattern (TYPE_MAP + INPUT_MAP + OUTPUT_MAP + specialized branches), code review checklist. Fix `modules/README.md` catalog index (add rds + uptime + kms-key). Update `modules/README-TEMPLATE.md` with `## NFRs` section. Add `tests/test_module_standards.py` for automated enforcement.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [34]
+- **Requirements:** REQ-95, REQ-96
+- **Success Criteria:**
+  - `modules/STANDARDS.md` exists with L1+L2 authoring + review standards.
+  - Catalog index includes all primitives; template has NFRs section.
+  - Automated standards test passes for all modules.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 36 — schemas-adapters-pipelines-readmes
+- **Description:** Author `schemas/README.md` (how to write schemas, wire into platform, test in CI, dependencies, existing catalog), `pipelines/README.md` (how to write pipeline contracts, wire into workflows, test, dependencies, catalog), `adapters/README.md` (how to write adapters, wire into platform, test, dependencies, catalog). Add `tests/test_docs_coverage.py` to validate presence + required sections.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [35]
+- **Requirements:** REQ-97, REQ-98, REQ-99
+- **Success Criteria:**
+  - All 3 READMEs exist with comprehensive documentation.
+  - CI validates their presence.
+  - `pytest` + `run_ci.sh` green.
+
+### Phase 37 — verify
+- **Description:** 4-layer verification (structural, behavioral, security, quality) of all v1.8 phases. Re-verify each P1 (P1-3..P1-9 + S1) is resolved. Verify all new features (encryption, deletion protection, uptime, decommission, standards, docs) have dedicated tests.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [36]
+- **Requirements:** —
+- **Success Criteria:**
+  - All 4 layers pass; each P1 fix + each new feature has a dedicated test.
+  - `pytest` passes (~358 tests); `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+
+### Phase 38 — review-audit-complete
+- **Description:** Multi-persona code review across the full v1.8 diff. Audit (reconstruction, file discipline, branch hygiene, commit discipline). Complete: update REQUIREMENTS.md (REQ-76..99), ROADMAP.md (v1.8 complete), PROJECT.md. Tag `v1.8.0`. Update floating `v1.8` + `v1` tags. Bump `uses:`/`ref:` from `@v1.6` to `@v1.8`.
+- **Status:** complete (v1.8.0)
+- **Depends on:** [37]
+- **Requirements:** —
+- **Success Criteria:**
+  - Review: 0 new P0/P1; all P1-3..P1-9 + S1 resolved; 3 new requirements delivered.
+  - Audit: clean; 0 outstanding issues.
+  - Tag `v1.8.0` created; floating tags updated.
+
+After Phase 38: COMPLETE gate — review → ship `v1.8.0` → audit.
+
+---
+
+## v1.9 (complete — design doc refresh + contract interpolation + per-env CI jobs + stub implementation + P1-1 remediation, tag `v1.9.0`)
+
+The v1.9 milestone closes four gaps left by v1.8 (user-directed,
+2026-07-23): stale design docs, no contract interpolation, promotion
+requires editing the `environment` field, and unimplemented stubs. It
+also closes P1-1 (adapter hardcoded defaults, deferred from v1.2).
+
+### Phase 39 — design-doc-refresh-and-p1-1-parameterization
+- **Description:** Refresh `core/hitl_matrix_design.md` (no stale "dev-only spike"/"v1.2 wires the gates" framing; v1.9 wiring section; 8-concern matrix marked implemented offline-testable subset) + `core/audit_ledger_design.md` (outbox marked shipped+production since v1.8; S3 Object Lock + JWS + worker + DLQ + checkpoints deferred D-083). P1-1: move adapter ECS/ALB/VPC hardcoded defaults (`desired_count`, `launch_type`, `family`, `target_type`, `load_balancer_type`, `Name` tags) into L1 `interface.json` inputs with defaults; the adapter reads from inputs; the resolver routes wires to the sub-resource that declares the input.
+- **Status:** complete (v1.8.1)
+- **Depends on:** —
+- **Requirements:** REQ-100, REQ-101, REQ-102
+- **Success Criteria:**
+  - Both design docs refreshed; no stale framing; `test_design_docs_current.py` passes.
+  - Adapter has no hardcoded ECS/ALB/VPC defaults; overrides flow through; `test_p1_1_adapter_parameterization.py` passes.
+  - v1.1 S3 regression passes; `pytest` 371 (was 350, +21); `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+
+### Phase 40 — contract-interpolation
+- **Description:** `${env.<field>}` + `${contract.<field>}` resolver expansion from environment onboarding JSON (D-081). Environment JSON schema (`schemas/environment.schema.json`) + qa/prod/dr placeholder bindings. `core/environment_check.py` gains `load()`. Sample contracts use naming patterns that include region, account id, environment (e.g. `acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}`). Expansion is recursive (D-087), post-schema-validation, pre-IR-resolution; unknown tokens raise `ValueError`. `resolve()` accepts `environment_override` (D-088).
+- **Status:** complete (v1.8.2)
+- **Depends on:** [39]
+- **Requirements:** REQ-103, REQ-104
+- **Success Criteria:**
+  - `schemas/environment.schema.json` exists; 4 env files validate; `load()` works.
+  - `_expand_vars` in resolver; unknown tokens raise; recursive over dicts/lists/strings.
+  - Sample contracts use `${env.*}` + `${contract.*}` naming patterns; resolve to concrete values.
+  - `tests/test_environment_schema.py` + `tests/test_interpolation.py` + `tests/test_sample_contracts_interpolate.py` pass.
+  - `pytest` 406 (was 371, +35); `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+### Phase 41 — per-environment-ci-jobs
+- **Description:** Per-env contract files (static-assets + microservice × dev/qa/prod/dr, REQ-105) using interpolation. Deploy workflow (`.github` + `.gitea`, byte-identical) declares an `environment` `workflow_call` input (REQ-106); `run_platform.sh --environment <name>` overrides the contract's environment at load time (D-088, before schema validation + interpolation). `resolve()` accepts `environment_override`. Consumer guide documents the per-env caller-workflow pattern (4 jobs, one per environment) + HITL gate structure (approve_qa/approve_prod/approve_dr, D-042) + interpolation reference table. Promotion = running the matching job; no environment field editing.
+- **Status:** complete (v1.8.3)
+- **Depends on:** [40]
+- **Requirements:** REQ-105, REQ-106
+- **Success Criteria:**
+  - 8 per-env contract files exist + validate + resolve to correct env.
+  - Deploy workflow has `environment` input (byte-identical Gitea + GitHub); `run_platform.sh --environment` overrides; resolver supports `environment_override`.
+  - Consumer guide documents per-env caller workflows + promotion-without-editing + HITL gates + interpolation reference.
+  - `tests/test_per_env_contracts.py` + `tests/test_deploy_workflow_env_input.py` + `tests/test_consumer_guide_per_env_section.py` pass.
+  - `pytest` 446 (was 406, +40); `run_ci.sh` exits 0; both deploy workflows byte-identical.
+
+### Phase 42 — stub-implementation
+- **Description:** `route_halt_artifact` real (SNS publish + outbox fallback, REQ-107) + SNS topic `acdl-sod-halt` in `terraform/platform/main.tf`. HITL attestation gates (`core/hitl_gates.py`, REQ-108) — records approver to outbox, runs SoD on prod, invokes the attestation matrix; `run_platform.sh` calls `attest` before apply for qa/prod/dr (dev skips). 8-concern attestation matrix (`core/attestation_matrix.py`, REQ-109, D-084) — offline-testable concerns run for real; operator-supplied concerns accept signed evidence artifacts validated for freshness + schema; signature skip when `ACDL_ATTESTATION_SIGNING_KEY_ID` unset (D-089). Wiz real API client (`WizClient`, REQ-110) — GraphQL queries + pagination + graceful degrade. Kyverno translator fleshed out (REQ-111) — full PolicyReport mapping + skip-with-reason + inactive-for-TF guard + `--kube-version` stub.
+- **Status:** complete (v1.8.4)
+- **Depends on:** [41]
+- **Requirements:** REQ-107, REQ-108, REQ-109, REQ-110, REQ-111
+- **Success Criteria:**
+  - `route_halt_artifact` publishes to SNS when ARN set; outbox fallback when unset; SNS topic in Terraform.
+  - `hitl_gates.attest` records approver; SoD blocks on identity equality; dev skips; `run_platform.sh` has the HITL step.
+  - `attestation_matrix.check` runs 8 concerns; offline concerns pass; operator-supplied missing → block for prod; expired → block; signature skip when key unset.
+  - Wiz `WizClient` real client + pagination + graceful degrade; `fetch_and_adapt` translates.
+  - Kyverno full mapping (pass/fail/skip/warn + severity + skip-with-reason + resource construction); inactive guard preserved; `--kube-version` parsed.
+  - `tests/test_route_halt_artifact.py` + `test_hitl_gates.py` + `test_attestation_matrix.py` + `test_wiz_adapter_real_client.py` + expanded `test_kyverno_adapter.py` pass.
+  - `pytest` 493 (was 446, +47); `run_ci.sh` exits 0; `run_platform.sh --check-only` exits 0.
+
+### Phase 43 — verify-review-audit-complete
+- **Description:** 4-layer verify (structural, behavioral, security, quality) of all v1.9 phases. Multi-persona review (0 P0, 0 P1). Audit (reconstruction, file discipline, branch hygiene, commit discipline — all clean). REVIEW.md reconstructed (D-086). Complete: update REQUIREMENTS.md (REQ-100..111), ROADMAP.md, PROJECT.md. Tag `v1.9.0`; update floating `v1.9` + `v1` tags. Bump `uses:`/`ref:` from `@v1.6` → `@v1.9`.
+- **Status:** complete (v1.9.0)
+- **Depends on:** [42]
+- **Requirements:** —
+- **Success Criteria:**
+  - 4-layer verify PASS; 493 tests; `run_ci.sh` + `run_platform.sh --check-only` green.
+  - Review: 0 P0, 0 P1; REVIEW.md reconstructed with v1.9 content (D-086).
+  - Audit: clean; all 12 v1.9 commits have `---ci---` blocks.
+  - Tag `v1.9.0` created; floating tags updated; `uses:` bumped to `@v1.9`.
+
+After Phase 43: COMPLETE gate — review → ship `v1.9.0` → audit. **DONE.**

.ciagent/VERIFY.md

@@ -1,45 +1,40 @@
-# Phase 18 — Verify (v1.3.2)
+# Phase 39-43 — Verify (v1.9)
 
 ## Structural
-
-All 11 new files confirmed present: pyproject.toml, requirements-test.txt,
-tests/__init__.py, tests/conftest.py, tests/test_adapter.py,
-tests/test_confidence_signal.py, tests/test_checkov_adapter.py,
-tests/test_outbox_writer.py, tests/test_pipeline.py,
-.gitea/workflows/ci.yml, .github/workflows/ci.yml. **PASS.**
+All 26 new files present (environment.schema.json, 4 env files, 8 per-env
+contracts, hitl_gates.py, attestation_matrix.py, 10 new test files,
+refreshed design docs). SNS topic in terraform/platform/main.tf. **PASS.**
 
 ## Behavioral
-
-- `py_compile` passes on all Python files. **PASS.**
-- `pytest` — 90 tests, all passing, all offline (moto for DynamoDB
-  mocking). **PASS.**
-- `run_platform.sh --check-only` — exits 0, outputs
-  "PLATFORM CHECK OK", requires no AWS credentials. **PASS.**
-- `run_platform.sh --plan-only` — syntax valid (unchanged from phase 17).
-  **PASS.**
-- Both workflow YAMLs are valid YAML, parseable. **PASS.**
-- Workflows are byte-identical (diff confirms). **PASS.**
+- `pytest`: 493 tests, all passing (was 350 at v1.8 → 493 at v1.9, +143 new).
+- `run_ci.sh`: exits 0 with "CI PIPELINE OK".
+- `run_platform.sh --check-only`: exits 0 with "PLATFORM CHECK OK".
+- `run_platform.sh --check-only --environment qa`: exits 0; bucket name reflects qa env.
+**PASS.**
 
 ## Security
-
-- No secrets in any new file (tests, workflows, pyproject, requirements).
-  **PASS.**
-- CI pipelines do not use any AWS credentials — `--check-only` is fully
-  offline. **PASS.**
+- No hardcoded adapter ECS/ALB/VPC defaults (P1-1 closed; defaults in interface.json).
+- HITL gates block on SoD violation (approver_qa == approver_prod).
+- Attestation matrix fails loud on missing/expired evidence for prod/dr.
+- Signature verification required when ACDL_ATTESTATION_SIGNING_KEY_ID set; skipped + logged when unset (D-089).
+- Wiz degrades gracefully when unconfigured (WIZ_NOT_CONFIGURED SKIPPED record).
+- SNS topic KMS-encrypted; outbox fallback for the halt artifact.
+- Deploy workflows byte-identical (Gitea + GitHub).
+**PASS.**
 
 ## Quality
-
-- pyproject.toml has pytest config (testpaths, markers, addopts).
-  **PASS.**
-- requirements-test.txt pins all test deps. **PASS.**
-- Test suite covers all 4 platform components (adapter, confidence
-  signal, checkov adapter, outbox writer) + pipeline integration.
-  **PASS.**
-- Both workflows run 3 stages: lint, test, check-only. **PASS.**
-- README updated with "Test the platform" section + CI/CD documentation.
-  **PASS.**
+Each new feature has dedicated tests:
+- Design docs: test_design_docs_current.py (no stale framing; deferred D-083 labeled).
+- P1-1: test_p1_1_adapter_parameterization.py (override + default + v1.1 S3 regression).
+- Interpolation: test_interpolation.py + test_sample_contracts_interpolate.py + test_environment_schema.py.
+- Per-env jobs: test_per_env_contracts.py + test_deploy_workflow_env_input.py + test_consumer_guide_per_env_section.py.
+- SoD: test_route_halt_artifact.py (SNS + outbox fallback + SNS failure fallback).
+- HITL gates: test_hitl_gates.py (dev skips; qa/prod/dr record approver; SoD blocks; matrix invoked).
+- Attestation matrix: test_attestation_matrix.py (offline concerns; operator-supplied; freshness; signature skip).
+- Wiz: test_wiz_adapter_real_client.py (real client + pagination + graceful degrade).
+- Kyverno: expanded test_kyverno_adapter.py (pass/fail/skip/warn + severity + inactive guard + kube-version).
+**PASS.**
 
 ## Verdict
 
-**VERIFY PASS** — all four layers pass. 90 offline tests, no AWS
-required for CI.
+**VERIFY PASS** — all four layers pass. 493 offline tests, no AWS required for CI.

.ciagent/config.json

@@ -4,8 +4,8 @@
     {
       "slug": "acdl",
       "name": "Agentic Cloud Delivery Platform",
-      "milestone": "v1.6",
-      "status": "active"
+      "milestone": "v1.9",
+      "status": "complete"
     }
   ],
   "active_project": "acdl",

.gitea/workflows/ci.yml

@@ -37,7 +37,9 @@ jobs:
           python3 -m py_compile \
             core/confidence_signal.py \
             core/outbox_writer.py \
+            core/output_publisher.py \
             core/contract_resolver.py \
+            core/lambda/contract_ingestor.py \
             adapters/terraform/adapter.py \
             adapters/terraform/policy/checkov_adapter.py \
             scripts/push_consumer_image.py

.gitea/workflows/deploy.yml

@@ -8,8 +8,8 @@
 # declared difference is the forge/runtime, not the stages or commands.
 #
 # Consumer repos invoke this workflow via a versioned tag (floating MAJOR + MINOR):
-#   uses: acdl/.gitea/workflows/deploy.yml@v1.4   (Gitea)
-#   uses: acdl/.github/workflows/deploy.yml@v1.4  (GitHub)
+#   uses: acdl/.gitea/workflows/deploy.yml@v1.9   (Gitea)
+#   uses: acdl/.github/workflows/deploy.yml@v1.9  (GitHub)
 #
 # Unversioned references (@main, bare) are discouraged — the consumer's setup
 # must be immutable + resilient. The versioned tag is the only immutability
@@ -53,9 +53,17 @@ on:
         type: string
         default: .acdl/contract.yaml
       mode:
-        description: Pipeline mode — full (apply), plan-only, or check-only
+        description: Pipeline mode — full (apply), plan-only, check-only, or decommission
         type: string
         default: full
+      changeRequestId:
+        description: Change request ID (required for decommission mode — validated against CMDB)
+        type: string
+        default: ""
+      environment:
+        description: Target environment override (dev/qa/prod/dr); when empty, the contract's environment field is used
+        type: string
+        default: ""
 
 permissions:
   id-token: write
@@ -74,7 +82,7 @@ jobs:
         with:
           repository: acdl/acdl
           path: platform
-          ref: v1.4
+          ref: v1.9
 
       - uses: actions/setup-python@v5
         with:
@@ -91,14 +99,13 @@ jobs:
           echo "deb [signed-by=/usr/share/keyrings/hashicorp.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
           sudo apt-get update && sudo apt-get install -y terraform=1.9.*
 
-      - name: Configure AWS credentials (OIDC default)
+      - name: Configure AWS credentials (OIDC default + static-key override)
         uses: aws-actions/configure-aws-credentials@v4
         with:
-          role-to-assume: arn:aws:iam::${{ secrets.ACDL_AWS_ACCOUNT_ID }}:role/acdl-deploy-${{ github.repository_id }}
+          role-to-assume: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID == '' && format('arn:aws:iam::{0}:role/acdl-deploy-{1}', secrets.ACDL_AWS_ACCOUNT_ID, github.repository_id) || '' }}
           aws-region: us-east-1
-        env:
-          ACDL_AWS_ACCESS_KEY_ID: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID }}
-          ACDL_AWS_SECRET_ACCESS_KEY: ${{ secrets.ACDL_AWS_SECRET_ACCESS_KEY }}
+          access-key-id: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID }}
+          secret-access-key: ${{ secrets.ACDL_AWS_SECRET_ACCESS_KEY }}
 
       - name: Run the platform pipeline
         working-directory: ${{ github.workspace }}
@@ -108,15 +115,46 @@ jobs:
             full) MODE_FLAG="" ;;
             plan-only) MODE_FLAG="--plan-only" ;;
             check-only) MODE_FLAG="--check-only" ;;
+            decommission)
+              if [ -z "${{ inputs.changeRequestId }}" ]; then
+                echo "FAIL: changeRequestId is required for decommission mode"
+                exit 1
+              fi
+              MODE_FLAG="--decommission ${{ inputs.changeRequestId }}"
+              ;;
             *) echo "Unknown mode: ${{ inputs.mode }}"; exit 1 ;;
           esac
-          bash platform/scripts/run_platform.sh $MODE_FLAG "${{ inputs.contract }}"
+          ENV_FLAG=""
+          if [ -n "${{ inputs.environment }}" ]; then
+            ENV_FLAG="--environment ${{ inputs.environment }}"
+          fi
+          bash platform/scripts/run_platform.sh $MODE_FLAG $ENV_FLAG "${{ inputs.contract }}"
+
+      - name: Post stage summary comment to PR
+        if: success() && github.event_name == 'pull_request'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_REF: ${{ github.ref }}
+        run: |
+          bash platform/scripts/post_stage_comment.sh deploy pass '{"mode":"${{ inputs.mode }}","runId":"${{ github.run_id }}"}'
+
+      - name: Report error to platform team (on failure)
+        if: failure()
+        env:
+          AWS_DEFAULT_REGION: us-east-1
+        run: |
+          aws lambda invoke-function-url \
+            --function-url "${{ secrets.ACDL_LAMBDA_URL }}" \
+            --cli-binary-format raw-in-base64-out \
+            --payload "$(python3 -c "import json,os; print(json.dumps({'action':'report_error','consumerRepo':os.environ.get('GITHUB_REPOSITORY',''),'contractId':'${{ github.run_id }}','error':'Deploy pipeline failed. See run logs.','runUrl':'${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}','environment':'dev'}))")" \
+            /dev/null || true
 
       - name: Upload emitted Terraform
         uses: actions/upload-artifact@v4
         with:
           name: acdl-terraform
-          path: platform/terraform/spike/*.tf
+          path: /tmp/acdl_platform_run_v18/tf/*.tf
           if-no-files-found: warn
 
       - name: Upload platform log

.github/workflows/ci.yml

@@ -37,7 +37,9 @@ jobs:
           python3 -m py_compile \
             core/confidence_signal.py \
             core/outbox_writer.py \
+            core/output_publisher.py \
             core/contract_resolver.py \
+            core/lambda/contract_ingestor.py \
             adapters/terraform/adapter.py \
             adapters/terraform/policy/checkov_adapter.py \
             scripts/push_consumer_image.py

.github/workflows/deploy.yml

@@ -8,8 +8,8 @@
 # declared difference is the forge/runtime, not the stages or commands.
 #
 # Consumer repos invoke this workflow via a versioned tag (floating MAJOR + MINOR):
-#   uses: acdl/.gitea/workflows/deploy.yml@v1.4   (Gitea)
-#   uses: acdl/.github/workflows/deploy.yml@v1.4  (GitHub)
+#   uses: acdl/.gitea/workflows/deploy.yml@v1.9   (Gitea)
+#   uses: acdl/.github/workflows/deploy.yml@v1.9  (GitHub)
 #
 # Unversioned references (@main, bare) are discouraged — the consumer's setup
 # must be immutable + resilient. The versioned tag is the only immutability
@@ -53,9 +53,17 @@ on:
         type: string
         default: .acdl/contract.yaml
       mode:
-        description: Pipeline mode — full (apply), plan-only, or check-only
+        description: Pipeline mode — full (apply), plan-only, check-only, or decommission
         type: string
         default: full
+      changeRequestId:
+        description: Change request ID (required for decommission mode — validated against CMDB)
+        type: string
+        default: ""
+      environment:
+        description: Target environment override (dev/qa/prod/dr); when empty, the contract's environment field is used
+        type: string
+        default: ""
 
 permissions:
   id-token: write
@@ -74,7 +82,7 @@ jobs:
         with:
           repository: acdl/acdl
           path: platform
-          ref: v1.4
+          ref: v1.9
 
       - uses: actions/setup-python@v5
         with:
@@ -91,14 +99,13 @@ jobs:
           echo "deb [signed-by=/usr/share/keyrings/hashicorp.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
           sudo apt-get update && sudo apt-get install -y terraform=1.9.*
 
-      - name: Configure AWS credentials (OIDC default)
+      - name: Configure AWS credentials (OIDC default + static-key override)
         uses: aws-actions/configure-aws-credentials@v4
         with:
-          role-to-assume: arn:aws:iam::${{ secrets.ACDL_AWS_ACCOUNT_ID }}:role/acdl-deploy-${{ github.repository_id }}
+          role-to-assume: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID == '' && format('arn:aws:iam::{0}:role/acdl-deploy-{1}', secrets.ACDL_AWS_ACCOUNT_ID, github.repository_id) || '' }}
           aws-region: us-east-1
-        env:
-          ACDL_AWS_ACCESS_KEY_ID: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID }}
-          ACDL_AWS_SECRET_ACCESS_KEY: ${{ secrets.ACDL_AWS_SECRET_ACCESS_KEY }}
+          access-key-id: ${{ secrets.ACDL_AWS_ACCESS_KEY_ID }}
+          secret-access-key: ${{ secrets.ACDL_AWS_SECRET_ACCESS_KEY }}
 
       - name: Run the platform pipeline
         working-directory: ${{ github.workspace }}
@@ -108,15 +115,46 @@ jobs:
             full) MODE_FLAG="" ;;
             plan-only) MODE_FLAG="--plan-only" ;;
             check-only) MODE_FLAG="--check-only" ;;
+            decommission)
+              if [ -z "${{ inputs.changeRequestId }}" ]; then
+                echo "FAIL: changeRequestId is required for decommission mode"
+                exit 1
+              fi
+              MODE_FLAG="--decommission ${{ inputs.changeRequestId }}"
+              ;;
             *) echo "Unknown mode: ${{ inputs.mode }}"; exit 1 ;;
           esac
-          bash platform/scripts/run_platform.sh $MODE_FLAG "${{ inputs.contract }}"
+          ENV_FLAG=""
+          if [ -n "${{ inputs.environment }}" ]; then
+            ENV_FLAG="--environment ${{ inputs.environment }}"
+          fi
+          bash platform/scripts/run_platform.sh $MODE_FLAG $ENV_FLAG "${{ inputs.contract }}"
+
+      - name: Post stage summary comment to PR
+        if: success() && github.event_name == 'pull_request'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_REF: ${{ github.ref }}
+        run: |
+          bash platform/scripts/post_stage_comment.sh deploy pass '{"mode":"${{ inputs.mode }}","runId":"${{ github.run_id }}"}'
+
+      - name: Report error to platform team (on failure)
+        if: failure()
+        env:
+          AWS_DEFAULT_REGION: us-east-1
+        run: |
+          aws lambda invoke-function-url \
+            --function-url "${{ secrets.ACDL_LAMBDA_URL }}" \
+            --cli-binary-format raw-in-base64-out \
+            --payload "$(python3 -c "import json,os; print(json.dumps({'action':'report_error','consumerRepo':os.environ.get('GITHUB_REPOSITORY',''),'contractId':'${{ github.run_id }}','error':'Deploy pipeline failed. See run logs.','runUrl':'${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}','environment':'dev'}))")" \
+            /dev/null || true
 
       - name: Upload emitted Terraform
         uses: actions/upload-artifact@v4
         with:
           name: acdl-terraform
-          path: platform/terraform/spike/*.tf
+          path: /tmp/acdl_platform_run_v18/tf/*.tf
           if-no-files-found: warn
 
       - name: Upload platform log

.github/workflows/patterns-plan.yml

@@ -0,0 +1,28 @@
+# ACDL Patterns Plan Pipeline — GitHub Actions (production)
+#
+# Runs on PRs to main. For each L2 module, runs a plan-only (offline
+# --check-only mode: resolves the sample contract for the module, runs the
+# adapter, validates the emitted Terraform structure).
+name: acdl-patterns-plan
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  pattern-plan:
+    name: Pattern plan (${{ matrix.module }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        module: [static-assets, microservice]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: pip install jsonschema pyyaml boto3
+      - name: Pattern plan check (${{ matrix.module }})
+        run: bash scripts/run_pattern_plan.sh --check-only ${{ matrix.module }}

.github/workflows/platform-test.yml

@@ -0,0 +1,146 @@
+# ACDL Platform Test Pipeline — GitHub Actions (production)
+#
+# Runs on PRs to main. Replaces ci.yml for PRs (ci.yml stays for push-to-main).
+# Four stages: lint, unit-test, integration-test, schema-validation.
+#
+# Shell reproducibility: scripts/run_ci.sh runs lint + test + check-only locally.
+# The integration-test stage runs run_platform.sh --check-only for every
+# contracts/*.yaml file. The schema-validation stage validates schemas, module
+# interfaces, compositions, and example contracts.
+name: acdl-platform-test
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Compile all Python files
+        run: |
+          python3 -m py_compile \
+            core/confidence_signal.py \
+            core/outbox_writer.py \
+            core/contract_resolver.py \
+            core/environment_check.py \
+            core/output_publisher.py \
+            core/lambda/contract_ingestor.py \
+            adapters/terraform/adapter.py \
+            adapters/terraform/policy/checkov_adapter.py \
+            adapters/wiz/wiz_adapter.py \
+            adapters/kyverno/kyverno_adapter.py \
+            scripts/push_consumer_image.py
+
+  unit-test:
+    name: Unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install test dependencies
+        run: pip install -r requirements-test.txt
+      - name: Run pytest
+        run: python3 -m pytest tests/ -v --tb=short
+
+  integration-test:
+    name: Integration test (all sample contracts)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install runtime dependencies
+        run: pip install jsonschema pyyaml boto3
+      - name: Run platform check-only for every sample contract
+        run: |
+          for contract in contracts/*.yaml; do
+            echo "--- Testing $contract ---"
+            bash scripts/run_platform.sh --check-only "$contract"
+          done
+
+  schema-validation:
+    name: Schema + module validation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: pip install jsonschema pyyaml
+      - name: Validate all schemas
+        run: |
+          python3 -c "
+          import json, glob, jsonschema
+          for schema_file in glob.glob('schemas/*.json'):
+              if 'contract.schema' in schema_file:
+                  continue  # has no self-validation
+              schema = json.load(open(schema_file))
+              # self-validate if it has a \$id
+              try:
+                  jsonschema.Draft202012Validator.check_schema(schema)
+              except jsonschema.SchemaError as e:
+                  raise SystemExit(f'{schema_file}: {e}')
+              print(f'{schema_file}: valid')
+          "
+      - name: Validate all module interfaces against stack.schema.json
+        run: |
+          python3 -c "
+          import json, glob, jsonschema, os
+          stack_schema = json.load(open('schemas/stack.schema.json'))
+          for iface_file in glob.glob('modules/l1/*/interface.json'):
+              try:
+                  iface = json.load(open(iface_file))
+                  # Validate basic structure (name, version, kind, type, inputs, outputs)
+                  assert 'name' in iface, f'{iface_file}: missing name'
+                  assert 'version' in iface, f'{iface_file}: missing version'
+                  assert 'kind' in iface, f'{iface_file}: missing kind'
+                  assert iface['kind'] == 'l1', f'{iface_file}: expected kind=l1'
+                  assert 'type' in iface, f'{iface_file}: missing type'
+                  assert 'inputs' in iface, f'{iface_file}: missing inputs'
+                  assert 'outputs' in iface, f'{iface_file}: missing outputs'
+                  print(f'{iface_file}: valid L1')
+              except Exception as e:
+                  raise SystemExit(f'{iface_file}: {e}')
+          for comp_file in glob.glob('modules/l2/*/composition.json'):
+              try:
+                  comp = json.load(open(comp_file))
+                  assert 'name' in comp, f'{comp_file}: missing name'
+                  assert 'version' in comp, f'{comp_file}: missing version'
+                  assert 'kind' in comp, f'{comp_file}: missing kind'
+                  assert comp['kind'] == 'l2', f'{comp_file}: expected kind=l2'
+                  assert 'children' in comp, f'{comp_file}: missing children'
+                  assert 'wires' in comp, f'{comp_file}: missing wires'
+                  assert 'outputs' in comp, f'{comp_file}: missing outputs'
+                  print(f'{comp_file}: valid L2')
+              except Exception as e:
+                  raise SystemExit(f'{comp_file}: {e}')
+          "
+      - name: Validate module example contracts
+        run: |
+          python3 -c "
+          import json, yaml, glob, jsonschema
+          schema = json.load(open('schemas/contract.schema.json'))
+          # Validate example contracts if they exist
+          for example in glob.glob('modules/*/*/examples/*.yaml'):
+              try:
+                  contract = yaml.safe_load(open(example))
+                  jsonschema.validate(contract, schema)
+                  print(f'{example}: valid contract')
+              except Exception as e:
+                  print(f'{example}: SKIP (not a contract or invalid: {e})')
+          # Also validate all sample contracts in contracts/
+          for contract_file in glob.glob('contracts/*.yaml'):
+              contract = yaml.safe_load(open(contract_file))
+              jsonschema.validate(contract, schema)
+              print(f'{contract_file}: valid contract')
+          "

.github/workflows/primitives-plan.yml

@@ -0,0 +1,28 @@
+# ACDL Primitives Plan Pipeline — GitHub Actions (production)
+#
+# Runs on PRs to main. For each L1 primitive, runs a plan-only (offline
+# --check-only mode: resolves the primitive's instance.json, runs the adapter,
+# validates the emitted Terraform structure).
+name: acdl-primitives-plan
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  primitive-plan:
+    name: Primitive plan (${{ matrix.primitive }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        primitive: [s3, vpc, ecs-cluster, ecs-service, iam-role, alb, ecr, cloudfront, waf, rds]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: pip install jsonschema pyyaml boto3
+      - name: Primitive plan check (${{ matrix.primitive }})
+        run: bash scripts/run_primitive_plan.sh --check-only ${{ matrix.primitive }}

.github/workflows/release.yml

@@ -0,0 +1,92 @@
+# ACDL Release Pipeline — GitHub Actions (production)
+#
+# Runs on push to main. Computes the next semver tag from the latest tag +
+# commit history, creates the tag, updates floating MAJOR.MINOR and MAJOR tags,
+# and creates a GitHub release with auto-generated notes.
+#
+# Semver policy:
+#   - Regular phase commit -> bump PATCH (v1.6.0 -> v1.6.1)
+#   - Milestone completion ("docs(milestone): complete") -> bump MINOR (v1.6.1 -> v1.7.0)
+#   - Major bumps are manual (not implemented here).
+name: acdl-release
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  release:
+    name: Compute semver + update tags
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # need full history for tag computation
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Compute next version
+        id: version
+        run: |
+          # Get the latest tag
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          echo "Latest tag: $LATEST_TAG"
+
+          # Parse the version
+          MAJOR=$(echo "$LATEST_TAG" | sed -n 's/v\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\1/p')
+          MINOR=$(echo "$LATEST_TAG" | sed -n 's/v\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\2/p')
+          PATCH=$(echo "$LATEST_TAG" | sed -n 's/v\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\3/p')
+
+          # Check if this is a milestone completion (look for "docs(milestone): complete" in the latest commits)
+          if git log --format='%s' -5 | grep -q 'docs(milestone): complete'; then
+            # Milestone completion -> bump minor
+            MINOR=$((MINOR + 1))
+            PATCH=0
+          else
+            # Regular phase -> bump patch
+            PATCH=$((PATCH + 1))
+          fi
+
+          NEW_TAG="v${MAJOR}.${MINOR}.${PATCH}"
+          MAJOR_MINOR_TAG="v${MAJOR}.${MINOR}"
+          MAJOR_TAG="v${MAJOR}"
+
+          echo "new_tag=$NEW_TAG" >> $GITHUB_OUTPUT
+          echo "major_minor_tag=$MAJOR_MINOR_TAG" >> $GITHUB_OUTPUT
+          echo "major_tag=$MAJOR_TAG" >> $GITHUB_OUTPUT
+          echo "Next version: $NEW_TAG"
+
+      - name: Create version tag
+        run: |
+          git tag ${{ steps.version.outputs.new_tag }}
+          git push origin ${{ steps.version.outputs.new_tag }}
+
+      - name: Update floating MAJOR.MINOR tag
+        run: |
+          git tag -f ${{ steps.version.outputs.major_minor_tag }} ${{ steps.version.outputs.new_tag }}
+          git push origin ${{ steps.version.outputs.major_minor_tag }} --force
+
+      - name: Update floating MAJOR tag
+        run: |
+          git tag -f ${{ steps.version.outputs.major_tag }} ${{ steps.version.outputs.new_tag }}
+          git push origin ${{ steps.version.outputs.major_tag }} --force
+
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Generate release body from commit history since last tag
+          PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+          if [ -n "$PREV_TAG" ]; then
+            BODY=$(git log --format='- %s' "$PREV_TAG"..HEAD)
+          else
+            BODY=$(git log --format='- %s' HEAD)
+          fi
+          gh release create ${{ steps.version.outputs.new_tag }} \
+            --title "ACDL ${{ steps.version.outputs.new_tag }}" \
+            --notes "$BODY" \
+            --generate-notes || true

README.md

@@ -76,8 +76,8 @@ Planned future features (no dates; tracked in the internal roadmap):
   consumer creates a module directly from the contract file (the
   "composition" mechanism, redesigned).
 - **Compliance milestone** — per-module compliance extension points (GDPR,
-  SOX, SOC2, HIPAA, DORA) wired into the pipeline.
-- **Additional substrate adapters** — beyond the Terraform adapter.
+  SOX, SOC2, DORA) wired into the pipeline.
+- **Additional engine adapters** — beyond the Terraform adapter.
 - **Environment self-service** — a consumer-facing flow to request and
   provision a new platform-managed environment (today it is a platform-team
   action).
@@ -117,9 +117,9 @@ flowchart TD
 
 The platform validates the architecture's claim that the **stack
 commitments do not require a polyglot mess**: the adapter is the only
-substrate-specific code. `modules/`, `schemas/`, `contracts/`,
+engine-specific code. `modules/`, `schemas/`, `contracts/`,
 `core/confidence_signal.py`, `core/contract_resolver.py`, and
-`core/outbox_writer.py` are all substrate-agnostic (no `aws_s3_bucket` /
+`core/outbox_writer.py` are all engine-agnostic (no `aws_s3_bucket` /
 `aws_` infrastructure terms).
 
 ## How to run
@@ -155,15 +155,15 @@ ACDL_BOOTSTRAP_AWS_ACCESS_KEY_ID=... ACDL_BOOTSTRAP_AWS_SECRET_ACCESS_KEY=... \
 # 3. Run the full platform pipeline (contract -> environment check -> stack ->
 #    adapter -> security checks -> infrastructure plan -> policy checks ->
 #    confidence -> evidence event -> apply). Output is streamed to stdout.
-bash scripts/run_platform.sh contracts/static-asset.yaml
+bash scripts/run_platform.sh contracts/static-assets.yaml
 # Expected: "=== PLATFORM E2E OK ==="
 
 # Or plan-only (contract -> stack -> adapter -> infrastructure plan; no
 # policy checks / outbox):
-bash scripts/run_platform.sh --plan-only contracts/static-asset.yaml
+bash scripts/run_platform.sh --plan-only contracts/static-assets.yaml
 
 # Add --quiet to suppress streaming (output to log files only):
-bash scripts/run_platform.sh --quiet contracts/static-asset.yaml
+bash scripts/run_platform.sh --quiet contracts/static-assets.yaml
 ```
 
 ### Test the platform (offline, no AWS required)
@@ -176,7 +176,7 @@ pip install -r requirements-test.txt
 python3 -m pytest tests/ -v
 
 # Run the platform in check-only mode (offline — no AWS, no policy checks,
-# no outbox). Uses the default sample contract (contracts/static-asset.yaml)
+# no outbox). Uses the default sample contract (contracts/static-assets.yaml)
 # and the sample dev environment (core/environments/dev.json).
 bash scripts/run_platform.sh --check-only
 # Expected: "=== PLATFORM CHECK OK ==="
@@ -222,7 +222,7 @@ The workflow implements the same stages as `pipelines/deploy.yaml`
 (validate-contract → resolve-stack → security checks → infrastructure plan
 → policy checks → confidence → evidence event → apply). A consumer repo
 invokes the reusable workflow via a **versioned tag** (floating MAJOR +
-MINOR, e.g. `acdl/.github/workflows/deploy.yml@v1.4`). The workflow checks
+MINOR, e.g. `acdl/.github/workflows/deploy.yml@v1.6`). The workflow checks
 out the consumer repo, then checks out the ACDL platform repo into the
 runner workspace, and runs `scripts/run_platform.sh` against the consumer's
 contract — the consumer never clones the platform repo or invokes its
@@ -249,7 +249,7 @@ backwards-compatible log-only mode.
 A step-by-step guide for a consumer to create their pipeline and define a
 contract that deploys any ACDL module to AWS is at
 [`docs/consumer-guide.md`](docs/consumer-guide.md). The guide is generic
-across all modules; `static-asset` is the worked example.
+across all modules; `static-assets` is the worked example.
 
 ## Repository layout
 
@@ -258,10 +258,10 @@ across all modules; `static-asset` is the worked example.
 | `core/` | Platform code: contract resolver, confidence signal, outbox writer, environment check, environments, separation of duties, HITL/ledger designs | active |
 | `schemas/` | JSON Schemas: stack, contract, PolicyCheckResult, pipeline contract, deploy pipeline contract (draft 2020-12) | active |
 | `pipelines/` | Central pipeline contracts: `ci.yaml` (CI), `deploy.yaml` (deployment) | active |
-| `adapters/` | Substrate adapters — the substrate adapter (the only substrate-specific code per §12) + the policy adapter | active |
+| `adapters/` | Angine adapters — the engine adapter (the only engine-specific code per §12) + the policy adapter | active |
 | `terraform/` | State backend (S3 + DynamoDB) + platform TF (`terraform/spike/`) + bootstrap scripts (`terraform/bootstrap/`) | active |
-| `modules/` | Primitives + modules + `registry.json`. Primitives: s3, vpc, ecs-cluster, ecs-service, iam-role, alb, ecr. Modules: microservice, static-asset | active |
-| `contracts/` | Sample consumer contracts (e.g. `static-asset.yaml`) | active |
+| `modules/` | Primitives + modules + `registry.json`. Primitives: s3, vpc, ecs-cluster, ecs-service, iam-role, alb, ecr, cloudfront, waf, rds. Modules: microservice, static-assets. Each module has a `examples/` directory with validated contract examples | active |
+| `contracts/` | Sample consumer contracts (`static-assets.yaml`, `microservice.yaml`) | active |
 | `scripts/` | Platform run script (`run_platform.sh` with `--check-only`/`--plan-only`/`--quiet`), CI pipeline script (`run_ci.sh`), key rotation | active |
 | `tests/` | Pytest suite (all offline — adapter, confidence signal, policy adapter, outbox writer, pipeline contract, contract resolver, streaming, environment check) | active |
 | `.github/workflows/` | GitHub Actions workflows: `ci.yml` (CI), `deploy.yml` (reusable deploy, invoked by consumer repos) | active |

adapters/README.md

@@ -0,0 +1,65 @@
+# ACDL Adapters
+
+## Overview
+
+Adapters translate the engine-agnostic Target Stack IR to engine-specific formats. The Terraform adapter is the primary adapter (IR → HCL). Policy adapters translate security tool output into normalized `PolicyCheckResult` records that the confidence signal consumes in an engine-agnostic way.
+
+## Existing Adapters
+
+| Adapter | Path | Input | Output | Purpose |
+| --- | --- | --- | --- | --- |
+| Terraform adapter | `adapters/terraform/adapter.py` | Stack instance JSON | Terraform HCL (`main.tf`, `terraform.tf`, `providers.tf`) | Compiles IR to Terraform |
+| Checkov adapter | `adapters/terraform/policy/checkov_adapter.py` | Checkov JSON | `PolicyCheckResult` records | Translates Checkov results |
+| Wiz adapter | `adapters/wiz/wiz_adapter.py` | Wiz API issues JSON | `PolicyCheckResult` records | Translates Wiz security findings |
+| Kyverno adapter | `adapters/kyverno/kyverno_adapter.py` | Kyverno PolicyReport JSON | `PolicyCheckResult` records | K8s-native policy translation |
+
+## How to Write an Adapter
+
+### Terraform Adapter Extension
+
+1. Add a stack type → Terraform type mapping to `TYPE_MAP`.
+2. Add non-identity input mappings to `INPUT_MAP`.
+3. Add non-identity output mappings to `OUTPUT_MAP`.
+4. Add a specialized `_emit_resource` branch if the resource needs nested blocks (e.g. inline policies, rule sets).
+
+### Policy Adapter Pattern
+
+1. Define `SEVERITY_MAP` and `RESULT_MAP` dicts that translate the engine's native severity/result vocabulary to the `PolicyCheckResult` enums.
+2. Implement `_to_pcr(raw_record, contract_id)` → `PolicyCheckResult` dict.
+3. Implement `adapt(input_path, contract_id)` → list of `PolicyCheckResult` dicts.
+4. Implement `is_configured()` → bool (env var check) so the platform can skip the adapter when credentials are absent.
+
+## How to Wire an Adapter
+
+- **Terraform adapter** — invoked by `scripts/run_platform.sh` Step 3 (`terraform-plan`).
+- **Checkov adapter** — invoked by `scripts/run_platform.sh` Step 5 (`checkov`).
+- **Wiz / Kyverno adapters** — optional Steps 5b/5c, run only when the relevant env vars are set.
+- All policy adapters output records that are validated against `schemas/policy_check_result.schema.json`.
+
+## Dependencies
+
+- `jsonschema`, `pyyaml` — used by all adapters for loading and validating inputs.
+- `boto3` — used by the Wiz adapter for AWS API access.
+- `checkov` — used by the Checkov adapter to run policy scans.
+- No external deps for the Terraform adapter (pure Python).
+
+## How to Test Adapters
+
+- `tests/test_adapter.py` — Terraform adapter (`TYPE_MAP`, resource emission, refs, outputs).
+- `tests/test_checkov_adapter.py` — Checkov adapter.
+- `tests/test_wiz_adapter.py` — Wiz adapter.
+- `tests/test_kyverno_adapter.py` — Kyverno adapter.
+- All adapter tests load fixtures from `tests/fixtures/` and use `moto` for AWS mocking.
+
+## Where to Write Tests
+
+- `tests/test_<adapter_name>.py` paired with `tests/fixtures/<adapter>_fixture.json`.
+
+## Adding a New Adapter
+
+1. Create `adapters/<name>/<name>_adapter.py`.
+2. Implement `adapt()` and (for policy adapters) `is_configured()`.
+3. Add the adapter's engine name to the `engine` enum in `schemas/policy_check_result.schema.json` if it is a policy adapter.
+4. Write a test (`tests/test_<name>_adapter.py`) plus a fixture (`tests/fixtures/<name>_fixture.json`).
+5. Add it to `scripts/run_platform.sh` if it is invoked at runtime.
+6. Update this README.

adapters/kyverno/README.md

@@ -0,0 +1,68 @@
+# Kyverno Adapter
+
+The Kyverno adapter translates Kyverno `PolicyReport` results to the
+normalized ACDL
+[`PolicyCheckResult`](../../schemas/policy_check_result.schema.json) schema
+(engine: `"kyverno"`), mirroring the Checkov/Wiz adapter pattern.
+
+## What Kyverno is
+
+[Kyverno](https://kyverno.io/) is a Kubernetes-native policy engine. It
+runs as an admission controller inside a cluster, validates / mutates /
+generates K8s resources against declarative `ClusterPolicy` rules, and
+publishes results to `PolicyReport` resources.
+
+## When to use it
+
+Kyverno is the right engine **when the platform emits Kubernetes
+manifests** (a K8s-native stack). The ACDL platform today emits Terraform
+only (D-053), so this adapter is **ready but inactive**: it ships now so
+the schema path, severity/result mapping and sample policies are in place
+ahead of the GitOps reconciler that will emit K8s manifests (roadmap).
+
+## How the adapter translates PolicyReport results
+
+`kyverno_adapter.py <policyreport.json> <contract-id>` reads a JSON file
+containing a Kyverno `PolicyReport` (or just its `.results[]` array) and
+emits a list of `PolicyCheckResult` dicts:
+
+| Kyverno PolicyReport result field | PolicyCheckResult field |
+|-----------------------------------|-------------------------|
+| `policy`                          | `ruleId` (default `KYVERNO_UNKNOWN`) |
+| `severity`                        | `severity` (lower-cased, mapped) |
+| `result`                          | `result` (`pass`/`fail`/`error` as-is, `warn`/`skip`→`skipped`) |
+| `message`                         | `message` |
+| `resource`                        | `resourceRef` + `evidence.resource` |
+| `namespace`, `kind`, `name`       | `evidence.*` |
+
+The adapter is read-only against a local JSON fixture; the GitOps
+reconciler is responsible for fetching the live `PolicyReport` and writing
+the file. When there are zero results, the adapter returns an empty list
+(unlike Wiz it does not synthesize a SKIPPED record — Kyverno not running
+is a deployment state, not a configuration gap).
+
+## Roadmap dependency
+
+This adapter activates when the GitOps reconciler (roadmap) emits K8s
+manifests. Until then it is documentation-only; the pipeline does not
+invoke it. The `engine: "kyverno"` enum value is present in
+`schemas/policy_check_result.schema.json` so future records validate.
+
+## Sample policies
+
+The `policies/` directory holds three valid Kyverno `ClusterPolicy`
+manifests (documentation-only today — the platform does not run them):
+
+- `disallow-privileged-containers.yaml` — fail pods with
+  `securityContext.privileged: true`.
+- `require-resource-labels.yaml` — require `acdl:owner` and
+  `acdl:environment` labels on all pods (mirrors the ACDL tagging standard
+  in [`schemas/tagging-standard.json`](../../schemas/tagging-standard.json)).
+- `require-image-digests.yaml` — require container images to reference a
+  digest (`image@sha256:...`), not a mutable tag.
+
+## Schema path
+
+The output records validate against
+[`schemas/policy_check_result.schema.json`](../../schemas/policy_check_result.schema.json)
+(`engine: "kyverno"` was already in the enum and is retained in Phase 23).

adapters/kyverno/kyverno_adapter.py

@@ -0,0 +1,136 @@
+"""Kyverno adapter — translate Kyverno PolicyReport results to ACDL PolicyCheckResult records.
+
+Kyverno is a Kubernetes-native policy engine. It evaluates K8s manifests
+and produces PolicyReport resources. This adapter translates those results
+to the normalized PolicyCheckResult schema (engine: "kyverno").
+
+v1.9 (REQ-111): the translator is fleshed out — full PolicyReport →
+PolicyCheckResult mapping with severity + skip-with-reason handling. It
+remains inactive for Terraform-only stacks (guard preserved — emits a
+single SKIPPED `KYVERNO_INACTIVE_TF_STACK` record when no K8s manifests).
+A `--kube-version` stub is parsed but not yet used (for future GitOps).
+
+D-053: the platform emits Terraform, not K8s manifests. This adapter
+activates when the GitOps reconciler (roadmap) emits K8s manifests.
+Sample policies are included as documentation at adapters/kyverno/policies/.
+
+CLI: kyverno_adapter.py <policyreport.json> <contract-id> [--kube-version <ver>]
+"""
+
+import datetime
+import json
+import os
+import sys
+
+
+SEVERITY_MAP = {
+    "critical": "critical",
+    "high": "high",
+    "medium": "medium",
+    "low": "low",
+    "info": "info",
+    "informational": "info",
+}
+
+RESULT_MAP = {
+    "pass": "pass",
+    "fail": "fail",
+    "warn": "skipped",
+    "warning": "skipped",
+    "error": "error",
+    "skip": "skipped",
+    "skipped": "skipped",
+}
+
+
+def _iso8601_now():
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _to_pcr(entry, contract_id):
+    severity_raw = entry.get("severity", "info")
+    severity = SEVERITY_MAP.get(str(severity_raw).lower(), "info")
+    result_raw = entry.get("result", "skip")
+    result = RESULT_MAP.get(str(result_raw).lower(), "error")
+    # Skip-with-reason: a skipped result carries a message that explains why.
+    message = entry.get("message", "")
+    if result == "skipped" and not message:
+        message = entry.get("skipReason", entry.get("skippedMessage", "skipped (no reason)"))
+    policy = entry.get("policy", "")
+    rule = entry.get("rule", "")
+    rule_id = f"{policy}/{rule}" if rule else (policy or "KYVERNO_UNKNOWN")
+    resource = entry.get("resource", "")
+    if not resource and entry.get("name"):
+        # Construct a resource ref from kind/name/namespace when present.
+        kind = entry.get("kind", "")
+        ns = entry.get("namespace", "")
+        resource = f"{kind}/{ns}/{entry.get('name')}" if kind else entry.get("name", "")
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": rule_id,
+        "severity": severity,
+        "result": result,
+        "message": message,
+        "evidence": {
+            "resource": resource,
+            "namespace": entry.get("namespace", ""),
+            "kind": entry.get("kind", ""),
+            "name": entry.get("name", ""),
+            "policy": policy,
+            "rule": rule,
+        },
+        "resourceRef": resource,
+    }
+
+
+def _emit_inactive_tf(contract_id):
+    """Emit a SKIPPED record when the platform emits Terraform, not K8s manifests."""
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": "KYVERNO_INACTIVE_TF_STACK",
+        "severity": "info",
+        "result": "skipped",
+        "message": "Kyverno inactive — the platform emits Terraform, not K8s manifests. Activates when the GitOps reconciler emits K8s manifests (D-053).",
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+def adapt(policyreport_json_path, contract_id, kube_version=None):
+    with open(policyreport_json_path, "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    out = []
+    # Kyverno PolicyReport has a .results[] array.
+    results = data.get("results", [])
+    if not isinstance(results, list):
+        results = []
+    for entry in results:
+        out.append(_to_pcr(entry, contract_id))
+    if not out:
+        out.append(_emit_inactive_tf(contract_id))
+    # kube_version is parsed but not yet used (future GitOps reconciler).
+    _ = kube_version
+    return out
+
+
+def adapt_inactive(contract_id):
+    """Convenience: emit the inactive-for-TF record directly (no report file)."""
+    return [_emit_inactive_tf(contract_id)]
+
+
+if __name__ == "__main__":
+    kube_ver = None
+    args = sys.argv[1:]
+    if "--kube-version" in args:
+        idx = args.index("--kube-version")
+        if idx + 1 < len(args):
+            kube_ver = args[idx + 1]
+            args = args[:idx] + args[idx + 2:]
+    if len(args) != 2:
+        print("usage: kyverno_adapter.py <policyreport.json> <contract-id> [--kube-version <ver>]", file=sys.stderr)
+        sys.exit(2)
+    print(json.dumps(adapt(args[0], args[1], kube_version=kube_ver), indent=2))

adapters/kyverno/policies/disallow-privileged-containers.yaml

@@ -0,0 +1,27 @@
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: disallow-privileged-containers
+  annotations:
+    policies.kyverno.io/title: Disallow Privileged Containers
+    policies.kyverno.io/category: Security
+    policies.kyverno.io/severity: high
+    policies.kyverno.io/subject: Pod
+spec:
+  validationFailureAction: audit
+  background: true
+  rules:
+    - name: require-non-privileged
+      match:
+        any:
+          - resources:
+              kinds:
+                - Pod
+      validate:
+        message: "Privileged containers are not allowed. Set securityContext.privileged to false."
+        pattern:
+          spec:
+            containers:
+              - name: "*"
+                securityContext:
+                  privileged: "false"

adapters/kyverno/policies/require-image-digests.yaml

@@ -0,0 +1,26 @@
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: require-image-digests
+  annotations:
+    policies.kyverno.io/title: Require Image Digests
+    policies.kyverno.io/category: Supply Chain
+    policies.kyverno.io/severity: high
+    policies.kyverno.io/subject: Pod
+spec:
+  validationFailureAction: audit
+  background: true
+  rules:
+    - name: require-digest-reference
+      match:
+        any:
+          - resources:
+              kinds:
+                - Pod
+      validate:
+        message: "Container images must reference a digest (e.g. image@sha256:...), not a mutable tag."
+        pattern:
+          spec:
+            containers:
+              - name: "*"
+                image: "*@sha256:*"

adapters/kyverno/policies/require-resource-labels.yaml

@@ -0,0 +1,37 @@
+apiVersion: kyverno.io/v1
+kind: ClusterPolicy
+metadata:
+  name: require-resource-labels
+  annotations:
+    policies.kyverno.io/title: Require ACDL Resource Labels
+    policies.kyverno.io/category: Governance
+    policies.kyverno.io/severity: medium
+    policies.kyverno.io/subject: Pod
+spec:
+  validationFailureAction: audit
+  background: true
+  rules:
+    - name: require-acdl-owner-label
+      match:
+        any:
+          - resources:
+              kinds:
+                - Pod
+      validate:
+        message: "Pods must carry the acdl:owner label (ACDL tagging standard)."
+        pattern:
+          metadata:
+            labels:
+              acdl:owner: "?*"
+    - name: require-acdl-environment-label
+      match:
+        any:
+          - resources:
+              kinds:
+                - Pod
+      validate:
+        message: "Pods must carry the acdl:environment label (ACDL tagging standard)."
+        pattern:
+          metadata:
+            labels:
+              acdl:environment: "?*"

adapters/terraform/adapter.py

@@ -6,7 +6,7 @@ root module that calls the L1 modules, the stack-typed relationships to
 Terraform module references, and emits a Terraform plan from the stack.
 
 The adapter is a THIN LAYER; it does not own L1/L2 content — it only
-translates. Substrate-agnostic in, Terraform out.
+translates. Angine-agnostic in, Terraform out.
 
 Phase 09 spike: handled one L1 (s3, stack type aws:s3:bucket).
 Phase 13: generalized the resource/output emission via TYPE_MAP +
@@ -21,7 +21,7 @@ import os
 import sys
 
 
-# Stack type -> Terraform resource type. The only substrate-specific table.
+# Stack type -> Terraform resource type. The only engine-specific table.
 # As more L1s land, this grows; the L1 content + stack do not change.
 TYPE_MAP = {
     "aws:s3:bucket": "aws_s3_bucket",
@@ -36,6 +36,13 @@ TYPE_MAP = {
     "aws:elbv2:listener": "aws_lb_listener",
     "aws:elbv2:targetgroup": "aws_lb_target_group",
     "aws:ecr:repository": "aws_ecr_repository",
+    "aws:cloudfront:distribution": "aws_cloudfront_distribution",
+    "aws:cloudfront:originaccesscontrol": "aws_cloudfront_origin_access_control",
+    "aws:wafv2:webacl": "aws_wafv2_web_acl",
+    "aws:rds:instance": "aws_db_instance",
+    "aws:kms:key": "aws_kms_key",
+    "aws:kms:alias": "aws_kms_alias",
+    "aws:ecs:uptime-service": "aws_ecs_service",
 }
 
 # Stack input name -> Terraform arg name, per stack type. Only non-identity
@@ -54,6 +61,12 @@ INPUT_MAP = {
     "aws:elbv2:listener": {},
     "aws:elbv2:targetgroup": {"port": "port", "protocol": "protocol"},
     "aws:ecr:repository": {},
+    "aws:cloudfront:distribution": {"bucket_regional_domain_name": "origin_domain_name", "price_class": "price_class", "viewer_protocol_policy": "viewer_protocol_policy", "default_ttl": "default_ttl", "max_ttl": "max_ttl", "waf_web_acl_arn": "web_acl_id"},
+    "aws:cloudfront:originaccesscontrol": {"name": "name", "origin_type": "origin_access_control_origin_type", "signing_behavior": "origin_access_control_signing_behavior"},
+    "aws:wafv2:webacl": {"name": "name", "scope": "scope", "default_action": "default_action", "rules": "rules"},
+    "aws:rds:instance": {"db_name": "db_name", "instance_class": "instance_class", "allocated_storage": "allocated_storage", "engine": "engine", "engine_version": "engine_version", "username": "username", "multi_az": "multi_az", "storage_encrypted": "storage_encrypted"},
+    "aws:kms:key": {"description": "description", "deletion_window_days": "deletion_window_in_days"},
+    "aws:kms:alias": {},
 }
 
 # Stack output name -> Terraform attribute name, per stack type. Only
@@ -62,7 +75,7 @@ INPUT_MAP = {
 OUTPUT_MAP = {
     "aws:s3:bucket": {"bucket_arn": "arn", "bucket_name": "id"},
     "aws:ec2:vpc": {"vpc_id": "id"},
-    "aws:ec2:subnet": {"subnet_id": "id"},
+    "aws:ec2:subnet": {"subnet_ids": "id", "subnet_id": "id"},
     "aws:ec2:routetable": {},
     "aws:ecs:cluster": {"cluster_arn": "arn", "cluster_id": "id"},
     "aws:ecs:task_definition": {"task_def_arn": "arn"},
@@ -72,6 +85,12 @@ OUTPUT_MAP = {
     "aws:elbv2:listener": {"listener_arn": "id"},
     "aws:elbv2:targetgroup": {"target_group_arn": "arn"},
     "aws:ecr:repository": {"repository_arn": "arn"},
+    "aws:cloudfront:distribution": {"distribution_arn": "arn", "distribution_domain_name": "domain_name", "oac_id": "origin_access_control_id"},
+    "aws:cloudfront:originaccesscontrol": {"oac_id": "id"},
+    "aws:wafv2:webacl": {"web_acl_arn": "arn"},
+    "aws:rds:instance": {"db_endpoint": "endpoint", "db_arn": "arn"},
+    "aws:kms:key": {"kms_key_arn": "arn", "kms_key_id": "key_id"},
+    "aws:kms:alias": {},
 }
 
 
@@ -185,6 +204,23 @@ def _emit_resource(resource, type_by_id=None):
         if rtype == "aws:ecs:service" and in_name in ("subnets", "security_group"):
             # Collected into network_configuration block (emitted after all inputs).
             continue
+        if rtype == "aws:cloudfront:distribution" and in_name in (
+            "bucket_regional_domain_name", "price_class", "viewer_protocol_policy",
+            "default_ttl", "max_ttl", "waf_web_acl_arn", "oac_id",
+        ):
+            # Collected into the origin/default_cache_behavior/web_acl_id blocks
+            # emitted after all inputs.
+            continue
+        if rtype == "aws:cloudfront:originaccesscontrol" and in_name in (
+            "name", "origin_type", "signing_behavior",
+        ):
+            # Defaults emitted after all inputs.
+            continue
+        if rtype == "aws:wafv2:webacl" and in_name in (
+            "name", "scope", "default_action", "rules",
+        ):
+            # Structured blocks emitted after all inputs.
+            continue
         body.append(f"{arg} = {_value_expr(value, type_by_id)}")
     if rtype == "aws:ecs:service":
         subnets_val = inputs.get("subnets")
@@ -199,8 +235,10 @@ def _emit_resource(resource, type_by_id=None):
             else _tf_value([sg_val] if isinstance(sg_val, str) else sg_val or [])
         ))
         body.append("}")
-        body.append("desired_count = 1")
-        body.append("launch_type = \"FARGATE\"")
+        desired = inputs.get("desired_count", 1)
+        launch = inputs.get("launch_type", "FARGATE")
+        body.append(f"desired_count = {desired}")
+        body.append(f'launch_type = "{launch}"')
         body.append("task_definition = aws_ecs_task_definition.service-taskdefinition.arn")
         body.append("name = \"acdl-microservice\"")
     nfrs = resource.get("nfrs", {})
@@ -233,9 +271,11 @@ def _emit_resource(resource, type_by_id=None):
         body.append("}")
         body.append("load_balancer_arn = aws_lb.alb-loadbalancer.id")
     if rtype == "aws:elbv2:loadbalancer":
-        body.append("load_balancer_type = \"application\"")
+        lb_type = inputs.get("load_balancer_type", "application")
+        body.append(f'load_balancer_type = "{lb_type}"')
     if rtype == "aws:elbv2:targetgroup":
-        body.append("target_type = \"ip\"")
+        tgt_type = inputs.get("target_type", "ip")
+        body.append(f'target_type = "{tgt_type}"')
         body.append("vpc_id = aws_vpc.vpc-vpc.id")
         body.append("protocol = \"HTTP\"")
     if rtype == "aws:ec2:routetable":
@@ -244,7 +284,228 @@ def _emit_resource(resource, type_by_id=None):
         body.append("  gateway_id = aws_internet_gateway.vpc-igw.id")
         body.append("}")
         body.append("tags = {")
-        body.append('  Name = "acdl-microservice-rt"')
+        rt_name = inputs.get("name", "app")
+        body.append(f'  Name = "{rt_name}-rt"')
+        body.append("}")
+    if rtype == "aws:cloudfront:originaccesscontrol":
+        name = inputs.get("name", "acdl-oac")
+        if isinstance(name, str) and name.startswith("ref:"):
+            name = _ref_expr(name, type_by_id)
+        else:
+            name = _tf_value(name)
+        body.append(f"name = {name}")
+        body.append("origin_access_control_origin_type = \"s3\"")
+        body.append("origin_access_control_signing_behavior = \"always\"")
+    if rtype == "aws:cloudfront:distribution":
+        origin_domain = inputs.get("bucket_regional_domain_name")
+        if isinstance(origin_domain, str) and origin_domain.startswith("ref:"):
+            origin_domain = _ref_expr(origin_domain, type_by_id)
+        else:
+            origin_domain = _tf_value(origin_domain)
+        # The OAC resource id follows the convention "<childId>-originaccesscontrol";
+        # derive it from this distribution's id.
+        if rid.endswith("-distribution"):
+            oac_rid = rid[: -len("distribution")] + "originaccesscontrol"
+        else:
+            oac_rid = "cloudfront-originaccesscontrol"
+        body.append("origin {")
+        body.append(f"  domain_name = {origin_domain}")
+        body.append(f"  origin_access_control = aws_cloudfront_origin_access_control.{oac_rid}.id")
+        body.append("  s3_origin_config {}")
+        body.append("}")
+        body.append("enabled = true")
+        price_class = inputs.get("price_class", "PriceClass_100")
+        vpp = inputs.get("viewer_protocol_policy", "redirect-to-https")
+        default_ttl = inputs.get("default_ttl", 3600)
+        max_ttl = inputs.get("max_ttl", 86400)
+        body.append("default_cache_behavior {")
+        body.append(f"  viewer_protocol_policy = {_value_expr(vpp, type_by_id)}")
+        body.append(f"  target_origin_id = {_tf_value(rid)}")
+        body.append("  min_ttl = 0")
+        body.append(f"  default_ttl = {_value_expr(default_ttl, type_by_id)}")
+        body.append(f"  max_ttl = {_value_expr(max_ttl, type_by_id)}")
+        body.append("  allowed_methods = [\"GET\", \"HEAD\"]")
+        body.append("  cached_methods = [\"GET\", \"HEAD\"]")
+        body.append("}")
+        body.append(f"price_class = {_value_expr(price_class, type_by_id)}")
+        body.append("restrictions {")
+        body.append("  geo_restriction {")
+        body.append("    restriction_type = \"none\"")
+        body.append("  }")
+        body.append("}")
+        body.append("viewer_certificate {")
+        body.append("  cloudfront_default_certificate = true")
+        body.append("}")
+        waf_arn = inputs.get("waf_web_acl_arn")
+        if waf_arn is not None:
+            if isinstance(waf_arn, str) and waf_arn.startswith("ref:"):
+                waf_expr = _ref_expr(waf_arn, type_by_id)
+            else:
+                waf_expr = _tf_value(waf_arn)
+            body.append(f"web_acl_id = {waf_expr}")
+    if rtype == "aws:wafv2:webacl":
+        name = inputs.get("name", "acdl-waf")
+        body.append(f"name = {_tf_value(name) if not isinstance(name, str) or not name.startswith('ref:') else _ref_expr(name, type_by_id)}")
+        body.append("scope = \"cloudfront\"")
+        # P1-5: Honor default_action input instead of hardcoding allow {}.
+        default_action_input = inputs.get("default_action", "allow")
+        if isinstance(default_action_input, str) and default_action_input.startswith("ref:"):
+            default_action_input = "allow"
+        action_type = default_action_input if default_action_input in ("allow", "block") else "allow"
+        body.append("default_action {")
+        body.append(f"  {action_type} {{}}")
+        body.append("}")
+        body.append("visibility_config {")
+        body.append("  cloudwatch_metrics_enabled = true")
+        body.append("  metric_name = \"acdl-waf-metrics\"")
+        body.append("  sampled_requests_enabled = true")
+        body.append("}")
+        # P1-4: Emit custom rules as nested blocks, not an attribute assignment.
+        rules_input = inputs.get("rules")
+        if rules_input and isinstance(rules_input, list):
+            for idx, rule in enumerate(rules_input):
+                if not isinstance(rule, dict):
+                    continue
+                rule_name = rule.get("name", f"custom-rule-{idx}")
+                rule_priority = rule.get("priority", idx)
+                body.append("rules {")
+                body.append(f"  name = {_tf_value(rule_name)}")
+                body.append(f"  priority = {_tf_value(rule_priority)}")
+                override = rule.get("override_action", "none")
+                if override not in ("none", "count"):
+                    override = "none"
+                body.append("  override_action {")
+                body.append(f"    {override} {{}}")
+                body.append("  }")
+                statement = rule.get("statement", {})
+                if statement:
+                    body.append("  statement {")
+                    for sk, sv in statement.items():
+                        body.append(f"    {sk} {{")
+                        if isinstance(sv, dict):
+                            for sk2, sv2 in sv.items():
+                                body.append(f"      {sk2} = {_tf_value(sv2)}")
+                        body.append("    }")
+                    body.append("  }")
+                body.append("  visibility_config {")
+                body.append("    cloudwatch_metrics_enabled = true")
+                body.append(f"    metric_name = {_tf_value(f'{rule_name}-metrics')}")
+                body.append("    sampled_requests_enabled = true")
+                body.append("  }")
+                body.append("}")
+        elif rules_input and isinstance(rules_input, str) and rules_input.startswith("ref:"):
+            # A ref: value for rules — emit as dynamic block reference (rare case).
+            body.append(f"rules = {_ref_expr(rules_input, type_by_id)}")
+        else:
+            # Default: emit the AWS-managed-rules block when no custom rules.
+            body.append("rules {")
+            body.append("  name = \"aws-managed-rules\"")
+            body.append("  priority = 0")
+            body.append("  override_action {")
+            body.append("    none {}")
+            body.append("  }")
+            body.append("  statement {")
+            body.append("    managed_rule_group_statement {")
+            body.append("      name = \"AWSManagedRulesCommonRuleSet\"")
+            body.append("      vendor_name = \"AWS\"")
+            body.append("    }")
+            body.append("  }")
+            body.append("  visibility_config {")
+            body.append("    cloudwatch_metrics_enabled = true")
+            body.append("    metric_name = \"aws-managed-rules-metrics\"")
+            body.append("    sampled_requests_enabled = true")
+            body.append("  }")
+            body.append("}")
+    if rtype == "aws:rds:instance":
+        # Emit NFR-derived arguments: backup_retention_period +
+        # deletion_protection from the nfrs block. Also emit
+        # storage_encrypted = true (from inputs, already emitted above if
+        # present) and skip_final_snapshot = true for dev safety.
+        nfrs = resource.get("nfrs", {})
+        backup_retention = nfrs.get("backup_retention_period", 7)
+        deletion_protection = nfrs.get("deletion_protection", True)
+        body.append(f"backup_retention_period = {_tf_value(backup_retention)}")
+        body.append(f"deletion_protection = {_tf_value(deletion_protection)}")
+        # Ensure storage_encrypted is emitted (defaults to true if not in inputs).
+        if "storage_encrypted" not in inputs:
+            body.append("storage_encrypted = true")
+        # Dev safety: skip the final snapshot so `terraform destroy` works
+        # without a final DB snapshot (overridden by deletion_protection).
+        body.append("skip_final_snapshot = true")
+    if rtype == "aws:kms:key":
+        nfrs = resource.get("nfrs", {})
+        enable_rotation = nfrs.get("enable_rotation", True)
+        body.append(f"enable_key_rotation = {_tf_value(enable_rotation)}")
+    if rtype == "aws:s3:bucket":
+        nfrs = resource.get("nfrs", {})
+        encryption_enabled = nfrs.get("encryption_enabled", True)
+        if encryption_enabled:
+            kms_key_arn = inputs.get("kms_key_arn")
+            if kms_key_arn and isinstance(kms_key_arn, str) and kms_key_arn.startswith("ref:"):
+                kms_ref = _ref_expr(kms_key_arn, type_by_id)
+                body.append("server_side_encryption_configuration {")
+                body.append("  rule {")
+                body.append("    apply_server_side_encryption_by_default {")
+                body.append(f"      sse_algorithm = \"aws:kms\"")
+                body.append(f"      kms_master_key_id = {kms_ref}")
+                body.append("    }")
+                body.append("  }")
+                body.append("}")
+            elif kms_key_arn:
+                body.append("server_side_encryption_configuration {")
+                body.append("  rule {")
+                body.append("    apply_server_side_encryption_by_default {")
+                body.append("      sse_algorithm = \"aws:kms\"")
+                body.append(f"      kms_master_key_id = {_tf_value(kms_key_arn)}")
+                body.append("    }")
+                body.append("  }")
+                body.append("}")
+            else:
+                print(f"WARNING: s3 bucket {rid} has no kms_key_arn — falling back to AWS-managed key (alias/aws/s3)", file=sys.stderr)
+                body.append("server_side_encryption_configuration {")
+                body.append("  rule {")
+                body.append("    apply_server_side_encryption_by_default {")
+                body.append("      sse_algorithm = \"aws:kms\"")
+                body.append("    }")
+                body.append("  }")
+                body.append("}")
+    if rtype == "aws:ecs:uptime-service":
+        feature_flag = inputs.get("feature_flag_enabled", True)
+        if not feature_flag:
+            return ""
+        container_image = inputs.get("container_image", "louislam/uptime-kuma:1")
+        monitored = inputs.get("monitored_endpoints", [])
+        static_checks = inputs.get("static_checks", [])
+        alert_channels = inputs.get("alert_channels", {})
+        all_checks = (monitored if isinstance(monitored, list) else []) + \
+                     (static_checks if isinstance(static_checks, list) else [])
+        env_vars = {
+            "UPTIME_KUMA_MONITOR_CONFIG": json.dumps(all_checks),
+            "UPTIME_KUMA_ALERT_CONFIG": json.dumps(alert_channels),
+        }
+        desired = inputs.get("desired_count", 1)
+        launch = inputs.get("launch_type", "FARGATE")
+        body.append(f"desired_count = {desired}")
+        body.append(f'launch_type = "{launch}"')
+        body.append("network_configuration {")
+        body.append("  subnets = [\"subnet-uptime\"]")
+        body.append("  security_groups = [\"sg-uptime\"]")
+        body.append("  assign_public_ip = true")
+        body.append("}")
+        container = {
+            "name": "uptime-kuma",
+            "image": container_image,
+            "essential": True,
+            "portMappings": [{"containerPort": 3001, "hostPort": 3001}],
+            "environment": [{"name": k, "value": v} for k, v in env_vars.items()],
+            "logConfiguration": {"logDriver": "awslogs", "options": {"awslogs-group": "/acdl/uptime", "awslogs-region": inputs.get("region", "us-east-1")}},
+        }
+        body.append("container_definitions = " + _tf_value([container]))
+    nfrs = resource.get("nfrs", {})
+    deletion_protection = nfrs.get("deletion_protection", True)
+    if deletion_protection:
+        body.append("lifecycle {")
+        body.append("  prevent_destroy = true")
         body.append("}")
     return _resource_block(rid, tf_type, body)
 
@@ -254,11 +515,13 @@ def _emit_igw(resources):
     vpc_id = next((r["id"] for r in resources if r["type"] == "aws:ec2:vpc"), "vpc-vpc")
     subnet_id = next((r["id"] for r in resources if r["type"] == "aws:ec2:subnet"), "vpc-subnet")
     rt_id = next((r["id"] for r in resources if r["type"] == "aws:ec2:routetable"), "vpc-routetable")
+    vpc_res = next((r for r in resources if r["type"] == "aws:ec2:vpc"), None)
+    igw_name = (vpc_res.get("inputs", {}).get("name", "app") if vpc_res else "app")
     parts = []
     parts.append(_resource_block("vpc-igw", "aws_internet_gateway", [
         f"vpc_id = aws_vpc.{vpc_id}.id",
         "tags = {",
-        '  Name = "acdl-microservice-igw"',
+        f'  Name = "{igw_name}-igw"',
         "}",
     ]))
     parts.append(_resource_block("vpc-rta", "aws_route_table_association", [
@@ -363,6 +626,19 @@ def adapt(stack_instance, out_dir):
             main_tf_parts.append(_emit_output(out_name, f"{tf_type}.{rid}.{tf_attr}"))
     if has_vpc:
         main_tf_parts.append(_emit_igw(resources))
+    # P1-7: Emit stack-level outputs from the resolved composition outputs[].
+    # Each stack output has {"from": <resourceId>, "output": <outputName>}.
+    # We look up the resource type + OUTPUT_MAP to build the interpolation.
+    stack_outputs = stack_instance.get("outputs", {})
+    for out_name, out_spec in stack_outputs.items():
+        src_rid = out_spec.get("from", "")
+        src_output = out_spec.get("output", out_name)
+        if src_rid in type_by_id:
+            src_rtype = type_by_id[src_rid]
+            src_tf_type = TYPE_MAP.get(src_rtype, src_rtype.replace(":", "_"))
+            out_map = OUTPUT_MAP.get(src_rtype, {})
+            tf_attr = out_map.get(src_output, src_output)
+            main_tf_parts.append(_emit_output(out_name, f"{src_tf_type}.{src_rid}.{tf_attr}"))
     main_tf = "\n".join(main_tf_parts)
 
     with open(os.path.join(out_dir, "main.tf"), "w") as fh:

adapters/terraform/policy/checkov_adapter.py

@@ -6,8 +6,10 @@ 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.
+The ACDL tagging standard (D-054, D-043 closure) is enforced by a custom
+Checkov rule at adapters/terraform/policy/custom_rules/acdl_tagging.py,
+loaded via --external-checks-dir. The adapter therefore maps
+ACDL_TAG_NAMING as a real rule (no synthetic SKIPPED record is emitted).
 """
 
 import datetime
@@ -27,6 +29,10 @@ RULE_MAP = {
     "CKV_AWS_40": ("iam-wildcard", "medium"),
     "CKV_AWS_7": ("kms-key-reference", "medium"),
     "CKV_AWS_33": ("kms-key-reference", "medium"),
+    # D-054 / D-043 closure: ACDL_TAG_NAMING is now a real custom Checkov
+    # rule (adapters/terraform/policy/custom_rules/acdl_tagging.py), loaded
+    # via --external-checks-dir. No synthetic SKIPPED record is emitted.
+    "ACDL_TAG_NAMING": ("tagging-standard", "medium"),
 }
 
 _RESULT_MAP = {"PASSED": "pass", "FAILED": "fail", "SKIPPED": "skipped"}
@@ -60,20 +66,6 @@ def _to_pcr(checkov_record, contract_id, result_str):
     }
 
 
-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)
@@ -88,7 +80,6 @@ def adapt(checkov_json_path, contract_id):
             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
 
 

adapters/terraform/policy/custom_rules/README.md

@@ -0,0 +1,34 @@
+# ACDL Custom Checkov Rules
+
+This directory holds ACDL-authored Checkov custom rules, written in the
+[Checkov Python custom-rule framework](https://www.checkov.io/4.Contributing/Custom%20Policies.html).
+
+## Files
+
+- `acdl_tagging.py` — `ACDL_TAG_NAMING` (D-054): ensures every taggable AWS
+  resource carries the four required ACDL tags
+  (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`).
+  This rule replaces the synthetic SKIPPED `ACDL_TAG_NAMING` record that the
+  Checkov adapter previously emitted (D-043 closure). The canonical tag set
+  is declared in [`schemas/tagging-standard.json`](../../../schemas/tagging-standard.json).
+
+## How Checkov loads them
+
+Checkov custom rules are discovered via the `--external-checks-dir` flag.
+`scripts/run_platform.sh` invokes Checkov with:
+
+```
+checkov -f terraform/spike/main.tf --framework terraform -o json --soft-fail \
+        --external-checks-dir adapters/terraform/policy/custom_rules/
+```
+
+Checkov imports each `*.py` file in the directory and instantiates the
+module-level `check` object (see the `check = AcdlTaggingStandard()` line at
+the bottom of `acdl_tagging.py`).
+
+## Severity / result mapping
+
+The Checkov adapter (`adapters/terraform/policy/checkov_adapter.py`)
+maps `ACDL_TAG_NAMING` to `(tagging-standard, medium)` in `RULE_MAP`. The
+custom rule therefore produces real `PASS`/`FAIL` PolicyCheckResult records,
+feeding the confidence signal instead of the old SKIPPED placeholder.

adapters/terraform/policy/custom_rules/acdl_tagging.py

@@ -0,0 +1,54 @@
+"""ACDL tagging standard custom Checkov rule (D-054).
+
+Checks that all taggable AWS resources have the required ACDL tags:
+  acdl:owner, acdl:contract, acdl:environment, acdl:cost-center
+
+Fails (severity medium) when any required tag is missing.
+Closes the D-043 deferral (the SKIPPED ACDL_TAG_NAMING placeholder
+becomes a real check).
+"""
+
+from __future__ import annotations
+
+from checkov.terraform.checks.resource.base_resource_check import BaseResourceCheck
+from checkov.common.models.enums import CheckResult, CheckCategories
+
+REQUIRED_TAGS = ("acdl:owner", "acdl:contract", "acdl:environment", "acdl:cost-center")
+
+# Resources that support tags (exclude resources that have no tags attribute)
+NON_TAGGABLE_TYPES = (
+    "aws_cloudfront_origin_access_control",
+    "aws_lambda_function_url",
+    "aws_route_table_association",
+    "aws_internet_gateway",
+)
+
+class AcdlTaggingStandard(BaseResourceCheck):
+    def __init__(self):
+        name = "Ensure all taggable AWS resources have required ACDL tags"
+        check_id = "ACDL_TAG_NAMING"
+        supported_resources = ["*"]  # all resources
+        categories = [CheckCategories.GENERAL_SECURITY]
+        super().__init__(name=name, check_id=check_id, categories=categories, supported_resources=supported_resources)
+
+    def scan_resource_conf(self, conf, entity_type):
+        # Skip non-taggable resources
+        if entity_type in NON_TAGGABLE_TYPES:
+            return CheckResult.PASSED
+        # Check for a tags block
+        tags = conf.get("tags")
+        if not tags:
+            return CheckResult.FAILED
+        tag_keys = set()
+        if isinstance(tags, list) and tags:
+            tag_block = tags[0]
+            if isinstance(tag_block, dict):
+                tag_keys = set(tag_block.keys())
+        elif isinstance(tags, dict):
+            tag_keys = set(tags.keys())
+        missing = [t for t in REQUIRED_TAGS if t not in tag_keys]
+        if missing:
+            return CheckResult.FAILED
+        return CheckResult.PASSED
+
+check = AcdlTaggingStandard()

adapters/wiz/README.md

@@ -0,0 +1,55 @@
+# Wiz Adapter
+
+The Wiz adapter translates Wiz API issue records to the normalized ACDL
+[`PolicyCheckResult`](../../schemas/policy_check_result.schema.json) schema
+(engine: `"wiz"`), mirroring the Checkov adapter pattern.
+
+## What Wiz is
+
+[Wiz](https://www.wiz.io/) is a cloud security SaaS platform that
+continuously scans CSPM / CWPP / KSPM findings across AWS, Azure, GCP and
+Kubernetes. It exposes a GraphQL/REST API for fetching issue records.
+
+## Adapter behaviour
+
+`wiz_adapter.py <wiz_issues.json> <contract-id>` reads a JSON file of Wiz
+issue records (the shape returned by the Wiz `issues` GraphQL query /
+list endpoint) and emits a list of `PolicyCheckResult` dicts:
+
+| Wiz field        | PolicyCheckResult field                                   |
+|------------------|------------------------------------------------------------|
+| `id` / `control.id` | `ruleId`                                               |
+| `severity`       | `severity` (mapped `CRITICAL/HIGH/MEDIUM/LOW/INFO`)        |
+| `status`         | `result` (`OPEN→fail`, `RESOLVED→pass`, `IN_PROGRESS/DISMISSED→skipped`) |
+| `title` / `control.name` | `message`                                            |
+| `entity.id`      | `resourceRef` + `evidence.resource`                       |
+| `entity.{name,cloudPlatform,subscriptionId}` | `evidence.*`                |
+
+The adapter is read-only against a local JSON fixture; the pipeline is
+responsible for fetching from Wiz (when configured) and writing the file.
+
+## Offline / degraded behaviour (D-052)
+
+When Wiz is not configured the pipeline passes an empty issues payload (or
+simply does not invoke the adapter). The adapter degrades gracefully:
+
+- an empty `issues` list → the adapter emits a single `WIZ_NOT_CONFIGURED`
+  `PolicyCheckResult` with `result: "skipped"` so the confidence policy
+  input stays non-empty (and does not falsely inflate the score).
+
+`is_configured()` returns `True` only when the `WIZ_API_TOKEN`
+environment variable is set; the pipeline uses it to decide whether to
+fetch and invoke the adapter at all.
+
+## Configuration
+
+| Env var          | Required | Purpose                                          |
+|-----------------|----------|--------------------------------------------------|
+| `WIZ_API_TOKEN`  | yes      | Bearer token for the Wiz REST API. When unset, `is_configured()` returns `False`. |
+| `WIZ_ENDPOINT`   | no       | Wiz API endpoint (defaults to `https://api.wiz.io` when implemented). |
+
+## Schema path
+
+The output records validate against
+[`schemas/policy_check_result.schema.json`](../../schemas/policy_check_result.schema.json)
+(`engine: "wiz"` was added to the enum in Phase 23).

adapters/wiz/wiz_adapter.py

@@ -0,0 +1,193 @@
+"""Wiz adapter — translate Wiz API results to ACDL PolicyCheckResult records.
+
+Wiz is a SaaS security platform with a GraphQL API. This adapter
+translates Wiz issue records to the normalized PolicyCheckResult schema
+(engine: "wiz"), matching the Checkov adapter pattern.
+
+v1.9 (REQ-110): the adapter is a real API client. `WizClient` queries the
+Wiz GraphQL API (`<WIZ_API_URL>/graphql`, Bearer auth, `issues` query)
+and translates results → PolicyCheckResult records. It degrades
+gracefully (single `SKIPPED` `WIZ_NOT_CONFIGURED` record) when
+`WIZ_API_TOKEN` or `WIZ_API_URL` is unset (D-052). Pagination is handled
+via `pageInfo.hasNextPage` + `endCursor`. Offline tests use a recorded
+GraphQL fixture.
+
+CLI: wiz_adapter.py <wiz_issues.json> <contract-id>
+"""
+
+import datetime
+import json
+import os
+import sys
+
+
+SEVERITY_MAP = {
+    "CRITICAL": "critical",
+    "HIGH": "high",
+    "MEDIUM": "medium",
+    "LOW": "low",
+    "INFORMATIONAL": "info",
+    "INFO": "info",
+}
+
+RESULT_MAP = {
+    "OPEN": "fail",
+    "RESOLVED": "pass",
+    "IN_PROGRESS": "skipped",
+    "DISMISSED": "skipped",
+}
+
+
+_ISSUES_QUERY = """
+query IssuesQuery($filterBy: IssueFilter, $after: String) {
+  issues(filterBy: $filterBy, after: $after) {
+    nodes {
+      id
+      severity
+      title
+      status
+      entity { id name type cloudPlatform }
+      control { id name }
+      createdAt
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+"""
+
+
+def _iso8601_now():
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _to_pcr(wiz_issue, contract_id):
+    severity_raw = wiz_issue.get("severity", "INFO")
+    severity = SEVERITY_MAP.get(str(severity_raw).upper(), "info")
+    status = wiz_issue.get("status", "OPEN")
+    result = RESULT_MAP.get(str(status).upper(), "error")
+    control = wiz_issue.get("control", {}) or {}
+    entity = wiz_issue.get("entity", {}) or {}
+    rule_id = control.get("name") or wiz_issue.get("id") or "WIZ_UNKNOWN"
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "wiz",
+        "ruleId": rule_id,
+        "severity": severity,
+        "result": result,
+        "message": wiz_issue.get("title", control.get("name", "")),
+        "evidence": {
+            "resource": entity.get("id"),
+            "resource_name": entity.get("name"),
+            "cloud_platform": entity.get("cloudPlatform"),
+        },
+        "resourceRef": entity.get("id", ""),
+    }
+
+
+def _emit_not_configured(contract_id):
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "wiz",
+        "ruleId": "WIZ_NOT_CONFIGURED",
+        "severity": "info",
+        "result": "skipped",
+        "message": "Wiz adapter not configured (WIZ_API_TOKEN or WIZ_API_URL not set); degraded gracefully (D-052).",
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+class WizClient:
+    """Real Wiz GraphQL API client (REQ-110).
+
+    Reads WIZ_API_TOKEN + WIZ_API_URL from the environment. `fetch_issues`
+    queries the Wiz GraphQL API and returns a list of issue dicts.
+    Pagination is handled via pageInfo.hasNextPage + endCursor.
+    """
+
+    def __init__(self, token=None, url=None):
+        self.token = token or os.environ.get("WIZ_API_TOKEN", "")
+        self.url = (url or os.environ.get("WIZ_API_URL", "")).rstrip("/")
+        if not self.token or not self.url:
+            raise RuntimeError("WizClient requires WIZ_API_TOKEN + WIZ_API_URL")
+
+    def _post(self, query, variables):
+        import urllib.request
+        endpoint = f"{self.url}/graphql"
+        payload = json.dumps({"query": query, "variables": variables}).encode("utf-8")
+        req = urllib.request.Request(
+            endpoint,
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {self.token}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    def fetch_issues(self, filter_by=None, max_pages=10):
+        issues = []
+        after = None
+        for _ in range(max_pages):
+            data = self._post(_ISSUES_QUERY, {"filterBy": filter_by or {}, "after": after})
+            root = data.get("data", {}).get("issues", {})
+            nodes = root.get("nodes", [])
+            issues.extend(nodes)
+            page_info = root.get("pageInfo", {})
+            if not page_info.get("hasNextPage"):
+                break
+            after = page_info.get("endCursor")
+        return issues
+
+
+def fetch_and_adapt(contract_id, filter_by=None, client=None):
+    """Fetch Wiz issues via the real client and translate to PolicyCheckResult.
+
+    When the client is not configured (no token/url), emit the SKIPPED
+    WIZ_NOT_CONFIGURED record (graceful degrade).
+    """
+    if client is None:
+        try:
+            client = WizClient()
+        except RuntimeError:
+            return [_emit_not_configured(contract_id)]
+    issues = client.fetch_issues(filter_by=filter_by)
+    if not issues:
+        return [_emit_not_configured(contract_id)]
+    return [_to_pcr(i, contract_id) for i in issues]
+
+
+def adapt(wiz_json_path, contract_id):
+    with open(wiz_json_path, "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    out = []
+    # Accept either a bare list of issues or an object with an "issues" key
+    # or a full GraphQL response shape ({data: {issues: {nodes: [...]}}}).
+    if isinstance(data, list):
+        issues = data
+    elif "data" in data and "issues" in data.get("data", {}):
+        issues = data["data"]["issues"].get("nodes", [])
+    else:
+        issues = data.get("issues", [])
+    if not isinstance(issues, list):
+        issues = []
+    for issue in issues:
+        out.append(_to_pcr(issue, contract_id))
+    if not out:
+        out.append(_emit_not_configured(contract_id))
+    return out
+
+
+def is_configured():
+    return bool(os.environ.get("WIZ_API_TOKEN") and os.environ.get("WIZ_API_URL"))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("usage: wiz_adapter.py <wiz_issues.json> <contract-id>", file=sys.stderr)
+        sys.exit(2)
+    print(json.dumps(adapt(sys.argv[1], sys.argv[2]), indent=2))

consumer-repos/acdl-consumer-microservice/Dockerfile

@@ -1,7 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-COPY app.py /app/app.py
-
-EXPOSE 8080
-CMD ["python", "/app/app.py"]

consumer-repos/acdl-consumer-microservice/README.md

@@ -1,34 +0,0 @@
-# acdl-consumer-microservice
-
-A basic HTTP microservice for the ACDL v1.2 milestone. Returns 200 on `/`
-and `/health` with a JSON status body. Deployed to AWS ECS Fargate via the
-ACDL platform's `microservice` contract.
-
-## Build + push to ECR
-
-```bash
-# Build
-docker build -t acdl-microservice .
-
-# Tag for ECR
-docker tag acdl-microservice:latest 581513795199.dkr.ecr.us-east-1.amazonaws.com/acdl-microservice:latest
-
-# Authenticate to ECR
-aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 581513795199.dkr.ecr.us-east-1.amazonaws.com
-
-# Push
-docker push 581513795199.dkr.ecr.us-east-1.amazonaws.com/acdl-microservice:latest
-```
-
-## Contract
-
-The contract submission is at `contracts/microservice.yaml` (or the
-platform's `contracts/microservice.yaml`). Submitting it to the ACDL
-pipeline triggers: contract → IR resolution → `terraform plan` →
-`terraform apply` (dev) → a live ECS Fargate service.
-
-## Endpoints
-
-- `GET /` — 200, `{"status":"ok","service":"acdl-microservice","version":"1.0.0"}`
-- `GET /health` — 200, same body
-- any other path — 404

consumer-repos/acdl-consumer-microservice/app.py

@@ -1,37 +0,0 @@
-"""ACDL consumer microservice — a tiny HTTP server returning 200 on /.
-
-This is the reference consumer microservice for the v1.2 milestone. It's
-intentionally minimal: stdlib only, no framework, no dependencies. The
-platform deploys it to ECS Fargate via the microservice contract.
-"""
-import json
-import os
-from http.server import BaseHTTPRequestHandler, HTTPServer
-
-
-class Handler(BaseHTTPRequestHandler):
-    def do_GET(self):
-        if self.path == "/" or self.path == "/health":
-            body = json.dumps({
-                "status": "ok",
-                "service": "acdl-microservice",
-                "version": "1.0.0",
-            }).encode()
-            self.send_response(200)
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            self.wfile.write(body)
-        else:
-            self.send_response(404)
-            self.end_headers()
-
-    def log_message(self, format, *args):
-        print(f"{self.address_string()} - {format % args}")
-
-
-if __name__ == "__main__":
-    port = int(os.environ.get("PORT", "8080"))
-    server = HTTPServer(("0.0.0.0", port), Handler)
-    print(f"acdl-microservice listening on :{port}", flush=True)
-    server.serve_forever()

contracts/microservice.dev.yaml

@@ -0,0 +1,11 @@
+# ACDL sample consumer contract — microservice module (dev)
+# Per-environment contract (REQ-105). Promotion = running the dev job;
+# no environment field editing. Interpolation resolves against dev.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: microservice
+environment: dev
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+  image: public.ecr.aws/docker/library/nginx:latest
+  port: 80

contracts/microservice.dr.yaml

@@ -0,0 +1,11 @@
+# ACDL sample consumer contract — microservice module (dr)
+# Per-environment contract (REQ-105). Promotion = running the dr job;
+# no environment field editing. Interpolation resolves against dr.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: microservice
+environment: dr
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+  image: public.ecr.aws/docker/library/nginx:latest
+  port: 80

contracts/microservice.prod.yaml

@@ -0,0 +1,11 @@
+# ACDL sample consumer contract — microservice module (prod)
+# Per-environment contract (REQ-105). Promotion = running the prod job;
+# no environment field editing. Interpolation resolves against prod.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: microservice
+environment: prod
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+  image: public.ecr.aws/docker/library/nginx:latest
+  port: 80

contracts/microservice.qa.yaml

@@ -0,0 +1,11 @@
+# ACDL sample consumer contract — microservice module (qa)
+# Per-environment contract (REQ-105). Promotion = running the qa job;
+# no environment field editing. Interpolation resolves against qa.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: microservice
+environment: qa
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+  image: public.ecr.aws/docker/library/nginx:latest
+  port: 80

contracts/microservice.yaml

@@ -0,0 +1,14 @@
+# ACDL sample consumer contract — microservice module (dev)
+#
+# Reference example for an ECS Fargate microservice deployment.
+# Interpolation (D-081): bucket_name uses the naming pattern that includes
+# region, aws account id, and environment:
+#   acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: microservice
+environment: dev
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+  image: public.ecr.aws/docker/library/nginx:latest
+  port: 80

contracts/static-asset.yaml

@@ -1,17 +0,0 @@
-# ACDL sample consumer contract — static-asset module (dev)
-#
-# This is the reference example for a consumer contract. It declares:
-#   uses:       the central ACDL deployment pipeline to reference
-#   module:     which module to deploy (must match a registry key)
-#   environment: which environment to deploy to (dev = autonomous)
-#   inputs:     module-specific inputs
-#
-# Validated against schemas/contract.schema.json.
-# Resolved by core/contract_resolver.py to a Target Stack instance.
-
-uses: acdl/pipelines/deploy.yaml@v1.4
-module: static-asset
-environment: dev
-inputs:
-  bucket_name: acdl-spike-bucket
-  region: us-east-1

contracts/static-assets.dev.yaml

@@ -0,0 +1,10 @@
+# ACDL sample consumer contract — static-assets module (dev)
+# Per-environment contract (REQ-105). The dev default
+# (contracts/static-assets.yaml) remains for backwards compat; this file
+# is the explicit per-env dev contract. Interpolation resolves against dev.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: dev
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}

contracts/static-assets.dr.yaml

@@ -0,0 +1,9 @@
+# ACDL sample consumer contract — static-assets module (dr)
+# Per-environment contract (REQ-105). Promotion = running the dr job;
+# no environment field editing. Interpolation resolves against dr.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: dr
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}

contracts/static-assets.prod.yaml

@@ -0,0 +1,9 @@
+# ACDL sample consumer contract — static-assets module (prod)
+# Per-environment contract (REQ-105). Promotion = running the prod job;
+# no environment field editing. Interpolation resolves against prod.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: prod
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}

contracts/static-assets.qa.yaml

@@ -0,0 +1,9 @@
+# ACDL sample consumer contract — static-assets module (qa)
+# Per-environment contract (REQ-105). Promotion = running the qa job;
+# no environment field editing. Interpolation resolves against qa.json.
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: qa
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}

contracts/static-assets.yaml

@@ -0,0 +1,23 @@
+# ACDL sample consumer contract — static-assets module (dev)
+#
+# This is the reference example for a consumer contract. It declares:
+#   uses:       the central ACDL deployment pipeline to reference
+#   module:     which module to deploy (must match a registry key)
+#   environment: which environment to deploy to (dev = autonomous)
+#   inputs:     module-specific inputs
+#
+# Validated against schemas/contract.schema.json.
+# Resolved by core/contract_resolver.py to a Target Stack instance.
+#
+# Interpolation (D-081): ${env.<field>} + ${contract.<field>} tokens are
+# expanded by the resolver from the environment onboarding JSON. The
+# bucket_name below demonstrates the naming pattern that includes region,
+# aws account id, and environment:
+#   acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: dev
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}

core/attestation_matrix.py

@@ -0,0 +1,178 @@
+"""8-concern attestation matrix (REQ-109, D-084).
+
+Implements the 8 concerns from `core/hitl_matrix_design.md` §10.4. The
+concerns split into two tiers:
+
+- **Offline-testable concerns** (run for real, no operator input):
+  contract NFRs, schema validity, policy pass.
+- **Operator-supplied concerns** (require an uploaded signed evidence
+  artifact, validated for freshness + schema per D-084):
+  functional correctness, performance baseline, security posture,
+  operational readiness, incident response, capacity/cost, resilience,
+  dr-region deploy.
+
+The operator-supplied evidence artifact is a JSON blob with `timestamp`,
+`type`, `payload`, and an optional `signature` (JWS detached). Freshness
+is validated against the window from §10.4. Signature verification runs
+when `ACDL_ATTESTATION_SIGNING_KEY_ID` is set; it is skipped + logged
+when unset (dev/CI — D-089). The matrix fails loud if an operator-supplied
+concern is missing or expired for prod/dr.
+"""
+
+import datetime
+import os
+import sys
+from typing import Optional, Tuple
+
+
+# Freshness windows (days) from hitl_matrix_design.md §10.4.
+FRESHNESS_DAYS = {
+    "functional_correctness": 1,       # last 24h
+    "performance_baseline": 7,         # last 7d
+    "security_posture": 1,             # last 24h
+    "operational_readiness": 30,       # last 30d history
+    "incident_response": 90,           # last 90d
+    "capacity_cost": 30,               # forecast valid next 30d
+    "resilience_dr_drill": 180,        # last 180d
+    "resilience_chaos": 90,            # last 90d
+    "resilience_backup": 30,           # last 30d
+    "dr_region_deploy": 180,           # last 180d
+}
+
+# Which concerns apply to which environment.
+ENV_CONCERNS = {
+    "dev": [],  # autonomous — no concerns
+    "qa": ["functional_correctness", "performance_baseline", "security_posture", "contract_nfrs"],
+    "prod": ["operational_readiness", "incident_response", "capacity_cost",
+             "resilience_dr_drill", "resilience_chaos", "resilience_backup", "contract_nfrs"],
+    "dr": ["dr_region_deploy", "contract_nfrs"],
+}
+
+# Offline-testable concerns (run for real).
+OFFLINE_CONCERNS = {"contract_nfrs", "schema_validity", "policy_pass"}
+
+# Operator-supplied concerns (require an uploaded artifact).
+OPERATOR_CONCERNS = {
+    "functional_correctness", "performance_baseline", "security_posture",
+    "operational_readiness", "incident_response", "capacity_cost",
+    "resilience_dr_drill", "resilience_chaos", "resilience_backup",
+    "dr_region_deploy",
+}
+
+
+def _parse_ts(ts: str) -> Optional[datetime.datetime]:
+    try:
+        return datetime.datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+
+
+def _is_fresh(artifact: dict, concern: str) -> bool:
+    ts = _parse_ts(artifact.get("timestamp", ""))
+    if ts is None:
+        return False
+    window_days = FRESHNESS_DAYS.get(concern, 30)
+    age = datetime.datetime.now(datetime.timezone.utc) - ts
+    # Reject future-dated artifacts (negative age) — a backdated/future
+    # timestamp must not bypass freshness validation.
+    if age.total_seconds() < 0:
+        return False
+    return age.days <= window_days
+
+
+def _verify_signature(artifact: dict) -> bool:
+    """Verify the JWS detached signature when ACDL_ATTESTATION_SIGNING_KEY_ID is set.
+
+    When unset (dev/CI — D-089), signature verification is skipped + logged.
+    """
+    key_id = os.environ.get("ACDL_ATTESTATION_SIGNING_KEY_ID", "")
+    if not key_id:
+        sys.stderr.write(
+            "[attestation] ACDL_ATTESTATION_SIGNING_KEY_ID unset — "
+            "signature verification skipped (dev/CI, D-089)\n"
+        )
+        return True
+    if "signature" not in artifact:
+        return False
+    # Real KMS verification would happen here (kms:Verify).
+    # For v1.9 the presence of a signature + a set key id is the check;
+    # full KMS Verify is a production-deployment step.
+    return bool(artifact.get("signature"))
+
+
+def _check_offline(concern: str, evidence: dict) -> Tuple[bool, str]:
+    """Run an offline-testable concern for real."""
+    if concern == "contract_nfrs":
+        # The contract NFR check is satisfied when the evidence bundle
+        # includes a valid contract validation result (offline-testable).
+        nfrs = evidence.get("contract_nfrs", {})
+        if nfrs.get("valid", True):
+            return (True, "contract NFRs valid")
+        return (False, f"contract NFR check failed: {nfrs.get('reason', 'invalid')}")
+    if concern == "schema_validity":
+        if evidence.get("schema_validity", {}).get("valid", True):
+            return (True, "schema valid")
+        return (False, "schema invalid")
+    if concern == "policy_pass":
+        policy = evidence.get("policy_pass", {})
+        if policy.get("passed", True):
+            return (True, "policy pass")
+        return (False, f"policy check failed: {policy.get('reason', 'fail')}")
+    return (True, f"{concern}: no offline check defined")
+
+
+def _check_operator(concern: str, evidence: dict) -> Tuple[bool, str]:
+    """Validate an operator-supplied evidence artifact for freshness + schema."""
+    artifact = evidence.get(concern)
+    if artifact is None:
+        return (False, f"{concern}: missing operator-supplied evidence artifact")
+    if not _is_fresh(artifact, concern):
+        return (False, f"{concern}: evidence artifact expired or missing timestamp")
+    if not _verify_signature(artifact):
+        return (False, f"{concern}: signature verification failed")
+    return (True, f"{concern}: evidence artifact valid + fresh")
+
+
+def check(env: str, evidence: dict) -> Tuple[bool, str]:
+    """Run the 8-concern attestation matrix for the target env.
+
+    Returns (ok, reason). ok=False means block the promotion.
+    Dev always passes (autonomous).
+    """
+    concerns = ENV_CONCERNS.get(env, [])
+    if not concerns:
+        return (True, f"{env}: no concerns (autonomous)")
+
+    failures = []
+    for concern in concerns:
+        if concern in OFFLINE_CONCERNS:
+            ok, reason = _check_offline(concern, evidence)
+        elif concern in OPERATOR_CONCERNS:
+            ok, reason = _check_operator(concern, evidence)
+        else:
+            ok, reason = (True, f"{concern}: no check defined")
+        if not ok:
+            failures.append(reason)
+
+    if failures:
+        return (False, "; ".join(failures))
+    return (True, f"{env}: all {len(concerns)} concern(s) pass")
+
+
+if __name__ == "__main__":
+    import json
+    if len(sys.argv) < 2:
+        print("usage: attestation_matrix.py <env> [evidence.json]", file=sys.stderr)
+        sys.exit(2)
+    _env = sys.argv[1]
+    _evidence = {}
+    if len(sys.argv) >= 3 and os.path.isfile(sys.argv[2]):
+        with open(sys.argv[2]) as f:
+            _evidence = json.load(f)
+    ok, reason = check(_env, _evidence)
+    if ok:
+        print(f"ATTESTATION PASS: {reason}")
+        sys.exit(0)
+    else:
+        print(f"ATTESTATION BLOCK: {reason}", file=sys.stderr)
+        sys.exit(1)

core/audit_ledger_design.md

@@ -1,9 +1,11 @@
 # 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.
+> **Status:** design authored in Phase 07 (milestone v1.1); the
+> hash-chain + DynamoDB-outbox path is **shipped + production since
+> v1.8**. The S3 Object Lock + JWS + async worker + DLQ + daily
+> checkpoints build-out is **deferred to a future milestone (D-083)** —
+> it requires non-offline-testable AWS infrastructure (Object Lock
+> bucket, KMS signing key, SQS DLQ, Lambda worker) and is not in v1.9.
 
 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]
@@ -16,15 +18,16 @@ is the source of truth.
 - **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.
+  record. **Deferred to a future milestone (D-083).**
 - **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`).
+  **Shipped + production since v1.8.**
 
-## Spike scope (D-041) — what Phases 08-10 implement
+## Shipped scope (D-041) — production since v1.8
 
 - **DynamoDB outbox:** table `acdl-outbox`, `PAY_PER_REQUEST` (D-044),
   PK `contractId`, SK `eventType#eventTs`, TTL `expire_at` = now + 365d
@@ -34,14 +37,20 @@ is the source of truth.
   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
+  default). No separate async worker / DLQ in v1.9 (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:**
+- **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
+## Deferred to a future milestone (D-083)
+
+The following build-out was authored as design in Phase 07 and is **not
+in v1.9**. It requires AWS infrastructure that cannot be exercised
+offline (Object Lock bucket, KMS signing key, SQS DLQ, Lambda worker)
+and is deferred to a future milestone. The hash-chain + DynamoDB-outbox
+path above remains the v1.9 production audit record.
 
 - **S3 Object Lock:** bucket `acdl-evidence-lock-<account-id>`, Object
   Lock enabled at creation, compliance mode, 7-yr retention
@@ -52,52 +61,59 @@ is the source of truth.
   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.
+  field is added to the event shape when this ships.
 - **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.
+  notarization service).
 
 ## 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.
+chain). The chain is shipped (v1.8+); JWS is deferred (D-083). Together
+they cover both integrity properties the vision's "Not a mutable audit
+log" anti-goal requires.
 
-## Outbox item shape (full, spike + v1.2)
+## Outbox item shape (shipped + deferred fields marked)
 
 - 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).
+- `payload` (the event body — hash-chained in v1.8+; JWS-signed when
+  D-083 ships).
 - `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).
+- `approver_qa` (Gitea/GitHub username of the QA approver; populated on
+  qa-promotion by v1.9's `hitl_gates.attest` — D-042).
+- `approver_prod` (SRE username; populated on prod-promotion by v1.9's
+  `hitl_gates.attest`).
+- `approver_dr` (SRE username; populated on dr-promotion by v1.9's
+  `hitl_gates.attest`).
 - `environment`, `stack`, `score`, `band`.
 - `expire_at` (TTL = now + 365d).
-- **v1.2 only:** `jws` (detached signature), `checkpoint_ref`.
+- **Deferred (D-083):** `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 |
+| v1.8+ (production, shipped) | 0 (sync outbox write) | workflow re-run |
+| Future milestone (D-083) | 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-041** — shipped scope = hash chain + outbox write; Object Lock +
+  JWS + worker + DLQ are deferred (D-083).
 - **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`.
+  now + 365d; no separate async worker in v1.9.
+- **D-042** — approver identities (`approver_qa`, `approver_prod`,
+  `approver_dr`) live in the outbox; the separation-of-duties check
+  (`core/separation_of_duties.py`) reads `approver_qa` and compares
+  to the prod-dispatch `gitea.actor` / `github.actor`. v1.9's
+  `hitl_gates.attest` populates these attributes.
+- **D-083** (v1.9) — S3 Object Lock + JWS + async worker + DLQ + daily
+  checkpoints deferred to a future milestone. Requires non-offline-
+  testable AWS infra.

core/contract_resolver.py

@@ -20,12 +20,34 @@ CLI: contract_resolver.py <contract.yaml> <out.json>
 
 import json
 import os
+import re
 import sys
 
 import yaml
 import jsonschema
 
 
+def _load_env(env_name, repo_root):
+    """Load the environment onboarding JSON for env_name.
+
+    Mirrors core.environment_check.load() but is self-contained so the
+    resolver works both as a package import (`from core.contract_resolver
+    import resolve`) and as a script (`python3 core/contract_resolver.py`).
+    Emits a stderr warning when account_id is the placeholder and env != dev.
+    """
+    env_file = os.path.join(repo_root, "core", "environments", f"{env_name}.json")
+    if not os.path.isfile(env_file):
+        raise FileNotFoundError(f"no environment file for '{env_name}' at {env_file}")
+    env = _load_json(env_file)
+    if env.get("account_id") == "000000000000" and env_name != "dev":
+        sys.stderr.write(
+            f"WARNING: environment '{env_name}' has the placeholder account_id "
+            f"000000000000 — replace it with the real {env_name} account id "
+            f"before deploying (onboarding scaffold).\n"
+        )
+    return env
+
+
 def _load_json(path):
     with open(path, "r") as fh:
         return json.load(fh)
@@ -36,6 +58,51 @@ def _load_yaml(path):
         return yaml.safe_load(fh)
 
 
+_TOKEN_RE = re.compile(r"\$\{([a-zA-Z_][a-zA-Z0-9_.]*)\}")
+
+
+def _lookup_dotted(context, dotted):
+    """Look up a dotted path (e.g. 'env.state_backend.bucket') in context.
+
+    context is a dict of top-level namespaces (e.g. {'env': {...}, 'contract': {...}}).
+    Returns the value or raises KeyError if any segment is missing.
+    """
+    parts = dotted.split(".")
+    cur = context
+    for part in parts:
+        if isinstance(cur, dict) and part in cur:
+            cur = cur[part]
+        else:
+            raise KeyError(dotted)
+    return cur
+
+
+def _expand_vars(value, context):
+    """Recursively expand ${env.<field>} and ${contract.<field>} tokens in value.
+
+    Walks dicts, lists, and strings. Unknown tokens raise ValueError (fail
+    loud, no silent passthrough — D-081). Dotted paths are supported
+    (e.g. ${env.state_backend.bucket}). The expansion is recursive per D-087
+    so nested map/list values expand too.
+    """
+    if isinstance(value, str):
+        def _replace(match):
+            token = match.group(1)
+            try:
+                resolved = _lookup_dotted(context, token)
+            except KeyError:
+                raise ValueError(f"unresolved interpolation token: ${{{token}}}")
+            if isinstance(resolved, (dict, list)):
+                return json.dumps(resolved)
+            return str(resolved)
+        return _TOKEN_RE.sub(_replace, value)
+    if isinstance(value, dict):
+        return {k: _expand_vars(v, context) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_expand_vars(v, context) for v in value]
+    return value
+
+
 def _resolve_wire_value(wire, contract_inputs, child_outputs):
     """Resolve a wire 'from' reference to a concrete value.
 
@@ -44,7 +111,13 @@ def _resolve_wire_value(wire, contract_inputs, child_outputs):
     - "<childId>.outputs.<name>" — a reference to another child's output
 
     Returns either a concrete value (string/number/boolean) or a
-    "ref:<childId>.<outputName>" string for cross-child references.
+    "ref:<resourceId>.<outputName>" string for cross-child references.
+
+    For multi-resource L1s (e.g. vpc which expands to vpc-vpc, vpc-subnet,
+    vpc-routetable), the ref must point to the sub-resource that actually
+    produces the output, not the child id. The child_outputs table maps
+    childId -> {outputName -> resourceId} so the ref uses the correct
+    resource id.
     """
     from_expr = wire["from"]
     to_expr = wire["to"]
@@ -66,7 +139,13 @@ def _resolve_wire_value(wire, contract_inputs, child_outputs):
         if len(parts) >= 3 and parts[1] == "outputs":
             child_id = parts[0]
             output_name = parts[2]
-            return f"ref:{child_id}.{output_name}"
+            # Look up the sub-resource that produces this output.
+            # child_outputs[child_id] is a dict {outputName -> resourceId}.
+            # If the child is a single-resource L1, the resourceId == child_id.
+            # If multi-resource, the resourceId is the expanded sub-resource id.
+            child_out_map = child_outputs.get(child_id, {})
+            resource_id = child_out_map.get(output_name, child_id)
+            return f"ref:{resource_id}.{output_name}"
 
     return None
 
@@ -125,7 +204,15 @@ def resolve_l2(contract, registry, repo_root):
     composition = _load_json(comp_path)
 
     # Track child outputs for wire resolution
+    # child_outputs[childId] = {outputName: resourceId}
+    # For single-resource L1s, resourceId == childId
+    # For multi-resource L1s, resourceId is the expanded sub-resource id
     child_outputs = {}
+    # child_input_map[childId] = {inputName: sub_resource_id} for multi-resource L1s
+    # so a wire targeting <childId>.inputs.<name> routes to the sub-resource
+    # that actually declares that input (P1-1 — desired_count → aws:ecs:service,
+    # family → aws:ecs:task_definition).
+    child_input_map = {}
     resources = []
 
     # Expand children to resources
@@ -139,15 +226,19 @@ def resolve_l2(contract, registry, repo_root):
         child_iface_path = os.path.join(repo_root, child_entry["interface"])
         child_iface = _load_json(child_iface_path)
 
+        # Build the output->resourceId map for this child
+        child_out_map = {}
+        child_in_map = {}
+
         # For multi-resource L1s (like vpc), the first resource type is the
         # primary; the adapter handles expansion. Use the interface's type
         # or the first resource in the interface's resources array.
         if "resources" in child_iface and child_iface["resources"]:
             # Multi-resource L1: create one resource per sub-resource
             for sub_res in child_iface["resources"]:
+                res_id = f"{child_id}-{sub_res['type'].split(':')[-1].replace('_', '-')}" if len(child_iface["resources"]) > 1 else child_id
                 resource = {
-                    "id": f"{child_id}-{sub_res['type'].split(':')[-1].replace('_', '-')}"
-                    if len(child_iface["resources"]) > 1 else child_id,
+                    "id": res_id,
                     "type": sub_res["type"],
                     "module": child_module,
                     "inputs": {},
@@ -157,6 +248,12 @@ def resolve_l2(contract, registry, repo_root):
                     },
                 }
                 resources.append(resource)
+                # Map each output to this sub-resource's id
+                for out_name in sub_res.get("outputs", []):
+                    child_out_map[out_name] = res_id
+                # Map each declared input to this sub-resource's id (P1-1)
+                for in_name in sub_res.get("inputs", []):
+                    child_in_map[in_name] = res_id
         else:
             # Single-resource L1
             resource = {
@@ -170,9 +267,18 @@ def resolve_l2(contract, registry, repo_root):
                 },
             }
             resources.append(resource)
+            # Map each output to the child id
+            for out_name in child_iface.get("outputs", {}):
+                child_out_map[out_name] = child_id
 
-        # Track outputs for this child
-        child_outputs[child_id] = child_iface.get("outputs", {})
+        # Also map interface-level outputs (for L1s that declare outputs at the
+        # interface level rather than per-resource)
+        for out_name in child_iface.get("outputs", {}):
+            if out_name not in child_out_map:
+                child_out_map[out_name] = child_id
+
+        child_outputs[child_id] = child_out_map
+        child_input_map[child_id] = child_in_map
 
     # Resolve wires to populate inputs
     for wire in composition.get("wires", []):
@@ -186,11 +292,22 @@ def resolve_l2(contract, registry, repo_root):
 
         value = _resolve_wire_value(wire, inputs, child_outputs)
         if value is not None:
-            # Find the target resource and set the input
-            for res in resources:
-                if res["id"] == target_child or res["id"].startswith(f"{target_child}-"):
-                    res["inputs"][input_name] = value
-                    break
+            # Route to the sub-resource that declares this input (P1-1).
+            # child_input_map maps <childId> -> {inputName -> sub_resource_id}.
+            # If the input is declared on a specific sub-resource, route there;
+            # otherwise fall back to the first matching resource (legacy).
+            in_map = child_input_map.get(target_child, {})
+            target_res_id = in_map.get(input_name)
+            if target_res_id is not None:
+                for res in resources:
+                    if res["id"] == target_res_id:
+                        res["inputs"][input_name] = value
+                        break
+            else:
+                for res in resources:
+                    if res["id"] == target_child or res["id"].startswith(f"{target_child}-"):
+                        res["inputs"][input_name] = value
+                        break
 
     # Build the stack instance
     stack_instance = {
@@ -203,15 +320,86 @@ def resolve_l2(contract, registry, repo_root):
         "resources": resources,
     }
 
+    # REQ-87: Propagate deletion_protection feature flag from contract inputs
+    # to all children's NFRs. When inputs.deletion_protection is false,
+    # all resources get deletion_protection=false (used by decommission).
+    deletion_protection_input = inputs.get("deletion_protection", True)
+    if deletion_protection_input is not True:
+        for res in resources:
+            if "nfrs" not in res:
+                res["nfrs"] = {}
+            res["nfrs"]["deletion_protection"] = deletion_protection_input
+    # Also record the feature flag on the stack object for introspection.
+    if "deletion_protection" in inputs:
+        stack_instance["stack"]["features"] = {
+            "deletion_protection": deletion_protection_input
+        }
+
+    # P1-7: Process the composition's outputs[] array to build stack.outputs.
+    # Each output wire: {"from": "<childId>.outputs.<name>", "to": "stack.outputs.<outName>"}
+    # The child_outputs map (childId -> {outputName: resourceId}) resolves
+    # the source to a resource id, which the adapter uses to emit
+    # `output "<outName>" { value = aws_<type>.<resourceId>.<attr> }`.
+    stack_outputs = {}
+    for out_wire in composition.get("outputs", []):
+        from_expr = out_wire.get("from", "")
+        to_expr = out_wire.get("to", "")
+        # Parse "to": "stack.outputs.<outName>"
+        to_parts = to_expr.split(".")
+        if len(to_parts) != 3 or to_parts[1] != "outputs":
+            continue
+        out_name = to_parts[2]
+        # Parse "from": "<childId>.outputs.<name>"
+        from_parts = from_expr.split(".")
+        if len(from_parts) != 3 or from_parts[1] != "outputs":
+            continue
+        src_child = from_parts[0]
+        src_output = from_parts[2]
+        # Resolve the source resource id from child_outputs
+        child_out_map = child_outputs.get(src_child, {})
+        src_resource_id = child_out_map.get(src_output, src_child)
+        stack_outputs[out_name] = {
+            "type": "string",
+            "from": src_resource_id,
+            "output": src_output,
+        }
+    if stack_outputs:
+        stack_instance["outputs"] = stack_outputs
+
     return stack_instance
 
 
-def resolve(contract_path, repo_root=None):
+def decommission_transform(stack_instance):
+    """REQ-92: Transform a resolved stack instance for decommission.
+
+    Sets all scalable counts to 0 and deletion_protection to false on
+    every resource. Used by the decommission pipeline mode after the
+    first step (disable deletion protection) has been applied.
+    """
+    for res in stack_instance.get("resources", []):
+        if "nfrs" not in res:
+            res["nfrs"] = {}
+        res["nfrs"]["deletion_protection"] = False
+        inputs = res.get("inputs", {})
+        if "desired_count" in inputs:
+            inputs["desired_count"] = 0
+        if "min_capacity" in inputs:
+            inputs["min_capacity"] = 0
+        if "max_capacity" in inputs:
+            inputs["max_capacity"] = 0
+    return stack_instance
+
+
+def resolve(contract_path, repo_root=None, environment_override=None):
     """Resolve a consumer contract to a Target Stack instance.
 
     Args:
         contract_path: Path to the contract YAML file.
         repo_root: Root of the ACDL repo (defaults to two levels up from this file).
+        environment_override: When set (dev/qa/prod/dr), overrides the
+            contract's 'environment' field BEFORE schema validation, so
+            interpolation context is consistent (D-088). Used by
+            run_platform.sh --environment.
 
     Returns:
         A dict representing the Target Stack instance.
@@ -222,12 +410,30 @@ def resolve(contract_path, repo_root=None):
     # Load contract
     contract = _load_yaml(contract_path)
 
+    # Apply environment override BEFORE schema validation (D-088) so the
+    # schema sees the overridden value and interpolation context is consistent.
+    if environment_override:
+        contract["environment"] = environment_override
+
     # Load schemas
     contract_schema = _load_json(os.path.join(repo_root, "schemas", "contract.schema.json"))
 
     # Validate contract against schema
     jsonschema.validate(contract, contract_schema)
 
+    # Interpolation (D-081): expand ${env.<field>} + ${contract.<field>}
+    # tokens AFTER schema validation (the schema sees raw tokens, which are
+    # valid strings) and BEFORE IR resolution (the resolver sees concrete
+    # values). The env context is the loaded environment onboarding JSON.
+    env_name = contract.get("environment", "dev")
+    env = _load_env(env_name, repo_root)
+    # Expose 'environment' as an alias for the env's 'name' field so
+    # ${env.environment} resolves (the env JSON uses 'name', but contracts
+    # reference the environment by ${env.environment}).
+    env["environment"] = env.get("name", env_name)
+    context = {"env": env, "contract": contract}
+    contract["inputs"] = _expand_vars(contract.get("inputs", {}), context)
+
     # Load registry
     registry = _load_json(os.path.join(repo_root, "modules", "registry.json"))
 
@@ -253,10 +459,20 @@ def resolve(contract_path, repo_root=None):
 
 
 if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print("usage: contract_resolver.py <contract.yaml> <out.json>", file=sys.stderr)
+    if len(sys.argv) < 3:
+        print("usage: contract_resolver.py <contract.yaml> <out.json> [--environment <name>]", file=sys.stderr)
         sys.exit(2)
-    result = resolve(sys.argv[1])
-    with open(sys.argv[2], "w") as fh:
+    contract_path = sys.argv[1]
+    out_path = sys.argv[2]
+    env_override = None
+    if "--environment" in sys.argv:
+        idx = sys.argv.index("--environment")
+        if idx + 1 < len(sys.argv):
+            env_override = sys.argv[idx + 1]
+    # Also honor the ACDL_ENVIRONMENT_OVERRIDE env var (used by run_platform.sh).
+    if env_override is None and os.environ.get("ACDL_ENVIRONMENT_OVERRIDE"):
+        env_override = os.environ["ACDL_ENVIRONMENT_OVERRIDE"]
+    result = resolve(contract_path, environment_override=env_override)
+    with open(out_path, "w") as fh:
         json.dump(result, fh, indent=2)
-    print(f"resolver: resolved {sys.argv[1]} -> {sys.argv[2]}", file=sys.stderr)
+    print(f"resolver: resolved {contract_path} -> {out_path}", file=sys.stderr)

core/environment_check.py

@@ -10,6 +10,7 @@ Usage:
     python3 core/environment_check.py <contract.yaml>
     python3 core/environment_check.py --env dev
 """
+import json
 import sys
 from pathlib import Path
 
@@ -32,6 +33,27 @@ def _contract_environment(contract_path):
     return contract.get("environment")
 
 
+def load(env_name, root=None):
+    """Load and return the parsed environment JSON for env_name.
+
+    Returns the env dict, or raises FileNotFoundError if no <env_name>.json
+    exists. Emits a stderr warning when account_id is the 000000000000
+    placeholder and env_name != 'dev' (prompts real binding).
+    """
+    env_file = _environments_dir(root) / f"{env_name}.json"
+    if not env_file.is_file():
+        raise FileNotFoundError(f"no environment file for '{env_name}' at {env_file}")
+    with open(env_file) as f:
+        env = json.load(f)
+    if env.get("account_id") == "000000000000" and env_name != "dev":
+        sys.stderr.write(
+            f"WARNING: environment '{env_name}' has the placeholder account_id "
+            f"000000000000 — replace it with the real {env_name} account id "
+            f"before deploying (onboarding scaffold).\n"
+        )
+    return env
+
+
 def _onboarding_message(env_name):
     return (
         "=== ACDL Environment Onboarding ===\n"

core/environments/README.md

@@ -10,7 +10,17 @@ runner key — the platform manages all of that here.
 
 ## Files
 
-- `dev.json` — the default dev environment (autonomous, confidence ≥ 0.50).
+- `dev.json` — the default dev environment (autonomous, confidence >= 0.50).
+- `qa.json` — QA environment (attested, QA HITL gate, confidence >= 0.75).
+  Placeholder binding (replace account_id with the real QA account).
+- `prod.json` — Production environment (attested, SRE HITL gate, confidence >= 0.90).
+  Placeholder binding.
+- `dr.json` — DR environment (attested, SRE HITL gate, confidence >= 0.95).
+  Placeholder binding.
+
+All files validate against `schemas/environment.schema.json`. The qa/prod/dr
+placeholders use `account_id: 000000000000` with a stderr warning at load
+time (prompts real binding before deploying).
 
 ## How it is used
 

core/environments/dr.json

@@ -0,0 +1,17 @@
+{
+  "name": "dr",
+  "description": "DR environment — attested (SRE HITL gate, confidence >= 0.95). Placeholder binding; replace account_id with the real DR account.",
+  "account_id": "000000000000",
+  "region": "us-east-1",
+  "state_backend": {
+    "bucket": "acdl-dr-state",
+    "lock_table": "acdl-dr-locks"
+  },
+  "network": {
+    "vpc_cidr": "10.3.0.0/16",
+    "azs": ["us-east-1a", "us-east-1b"]
+  },
+  "runner_role_arn": "arn:aws:iam::000000000000:role/acdl-dr-runner",
+  "autonomy": "attested",
+  "confidence_threshold": 0.95
+}

core/environments/prod.json

@@ -0,0 +1,17 @@
+{
+  "name": "prod",
+  "description": "Production environment — attested (SRE HITL gate, confidence >= 0.90). Placeholder binding; replace account_id with the real prod account.",
+  "account_id": "000000000000",
+  "region": "us-east-1",
+  "state_backend": {
+    "bucket": "acdl-prod-state",
+    "lock_table": "acdl-prod-locks"
+  },
+  "network": {
+    "vpc_cidr": "10.2.0.0/16",
+    "azs": ["us-east-1a", "us-east-1b"]
+  },
+  "runner_role_arn": "arn:aws:iam::000000000000:role/acdl-prod-runner",
+  "autonomy": "attested",
+  "confidence_threshold": 0.90
+}

core/environments/qa.json

@@ -0,0 +1,17 @@
+{
+  "name": "qa",
+  "description": "QA environment — attested (QA HITL gate, confidence >= 0.75). Placeholder binding; replace account_id with the real QA account.",
+  "account_id": "000000000000",
+  "region": "us-east-1",
+  "state_backend": {
+    "bucket": "acdl-qa-state",
+    "lock_table": "acdl-qa-locks"
+  },
+  "network": {
+    "vpc_cidr": "10.1.0.0/16",
+    "azs": ["us-east-1a", "us-east-1b"]
+  },
+  "runner_role_arn": "arn:aws:iam::000000000000:role/acdl-qa-runner",
+  "autonomy": "attested",
+  "confidence_threshold": 0.75
+}

core/hitl_gates.py

@@ -0,0 +1,91 @@
+"""HITL pre-execution attestation gates (REQ-108, D-084).
+
+Records the approver identity (`gitea.actor` / `github.actor`) to the
+DynamoDB outbox for the contractId (attribute `approver_qa` /
+`approver_prod` / `approver_dr`), runs the separation-of-duties check on
+prod, invokes the 8-concern attestation matrix for the target env, and
+returns (ok, reason). Dev skips (autonomous). `scripts/run_platform.sh`
+calls `attest` before apply for qa/prod/dr.
+"""
+
+import os
+import sys
+from typing import Optional, Tuple
+
+
+def _approver_attr(env: str) -> str:
+    return {"qa": "approver_qa", "prod": "approver_prod", "dr": "approver_dr"}.get(env, "")
+
+
+def attest(contract_id: str, env: str, approver: str,
+           evidence: Optional[dict] = None,
+           outbox_client=None) -> Tuple[bool, str]:
+    """Attest a promotion gate for the given environment.
+
+    Args:
+        contract_id: the contract UUID.
+        env: dev/qa/prod/dr.
+        approver: the approver's username (`gitea.actor` / `github.actor`).
+        evidence: optional operator-supplied evidence artifacts (for the
+            attestation matrix operator-supplied concerns).
+        outbox_client: optional moto-mocked DynamoDB outbox client for tests.
+
+    Returns:
+        (ok, reason). ok=False means block the promotion.
+    """
+    if env == "dev":
+        return (True, "dev autonomous (no HITL gate)")
+
+    if not approver:
+        return (False, f"no approver identity for {env} (GITHUB_ACTOR/GITEA_ACTOR unset)")
+
+    attr = _approver_attr(env)
+    if not attr:
+        return (False, f"unknown environment: {env}")
+
+    # Record the approver to the outbox.
+    if outbox_client is not None:
+        outbox_client.put_approver(contract_id, attr, approver)
+
+    # Run the separation-of-duties check on prod.
+    if env == "prod":
+        from core.separation_of_duties import check as sod_check, route_halt_artifact
+        ok, reason = sod_check(outbox_client, contract_id, approver)
+        if not ok:
+            route_halt_artifact(contract_id, reason, oncall_client=None)
+            return (False, reason)
+
+    # Run the 8-concern attestation matrix.
+    from core.attestation_matrix import check as matrix_check
+    ok, reason = matrix_check(env, evidence or {})
+    if not ok:
+        return (False, reason)
+
+    return (True, f"{env} attested by {approver}")
+
+
+def approver_from_env() -> Optional[str]:
+    """Read the approver identity from the environment."""
+    return os.environ.get("GITHUB_ACTOR") or os.environ.get("GITEA_ACTOR")
+
+
+if __name__ == "__main__":
+    # CLI: hitl_gates.py <contract_id> <env> [evidence.json]
+    if len(sys.argv) < 3:
+        print("usage: hitl_gates.py <contract_id> <env> [evidence.json]", file=sys.stderr)
+        sys.exit(2)
+    _cid = sys.argv[1]
+    _env = sys.argv[2]
+    _evidence = {}
+    if len(sys.argv) >= 4 and os.path.isfile(sys.argv[3]):
+        import json
+        with open(sys.argv[3]) as f:
+            _evidence = json.load(f)
+    _approver = approver_from_env() or ""
+    ok, reason = attest(_cid, _env, _approver, _evidence)
+    if ok:
+        print(f"HITL PASS: {reason}")
+        sys.exit(0)
+    else:
+        print(f"HITL BLOCK: {reason}", file=sys.stderr)
+        sys.exit(1)

core/hitl_matrix_design.md

@@ -1,8 +1,10 @@
 # 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`).
+> **Status:** design authored in Phase 07 (milestone v1.1); **v1.9 wires
+> the gates** (Phase 42). The spike (Phases 08-10) was dev-only; HITL was
+> not exercised then. v1.9 implements the qa/prod/dr pre-execution
+> attestation gates, the 8-concern attestation matrix (offline-testable
+> subset), and the outbox-based separation-of-duties check.
 
 The vision's "Lower Environments are Autonomous; Higher Environments are
 Attested" tenet [1] and the "deliberate human attestation — not as a
@@ -29,11 +31,16 @@ is modeled as a `workflow_dispatch` with approval inputs:
 - **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 —
+(D-042). There is no other approval-identity signal in Gitea. The 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.
 
+On GitHub, the equivalent is `github.actor` of the `workflow_dispatch`
+run; GitHub Environments with required reviewers are the native gate,
+but the `workflow_dispatch` approval-input fallback is used for
+byte-identical Gitea + GitHub workflows.
+
 ## Reviewer routing (ARCHITECTURE.md §10.2)
 
 Gitea CODEOWNERS routes the right reviewer to the right gate:
@@ -44,9 +51,32 @@ Gitea CODEOWNERS routes the right reviewer to the right gate:
 
 CODEOWNERS **routes**; it does **not** enforce identity distinctness (that
 is the platform-internal outbox check in
-`platform/separation_of_duties.py`).
+`core/separation_of_duties.py`).
 
-## Full 8-concern attestation matrix (§10.4, lifted verbatim)
+## Full 8-concern attestation matrix (§10.4)
+
+The matrix is implemented in v1.9 as `core/attestation_matrix.py`
+(REQ-109, D-084). The concerns split into two tiers:
+
+**Offline-testable concerns** (run for real, no operator input):
+- Contract NFRs (the platform's own contract validator).
+- Schema validity (jsonschema).
+- Policy pass (Checkov/Wiz/Kyverno `PolicyCheckResult` records).
+
+**Operator-supplied concerns** (require an uploaded signed evidence
+artifact, validated for freshness + schema per D-084):
+- Functional correctness (e2e suite report).
+- Performance baseline (k6 / Gatling / Locust load test report).
+- Security posture (Trivy / Snyk / contract-declared scan + Security
+  on-call signature).
+- Operational readiness (runbook published, dashboard exists, on-call
+  rotation assigned, alerts configured).
+- Incident response (Sev-1 runbook tabletop or live drill completed).
+- Capacity / cost (FinOps forecast for next 30d within budget envelope).
+- Resilience (DR drill, chaos engineering report, backup verified).
+- dr-region deploy (most recent prod-bound dr drill as canary evidence).
+
+The full table (lifted verbatim from §10.4):
 
 | Env | Concern | Evidence artifact | Freshness | Source | Attester |
 |---|---|---|---|---|---|
@@ -60,6 +90,13 @@ is the platform-internal outbox check in
 | 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 |
 
+The operator-supplied evidence artifact is a JSON blob with `timestamp`,
+`type`, `payload`, and an optional `signature` (JWS detached). Freshness
+is validated against the window above. Signature verification runs when
+`ACDL_ATTESTATION_SIGNING_KEY_ID` is set; it is skipped + logged when
+unset (dev/CI — D-089). The matrix fails loud if an operator-supplied
+concern is missing or expired for prod/dr.
+
 ## Timeout behavior (§10.5)
 
 | Time | State | Action |
@@ -71,7 +108,8 @@ is the platform-internal outbox check in
 **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).
+implemented in v1.9 (roadmap item; the attestation gates themselves are
+wired, the timeout scanner is future work).
 
 ## Rejection and rollback (§10.6)
 
@@ -88,28 +126,50 @@ 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`).
+   from the `workflow_dispatch` run's `gitea.actor` (or `github.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`
+4. The check is implemented in `core/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
+v1.9 implements `route_halt_artifact` as a real SNS publish (topic
+`acdl-sod-halt`, ARN from `ACDL_SOD_HALT_TOPIC_ARN`) with an outbox-event
+fallback when the topic ARN is unset (REQ-107). The attestation gate
+itself is `core/hitl_gates.py` (`attest(contract_id, env, approver,
+evidence)`), which records the approver to the outbox, runs the SoD
+check on prod, invokes the attestation matrix, and returns `(ok, reason)`.
 
-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.
+## v1.9 wiring
+
+v1.9 (Phase 41 + Phase 42) wires the gates end-to-end:
+
+- **Phase 41** ships the per-environment CI job structure: one job per
+  environment (dev/qa/prod/dr), each pointing at its respective contract
+  (or the same contract + the `environment` workflow_call input). The
+  qa/prod/dr caller workflows use `workflow_dispatch` with the approval
+  inputs above; dev is autonomous (no gate). Promotion = running the
+  matching job; no `environment:` field editing (D-082).
+- **Phase 42** implements `core/hitl_gates.py` (the attestation gate),
+  `core/attestation_matrix.py` (the 8-concern matrix), and the real
+  `route_halt_artifact` (SNS + outbox fallback). `scripts/run_platform.sh`
+  calls `hitl_gates.attest` before apply for qa/prod/dr (dev skips).
 
 ## Decision trail
 
 - **D-042** — approver identity = `gitea.actor` of the `workflow_dispatch`
-  run; no Environments API in Gitea.
+  run; no Environments API in Gitea. On GitHub, `github.actor`.
 - **D-013** (v1.0) — the `workflow_dispatch` approval-input fallback,
-  re-used for the real platform's pre-execution gate model.
+  re-used for the real platform's pre-execution gate model.
+- **D-084** (v1.9) — 8-concern attestation matrix: offline-testable
+  concerns run for real; operator-supplied concerns accept signed
+  evidence artifacts validated for freshness + schema.
+- **D-089** (v1.9) — attestation artifact signature verification is
+  skipped when `ACDL_ATTESTATION_SIGNING_KEY_ID` is unset (dev/CI);
+  required for prod/dr.

core/lambda/contract_ingestor.py

@@ -0,0 +1,331 @@
+"""Platform Lambda — contract ingestor.
+
+Invoked via a Function URL (IAM auth) by consumer pipelines (one-way
+communication, D-051). Accepts { consumerRepo, contractId, contract,
+environment, action } and writes contracts to DynamoDB table acdl-contracts
+(PK consumerRepo, SK contractId#submittedAt).
+
+The report_error action (D-055) creates a GitHub issue on the platform repo
+via the GitHub API, using a token from Secrets Manager. It is idempotent: if
+an open issue with the same title exists, it comments rather than duplicating.
+
+Cross-account: the Lambda's Function URL uses IAM auth; the consumer's
+deploy role (granted during onboarding) invokes it via SigV4-signed
+requests. The invoke policy is scoped via ABAC (consumer repo identity).
+"""
+
+import datetime
+import json
+import os
+import urllib.parse
+
+import boto3
+
+TABLE_NAME = os.environ.get("CONTRACTS_TABLE", "acdl-contracts")
+CHANGE_REQUESTS_TABLE = os.environ.get("CHANGE_REQUESTS_TABLE", "acdl-change-requests")
+GITHUB_TOKEN_SECRET_ID = os.environ.get("GITHUB_TOKEN_SECRET_ID", "acdl/github-token")
+PLATFORM_REPO = os.environ.get("PLATFORM_REPO", "acdl/acdl")
+# P1-9: Forge-agnostic API base URL. Defaults to GitHub; set GITHUB_API_BASE
+# to a Gitea API root (e.g. https://git.cloudinit.dev/api/v1) for Gitea.
+GITHUB_API_BASE = os.environ.get("GITHUB_API_BASE", "https://api.github.com")
+
+_dynamodb = None
+_secrets_client = None
+
+
+def _get_dynamodb():
+    global _dynamodb
+    if _dynamodb is None:
+        _dynamodb = boto3.resource("dynamodb")
+    return _dynamodb
+
+
+def _get_secrets_client():
+    global _secrets_client
+    if _secrets_client is None:
+        _secrets_client = boto3.client("secretsmanager")
+    return _secrets_client
+
+
+def _iso8601_now():
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _forge_type():
+    """P1-9: Detect whether the API base is GitHub or Gitea.
+
+    Gitea API roots contain '/api/v1'; GitHub's is 'api.github.com'.
+    """
+    if "/api/v1" in GITHUB_API_BASE:
+        return "gitea"
+    return "github"
+
+
+def _issues_search_url(owner, repo, encoded_query):
+    """P1-9: Build the issue search URL based on forge type.
+
+    GitHub uses /search/issues?q=...; Gitea uses /repos/{owner}/{repo}/issues?...
+    with query params (no /search/issues endpoint).
+    """
+    if _forge_type() == "gitea":
+        return (
+            f"{GITHUB_API_BASE}/repos/{owner}/{repo}/issues"
+            f"?state=open&type=issues&q={encoded_query}"
+        )
+    return (
+        f"{GITHUB_API_BASE}/search/issues?q=repo:{owner}/{repo}"
+        f"+is:issue+is:open+in:title+%22{encoded_query}%22"
+    )
+
+
+def _issues_create_url(owner, repo):
+    """URL for creating an issue (same pattern for both GitHub + Gitea)."""
+    return f"{GITHUB_API_BASE}/repos/{owner}/{repo}/issues"
+
+
+def _issue_comments_url(owner, repo, issue_number):
+    """URL for posting a comment on an issue (same for both forges)."""
+    return f"{GITHUB_API_BASE}/repos/{owner}/{repo}/issues/{issue_number}/comments"
+
+
+def _submit_contract(payload):
+    consumer_repo = payload["consumerRepo"]
+    contract_id = payload["contractId"]
+    contract = payload["contract"]
+    environment = payload["environment"]
+    submitted_at = _iso8601_now()
+    table = _get_dynamodb().Table(TABLE_NAME)
+    item = {
+        "consumerRepo": consumer_repo,
+        "contractId#submittedAt": f"{contract_id}#{submitted_at}",
+        "contractId": contract_id,
+        "contract": contract,
+        "environment": environment,
+        "status": "submitted",
+        "submittedAt": submitted_at,
+    }
+    table.put_item(TableName=TABLE_NAME, Item=item)
+    return {
+        "status": "ok",
+        "contractId": contract_id,
+        "action": "submit_contract",
+        "submittedAt": submitted_at,
+    }
+
+
+def _report_error(payload):
+    """Create a GitHub issue on the platform repo for a deploy failure (D-055).
+
+    Uses the GitHub token from Secrets Manager. Idempotent: if an open
+    issue with the same title exists, comments on it rather than duplicating.
+    """
+    import urllib.request
+
+    required = ["consumerRepo", "contractId", "error"]
+    for field in required:
+        if field not in payload:
+            raise ValueError(f"report_error requires '{field}'")
+
+    consumer_repo = payload["consumerRepo"]
+    contract_id = payload["contractId"]
+    error = payload.get("error", "unknown error")
+    run_url = payload.get("runUrl", "")
+    stack_trace = payload.get("stackTrace", "")[:2000]  # truncate
+
+    # Get the GitHub token from Secrets Manager
+    secrets = _get_secrets_client()
+    try:
+        secret_response = secrets.get_secret_value(SecretId=GITHUB_TOKEN_SECRET_ID)
+        github_token = secret_response["SecretString"]
+    except Exception as e:
+        raise RuntimeError(f"failed to read GitHub token from Secrets Manager: {e}")
+
+    owner, repo = PLATFORM_REPO.split("/")
+    title = f"[ACDL-ALERT] Deploy failure: {consumer_repo} / {contract_id}"
+
+    # Check for an existing open issue with the same title (idempotency)
+    # URL-encode the contract_id to prevent search-query injection (P1-1).
+    encoded_contract_id = urllib.parse.quote(contract_id, safe="")
+    search_url = _issues_search_url(owner, repo, encoded_contract_id)
+    req = urllib.request.Request(search_url)
+    req.add_header("Authorization", f"token {github_token}")
+    req.add_header("Accept", "application/vnd.github+json")
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            search_result = json.loads(resp.read())
+        existing = search_result.get("items", [])
+    except Exception:
+        existing = []
+
+    body = f"""## Deploy Failure Report
+
+| Field | Value |
+|-------|-------|
+| **Consumer repo** | `{consumer_repo}` |
+| **Contract ID** | `{contract_id}` |
+| **Run URL** | {run_url if run_url else "_(not provided)_"} |
+| **Environment** | {payload.get('environment', 'unknown')} |
+
+## Error
+
+```
+{error}
+```
+
+## Stack Trace
+
+```
+{stack_trace}
+```
+
+_This issue was auto-created by the ACDL platform Lambda (D-055). The consumer's onboarding-granted Lambda-invoke permission is the only grant needed._
+"""
+
+    if existing:
+        # Comment on the existing issue
+        issue_number = existing[0]["number"]
+        url = _issue_comments_url(owner, repo, issue_number)
+        data = json.dumps({"body": body}).encode()
+        req = urllib.request.Request(url, data=data, method="POST")
+        req.add_header("Authorization", f"token {github_token}")
+        req.add_header("Accept", "application/vnd.github+json")
+        urllib.request.urlopen(req, timeout=10)
+        return {
+            "status": "commented_on_existing",
+            "issueNumber": issue_number,
+            "contractId": contract_id,
+            "action": "report_error",
+        }
+    else:
+        # Create a new issue
+        url = _issues_create_url(owner, repo)
+        data = json.dumps({
+            "title": title,
+            "body": body,
+            "labels": ["platform-alert", "auto-generated"],
+        }).encode()
+        req = urllib.request.Request(url, data=data, method="POST")
+        req.add_header("Authorization", f"token {github_token}")
+        req.add_header("Accept", "application/vnd.github+json")
+        resp = urllib.request.urlopen(req, timeout=10)
+        issue = json.loads(resp.read())
+        return {
+            "status": "issue_created",
+            "issueNumber": issue["number"],
+            "issueUrl": issue["html_url"],
+            "contractId": contract_id,
+            "action": "report_error",
+        }
+
+
+def _validate_caller_identity(event, payload):
+    """Validate that the payload's consumerRepo matches the invoking principal (P1-2).
+
+    The Lambda's Function URL uses IAM auth. The caller's identity is available
+    in event["requestContext"]["identity"]. We validate that the consumerRepo
+    in the payload matches the principal's ARN-derived source identity, preventing
+    one consumer from impersonating another.
+
+    If the identity is not available (e.g. local testing or non-IAM auth), the
+    check is skipped (the ABAC policy at the IAM layer enforces the scope).
+    """
+    identity = event.get("requestContext", {}).get("identity", {})
+    caller_arn = identity.get("userArn", "")
+    if not caller_arn:
+        return  # no identity available — rely on IAM ABAC enforcement
+    payload_repo = payload.get("consumerRepo", "")
+    if not payload_repo:
+        return
+    # Extract the session name or principal tag from the ARN. The ABAC policy
+    # scopes via aws:PrincipalTag/acdl:owner = <consumerRepo>. The Function URL
+    # IAM identity does not expose principal tags in the event, so we do a
+    # best-effort check: the consumerRepo must not be empty and must be a valid
+    # repo identifier (org/repo format). Full enforcement is at the IAM layer.
+    if "/" not in payload_repo or len(payload_repo) > 128:
+        raise ValueError(f"invalid consumerRepo format: {payload_repo!r}")
+
+
+def _validate_change_request(payload):
+    """REQ-93: Validate a change request ID against the CMDB (DynamoDB).
+
+    Queries the acdl-change-requests table for the given changeRequestId.
+    Returns the CR details if status is 'approved' and the consumerRepo matches.
+    Raises ValueError if the CR is not found, not approved, or the repo doesn't match.
+    """
+    required = ["changeRequestId", "consumerRepo"]
+    for field in required:
+        if field not in payload:
+            raise ValueError(f"validate_change_request requires '{field}'")
+
+    change_request_id = payload["changeRequestId"]
+    consumer_repo = payload["consumerRepo"]
+
+    table = _get_dynamodb().Table(CHANGE_REQUESTS_TABLE)
+    response = table.query(
+        KeyConditionExpression="changeRequestId = :crId",
+        ExpressionAttributeValues={":crId": change_request_id},
+        Limit=1,
+    )
+    items = response.get("Items", [])
+    if not items:
+        raise ValueError(f"change request '{change_request_id}' not found in CMDB")
+
+    cr = items[0]
+    if cr.get("status") != "approved":
+        raise ValueError(
+            f"change request '{change_request_id}' status is '{cr.get('status')}', expected 'approved'"
+        )
+
+    if cr.get("consumerRepo") != consumer_repo:
+        raise ValueError(
+            f"change request '{change_request_id}' consumerRepo mismatch: "
+            f"CR has '{cr.get('consumerRepo')}', request has '{consumer_repo}'"
+        )
+
+    return {
+        "status": "approved",
+        "changeRequestId": change_request_id,
+        "consumerRepo": consumer_repo,
+        "contractId": cr.get("contractId", ""),
+        "action": "validate_change_request",
+    }
+
+
+def lambda_handler(event, context):
+    """AWS Lambda handler entry point.
+
+    Accepts a Function-URL-style event whose ``body`` is a JSON string
+    containing ``{ consumerRepo, contractId, contract, environment, action }``.
+    """
+    try:
+        body = event.get("body", "{}")
+        if isinstance(body, str):
+            payload = json.loads(body)
+        else:
+            payload = body
+        action = payload.get("action", "submit_contract")
+        # Validate caller identity against the payload (P1-2).
+        _validate_caller_identity(event, payload)
+        if action == "submit_contract":
+            # Validate required fields up front for a clean 400.
+            for field in ("consumerRepo", "contractId", "contract", "environment"):
+                if field not in payload:
+                    return {
+                        "statusCode": 400,
+                        "body": json.dumps({"error": f"missing field: {field}"}),
+                    }
+            result = _submit_contract(payload)
+        elif action == "report_error":
+            result = _report_error(payload)
+        elif action == "validate_change_request":
+            result = _validate_change_request(payload)
+        else:
+            return {
+                "statusCode": 400,
+                "body": json.dumps({"error": f"unknown action: {action}"}),
+            }
+        return {"statusCode": 200, "body": json.dumps(result)}
+    except ValueError as e:
+        return {"statusCode": 400, "body": json.dumps({"error": str(e)})}
+    except Exception as e:  # pragma: no cover - defensive top-level guard
+        return {"statusCode": 500, "body": json.dumps({"error": str(e)})}

core/output_publisher.py

@@ -0,0 +1,183 @@
+"""Publish deploy outputs to SSM + format GitHub PR comments (D-050).
+
+Two canonical mechanisms:
+  1. SSM Parameter Store (SecureString, KMS-encrypted) for runtime-injectable
+     values — resources that need to read outputs at runtime (e.g. an ECS
+     task reading its S3 bucket name).
+  2. GitHub PR comment / job summary for human-readable outputs (connection
+     strings, ALB DNS, S3 bucket URL, CloudFront domain). No raw secrets in
+     the comment — only non-sensitive outputs (DNS names, ARNs, bucket names).
+
+The namespace is /acdl/{environment}/{contractId}/{output_name} so consumers
+can query their own outputs via aws ssm get-parameter --name /acdl/dev/<id>/...
+"""
+
+import json
+import os
+import sys
+
+try:
+    import boto3
+except ImportError:
+    boto3 = None
+
+SSM_PREFIX = "/acdl"
+KMS_KEY_ID_ENV = "ACDL_KMS_KEY_ID"
+
+# Outputs that are safe to display in a PR comment (no secrets).
+SAFE_OUTPUT_NAMES = {
+    "distribution_domain_name",
+    "bucket_arn",
+    "bucket_name",
+    "bucket_regional_domain_name",
+    "web_acl_arn",
+    "lb_arn",
+    "listener_arn",
+    "target_group_arn",
+    "service_arn",
+    "cluster_arn",
+    "repository_url",
+    "db_endpoint",
+    "db_arn",
+    "distribution_arn",
+    "vpc_id",
+    "subnet_ids",
+}
+
+
+def _ssm_client():
+    if boto3 is None:
+        raise RuntimeError("boto3 is required for SSM publishing")
+    return boto3.client("ssm")
+
+
+def _kms_key_id():
+    """Return the KMS key ID for SSM SecureString encryption.
+
+    P1-3: Fail loud when ACDL_KMS_KEY_ID is not set — silently falling back
+    to the AWS-managed key (`alias/aws/ssm`) was a security gap. The platform
+    CMK must be explicitly configured. Set ACDL_ALLOW_DEFAULT_KMS=1 to use
+    the AWS-managed key as an escape hatch for local testing.
+    """
+    key_id = os.environ.get(KMS_KEY_ID_ENV)
+    if key_id:
+        return key_id
+    if os.environ.get("ACDL_ALLOW_DEFAULT_KMS") == "1":
+        return "alias/aws/ssm"
+    raise RuntimeError(
+        f"{KMS_KEY_ID_ENV} is not set — refusing to use the AWS-managed SSM key "
+        f"silently. Set {KMS_KEY_ID_ENV} to your platform CMK ARN, or set "
+        f"ACDL_ALLOW_DEFAULT_KMS=1 to use alias/aws/ssm (escape hatch for local testing)."
+    )
+
+
+def publish_to_ssm(outputs, environment, contract_id):
+    """Write each output to SSM Parameter Store as a SecureString.
+
+    Returns a dict of {output_name: parameter_arn} for successful writes.
+    Skips None values and empty strings.
+    """
+    if boto3 is None:
+        return {}
+    client = _ssm_client()
+    kms_key = _kms_key_id()
+    results = {}
+    for name, value in outputs.items():
+        if value is None:
+            continue
+        if isinstance(value, str) and not value.strip():
+            continue
+        param_name = f"{SSM_PREFIX}/{environment}/{contract_id}/{name}"
+        try:
+            client.put_parameter(
+                Name=param_name,
+                Value=str(value),
+                Type="SecureString",
+                KeyId=kms_key,
+                Overwrite=True,
+            )
+            results[name] = param_name
+        except Exception:
+            # Don't fail the pipeline if one output fails to publish
+            results[name] = None
+    return results
+
+
+def format_comment(outputs, environment, contract_id, ssm_results=None):
+    """Format a GitHub PR comment / job summary with human-readable outputs.
+
+    Only non-sensitive outputs (SAFE_OUTPUT_NAMES) are included. Sensitive
+    outputs are noted as 'published to SSM' without their values.
+    """
+    lines = [
+        f"### ACDL Deploy Outputs ({environment})",
+        "",
+        f"**Contract:** `{contract_id}`",
+        f"**Environment:** `{environment}`",
+        "",
+        "| Output | Value | SSM |",
+        "|--------|-------|-----|",
+    ]
+    for name, value in sorted(outputs.items()):
+        if value is None:
+            continue
+        if isinstance(value, str) and not value.strip():
+            continue
+        safe = name in SAFE_OUTPUT_NAMES
+        display = str(value) if safe else "`(published to SSM)`"
+        ssm_path = ""
+        if ssm_results and ssm_results.get(name):
+            ssm_path = f"`{ssm_results[name]}`"
+        elif ssm_results is not None:
+            ssm_path = "—"
+        lines.append(f"| `{name}` | {display} | {ssm_path} |")
+    lines.append("")
+    lines.append("> Sensitive outputs are available via `aws ssm get-parameter --name /acdl/" + environment + "/" + contract_id + "/<output_name>` (KMS-encrypted SecureString).")
+    return "\n".join(lines)
+
+
+def post_github_comment(comment_text, token=None, repo=None, pr_number=None):
+    """Post a comment to a GitHub PR via the GitHub API.
+
+    Uses GITHUB_TOKEN from env if token is None. Uses GITHUB_REPOSITORY if
+    repo is None. Uses the PR number from the GITHUB_REF env if pr_number is
+    None (extracts from refs/pull/<N>/merge). No-op if not in a PR context.
+    """
+    if token is None:
+        token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if repo is None:
+        repo = os.environ.get("GITHUB_REPOSITORY", "")
+    if pr_number is None:
+        ref = os.environ.get("GITHUB_REF", "")
+        if "refs/pull/" in ref:
+            try:
+                pr_number = int(ref.split("/")[2])
+            except (IndexError, ValueError):
+                pass
+    if not token or not repo or not pr_number:
+        return False  # not in a PR context or no token
+    try:
+        import urllib.request
+        url = f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments"
+        data = json.dumps({"body": comment_text}).encode()
+        req = urllib.request.Request(url, data=data, method="POST")
+        req.add_header("Authorization", f"token {token}")
+        req.add_header("Accept", "application/vnd.github+json")
+        urllib.request.urlopen(req, timeout=10)
+        return True
+    except Exception:
+        return False
+
+
+if __name__ == "__main__":
+    # CLI: output_publisher.py <outputs.json> <environment> <contract_id>
+    if len(sys.argv) != 4:
+        print("usage: output_publisher.py <outputs.json> <environment> <contract-id>", file=sys.stderr)
+        sys.exit(2)
+    with open(sys.argv[1]) as f:
+        outputs = json.load(f)
+    env = sys.argv[2]
+    cid = sys.argv[3]
+    ssm_results = publish_to_ssm(outputs, env, cid)
+    comment = format_comment(outputs, env, cid, ssm_results)
+    print(comment)

core/separation_of_duties.py

@@ -1,16 +1,18 @@
 """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.
+contractId, compares to the prod-dispatch `gitea.actor` / `github.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)').
+v1.9 (REQ-107, D-085): route_halt_artifact is a real implementation —
+publishes to SNS topic `acdl-sod-halt` (ARN from ACDL_SOD_HALT_TOPIC_ARN)
+when set; falls back to a structured stderr emission + a
+SEPARATION_OF_DUTIES_VIOLATION event write to the DynamoDB outbox when
+unset. No silent print-only stub.
 """
 
+import os
+import sys
 from typing import Optional, Tuple
 
 
@@ -35,8 +37,59 @@ def check(outbox_client, contract_id: str,
 
 
 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)
+                        oncall_client=None) -> None:
+    """Route a halt artifact to SRE on-call (REQ-107, D-085).
+
+    When ACDL_SOD_HALT_TOPIC_ARN is set, publish to the SNS topic via
+    boto3. When unset (dev/CI), fall back to a structured stderr emission
+    + a SEPARATION_OF_DUTIES_VIOLATION event write to the DynamoDB outbox
+    via outbox_writer.write_event (so the halt is in the audit chain).
+    The oncall_client, when provided, is the SNS client (test injection).
+    """
+    topic_arn = os.environ.get("ACDL_SOD_HALT_TOPIC_ARN", "")
+    halt_payload = {
+        "contractId": contract_id,
+        "reason": violation_reason,
+        "action": "HALT_PROMOTION",
+    }
+    if topic_arn:
+        import json
+        try:
+            import boto3
+            if oncall_client is not None:
+                sns = oncall_client
+            else:
+                sns = boto3.client("sns")
+            sns.publish(
+                TopicArn=topic_arn,
+                Message=json.dumps(halt_payload),
+                Subject="ACDL SoD halt",
+            )
+            print(f"[halt-artifact] SNS published contract={contract_id} "
+                  f"topic={topic_arn}", flush=True)
+            return
+        except Exception as exc:
+            sys.stderr.write(
+                f"[halt-artifact] SNS publish failed ({exc}); "
+                f"falling back to outbox event\n"
+            )
+    # Fallback: stderr + outbox event (the halt is in the audit chain).
+    sys.stderr.write(
+        f"[halt-artifact] contract={contract_id} reason={violation_reason} "
+        f"oncall={oncall_client} (no SNS topic — outbox fallback)\n"
+    )
+    try:
+        from core.outbox_writer import write_event
+        write_event({
+            "contractId": contract_id,
+            "eventType": "SEPARATION_OF_DUTIES_VIOLATION",
+            "environment": "",
+            "stack": "",
+            "score": 0,
+            "band": "halt",
+            "reason": violation_reason,
+        })
+    except Exception as exc:
+        sys.stderr.write(
+            f"[halt-artifact] outbox fallback write failed ({exc})\n"
+        )

docs/architecture.md

@@ -21,7 +21,7 @@ flowchart TD
     A["Consumer surfaces"] --> B["Contract schema"]
     B --> C["Central pipeline"]
     C --> D["Modules + primitives"]
-    C --> E["Substrate adapter"]
+    C --> E["Angine adapter"]
     C --> F["Confidence signal"]
     C --> G["Evidence stream"]
     D --> E
@@ -31,12 +31,12 @@ flowchart TD
 
 The four layers:
 
-1. **Primitives** — single-purpose, substrate-agnostic modules representing
+1. **Primitives** — single-purpose, engine-agnostic modules representing
    the smallest reusable infrastructure pieces (a VPC, an S3 bucket, an ECS
    cluster). A primitive does not reference other primitives; it takes its
    environment as input.
 2. **Modules** — patterns that combine primitives into deployable
-   infrastructure shapes (an ECS Fargate microservice, a static-asset site).
+   infrastructure shapes (an ECS Fargate microservice, a static-assets site).
    A module references registered primitives (max depth 5).
 3. **Developer surface** — the developer-owned workflow file + contract. The
    developer references the central pipeline via a versioned tag and owns
@@ -51,9 +51,9 @@ Both end in a contract submission that enters the same pipeline.
 
 ## 2. Primitives
 
-Single-purpose, substrate-agnostic modules. Locked commitments:
+Single-purpose, engine-agnostic modules. Locked commitments:
 
-- No inter-primitive references. A primitive may call substrate data sources.
+- No inter-primitive references. A primitive may call engine data sources.
 - Semver with three triggers: interface → MAJOR, behavior → MINOR,
   lifecycle → PATCH.
 - Immutability on publication.
@@ -61,8 +61,8 @@ Single-purpose, substrate-agnostic modules. Locked commitments:
 - AI refinement is a flag, triggered by a joint operational condition
   (N ≥ 50 consecutive zero-rollback changes, no primitive/module incident in
   6 months, Infra & Ops unilateral override).
-- A primitive's interface is defined against the Target Stack (substrate-
-  agnostic), not against any substrate's variable block directly.
+- A primitive's interface is defined against the Target Stack (engine-
+  agnostic), not against any engine's variable block directly.
 
 ## 3. Modules
 
@@ -79,9 +79,9 @@ Patterns that combine primitives into deployable shapes. Locked commitments:
   creation, key/secret creation, external data transfer.
 - Auto-promote after 3 observed usages.
 - A module's pattern tree wires field is defined against the stack's
-  relationship type, not against any substrate's module block. The stack →
-  substrate translation is the substrate adapter's job (§12). The pattern
-  pipeline itself is substrate-agnostic.
+  relationship type, not against any engine's module block. The stack →
+  engine translation is the engine adapter's job (§12). The pattern
+  pipeline itself is engine-agnostic.
 
 ## 4. Developer Surface
 
@@ -110,7 +110,7 @@ Patterns that combine primitives into deployable shapes. Locked commitments:
 - Central repo + generated client libraries.
 - Multi-stage validation pipeline: schema → policy → NFR → confidence.
 - Distributed enrichment.
-- GitOps reconciler + substrate execution layer.
+- GitOps reconciler + engine execution layer.
 - The pipeline emits a `PolicyCheckResult` record per policy rule evaluated;
   the confidence signal consumes these as one normalized input (§8).
 
@@ -174,12 +174,12 @@ integration, contract, security smoke, and performance smoke validation.
 - The DynamoDB outbox enforces identity distinctness across environment
   approvers.
 
-## 12. Cross-Cutting — Substrate Execution
+## 12. Cross-Cutting — Angine Execution
 
-The technical execution layer. Primitives and modules are substrate-agnostic
-in shape; substrate adapters are the only substrate-specific component.
+The technical execution layer. Primitives and modules are engine-agnostic
+in shape; engine adapters are the only engine-specific component.
 
-The architecture defines a **Target Stack** — a substrate-neutral
+The architecture defines a **Target Stack** — a engine-neutral
 description of:
 
 - The resources to create (typed against the stack schema).
@@ -189,7 +189,7 @@ description of:
 
 The registry, the module pattern tree, the contract schema, and the
 `PolicyCheckResult` schema are all defined against the stack schema. None is
-defined against any specific substrate.
+defined against any specific engine.
 
 **v1 implementation reality:** the stack is shaped to round-trip cleanly to
 Terraform because there is no other adapter to differentiate from. As
@@ -198,19 +198,19 @@ gain translation logic, but the primitive content, the module pattern tree,
 and the contract schema do not change. This is the design that prevents a
 polyglot mess.
 
-The substrate adapter:
+The engine adapter:
 
-- Translates the stack-typed module pattern tree to a substrate root module
+- Translates the stack-typed module pattern tree to a engine root module
   that calls the primitive modules.
 - Is a thin layer. It does not own primitive/module content; it only
   translates.
-- Is the only substrate-specific code in the platform.
+- Is the only engine-specific code in the platform.
 
-Policy checks run on the substrate plan output. Results are normalized to
+Policy checks run on the engine plan output. Results are normalized to
 `PolicyCheckResult` records by a policy adapter. The confidence signal
 consumes the union of all `PolicyCheckResult` records, regardless of engine
-— substrate-agnostic over its inputs, matching the module model's
-substrate-agnosticism over its outputs.
+— engine-agnostic over its inputs, matching the module model's
+engine-agnosticism over its outputs.
 
 ## 13. Cross-Cutting — Platform Runners
 
@@ -230,12 +230,12 @@ change to the modules/stack/confidence/audit.
 - A MAJOR bump requires a new registry entry (immutable publication); the
   old entry enters a 12-month deprecation window.
 - The central deploy pipeline is referenced by a floating MAJOR + MINOR tag
-  (e.g. `@v1.4`); patch fixes flow within the tag, breaking changes land
+  (e.g. `@v1.6`); patch fixes flow within the tag, breaking changes land
   under the next MINOR tag.
 
 See [Versioning](pipeline/versioning) for the consumer-facing details.
 
 ## 15. OpenTofu
 
-Not in v1. The substrate abstraction (§12) makes OpenTofu a future adapter,
+Not in v1. The engine abstraction (§12) makes OpenTofu a future adapter,
 not an architecture change. Revisit when an OpenTofu adapter is requested.

docs/consumer-guide.md

@@ -2,7 +2,7 @@
 
 This guide walks a consumer through creating their pipeline and defining a
 contract that deploys any ACDL module to AWS. It is **generic** across all
-modules in the registry; `static-asset` is the worked example, but every
+modules in the registry; `static-assets` is the worked example, but every
 step applies to `microservice` and any future module.
 
 ## The model
@@ -10,7 +10,7 @@ step applies to `microservice` and any future module.
 Consumers have their own repos and consume ACDL by referencing `uses:` the
 central pipeline definitions. The consumer declares a **contract** (which
 module, which environment, which inputs); the ACDL platform owns the
-pipelines, modules, substrate adapter, and evidence stream.
+pipelines, modules, engine adapter, and evidence stream.
 
 You do not write infrastructure modules, workflow YAML, or adapter code.
 You write a contract YAML file and the platform does the rest. Your
@@ -19,7 +19,7 @@ definitions.
 
 ```mermaid
 flowchart LR
-    A["your repo<br/>(app code + contracts + CI definitions)"] -->|uses: acdl/.github/workflows/deploy.yml@v1.4| B
+    A["your repo<br/>(app code + contracts + CI definitions)"] -->|uses: acdl/.github/workflows/deploy.yml@v1.9| B
     B["platform runners<br/>(modules + pipelines + adapters + schemas)"] -->|contract -&gt; resolver -&gt; stack -&gt; adapter<br/>-&gt; security checks -&gt; infrastructure plan -&gt; policy checks<br/>-&gt; confidence -&gt; apply -&gt; evidence event| C
     C["your resources in AWS"]
 ```
@@ -27,7 +27,7 @@ flowchart LR
 ## Versioning the `uses:` reference
 
 The central deployment pipeline is **always versioned with floating MAJOR
-and MINOR tags** (e.g. `acdl/pipelines/deploy.yaml@v1.4`). Version
+and MINOR tags** (e.g. `acdl/pipelines/deploy.yaml@v1.9`). Version
 constraints cannot be expressed inside the contract, so the tag in
 `uses:` is the only immutability lever a consumer has. See
 [Versioning](pipeline/versioning) for the full rationale.
@@ -47,7 +47,7 @@ platform-managed. See [Environments](environments/).
   environment is bound, your first pipeline run emits a friendly onboarding
   prompt. See [Environments](environments/).
 - **Authorization to reference the central pipeline.** Onboarding grants
-  your repo the right to `uses: acdl/.github/workflows/deploy.yml@v1.4`.
+  your repo the right to `uses: acdl/.github/workflows/deploy.yml@v1.9`.
   Contact the platform team if you have not been onboarded.
 
 ## Step 1 — Create a consumer repo
@@ -92,7 +92,7 @@ In your contract YAML, declare `uses:` pointing at the central ACDL
 deployment pipeline with a **versioned tag** (floating MAJOR + MINOR):
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
+uses: acdl/pipelines/deploy.yaml@v1.9
 ```
 
 This tells the platform to run the standard deployment pipeline:
@@ -101,11 +101,11 @@ policy checks → confidence → evidence event → apply.
 
 ## Step 3 — Define the contract
 
-Write `.acdl/contract.yaml`. The `static-asset` example:
+Write `.acdl/contract.yaml`. The `static-assets` example:
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
-module: static-asset
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
 environment: dev
 inputs:
   bucket_name: my-static-site-assets
@@ -115,7 +115,7 @@ inputs:
 A `microservice` example:
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
+uses: acdl/pipelines/deploy.yaml@v1.9
 module: microservice
 environment: dev
 inputs:
@@ -129,8 +129,8 @@ inputs:
 
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
-| `uses` | string | yes | Reference to the central deployment pipeline, **versioned** with a floating MAJOR+MINOR tag (e.g. `acdl/pipelines/deploy.yaml@v1.4`). Bare or `@main` references are discouraged. See [Versioning](pipeline/versioning). |
-| `module` | string | yes | Module name from the registry — any primitive or module (e.g. `static-asset`, `microservice`, `s3`). See the [module catalog](modules/). |
+| `uses` | string | yes | Reference to the central deployment pipeline, **versioned** with a floating MAJOR+MINOR tag (e.g. `acdl/pipelines/deploy.yaml@v1.9`). Bare or `@main` references are discouraged. See [Versioning](pipeline/versioning). |
+| `module` | string | yes | Module name from the registry — any primitive or module (e.g. `static-assets`, `microservice`, `s3`). See the [module catalog](modules/). |
 | `environment` | string | yes | The platform-managed environment to deploy to (e.g. `dev`). See [Environments](environments/). |
 | `inputs` | object | yes | Module-specific inputs (see the module's README). |
 
@@ -139,7 +139,10 @@ inputs:
 Each module declares its inputs in its `interface.json` (primitives) or
 `composition.json` (modules). Consult the [module catalog](modules/) for
 the full list, or read the module's own README under `modules/l1/<name>/`
-or `modules/l2/<name>/`.
+or `modules/l2/<name>/`. Each module also has an `examples/` directory
+with validated consumer contract examples (`simple.yaml` + `complex.yaml`
++ variation files) that demonstrate real usage — see the module's
+`## Examples` section.
 
 The contract is validated against the contract schema. An invalid contract
 (missing field, unknown module, wrong type) fails at the validate-contract
@@ -163,14 +166,14 @@ on:
     branches: [main]
 jobs:
   deploy:
-    uses: acdl/.github/workflows/deploy.yml@v1.4
+    uses: acdl/.github/workflows/deploy.yml@v1.9
     with:
       contract: .acdl/contract.yaml
 ```
 
 That is the entire consumer-side workflow. When you push to `main`:
 
-1. The platform runner resolves `uses: acdl/.github/workflows/deploy.yml@v1.4`
+1. The platform runner resolves `uses: acdl/.github/workflows/deploy.yml@v1.9`
    to the reusable workflow **at the pinned tag**.
 2. A **platform-provided runner** checks out **your** repo.
 3. The runner checks out the **ACDL platform repo** into the workspace —
@@ -226,7 +229,7 @@ flowchart TD
    a stack JSON instance.
 3. **security checks** (adapter) — security checks run on the resolved
    stack before any infrastructure is planned.
-4. **infrastructure plan** (adapter) — the substrate adapter compiles the
+4. **infrastructure plan** (adapter) — the engine adapter compiles the
    stack to an infrastructure plan. You see the plan in your run logs.
 5. **policy checks** (adapter) — policy checks run on the plan. The results
    are normalized to `PolicyCheckResult` records. Each result has a
@@ -245,22 +248,26 @@ flowchart TD
 After a successful `dev` run, the resources declared by your module's
 pattern exist in your AWS account, and an evidence event is recorded.
 
-For the `static-asset` example:
+For the `static-assets` example:
 
 - **An S3 bucket** named `my-static-site-assets` in `us-east-1` with
   versioning enabled.
+- **A CloudFront distribution** with the S3 bucket as the origin (via
+  Origin Access Control) and HTTPS redirection.
+- **A WAFv2 Web ACL** (CloudFront-scoped) associated with the
+  distribution.
 - **An evidence event** in the audit outbox with the contract ID, stack
-  name (`static-asset`), confidence score, and band.
+  name (`static-assets`), confidence score, and band.
 - **A confidence band** of `pass` (score ≥ 0.50 for dev).
 
 For other modules, consult the module's README
 (`modules/l1/<name>/README.md` or `modules/l2/<name>/README.md`) for the
 exact resources created.
 
-## Step 7 — Upload your content (static-asset example)
+## Step 7 — Upload your content (static-assets example)
 
 The platform provisions the infrastructure; you upload your content. For
-the `static-asset` module:
+the `static-assets` module:
 
 ```bash
 aws s3 sync ./assets s3://my-static-site-assets/ --acl public-read
@@ -274,7 +281,7 @@ push your container image to the ECR repo the platform created.
 Change `environment` in your contract (keeping the same versioned `uses:`):
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
+uses: acdl/pipelines/deploy.yaml@v1.9
 environment: qa   # QA attestation + confidence >= 0.75
 ```
 
@@ -285,7 +292,7 @@ for the full table.
 ## Step 9 — Compliance extensions
 
 Each module lists compliance extension points for the future compliance
-milestone (GDPR, SOX, SOC2, HIPAA, DORA). See each module's README under
+milestone (GDPR, SOX, SOC2, DORA). See each module's README under
 `modules/l1/<name>/README.md` or `modules/l2/<name>/README.md` for the
 per-module extension points. Common examples:
 
@@ -303,11 +310,150 @@ per-module extension points. Common examples:
 | Contract schema | `schemas/contract.schema.json` | JSON Schema for consumer contracts. |
 | Stack schema | `schemas/stack.schema.json` | JSON Schema for the resolved stack instance. |
 | Module catalog | [modules/](modules/) | All primitives and modules. |
-| Sample contract | `contracts/static-asset.yaml` | The reference example contract (uses `@v1.4`). |
+| Sample contract | `contracts/static-assets.yaml` | The reference example contract (uses `@v1.9`). |
+| Sample contract | `contracts/microservice.yaml` | The microservice example contract (uses `@v1.9`). |
+| Module examples | `modules/<name>/examples/` | Validated per-module example contracts (`simple.yaml` + `complex.yaml`). |
 | Contract resolver | `core/contract_resolver.py` | Resolves contracts to stack instances. |
-| Substrate adapter | `adapters/terraform/adapter.py` | Compiles stack instances to infrastructure. |
+| Angine adapter | `adapters/terraform/adapter.py` | Compiles stack instances to infrastructure. |
 | Platform pipeline runner | `scripts/run_platform.sh` | The pipeline runner (platform-side; consumers do not invoke it directly). |
 | Environments | [environments/](environments/) | Platform-managed environments + onboarding. |
 | Versioning | [pipeline/versioning](pipeline/versioning) | The `uses:` tag + module versioning. |
 | Platform README | `README.md` | How the platform works + how to run the platform repo locally. |
-| Credentials & zero-trust | `README.md#credentials--zero-trust` | The OIDC/ABAC default + static-key override model. |
+| Credentials & zero-trust | `README.md#credentials--zero-trust` | The OIDC/ABAC default + static-key override model. |
+
+## Decommissioning a stack
+
+When a consumer needs to tear down a deployed stack, the platform provides
+a **decommission mode** on the same deploy pipeline. The decommission
+process is a 2-step pipeline with **HITL SRE gates** to prevent accidental
+destruction:
+
+1. **Request a change request (CR):** Contact the platform team to create a
+   change request in the platform CMDB (DynamoDB `acdl-change-requests`
+   table). The CR must be approved before decommission can proceed. The CR
+   includes the consumer repo, contract ID, and the reason for decommission.
+
+2. **Trigger decommission:** Update the consumer's deploy workflow call to
+   use `mode: decommission` with the `changeRequestId` input:
+
+   ```yaml
+   uses: acdl/.github/workflows/deploy.yml@v1.8
+   with:
+     contract: .acdl/contract.yaml
+     mode: decommission
+     changeRequestId: "CHG0678912"
+   ```
+
+3. **Step 1 — Disable deletion protection (HITL SRE gate):** The pipeline
+   validates the CR ID against the CMDB (status must be `approved`). Then
+   it resolves the contract with `deletion_protection: false` injected into
+   all resources and runs `terraform plan` + `terraform apply`. This
+   removes the `prevent_destroy` lifecycle meta-argument from all resources.
+   **An SRE must approve this step** via the GitHub environment
+   `decommission-gate-sre`.
+
+4. **Step 2 — Zero counts + destroy (HITL SRE gate):** The pipeline applies
+   `decommission_transform` which sets all scalable counts to 0
+   (`desired_count=0`, `min_capacity=0`, `max_capacity=0`) and
+   `deletion_protection=false` on all resources. Then it runs
+   `terraform plan` + `terraform apply` which destroys all resources (now
+   that deletion protection is off and counts are zeroed). **A second SRE
+   must approve this step** via the GitHub environment
+   `decommission-destroy-sre`.
+
+5. **Confirmation:** The pipeline confirms the stack is destroyed
+   (terraform state is empty for the stack).
+
+### What happens to the per-stack CMK?
+
+The per-stack CMK is not immediately destroyed — it enters a deletion
+window (default 30 days, configurable via the `deletion_window_days` input).
+This ensures any encrypted data can still be decrypted during the deletion
+window if needed. The CMK is permanently deleted after the window expires.
+
+### What happens to the uptime monitoring?
+
+The uptime monitoring stack (deployed with separate state) is not
+automatically destroyed by the decommission. It must be destroyed
+separately (or left running to monitor the decommissioned stack's
+endpoints going dark).
+## Per-environment deployment
+
+ACDL supports a **promotion-without-editing** model: you do not edit the
+`environment:` field in a contract to promote dev → qa → prod → dr.
+Instead, there is **one CI job per environment**, each pointing at its
+respective contract (or the same contract + the `environment` workflow
+input). Promotion = running the matching job.
+
+### Two shapes (both supported)
+
+**Shape 1 — per-environment contract files:** a consumer repo has one
+contract per environment (e.g. `.acdl/static-assets.dev.yaml`,
+`.acdl/static-assets.qa.yaml`, …). Each sets `environment:` to its own
+name and uses interpolation so env-specific values differ automatically:
+
+```yaml
+# .acdl/static-assets.qa.yaml
+uses: acdl/pipelines/deploy.yaml@v1.9
+module: static-assets
+environment: qa
+inputs:
+  bucket_name: acdl-${env.environment}-${contract.module}-${env.account_id}-${env.region}
+  region: ${env.region}
+```
+
+**Shape 2 — single contract + `environment` workflow input:** the
+reusable deploy workflow (`acdl/.github/workflows/deploy.yml@v1.9`)
+declares an `environment` input. When non-empty, it overrides the
+contract's `environment` field at load time (before interpolation), so
+the same contract can be promoted by passing a different environment:
+
+```yaml
+# .github/workflows/deploy-qa.yml  (caller workflow)
+on: workflow_dispatch:
+  inputs:
+    approve_qa:
+      description: "Set to true to approve the QA promotion"
+      type: boolean
+      required: true
+jobs:
+  deploy-qa:
+    uses: acdl/.github/workflows/deploy.yml@v1.9
+    with:
+      environment: qa
+      contract: .acdl/contract.yaml
+```
+
+### One job per environment
+
+A consumer repo's `.github/workflows/` directory has one caller workflow
+per environment:
+
+| File | Environment | Gate |
+|------|-------------|------|
+| `deploy-dev.yml` | dev | autonomous (no gate, confidence ≥ 0.50) |
+| `deploy-qa.yml` | qa | QA HITL (`approve_qa` workflow_dispatch input; `github.actor` is the approver of record) |
+| `deploy-prod.yml` | prod | SRE HITL (`approve_prod`; separation-of-duties enforced) |
+| `deploy-dr.yml` | dr | SRE HITL (`approve_dr`) |
+
+**Promotion = running the matching job.** No `environment:` field editing.
+The approver identity is recorded to the DynamoDB outbox
+(`approver_qa` / `approver_prod` / `approver_dr`) and the separation-of-
+duties check blocks a prod promotion when `approver_qa == approver_prod`
+(see `core/hitl_matrix_design.md`).
+
+### Interpolation reference
+
+| Token | Resolves to | Example |
+|-------|-------------|---------|
+| `${env.environment}` | the environment name (dev/qa/prod/dr) | `qa` |
+| `${env.region}` | the environment's AWS region | `us-east-1` |
+| `${env.account_id}` | the environment's AWS account id | `123456789012` |
+| `${env.state_backend.bucket}` | the environment's state bucket | `acdl-qa-state` |
+| `${env.network.vpc_cidr}` | the environment's VPC CIDR | `10.1.0.0/16` |
+| `${contract.module}` | the contract's module name | `static-assets` |
+| `${contract.environment}` | the contract's environment field | `qa` |
+| `${contract.inputs.<name>}` | a contract input value | (as declared) |
+
+Unknown tokens raise `ValueError` (fail loud). Expansion is recursive
+(nested map/list values expand too).

docs/contracts/index.md

@@ -8,11 +8,11 @@ resolves, and deploys it.
 ## The contract file
 
 A consumer repo keeps its contract at `.acdl/contract.yaml`. A minimal
-example (the `static-asset` module):
+example (the `static-assets` module):
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
-module: static-asset
+uses: acdl/pipelines/deploy.yaml@v1.6
+module: static-assets
 environment: dev
 inputs:
   bucket_name: my-static-site-assets
@@ -22,7 +22,7 @@ inputs:
 A `microservice` example:
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
+uses: acdl/pipelines/deploy.yaml@v1.6
 module: microservice
 environment: dev
 inputs:
@@ -36,8 +36,8 @@ inputs:
 
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
-| `uses` | string | yes | Reference to the central deploy pipeline, **versioned** with a floating MAJOR+MINOR tag (e.g. `acdl/pipelines/deploy.yaml@v1.4`). Bare or `@main` references are discouraged. See [Versioning](../pipeline/versioning). |
-| `module` | string | yes | Module name from the registry — any primitive or module (e.g. `static-asset`, `microservice`, `s3`). See the [module catalog](../modules/). |
+| `uses` | string | yes | Reference to the central deploy pipeline, **versioned** with a floating MAJOR+MINOR tag (e.g. `acdl/pipelines/deploy.yaml@v1.6`). Bare or `@main` references are discouraged. See [Versioning](../pipeline/versioning). |
+| `module` | string | yes | Module name from the registry — any primitive or module (e.g. `static-assets`, `microservice`, `s3`). See the [module catalog](../modules/). |
 | `environment` | string | yes | The platform-managed environment to deploy to (e.g. `dev`). See [Environments](../environments/). |
 | `inputs` | object | yes | Module-specific inputs (see the module's README). |
 
@@ -48,11 +48,18 @@ The contract is validated against
 An invalid contract (missing field, unknown module, wrong type) fails at the
 validate-contract stage with a clear error.
 
-## Sample contract
+## Sample contracts
 
-The reference example is
-[`contracts/static-asset.yaml`](https://github.com/acdl/acdl/blob/main/contracts/static-asset.yaml),
-which uses `@v1.4` as the canonical versioned `uses:` reference.
+Two reference examples exist in `contracts/`:
+
+- [`contracts/static-assets.yaml`](https://github.com/acdl/acdl/blob/main/contracts/static-assets.yaml)
+  — the `static-assets` module (uses `@v1.6`).
+- [`contracts/microservice.yaml`](https://github.com/acdl/acdl/blob/main/contracts/microservice.yaml)
+  — the `microservice` module (uses `@v1.6`).
+
+Additionally, every module has a `modules/<name>/examples/` directory with
+validated example contracts (`simple.yaml` + `complex.yaml` + variation
+files). See the [module catalog](../modules/) for the full list.
 
 ## Multiple contracts
 

docs/environments/index.md

@@ -53,6 +53,41 @@ normally.
 attestation (a platform-runner deployment approval) and a higher confidence
 threshold. Staging does not exist.
 
+## Cross-account contract ingestion grant (D-051)
+
+Onboarding now also grants the consumer repo's deploy role permission to
+invoke the **platform Lambda** — `acdl-contract-ingestor` — across
+accounts. The Lambda is invoked via a Function URL with IAM auth, so the
+grant is an inline IAM policy applied to the consumer's deploy role. The
+policy template lives at
+[`terraform/platform/consumer_invoke_policy.json`](https://github.com/acdl/acdl/blob/main/terraform/platform/consumer_invoke_policy.json)
+and is scoped via **ABAC**: the condition
+`aws:PrincipalTag/acdl:owner == ${consumerRepo}` ensures a repo can only
+invoke the Lambda when its principal tag matches its claimed identity.
+
+The consumer's deploy workflow signs the Function URL request with
+SigV4 using its deploy-role credentials; the platform Lambda validates
+the signature and the ABAC condition before accepting the payload.
+
+This is a **one-way** channel — the consumer pushes contracts *to* the
+platform; the platform never reaches back into the consumer account. It
+is used for two purposes:
+
+1. **Contract ingestion** — the consumer submits its resolved deployment
+   contract (`action: "submit_contract"`) so the platform has a durable
+   record in the `acdl-contracts` DynamoDB table (PK `consumerRepo`, SK
+   `contractId#submittedAt`).
+2. **Error reporting** (D-055) — the consumer reports a deployment error
+   (`action: "report_error"`) which the platform turns into a GitHub
+   issue on the platform repo (wired in Phase 25; the Lambda returns a
+   prepared-status stub until then).
+
+The Lambda handler and the Terraform that deploys it live in
+[`core/lambda/contract_ingestor.py`](https://github.com/acdl/acdl/blob/main/core/lambda/contract_ingestor.py)
+and
+[`terraform/platform/main.tf`](https://github.com/acdl/acdl/blob/main/terraform/platform/main.tf)
+respectively.
+
 ## Onboarding scaffold (current state)
 
 The platform repo ships a minimal onboarding scaffold:

docs/index.md

@@ -32,7 +32,7 @@ There are two kinds of repository in the ACDL model:
 | [Pipeline](pipeline/) | Consumers + platform engineers | The central CI + deployment pipeline and its stages. |
 | [Versioning](pipeline/versioning) | Consumers + platform engineers | Module versioning + deploy-pipeline versioning (the `uses:` tag). |
 | [Environments](environments/) | Consumers | Platform-managed environments and the first-run onboarding flow. |
-| [Architecture](architecture) | Platform engineers | The current architecture — layers, cross-cutting concerns, the substrate abstraction. |
+| [Architecture](architecture) | Platform engineers | The current architecture — layers, cross-cutting concerns, the engine abstraction. |
 | [Vision](vision) | All | The why — the friction the platform absorbs and the north star. |
 
 ## Features
@@ -63,8 +63,8 @@ Planned future features (no dates; tracked in the internal roadmap):
   consumer creates a module directly from the contract file (the "composition"
   mechanism, redesigned).
 - **Compliance milestone** — per-module compliance extension points (GDPR,
-  SOX, SOC2, HIPAA, DORA) wired into the pipeline.
-- **Additional substrate adapters** — beyond the Terraform adapter.
+  SOX, SOC2, DORA) wired into the pipeline.
+- **Additional engine adapters** — beyond the Terraform adapter.
 - **Environment self-service** — a consumer-facing flow to request and
   provision a new platform-managed environment.
 - **HITL gates for qa / prod / dr** — human attestation + higher confidence

docs/modules/index.md

@@ -9,7 +9,7 @@ Reusable building blocks for cloud infrastructure. There are two kinds:
   complete stack (e.g. an ECS Fargate microservice). Each module has a
   `composition.json` declaring its children and wires.
 
-The substrate adapter compiles a module instance to infrastructure. Each
+The engine adapter compiles a module instance to infrastructure. Each
 module's README documents which resources it creates.
 
 ## Primitives
@@ -23,12 +23,15 @@ module's README documents which resources it creates.
 | `iam-role` | `aws_iam_role` — IAM role with assume-role policy | [modules/l1/iam-role/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/iam-role/README.md) |
 | `alb` | `aws_lb` + `aws_lb_target_group` + `aws_lb_listener` — Application Load Balancer | [modules/l1/alb/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/alb/README.md) |
 | `ecr` | `aws_ecr_repository` — ECR container image repository | [modules/l1/ecr/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/ecr/README.md) |
+| `cloudfront` | `aws_cloudfront_distribution` + `aws_cloudfront_origin_access_control` — CloudFront distribution with S3 origin via OAC | [modules/l1/cloudfront/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/cloudfront/README.md) |
+| `waf` | `aws_wafv2_web_acl` — WAFv2 Web ACL (CloudFront-scoped) | [modules/l1/waf/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/waf/README.md) |
+| `rds` | `aws_db_instance` — RDS database instance (multi-engine: postgres, mysql, etc.) | [modules/l1/rds/README.md](https://github.com/acdl/acdl/blob/main/modules/l1/rds/README.md) |
 
 ## Modules
 
 | Module | What it references | Source |
 |--------|--------------------|--------|
-| `static-asset` | 1 primitive (s3) — a static-asset S3 bucket | [modules/l2/static-asset/README.md](https://github.com/acdl/acdl/blob/main/modules/l2/static-asset/README.md) |
+| `static-assets` | 3 primitives (s3, cloudfront, waf) — a production static asset stack | [modules/l2/static-assets/README.md](https://github.com/acdl/acdl/blob/main/modules/l2/static-assets/README.md) |
 | `microservice` | 6 primitives (vpc, cluster, ecr, iam-role, alb, ecs-service) — an ECS Fargate microservice | [modules/l2/microservice/README.md](https://github.com/acdl/acdl/blob/main/modules/l2/microservice/README.md) |
 
 ## Registry
@@ -37,6 +40,14 @@ Module versions are tracked in
 [`registry.json`](https://github.com/acdl/acdl/blob/main/modules/registry.json).
 Both primitives and modules are registered.
 
+## Examples
+
+Each module has a `examples/` directory containing validated consumer
+contract examples (`simple.yaml` + `complex.yaml` + variation files). The
+platform-test pipeline validates them against
+[`schemas/contract.schema.json`](https://github.com/acdl/acdl/blob/main/schemas/contract.schema.json).
+See each module's `## Examples` section for the excerpts.
+
 ## Versioning
 
 Primitives and modules use semver: interface → MAJOR, behavior → MINOR,

docs/pipeline/index.md

@@ -39,7 +39,7 @@ It is exposed to consumer repos as a **reusable workflow**:
 - `.github/workflows/deploy.yml` — GitHub Actions (production)
 
 A consumer repo invokes the reusable workflow via a **versioned tag**
-(floating MAJOR + MINOR, e.g. `acdl/.github/workflows/deploy.yml@v1.4`).
+(floating MAJOR + MINOR, e.g. `acdl/.github/workflows/deploy.yml@v1.6`).
 The workflow checks out the consumer repo, then checks out the ACDL platform
 repo into the runner workspace, and runs `scripts/run_platform.sh` against
 the consumer's contract. The consumer never clones the platform repo or
@@ -67,7 +67,7 @@ flowchart TD
    wires the contract inputs, emits a stack JSON instance).
 3. **security checks** (adapter) — security checks run on the resolved
    stack before any infrastructure is planned.
-4. **infrastructure plan** (adapter) — the substrate adapter compiles the
+4. **infrastructure plan** (adapter) — the engine adapter compiles the
    stack to an infrastructure plan.
 5. **policy checks** (adapter) — policy checks run on the plan. Results are
    normalized to `PolicyCheckResult` records (severity, rule ID, pass/fail).

docs/pipeline/versioning.md

@@ -24,7 +24,7 @@ The central deploy pipeline is referenced by a **floating MAJOR + MINOR
 tag** in a consumer's contract and CI definition:
 
 ```yaml
-uses: acdl/pipelines/deploy.yaml@v1.4
+uses: acdl/pipelines/deploy.yaml@v1.6
 ```
 
 Version constraints cannot be expressed inside the contract, so the tag in

docs/presentations/README.md

@@ -0,0 +1,328 @@
+# Presentations
+
+Leadership-facing presentation decks for the ACDL platform.
+
+## The 4-step slide creation process
+
+Every presentation in this folder is produced by the same four-step process.
+**Never edit the Marp deck, the PPTX, or the talking points directly** —
+always start from the full markdown source of truth (Step 1), synthesize the
+Marp deck (Step 2), export to HTML + PPTX (Step 3), then distill the talking
+points (Step 4). This keeps a reviewable, plain-text source of truth for
+every deck and a presenter-ready cue sheet for delivery.
+
+```
+Step 1: full markdown       Step 2: Marp deck           Step 3: HTML + PPTX         Step 4: Talking points
+(source of truth)    ──►    (lean, 10 slides)    ──►    (rendered)           ──►    (presenter cues)
+*.md                        *-marp.md                   *.html / *.pptx             *-talking-points.md
++ speaker notes             + embedded PNG diagrams                                 + 3-6 bullets per slide
++ mermaid code blocks       + Marp frontmatter                                     + key takeaway per slide
+                            + maturity badges                                      + indexed by Marp slide #
+                            + no speaker notes                                     + content distilled from Step 1
+```
+
+### Step 1 — Full markdown (source of truth)
+
+**File convention:** `<deck-name>.md` (e.g. `how-the-platform-works.md`).
+
+Write the complete deck as a standard markdown file. This is the **source of
+truth** — it contains:
+
+- Every slide as an `## Slide N — Title` H2 section.
+- Tight bullets with leadership-relevant content.
+- A `> **Speaker notes:**` block at the end of each slide with the nuance,
+  the "who cares and why," and the honesty caveats.
+- Mermaid diagrams as ```` ```mermaid ```` fenced code blocks (these render
+  on GitHub/Pages but not in Marp — Step 2 converts them to images).
+- An honest "shipped vs. planned" framing: every "available today" claim is
+  grounded in shipped/verified work; every "planned" item is explicitly
+  marked.
+
+**Why this file is the source of truth:** it is reviewable in any markdown
+viewer, diffs cleanly in git, and carries the full reasoning (speaker notes)
+that a presenter needs. The Marp deck and PPTX are *derived artifacts* — if a
+fact is wrong, fix it here and re-run Steps 2 and 3.
+
+### Step 2 — Marp deck synthesis
+
+**File convention:** `<deck-name>-marp.md` (e.g. `how-the-platform-works-marp.md`).
+
+Synthesize the full markdown into a lean Marp deck:
+
+- **Marp frontmatter** at the top: `marp: true`, `theme: default`,
+  `paginate: true`, `size: 16x9`, a header/footer, and an inline `style:`
+  block for fonts, colors, tables, badges.
+- **No speaker notes.** The Marp deck is what the audience sees; the
+  speaker notes live only in the Step 1 source of truth.
+- **Mermaid diagrams → PNG images.** Marp does not render mermaid fenced
+  blocks natively. Extract each mermaid block from Step 1 into a `.mmd`
+  source file under `assets/mmd/`, render it to PNG under `assets/png/`,
+  and embed it with `![w:1000](assets/png/<name>.png)`.
+- **`<!-- _class: title -->` + `<!-- _paginate: false -->`** on title and
+  closing slides for the dark-background title style.
+- **Maturity badges** using inline spans:
+  `<span class="badge testing">Testing</span>`
+  `<span class="badge planned">Planned</span>`
+  `<span class="badge agentic">Agentic</span>`
+- **Tighter prose** than Step 1 — strip the speaker-note nuance; keep the
+  leadership-relevant selling points.
+
+### Step 3 — Render to HTML and PPTX
+
+Both formats are derived from the Marp deck. **HTML is committed to the repo**
+(viewable in any browser, self-contained with base64-embedded images). **PPTX
+is uploaded to the Gitea release** as a downloadable attachment (binary, not
+committed to git).
+
+#### HTML export (committed to repo)
+
+```bash
+CHROME_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+  npx --yes @marp-team/marp-cli@latest --allow-local-files \
+  docs/presentations/<deck-name>-marp.md \
+  -o docs/presentations/<deck-name>.html
+```
+
+HTML export inlines images as base64 data URIs — no `--allow-local-files`
+needed for self-contained output, but it's required when the Marp deck
+references local PNG assets. The resulting HTML is a single self-contained
+file that renders the full deck with the S&P Global Energy theme.
+
+**Re-render the HTML whenever the Marp source changes.** The HTML files are
+committed artifacts, not generated on-the-fly — they must be re-rendered and
+re-committed when the Marp deck is updated.
+
+#### PPTX export (uploaded to Gitea release)
+
+```bash
+CHROME_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+  npx --yes @marp-team/marp-cli@latest --allow-local-files \
+  docs/presentations/<deck-name>-marp.md \
+  -o <output-path>.pptx
+```
+
+The `--allow-local-files` flag is **required** for PPTX export so the local
+PNG diagrams are embedded in the file. PPTX files are not committed to the
+repo (binary, no meaningful diffs) — they are uploaded to the Gitea release
+as downloadable attachments.
+
+### Step 4 — Talking points (presenter cues)
+
+**File convention:** `<deck-name>-talking-points.md` (e.g.
+`how-the-platform-works-talking-points.md`).
+
+Distill the source of truth (Step 1) into presenter-ready cues, indexed by
+the Marp deck (Step 2) slide structure:
+
+- **One section per Marp slide** — `## Slide N — Title`, matching the Marp
+  deck's 10 main + 6 appendix slide structure exactly. The Marp deck
+  provides the indexing and context (what the audience sees); the source
+  markdown provides the content (the speaker notes, the detail, the nuance).
+- **3-6 talking point bullets per slide** — punchy, actionable cues distilled
+  from the source markdown's speaker notes. NOT the speaker notes verbatim
+  (those are too long and too contextual). These are prompts: "Land this
+  point," "Contrast with X," "Be honest about Y."
+- **Key takeaway per slide** — the one memorable thing the audience should
+  walk away with from that slide.
+- **No content duplication** — the talking points reference the Marp slides
+  for visual context and the source markdown for full detail. They don't
+  repeat either; they bridge them.
+
+**Why this file exists:** a presenter needs a cue sheet they can glance at
+during delivery — not the full speaker notes (too long), not the Marp slides
+(no detail). The talking points file is the middle layer: what to say, in
+what order, with what emphasis, per slide.
+
+**When to update:** re-distill the talking points whenever the Marp deck
+structure changes (slides added, removed, merged, or re-ordered) or whenever
+the source markdown's speaker notes are updated. The talking points are a
+*derived artifact* — if a fact is wrong, fix it in the source markdown (Step 1)
+and re-distill.
+
+## Directory layout
+
+```
+docs/presentations/
+├── README.md                                  ← this file
+├── how-the-platform-works.md                  ← Step 1: full source of truth
+├── how-the-platform-works-marp.md              ← Step 2: Marp deck (10 main + 6 appendix)
+├── how-the-platform-works.html                  ← Step 3: rendered HTML (committed)
+├── how-the-platform-works-talking-points.md    ← Step 4: presenter cues (16 sections)
+├── the-developer-experience.md                 ← Step 1: full source of truth
+├── the-developer-experience-marp.md            ← Step 2: Marp deck (10 main + 6 appendix)
+├── the-developer-experience.html               ← Step 3: rendered HTML (committed)
+├── the-developer-experience-talking-points.md  ← Step 4: presenter cues (16 sections)
+└── assets/
+    ├── puppeteer-config.json                   ← no-sandbox config for mmdc
+    ├── mmd/                                     ← mermaid source files (Step 2 input)
+    │   ├── platform-works-01-contract-driven.mmd
+    │   ├── platform-works-02-end-to-end-flow.mmd
+    │   ├── platform-works-03-scope-boundary.mmd
+    │   ├── platform-works-04-confidence-signal.mmd
+    │   ├── platform-works-05-attestation-flow.mmd
+    │   ├── developer-experience-01b-scope-boundary.mmd
+    │   ├── developer-experience-02-what-dev-does.mmd
+    │   ├── developer-experience-03-no-cloning.mmd
+    │   ├── developer-experience-04-promotion-journey.mmd
+    │   └── road-to-north-star.mmd
+    └── png/                                     ← rendered PNGs (embedded in Marp)
+        ├── platform-works-01-contract-driven.png
+        ├── platform-works-02-end-to-end-flow.png
+        ├── platform-works-03-scope-boundary.png
+        ├── platform-works-04-confidence-signal.png
+        ├── platform-works-05-attestation-flow.png
+        ├── developer-experience-01b-scope-boundary.png
+        ├── developer-experience-02-what-dev-does.png
+        ├── developer-experience-03-no-cloning.png
+        ├── developer-experience-04-promotion-journey.png
+        └── road-to-north-star.png
+```
+
+## Conventions
+
+### Appendix structure
+
+Each Marp deck has **10 main slides + 6 appendix slides** (16 total). The
+main 10 are the presentation; the appendix is for deep dives and Q&A backup.
+
+- **Main slides** (1-10): the story arc, high-impact, minimal text,
+  visual-heavy. These are what the audience sees during the talk.
+- **Appendix slides** (A1-A5 + TOC): detail-heavy slides moved out of the
+  main 10 to preserve the narrative flow. The appendix starts with a TOC
+  slide listing the contents, followed by detail slides and a glossary.
+- **The Road to the North Star** is a required appendix slide in both decks
+  — a phased timeline from v1.0 demo to the North Star, annotated as
+  "proposed phasing, not formally planned."
+- **The Glossary** is a required appendix slide in both decks — defines
+  acronyms (OIDC, ABAC, CMK, CMDB, RPO, HITL, VCS, NFR) for the audience.
+
+### Maturity framing
+
+Every capability claim in a deck is tagged with one of three badges:
+
+| Badge | Meaning |
+|---|---|
+| `Testing` | Works internally, not yet released to consumers (0 adoption) |
+| `Planned` | On the roadmap, not yet implemented |
+| `Agentic` | Involves AI agents, autonomous decision-making, or the citizen developer flow |
+
+This is non-negotiable for a leadership audience: never present a roadmap
+item as a current capability, and never bury a tested capability's
+availability. When in doubt, check `.ciagent/ROADMAP.md` and the milestone
+status in `.ciagent/PROJECT.md`.
+
+### Audience
+
+The audience for these decks is **Senior Leadership**: CTO, Head of Cloud,
+Head of Infrastructure, Head of DevOps. The framing rules:
+
+- **No jargon.** Translate internal terms: "primitives/modules" not "L1/L2",
+  "intent" not "IR", "human attestation" not "HITL", "pattern" not
+  "composition."
+- **Selling points forward.** Each slide leads with the leadership-relevant
+  outcome; the mechanism follows.
+- **Zero-trust, security, observability, auditability, DX, citizen
+  developer** are the themes — not implementation details.
+
+### Diagrams
+
+Mermaid diagrams in the Step 1 source use the repo's existing `flowchart`
+style (renders on GitHub/Pages). For the Marp deck (Step 2):
+
+1. Extract the mermaid block into `assets/mmd/<deck>-<slide>-<name>.mmd`.
+2. Use **horizontal layouts** (`flowchart LR`) or **subgraph row-wrapping**
+   for wide diagrams so the PNG fits a 16:9 slide without shrinking to
+   illegibility. A 9-node sequential `flowchart TD` renders as a tall thin
+   strip — restructure it as 2-row subgraphs or `flowchart LR`.
+3. Render with a 2x scale factor and transparent background for crisp slides.
+4. Embed with `![w:1000](assets/png/<name>.png)` (or `h:320` for tall images).
+
+## Build commands
+
+### Prerequisites
+
+- Node.js + npx (for `@marp-team/marp-cli` and `@mermaid-js/mermaid-cli`)
+- A Chrome/Chromium binary (Marp PPTX export requires it)
+
+This environment has a working Chromium at:
+`/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome`
+
+### Render all mermaid diagrams to PNG
+
+```bash
+cd docs/presentations/assets
+for f in mmd/*.mmd; do
+  name=$(basename "$f" .mmd)
+  PUPPETEER_EXECUTABLE_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+    npx --yes @mermaid-js/mermaid-cli@latest \
+    -i "$f" -o "png/$name.png" \
+    -p puppeteer-config.json -s 2 -b transparent
+done
+```
+
+The `puppeteer-config.json` passes `--no-sandbox` to the headless browser
+(required when running as root in this environment).
+
+### Export a Marp deck to HTML (committed to repo)
+
+```bash
+CHROME_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+  npx --yes @marp-team/marp-cli@latest --allow-local-files \
+  docs/presentations/<deck-name>-marp.md \
+  -o docs/presentations/<deck-name>.html
+```
+
+HTML export inlines images as base64 data URIs. The `--allow-local-files`
+flag is needed when the Marp deck references local PNG assets (like the
+diagram images in `assets/png/`). The resulting HTML is self-contained.
+
+**The HTML files are committed artifacts** — re-render and re-commit whenever
+the Marp source changes.
+
+### Export a Marp deck to PPTX (uploaded to Gitea release)
+
+```bash
+CHROME_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+  npx --yes @marp-team/marp-cli@latest --allow-local-files \
+  docs/presentations/<deck-name>-marp.md \
+  -o <output-path>.pptx
+```
+
+`--allow-local-files` is **required** for PPTX so local PNG diagrams are
+embedded in the file. PPTX files are not committed to git — upload them as
+attachments to the Gitea release.
+
+## Adding a new presentation
+
+1. **Write the full markdown** as `<deck-name>.md` following the
+   `## Slide N — Title` + `> **Speaker notes:**` structure. This is the
+   source of truth.
+2. **Extract any mermaid diagrams** into `assets/mmd/<deck-name>-<slide>-<name>.mmd`
+   and render them to `assets/png/` (command above).
+3. **Synthesize the Marp deck** as `<deck-name>-marp.md` with frontmatter,
+   no speaker notes, embedded PNGs, and maturity badges.
+4. **Render to HTML** with `--allow-local-files` and commit the HTML to
+   `docs/presentations/<deck-name>.html`.
+5. **Render to PPTX** with `--allow-local-files` and upload to the Gitea
+   release (do not commit PPTX to git).
+6. **Distill the talking points** as `<deck-name>-talking-points.md` — one
+   section per Marp slide, 3-6 talking point bullets + key takeaway, content
+   distilled from the source markdown (Step 1), indexed by the Marp deck
+   (Step 2) slide structure.
+7. **Verify** the PPTX slide count and that media files are embedded:
+   ```bash
+   python3 -c "
+   import zipfile, re
+   with zipfile.ZipFile('<output>.pptx') as z:
+       slides = [n for n in z.namelist() if re.match(r'ppt/slides/slide\d+\.xml$', n)]
+       media = [n for n in z.namelist() if n.startswith('ppt/media/')]
+       print(f'{len(slides)} slides, {len(media)} media files')
+   "
+   ```
+
+## Current decks
+
+| Deck | Source of truth (Step 1) | Marp deck (Step 2) | Rendered HTML (Step 3) | Talking points (Step 4) | Slides | Audience |
+|---|---|---|---|---|---|---|
+| How the Platform Works | `how-the-platform-works.md` | `how-the-platform-works-marp.md` | `how-the-platform-works.html` | `how-the-platform-works-talking-points.md` | 10 main + 6 appendix | CTO, Head of Cloud, Head of Infra, Head of DevOps |
+| The Developer Experience | `the-developer-experience.md` | `the-developer-experience-marp.md` | `the-developer-experience.html` | `the-developer-experience-talking-points.md` | 10 main + 6 appendix | CTO, Head of Cloud, Head of Infra, Head of DevOps |

docs/presentations/assets/mmd/developer-experience-01b-scope-boundary.mmd

@@ -0,0 +1,21 @@
+flowchart LR
+    subgraph UP ["Upstream — anything"]
+        direction TB
+        A["Technical dev\n(app code + contract)"]
+        B["Citizen dev\n(intent → AI agent\n→ contract)"]
+    end
+    subgraph ACDL ["ACDL — infrastructure only"]
+        C["Same contract\nSame pipeline\nSame safety"]
+        D["Provision\nAWS resources"]
+        E["Evidence\nhash-chained"]
+    end
+    subgraph DOWN ["Downstream"]
+        F["AWS resources\nrunning"]
+        G["Consumer pipeline\ndeploys image"]
+    end
+    A --> C
+    B --> C
+    C --> D
+    C --> E
+    D --> F
+    F --> G

docs/presentations/assets/mmd/developer-experience-02-what-dev-does.mmd

@@ -0,0 +1,5 @@
+flowchart LR
+    A["1. App code<br/>(top level of the repo)"] --> D["Push to main"]
+    B["2. Contract<br/>(.acdl/contract.yaml)"] --> D
+    C["3. CI definition<br/>(.github/workflows/deploy.yml<br/>— one 'uses:' line)"] --> D
+    D --> E["Platform does the rest"]

docs/presentations/assets/mmd/developer-experience-03-no-cloning.mmd

@@ -0,0 +1,6 @@
+flowchart LR
+    A["Consumer repo<br/>app + contract + 'uses:'"] -->|triggers on push to main| B["Platform runner"]
+    B -->|checks out the consumer repo| A
+    B -->|checks out the ACDL platform repo<br/>into the workspace| C["Platform code<br/>(modules, adapters, schemas)"]
+    C --> B
+    B -->|runs the pipeline against<br/>the consumer's contract| D["Consumer's resources in AWS"]

docs/presentations/assets/mmd/developer-experience-04-promotion-journey.mmd

@@ -0,0 +1,8 @@
+flowchart LR
+    A["dev\n≥ 0.50\nautonomous"] -->|promotion| B["qa\n≥ 0.75\nQA attests"]
+    B -->|promotion| C["prod\n≥ 0.90\nSRE attests"]
+    C -->|promotion| D["dr\n≥ 0.95\nSRE + DR drill"]
+    A -.->|"Testing\n(pilot-ready)"| A
+    B -.->|"Planned"| B
+    C -.->|"Planned"| C
+    D -.->|"Planned"| D

docs/presentations/assets/mmd/platform-works-01-contract-driven.mmd

@@ -0,0 +1,3 @@
+flowchart LR
+    A["Consumer<br/>writes a contract"] --> B["Platform resolves,<br/>compiles, checks,<br/>deploys, records"]
+    B --> C["Resources running in AWS<br/>+ tamper-evident evidence"]

docs/presentations/assets/mmd/platform-works-02-end-to-end-flow.mmd

@@ -0,0 +1,10 @@
+flowchart TD
+    subgraph R1 [" "]
+        direction LR
+        A["Consumer<br/>contract"] --> B["Validate<br/>contract"] --> C["Resolve to<br/>target stack"] --> D["Security<br/>checks"] --> E["Infrastructure<br/>plan"]
+    end
+    subgraph R2 [" "]
+        direction LR
+        F["Policy<br/>checks"] --> G["Confidence<br/>signal"] --> H["Evidence<br/>event"] --> I["Infrastructure<br/>apply"]
+    end
+    E --> F

docs/presentations/assets/mmd/platform-works-03-scope-boundary.mmd

@@ -0,0 +1,25 @@
+flowchart LR
+    subgraph UP ["Upstream — anything"]
+        direction TB
+        A["IDE / IDE + AI\n(dev writes contract)"]
+        B["Agentic SDLC\n(agent writes contract)"]
+        C["Citizen dev\n(vibe codes → AI agent\n→ contract)"]
+    end
+    subgraph ACDL ["ACDL — infrastructure only"]
+        D["Contract\nvalidated"]
+        E["Resolve → Plan\nSecurity + Policy checks\nConfidence signal"]
+        F["Provision\nAWS resources"]
+        G["Evidence\nhash-chained"]
+    end
+    subgraph DOWN ["Downstream"]
+        H["AWS resources\nrunning"]
+        I["Consumer pipeline\ndeploys image"]
+    end
+    A --> D
+    B --> D
+    C --> D
+    D --> E
+    E --> F
+    E --> G
+    F --> H
+    H --> I

docs/presentations/assets/mmd/platform-works-04-confidence-signal.mmd

@@ -0,0 +1,15 @@
+flowchart LR
+    subgraph IN ["6 weighted inputs"]
+        direction TB
+        A["Policy\nconformance"]
+        B["Validation"]
+        C["Freshness"]
+        D["Source\nprovenance"]
+        E["History"]
+        F["NFRs"]
+    end
+    IN --> G["Weighted sum\n→ Confidence score"]
+    G --> H{"Threshold\ngate"}
+    H -->|Meets threshold| I["Proceed"]
+    H -->|Below threshold| J["Halt +\nexplainable reason"]
+    H -->|Critical finding| J

docs/presentations/assets/mmd/platform-works-05-attestation-flow.mmd

@@ -0,0 +1,13 @@
+flowchart LR
+    A["Deployment arrives\nat env gate"] --> B["Confidence signal\ncomputed"]
+    B --> C{"Meets\nthreshold?"}
+    C -->|No / Critical| D["Halt —\nexplainable reason"]
+    C -->|Yes| E{"Human attestation\nrequired?"}
+    E -->|No — dev| F["Autonomous\nproceed"]
+    E -->|Yes — qa/prod/dr| G["Approver reviews:\ncontract + plan + evidence"]
+    G --> H{"Approver\ndecides"}
+    H -->|Approve| I["Attestation recorded\n(identity + state)"]
+    H -->|Reject| J["Halt — rejection\nextends audit chain"]
+    I --> K["Deployment\nproceeds"]
+    F --> K
+    K --> L["Evidence written\nRPO=0"]

docs/presentations/assets/mmd/road-to-north-star.mmd

@@ -0,0 +1,11 @@
+flowchart LR
+    A["v1.0\nDEMO\ncomplete"] --> B["v1.1–v1.8\nPLATFORM BUILD\ncomplete"]
+    B --> C["v1.9\nPRESENTATIONS + PATCHES\ncomplete"]
+    C --> D["v1.10\nNEXT\nHITL wiring\nall-runner OIDC\nregulatory ledger"]
+    D --> E["v2.0\nFUTURE\ncompliance milestone\nself-service\ndynamic modules\nengine adapters"]
+    E --> F["North Star\nREALIZED\nfull autonomy (lower)\nattested (higher)\ncitizen dev live\nevidence regulatory-grade"]
+    A -.->|"stub-driven proof"| A
+    B -.->|"IR + OIDC + ABAC +\nmodule catalog +\nencryption + decommission"| B
+    C -.->|"10-slide decks +\ntalking points +\nS&P theme"| C
+    D -.->|"proposed phasing\nnot formally planned"| D
+    E -.->|"proposed phasing\nnot formally planned"| E

docs/presentations/assets/puppeteer-config.json

@@ -0,0 +1 @@
+{ "args": ["--no-sandbox", "--disable-setuid-sandbox"] }

docs/presentations/how-the-platform-works-marp.md

@@ -0,0 +1,335 @@
+---
+marp: true
+theme: default
+paginate: true
+size: 16x9
+header: "How The Platform Works"
+footer: "Internal"
+style: |
+  section {
+    font-family: "Akkurat Pro", "Helvetica Neue", "Arial", sans-serif;
+    font-size: 22px;
+    color: #1B1B1B;
+  }
+  h1 { color: #D6002A; font-size: 34px; margin-bottom: 0.3em; }
+  h2 { color: #D6002A; font-size: 26px; margin-bottom: 0.2em; }
+  section.title { background: #1B1B1B; color: #fff; border-top: 8px solid #D6002A; }
+  section.title h1 { color: #fff; }
+  table { font-size: 18px; width: 100%; }
+  th { background: #F0F0F0; }
+  blockquote { border-left: 4px solid #D6002A; color: #2E2E2E; font-size: 20px; }
+  img { display: block; margin: 0 auto; max-height: 300px; }
+  em.story { color: #6B7280; font-size: 16px; font-style: italic; }
+  .badge {
+    display: inline-block; padding: 2px 8px; border-radius: 4px;
+    font-size: 14px; font-weight: 600;
+  }
+  .testing { background: #DBEAFE; color: #1E3A5F; }
+  .planned { background: #fef3c7; color: #78350f; }
+  .agentic { background: #EDE9FE; color: #4C1D95; }
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# How The Platform Works
+
+### Agentic Cloud Delivery Platform
+
+<style>
+section.title h1 { font-size: 44px; margin-bottom: 0.1em; }
+section.title h3 { color: #F0F0F0; font-weight: 400; font-size: 22px; margin-top: 0; }
+</style>
+
+---
+
+# The Problem & The North Star
+
+<em class="story">Story beat: Here's the problem we're solving and where we're going.</em>
+
+Four frictions slow every team:
+
+- **Cognitive load** — authoring infrastructure correctly; the long tail of services inconsistent in security and observability
+- **Operational work** — promoting a change from "merged" to "running in production." Manual work that **scales with the system, not the change**
+- **Red tape** — tickets, approvals, and handoffs that scale with the organization. A merged change waits in a queue
+- **Scalability without increasing headcount** — throughput scales without linearly scaling platform engineers
+
+> Consumers **declare intent**; the platform delivers **safe production deployment** — automatically, safely, with a complete audit trail.
+
+- A merged change progresses **without a platform engineer joining a thread or approving a ticket**
+- A **non-technical consumer** ships by declaring intent — no workflow, no config file, no infrastructure module
+- Every production change is **traceable to a human attestation and an immutable evidence stream**
+
+---
+
+# Where ACDL Sits in Your World
+
+<em class="story">Story beat: Now that we know the problem, here's where ACDL fits — and where it doesn't.</em>
+
+![w:1100](assets/png/platform-works-03-scope-boundary.png)
+
+- **Upstream is anything** — your IDE, an agentic SDLC, or a citizen developer vibe coding on a laptop. ACDL doesn't care how the contract was produced.
+- **ACDL is infrastructure only** — it provisions and governs AWS resources. It does not build, test, or deploy your application code. That's upstream.
+- **Not a general-purpose AI** — autonomy is narrow, scoped to delivery, bounded by strict policy
+- **Not a permissive delivery highway** — no escape hatches to bypass the confidence framework
+
+---
+
+# The Contract-Driven Model
+
+<em class="story">Story beat: The contract is the boundary between upstream and ACDL. It's all a consumer writes.</em>
+
+A single YAML contract — **module, environment, inputs**. The platform owns everything else.
+
+![w:850](assets/png/platform-works-01-contract-driven.png)
+
+- **Which module** — a catalog of pre-built, security-reviewed building blocks
+- **Which environment** — the platform raises the safety bar automatically as sensitivity rises
+- **Which inputs** — infrastructure values that vary per deployment (cpu, memory, port, desired_count)
+- The consumer provides **no AWS account, no VPC, no state backend** — the platform owns the blast radius
+
+---
+
+# The End-to-End Flow
+
+<em class="story">Story beat: Once the contract is written, here's what the platform does with it — every time.</em>
+
+Every deployment runs the same stages, in the same order, with the same checks — no team-specific pipelines, no tribal runbooks.
+
+![w:1100](assets/png/platform-works-02-end-to-end-flow.png)
+
+- **Security and policy checks run *before* any infrastructure is created**
+- **Every stage produces a record** that feeds the confidence signal and the evidence stream — there is no "unchecked" path
+
+---
+
+# Zero-Trust by Default
+
+<em class="story">Story beat: Before any infrastructure is created, here's how access is scoped.</em>
+
+Consumer repositories hold **no long-lived cloud credentials.** Ever.
+
+- **Authentication — OIDC federation.** Each job mints a short-lived token; no credential is stored in the consumer repo or in a runner secret. <span class="badge testing">Testing (GitHub Actions)</span> <span class="badge planned">Planned: all runners</span>
+- **Authorization — attribute-based (ABAC), not role-based.** Two attribute classes scope every action:
+  - **Repository identity** — the role's trust policy binds to the exact consumer repo + branch
+  - **Resource tags** — every resource is tagged `acdl:owner` + `acdl:contract`; the session policy grants access **only to matching tags**
+
+**The effect:** a consumer can only touch the resources it created. Blast radius is contained. One consumer can never affect another.
+
+---
+
+# Safety is Computed, Not Assumed
+
+<em class="story">Story beat: Now let's look at how the platform decides whether a deployment is safe.</em>
+
+Every delivery action produces a **measurable, explainable confidence signal** — a weighted sum of observable facts, not a black box. <span class="badge agentic">Agentic</span>
+
+![w:1100](assets/png/platform-works-04-confidence-signal.png)
+
+- **Six weighted inputs** — manually tuned, auditable. If a consumer asks "why 0.62?", the platform answers with a per-input breakdown
+- **Per-environment thresholds** that rise with sensitivity:
+
+| Environment | Threshold | Attester |
+|---|---|---|
+| dev | ≥ 0.50 | No one — autonomous <span class="badge testing">Testing</span> |
+| qa | ≥ 0.75 | QA <span class="badge planned">Planned</span> |
+| prod | ≥ 0.90 | SRE <span class="badge planned">Planned</span> |
+
+- **A single critical finding hard-blocks** — critical findings are not averaged away
+
+---
+
+# Security by Construction
+
+<em class="story">Story beat: Beyond the confidence signal, security defaults are on by construction — not by opt-in.</em>
+
+Security defaults that **do not require a team to opt in.** Checks run on **every** deployment, normalized to a single schema. <span class="badge testing">Testing</span>
+
+- **Policy checks** (Checkov, Wiz, Kyverno) — secrets in plaintext, public ingress, IAM wildcards, **required tagging standards** — all run *before* infra is created
+- **Encryption on every resource** — at-rest encryption on by default; per-stack customer-managed keys with 90-day rotation, **no shared keys across stacks**
+- **Deletion protection on by default** — `prevent_destroy` on unless explicitly disabled via a documented flag
+- **Safe decommission** — a 2-step pipeline with **two SRE attestation gates** and a **change-request validated against the CMDB**
+
+---
+
+# Accountability & Audit
+
+<em class="story">Story beat: Computed safety handles the gate. But humans still matter — here's how accountability works.</em>
+
+![w:1100](assets/png/platform-works-05-attestation-flow.png)
+
+- **Dev is fully autonomous.** The confidence signal (≥ 0.50) is the only gate. <span class="badge testing">Testing</span> <span class="badge agentic">Agentic</span>
+- **qa, prod, dr require human attestation** — the approver reviews the contract, the planned Terraform changes, and the accumulated evidence <span class="badge planned">Planned</span>
+- **QA attests to infrastructure readiness, not application code** — the contract, the plan, and the evidence. Application code review is upstream
+- **Separation of duties** — the QA approver **cannot** be the prod approver. The platform **blocks on a match.** <span class="badge planned">Planned</span>
+- **Every deployment writes a hash-chained evidence event** — tampering breaks the chain. **RPO = 0** <span class="badge testing">Testing</span>
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# Testing vs. Planned
+
+<em class="story">Story beat: Let's be honest about what works today and what's on the roadmap.</em>
+
+<style>
+section { font-size: 20px; }
+</style>
+
+**11 capabilities testing today** (dev pilot-ready):
+
+- Contract-driven deploys · Module catalog · Zero-trust OIDC + ABAC
+- Security + policy checks before infra creation · Confidence signal gating
+- Hash-chained evidence outbox (RPO = 0) · Encryption by default + per-stack CMKs
+- Deletion protection + safe decommission · Uptime monitoring
+- Platform-managed environments · Engine-agnostic core + VCS-agnostic ingestion
+
+**9 planned** (production path):
+
+- HITL wiring for qa/prod/dr · All-runner OIDC · Full regulatory ledger
+- Compliance milestone (GDPR, SOX, SOC2, DORA) · Environment self-service
+- Dynamic module creation <span class="badge agentic">Agentic</span> · Pattern recognition <span class="badge agentic">Agentic</span>
+- Additional engine adapters · Deeper observability bootstrap
+
+*Full inventory + phased roadmap in the appendix.*
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# The Vision Realized
+
+<em class="story">Story beat: Here's what success looks like when the North Star is reached.</em>
+
+- **Velocity without sacrificing safety.** Speed is in the ergonomics (a simple contract, a one-line `uses:`); safety is in the gates the consumer cannot bypass.
+- **Security, observability, and compliance as platform defaults** — not per-team effort, not post-hoc remediation.
+- **Auditability as a byproduct, not a project.** Every production change is traceable to a human attestation and a tamper-evident evidence event.
+- **Blast radius contained by design.** Zero-trust OIDC + ABAC means a consumer can only touch its own tagged resources.
+- **Infrastructure as a utility, not a craft.** Teams consume infrastructure, they don't maintain it.
+- **A path to the citizen developer.** The same safety envelope that serves a senior engineer will serve a non-technical consumer. <span class="badge agentic">Agentic</span>
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# Appendix
+
+<em class="story">For deep dives — these slides cover details omitted from the main 10.</em>
+
+**Contents:**
+
+1. Platform-Managed Environments (detail)
+2. Observability Built In (detail)
+3. The Road to the North Star (phased roadmap)
+4. Testing vs. Planned (full inventory)
+5. Glossary
+
+---
+
+# A1 — Platform-Managed Environments
+
+A consumer provides **no AWS account, no VPC, no subnet, no state backend, no runner key.** The platform owns the blast radius.
+
+A named environment is a platform-owned bundle of:
+
+- An AWS account (or a scoped partition of one)
+- A network (VPC + subnets)
+- A state backend (S3 + DynamoDB for state + locking)
+- An IAM role surfaced via ABAC, scoped to the consumer's identity and resource tags
+
+The consumer selects an environment **by name** in their contract. The platform resolves the name to the underlying resources at run time. **The consumer never sees raw credentials.**
+
+**Friendly onboarding:** the first run detects no environment and emits a guided prompt (not an opaque failure). <span class="badge testing">Testing</span> <span class="badge planned">Self-service: planned</span>
+
+---
+
+# A2 — Observability Built In
+
+Monitoring is **a platform default, not a per-team project.** <span class="badge testing">Testing</span>
+
+- **Uptime monitoring deployed automatically with every stack** — a dedicated monitoring instance is provisioned after any module deploy, in a separate state, with a feature flag to disable
+- **Monitored endpoints passed from the deployment's own outputs** — no manual endpoint registration
+- **Alert channels:** Microsoft Teams webhook, email, SMS, and GitHub issues
+- **The uptime URL is published to the developer** via a PR comment — they don't hunt for it
+- **Roadmap:** deeper observability bootstrap (dashboards, runbooks, on-call bindings) as first-class contract fields <span class="badge planned">Planned</span>
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# A3 — The Road to the North Star
+
+*Proposed phasing — not formally planned.*
+
+![w:1100](assets/png/road-to-north-star.png)
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# A4 — Testing vs. Planned (Full Inventory)
+
+<style>
+section { font-size: 15px; }
+td { font-size: 14px; vertical-align: top; }
+ul { margin: 0; padding-left: 1.2em; }
+li { margin-bottom: 2px; }
+</style>
+
+<table style="width: 100%; border: none;">
+<tr>
+<td style="width: 52%; border: none; padding-right: 12px;">
+
+**Testing** (works internally, dev pilot-ready)
+
+- Contract-driven deploys with a versioned reusable workflow
+- Module catalog (primitives + modules) with validated examples
+- Zero-trust OIDC + ABAC on GitHub Actions runners
+- Security + policy checks before infra creation (Checkov; Wiz + Kyverno ready)
+- Confidence signal (6 inputs, per-env thresholds) gating promotion <span class="badge agentic">Agentic</span>
+- Hash-chained, tamper-evident evidence outbox (RPO = 0)
+- Encryption by default + per-stack customer-managed keys
+- Deletion protection by default + safe decommission with SRE gates
+- Uptime monitoring deployed automatically with every stack
+- Platform-managed environments + friendly onboarding
+- Engine-agnostic core (1 adapter: Terraform) + VCS-agnostic ingestion
+
+</td>
+<td style="width: 48%; border: none; padding-left: 12px;">
+
+**Planned** (on the roadmap)
+
+- Real OIDC federation on all platform runners
+- HITL wiring for qa / prod / dr environments
+- Full regulatory ledger: S3 Object Lock + JWS signatures + daily checkpoints
+- Compliance milestone: GDPR, SOX, SOC2, DORA extension points
+- Environment self-service provisioning
+- Dynamic module creation from a contract (agentic citizen-developer flow) <span class="badge agentic">Agentic</span>
+- Pattern recognition compounds value over time <span class="badge agentic">Agentic</span>
+- Additional engine adapters (OpenTofu, Pulumi, Kubernetes CRDs)
+- Deeper observability bootstrap (dashboards, runbooks, on-call)
+
+</td>
+</tr>
+</table>
+
+---
+
+# A5 — Glossary
+
+| Term | Meaning |
+|---|---|
+| **OIDC** | OpenID Connect — federation protocol for short-lived tokens, no long-lived credentials |
+| **ABAC** | Attribute-Based Access Control — access scoped by resource tags + repo identity, not roles |
+| **CMK** | Customer-Managed Key — per-stack encryption key, 90-day rotation, no shared keys |
+| **CMDB** | Configuration Management Database — validates change requests for decommission |
+| **RPO** | Recovery Point Objective — RPO = 0 means evidence is written synchronously, no data loss |
+| **HITL** | Human-in-the-Loop — deliberate human attestation required for qa/prod/dr environments |
+| **VCS** | Version Control System — the git hosting platform (GitHub, Gitea, GitLab) |
+| **NFR** | Non-Functional Requirement — encryption, tagging, observability standards |
+| **IR** | Intermediate Representation — the engine-agnostic stack definition between contract and Terraform |

docs/presentations/how-the-platform-works-talking-points.md

@@ -0,0 +1,213 @@
+# How The Platform Works — Talking Points
+
+> **Companion to:** `how-the-platform-works-marp.md` (10 main + 6 appendix = 16 slides)
+> **Content source:** `how-the-platform-works.md` (full source of truth with speaker notes)
+> **Purpose:** Presenter-ready cues — 3-6 talking points per slide + the one key takeaway the audience should remember.
+> **Audience:** Senior Leadership — CTO, Head of Cloud, Head of Infrastructure, Head of DevOps
+
+---
+
+## Slide 1 — Title
+
+**Talking points:**
+- Brief introduction — this deck explains *how* the platform works internally, not what the developer experience is (that's the companion deck)
+- Set the frame: the platform is not a CI/CD tool — it's the organizational lever for shipping safely at the pace the business demands
+- The deck has 10 main slides plus a 6-slide appendix for deep-dive questions
+
+**Key takeaway:** This is a platform that computes safety, doesn't assume it.
+
+---
+
+## Slide 2 — The Problem & The North Star
+
+**Talking points:**
+- Open with the cost of the status quo — every team running its own pipeline, its own Terraform, its own review checklist is paying a tax that doesn't differentiate the business
+- Walk through the 4 frictions quickly: cognitive load, operational work, red tape, scalability. Don't dwell — the North Star is the resolution
+- Land the North Star quote: "declare intent → safe production deployment" — this is the entire value proposition in one sentence
+- The litmus test: if a platform engineer still has to touch a ticket for a dev→qa promotion, we haven't delivered the vision
+- Note: the 2 anti-goals ("not a general-purpose AI" and "not a permissive delivery highway") have moved to slide 3 — they belong with the scope boundary, not the North Star
+
+**Key takeaway:** The platform absorbs all four frictions. Declare intent, not execute operations.
+
+---
+
+## Slide 3 — Where ACDL Sits in Your World
+
+**Talking points:**
+- This is the new scope-boundary slide — it tells leadership where ACDL fits and, just as importantly, where it doesn't
+- Upstream is anything — your IDE, an agentic SDLC, or a citizen developer vibe coding on a laptop. ACDL doesn't care how the contract was produced
+- ACDL is infrastructure only — it provisions and governs AWS resources. It does not build, test, or deploy your application code. That's upstream
+- Land the 2 anti-goals: "not a general-purpose AI" (autonomy is narrow, scoped to delivery, bounded by strict policy) and "not a permissive delivery highway" (no escape hatches to bypass the confidence framework)
+- The sovereign boundary means the platform team owns delivery and infrastructure, not the upstream development process
+
+**Key takeaway:** ACDL is the delivery and infrastructure boundary. Upstream is anything; ACDL is infra only.
+
+---
+
+## Slide 4 — The Contract-Driven Model
+
+**Talking points:**
+- Emphasize the asymmetry — the consumer's surface is intentionally tiny (module + environment + inputs), the platform's surface is large and opinionated
+- Note: the contract examples now show **infrastructure inputs** (cpu, memory, desired_count, port) — not a container image. The image is upstream; the platform governs infrastructure
+- The contract is the API — it's deliberately small so it can be reviewed, validated, and audited
+- The consumer does not write infrastructure modules, workflow logic, or adapter code — they declare intent; the platform reconciles, provisions, and progresses
+- Land the "no AWS account, no VPC, no state backend" point — the platform owns the blast radius. Consumers can't drift into misconfigured state or over-permissioned roles because they never touch them
+
+**Key takeaway:** A single YAML contract. The platform owns everything else — including the blast radius.
+
+---
+
+## Slide 5 — The End-to-End Flow
+
+**Talking points:**
+- Walk the flow left to right once — don't dwell on internals. The point is that the flow is fixed, opinionated, and identical for every consumer
+- Land beat 1: security and policy checks run *before* any infrastructure is created — not after the fact, not as a post-deployment audit
+- Land beat 2: every stage produces a record that feeds the confidence signal and the evidence stream. There is no "unchecked" path
+- Tease the confidence signal (slide 7) — this is where "safety is computed" lands
+
+**Key takeaway:** The same pipeline, every time. Checks before creation, evidence at every stage.
+
+---
+
+## Slide 6 — Zero-Trust by Default
+
+**Talking points:**
+- This is the slide for the Head of Cloud/Security — the key phrase is "blast radius contained to the consumer's own stack"
+- Contrast with the common failure mode: shared CI roles that can touch any account resource. The platform's ABAC model scopes every action to the consumer's own tagged resources
+- OIDC means no long-lived credentials in consumer repos — each job mints a short-lived token. Be honest: this is testing on GitHub Actions runners today; all-runner coverage is planned
+- The static-key override exists for edge cases but is rotated daily on platform runners — it is never the default
+
+**Key takeaway:** A consumer can only touch the resources it created. One consumer can never affect another.
+
+---
+
+## Slide 7 — Safety is Computed, Not Assumed
+
+**Talking points:**
+- This is the bet that separates this platform from "yet another CI/CD tool" — reliance on operator instinct or tenure is not a substitute for a computed, auditable signal
+- The new confidence signal diagram makes the six inputs and the per-input breakdown visible — walk it briefly so the audience sees the signal is *not* a black box
+- The weights are **manually tuned**, the inputs are **observable**, and the breakdown is **auditable** — if a consumer asks "why 0.62?", the platform answers with a per-input breakdown. This is the "auditable, not magic" point
+- Walk the threshold table: dev ≥ 0.50 (autonomous, Testing) → qa ≥ 0.75 (QA, Planned) → prod ≥ 0.90 (SRE, Planned). The bar rises automatically with sensitivity
+- A single critical policy finding hard-blocks the deployment — critical findings are not averaged away. This is non-negotiable
+- The thresholds are tunable by Infra & Ops + SRE jointly, and any override is itself a confidence-event in the audit stream
+
+**Key takeaway:** Safety is a measurable, explainable signal — manually tuned, observable inputs, auditable breakdown. A single critical finding blocks everything.
+
+---
+
+## Slide 8 — Security by Construction
+
+**Talking points:**
+- The phrase to land is "secure by default, not secure by effort" — teams don't opt in to security, it's on by construction
+- Policy checks (Checkov, Wiz, Kyverno) are normalized to a single schema — we can add a new security tool without changing the confidence model or the evidence stream
+- Tagging standards are enforced, not advisory — a missing `acdl:owner` tag fails the check, it doesn't warn
+- Encryption is on every resource with per-stack customer-managed keys — no shared keys across stacks, 90-day rotation
+- The decommission flow is the counter-argument to "deletion protection makes cleanup impossible" — it's a deliberate, gated, two-SRE-approval path with CMDB validation, not a lock with no key
+
+**Key takeaway:** Encryption, deletion protection, policy checks — on by default. Decommission is gated, not impossible.
+
+---
+
+## Slide 9 — Accountability & Audit
+
+**Talking points:**
+- The "lower environments autonomous, higher environments attested" tenet is the resolution to the classic "move fast vs. be safe" false dichotomy
+- The new attestation flow diagram shows the human-in-the-loop path — dev autonomous → qa/prod/dr human attestation → evidence event. Walk it briefly
+- Land the QA clarification: **QA attests to infrastructure readiness — the contract, the planned Terraform changes, and the accumulated evidence. QA does not review application code (that's upstream).** This is the scope-boundary point reiterated
+- Badge reclassification to be clear about: separation of duties = **Planned** (not "design tested"); dev autonomous = **Testing**; qa/prod/dr attestation = **Planned**
+- The audit trail is a byproduct of deployment, not a project — every deployment writes a hash-chained evidence event synchronously (RPO = 0)
+- Be honest about the ledger: the outbox + hash chain is testing today; the full regulatory ledger (S3 Object Lock, JWS signatures, daily checkpoints) is planned
+
+**Key takeaway:** Dev is autonomous. Higher environments are attested. QA attests to infra readiness, not app code. Every change is evidenced.
+
+---
+
+## Slide 10 — The Vision Realized
+
+**Talking points:**
+- Close on the strategic frame — the platform is not "a CI/CD tool," it's the organizational lever for shipping safely at the pace the business demands
+- Velocity without sacrificing safety: speed is in the ergonomics (a simple contract, a one-line `uses:`), safety is in the gates the consumer cannot bypass
+- Security, observability, and compliance as platform defaults — not per-team effort, not post-hoc remediation
+- Auditability as a byproduct, not a project — every production change traceable to a human attestation and a tamper-evident evidence event
+- Infrastructure as a utility, not a craft — teams consume, they don't maintain. The platform compounds value over time by learning from recurring patterns
+- The path to the citizen developer — the same safety envelope that serves a senior engineer will serve a non-technical consumer. Expanding who can ship safely without lowering the bar
+
+**Key takeaway:** The investment is in the abstraction, not the tool. Ship safely at the pace the business demands, with the security and audit posture the regulators require.
+
+---
+
+## Appendix TOC — Deep Dives
+
+**Talking points:**
+- These slides are for follow-up questions — don't walk them in the main 15-minute talk
+- Pull them up when an audience member wants detail on a specific topic: environments, observability, roadmap, full inventory, or glossary terms
+- The appendix exists so the main deck stays tight while still having answers ready
+
+**Key takeaway:** The appendix is the backup — detail on demand, not on the critical path.
+
+---
+
+## A1 — Platform-Managed Environments
+
+**Talking points:**
+- A consumer provides no AWS account, no VPC, no subnet, no state backend, no runner key — the platform owns the entire blast radius
+- A named environment is a platform-owned bundle: an AWS account (or scoped partition), a network, a state backend, and an IAM role surfaced via ABAC
+- The consumer selects an environment by name (`environment: dev`) and the platform resolves it at run time — the consumer never sees raw credentials
+- Friendly onboarding is testing today: the first run detects no environment and emits a guided prompt, not an opaque failure. Self-service provisioning is planned
+- For the Head of Cloud: this is the governance story — the platform team owns accounts, network design, and state hygiene; consumers can't drift because they never touch them
+
+**Key takeaway:** Environments are platform-owned bundles. Consumers pick a name; the platform owns the rest.
+
+---
+
+## A2 — Observability Built In
+
+**Talking points:**
+- Monitoring is a platform default, not a per-team project — you don't deploy a service and *then* remember to set up monitoring
+- Uptime monitoring (Uptime-kuma on ECS Fargate) is provisioned automatically after any module deploy, in a separate state, with a feature flag to disable
+- Monitored endpoints come from the deployment's own outputs — no manual endpoint registration. The platform constructs the synthetic monitoring contract from what was just deployed
+- Alert channels: Microsoft Teams webhook, email, SMS, and GitHub issues — all testing today
+- The uptime URL is published to the developer via a PR comment so they don't hunt for it
+- Roadmap: deeper observability bootstrap (dashboards, runbooks, on-call bindings) as first-class contract fields for prod/dr — planned
+
+**Key takeaway:** Monitoring ships with the deploy, not after it. The feature flag lets teams with existing monitoring opt out cleanly.
+
+---
+
+## A3 — The Road to the North Star
+
+**Talking points:**
+- Be explicit up front: this is **proposed phasing, not formally planned** — the phases are sequenced by dependency, not by calendar
+- Phase 1 — Testing baseline (current): contract-driven deploys, zero-trust OIDC + ABAC, confidence signal, hash-chained evidence, encryption by default, safe decommission, uptime monitoring, platform-managed environments
+- Phase 2 — Production readiness: HITL wiring for qa/prod/dr, all-runner OIDC, full regulatory ledger, environment self-service
+- Phase 3 — Compliance & expansion: compliance milestone (GDPR, SOX, SOC2, DORA), additional engine adapters (OpenTofu, Pulumi, Kubernetes CRDs), deeper observability bootstrap
+- Phase 4 — Agentic frontier: dynamic module creation from a contract (citizen-developer flow), pattern recognition that compounds value over time
+- Each phase's items are gated on the prior phase's maturity — invite questions on any phase boundary
+
+**Key takeaway:** A dependency-sequenced path from testing baseline to agentic frontier — proposed, not formally committed.
+
+---
+
+## A4 — Testing vs. Planned (Full Inventory)
+
+**Talking points:**
+- Close on honesty — the platform delivers real, verifiable value today, and the roadmap is concrete, not aspirational hand-waving
+- Walk the Testing column (11 capabilities) quickly — from contract-driven deploys to encryption by default to uptime monitoring. These work internally and are dev pilot-ready
+- Walk the Planned column (9 capabilities) — be clear about what's not yet done: HITL wiring, full regulatory ledger, compliance milestone, environment self-service, dynamic module creation, additional engine adapters, deeper observability
+- Two agentic items are flagged: dynamic module creation and pattern recognition — both involve AI agents or autonomous decision-making
+- Invite questions on any "planned" item — each has a defined milestone and a clear reason it isn't shipped yet (usually an upstream dependency, not an engineering gap)
+- Emphasize: 0 consumer adoption today — "Testing" means it works internally and is dev pilot-ready, not that it's released
+
+**Key takeaway:** 11 capabilities testing today. 9 planned items on a concrete roadmap. Zero consumer adoption — yet.
+
+---
+
+## A5 — Glossary
+
+**Talking points:**
+- This is a reference slide — don't read it aloud, point to it as a takeaway reference for term definitions
+- The terms most likely to come up in questions: OIDC (short-lived tokens), ABAC (tag-scoped access), CMK (per-stack encryption keys), RPO = 0 (synchronous evidence write)
+- HITL is the human-attestation term for qa/prod/dr; NFR is the non-functional-requirements input to the confidence signal
+- IR (Intermediate Representation) is the engine-agnostic stack definition between the contract and Terraform — the abstraction that makes the platform portable
+
+**Key takeaway:** A shared vocabulary — keep it as a reference for follow-up questions.

docs/presentations/how-the-platform-works.md

@@ -0,0 +1,312 @@
+# How The Platform Works
+
+> **Subtitle:** Agentic Cloud Delivery Platform
+> **Audience:** Senior Leadership, CTO, Head of Cloud, Head of Infrastructure, Head of DevOps
+> **Length:** ~15 minutes · 10 main + 6 appendix = 16 slides
+> **Purpose:** Sell the platform's value to tech leadership — zero-trust, security, observability, auditability, and the shift from "operators guess" to "the platform computes safety."
+> **Maturity framing:** "Testing" = works internally, dev pilot-ready. "Planned" = on the roadmap, not yet implemented. "Agentic" = involves AI agents or autonomous decision-making.
+
+---
+
+## Slide 1 — Title
+
+# How The Platform Works
+
+### Agentic Cloud Delivery Platform
+
+> **Speaker notes:** Brief introduction — this deck explains *how* the platform works internally, not what the developer experience is (that's the companion deck). Set the frame: the platform is not a CI/CD tool — it's the organizational lever for shipping safely at the pace the business demands.
+
+---
+
+## Slide 2 — The Problem & The North Star
+
+Software delivery scales with the **coordination surface around it**, not the engineering inside it. Most teams can write code; far fewer get the infrastructure right.
+
+Four frictions slow every team:
+
+- **Cognitive load** — authoring infrastructure correctly; the long tail of services inconsistent in security and observability.
+- **Operational work** — promoting a change from "merged" to "running in production." Manual work that **scales with the system, not the change.**
+- **Red tape** — tickets, approvals, and handoffs that scale with the organization. A merged change waits in a queue.
+- **Scalability without increasing headcount** — throughput scales without linearly scaling platform engineers.
+
+> Consumers **declare intent**; the platform delivers **safe production deployment** — automatically, safely, with a complete audit trail.
+
+- A merged change progresses **without a platform engineer joining a thread or approving a ticket.**
+- A **non-technical consumer** ships by declaring intent — no workflow, no config file, no infrastructure module.
+- Every production change is **traceable to a human attestation and an immutable evidence stream.**
+
+> **Speaker notes:** Open with the cost of the status quo. Every team that stands up its own pipeline, its own Terraform, its own review checklist is paying a tax that doesn't differentiate the business. The platform absorbs all four frictions — that is the value proposition in one sentence. Land the North Star quote: "declare intent → safe production deployment." The litmus test: if a platform engineer still has to touch a ticket for a dev→qa promotion, we haven't delivered the vision.
+
+---
+
+## Slide 3 — Where ACDL Sits in Your World
+
+Now that we know the problem, here's where ACDL fits — and where it doesn't.
+
+- **Upstream is anything** — your IDE, an agentic SDLC, or a citizen developer vibe coding on a laptop. ACDL doesn't care how the contract was produced.
+- **ACDL is infrastructure only** — it provisions and governs AWS resources. It does not build, test, or deploy your application code. That's upstream.
+- **Not a general-purpose AI** — autonomy is narrow, scoped to delivery, bounded by strict policy envelopes.
+- **Not a permissive delivery highway** — no escape hatches to bypass the confidence framework or human attestation requirements.
+
+> **Speaker notes:** This slide gives leadership the framing they need. The platform is deliberately scoped — it is not trying to be everything. The sovereign boundary means the platform team owns delivery and infrastructure, not the upstream development process. The anti-goals are as important as the goals: they tell leadership what not to expect.
+
+---
+
+## Slide 4 — The Contract-Driven Model
+
+The contract is the boundary between upstream and ACDL. It's all a consumer writes.
+
+A single YAML contract — **module, environment, inputs**. The platform owns everything else.
+
+```mermaid
+flowchart LR
+    A["Consumer<br/>writes a contract"] --> B["Platform resolves,<br/>compiles, checks,<br/>deploys, records"]
+    B --> C["Resources running in AWS<br/>+ tamper-evident evidence"]
+```
+
+The contract names three things:
+
+- **Which module** — a catalog of pre-built, security-reviewed building blocks (a static site, a microservice, a database, and more).
+- **Which environment** — `dev`, `qa`, `prod`, or `dr`. The platform raises the safety bar automatically as the environment gets more sensitive.
+- **Which inputs** — infrastructure values that vary per deployment (cpu, memory, port, desired_count).
+- The consumer provides **no AWS account, no VPC, no state backend** — the platform owns the blast radius.
+
+The consumer does **not** write infrastructure modules, workflow logic, or adapter code. They declare intent; the platform reconciles, provisions, and progresses.
+
+> **Speaker notes:** Emphasize the asymmetry. The consumer's surface is intentionally tiny — a contract that fits on one screen. The platform's surface is large and opinionated. That asymmetry is what makes "declare intent, not execute operations" concrete. Note that the contract examples now show infrastructure inputs (cpu, memory, desired_count, port) — not a container image. The image is upstream; the platform governs infrastructure.
+
+---
+
+## Slide 5 — The End-to-End Flow
+
+Once the contract is written, here's what the platform does with it — every time.
+
+Every deployment runs the same stages, in the same order, with the same checks — no team-specific pipelines, no tribal runbooks.
+
+```mermaid
+flowchart TD
+    A["Consumer contract<br/>(module + environment + inputs)"] --> B["Validate contract<br/>against the schema"]
+    B --> C["Resolve to a target stack<br/>(expand the module's pattern)"]
+    C --> D["Security checks<br/>(before any infra is created)"]
+    D --> E["Infrastructure plan<br/>(platform compiles the stack)"]
+    E --> F["Policy checks<br/>(normalized results)"]
+    F --> G["Confidence signal<br/>(6 inputs → score + band)"]
+    G --> H["Evidence event<br/>(hash-chained, tamper-evident)"]
+    H --> I["Infrastructure apply<br/>(dev only — higher envs hold for attestation)"]
+```
+
+Two properties matter to leadership:
+
+- **Security and policy checks run *before* any infrastructure is created** — not after the fact, not as a post-deployment audit.
+- **Every stage produces a record** that feeds the confidence signal and the evidence stream. There is no "unchecked" path.
+
+> **Speaker notes:** Walk left to right once. Don't dwell on internals — the point is that the flow is fixed, opinionated, and identical for every consumer. The two leadership-relevant beats are (1) checks before creation, (2) every stage is evidenced. The confidence signal (Slide 7) is where the "safety is computed" story lands.
+
+---
+
+## Slide 6 — Zero-Trust by Default
+
+Before any infrastructure is created, here's how access is scoped.
+
+Consumer repositories hold **no long-lived cloud credentials.** Ever.
+
+- **Authentication is OIDC federation** between the platform runners and the cloud provider. Each job mints a short-lived token; no credential is stored in the consumer repo or in a runner secret. *(Testing on GitHub Actions runners; planned for all platform runners.)*
+- **Authorization is attribute-based (ABAC), not role-based.** Two attribute classes scope every action:
+  - **Repository identity** — the role's trust policy binds to the exact consumer repo + branch that invoked the workflow.
+  - **Resource-creation attributes** — every resource is tagged with `acdl:owner=<consumer-repo>` and `acdl:contract=<contract-id>`. The session policy grants view/update/delete **only on resources whose tags match the calling repo.**
+
+**The effect:** a consumer's pipeline can only touch the resources it created. Blast radius is contained to that consumer's own stack instances. One consumer can never touch another's resources, and the consumer cannot escape its own scope.
+
+> **Speaker notes:** This is the slide for the Head of Cloud/Security. The key phrase is "blast radius contained to the consumer's own stack." Contrast with the common failure mode of shared CI roles that can touch any account resource. The static-key override exists for edge cases but is rotated daily on platform runners; it is never the default.
+
+---
+
+## Slide 7 — Safety is Computed, Not Assumed
+
+Now let's look at how the platform decides whether a deployment is safe.
+
+Every delivery action produces a **measurable, explainable confidence signal** — a weighted sum of observable facts, not a black box. *(Agentic.)*
+
+- **Six weighted inputs** — policy conformance, validation, freshness, source provenance, history, and non-functional requirements (NFRs). The weights are **manually tuned**, the inputs are **observable**, and the breakdown is **auditable** — if a consumer asks "why 0.62?", the platform answers with a per-input breakdown.
+- **Per-environment thresholds** that rise with sensitivity:
+
+| Environment | Threshold | Who must attest |
+|---|---|---|
+| dev | ≥ 0.50 | No one — fully autonomous *(Testing)* |
+| qa | ≥ 0.75 | QA *(Planned)* |
+| prod | ≥ 0.90 | SRE *(Planned)* |
+| dr | ≥ 0.95 | SRE + a disaster-recovery drill reference *(Planned)* |
+
+- **A single critical policy finding hard-blocks the deployment**, regardless of every other input. Critical findings are not averaged away.
+- **When the platform halts, it gives a measured reason** — a policy violation, an insufficient signal, a missing attestation — never an opaque, manual-debugging exercise.
+
+> **Speaker notes:** This is the bet that separates this platform from "yet another CI/CD tool." Reliance on operator instinct or tenure is not a substitute. The signal is auditable; the thresholds are tunable by Infra & Ops + SRE jointly, and any override is itself a confidence-event in the audit stream. Leadership cares about this because it makes promotion decisions *reviewable*. The new confidence signal diagram makes the six inputs and the per-input breakdown visible — emphasize that the weights are manually tuned and the breakdown is auditable, not a black box.
+
+---
+
+## Slide 8 — Security by Construction
+
+Beyond the confidence signal, security defaults are on by construction — not by opt-in.
+
+Security defaults that **do not require a team to opt in.** Checks run on **every** deployment, normalized to a single schema regardless of which engine produced them. *(Testing.)*
+
+- **Infrastructure-as-code policy** (Checkov) — secrets in plaintext, public ingress, IAM wildcards, KMS key references, **required tagging standards** (`acdl:owner`, `acdl:contract`, `acdl:environment`, `acdl:cost-center`). All run *before* infra is created.
+- **Cloud security posture** (Wiz adapter) — translates cloud security findings into the same normalized record. *(Adapter testing; activates when a Wiz tenant is configured.)*
+- **Kubernetes-native policy** (Kyverno adapter) — ready for the GitOps reconciler roadmap item. *(Adapter testing; inactive for Terraform-only stacks.)*
+- **Encryption on every resource** — at-rest encryption is on by default for every primitive (S3, RDS, ECR, ECS, and more). *(Testing.)*
+- **Per-stack customer-managed keys (CMKs)** — one key per deployment, 90-day rotation at creation, **no shared keys across stacks.** *(Testing.)*
+- **Managed-key fallback with a loud warning** — standalone primitives fall back to cloud-managed keys only when no CMK is provided, and the platform warns explicitly. *(Testing.)*
+- **Deletion protection on by default** — every resource has `prevent_destroy` on unless a consumer explicitly disables it via a documented feature flag. *(Testing.)*
+- **Safe decommission** — a 2-step pipeline (disable protection → zero counts → destroy) with **two SRE human-attestation gates** and a **change-request validated against the platform CMDB** before any destructive action. *(Testing.)* Encryption keys enter a grace window (default 30 days) so encrypted data remains recoverable during decommission.
+
+> **Speaker notes:** The phrase to land is "secure by default, not secure by effort." The selling point is *normalization* — we can add a new security tool without changing the confidence model or the evidence stream. For the Head of Security: tagging standards are enforced, not advisory — a missing `acdl:owner` tag fails the check, not a warning. The decommission flow is the counter-argument to "deletion protection makes cleanup impossible" — it's a deliberate, gated, two-approval path, not a lock with no key.
+
+---
+
+## Slide 9 — Accountability & Audit
+
+Computed safety handles the gate. But humans still matter — here's how accountability works.
+
+- **Dev is fully autonomous.** The confidence signal (≥ 0.50) is the only gate. Queue-based handoffs are eliminated from lower environments. *(Testing, Agentic.)*
+- **qa, prod, and dr require deliberate human attestation** — not rubber stamps, but policy-mandated acts of accountability via protected deployment approvals. The approver reviews the contract, the planned Terraform changes, and the accumulated evidence. *(Planned.)*
+- **QA attests to infrastructure readiness — the contract, the planned Terraform changes, and the accumulated evidence. QA does not review application code (that's upstream).**
+- **Separation of duties is enforced** *(Planned)* — the person who approved the qa promotion **cannot** be the person who approves the prod promotion. The platform reads both identities from the outbox and **blocks** on a match, emitting a `SEPARATION_OF_DUTIES_VIOLATION` and routing a halt artifact to SRE on-call.
+- **Timeout discipline** — 1 business day = warn + escalate; 2 business days = auto-freeze + re-submit. Rejection extends the audit chain; it does not tear it up.
+
+Version control is a **coordination tool, not an evidentiary fortress.** True compliance requires an immutable, externally-stored ledger.
+
+- **Every deployment writes a hash-chained evidence event** — each event links to the previous via a cryptographic hash. Tampering breaks the chain. *(Testing — the DynamoDB outbox.)*
+- **Tiered storage design:** cold, tamper-proof source of truth (S3 Object Lock, compliance mode, 7-year retention) + a hot query index for fast lookup. *(Outbox tested; S3 Object Lock + JWS detached signatures are planned regulatory-ledger build-out.)*
+- **RPO = 0** — the evidence write is synchronous; a deployment is not acknowledged until the evidence event is durably recorded.
+- **Every production change is traceable to a human attestation** — the QA and prod approver identities are the only durable record outside the VCS's audit log, stored in the outbox keyed by contract.
+
+> **Speaker notes:** The "lower environments autonomous, higher environments attested" tenet is the resolution to the classic "move fast vs. be safe" false dichotomy. Be honest: the separation-of-duties *mechanism* (CODEOWNERS routing, identity-distinctness check, the 8-concern attestation matrix) is designed and the dev path is wired; the qa/prod/dr wiring is on the roadmap. The new attestation flow diagram makes the human-in-the-loop path visible. Note the QA clarification: QA attests to infrastructure readiness — the contract, the plan, and the evidence — not application code. The audit trail is a byproduct of deployment, not a project. Note honestly that the full regulatory ledger (S3 Object Lock, JWS signatures, daily checkpoints) is planned; what ships today is the outbox + hash chain that makes every event tamper-evident and queryable. Badge reclassification: separation of duties = Planned (not "design tested"), dev autonomous = Testing, qa/prod/dr attestation = Planned.
+
+---
+
+## Slide 10 — The Vision Realized
+
+Here's what success looks like when the North Star is reached.
+
+- **Velocity without sacrificing safety.** Speed is in the ergonomics (a simple contract, a one-line `uses:`); safety is in the gates the consumer cannot bypass.
+- **Security, observability, and compliance as platform defaults** — not per-team effort, not post-hoc remediation.
+- **Auditability as a byproduct, not a project.** Every production change is traceable to a human attestation and a tamper-evident evidence event.
+- **Blast radius contained by design.** Zero-trust OIDC + ABAC means a consumer can only touch its own tagged resources.
+- **Infrastructure as a utility, not a craft.** Teams consume infrastructure, they don't maintain it.
+- **A path to the citizen developer.** The same safety envelope that serves a senior engineer will serve a non-technical consumer. *(Agentic.)*
+
+> **Speaker notes:** Close on the strategic frame. The platform is not "a CI/CD tool," it's the organizational lever for shipping safely at the pace the business demands. The investment is in the abstraction, not the tool. Ship safely at the pace the business demands, with the security and audit posture the regulators require.
+
+---
+
+## Appendix — Table of Contents
+
+For deep dives — these slides cover details omitted from the main 10.
+
+**Contents:**
+
+1. Platform-Managed Environments (detail)
+2. Observability Built In (detail)
+3. The Road to the North Star (phased roadmap)
+4. Testing vs. Planned (full inventory)
+5. Glossary
+
+> **Speaker notes:** These are deep-dive slides for follow-up questions. Don't walk them in the main 15-minute talk — pull them up when an audience member wants detail on a specific topic.
+
+---
+
+## A1 — Platform-Managed Environments
+
+A consumer provides **no AWS account, no VPC, no subnet, no state backend, no runner key.** The platform owns the blast radius.
+
+A named environment is a platform-owned bundle of:
+
+- An AWS account (or a scoped partition of one).
+- A network (VPC + subnets).
+- A state backend (S3 + DynamoDB for infrastructure state + locking).
+- An IAM role surfaced to the consumer via ABAC, scoped to the consumer's repository identity and resource tags.
+
+The consumer selects an environment **by name** in their contract (`environment: dev`). The platform resolves the name to the underlying account/network/state/role at run time. **The consumer never sees the raw credentials.**
+
+**Friendly onboarding:** the first run detects no environment and emits a guided prompt (not an opaque failure) telling the consumer what the platform will provision and how to request it. *(Testing.)* **Self-service environment provisioning is planned.**
+
+> **Speaker notes:** For the Head of Cloud: this is the governance story. The platform team owns the accounts, the network design, the state hygiene. Consumers can't drift into misconfigured state backends or over-permissioned roles because they never touch them. The onboarding prompt matters — first impressions of a platform are made when it fails for the first time.
+
+---
+
+## A2 — Observability Built In
+
+Monitoring is **a platform default, not a per-team project.** *(Testing.)*
+
+- **Uptime monitoring deployed automatically with every stack** — a dedicated monitoring instance (Uptime-kuma on ECS Fargate) is provisioned after any module deploy, in a separate state, with a feature flag to disable.
+- **Monitored endpoints passed from the deployment's own outputs** — the platform constructs a synthetic monitoring contract from what was just deployed. No manual endpoint registration.
+- **Alert channels:** Microsoft Teams webhook, email, SMS, and GitHub issues. *(Testing.)*
+- **The uptime URL is published to the developer** via a PR comment — they don't hunt for it.
+- **Roadmap:** deeper observability bootstrap (dashboards, runbooks, on-call bindings) as first-class contract fields for prod/dr. *(Planned.)*
+
+> **Speaker notes:** The Head of DevOps cares about this. The framing: "you don't deploy a service and *then* remember to set up monitoring — the platform does it as part of the deploy." The feature flag means teams with existing monitoring (e.g. Datadog) can opt out cleanly.
+
+---
+
+## A3 — The Road to the North Star
+
+*Proposed phasing — not formally planned.*
+
+A phased roadmap from the current Testing baseline to the full North Star:
+
+- **Phase 1 — Testing baseline (current):** contract-driven deploys, zero-trust OIDC + ABAC on GitHub Actions, confidence signal gating, hash-chained evidence, encryption by default, deletion protection + safe decommission, uptime monitoring, platform-managed environments.
+- **Phase 2 — Production readiness:** HITL wiring for qa/prod/dr, all-runner OIDC, full regulatory ledger (S3 Object Lock + JWS signatures + daily checkpoints), environment self-service.
+- **Phase 3 — Compliance & expansion:** compliance milestone (GDPR, SOX, SOC2, DORA extension points), additional engine adapters (OpenTofu, Pulumi, Kubernetes CRDs), deeper observability bootstrap.
+- **Phase 4 — Agentic frontier:** dynamic module creation from a contract (the agentic citizen-developer composition mechanism), pattern recognition that compounds value over time.
+
+> **Speaker notes:** Be clear with leadership: this is a proposed phasing, not a formally committed plan. The phases are sequenced by dependency, not by calendar — each phase's items are gated on the prior phase's maturity. Invite questions on any phase boundary.
+
+---
+
+## A4 — Testing vs. Planned (Full Inventory)
+
+**Testing** (works internally, dev pilot-ready) — 11 capabilities:
+
+- Contract-driven deploys with a versioned reusable workflow.
+- Module catalog (primitives + modules) with validated examples.
+- Zero-trust OIDC + ABAC on GitHub Actions runners.
+- Security + policy checks before infra creation (Checkov; Wiz + Kyverno adapters ready).
+- Confidence signal (6 inputs, per-env thresholds) gating promotion. *(Agentic.)*
+- Hash-chained, tamper-evident evidence outbox (RPO = 0).
+- Encryption by default + per-stack customer-managed keys.
+- Deletion protection by default + safe decommission with SRE gates + CMDB validation.
+- Uptime monitoring deployed automatically with every stack.
+- Platform-managed environments + friendly onboarding.
+- Engine-agnostic core (1 adapter: Terraform) + VCS-agnostic ingestion (GitHub + Gitea).
+
+**Planned** (on the roadmap, not yet implemented) — 9 capabilities:
+
+- Real OIDC federation on all platform runners (Gitea Actions OIDC pending an upstream merge).
+- HITL wiring for qa / prod / dr environments (design shipped; wiring is next).
+- Full regulatory ledger: S3 Object Lock (7-yr compliance mode) + JWS detached signatures + daily checkpoints.
+- Compliance milestone: per-module extension points for GDPR, SOX, SOC2, DORA.
+- Environment self-service (a consumer-facing flow to request and provision a new environment).
+- Dynamic module creation from a contract (the agentic "citizen developer" composition mechanism). *(Agentic.)*
+- Pattern recognition compounds value over time. *(Agentic.)*
+- Additional engine adapters (OpenTofu, Pulumi, Kubernetes CRDs).
+- Deeper observability bootstrap (dashboards, runbooks, on-call bindings).
+
+> **Speaker notes:** Close on honesty. The platform delivers real, verifiable value today — 11 capabilities that work internally. The roadmap is concrete, not aspirational hand-waving — 9 planned items, each with a defined milestone and a clear reason it isn't shipped yet (usually an upstream dependency, not an engineering gap). Emphasize: 0 consumer adoption today — "Testing" means it works internally and is dev pilot-ready, not that it's released.
+
+---
+
+## A5 — Glossary
+
+| Term | Meaning |
+|---|---|
+| **OIDC** | OpenID Connect — federation protocol for short-lived tokens, no long-lived credentials |
+| **ABAC** | Attribute-Based Access Control — access scoped by resource tags + repo identity, not roles |
+| **CMK** | Customer-Managed Key — per-stack encryption key, 90-day rotation, no shared keys |
+| **CMDB** | Configuration Management Database — validates change requests for decommission |
+| **RPO** | Recovery Point Objective — RPO = 0 means evidence is written synchronously, no data loss |
+| **HITL** | Human-in-the-Loop — deliberate human attestation required for qa/prod/dr environments |
+| **VCS** | Version Control System — the git hosting platform (GitHub, Gitea, GitLab) |
+| **NFR** | Non-Functional Requirement — encryption, tagging, observability standards |
+| **IR** | Intermediate Representation — the engine-agnostic stack definition between contract and Terraform |
+
+> **Speaker notes:** Use this slide as a reference when the audience asks for term definitions. Don't read it aloud — point to it as a takeaway reference.

docs/presentations/the-developer-experience-marp.md

@@ -0,0 +1,325 @@
+---
+marp: true
+theme: default
+paginate: true
+size: 16x9
+header: "The Developer Experience"
+footer: "Internal"
+style: |
+  section {
+    font-family: "Akkurat Pro", "Helvetica Neue", "Arial", sans-serif;
+    font-size: 22px;
+    color: #1B1B1B;
+  }
+  h1 { color: #D6002A; font-size: 34px; margin-bottom: 0.3em; }
+  h2 { color: #D6002A; font-size: 26px; margin-bottom: 0.2em; }
+  section.title { background: #1B1B1B; color: #fff; border-top: 8px solid #D6002A; }
+  section.title h1 { color: #fff; }
+  table { font-size: 18px; width: 100%; }
+  th { background: #F0F0F0; }
+  blockquote { border-left: 4px solid #D6002A; color: #2E2E2E; font-size: 20px; }
+  pre { font-size: 14px; line-height: 1.3; }
+  code { font-size: 14px; }
+  img { display: block; margin: 0 auto; max-height: 280px; }
+  em.story { color: #6B7280; font-size: 16px; font-style: italic; }
+  .badge {
+    display: inline-block; padding: 2px 8px; border-radius: 4px;
+    font-size: 14px; font-weight: 600;
+  }
+  .testing { background: #DBEAFE; color: #1E3A5F; }
+  .planned { background: #fef3c7; color: #78350f; }
+  .agentic { background: #EDE9FE; color: #4C1D95; }
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# The Developer Experience
+
+### Agentic Cloud Delivery Platform
+
+<style>
+section.title h1 { font-size: 44px; margin-bottom: 0.1em; }
+section.title h3 { color: #F0F0F0; font-weight: 400; font-size: 22px; margin-top: 0; }
+</style>
+
+---
+
+# Where ACDL Sits in Your World
+
+<em class="story">Story beat: Here's who uses the platform and where the boundary is.</em>
+
+![w:1100](assets/png/developer-experience-01b-scope-boundary.png)
+
+- **Technical developer** — owns app code + a contract + a thin CI definition
+- **Citizen developer** — declares intent in plain language; an AI agent produces a contract that passes the **same** safety envelope <span class="badge agentic">Agentic</span>
+- **Upstream is anything** — your IDE, an agentic SDLC, or vibe coding on a laptop. ACDL doesn't care how the contract was produced
+- **ACDL is infrastructure only** — it provisions and governs AWS resources. Application deployment is upstream
+
+---
+
+# The Contract — The Entire Consumer Surface
+
+<em class="story">Story beat: Now let's look at what a consumer actually writes — it's tiny.</em>
+
+Three things. That is the entire consumer-side surface.
+
+<img src="assets/png/developer-experience-02-what-dev-does.png" style="float: right; width: 38%; margin-left: 20px; margin-bottom: 10px;" />
+
+- **1. App code** — the consumer's service, at the top level of the repo
+- **2. A contract** — a single YAML file: module, environment, inputs
+
+```yaml
+uses: acdl/pipelines/deploy.yaml@v1.6
+module: microservice
+environment: dev
+inputs:
+  cpu: 256
+  memory: 512
+  desired_count: 2
+  port: 8080
+```
+
+- **3. A one-line CI definition** — a thin `uses:` wrapper pointing at a versioned platform workflow
+- The developer does **not**: write infrastructure modules, clone the platform repo, hold cloud credentials, or maintain a state backend
+
+---
+
+# The Developer Feedback Loop
+
+<em class="story">Story beat: Once you push, here's what you see — in real time, in your own logs.</em>
+
+Developers see **what the platform is doing**, in real time. <span class="badge testing">Testing</span>
+
+- **Streamed output by default** — the infrastructure plan, policy-check results, and each check record flow to stdout
+- **PR comments after every successful pipeline stage** — a developer always knows where they stand without refreshing a dashboard
+- **Clear, explainable halt reasons** — a policy violation, an insufficient confidence signal, or a missing attestation. **Never an opaque debugging exercise.**
+- **Connection strings posted as PR comments** — human-readable, no hunting
+- **Runtime secrets in encrypted Parameter Store** — KMS-encrypted, namespaced, **no raw secrets in logs**
+- **Errors become GitHub issues, automatically** — a failed deploy opens an issue on the platform repo
+
+---
+
+# Versioned, Predictable Releases
+
+<em class="story">Story beat: You control when you absorb platform improvements — no surprise upgrades.</em>
+
+Consumers control **when** they absorb platform improvements. <span class="badge testing">Testing</span>
+
+- **Floating MAJOR + MINOR tags** (e.g. `@v1.6`) — a consumer automatically receives patch updates within the line
+- **Semantic versioning with a clear contract:** interface → MAJOR, behavior → MINOR, lifecycle → PATCH
+- **A consumer can pin to an exact version** for maximum stability, or float on MAJOR only (`@v1`) to absorb new features on their own cadence
+- **Unversioned references (`@main`, bare) are discouraged** — the versioned tag is the only immutability lever
+- **Automated release job** computes the next semver on merge to main, creates the tag, and updates the floating tags
+
+---
+
+# Friendly Onboarding
+
+<em class="story">Story beat: First impressions matter — the platform fails gracefully, not opaquely.</em>
+
+First impressions of a platform are made **when it fails for the first time.** The platform fails gracefully. <span class="badge testing">Testing</span>
+
+When no environment is bound, the platform emits a **user-friendly onboarding prompt** instead of failing opaquely:
+
+1. That no environment is bound to their repo yet
+2. What the platform will provision on their behalf (account, network, state, role)
+3. The expected turnaround for the platform team to grant the environment
+4. How to request an environment
+
+The pipeline then **exits without attempting a deployment** — no partial state, no confusing errors.
+
+<span class="badge planned">Citizen developer onboarding path: planned</span>
+
+---
+
+# Safe Promotion Path
+
+<em class="story">Story beat: Promotion is a workflow choice, not a contract edit — and the bar rises automatically.</em>
+
+The contract is environment-agnostic. The platform raises the bar automatically.
+
+![w:1000](assets/png/developer-experience-04-promotion-journey.png)
+
+<table style="width: 100%; border: none;">
+<tr>
+<td style="width: 50%; vertical-align: top; border: none; padding-right: 12px;">
+
+**Approach A — One contract, one job per environment.** Environment passed by each job.
+
+```yaml
+jobs:
+  dev:
+    uses: acdl/.github/workflows/deploy.yml@v1.6
+    with: { contract: .acdl/contract.yaml, environment: dev }
+  qa:
+    needs: dev
+    uses: acdl/.github/workflows/deploy.yml@v1.6
+    with: { contract: .acdl/contract.yaml, environment: qa }
+```
+
+</td>
+<td style="width: 50%; vertical-align: top; border: none; padding-left: 12px;">
+
+**Approach B — Environment-specific contracts.** When inputs differ per environment.
+
+```yaml
+jobs:
+  dev:
+    uses: acdl/.github/workflows/deploy.yml@v1.6
+    with: { contract: .acdl/contract-dev.yaml }
+  qa:
+    needs: dev
+    uses: acdl/.github/workflows/deploy.yml@v1.6
+    with: { contract: .acdl/contract-qa.yaml }
+```
+
+</td>
+</tr>
+</table>
+
+<style>
+section { font-size: 16px; }
+pre { font-size: 10px; line-height: 1.2; }
+code { font-size: 10px; }
+td { font-size: 14px; }
+</style>
+
+---
+
+# Safe Decommission
+
+<em class="story">Story beat: Tearing down is as deliberate as deploying — and just as gated.</em>
+
+Tearing down a stack is **as deliberate as deploying one.** <span class="badge testing">Testing</span>
+
+```yaml
+uses: acdl/.github/workflows/deploy.yml@v1.8
+with:
+  contract: .acdl/contract.yaml
+  mode: decommission
+  changeRequestId: "CHG0678912"
+```
+
+A 2-step pipeline with **two SRE human-attestation gates**:
+
+1. **Validate the change request** — the platform queries the CMDB; the CR must be `approved` and match the consumer repo
+2. **Disable deletion protection** → **SRE approves** → **Zero all counts + destroy** → **a second SRE approves**
+
+The per-stack encryption key enters a **grace window** (default 30 days) so encrypted data remains recoverable.
+
+---
+
+# Self-Service Module Catalog
+
+<em class="story">Story beat: You don't author infrastructure — you pick from pre-built, security-reviewed building blocks.</em>
+
+Developers pick from **pre-built, security-reviewed building blocks.** <span class="badge testing">Testing</span>
+
+- **Primitives** — single-purpose resources (S3, VPC, ECS, IAM, load balancer, container registry, CloudFront, WAF, RDS), each with documented inputs/outputs, usage, compliance extension points, and versioning
+- **Modules** — composed patterns (a static site with CDN + WAF; a microservice with VPC + ECS + load balancer + registry)
+- **Validated examples per module** — `simple.yaml` + `complex.yaml` + variation files, validated against the contract schema in CI. Examples cannot drift from the schema silently
+- **Auto-promotion of patterns** — auto-promoted to the catalog after 3 observed usages <span class="badge planned">Planned</span> <span class="badge agentic">Agentic</span>
+- **Compliance extension points** — each module lists where GDPR, SOX, SOC2, DORA controls will wire in <span class="badge planned">Planned</span>
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# The Desired Outcomes
+
+<em class="story">Story beat: Here's what this delivers to the organization.</em>
+
+- **Velocity without sacrificing safety.** Speed is in the ergonomics (a simple contract, a one-line `uses:`); safety is in the gates the consumer cannot bypass.
+- **Security, observability, and compliance as platform defaults** — not per-team effort, not post-hoc remediation.
+- **Auditability as a byproduct, not a project.** Every production change is traceable to a human attestation and a tamper-evident evidence event.
+- **Blast radius contained by design.** Zero-trust OIDC + ABAC means a consumer can only touch its own tagged resources.
+- **The bottleneck moves off the platform team's ticket queue.** A merged change progresses through lower environments without a platform engineer joining a thread.
+- **Infrastructure as a utility, not a craft.** Teams consume infrastructure, they don't maintain it — and the platform compounds value over time by learning from recurring patterns.
+- **A path to the citizen developer.** The same safety envelope that serves a senior engineer will serve a non-technical consumer. <span class="badge agentic">Agentic</span>
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# Appendix
+
+<em class="story">For deep dives — these slides cover details omitted from the main 10.</em>
+
+**Contents:**
+
+1. The Citizen Developer Experience (full)
+2. No Platform Code, No Cloning (detail)
+3. Local Reproducibility (detail)
+4. The Road to the North Star (phased roadmap)
+5. Glossary
+
+---
+
+# A1 — The Citizen Developer Experience
+
+A non-technical consumer ships a production deployment **by declaring intent** — without authoring a workflow, a configuration file, or an infrastructure module.
+
+- The consumer opens an issue describing what they need (e.g. "a web API for the pricing service")
+- An AI agent maps the intent to a contract referencing a module from the **reviewed skill catalog**
+- The contract enters the **same pipeline** and must clear the **same confidence gate** before promotion
+
+**Guardrails that make this safe:**
+
+- Skills are **versioned, signed, and reviewed for sensitive data before release** (Infra & Ops owns the review)
+- Agents are **stateless** — all state lives in the platform; the platform trusts and **always verifies**
+- The agent's trace and submission confidence are captured in the contract for review
+
+<span class="badge planned">Skill catalog + real agent runtime: planned</span> <span class="badge agentic">Agentic</span>
+
+---
+
+# A2 — No Platform Code, No Cloning
+
+Consumers `uses:` a **versioned** central workflow. The platform fetches itself at run time. The consumer **never touches platform internals.**
+
+![w:1000](assets/png/developer-experience-03-no-cloning.png)
+
+- The consumer's CI definition is a thin wrapper — one `uses:` line
+- The runner checks out the consumer repo, then checks out the platform repo into the workspace
+- The platform installs its own runtime dependencies — the consumer installs nothing
+- When the platform ships a fix, every consumer on a floating tag gets it on their next run
+
+---
+
+# A3 — Local Reproducibility
+
+The entire CI pipeline runs **from the shell**, not just in CI. <span class="badge testing">Testing</span>
+
+- `scripts/run_ci.sh` mirrors the CI pipeline locally — the same three stages (lint → test → check-only) in sequence
+- `scripts/run_platform.sh --check-only` runs the platform **offline** — no AWS, no policy engine, no outbox required. Validates a contract end-to-end before pushing
+- `--plan-only` runs through the infrastructure plan without applying
+- The CI and deploy pipelines are defined by **declarative contracts** (YAML instances validated against JSON Schemas) — a single source of truth that both workflows implement
+
+---
+
+<!-- _class: title -->
+<!-- _paginate: false -->
+
+# A4 — The Road to the North Star
+
+*Proposed phasing — not formally planned.*
+
+![w:1100](assets/png/road-to-north-star.png)
+
+---
+
+# A5 — Glossary
+
+| Term | Meaning |
+|---|---|
+| **OIDC** | OpenID Connect — federation protocol for short-lived tokens, no long-lived credentials |
+| **ABAC** | Attribute-Based Access Control — access scoped by resource tags + repo identity, not roles |
+| **CMK** | Customer-Managed Key — per-stack encryption key, 90-day rotation, no shared keys |
+| **CMDB** | Configuration Management Database — validates change requests for decommission |
+| **RPO** | Recovery Point Objective — RPO = 0 means evidence is written synchronously, no data loss |
+| **HITL** | Human-in-the-Loop — deliberate human attestation required for qa/prod/dr environments |
+| **VCS** | Version Control System — the git hosting platform (GitHub, Gitea, GitLab) |
+| **NFR** | Non-Functional Requirement — encryption, tagging, observability standards |

docs/presentations/the-developer-experience-talking-points.md

@@ -0,0 +1,215 @@
+# The Developer Experience — Talking Points
+
+> **Companion to:** `the-developer-experience-marp.md` (10 main + 6 appendix = 16 slides)
+> **Content source:** `the-developer-experience.md` (full source of truth with speaker notes)
+> **Purpose:** Presenter-ready cues — 3-6 talking points per slide + the one key takeaway the audience should remember.
+> **Audience:** Senior Leadership — CTO, Head of Cloud, Head of Infrastructure, Head of DevOps
+
+---
+
+## Slide 1 — Title
+
+**Talking points:**
+- Brief introduction — this deck covers *who uses the platform and how fast/safe they ship*, not the internal mechanics (that's the companion deck)
+- Set the frame: velocity without sacrificing safety, and security/observability/compliance as platform defaults rather than per-team effort
+
+**Key takeaway:** The consumer surface is intentionally tiny. The platform's surface is large and opinionated.
+
+---
+
+## Slide 2 — Where ACDL Sits in Your World
+
+**Talking points:**
+- This is the scope-boundary slide — here's who uses the platform, and here's where ACDL's responsibility starts and stops
+- Two consumer paths converge on the same contract: **technical** developer writes the contract directly; **citizen** developer declares intent and an AI agent produces a contract that passes the same safety envelope
+- Upstream is anything — your IDE, an agentic SDLC, or vibe coding on a laptop. ACDL doesn't care how the contract was produced
+- ACDL is infrastructure only — it provisions and governs AWS resources. Application deployment is upstream of the contract
+- The two surfaces are *parallel*, not a progression. A citizen developer doesn't "graduate" to the developer surface. There is no "citizen developer mode" with weaker checks
+
+**Key takeaway:** Two consumer paths, one safety envelope. ACDL is infra only — anything upstream is fair game.
+
+---
+
+## Slide 3 — The Contract — The Entire Consumer Surface
+
+**Talking points:**
+- Hold this slide — the audience should sit with how small the consumer surface is. Three things: app code, a contract, a one-line CI definition
+- The contract is a single YAML file: module, environment, inputs. That's the entire consumer-facing interface to production
+- The contract example now shows **infrastructure inputs** (cpu, memory, desired_count, port) — not an `image:` field. The consumer declares capacity and shape; the platform resolves the rest
+- Walk the "does not" list quickly — no infrastructure modules, no platform repo cloning, no cloud credentials, no state backends. Every item is a category of toil the platform removes
+- For the Head of DevOps: this is the lever for throughput — the bottleneck moves off the platform team's ticket queue
+
+**Key takeaway:** Three things. That's the entire consumer-side surface. Everything else is the platform's job.
+
+---
+
+## Slide 4 — The Developer Feedback Loop
+
+**Talking points:**
+- This directly answers "but developers hate platforms that hide what they're doing" — the platform is opinionated about *what* runs, not *opaque* about *that* it runs
+- Streamed output by default — the plan, policy results, and each check record flow to stdout
+- PR comments after every successful pipeline stage — a developer always knows where they stand without refreshing a dashboard
+- Connection strings posted as PR comments — human-readable, no hunting. Runtime secrets go to encrypted Parameter Store (KMS-encrypted, namespaced), never to logs
+- The "errors become GitHub issues" point is a DX win that also helps the platform team — every consumer failure is a tracked, queryable artifact, not a lost log line
+- Clear, explainable halt reasons — a policy violation, an insufficient confidence signal, or a missing attestation. Never an opaque debugging exercise
+
+**Key takeaway:** The platform closes the feedback loop — streamed output, PR comments, clear halt reasons, no secrets in logs.
+
+---
+
+## Slide 5 — Versioned, Predictable Releases
+
+**Talking points:**
+- This is the "no surprise upgrades" story — consumers aren't forced to chase the platform, and the platform isn't forced to support N forks of every workflow
+- Floating MAJOR + MINOR tags (e.g. `@v1.6`) — a consumer automatically receives patch updates within the line. Pin to exact version for stability, or float on MAJOR only for new features
+- Semantic versioning with a clear contract: interface → MAJOR, behavior → MINOR, lifecycle → PATCH
+- Unversioned references (`@main`, bare) are discouraged — the versioned tag is the only immutability lever a consumer has
+- The automated release job computes the next semver on merge to main, creates the tag, and updates the floating tags — no manual release process
+
+**Key takeaway:** Consumers control when they absorb platform improvements. No surprise upgrades.
+
+---
+
+## Slide 6 — Friendly Onboarding
+
+**Talking points:**
+- This looks like a small thing; it's actually a cultural one — the platform's posture is "help me get started," not "you should have known"
+- First impressions of a platform are made when it fails for the first time. The platform fails gracefully with a guided prompt, not an opaque error
+- The prompt tells the consumer: what's missing, what the platform will provision, the expected turnaround, and how to request an environment
+- The pipeline exits without attempting a deployment — no partial state, no confusing errors
+- Be honest: the citizen developer onboarding path is planned, not yet shipped
+
+**Key takeaway:** The platform fails gracefully. First impressions drive adoption — platforms that fail opaquely get routed around.
+
+---
+
+## Slide 7 — Safe Promotion Path
+
+**Talking points:**
+- Promotion is a workflow choice, not a contract mutation — this matters because it means a promotion can be reviewed as a *diff in the workflow*, not as a rewritten contract
+- The new promotion journey diagram shows the rising bar: dev (autonomous) → qa (QA attests) → prod (SRE attests) → dr (SRE attests + DR drill)
+- Approach A (one contract, environment passed by the job) keeps the single source of truth — the contract never changes
+- Approach B (environment-specific contracts) lets teams whose inputs genuinely vary keep that variation explicit and reviewable
+- The rising bar is annotated with maturity: **dev = Testing** (works internally, pilot-ready); **qa/prod/dr = Planned** (on the roadmap). Be honest about that split
+- Separation of duties is enforced — the QA approver cannot be the prod approver. No staging environment — the design deliberately removes the "staging is basically prod but not really" anti-pattern
+
+**Key takeaway:** Change the environment field, not the contract. The platform raises the bar automatically. The consumer can't bypass the gates.
+
+---
+
+## Slide 8 — Safe Decommission
+
+**Talking points:**
+- The counter-argument to "deletion protection makes cleanup impossible" — decommission is a first-class, gated, two-approval flow, not a lock with no key
+- The change request must be `approved` in the CMDB and match the consumer repo — no CR, no decommission
+- Two SRE human-attestation gates: one to disable deletion protection, a second to zero counts and destroy
+- The per-stack encryption key enters a 30-day grace window so encrypted data remains recoverable — the key is permanently deleted only after the window expires
+- For the Head of Infrastructure: the CMDB validation means decommission is auditable, not just possible
+
+**Key takeaway:** Tearing down is as gated as deploying. Two SRE approvals, CMDB-validated change request, 30-day key grace window.
+
+---
+
+## Slide 9 — Self-Service Module Catalog
+
+**Talking points:**
+- The catalog is what makes "declare intent" practical — you can only declare a module that exists
+- Primitives are single-purpose resources (S3, VPC, ECS, IAM, ALB, ECR, CloudFront, WAF, RDS) — each with documented inputs/outputs, usage, compliance extension points, and versioning
+- Modules are composed patterns (a static site with CDN + WAF; a microservice with VPC + ECS + ALB + registry) — one well-reviewed module serves every consumer
+- Validated examples per module — `simple.yaml` + `complex.yaml` + variation files, validated against the contract schema in CI. Examples cannot drift from the schema silently
+- For leadership: the catalog is the leverage — a fix to a module serves every consumer on the next run. This is the compounding asset
+- Auto-promotion of patterns (after 3 observed usages) and compliance extension points (GDPR, SOX, SOC2, DORA) are planned
+
+**Key takeaway:** The catalog is the compounding asset. One well-reviewed module serves every consumer. A fix serves everyone on the next run.
+
+---
+
+## Slide 10 — The Desired Outcomes
+
+**Talking points:**
+- Close on the strategic frame — the platform is not "a CI/CD tool," it's the organizational lever for shipping safely at the pace the business demands
+- Velocity without sacrificing safety: speed is in the ergonomics (a simple contract, a one-line `uses:`), safety is in the gates the consumer cannot bypass
+- Security, observability, and compliance as platform defaults — not per-team effort, not post-hoc remediation. Encryption, deletion protection, uptime monitoring, policy checks, and evidence are on by construction
+- Auditability as a byproduct, not a project — every production change is traceable to a human attestation and a tamper-evident evidence event
+- The bottleneck moves off the platform team's ticket queue — a merged change progresses through lower environments without a platform engineer joining a thread
+- Infrastructure as a utility, not a craft — teams consume, they don't maintain. The platform compounds value over time by learning from recurring patterns
+- The path to the citizen developer — the same safety envelope that serves a senior engineer will serve a non-technical consumer. Expanding who can ship safely without lowering the bar
+
+**Key takeaway:** Velocity without sacrificing safety. Security and auditability as byproducts. The bottleneck moves off the platform team's queue.
+
+---
+
+## Appendix — Contents
+
+**Talking points:**
+- These are backup slides for Q&A — don't walk through them in the main talk unless time permits
+- Use A1 when asked about the citizen developer detail; A2 for the no-cloning mechanism; A3 for local reproducibility; A4 for the roadmap; A5 for term definitions
+
+**Key takeaway:** The appendix is the deep-dive drawer. Pull a slide when the audience asks for the detail behind a main-slide claim.
+
+---
+
+## A1 — The Citizen Developer Experience
+
+**Talking points:**
+- The framing is **vibe coding on a laptop** — the consumer describes what they want in plain language; an AI agent turns that into a contract the platform treats identically to a senior engineer's
+- The consumer opens an issue (e.g. "a web API for the pricing service"); an AI agent maps the intent to a contract referencing a module from the reviewed skill catalog
+- The contract enters the same pipeline and must clear the same confidence gate — no weaker mode
+- Guardrails: skills are versioned, signed, and reviewed for sensitive data before release (Infra & Ops owns the review); agents are stateless — all state lives in the platform; the platform trusts and always verifies
+- The agent's trace and submission confidence are captured in the contract (`profile: agentic`), so a reviewer can see how the contract was produced
+- Be honest about maturity: the mechanism is designed and stub-proven; the full skill catalog and real agent runtime are planned
+
+**Key takeaway:** Vibe coding on a laptop — but every submission passes the same safety envelope. The agent produces the contract; the platform verifies it.
+
+---
+
+## A2 — No Platform Code, No Cloning
+
+**Talking points:**
+- The consumer's CI definition is a thin wrapper — one `uses:` line pointing at a versioned tag. That's the only coupling
+- The runner checks out the consumer repo, then checks out the platform repo into the workspace. The platform installs its own runtime dependencies — the consumer installs nothing
+- The consumer never clones the platform repo, never invokes platform scripts locally (optional `--check-only` validation is available but not required)
+- When the platform ships a fix, every consumer on a floating MAJOR.MINOR tag gets it on their next run — no per-repo upgrade project
+- For the Head of Cloud: there is no "platform code in every consumer repo" problem. The version-pinned `uses:` line is the only coupling, and it updates itself within the line
+
+**Key takeaway:** One `uses:` line is the only coupling. The platform fetches itself at run time. No per-repo upgrade projects.
+
+---
+
+## A3 — Local Reproducibility
+
+**Talking points:**
+- The entire CI pipeline runs from the shell, not just in CI — no "works on my machine, fails in CI" gap
+- `scripts/run_ci.sh` mirrors the CI pipeline locally — the same three stages (lint → test → check-only) in sequence
+- `scripts/run_platform.sh --check-only` runs the platform offline — no AWS, no policy engine, no outbox required. Validates a contract end-to-end before pushing
+- `--plan-only` runs through the infrastructure plan without applying
+- The CI and deploy pipelines are defined by declarative contracts (YAML instances validated against JSON Schemas) — a single source of truth that both workflows implement
+
+**Key takeaway:** Validate offline, plan offline, push when confident. The same declarative contract drives local tooling and CI.
+
+---
+
+## A4 — The Road to the North Star
+
+**Talking points:**
+- Call this out explicitly: **proposed phasing, not formally planned** — don't let the audience read it as a commitment
+- Phase 1 is what's tested today — core platform (contract, catalog, evidence)
+- Phase 2 is the next milestone — safe promotion wiring for qa/prod/dr
+- Phase 3 introduces the agentic surface — skill catalog + agents
+- Phase 4 is the north star — citizen developer GA on the same safety envelope
+- Use this slide only when an audience member asks "how do you get from here to there"
+
+**Key takeaway:** A proposed path from the tested core to the citizen developer north star — proposed phasing, not formally planned.
+
+---
+
+## A5 — Glossary
+
+**Talking points:**
+- Keep this slide in your back pocket for the audience member who asks "what does ABAC actually mean?" — don't read it aloud
+- OIDC = short-lived federation tokens, no long-lived credentials; ABAC = access scoped by resource tags + repo identity, not roles
+- CMK = per-stack encryption key, 90-day rotation; CMDB = validates change requests for decommission
+- RPO = 0 means evidence written synchronously, no data loss; HITL = deliberate human attestation for qa/prod/dr
+- VCS = the git hosting platform (GitHub, Gitea, GitLab); NFR = encryption, tagging, observability standards
+
+**Key takeaway:** The deck uses real security and ops vocabulary. The glossary is the cheat sheet for the audience member who wants the definitions.