docs(ship): P3 complete → v1.27.3 (v1.28 idp-auth)

---ci---
project: acdl
phase: 3
milestone: v1.28
status: complete
---/ci---

.ciagent/ARCHITECTURE.md

@@ -1,16 +1,28 @@
-# Nova — Architecture (v1.1 target)
+# Nova — Architecture
 
-> Target architecture for the real Agentic Cloud Delivery Platform (rebranded
+> **Compressed.** The full v1.0–v1.24 architecture history (v1.1 spike
-> Nova in v1.15). Source of truth for **how**: `docs/architecture.md` (v0.2) is the upstream
+> scope, v1.2 build-out, v1.8–v1.16 addenda) is preserved verbatim at
-> draft; this file is the Nova-repo operating copy, refined at phase
+> `.ciagent/archive/ARCHITECTURE-v1.0-v1.24.md`. This file retains the
-> boundaries. Where this file and `docs/vision.md` conflict, the vision wins.
+> durable target architecture (§1–§12, the four layers + six cross-cutting
+> concerns) + the three addenda that describe the **current state**:
+> v1.11 (stateless adapter), v1.15 (Nova rebrand — current naming), and
+> v1.17 (telemetry/observability layer + §12.7 Policy Engine Registry).
+> Intermediate addenda (v1.1 spike scope, v1.2 build-out, v1.8/1.9/1.10/
+> 1.12/1.13/1.14/1.16) describe evolved or superseded states and are
+> preserved in the archive snapshot.
+>
+> Source of truth for **how**: `docs/architecture.md` (v0.2) is the
+> upstream draft; this file is the Nova-repo operating copy, refined at
+> phase boundaries. Where this file and `docs/vision.md` conflict, the
+> vision wins.
 
 ## Status
 
-Architecture is at **v0.2** upstream (`docs/architecture.md`). Milestone v1.1
+Architecture is at **v0.2** upstream (`docs/architecture.md`). Milestone
-**finalizes it to v1.0** in Phase 07 by resolving the 11 open decisions
+v1.1 **finalized it to v1.0** in Phase 07 by resolving the 11 open
-(see `PROJECT.md` open-decision resolutions table). This file records the
+decisions (see `PROJECT.md` open-decision resolutions table). The v1.11
-locked commitments and the v1.1 spike scope.
+addendum (stateless adapter) and the v1.17 addendum (telemetry layer +
+§12.7 Policy Engine Registry) record the current-state refinements.
 
 ## Overview
 
@@ -55,8 +67,9 @@ the same policy envelope, and the same evidence stream.
 ### Layer 1 — Foundational Primitives
 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
+interface is defined against the **Target Stack IR**, not against
-directly (the IR is shaped to round-trip to Terraform in v1, per §12.1).
+Terraform directly (the IR is shaped to round-trip to Terraform in v1,
+per §12.1).
 
 - No inter-L1 references. L1 may call Terraform data sources.
 - Semver: interface → MAJOR, behavior → MINOR, lifecycle → PATCH (W3.D).
@@ -68,8 +81,8 @@ Combine L1 primitives into deployable shapes. Each codebase maps to one
 canonical L2 stack (`multiStack: true` only per W1.B). Shape X
 (parameterized module) or Shape Y (thin-composition layer). Hierarchical
 composition, max depth 5, only registered L1s. The thin-composition tree's
-`wires` field is defined against the IR's relationship type, not a Terraform
+`wires` field is defined against the IR's relationship type, not a
-module block.
+Terraform module block.
 
 Pipeline quality checks: secrets-in-plaintext, public ingress, IAM
 wildcard, KMS key reference, tag compliance, naming convention. Restricted
@@ -149,6 +162,10 @@ before contract submission ack); RTO = async worker's dead-letter recovery.
 Single-region in v1. The outbox also stores per-contract QA and prod
 approver identities (the only durable record outside GitHub's audit log).
 
+> **v1.17 update:** the Decision Ledger (SQLite hash-chain, D-121) is the
+> pilot's audit record. S3 Object Lock / JWS (D-083) is deferred — see
+> the v1.17 addendum below.
+
 ### Human-in-the-Loop mechanics (§10)
 Pre-execution gates. qa, prod, dr are PR-based attestation gates backed by
 GitHub Environments with required reviewers. No partial deployment to roll
@@ -181,28 +198,28 @@ 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).
 
-### Angine execution (§12) — the binding constraint
+### Engine execution (§12) — the binding constraint
-**Target Stack IR** (locked): a engine-neutral description of resources
+**Target Stack IR** (locked): an 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 engine.
 
-**Angine adapters** are the only engine-specific code. An adapter
+**Engine adapters** are the only engine-specific code. An adapter
-compiles the IR into a engine execution plan. **v1 ships exactly one
+compiles the IR into an engine execution plan. **v1 ships exactly one
 adapter: the Terraform adapter.** v2+ may add OpenTofu, Pulumi, K8s CRDs
 without architectural change.
 
 v1 reality: the IR is shaped to round-trip cleanly to Terraform (nearly
 isomorphic). As more adapters appear, the IR gets more expressive and the
-adapters gain translation logic; the L1 content, the YML standard, and the
+adapters gain translation logic; the L1 content, the YML standard, and
-thin-composition tree do not change.
+the thin-composition tree do not change.
 
-**Terraform adapter (v1):** translates IR-typed L1 interface → Terraform
+> **v1.11 update:** the Terraform adapter is now a **stateless assembler**
-`variable`/`output` blocks; IR-typed L2 thin-composition tree → Terraform
+> (~80 lines, emits `module "x" { source }` blocks) — see the v1.11
-root module; IR-typed relationships → module references; emits a
+> addendum below. The §12 "thin layer that translates IR → Terraform
-`terraform plan` from the IR. The adapter is a thin layer; it does not own
+> variable/output blocks" framing is superseded by the stateless-assembler
-L1/L2 content.
+> model; the L1-owns-its-shape invariant is the new contract.
 
 State storage: S3 (state) + DynamoDB (locking), cloud-managed,
 single-region in v1.
@@ -211,6 +228,10 @@ Policy toolchain: **Checkov** for Terraform plan policy (the L2 checks +
 tag/naming); **Kyverno** for K8s-native/platform-internal policy; **OPA**
 reserved for cross-resource cases, explicitly last resort.
 
+> **v1.25 update:** the policy toolchain is now unified under the
+> swappable `PolicyEngine` protocol — see §12.7 below. Checkov and Wiz
+> remain as raw-finding adapters feeding into kyverno-json meta-policies.
+
 **Policy result normalization (§12.6):** the confidence signal consumes a
 normalized `PolicyCheckResult` schema, not raw engine output.
 
@@ -242,337 +263,9 @@ Contract→IR resolution: the contract declares intent in IR-typed terms;
 the pipeline resolves it to a target stack (list of L1 instances + inputs +
 relationships); the Terraform adapter compiles the target stack to a plan.
 
-## v1.1 spike scope
+---
 
-The spike (Phases 08–10) materializes the **minimum** that proves the IR
+## v1.11 Addendum — Stateless Adapter + Pipeline-Driven Lifecycle Testing (current state)
-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-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
-  outbox.
-- State: S3 + DynamoDB (real AWS, single-region).
-
-Out of spike scope: full HITL matrix wiring, Kyverno, OPA, MCP skill
-catalog, GitOps reconciler, multi-region, prod/dr environments, the 5-skill
-L3B catalog. Those are post-spike (v1.2+) platform build-out.
-
-## Gitea API surface (carried from v1.0, refined)
-
-| Capability | Gitea support | ACDL approach (v1.1) |
-|------------|---------------|----------------------|
-| Org-scoped repo create | `POST /api/v1/orgs/{org}/repos` | Used for any new repos |
-| Native Pages | **None** | Serve `acdl-evidence` via raw file URLs (unchanged from v1.0) |
-| Environments API | **None**; act_runner ignores `environment:` | Model HITL gates via `workflow_dispatch` approval inputs (v1.0 D-013 pattern) — **refined in Phase 07** for the real pre-execution gate model |
-| `repository_dispatch` | Not supported | Cross-repo trigger via `workflow_dispatch` API (unchanged) |
-| Reusable workflows | Supported | `acdl/.gitea/workflows/pipeline.yml` via `uses: ...@<ref>` |
-| `id-token: write` / OIDC | **Not supported** (RESEARCH TARGET 1, conf 0.95). Gitea docs list `id-token` as an unsupported GitHub-only scope; open proposal go-gitea/gitea#33681; draft PR go-gitea/gitea#36988 unmerged. Even Gitea's own CI uses long-lived AWS keys (issue #37980). | **Spike waiver D-039:** per-run-rotated long-lived key (rotated after each run by `scripts/rotate_spike_key.sh`). Real OIDC deferred to v1.2, blocked on PR #36988. |
-| `actions/configure-aws-credentials` | Unusable without OIDC | Spike uses static AWS creds from a (rotated) Gitea Actions secret via the `aws-actions/configure-aws-credentials@v4` `access-key-id`/`secret-access-key` inputs, or plain `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` env vars. v1.2 switches to `role-to-assume` when OIDC lands. |
-
-### Branch pinning rule (refined for W2.A)
-
-- Dev/qa contracts reference the reusable workflow by **tag**
-  (`@v1.1-spike`).
-- Prod-bound workflows reference by **SHA**; the platform CLI
-  (`platform/cli/resolve-tag.ts`, Phase 07) resolves the current tag to its
-  SHA. (Spike scope: the CLI is a stub; the real CLI lands in v1.2.)
-
-### Verification toolchain
-
-ACDL has no `package.json`. The verification gate substitutes:
-- **typecheck:** `terraform validate`, `python3 -m py_compile`, JSON Schema
-  validation (`ajv` or `python -m jsonschema`) against `schemas/`.
-- **test:** per-phase `scripts/verify_phaseNN.sh` (Phase 06: archive integrity;
-  Phase 07: schema validation + decision-resolution completeness; Phase 08:
-  OIDC assume-role + state backend; Phase 09: IR + L1 + adapter `terraform
-  plan`; Phase 10: end-to-end contract submission).
-- **build:** `terraform init` (real build for the spike).
-- See `PERSONAS.md` verification_toolchain.
-
-## Build order (v1.1)
-
-1. Phase 06 — archive demo, reorient repo.
-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-assets` + contract→IR → end-to-end spike.
-6. COMPLETE gate — review → ship `v1.2.0` → audit. **DONE.**
-
-## v1.2 build-out scope
-
-v1.2 takes the v1.1 spike (dev-only, `plan`-only, single S3 L1) to a real,
-simpler, better-documented platform that delivers a microservice to AWS ECS
-Fargate end-to-end. The locked architecture (§1–§12) is unchanged — v1.2
-extends the *implementation*, not the design.
-
-### In scope (five axes, user-directed 2026-07-21)
-
-1. **Re-evaluate the current state.** go-gitea/gitea#36988 (OIDC for Gitea
-   Actions) re-checked 2026-07-21: still **open** (last updated 2026-05-27,
-   not merged). Real OIDC remains deferred to v1.3+; v1.2 extends the D-039
-   per-run-rotated-key waiver as **D-047**. The waiver continues to satisfy
-   §12.5's *intent* (no *persistently* long-lived key): the spike key is
-   rotated after each run by `scripts/rotate_spike_key.sh`, and Phase 12
-   tightens the IAM scoping + rotation hygiene.
-2. **NFR improvements on the existing spike.** Least-privilege IAM audit of
-   `spike_runner_policy.json`; idempotent `create_state_backend.py` /
-   `create_iam_user.py`; proper exit codes / error handling; P1-1 redaction
-   (two AWS access key IDs in `.ciagent/VERIFY.md` Phase 09 narrative).
-3. **Streamline / simplify the current setup.** Consolidate
-   `run_spike_plan.sh` + `run_spike_e2e.sh` into one
-   `scripts/run_platform.sh`; remove dead code and stale `platform/` paths.
-4. **README.md fully up to date on how the platform works.** Reflect v1.1
-   complete; document the actual spike flow, `scripts/run_platform.sh`, the
-   real repo layout, and the v1.2 objective.
-5. **Bootstrap a consumer repo with a basic microservice deployed to ECS
-   end-to-end.** New Gitea repo `acdl-consumer-microservice` (org
-   `continuous-intelligence`); new IR-typed L1s (`l1-vpc`, `l1-ecs-cluster`,
-   `l1-ecs-service`, `l1-iam-role`, `l1-alb`, `l1-ecr`); new
-   `l2-microservice` thin-composition; one contract submission →
-   `terraform apply` (dev, autonomous per §10, confidence ≥ 0.50) → a live
-   ECS Fargate service serving HTTP 200 → evidence event to the DynamoDB
-   outbox → acdl-evidence timeline.
-
-### Angine extension (ECS Fargate)
-
-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/`, `core/confidence_signal.py`,
-`core/contract_resolver.py`, `core/outbox_writer.py`
-remain engine-agnostic.
-
-### `terraform apply` (dev only)
-
-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
-stream as a `terraform.apply` event.
-
-### Out of scope for v1.2 (deferred to v1.3+)
-
-| Feature | Reason |
-|---------|--------|
-| Real OIDC federation | go-gitea/gitea#36988 still open. v1.2 extends D-039 waiver (D-047); real OIDC is v1.3+. |
-| Full HITL matrix wiring (qa/prod/dr) | v1.2 is dev-only autonomous `apply`; HITL wiring is v1.3. |
-| Kyverno + OPA policy engines | v1.2 keeps Checkov only; Kyverno/OPA are v1.3. |
-| MCP skill catalog + real L3B agent | v1.2 keeps the L3B stub; the 5-skill catalog is v1.3. |
-| Audit ledger build-out (S3 Object Lock + JWS + async worker + DLQ + daily checkpoints) | v1.2 keeps the v1.1 outbox; the regulatory ledger is v1.3. |
-| Multi-region state / outbox | Single-region in v1 (§9, §12.3); multi-region is v1.3+. |
-| Prod/dr environments | v1.2 is dev-only; prod/dr are v1.3. |
-| GitOps reconciler (ArgoCD/Flux) | v1.3+. |
-
-## Build order (v1.2)
-
-1. Phase 11 — re-eval #36988 + NFR audit + simplification findings + README rewrite.
-2. Phase 12 — NFR harden + simplify (idempotent bootstrap, one `run_platform.sh`, IAM audit, redactions).
-3. Phase 13 — six ECS L1s + adapter `TYPE_MAP` expansion.
-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.
-
-## 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.
-
-## v1.10 Addendum — Regression VERIFY + Local Emulators + Capability Re-Verification
-
-### Regression-Class VERIFY (D-091, `core/regression_verify.py`)
-
-The standard VERIFY stage was diff-scoped (it checked the phase diff
-only, never re-ran underlying capability). This let 8 NFR-patch phases
-(v1.9.1–v1.9.8) pass while the platform decayed. The regression-class
-VERIFY (`core/regression_verify.py`) re-runs capability checks against
-the current codebase and tags each Verified/Decayed/Broken. It fails
-closed on any non-Verified capability, blocking milestone completion.
-
-The registry (`CAPABILITY_REGISTRY`) holds 16 capability checks
-(CAP-001..CAP-016): 12 local-tier + 4 live-AWS. Adding a capability is
-a single function + one registry entry. The gate runs via
-`scripts/run_regression.sh` and writes `.ciagent/REGRESSION_REPORT.md`
-+ `.json`.
-
-### Local Emulating Adapters (D-092, `core/local_emulators.py`)
-
-Four local adapters let the platform run the full headline E2E without
-cloud credentials:
-
-- `FlatFileOutbox` — flat-file DynamoDB outbox emulator (hash-chained
-  JSONL; resumable across instances; chain verification).
-- `LocalEcsEmulator` — local ECS Fargate HTTP 200 emulator (binds port
-  0 on 127.0.0.1; daemon thread; clean destroy).
-- `LocalS3StateBackend` — rewrites the terraform S3 backend to a local
-  backend (per-stack tfstate in a temp folder).
-- `LocalLambdaStub` — invokes the contract_ingestor handler in-process
-  (patches `_get_dynamodb`/`_get_secrets_client`/`urllib.urlopen`;
-  DynamoDB writes redirected to the FlatFileOutbox).
-
-`run_local_e2e()` runs the full pipeline: contract → resolver → adapter
-→ local S3 backend → local ECS (HTTP 200) → flat-file outbox (chain
-verified) → local Lambda (200). Gated on `ACDL_LOCAL_TIER=1`.
-
-### Capability Re-Verification Sweep (D-093)
-
-`.ciagent/CAPABILITY_INVENTORY.md` enumerates 16 auto-verified
-capabilities + 6 IAM-gated escalated resources. The sweep found and
-fixed 7 adapter defects in `adapters/terraform/adapter.py` (duplicate
-outputs, duplicate args, missing required args, deprecated AWS provider
-v5 arg names). The headline E2E now passes at both tiers: local
-emulator + live-AWS terraform init/validate/plan.
-
-### Adapter Defect Fixes (P54)
-
-7 defects fixed in `adapters/terraform/adapter.py`:
-1. Duplicate output definitions (per-resource + stack-level both emitted).
-2. Duplicate `desired_count`/`launch_type` on ECS service.
-3. Duplicate `target_type`/`family`/`load_balancer_type`.
-4. Missing `assume_role_policy`/`role_name` on IAM role (L2 composition gap).
-5. Missing `cidr_block`/`vpc_id`/`name` defaults on VPC/subnet/route_table/
-   ECS cluster/ECR repository.
-6. ECR `kms_key_arn` unsupported arg → `encryption_configuration` block.
-7. CloudFront OAC + WAF deprecated arg names (AWS provider v5):
-   `signing_behavior`, `signing_protocol`, `origin_access_control_id`,
-   `s3_origin_config.origin_access_identity`, `origin_id`, `rule`
-   (singular), `scope=CLOUDFRONT` (uppercase).
-
-## v1.11 Addendum — Stateless Adapter + Pipeline-Driven Lifecycle Testing
 
 **Stateless adapter (D-098).** `adapters/terraform/adapter.py` rewritten
 from a 918-line monolith (3 constant tables `TYPE_MAP`/`INPUT_MAP`/
@@ -598,83 +291,25 @@ VPC; the microservice composition references it via
 `terraform_remote_state` (data source). State keys are deterministic and
 env-aware (`spike/{contract.id}/{contract.environment}/terraform.tfstate`).
 
-**NOVA_LIFECYCLE_MODE (v1.12, REQ-134; renamed ACDL→NOVA in v1.15 P2).** The lifecycle pipeline defaults
+**NOVA_LIFECYCLE_MODE (v1.12, REQ-134; renamed ACDL→NOVA in v1.15 P2).**
-to plan-only (fast, no AWS mutation, no cost). A CI variable
+The lifecycle pipeline defaults to plan-only (fast, no AWS mutation, no
-`NOVA_LIFECYCLE_MODE` (default `plan`) overrides to `full` for the real
+cost). A CI variable `NOVA_LIFECYCLE_MODE` (default `plan`) overrides to
-apply→modify→destroy. (P2–P4 dual-read fallback to `ACDL_LIFECYCLE_MODE`;
+`full` for the real apply→modify→destroy. (P2–P4 dual-read fallback to
-fallback removed in P5 per the v1.15 addendum.)
+`ACDL_LIFECYCLE_MODE`; fallback removed in P5 per the v1.15 addendum.)
 
-## v1.12 Addendum — Presentation Refinement + CAP-013 Fix
-
-**CAP-013 adapter dedup fix (REQ-129).** Multi-resource L1s (ecs-service,
-alb) with stack outputs + cross-module refs now dedup to ONE module block
-named by the composition child id, with expanded sub-ids rewritten via
-`id_remap`. `terraform validate` succeeds for the microservice stack.
-
-**CAP-017/018 probe fixes (REQ-130).** CAP-017's probe no longer requires
-`locals.tf` for modules that legitimately omit it. CAP-018's probe
-instantiates `LocalLambdaStub` with the required `outbox` arg.
-
-## v1.13 Addendum — Presentation Polish + Config Schema Migration
-
-**Config.json schema migration (v1.13.1).** Regenerated
-`.ciagent/config.json` to the updated CIAgent v2 config structure (drop
-removed fields, migrate `gitea`→`release.gitea`, add
-`secrets`/`ship`/`backend`/`ideation`/`personas`/`logging`/`telemetry`
-sections).
-
-**Presentation polish (v1.13.0, v1.13.2).** Action headlines, story-arc
-restructure, larger fonts, 6 new mermaid diagrams, badge cleanup,
-platform-architecture diagram. Docs-only NFR patches.
-
-## v1.14 Addendum — NFR Refinement (bug fixes, security, stubs, tests, docs)
-
-**Bug fixes (Wave 1, P1-P6).** Adapter dedup rejects unregistered modules
-with ValueError (P1). Static-assets composition wires cloudfront inputs
-(P2). L2 lifecycle scripts document remote-state design (P3). Regression
-gate adds `terraform fmt -check` syntax probe (P4). Adapter dedup-merge +
-remote-state-key unit tests (P5). ALB target group name_prefix derives
-from var.name (P6).
-
-**Security (Wave 2, P7-P12).** 6 swallowed-error sites narrowed to
-specific exceptions (P7). Account ID externalized to
-`ACDL_AWS_ACCOUNT_ID` env (P8). IAM policy scoped to `acdl-*` ARNs (P9).
-Contract ingestor validates contractId/environment/error (P10). Environment
-schema adds `additionalProperties: false` + format validation (P11).
-`.gitignore` credential-pattern catch-all (P12).
-
-**Stub/test/CI/hygiene (Wave 3, P13-P17).** Kyverno `--kube-version` flag
-removed (P13, G-103). Orphan artifacts + dead config cleaned (P14). 7
-untested scripts gain test coverage (P15). Gitea workflow parity
-documented + script `set` flags fixed (P16). Config.json persona +
-branching strategy + ollama-cloud aligned (P17).
-
-**Standards/docs/VPC (Wave 4, P18-P20).** STANDARDS.md reconciled (P18).
-Documentation synced: ARCHITECTURE.md addenda, stale `@v1.6-1.9` → `@v1.13`,
-GRILL G-005/G-008 resolved, COST.md window extended, D-083 deferral
-recorded (P19). Platform VPC CIDR parameterized + data-driven subnet
-count (P20).
-
-**D-083 deferral (explicit).** The audit ledger build-out (S3 Object Lock
-+ JWS detached signatures + SQS DLQ + async worker + daily checkpoints)
-remains deferred (D-096, v1.14). The hash-chain + DynamoDB outbox is the
-v1.14 audit record. JWS per-event authenticity is not implemented; a
-forged event is only detectable by re-reading the whole chain. The
-deferral is documented here explicitly per the v1.14 grill (E-001).
 ---
 
-## v1.15 Addendum — Nova Rebrand (Major/breaking, 2026-07-30)
+## v1.15 Addendum — Nova Rebrand (current naming)
 
 **Milestone:** v1.15-Nova. A full rebrand from **ACDL** / "Agentic Cloud
-Delivery Platform" → **Nova** / "The New Dawn of DevSecOps — security
+Delivery Platform" → **Nova** / "The New Dawn of DevSecOps — security as
-as a seamless enabler of fast deployments." This is a **Major
+a seamless enabler of fast deployments." This is a **Major milestone**
-milestone** (breaking): consumer-facing path, env var prefixes, SSM
+(breaking): consumer-facing path, env var prefixes, SSM path, AWS tag
-path, AWS tag keys, and AWS resource names all change. Per the
+keys, and AWS resource names all change. v1.15 tags run on the **v1.15.x
-branch-strategy precedent (breaking/feature milestones tag on their
+minor line**: `v1.15.0` (P0) → `v1.15.4` (P5 final = release). (G-104
-OWN minor line), v1.15 tags run on the **v1.15.x minor line**:
+binding.)
-`v1.15.0` (P0) → `v1.15.4` (P5 final = release). (G-104 binding.)
 
-### Naming conventions (rebranded)
+### Naming conventions (rebranded — current)
 
 | Convention | Before (v1.0–v1.14) | After (v1.15+) | Phase |
 |------------|---------------------|-----------------|-------|
@@ -713,94 +348,15 @@ OWN minor line), v1.15 tags run on the **v1.15.x minor line**:
   brand name present (D-112: flat-branch convention preserved).
 - **Past Gitea release titles** — existing releases keep `ACDL vX.Y.Z`.
 
-### Migration ordering (binding)
+> The full migration ordering (P1–P5), capability gate, and rollback
-
+> runbook are preserved in `.ciagent/archive/ARCHITECTURE-v1.0-v1.24.md`
-1. **P1** docs/decks/prose — no runtime impact; ships consumer migration
+> §v1.15 Addendum.
-   guide announcing the 5 breaking changes.
-2. **P2** code + env vars (dual-read) + consumer path — deployments don't
-   break during the transition window (dual-read fallback).
-3. **P3** SSM path (copy → read → delete) + tag keys (parallel-tag →
-   policy swap → remove old).
-4. **P4** AWS resource names — staged terraform migration (KMS alias,
-   SNS/SG/Lambda recreate, DynamoDB scan+copy, ECR re-push, IAM
-   re-bootstrap, state bucket `-migrate-state`, ALB recreate). Maintenance
-   window + rollback runbook (`docs/NOVA_AWS_MIGRATION.md`).
-5. **P5** final review + audit + remove dual-read fallback + milestone ship.
-
-### Capability gate (binding)
-
-The regression gate (CAP-001..CAP-016, `scripts/run_regression.sh`) must
-stay **16/16 Verified** throughout the rebrand. P2/P3/P4 update test
-fixtures that reference `ACDL`/`acdl` so the gate stays green. No
-capability is added, removed, or reclassified in v1.15 — the rebrand is
-nomenclature + identifiers, not behavior.
 
 ---
 
-## v1.16 Addendum — Nova Simplification (NFR, 2026-07-30)
+## v1.17 Addendum — Strategic Direction, Leadership Metrics & Unified Story (current telemetry layer)
 
-The v1.16 NFR milestone added 6 new code components + 1 new Terraform
+The v1.17 milestone added a telemetry/observability layer, a Decision
-module + 1 new schema, all documented here for the architecture record.
-
-### New components
-
-| Component | Path | Purpose |
-|-----------|------|---------|
-| Onboarding request handler | `core/onboarding.py` | `generate_env_file(request, template_env)` — produces a `<env>.json` from a consumer onboarding request (P19, REQ-183). CLI entry point for self-service env-file generation. |
-| Decommission transform | `core/decommission_transform.py` | `decommission_transform(stack)` — zero counts + disable deletion protection (REQ-92). Extracted from contract_resolver (P12, REQ-176). |
-| Contract resolver CLI | `core/contract_resolver_cli.py` | `main()` CLI entry point — resolves a contract YAML to a Target Stack JSON. Extracted from contract_resolver (P12, REQ-176). |
-| Regression verify CLI | `core/regression_verify_cli.py` | `main()` CLI entry point — runs the regression gate + writes the report. Extracted from regression_verify (P13, REQ-177). |
-| Workflow sync generator | `scripts/sync_workflows.py` | `--check`/`--write` — generates the 3 byte-identical Gitea+GitHub workflow pairs from `workflows-src/` (P8, REQ-172). |
-| Onboarding Terraform | `terraform/onboarding/` | `aws_iam_role.consumer_deploy` + `aws_iam_role_policy.consumer_invoke` (ABAC `nova:owner` tag). Offline-proven only (P20, REQ-184, D-114). |
-
-### Modified components
-
-| Component | Change | Phase |
-|-----------|--------|-------|
-| `core/contract_resolver.py` | `_load_env` delegates to `environment_check.load()` (dedup); `is_l2` uses registry `kind` field; `_load_schema` caches schemas; `decommission_transform` + CLI re-export shim (P12). | P7, P12, P14 |
-| `core/regression_verify.py` | Dedup helpers (`_check_resolver`, `_check_live_terraform_plan`, `_assert_contracts_resolve`); CAP-013..016 `Skipped` on post-teardown (G-111); `passed` accepts Skipped; CLI re-export shim (P13). | P5, P9, P13 |
-| `core/lambda/contract_ingestor.py` | Fail closed on missing IAM identity (P10); env enum from `core/environments/` (P10); payload size cap + schema validation (P11); `onboard_consumer` action (P18); `[NOVA-ALERT]` rebrand (P2). | P2, P10, P11, P18 |
-| `core/output_publisher.py` | `SAFE_OUTPUT_NAMES` schema-driven from `interface.json`; narrowed excepts; `urllib.error` import (P4, P14). | P4, P14 |
-| `core/environment_check.py` | Onboarding message rebranded Nova + self-service request path (P2, P19). | P2, P19 |
-| `core/local_emulators.py` | `LocalLambdaStub` sets `NOVA_LAMBDA_LOCAL_BYPASS`; stale dual-read comments + `acdl_*` prefixes removed (P3, P10). | P3, P10 |
-| `scripts/run_platform.sh` | `--help` flag; `run_hitl_gate()` fn; `NOVA_CONTRACT_ID`/`NOVA_WORK_DIR` config; decommission + uptime blocks extracted to sourced helpers (P6, P9, P15). | P6, P9, P15 |
-| `adapters/terraform/adapter.py` | State bucket `nova-tfstate-*` (P1); module docstring Nova (P2). | P1, P2 |
-| `adapters/kyverno/policies/require-resource-labels.yml` | `nova:*` labels (not `acdl:*`) (P1). | P1 |
-| `modules/registry.json` | `kind` field (`l1`/`l2`) on all 14 entries (P7). | P7 |
-
-### New schema
-
-- `schemas/onboarding.schema.json` — the self-service onboarding request
-  (consumerRepo, requestedEnvironment, ownerId, billingTag). P18, REQ-182.
-
-### Onboarding request-path architecture (D-113)
-
-The no-humans onboarding flow is a 3-step request path (real AWS
-provisioning deferred):
-
-```
-Consumer → POST Lambda (onboard_consumer) → pending CMDB row (P18)
-         → core/onboarding.py → <env>.json binding file (P19)
-         → terraform/onboarding/ → cross-account role + ABAC tag (P20, offline)
-```
-
-The Lambda Function URL (IAM auth) + `consumer_invoke_policy.json` (ABAC
-`nova:owner`) are the transport; the request is accepted + a binding
-generated + the role Terraform proven offline. No AWS resources are
-created by the request path (D-113/D-114).
-
-### Regression gate (G-111 binding)
-
-The regression gate (D-091) now treats `Skipped` as acceptable for the
-post-v1.11-teardown steady state (D-096): CAP-013..016 (live-AWS tier)
-return `Skipped` when the resources are absent (`NoSuchBucket`/
-`ResourceNotFoundException`). `RegressionReport.passed` is
-`all(r.status in ("Verified", "Skipped"))`. The gate passes at 18
-Verified + 4 Skipped (0 Decayed/Broken).
-
-## v1.17 Addendum — Strategic Direction, Leadership Metrics & Unified Story (2026-08-04)
-
-The v1.17 milestone adds a telemetry/observability layer, a Decision
 Ledger, a metrics export pipeline, a unified narrative deck, and a
 durable strategic-direction artifact. This addendum documents the
 architecture; the full research findings are in RESEARCH.md §v1.17.
@@ -840,26 +396,26 @@ architecture; the full research findings are in RESEARCH.md §v1.17.
 │  Nova platform components (existing)                                │
 │  run_platform.sh · confidence_signal · checkov_adapter ·            │
 │  hitl_gates · regression_verify · outbox_writer · contract_ingestor │
-└──────────────────────┬──────────────────────────────────────────────┘
+└────────────────────┬──────────────────────────────────────────────┘
-                       │ CloudEvents 1.0 envelope (new emitters, P1)
+                     │ CloudEvents 1.0 envelope (new emitters, P1)
-                       ▼
+                     ▼
 ┌─────────────────────────────────────────────────────────────────────┐
 │  metrics/events.jsonl  (append-only CloudEvents log)                │
 │  metrics/runs/<run_id>.json  (per-run manifests)                    │
 │  metrics/decision_ledger.db  (SQLite hash-chain, D-121)             │
 │  metrics/test-results.xml  (junit, P1)                              │
-└──────────────────────┬──────────────────────────────────────────────┘
+└────────────────────┬──────────────────────────────────────────────┘
-                       │ collector reads (P2)
+                     │ collector reads (P2)
-                       ▼
+                     ▼
 ┌─────────────────────────────────────────────────────────────────────┐
 │  metrics/nova_metrics.db  (SQLite cold store, D-126)                │
 │  fact_run · fact_capability · fact_policy_check · fact_confidence  │
 │  fact_test · fact_decision · fact_cost_estimate                     │
 │  dim_capability · dim_milestone                                     │
 │  + 8 empty placeholder views (deferred metrics)                    │
-└──────────────────────┬──────────────────────────────────────────────┘
+└────────────────────┬──────────────────────────────────────────────┘
-                       │ powerbi_export (P3)
+                     │ powerbi_export (P3)
-                       ▼
+                     ▼
 ┌─────────────────────────────────────────────────────────────────────┐
 │  metrics/powerbi/  (CSV/JSON views, folder connector, D-129)        │
 │  → PowerBI dashboards (external)                                    │
@@ -868,14 +424,236 @@ architecture; the full research findings are in RESEARCH.md §v1.17.
 
 **Hot path: deferred (D-126).** No live ops dashboard; SQLite is
 cold-only (batch/historical). The hot path activates when live AWS is
-re-provisioned (D-096 lift).
+re-provisioned (D-096 lift — the v1.26 milestone lifts this for the pilot
+estate).
 
 ### NORTH_STAR integration point (REQ-186)
 
 `.ciagent/NORTH_STAR.md` is read by CIAgent in context-loading for all
-future milestones. The integration mechanism (to be finalized in P4):
+future milestones. The integration mechanism: a reference from
-a reference from `PROJECT.md` + `ARCHITECTURE.md` (this section) + a
+`PROJECT.md` + `ARCHITECTURE.md` (this section) + a config entry in
-config entry in `config.json` (`strategic_direction_file:
+`config.json` (`strategic_direction_file: ".ciagent/NORTH_STAR.md"`)
-".ciagent/NORTH_STAR.md"`) that the run workflow reads at SPECIFY. This
+that the run workflow reads at SPECIFY. This ensures the strategic
-ensures the strategic direction survives across milestones without
+direction survives across milestones without being overwritten by status
-being overwritten by status updates.
+updates.
+
+### §12.7 — Policy Engine Registry (v1.25, REQ-291 — current)
+
+The policy-engine abstraction is first-class: a swappable `PolicyEngine`
+protocol so the engine may change without touching the confidence
+signal, the pipeline, or the `PolicyCheckResult` schema. This is the
+**swap boundary** that keeps the platform's compliance posture
+replaceable (Strategic Objective #2 — provable trust via a replaceable
+substrate, not a vendor lock-in).
+
+```
+ contract.yml ─┐                         ┌─→ list[PolicyCheckResult] ─┐
+ stack IR ─────┼─→ PolicyEngine.evaluate ├─→ list[PolicyCheckResult] ─┼─→ confidence_signal
+ plan JSON ────┤    (protocol)            └─→ list[PolicyCheckResult] ─┘  (engine-agnostic,
+ PCR list ─────┘                                                         unchanged)
+                    │
+                    ▼
+          ┌─ KyvernoJsonEngine (shells to `kj scan`; engine: "kyverno")
+          └─ OpaEngine (future — same protocol; engine: "opa")
+
+   checkov/wiz ──→ raw findings ──→ (merged PCR list is the meta-policy payload)
+```
+
+**The protocol (`core/policy_engine.py`):**
+```python
+class PolicyEngine(Protocol):
+    @property
+    def name(self) -> str: ...
+    def is_configured(self) -> bool: ...
+    def evaluate(self, payload, policy_dir: Path, contract_id: str) -> list[dict]: ...
+```
+
+**The registry** reads `config.json.policy.engine` (default
+`"kyverno-json"`) and returns the active engine. A `NullEngine` is the
+fallback when the `policy` key is absent (emits `SKIPPED` PCRs —
+backward compatibility for tests that don't set the key). The
+confidence signal is **untouched** — it already consumes
+`list[PolicyCheckResult]` engine-agnostically (§12.6). v1.25 only
+changes *who produces* the PCR list, not *what* the list is.
+
+**Engine enum reuse (D-116):** kyverno-json PCR records carry
+`engine: "kyverno"` (no new enum value). The `engine` field records the
+policy-engine *family*, not the specific binary. The K8s Kyverno adapter
+and the kyverno-json engine are distinguished by `ruleId` prefix
+(`KYVERNO_` vs `KJ_`) and `evidence` payload shape (`namespace`/`kind`
+vs `assertion`/`jmespath`).
+
+**Defense-in-depth (D-119):** the declarative meta-policy
+`block-on-any-critical` (asserts no PCR has `severity: critical` +
+`result: fail`) is the *source of truth* for "critical = block". The
+`confidence_signal.py` `PENALTY["critical"]: None` hard-override stays
+as the *imperative* safety net — the meta-policy runs *before* the
+confidence signal (produces PCRs that flow in), the hard-override runs
+*inside* it (the last gate). Removing the hard-override would make the
+"critical = block" guarantee depend on a single policy file — a
+regression in provable trust.
+
+**Graceful degradation (D-120):** `KyvernoJsonEngine.is_configured()`
+returns false when `which kj` is absent → `evaluate()` returns a single
+`SKIPPED` PCR (`ruleId: "KJ_ENGINE_NOT_CONFIGURED"`). The platform
+functions without the binary (the "platform functions without AI /
+deterministic scripts" tenet holds — kyverno-json is deterministic, not
+AI; the `is_configured()` guard ensures the platform runs even when the
+binary is not installed).
+
+### §12.8 — Pilot Estate (v1.26, live)
+
+The first real consumer estate is **`nova-blockchain-exchange`** — a
+blockchain stock exchange on a homegrown Proof-of-Authority chain,
+equities only, dev only (D-020/D-200/D-201). The live apply landed on
+2026-08-19 against AWS account `581513795199`. This is the estate that
+activated the Post-Pilot metric denominators (see `docs/METRICS.md`).
+
+**The live apply (run id `blkex-pilot-apply-v0.2`):**
+- Target: account `581513795199`, environment `dev`, autonomous (no
+  HITL — dev is the only autonomous environment, confidence ≥ 0.50).
+- The microservice L2 composition (ECS Fargate running nginx) + the
+  `dynamodb` L1 (the `nova-blkex-ledger-dev` table) + the `s3` L1 (the
+  `nova-blkex-blocks-dev-581513795199-us-east-1` bucket).
+- The platform VPC prerequisite (`vpc-0d7c8867e6cc080f1` + 6 subnets +
+  the ECS SG) is read via `terraform_remote_state` — the L2 composition
+  does not own the network boundary (the "restricted from
+  thin-composition" rule from §Layer 2).
+- Confidence signal: score **0.800**, band **pass**; `human_override`
+  false; `escalation_reason` absent (clean apply).
+
+**The Gitea adapter (SPEC §10 Q1):** Gitea Actions does not support
+cross-repo `uses:`, so the consumer's `deploy.yml` is an **inline
+adapter** — `actions/checkout@v4` the consumer, `actions/checkout@v4`
+`acdl/acdl` @ `ref: v1.25` into `platform/`, then
+`bash platform/scripts/run_platform.sh ...`. The platform's own
+`.github/workflows/deploy.yml` stays as the GitHub Actions reference
+impl (the reusable `workflow_call` workflow). See `adapters/README.md`
+§Consumers for the adapter note.
+
+**The Decision Ledger evidence stream** (the apply produces these
+events in order):
+```
+nova.confidence.computed  (score 0.800, band pass)
+        │
+        ▼
+nova.ai.decision.made     (decision_id blkex-pilot-apply-v0.2,
+                           chosen_action pass, human_override false)
+        │
+        ▼
+nova.attestation.recorded (dev = no HITL gate; the record exists,
+                           the gate is a no-op in the autonomous env)
+        │
+        ▼
+nova.run.completed        (apply succeeded)
+        │
+        ▼
+nova.outcome.backfilled   (outcome pending → succeeded, REQ-317;
+                           backfilled_at 2026-08-19T03:05:04Z)
+```
+The SQLite hash-chain is valid (0 breaks). S3 Object Lock / JWS
+(D-083) stays deferred — the SQLite Decision Ledger is the pilot's
+audit record (D-204).
+
+**Live outputs (account 581513795199):**
+- ALB DNS: `app-254671247.us-east-1.elb.amazonaws.com`
+- ECS service: `arn:aws:ecs:us-east-1:581513795199:service/nova-cluster/nova-microservice`
+- DynamoDB table: `nova-blkex-ledger-dev` (PK `block_index`, PAY_PER_REQUEST)
+- S3 bucket: `nova-blkex-blocks-dev-581513795199-us-east-1` (versioning + SSE)
+
+The full evidence (every ARN, the confidence JSON, the Decision Ledger
+rows, the module-completeness gaps the live apply uncovered) is in
+`.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md` (archived v1.27).
+
+### §12.9 — Secret Rotation (v1.26 P3 W7, SPEC §5.9 — current)
+
+The platform-managed scheduled workflow `workflows-src/rotate-aws-key.yml`
+rotates the `NOVA_AWS_*` static key daily (cron `0 0 * * *`) and on
+`workflow_dispatch`. v0.2 scope: the mechanism exists (SPEC §5.9 —
+exists-not-ran); the v0.2 deploy uses the currently-active key. The
+rotation is idempotent — `scripts/rotate_spike_key.sh` deactivates the old
+key only after the new one propagates to the consumer's Actions secret
+store, verified by a post-PUT GET; on upload/verify failure the old key is
+left Active and the run exits non-zero. The synced workflow file is
+forge-agnostic (REQ-230): forge base URL / owner / consumer repo come from
+repository secrets (`NOVA_FORGE_*`, `NOVA_CONSUMER_REPO`), not literals.
+
+### §12.10 — Nova-idp Identity Layer (v1.28, current)
+
+Nova owns its identity layer end-to-end. Two (optionally three) Lambda
+functions + four DynamoDB tables + one KMS asymmetric signing key + one
+kyverno-json ABAC policy. **No Cognito, no IAM Identity Center (INV-15).**
+The `nova-cli` Lambda layer carries the Nova wheel + `argon2-cffi` +
+`cryptography` + `pyjwt` + the `kj` Go binary, making the same code
+importable in both the CLI and the Lambda (REQ-329 dual-use, NFR-7).
+
+**Components:**
+
+- `nova-idp-auth` Lambda — sign-up, sign-in, session creation. Argon2id
+  password hashing (D-228: bundled abi3 wheel; fail-closed on
+  `ImportError`, no pure-Python fallback). DynamoDB: `nova-users`
+  (PK `user_id`, Argon2id `password_hash`), `nova-sessions` (PK
+  `session_id`, TTL `expires_at`), `nova-password-resets` (PK
+  `reset_token`, TTL 15m). Function URL with IAM auth.
+- `nova-idp-token-vend` Lambda — accepts a PAT (or session token),
+  validates revocation (`nova-pats.GetItem(jti, ConsistentRead=True)` —
+  D-229, 60s SLO), evaluates the kyverno-json ABAC policy at
+  `platform/abac/token-vend.policy` (D-227, INV-17), KMS-signs an
+  ECDSA P-256 JWT (`ES256`), converts DER→raw ECDSA signature (RFC 7515
+  §3.1.3), returns the OIDC token. The `policy_version` (git SHA,
+  D-231) is recorded in every `token.vend.allowed/denied` audit event.
+- `nova-idp-jwks` Lambda (optional, separation of concerns) — function
+  URL with `AuthType: NONE` (public key only), `Cache-Control: max-age=3600`.
+  `kms.get_public_key` → DER SPKI → JWK via `cryptography`. Custom
+  domain + WAF via CloudFront is OPTIONAL (`--public-jwks-domain` flag
+  on `nova idp setup`, D-230).
+- `nova-pats` DynamoDB table — PK `jti`, GSI1 `sub` (list PATs for
+  user), GSI2 `pat_hash` (lookup by hash). Only the hash stored (not
+  raw PAT, REQ-343). Revoked PATs retained for audit.
+
+**CLI surface (`nova` package, greenfield):**
+
+- Entry point: `[project.scripts] nova = "nova.cli:main"` (argparse-only,
+  no click/typer — repo convention). `nova/cli.py` auto-discovers
+  `nova/<module>.py` subcommands via `pkgutil.iter_modules`, dispatches,
+  emits the `cli.invocation` audit event (INV-12) with `mode`,
+  `selection_reason`, `credential_type`, `command`, `args`.
+- Each `nova/<module>.py` is ≤50 lines, delegates to `core/` (CAP-034
+  AST scan). Subgroups: `nova auth login/revoke/status`, `nova idp
+  setup --check/--apply/--verify`, `nova init`, `nova apply --local`.
+- `core/mode_resolver.py` — flag → env (`NOVA_CLIENT_MODE`) → credential
+  type → `sys.stdin.isatty()` (D-226). CLI-only; Lambdas don't resolve
+  modes. Property-tested with `hypothesis` (REQ-349).
+- `core/env.py:+synthesize_local_env()` — synthesizes a local env dict
+  from a contract + `--local` flag (REQ-330). No cloud provisioning.
+
+**Packaging (NFR-6, CAP-035):**
+
+- CI publishes a wheel to CodeArtifact AND a Lambda layer with identical
+  version strings on every merge affecting `core/`/`adapters/`/`nova/`.
+  Version mapping recorded in SSM `/nova/layer/nova-cli/version`.
+  If either publish fails, the merge is blocked (REQ-323).
+- `nova cli-action` composite action at
+  `.github/actions/nova-cli/action.yml`, referenced by both GitHub +
+  Gitea (`uses: continuous-intelligence/acdl/.github/actions/nova-cli@v1.28`).
+  Python 3.12 pinned. Byte-identical behavior verified by CI matrix
+  (REQ-326, NFR-11).
+
+**Data flows:**
+
+1. Sign-up → `nova-idp-auth` → Argon2id → `nova-users` PutItem → session
+   → `nova-sessions` PutItem → return session token.
+2. Token vend (hot path) → `nova-idp-token-vend` → `nova-pats` strong
+   read (revocation) → kyverno-json ABAC eval → if allow → KMS sign →
+   DER→raw → return OIDC JWT. Audit at every step.
+3. JWKS fetch → `nova-idp-jwks` → `kms.get_public_key` → DER→JWK →
+   `{"keys":[...]}`. Cached 1h at CloudFront (if custom domain) / client.
+4. PAT revoke → `nova auth revoke --pat <jti>` → `nova-pats.UpdateItem(
+   status=revoked)` → audit. Strong read on next vend → 403 (within 60s).
+
+**`nova idp setup` (REQ-340, NFR-10):** generates a CloudFormation
+template (raw dict → JSON, no troposphere dep), presents for review
+(`$PAGER` + resource summary), requires explicit `y/N` approval before
+`cloudformation deploy --capabilities CAPABILITY_IAM`. `--check` reports
+prerequisites + IAM policy delta; `--verify` runs the KMS round-trip
+test. New IAM grants required: `cloudformation:*`, `codeartifact:*`.

.ciagent/CHECKPOINT.json

@@ -1,9 +1,19 @@
 {
-  "phase": 0,
+  "phase": 3,
-  "stage": "grill",
+  "stage": "complete",
-  "milestone": "v1.23",
+  "milestone": "v1.28",
-  "phase_role": "pre_execution",
+  "phase_role": "execution",
   "attempts": 0,
-  "updated_at": "2026-08-11T23:30:00Z",
+  "updated_at": "2026-08-19T22:30:00Z",
-  "project": "acdl"
+  "project": "acdl",
+  "projects": ["acdl", "nova-blockchain-exchange"],
+  "active_milestone": "v1.28",
+  "milestone_branch": "milestone/v1.28-cli-identity",
+  "phase_branch": "phase/03-idp-auth",
+  "tag_line": "v1.27.x",
+  "phase_name": "idp-auth",
+  "reqs_covered": ["REQ-333", "REQ-334", "REQ-335"],
+  "caps_verified": ["CAP-036"],
+  "tests": {"p3_specific": 22, "total_passing": 944, "failures": 0},
+  "notes": "v1.28 P3 SHIP. idp-auth complete. Tag v1.27.3. Merged phase/03 -> milestone/v1.28-cli-identity. 3 REQs covered (REQ-333..335), CAP-036 verified. nova-idp-auth Lambda (sign-up/sign-in/session), Argon2id t=3 m=65536 p=1 fail-closed, 4 DDB tables. Next: P4 token-vend-pat (highest-risk, double-length)."
 }

.ciagent/CLARIFY.md

@@ -1,76 +1,276 @@
-# CLARIFY — v1.23 (auto-resolved, full autonomy)
+# CLARIFY — v1.28 CLI Canonicalization + Identity Layer
 
-8 ambiguities identified, all auto-resolved at confidence ≥ 0.6.
+> **Autonomy:** full. Auto-resolution with assumption logging per
-No human escalation (full autonomy). All decisions logged below.
+> `config.autonomy.level: "full"`. No human escalation unless confidence
+> < 0.60. The user-approved re-mapping plan (v1.18 spec → v1.28) resolved
+> the headline discrepancy. This file records the remaining ambiguities
+> and the grounding gaps surfaced in pre-flight.
 
-## C1 — Speaker notes source for HTML comments (conf 0.95)
+---
-**Ambiguity:** The plain `.md` has `> **Speaker notes:**` and
-`> **Transition:**` blocks per slide; talking points live in a separate
-file. Which content goes into the `<!-- ... -->` comments?
-**Resolution:** Extract `> **Speaker notes:**` and `> **Transition:**`
-blocks from the plain `.md` and embed each slide's as
-`<!-- Speaker notes: ... -->` before the next `---` separator. Talking
-points come from `talking-points.md` (the 3-6 bullets per slide)
-embedded as `<!-- Talking points: ... -->`. Both are Marp HTML comments
-(excluded from slide rendering; the `talking-points.md` stays as the
-standalone synced aid).
 
-## C2 — python-pptx dependency placement (conf 0.9)
+## Method
-**Ambiguity:** `pyproject.toml` has `[project.optional-dependencies]`
-`test`. Where does `python-pptx` go?
-**Resolution:** Add a new optional-dependency group
-`slides = ["python-pptx>=0.6.23"]`. Keeps the base `dependencies`
-minimal (the render script is a docs-only concern, not a runtime
-dep). CI installs via `pip install -e .[slides]`. The `render_pptx.py`
-script imports `pptx` at module load (not a hard failure if absent —
-the script prints a clear "pip install -e .[slides]" message and exits
-1).
 
-## C3 — Benefit callout markdown representation (conf 0.9)
+The clarify stage identifies ambiguities in the v1.28 specification and
-**Ambiguity:** Marp markdown can't natively produce arbitrary `<div>`.
+resolves them at full autonomy. The v1.28 spec is the user-provided
-How is the `.benefit` class applied?
+"Universal Feature Specification — v1.18 CLI Canonicalization + Identity
-**Resolution:** Use Marp's HTML-in-markdown support — write benefit
+Layer," re-mapped to v1.28 (milestone number, tag line, and all
-lines as `<div class="benefit">text</div>` directly in the markdown
+ID namespaces) per the user-approved plan. Each ambiguity gets a
-(Marp passes through HTML blocks). The inline `style:` block targets
+decision ID (D-226+, continuing from v1.27's D-214..D-225), a resolution,
-`.benefit`. The `**Benefit:**` prefix is removed.
+a confidence score, and a rationale.
 
-## C4 — Image inlining MIME types (conf 0.95)
+---
-**Ambiguity:** What MIME types does `inline_images.py` handle?
-**Resolution:** The deck references `.png` files only (mermaid
-renders). `inline_images.py` MIME-sniffs by extension:
-`.png`→`image/png`, `.svg`→`image/svg+xml`, `.jpg/.jpeg`→`image/jpeg`,
-`.gif`→`image/gif`; fallback `application/octet-stream`. Only relative
-`src="assets/..."` paths are inlined (absolute/`http(s)://` URLs are
-left alone).
 
-## C5 — render_slides.sh step ordering (conf 0.9)
+## Prior-conversation resolutions (already locked, restated for the record)
-**Ambiguity:** Where do the new inline-images + python-pptx steps go?
-**Resolution:** Step 1 mermaid → PNG (unchanged); Step 2 MARP → HTML +
-PPTX (drop `--theme`); Step 3 inline images into HTML; Step 4
-python-pptx → `*-python.pptx`; Step 5 stage all. The inline step runs
-only on the HTML (not the PPTX — both PPTX formats embed media in
-their zip by construction).
 
-## C6 — "penetrate" absence test scope (conf 0.95)
+These were resolved by the user-approved re-mapping plan in the
-**Ambiguity:** How is "penetrate" absence asserted?
+conversation that spawned v1.28. They are load-bearing for v1.28
-**Resolution:** `grep -ri penetrat docs/presentations/` returns nothing
+execution.
-(covers `.md`, `-marp.md`, `talking-points.md`, `.html`; `.pptx` is
-binary so excluded). A new test `test_no_penetrate_term` asserts this.
 
-## C7 — attach_release_asset.py dual-PPTX (conf 0.85)
+### Q-P1 — The source spec is titled "v1.18" but v1.18 already shipped. What milestone is this?
-**Ambiguity:** Does the release attach both PPTX files?
-**Resolution:** Yes — attach both `.pptx` (MARP image-of-slide) and
-`-python.pptx` (structured). Minimal change: loop over both filenames.
-The MARP PPTX remains the "primary" attachment (first); the python
-PPTX is secondary (comparison artifact).
 
-## C8 — Wave ordering (conf 0.85)
+**Resolution:** Re-map the spec's *content* (CLI Canonicalization +
-**Ambiguity:** Can P1 (consolidate) and P2 (style) parallelize?
+Identity Layer) to **v1.28**, the next milestone after v1.27 (complete).
-**Resolution:** No — both edit `-marp.md` with a serial dependency: P1
+Tags run on the **v1.27.x** line (P0 = `v1.27.0`). Milestone branch:
-establishes the single doc (deletes the plain `.md`, adds HTML-comment
+`milestone/v1.28-cli-identity`.
-speaker notes); P2 edits that single doc's frontmatter + benefit
+**Confidence:** 1.0 (user-confirmed — "Re-map to v1.28"). **Decision:** n/a (milestone identity, not a D-ID).
-callouts. Order: P1 → P2 → (P3 + P4 parallel: P3 edits
+
-`scripts/inline_images.py` + `render_pptx.py` + `render_slides.sh` +
+### Q-P2 — The spec's "locked inputs" (D-NEW-26, kj engine, Nova-idp, INV-63/64/65, CAP-025..030, REQ-001..031) don't exist in the repo. How to handle?
-`pyproject`; P4 edits the deck markdown — zero file overlap) → P5 →
+
-P6. P3 depends on P2's render-script `--theme` drop. P4 depends on
+**Resolution:** Author them fresh in this milestone's CLARIFY/RESEARCH as
-P1's consolidated doc.
+**D-226..D-231, INV-12..17, CAP-033..038, REQ-323..353**. The `kj` engine
+is mapped to the existing **kyverno-json** engine (INV-4 swappable) — no
+new engine is built. CAP/INV/REQ IDs are re-allocated to avoid collisions
+with shipped history (CAP-025..032 and INV-1..11 are blockchain/pilot).
+**Confidence:** 1.0 (user-confirmed — "Re-map to v1.28"). **Decision:** D-227 (kj→kyverno-json), plus the ID-allocation block in REQUIREMENTS.md.
+
+### Q-P3 — The spec claims a "Cognito drop." No Cognito exists in the repo. What does NFR-5 mean?
+
+**Resolution:** NFR-5 (no AWS-managed identity in the path) is a
+**greenfield constraint**, not a migration. Nova-idp is built fresh; no
+Cognito/IAM Identity Center is *introduced*. The "drop" framing is
+aspirational language from the source spec, not a literal removal.
+**Confidence:** 1.0. **Decision:** D-226 (recorded below; NFR-5 restated
+as a greenfield constraint in INV-15).
+
+---
+
+## Open questions from the spec's §7 (auto-resolved at full autonomy)
+
+### Q1 — Argon2 native dependency in Lambda runtime
+
+`argon2-cffi` has a C extension that may not build cleanly in the Lambda
+Python 3.12 runtime.
+
+**Resolution (D-228):** Use `argon2-cffi` with bundled wheels; if the
+extension fails to load, fall back to the pure-Python implementation. If
+both fail, document the Fargate migration path for the auth Lambda.
+CAP-036 covers end-to-end verification.
+**Confidence:** 0.85. **Rationale:** Bundled wheels are the standard
+workaround for Lambda native deps; the pure-Python fallback is a safe
+degradation. Fargate is the escape hatch if Lambda's runtime is
+fundamentally incompatible. RESEARCH will validate wheel availability for
+Python 3.12 + the Lambda execution environment.
+**Impact if wrong:** Auth Lambda migrates to Fargate, adding ~1 week to P2.
+
+### Q2 — PAT revocation propagation latency
+
+The 60-second SLO (NFR-4) depends on whether the token-vend Lambda reads
+PAT revocation state from DynamoDB on every request (eventually
+consistent reads) or via a cached/denylist mechanism.
+
+**Resolution (D-229):** Read-on-every-request with strongly consistent
+reads on the PAT hash table. Cost is acceptable given expected request
+volume (token vending is not a hot path — it precedes a deploy, not every
+request). REV-351 verifies the SLO in CI.
+**Confidence:** 0.90. **Rationale:** Strongly consistent DynamoDB reads
+have single-digit-ms latency at expected volume; the 60s SLO has >10x
+headroom. A cache layer adds invalidation complexity that the SLO does
+not require.
+**Impact if wrong:** If read latency exceeds 60s under load, introduce a
+DynamoDB TTL + cache layer; SLO must be re-verified.
+
+### Q3 — JWKS endpoint: Lambda function URL vs. API Gateway
+
+A function URL is simpler and cheaper but lacks throttling, WAF, and
+custom domains out of the box.
+
+**Resolution (D-230):** Start with a Lambda function URL behind a custom
+domain; rate limiting configured at the DNS/CDN layer. API Gateway
+migration deferred to v1.19+ if throttling requirements grow.
+**Confidence:** 0.80. **Rationale:** The JWKS endpoint is public-key
+only (no secrets); the threat surface is low. Function URL + CDN rate-
+limiting covers the v1.28 volume. API Gateway is over-engineering until
+traffic patterns are known.
+**Impact if wrong:** If throttling becomes a requirement, API Gateway
+migration adds ~3-5 days.
+
+### Q4 — Mode resolver precedence with invalid `NOVA_CLIENT_MODE` value
+
+What happens if the env var is set to something other than `agent` or
+`interactive` (e.g., `NOVA_CLIENT_MODE=auto`)?
+
+**Resolution (D-226):** Invalid env var values are ignored, falling
+through to credential type. A warning is logged. Behavior is documented
+in the `nova-cli` README. This is a sub-clause of the mode-resolution
+priority decision.
+**Confidence:** 0.90. **Rationale:** Ignoring + warning is the least
+surprising behavior for an operator debugging mode issues. Failing hard
+would block legitimate workflows that set a stale/typo'd env var.
+**Impact if wrong:** Operators debugging mode issues may be confused;
+non-blocking.
+
+### Q5 — Service-account PAT vs. developer PAT in the same session
+
+What if both credential types are available (e.g., a developer explicitly
+exports a service-account PAT)?
+
+**Resolution (D-226):** The most recently acquired credential wins.
+Documented in `nova auth login` output. The credential type is what
+drives mode resolution (INV-14), so the operator sees which mode was
+selected and why.
+**Confidence:** 0.85. **Rationale:** "Most recent wins" is the simplest
+deterministic rule that matches operator mental models of "I just logged
+in as X." The audit event records the winning credential type, so the
+selection is traceable.
+**Impact if wrong:** Mode selection may surprise the operator; non-
+blocking, but `nova auth status` must make the active credential explicit.
+
+### Q6 — ABAC policy ownership and versioning
+
+`platform/abac/token-vend.policy` is referenced, but who owns changes?
+How are policy versions tracked in audit?
+
+**Resolution (D-231):** Policy changes require PR review; the policy
+version (git SHA) is recorded in every token-vend audit event. Owner:
+Platform Security. The policy file lives in the platform repo at
+`platform/abac/token-vend.policy` and is reviewed like any other
+production config.
+**Confidence:** 0.90. **Rationale:** Git SHA is the natural version
+identifier for a repo-resident policy; recording it in the audit event
+makes every allow/deny decision reconstructable to the exact policy text.
+**Impact if wrong:** Untracked policy changes could lead to unexpected
+allow/deny decisions in production, undermining audit defensibility.
+
+---
+
+## Grounding gaps surfaced in pre-flight (auto-resolved)
+
+### G1 — The `kj` engine does not exist; the spec treats it as locked.
+
+**Resolution (D-227):** The token-vend Lambda uses the existing
+**kyverno-json** engine (INV-4 swappable) as the ABAC evaluator. The
+policy at `platform/abac/token-vend.policy` is a kyverno-json policy.
+No new `kj` engine is built in v1.28. If a distinct `kj` engine is
+desired later, it is a separate research spike (not this milestone).
+**Confidence:** 0.95. **Rationale:** The repo already has a swappable
+policy engine (INV-4) implemented as kyverno-json. Building a second
+engine to do the same job violates the swappable-engine invariant's
+spirit. kyverno-json's `evaluate` semantics cover the spec's ABAC needs
+(subject, claims, resource, environment → allow/deny).
+**Impact if wrong:** If the user actually wants a new `kj` engine, v1.28
+scope expands significantly (engine design + implementation + migration).
+This was flagged as caveat #3 in the approved plan; the recommended path
+(kyverno-json) is locked here.
+
+### G2 — The spec's INV-18..21, INV-34, INV-63/64/65 don't exist.
+
+**Resolution:** Re-allocated as **INV-12..INV-17** (see REQUIREMENTS.md
+§v1.28 Invariants). The 1:1 mapping:
+- INV-63 (mode observability) → INV-12
+- INV-64 (mode determinism) → INV-13
+- INV-65 (credential type encodes role) → INV-14
+- INV-18..21 (attestation invariants) → INV-15 (no AWS-managed identity),
+  INV-16 (password storage), INV-17 (ABAC discipline). The spec's
+  attestation invariants INV-18..21 are partially covered by existing
+  invariants (INV-6 immutable audit) + INV-17; the JWS-from-PAT behavior
+  (REQ-332) is a requirement, not a separate invariant, in this mapping.
+- INV-34 (MFA enforcement) → deferred to v1.21+ (out of scope per §2.2);
+  no INV allocated in v1.28.
+**Confidence:** 0.85. **Rationale:** The mapping preserves the spec's
+intent without colliding with the repo's INV-1..11. INV-34 (MFA) is
+explicitly deferred per the spec's own §2.2 out-of-scope table.
+**Impact if wrong:** If the user wants the exact INV-18..21 semantics as
+separate invariants, INV-12..17 can be re-numbered; non-blocking.
+
+### G3 — The spec's CAP-025..030 collide with blockchain/pilot CAPs.
+
+**Resolution:** Re-allocated as **CAP-033..CAP-038** (see REQUIREMENTS.md
+§v1.28 + REQ-352). The 1:1 mapping:
+- CAP-025 (CLI subcommand surface) → CAP-033
+- CAP-026 (subcommand delegates to core/) → CAP-034
+- CAP-027 (layer matches wheel) → CAP-035
+- CAP-028 (Nova-idp auth flow) → CAP-036
+- CAP-029 (token-vend signs via KMS) → CAP-037
+- CAP-030 (PAT issuance + revocation) → CAP-038
+**Confidence:** 1.0. **Rationale:** Existing CAP-025..032 are
+blockchain/pilot capabilities (STATE.md); re-use would corrupt the
+capability registry. The re-allocated IDs are the next available.
+**Impact if wrong:** None — this is a numbering decision, not a semantic
+one.
+
+### G4 — The spec's REQ-001..031 collide / don't exist.
+
+**Resolution:** Re-allocated as **REQ-323..REQ-353** (1:1 with the spec's
+REQ-001..031). Full text in REQUIREMENTS.md §v1.28. Max existing REQ =
+REQ-322.
+**Confidence:** 1.0. **Rationale:** Same as G3 — avoid collision, use
+next available range.
+
+### G5 — `platform/abac/`, `nova/` subcommand dir, `nova-idp-*` Lambdas don't exist.
+
+**Resolution:** These are **greenfield deliverables** of v1.28 execution
+phases, not pre-existing "locked architectures." RESEARCH will design
+them; PLAN will sequence them; EXECUTE will build them. The spec's
+"Operating Principle 1" (incremental delivery) is honored — v1.28 is
+net-new work.
+**Confidence:** 1.0. **Rationale:** The spec itself describes these as
+new ("introducing Nova-idp"). The mis-framing was in calling them
+"locked" — they are locked in *scope*, not in *prior existence*.
+**Impact if wrong:** None — this is a framing correction.
+
+---
+
+## Decision ledger (v1.28 — D-226..D-231)
+
+| ID | Title | Confidence | Load-bearing for |
+|----|-------|------------|------------------|
+| D-226 | Mode resolution priority + invalid-env + dual-credential | 0.90 | REQ-327, INV-12, INV-13, INV-14 |
+| D-227 | ABAC engine = kyverno-json (no `kj` engine built) | 0.95 | REQ-336, REQ-339, INV-17, NFR-9 |
+| D-228 | Argon2id in Lambda: bundled wheels + pure-Python fallback + Fargate path | 0.85 | REQ-333, REQ-334, INV-16, NFR-8 |
+| D-229 | PAT revocation: strongly-consistent DDB read-on-every-request, 60s SLO | 0.90 | REQ-342, REQ-343, REQ-351, NFR-4 |
+| D-230 | JWKS endpoint: Lambda function URL + custom domain + CDN rate-limit | 0.80 | REQ-338, NFR-5 |
+| D-231 | ABAC policy ownership: Platform Security, git SHA in audit | 0.90 | REQ-339, NFR-9 |
+
+---
+
+## Assumptions logged (full autonomy, no human escalation)
+
+1. **CodeArtifact is provisionable** in AWS account `581513795199` (the
+   pilot account). RESEARCH will confirm IAM permissions + repository
+   creation. If not, v1.28 falls back to a private PyPI server or a
+   Gitea-hosted wheel index; the CLI subcommand surface (REQ-324) and
+   identity layer (REQ-333+) are unaffected.
+2. **Python 3.12** is the target runtime for both the CLI wheel and the
+   Lambda functions (spec §4 REQ-004.3). The repo's current Python
+   version will be confirmed in RESEARCH; if it differs, the CLI pins
+   3.12 and Lambda uses the 3.12 runtime regardless.
+3. **KMS asymmetric signing** (RSA-2048 or ECDSA P-256) is available in
+   the target account. RESEARCH will confirm. If only symmetric KMS is
+   available, the token-vend Lambda uses symmetric signing + a public-key
+   publication step (less ideal, but functional); INV-15 is unaffected.
+4. **The Forge action** (REQ-326) is the existing `nova cli-action`
+   pattern, extended to both GitHub and Gitea marketplaces. The repo's
+   current Forge/Gitea workflow conventions (`.gitea/workflows/`,
+   `deploy.yml@v1.25`) are the baseline.
+5. **MFA/TOTP** code path ships in v1.28 (per spec §2.2) but enforcement
+   for prod/dr is deferred to v1.21+. This is a doc/test-only path in
+   v1.28 — no enforcement gate.
+
+---
+
+## CLARIFY complete
+
+All material ambiguities resolved at full autonomy (6 open questions +
+5 grounding gaps → D-226..D-231, confidence ≥ 0.80). No human escalation
+triggered (all confidences ≥ 0.60 threshold). REQUIREMENTS.md updated
+with the decision ledger + invariants. Next: RESEARCH.

.ciagent/GRILL.md

@@ -1,207 +1,110 @@
-# CIAgent Grill Report
+# GRILL — v1.28 CLI Canonicalization + Identity Layer
 
-## Run: 2026-08-12 (mode: interactive, focus: all axes) — v1.23 Nova Deck Cleanup & Python PPTX
+> Adversarial review of the v1.28 SPECIFY + CLARIFY + RESEARCH + PLAN.
-
+> Griller: ci-griller subagent. Autonomy: full. All 9 axes reviewed;
-### Overall Verdict: PROCEED-WITH-REVISIONS  (confidence: 0.78)
+> every claim verified against the live codebase.
-
-The plan is fundamentally sound — the empirical checks (image format, Marp
-`<div>` passthrough, versioning, test-inversion completeness) all pass. But
-four binding revisions restructure the wave/phase plan and expand the
-"penetrate" purge scope. Two axes were escalated-but-resolved (the empirical
-verifications de-risked P2 and P3). The plan proceeds with the revisions
-below.
 
 ---
 
-### Per-Axis Findings
+## Overall verdict: **PROCEED-WITH-CONDITIONS** · Confidence 0.76
 
-#### Axis 1 — Scope / over-reach: PASS (conf 0.80)
+The plan is fundamentally sound — architecture correct, re-mapping
-Building a whole new `render_pptx.py` + markdown parser is significant for a
+clean (no ID collisions), technical depth accurate (DER→raw, strong-
-"deck cleanup" milestone, but REQ-269 explicitly mandates it, the milestone
+read revocation, stdin TTY), highest-risk item (kj binary) has a
-is NFR docs/render/test-only (no runtime impact), and the dual-PPTX value
+Fargate fallback. Not unfeasible, not over-scoped beyond an agent-driven
-(MARP image-of-slide + python structured/editable) is a real deliverable, not
+repo's capacity, not security-broken by design.
-gold-plating. The G-003 split (P3a/P3b) mitigates the parser-complexity risk.
-The plan stays in scope; it does not reach into the deck's 4-beat narrative
-arc (out-of-scope section confirms).
 
-#### Axis 2 — Hidden dependencies (P3/P4 "zero file overlap"): REVISE → G-002 (conf 0.85)
+**3 critical conditions (must-fix before P1) + 16 tracked conditions.**
-The "zero file overlap" claim is true for EDITS but false for VERIFICATION.
+No escalations (all axes ≥ 0.70 confidence).
-P3's `render_pptx.py` parsing logic depends on the deck markdown structure
-that P4 is simultaneously trimming; P4's verify step runs `render_slides.sh`
-that P3 is mid-editing. **Binding revision G-002:** serialize P3→P4.
-
-#### Axis 3 — Test inversion risk: PASS (conf 0.92)
-The plan's test-update list (Finding 5 / P5 tasks) is complete and accurate.
-Empirically confirmed all affected tests:
-- `test_marp_deck_not_using_default_theme` (line 66-74: invert — we now USE
-  `theme: default`) ✓ plan mentions
-- `test_marp_deck_uses_sp_theme` (line 55-64: rewrite to assert inline `style:`
-  block) ✓ plan mentions
-- `test_theme_css_*` trio (lines 275, 284, 295: retarget to inline `style:`) ✓
-- `test_html_embeds_theme` (line 353: `--sp-red` → `#D6002A`) ✓ plan mentions
-- `test_source_md_*` pair (lines 240, 266: delete — plain `.md` gone) ✓
-- `test_render_slides_script_renders_marp` (line 92: still produces `.pptx`
-  via marp-cli for the fallback PPTX) — ✓ plan handles
-- No latent assertions missed. The plan's enumeration is thorough.
-
-#### Axis 4 — Image-inlining correctness: PASS (conf 0.95)
-Empirically verified the rendered HTML at
-`docs/presentations/nova-autonomous-cloud-delivery.html` uses plain
-`<img src="assets/png/platform-pipeline.png" ...>` and
-`<img src="assets/png/telemetry-live-ops.png" ...>` — standard `<img>` tags
-inside Marp's SVG `<foreignObject>` wrapper. Zero `xlink:href` occurrences.
-The `inline_images.py` regex (`<img\s+src="([^"]+)"`) will match. The 2
-`data:image` matches already in the HTML are Marp OSC onscreen-control SVG
-icons (CSS backgrounds, not slide images) — not a conflict. **P0 risk
-cleared.**
-
-#### Axis 5 — python-pptx parser complexity: REVISE → G-003 (conf 0.80)
-The parser must handle 10+ distinct markdown constructs (frontmatter, `---`
-separators, H1/H2, bullets, bold leads, blockquotes, fenced code, images,
-markdown tables, `<div class="benefit">` HTML blocks) plus edge cases
-(tables with `**bold**` R/A cells, nested bullets, `class:tall` image alt
-text) plus two python-pptx constraints (no CSS font fallback — single
-`font.name`; blank layout has no bullets — must inject `<a:buChar>` XML).
-Finding 3 confirmed the APIs exist but the parser is non-trivial. With P3
-on the serial critical path (G-002), an overflow blocks everything.
-**Binding revision G-003:** split P3 into P3a (inline_images + render_slides.sh
-+ pyproject — low-risk mechanical) and P3b (render_pptx.py + parser + the
-attach_release_asset.py extension — high-risk).
-
-#### Axis 6 — Benefit callout `<div>` in Marp: PASS (conf 0.95)
-Empirically verified by rendering a minimal test deck through
-`@marp-team/marp-cli@4.5.0` (the pinned version): `<div class="benefit">text</div>`
-passes through verbatim into the rendered `<section>`. Marpit's `html: true`
-option is on by default; no sanitization of styling divs. The `.benefit` class
-in the inline `style:` block will apply. P2's restyle approach is valid.
-**P0 risk cleared.**
-
-#### Axis 7 — "penetrate" removal completeness: REVISE → G-001 (conf 0.85)
-CRITICAL gap. The plan's verify step `grep -ri penetrat docs/presentations/`
-misses `docs/scope.md` (line 16: "Nova never penetrates the PDLC") and
-`docs/vision.md` (line 18: "It does not penetrate upstream product or
-software development lifecycles") — the repo's two core strategic docs. The
-term also appears in every `.ciagent/` file (PLAN, REQUIREMENTS, RESEARCH,
-CLARIFY, ROADMAP, PROJECT, PERSONAS, NORTH_STAR). The deck does not link out
-to these docs, but they are audience-reachable via the repo.
-**Binding revision G-001:** purge "penetrate" (and derivatives) from the
-entire repo — `docs/` AND `.ciagent/`. P4's verify step becomes
-`grep -ri penetrat docs/ .ciagent/` returns nothing. `test_no_penetrate_term`
-asserts the same. The deleted plain `.md` (P1) already removes its
-occurrence; `docs/scope.md` + `docs/vision.md` reworded in P4; all
-`.ciagent/` files reworded across the relevant phases (the phase that owns
-each file's edit window).
-
-#### Axis 8 — Wave 3 parallelization feasibility: REVISE → G-002 (conf 0.85)
-Resolved by G-002 (serialize P3→P4). Wave 3 is no longer parallel. P3's
-`render_slides.sh` is stable before P4 runs its verify render; P3's parser
-is tested against the current (untrimmed) deck before P4 trims it.
-
-#### Axis 9 — Phase count vs. value: REVISE → G-004 (conf 0.80)
-G-003 split P3 (→8 phases); G-004 merges P5+P6 to compensate. P6
-(final-review-ship) for an NFR docs-only milestone is largely ceremonial —
-the review/audit/ship work folds into P5's final commits. **Binding revision
-G-004:** merge P5+P6. Net phase count returns to 7.
-
-#### Axis 10 — Versioning: PASS (conf 0.95)
-`git tag --list 'v1.22.*'` returns nothing — no conflicts. The v1.21.x line
-(v1.21.0..v1.21.6) is the precedent; v1.23 tags v1.22.0..v1.22.6 per the
-revised phase plan (G-003 split shifts tag numbers; G-004 merge keeps the
-final at v1.22.6).
 
 ---
 
-### Binding Decisions
+## Axis verdicts
 
-| ID | Decision | Confidence | Rationale |
+| Axis | Verdict | Confidence | Critical condition |
-|----|----------|-----------|----------|
+|------|---------|-----------|-------------------|
-| G-001 | Purge "penetrate" (and derivatives) from the entire repo — `docs/` AND `.ciagent/`, not just `docs/presentations/`. P4 verify: `grep -ri penetrat docs/ .ciagent/` returns nothing. `test_no_penetrate_term` asserts the same. `docs/scope.md:16` + `docs/vision.md:18` reworded in P4; all `.ciagent/` files reworded in the phase that owns each file's edit window. | 0.85 | The term appears in the repo's two core strategic docs (audience-reachable) and all internal metadata. REQ-272 says "removed from all presentation files"; the user confirmed a full-repo purge (politically loaded term). The plan's `docs/presentations/`-only grep is a gap. |
+| §1 Feasibility | PROCEED-WITH-CONDITIONS | 0.82 | C-1.1 KMS asym verify; C-1.2 Argon2 fail-closed test |
-| G-002 | Serialize P3→P4. Wave 3 is no longer parallel. P3 completes (stable `render_slides.sh` + tested parser against the current deck) before P4 trims the deck + purges "penetrate" (per G-001). C8's parallelization rationale is overruled. | 0.85 | "Zero file overlap" is true for edits but false for verification: P3's parser depends on the deck structure P4 is trimming; P4's verify render depends on P3's `render_slides.sh` being stable. The interaction risk is the failure mode. |
+| §2 Scope | PROCEED-WITH-CONDITIONS | 0.74 | C-2.1 fold P5 into P4; C-2.2 P4 overload |
-| G-003 | Split P3 into P3a (inline_images.py + render_slides.sh inline-images step + pyproject.toml — low-risk mechanical) and P3b (render_pptx.py + the full markdown parser + render_slides.sh python-pptx step + attach_release_asset.py extension — high-risk). Both serial in Wave 3. | 0.80 | The parser handles 10+ markdown constructs + python-pptx XML constraints (font fallback, bullet injection); on the serial critical path (G-002) an overflow blocks everything. Splitting isolates the high-risk work. |
+| §3 Cost | PROCEED-WITH-CONDITIONS | 0.70 | C-3.1 cost estimate; C-3.2 CodeArtifact P1 task |
-| G-004 | Merge P5+P6. P5 absorbs the final-review/audit/ship work (multi-persona review, reconstruction audit, milestone merge, tag, release, branch cleanup, REQUIREMENTS/ROADMAP update) as its final commits. Tag v1.22.6 = milestone release. | 0.80 | For an NFR docs-only milestone, a dedicated review/ship phase is ceremonial overhead. P5 already asserts the final state via tests. The merge compensates for the G-003 split, returning to 7 phases. |
+| §4 Schedule | PROCEED-WITH-CONDITIONS | 0.76 | C-4.1 P4 critical path; C-4.2 per-phase exit |
-
+| §5 Technical Depth | PROCEED-WITH-CONDITIONS | 0.80 | C-5.1 ABAC shape; **C-5.2 JWS KDF** |
-### Escalations
+| §6 Operational Readiness | PROCEED-WITH-CONDITIONS | 0.72 | **C-6.1 ABAC fail-closed**; C-6.2 threat model; C-6.3 ops guide |
-
+| §7 Security Posture | PROCEED-WITH-CONDITIONS | 0.73 | **C-7.1 ABAC fail-closed**; C-7.2 Argon2 params; C-7.3 cred file |
-None. All axes resolved at confidence ≥ 0.78. Two axes (4 and 6) were
+| §8 Dependency Risk | PROCEED-WITH-CONDITIONS | 0.83 | C-8.1 CodeArtifact P1; C-8.2 pin kj version |
-escalation candidates (P0 risks if the empirical checks failed) but both
+| §9 Re-mapping Integrity | PROCEED-WITH-CONDITIONS | 0.84 | **C-9.1 traceability fix**; C-9.2 INV audit |
-were cleared by direct verification — the rendered HTML uses plain `<img
-src="assets/...">` (not SVG xlink:href), and Marp 4.5.0 passes through
-`<div class="benefit">` verbatim (empirically confirmed with a minimal test
-deck).
 
 ---
 
-### Revised Wave/Phase Plan (post-revisions)
+## Critical conditions (the 3 must-fix-before-P1)
 
-```
+### 🔴 C-6.1 / C-7.1 — ABAC fail-closed
-Wave 1 (P1):        consolidate-docs (edits -marp.md, deletes plain .md)
+The token-vend Lambda's behavior on `kj` absence/error is unspecified.
-   ↓
+Without fail-closed, INV-17 is documentation, not a runtime guarantee —
-Wave 2 (P2):        restore-clean-style (edits -marp.md frontmatter +
+a `kj` load failure would bypass the ABAC gate (every PAT gets a token).
-   ↓                benefit callouts; edits render_slides.sh; retires
+**Fix applied to PLAN.md P4 Wave 4 Task 4.1:** "If
-                    nova-sp-theme.css from render)
+`KyvernoJsonEngine.is_configured()` returns false or `evaluate()`
-   ↓
+raises, return 403 + audit `token.vend.denied` (reason:
-Wave 3 (P3a → P3b, serial):
+`abac_eval_failed`). Never fail open. Test: `tests/test_abac_fail_closed.py`."
-   P3a: inline-images (inline_images.py + render_slides.sh step + pyproject)
-    ↓
-   P3b: python-pptx-generator (render_pptx.py + parser + render_slides.sh
-        step + attach_release_asset.py extension)
-   ↓
-Wave 4 (P4):        trim-wordcount + purge "penetrate" (edits -marp.md +
-   ↓                talking-points.md + docs/scope.md + docs/vision.md +
-                    all .ciagent/ files per G-001)
-   ↓
-Wave 5 (P5+P6 merged): ci-tests-readme + final-review-ship (tests, CI,
-                      README, multi-persona review, audit, ship —
-                      tag v1.22.6 = milestone release)
-```
 
-### Revised Tag Plan
+### 🔴 C-5.2 — JWS-from-PAT key derivation
+REQ-332's AC ("public key derivable from the PAT") is unimplementable
+without a specified KDF. A PAT is a JWT, not a keypair.
+**Fix applied to PLAN.md P2 Wave 2 Task 2.3 + REQ-332 AC:** the JWS
+uses HMAC-SHA256 with a key derived via
+`HKDF-SHA256(PAT_bytes, salt='nova-local-attestation', info='jws-signing-key')`
+→ 32-byte symmetric key. The "public key derivable" AC is re-interpreted:
+the *verification key* is derived from the PAT via the same KDF (the
+PAT is the shared secret). This is a symmetric scheme, not asymmetric.
 
-- v1.22.0 (P0 — already tagged)
+### 🔴 C-9.1 — Traceability drift
-- v1.22.1 (P1)
+REQUIREMENTS.md §v1.28 traceability table mapped 16 REQs to P2;
-- v1.22.2 (P2)
+PLAN.md splits them across P2/P3/P4/P5/P6. **Fix applied to
-- v1.22.3 (P3a)
+REQUIREMENTS.md** — traceability table updated to match PLAN.md phase
-- v1.22.4 (P3b)
+structure.
-- v1.22.5 (P4)
-- v1.22.6 (P5+P6 merged — final patch = milestone release)
-
-### P4 expanded scope (per G-001)
-
-P4 now owns, in addition to the deck word-count trim:
-- `docs/scope.md:16` — reword "Nova never penetrates the PDLC"
-- `docs/vision.md:18` — reword "It does not penetrate upstream product or
-  software development lifecycles"
-- `.ciagent/PLAN.md`, `REQUIREMENTS.md`, `RESEARCH.md`, `CLARIFY.md`,
-  `ROADMAP.md`, `PROJECT.md`, `PERSONAS.md`, `NORTH_STAR.md` — reword every
-  "penetrate" occurrence (or the phase that owns each file's edit window
-  does so; P4 is the natural owner since it owns the "penetrate" removal
-  requirement REQ-272).
-
-### P5 expanded scope (per G-004)
-
-P5 now owns, in addition to the test/CI/README work:
-- Multi-persona code review (`ciagent-review`) of the milestone branch
-- Audit (`ciagent-audit`) — reconstruction test + .ciagent discipline
-- Milestone ship (`ciagent-ship`) — merge to milestone branch → main, tag
-  v1.22.6, release with both PPTX attached, delete milestone branches
-- Update REQUIREMENTS.md (mark v1.23 complete) + ROADMAP.md (mark v1.23
-  complete)
-- Commit: `docs(milestone): complete v1.23 — Nova Deck Cleanup & Python PPTX`
 
 ---
 
-### Evidence Index
+## Tracked conditions (16 — applied to PLAN.md as amendments)
 
-- Image format: `docs/presentations/nova-autonomous-cloud-delivery.html`
+- **C-1.1** KMS asymmetric key verification before P4 Wave 3 (one
-  grep — 2× `<img src="assets/png/...">`, 0× `xlink:href`
+  `aws kms create-key --key-spec ECC_NIST_P256` call).
-- Marp `<div>` passthrough: minimal test deck rendered through
+- **C-1.2** Argon2 fail-closed test in P3 Wave 2 (Lambda returns 503
-  `@marp-team/marp-cli@4.5.0` → `<div class="benefit">` survives verbatim
+  on `ImportError`, not a crash or pure-Python hash).
-- Versioning: `git tag --list 'v1.22.*'` → empty (no conflicts)
+- **C-2.1** Fold P5 (idp-setup) into P4 as P4 Wave 8 → **reduces to 6
-- "penetrate" occurrences: `grep -riI penetrat` → docs/scope.md:16,
+  execution phases** (P1..P6, P7 = final). Applied.
-  docs/vision.md:18, docs/presentations/{-marp.md, .html, .md,
+- **C-2.2** P4 is a double-length phase; acknowledged in P4 header.
-  -talking-points.md}, all .ciagent/*.md
+- **C-3.1** Cost envelope subsection added to PLAN.md.
-- Test inversion targets: tests/test_slides_pipeline.py lines 55-64
+- **C-3.2 / C-8.1** CodeArtifact provisioning = P1 Wave 0 task with
-  (rewrite), 66-74 (invert), 240-270 (delete), 275-302 (retarget), 353-359
+  binary go/no-go gate; Gitea wheel index fallback documented.
-  (assert #D6002A not --sp-red)
+- **C-4.1** P4 flagged as critical-path phase (kj spike = highest-
-- Benefit callout count: 21 `**Benefit:**` in current deck → 21
+  probability schedule slip; Fargate = +1 week).
-  `<div class="benefit">` in P2
+- **C-4.2** Per-phase exit criteria added to PLAN.md.
+- **C-5.1** `requested_claims` = list of claim names (the policy
+  asserts the subject is *allowed* to request those claims).
+- **C-6.2** Threat model (REQ-347) adds: JWKS DDoS surface, PAT theft
+  + max TTL (≤24h dev, ≤1h service-account), ABAC fail-closed,
+  INV-18..21 compression audit.
+- **C-6.3** Operator guide (REQ-345) adds: KMS rotation, layer update,
+  PITR restore, emergency PAT revocation.
+- **C-7.2** Argon2id parameters: t=3, m=65536 KiB, p=1 (OWASP min).
+- **C-7.3** `~/.nova/credentials.json` stores OIDC token + PAT metadata
+  (jti, exp, type), NOT the raw PAT.
+- **C-8.2** `kj` pinned to a specific release + SHA256 recorded.
+- **C-9.2** Threat model includes INV-18..21 compression audit
+  (verify spec's attestation invariant semantics are captured by
+  INV-15/16/17 + REQ-332).
+
+---
+
+## Escalations
+
+None. All 9 axes resolved at confidence ≥ 0.70. No human escalation
+required (full autonomy).
+
+---
+
+## Grill complete
+
+The plan proceeds with the 3 critical fixes and 16 tracked conditions
+applied to PLAN.md + REQUIREMENTS.md. The binding decisions above are
+the authoritative grill record. Next: MVP/UX CHECK → SHIP phase 0.

.ciagent/IAM_POLICY.md

@@ -56,7 +56,8 @@ and covered by the baseline test.
 ## OIDC act_runner role (CAP-022, Phase 56)
 
 The OIDC role for the Gitea `act_runner` was created in Phase 08 and
-gone since (CAPABILITY_INVENTORY.md CAP-022). Phase 56 re-creates it
+gone since (`archive/CAPABILITY_INVENTORY-v1.10.md` CAP-022, archived
+v1.27). Phase 56 re-creates it
 with a trust policy for the Gitea runner ARN. The role grants the
 spike-runner-equivalent permissions to the runner via `sts:AssumeRole`,
 so the runner does not need a long-lived access key. This closes the
@@ -73,7 +74,7 @@ bootstrap root key; the runner then assumes the role.
 
 The OIDC role for the Gitea `act_runner` was planned in Phase 08 but
 never created (the spike used a long-lived key per D-039 waiver).
-CAPABILITY_INVENTORY.md CAP-022 recorded "iam:ListRoles shows no acdl*
+`archive/CAPABILITY_INVENTORY-v1.10.md` CAP-022 recorded "iam:ListRoles shows no acdl*
 roles." Phase 56 re-created the role:
 
 - **Role name:** `acdl-act-runner-role`

.ciagent/IDEATE.md

@@ -0,0 +1,194 @@
+# IDEATE — v1.26 Live Pilot Estate Activation
+
+> **Autonomy:** full. 3-tier ideation per `config.json ideation.enabled:
+> true`. `cross_project.enabled: false` → cross-project tier scoped to
+> multi-project (deferred ideas only, no cross-project candidates
+> accepted). `confidence_threshold: 0.6`, `max_ideas: 20`.
+> Categories: security, quality, architecture, coverage, improvement.
+
+## Tier 1 — Mechanical (pattern-driven, codebase-grounded)
+
+### I1 — Outcome-backfill emitter ✅ ACCEPTED (REQ-317)
+
+**Category:** quality, coverage
+**Confidence:** 0.92
+**Pattern:** stuck `pending` status → backfilled from a later event
+(the most direct metric-grounding pattern).
+**Source:** `core/metrics/decision_ledger.py:210-211` documents the
+event chain `confidence.computed → ai.decision.made →
+attestation.recorded → run.completed/failed`. `collector.py:262`
+inserts `fact_decision.outcome` as `"pending"` — no backfill step
+wires `run.completed/failed` back into the decision's outcome. The AI
+Decision Accuracy metric (`trust_snapshot.py:70-85`) reads
+`decisions WHERE outcome='succeeded' ÷ total` → 0% today (all pending).
+**Idea:** `core/metrics/outcome_backfill.py` reads run-manifest
+`completed`/`failed` events and updates `fact_decision.outcome` +
+`fact_decision.backfilled_at`. The collector invokes backfill after run
+completion. Grounds AI Decision Accuracy (Post-Pilot target).
+**Accepted into:** REQ-317. Phase P3.
+
+### I2 — `reason='confidence'` escalation tag ✅ ACCEPTED (REQ-318)
+
+**Category:** quality, coverage
+**Confidence:** 0.90
+**Pattern:** boolean field → discriminated field (the metric-numerator
+precision pattern).
+**Source:** `core/confidence_signal.py:184` — a `block` band sets
+`human_override=True`. The Human Escalation Frequency metric
+(`docs/metrics/human_escalation_frequency.md:11-12`) is defined as
+`count(runs WHERE hitl_block=1 AND reason='confidence') ÷ total runs`.
+The `reason='confidence'` discriminator is not stored today.
+**Idea:** `ai.decision.made` gains `escalation_reason: 'confidence'`
+when `band == 'block'`. The collector persists it into `fact_run`.
+Grounds Human Escalation Frequency numerator.
+**Accepted into:** REQ-318. Phase P3.
+
+### I3 — Env-JSON `state_backend` wiring reconciliation ✅ ACCEPTED (REQ-319)
+
+**Category:** architecture, improvement
+**Confidence:** 0.88
+**Pattern:** unused config field → wired config field (the
+single-source-of-truth pattern).
+**Source:** `adapters/terraform/adapter.py:116-117` computes the state
+bucket as `nova-tfstate-<AWS_ACCOUNT_ID>-us-east-1` from the
+`AWS_ACCOUNT_ID` env var — **not** from the env JSON's
+`state_backend.bucket`. The env JSON's `state_backend` field is
+currently unused by the live apply path.
+**Idea:** The adapter reads `env.state_backend.bucket` when present
+(falling back to the computed name for backwards compat). `dev.json`
+gets the real bucket name. Closes the wiring gap so the pilot's env
+JSON is the single source of truth.
+**Accepted into:** REQ-319. Phase P3.
+
+### I4 — Pilot-readiness kyverno-json policy ✅ ACCEPTED (REQ-320)
+
+**Category:** security, architecture
+**Confidence:** 0.85
+**Pattern:** runtime guard → declarative policy (the v1.25 thesis
+applied to pilot onboarding).
+**Source:** `core/environment_check.py:48-53` emits a stderr warning
+(non-fatal) when `account_id == "000000000000"` and env != dev. A
+warning is not a gate. The pilot should fail-closed if someone tries
+to apply against a placeholder account.
+**Idea:** A kyverno-json policy over the env JSON asserting
+`account_id != "000000000000"` before any apply. Declarative
+fail-closed gate. Extends v1.25's policy engine to the pilot-onboarding
+domain.
+**Accepted into:** REQ-320. Phase P3.
+
+## Tier 2 — Backend-enriched (signal-driven)
+
+### I5 — Settlement-finality kyverno-json policy ✅ ACCEPTED (REQ-315)
+
+**Category:** security, coverage
+**Confidence:** 0.82
+**Pattern:** domain invariant → declarative policy (the v1.25 thesis
+applied to the securities domain — the most novel use of kyverno-json
+in v1.26).
+**Source:** The pilot's settlement service records matches as
+transactions on the chain; settlement finality = block commit. The
+NORTH_STAR Objective #2 (provable trust) says trust should be a policy
+artifact, not a promise. Today settlement finality is a runtime
+property of the chain; making it a declarative policy turns it into an
+auditable gate.
+**Idea:** A kyverno-json policy over the settlement-service status JSON
+asserting `all_committed: true` before any promotion (qa→prod). The
+securities-specific extension of v1.25's policy engine. The policy is
+skip-when-kj-absent (graceful).
+**Accepted into:** REQ-315. Phase P3.
+
+### I6 — Pilot-estate regression capability (CAP-025) ✅ ACCEPTED (REQ-316)
+
+**Category:** quality, coverage
+**Confidence:** 0.88
+**Pattern:** manual e2e → regression-gated capability (the v1.0 CAP
+pattern applied to the pilot).
+**Source:** `core/regression_verify.py` has CAP-013..024 (live-AWS +
+local tiers). The pilot estate is a new live-AWS capability —
+"contract resolve → adapter compile → terraform plan → policy scan →
+confidence signal → attestation → outbox record" against
+`581513795199`. Without a regression CAP, the pilot could silently
+decay.
+**Idea:** CAP-025 (live-pilot-apply) in the regression gate. The
+round-trip assertion. Grounds the pilot as a maintained capability,
+not a one-shot demo.
+**Accepted into:** REQ-316. Phase P3.
+
+### I7 — DynamoDB L1 primitive ✅ ACCEPTED (REQ-322)
+
+**Category:** architecture, coverage
+**Confidence:** 0.95
+**Pattern:** missing primitive → authored module (the v1.7 + v1.8
+module-build-out pattern).
+**Source:** RESEARCH §3.4 — no `modules/l1/dynamodb/` exists. The
+blockchain exchange's ledger table needs it. The adapter is
+stateless/registry-driven (no `TYPE_MAP`); a new stack type requires a
+new L1 module, not an adapter change.
+**Idea:** Author `modules/l1/dynamodb/` (interface.json +
+terraform/main.tf + README.md + instance.json + registry.json entry).
+The single platform-side module build-out for the milestone. Follows
+the `s3`/`rds` primitive template. Encryption + PITR enabled per v1.8
+NFR defaults.
+**Accepted into:** REQ-322. Phase P3.
+
+### I8 — Stale `adapters/README.md` TYPE_MAP references ❌ DEFERRED (scope)
+
+**Category:** improvement
+**Confidence:** 0.70 (above threshold, but scoped into REQ-321)
+**Pattern:** stale doc → corrected doc.
+**Source:** `adapters/README.md:49-54` references the deleted
+`TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP` — contradicts `adapter.py:1-11` +
+`modules/STANDARDS.md:212-214`.
+**Idea:** Fix the stale references as part of the docs phase.
+**Reason deferred as a standalone idea:** Already captured in REQ-321
+(docs + adapter README). No new requirement needed — the fix lands in
+P4 docs.
+
+## Tier 3 — Cross-project (deferred — multi-project, but cross-project sharing disabled)
+
+### I9 — Cross-project policy sharing ❌ DEFERRED (config)
+
+**Category:** improvement
+**Confidence:** N/A
+**Pattern:** policies shared across projects in a multi-project org.
+**Source:** `config.json ideation.cross_project.enabled: false`.
+**Idea:** In a multi-project org, kyverno-json policies could be shared
+across projects (a tagging standard policy applies to all projects).
+**Reason deferred:** `cross_project.enabled: false`. Even though
+v1.26 is multi-project (acdl + nova-blockchain-exchange),
+cross-project *ideation* is disabled in config. Recorded for when the
+org grows + the flag is enabled.
+
+### I10 — Consumer-repo CI scaffolding as a reusable template ❌ DEFERRED
+
+**Category:** improvement
+**Confidence:** 0.55 (below threshold — deferred, not rejected)
+**Pattern:** one-off CI → reusable template.
+**Source:** The consumer repo (`nova-blockchain-exchange`) needs its
+own CI (`ci.yml` — lint + pytest). If Nova expects many consumers, a
+reusable consumer-CI template would reduce onboarding friction.
+**Idea:** A `nova-consumer-template` repo (or a
+`.github/workflow-templates/` dir) that new consumers instantiate.
+**Reason deferred:** Nova has 1 consumer today (the pilot). A template
+is premature abstraction until the 2nd consumer arrives. The pilot's
+CI is authored directly (REQ-310..312 tests). Recorded for when the
+3rd consumer onboards.
+
+## Summary
+
+- 7 ideas accepted (I1..I7) → already captured as REQ-315, REQ-316,
+  REQ-317, REQ-318, REQ-319, REQ-320, REQ-322.
+- 3 ideas deferred (I8 scoped into REQ-321; I9 config-disabled; I10
+  below threshold) with documented blocking reasons.
+- 0 ideas rejected (below-threshold ideas are deferred, not rejected —
+  they may activate when their blockers lift).
+- The accepted ideas are the **quality improvement** the `--ideate` flag
+  drives: I1 + I2 ground the Post-Pilot metrics (outcome backfill +
+  escalation reason); I3 closes the env-JSON wiring gap; I4 + I5 extend
+  v1.25's policy engine to the pilot domain (pilot-readiness +
+  settlement-finality); I6 gates the pilot as a maintained capability;
+  I7 is the single platform-side module build-out.
+- No new requirements added beyond REQ-310..322 (the accepted ideas are
+  already scoped into the existing requirements). The IDEATE pass
+  validated the requirement set rather than expanding it — the ideas
+  were anticipated in the SPECIFY + RESEARCH stages.

.ciagent/NORTH_STAR.md

@@ -93,7 +93,7 @@ deploy — not a vendor arriving late to that market.
 3. **Not an upstream development platform.** Nova does not own the
    product backlog, IDE workflows, code authorship, or application
    business logic. The PDLC is upstream; Nova integrates with it through
-   a validated contract boundary — Nova never penetrates it.
+   a validated contract boundary — Nova never reaches into it.
 4. **Not a replacement for the Product Development Lifecycle (PDLC).**
    Nova governs infrastructure + delivery only. Product lifecycle
    decisions (what to build, when to ship, for whom) remain with the
@@ -229,4 +229,28 @@ their AI engineering teams reach for first when an agent needs to deploy.
   RESEARCH.md/ARCHITECTURE.md. It is the *how*; this file is the *why*.
 - **Pillar C (story):** the unified narrative deck proves Pillars A+B to
   leadership. The deck's Proof section cites grounded metrics; its
-  Roadmap section cites deferred targets honestly.
+  Roadmap section cites deferred targets honestly.
+
+## Relationship to engineering files (v1.27 update)
+
+- **NORTH_STAR.md** (this file) = the *why* — PO-authored strategic
+  direction, loaded every ci-run via `config.strategic_direction_file`.
+- **STATE.md** = the *what exists* — PO-owned capability catalog,
+  additive, updated at every milestone ship (P-final Wave 3). The PO
+  reads STATE.md before writing new REQ-NNN specs to avoid re-spec'ing
+  existing capability and to respect the invariants.
+- **ARCHITECTURE.md** = the *how* — the durable target architecture.
+- **CHECKPOINT.json** = the *now* — authoritative live phase/ship
+  state.
+
+## v1.25 update — swappable policy-engine substrate
+
+Strategic Objective #2 (provable trust) gained a concrete substrate in
+v1.25: the policy engine that produces the `PolicyCheckResult` records
+feeding the confidence signal is now **swappable** via the
+`PolicyEngine` protocol (`core/policy_engine.py`). `kyverno-json` is
+the v1.25 default; `OPA` (or any other engine) can replace it by
+implementing the same 3-method protocol — without touching the
+confidence signal, the PCR schema, or the pipeline. See
+ARCHITECTURE.md §12.7. The trust moat is a *replaceable* engine, not a
+vendor lock-in.

.ciagent/PERSONAS.md

@@ -1,264 +1,119 @@
 ---
 project: acdl
-milestone: v1.23
+milestone: v1.28
-generated_at: 2026-08-11
+generated_at: 2026-08-19
 generator: lead-developer
 verification_toolchain:
-  typecheck: "python3 -m py_compile scripts/inline_images.py scripts/render_pptx.py tests/test_slides_pipeline.py"
+  typecheck: "python3 -m py_compile core/mode_resolver.py nova/cli.py 2>&1 | head -5 || true"
-  test: "pytest tests/test_slides_pipeline.py   # REQ-263..275"
+  test: "pytest tests/test_mode_resolver.py tests/test_cli_subcommands.py -q 2>&1 | tail -15 || true"
-  build: "bash scripts/render_slides.sh nova-autonomous-cloud-delivery   # HTML + Marp PPTX; then python3 scripts/render_pptx.py   # structured PPTX"
+  lint: "ruff check nova/ core/lambda/nova_idp_*.py 2>/dev/null || true"
   note: |
-    v1.23 is the Nova Deck Cleanup & Python PPTX — a docs/render/test
+    v1.28 is a feature milestone (CLI Canonicalization + Identity Layer).
-    NFR milestone. Two active personas: lead-developer (deck markdown
+    Four active personas: backend-engineer (Lambda/DynamoDB/KMS/CodeArtifact),
-    consolidation + inline Marp style CSS + README + .ciagent metadata),
+    security-engineer (Argon2id/KMS/ABAC/threat model), cli-engineer
-    backend-engineer (Python scripts inline_images.py + render_pptx.py
+    (subcommand surface/mode_resolver/argparse/CAP-034), lead-developer
-    via python-pptx + render_slides.sh updates + tests + CI YAML +
+    (plan/review/ship/capability gate). frontend-engineer + data-engineer
-    attach_release_asset.py extension). frontend-engineer stays
+    deactivated (no UI, no data pipelines). The kj-binary-in-Lambda-layer
-    deactivated (decks are markdown + Marp CSS = lead-developer
+    risk (D-227, RESEARCH §7) is the highest-risk item; P2 spike confirms.
-    territory, per v1.17/v1.18/v1.22 precedent). No data-engineer (no
-    schema/DB changes). No new personas (the work splits cleanly into
-    narrative+CSS+docs and Python+bash+tests+CI).
 ---
 
-# ACDL — Persona Roster (v1.23 Nova Deck Cleanup & Python PPTX)
+# Personas — v1.28 CLI Canonicalization + Identity Layer
 
-> v1.23 roster. Two active personas + two deactivated. This is a
+## Roster
-> docs/render/test NFR milestone: the work is deck markdown
-> consolidation, Marp inline `style:` CSS (reverting from the standalone
-> `nova-sp-theme.css` to `theme: default` + inline block), two Python
-> render scripts (`inline_images.py` stdlib image inlining +
-> `render_pptx.py` structured PPTX via python-pptx), test updates, CI
-> YAML, README rewrite, and the `attach_release_asset.py` extension to
-> dual-PPTX. frontend-engineer stays deactivated (Marp CSS is a static
-> stylesheet, not a React/Next.js component system — D-148 precedent).
-> No data-engineer (no schema/DB/ORM changes).
-
-## Active personas
-
-### lead-developer
-- **Domain:** coordination + deck content + inline CSS
-- **Active:** true
-- **Phase-specific:** false
-- **Frameworks:** [] (no framework — owns process + narrative + Marp inline CSS + markdown + README)
-- **Constraints:** ["pragmatic", "battle-tested defaults", "no fabrication (NORTH_STAR honesty model)", "do not change the 4-beat arc", "do not re-introduce badges/version/internal citations", "port the reference deck's exact inline style CSS (the clean look)"]
-- **Territory:**
-  - `docs/presentations/nova-autonomous-cloud-delivery-marp.md` (REQ-263..275 — deck consolidation: merge plain .md into -marp.md, trim word count, remove "penetrate")
-  - `docs/presentations/nova-autonomous-cloud-delivery.md` (DELETE — consolidated into -marp.md)
-  - `docs/presentations/nova-autonomous-cloud-delivery-talking-points.md` (sync to final slide structure)
-  - `docs/presentations/README.md` (rewrite 4-step → 3-step process for single-document + dual-PPTX pipeline)
-  - `docs/presentations/assets/nova-sp-theme.css` (RETIRE from render; keep as reference file)
-  - `.ciagent/**` (PROJECT, ROADMAP, REQUIREMENTS, RESEARCH, PLAN, GRILL, PERSONAS, REVIEW, CHECKPOINT)
-- **Reason:** Owns the deck markdown consolidation (plain `.md` +
-  `-marp.md` → single `-marp.md` with speaker notes as HTML comments),
-  the inline `style:` CSS block (porting the reference deck's exact
-  CSS — the "clean look"), the word-count trim, the "penetrate"
-  removal, the talking-points sync, the README rewrite, and all
-  CIAgent metadata. Is the only persona that touches `.ciagent/**` and
-  the deck markdown/CSS. The inline `style:` block is a Marp
-  frontmatter stylesheet, not a frontend component system (D-148
-  precedent from v1.22).
-- **Phase-specific flag:** none (active for all of P0–P-final).
 
 ### backend-engineer
-- **Domain:** Python render scripts + bash + tests + CI
+```yaml
-- **Active:** true
+active: true
-- **Phase-specific:** false
+domain: "Lambda functions, DynamoDB, KMS integration, dual-use packaging, CodeArtifact publish, CloudFormation generation"
-- **Frameworks:** ["python-pptx", "bash", "pytest", "marp-cli", "mermaid-cli", "base64/re/mimetypes (stdlib)"]
+frameworks: ["Python 3.12", "boto3", "argparse", "pytest", "moto[dynamodb]", "CloudFormation"]
-- **Constraints:** ["pin CLI versions (no @latest in workflows-src/slides.yml — currently unpinned, must fix)", "python-pptx>=0.6.23 minimum", "stdlib-only for inline_images.py (no external image lib)", "tests must catch the theme-default + inline-style regression (the gap that let v1.22's standalone-theme drift through)", "no raw curl with shell-env tokens"]
+constraints: ["INV-15", "INV-16", "INV-17", "D-228", "D-229", "D-230", "NFR-5", "NFR-6", "NFR-7", "NFR-8"]
-- **Territory:**
+territory:
-  - `scripts/inline_images.py` (NEW — stdlib base64 image inlining into rendered HTML)
+  - "core/lambda/**"
-  - `scripts/render_pptx.py` (NEW — structured editable PPTX via python-pptx)
+  - "core/metrics/**"
-  - `scripts/render_slides.sh` (update: drop --theme nova-sp-theme.css; add inline_images.py + render_pptx.py invocations)
+  - "core/env.py"
-  - `scripts/attach_release_asset.py` (extend to accept multiple file paths: both .pptx + -python.pptx)
+  - "core/outbox_writer.py"
-  - `tests/test_slides_pipeline.py` (REQ-262 successor — invert theme tests, retarget CSS tests to inline style block, delete source-md tests, update slide count)
+  - "terraform/bootstrap/**"
-  - `workflows-src/slides.yml` (add python-pptx install step; pin @latest → @4.5.0/@11.16.0; add -python.pptx to commit list)
+  - ".gitea/workflows/publish.yml"
-  - `pyproject.toml` (add python-pptx>=0.6.23 to [project.optional-dependencies] test)
+  - ".github/workflows/publish.yml"
-- **Reason:** Owns the Python render scripts (`inline_images.py` is
+  - ".github/actions/nova-cli/**"
-  stdlib regex + base64; `render_pptx.py` is python-pptx — a backend
+```
-  Python library, not a frontend framework). The render_slides.sh
-  updates (drop `--theme`, add the two Python script invocations) and
-  the CI YAML (add python-pptx install, pin versions, add
-  -python.pptx to commit list) are backend/scripting tasks. The test
-  suite updates (invert the theme-default test, retarget CSS tests to
-  the inline `style:` block, delete the source-md tests) are the gap
-  that let v1.22's standalone-theme drift through — backend-engineer
-  owns closing it. python-pptx is new to v1.23; backend-engineer's
-  frameworks list gains it.
-- **Phase-specific flag:** none (active for P2 scripts, P5 tests; light
-  touch on P0/P-final).
 
-## Deactivated personas
+### security-engineer
+```yaml
+active: true
+domain: "Argon2id hashing, KMS asymmetric signing (ECDSA P-256 / ES256), ABAC policy, JWKS exposure, PAT lifecycle, threat model, DER→raw ECDSA conversion"
+frameworks: ["argon2-cffi", "cryptography", "pyjwt", "kyverno-json", "JMESPath", "KMS Sign/Verify/GetPublicKey"]
+constraints: ["INV-15", "INV-16", "INV-17", "NFR-5", "NFR-8", "NFR-9", "D-227", "D-231"]
+territory:
+  - "platform/abac/**"
+  - "core/policy_engine.py"
+  - "adapters/kyverno-json/**"
+  - "core/lambda/nova_idp_auth.py"
+  - "core/lambda/nova_idp_token_vend.py"
+  - "core/lambda/nova_idp_jwks.py"
+  - "docs/threat-model.md"
+```
+
+### cli-engineer
+```yaml
+active: true
+domain: "CLI subcommand surface, mode_resolver, argparse, [project.scripts] entry-point, CAP-034 AST scan, nova auth/idp subgroups, property tests"
+frameworks: ["Python 3.12", "argparse", "setuptools [project.scripts]", "hypothesis", "pkgutil"]
+constraints: ["INV-12", "INV-13", "INV-14", "D-226", "NFR-1", "NFR-2", "NFR-3"]
+territory:
+  - "nova/**"
+  - "core/mode_resolver.py"
+  - "pyproject.toml"
+  - "tests/test_mode_resolver.py"
+  - "tests/test_cli_subcommands.py"
+```
+
+### lead-developer
+```yaml
+active: true
+domain: "Phase plan, persona roster, review gates, milestone ship, capability gate (CAP-033..038), ROADMAP/STATE/PROJECT wiring"
+frameworks: ["git", "Gitea Actions", "semver tagging", ".ciagent/ discipline"]
+constraints: ["INV-1..17 (cross-cutting)", "v1.28 hard constraints", "NFR-6", "NFR-11"]
+territory:
+  - ".ciagent/**"
+  - "PLAN.md"
+  - "CHECKPOINT.json"
+  - "STATE.md"
+  - "REQUIREMENTS.md"
+  - "ROADMAP.md"
+```
 
 ### frontend-engineer
-- **Active:** false
+```yaml
-- **Domain:** frontend
+active: false
-- **Frameworks:** ["react", "next.js"] (inert — no territory)
+phase_specific: false
-- **Constraints:** ["component-first", "server-components", "minimal-client-js"] (inert)
+reason: "No UI in v1.28 (CLI + JSON endpoints only). JWKS serves application/json; no HTML/CSS/JS surface."
-- **Territory:** [] (no territory in v1.23)
+```
-- **Reason:** v1.23 has no frontend; decks are markdown + Marp inline
-  CSS (lead-developer territory); deactivated per PERSONAS.md
-  v1.17/v1.18/v1.22 precedent. The inline `style:` block is a Marp
-  frontmatter stylesheet (CSS rules in the markdown frontmatter), not
-  a React/Next.js component system — it stays lead-developer
-  territory. No reactivation trigger.
 
 ### data-engineer
-- **Active:** false
+```yaml
-- **Domain:** data
+active: false
-- **Frameworks:** [] (inert)
+phase_specific: false
-- **Constraints:** [] (inert)
+reason: "No data pipelines / metrics / PowerBI work in v1.28. The metrics layer is v1.17-complete; v1.28 adds audit events but no new fact/dim tables."
-- **Territory:** [] (no territory in v1.23)
+```
-- **Reason:** v1.23 has no schema/DB/ORM changes. The milestone is
-  docs + Python scripts + bash + tests + CI only. No reactivation
-  trigger.
 
-## Roster decisions
+## Territory overlap notes
 
-### D-163 (0.95): Inline Marp `style:` block is lead-developer territory, not frontend-engineer
+- `core/lambda/contract_ingestor.py` (dual-use refactor, REQ-329) =
-The inline `style:` block in the Marp frontmatter is a static CSS
+  backend-engineer territory. `core/lambda/nova_idp_auth.py` +
-stylesheet (a block of CSS rules in the markdown frontmatter, applied
+  `nova_idp_token_vend.py` are **co-owned** by backend-engineer (Lambda
-by Marp to the rendered slides), not a React/Next.js component system.
+  plumbing, DynamoDB, function URLs) + security-engineer (crypto, ABAC,
-The v1.17/v1.18/v1.22 precedent (decks are markdown = lead-developer
+  Argon2id logic inside).
-territory; the theme CSS is a Marp stylesheet, not a frontend framework
+- `core/mode_resolver.py` = cli-engineer. `core/policy_engine.py` =
-— D-148) extends to the inline `style:` block. frontend-engineer's
+  security-engineer (the ABAC evaluation path).
-frameworks (react, next.js) are irrelevant to Marp frontmatter CSS.
+- `nova/idp/setup.py` = cli-engineer (the subcommand + arg parsing) +
-**Decision:** inline `style:` block stays lead-developer territory.
+  backend-engineer (the CloudFormation generation + deploy).
-Confidence 0.95 — the only counter-argument is that CSS is "frontend,"
+- `nova/auth/*` = cli-engineer (subcommands) + security-engineer (the
-but Marp frontmatter CSS is a static stylesheet authored in the
+  token exchange + credential storage logic).
-markdown source, not a component system.
 
-### D-164 (0.90): No new personas for v1.23
+## Phase-specific personas
-The work is markdown + inline CSS + Python scripts + bash + tests + CI
-YAML + README. All of this is within the two active personas' range
-(lead-developer: markdown + CSS + README + metadata; backend-engineer:
-Python + bash + tests + CI). Creating a separate "slides-engineer" or
-"pptx-engineer" persona would fragment ownership of the deck markdown
-(lead) and the render scripts (backend). The python-pptx work is
-unambiguously backend (a Python library + script), even though the
-slide layout decisions within `render_pptx.py` are co-owned with lead-
-developer. **Decision:** no new personas. Confidence 0.90 — follows
-v1.22 D-149 precedent.
 
-### Territory-overlap resolution (co-ownership)
+None. All four active personas span the full milestone. The
-
+security-engineer is heaviest in P2 (identity layer) + P3 (threat model);
-| Path | Primary | Co-owner | Why |
+the cli-engineer is heaviest in P1 (CLI substrate); the backend-engineer
-|------|---------|----------|-----|
+spans P1 (CodeArtifact/layer) + P2 (Lambdas/DynamoDB).
-| `scripts/render_pptx.py` | backend-engineer (Python code + python-pptx API) | lead-developer (slide layout decisions: which image where, font sizes, bullet structure) | The script is backend (Python); the slide-by-slide layout decisions within it are design decisions that reflect lead-developer's deck ownership. `warn` enforcement — cross-territory edits logged, not blocked. |
-| `scripts/render_slides.sh` | backend-engineer (bash script) | lead-developer (the inline `style:` block content it renders) | The script is backend; the CSS it renders is lead-developer's. |
-| `tests/test_slides_pipeline.py` | backend-engineer (test code) | lead-developer (assertions reflect deck structure + inline CSS) | The test code is backend; the assertions (slide count, inline style rules, theme-default) reflect lead-developer's deck/CSS decisions. |
-| `docs/presentations/README.md` | lead-developer (process narrative) | backend-engineer (build commands + render script invocations) | The process narrative is lead; the build commands + script names are backend. |
-
-## Domain priority (v1.23)
-
-`lead-developer → backend-engineer`
-
-Rationale: the deck markdown consolidation + inline CSS (lead) is the
-binding constraint — the render scripts (backend) can't be finalized
-until the deck structure is stable (slide count, inline style). The
-inline `style:` block must be ported + verified before the render
-pipeline (HTML + PPTX) is re-run. Backend (scripts + tests + CI)
-follows once the deck + CSS are settled. The dual-PPTX pipeline is
-wired last, once the deck renders clean with the inline style.
-
----
-
-## Historical rosters
-
-<details>
-<summary>v1.22 roster (Nova Deck Layout Fix) — superseded by v1.23</summary>
-
-### Active personas (v1.22)
-
-### lead-developer
-- **Domain:** coordination + deck content
-- **Active:** true
-- **Phase-specific:** false
-- **Frameworks:** [] (no framework — owns process + narrative + CSS + markdown)
-- **Constraints:** ["pragmatic", "battle-tested defaults", "no fabrication (NORTH_STAR honesty model)", "do not change the 4-beat arc", "do not re-introduce badges/version/internal citations"]
-- **Territory:**
-  - `docs/presentations/assets/nova-sp-theme.css` (REQ-254,255,256 — theme CSS)
-  - `docs/presentations/nova-autonomous-cloud-delivery-marp.md` (REQ-261 — deck content)
-  - `docs/presentations/nova-autonomous-cloud-delivery.md` (REQ-261 — source of truth)
-  - `docs/presentations/nova-autonomous-cloud-delivery-talking-points.md` (REQ-261)
-  - `docs/presentations/README.md` (REQ-261 — slide-count convention)
-  - `docs/presentations/assets/mmd/*.mmd` (REQ-259,260 — mermaid re-layout)
-  - `.ciagent/**` (PROJECT, ROADMAP, REQUIREMENTS, RESEARCH, PLAN, GRILL, PERSONAS, REVIEW, CHECKPOINT)
-- **Reason:** Owns the theme CSS (the root cause), the deck markdown
-  (trim/split overflowing slides), the mermaid re-layout, the talking
-  points, the README, and all CIAgent metadata. Is the only persona
-  that touches `.ciagent/**` and the deck markdown/CSS.
-- **Phase-specific flag:** none (active for all of P0–P6).
-
-### backend-engineer
-- **Domain:** render scripts + tests
-- **Active:** true
-- **Phase-specific:** false
-- **Frameworks:** ["bash", "pytest", "marp-cli", "mermaid-cli"]
-- **Constraints:** ["pin CLI versions (no @latest)", "2x scale + transparent bg for mermaid", "tests must catch layout regressions", "no raw curl with shell-env tokens"]
-- **Territory:**
-  - `scripts/render_slides.sh` (REQ-257,258 — pin versions, 2x scale)
-  - `scripts/render_deck.sh` (REQ-257 — DELETE)
-  - `tests/test_slides_pipeline.py` (REQ-262 — layout/aspect-ratio/theme-structural tests)
-  - `.github/workflows/slides.yml` (if references to render_deck.sh need removal)
-- **Reason:** Owns the render pipeline (bash scripts) and the test
-  suite. The layout/aspect-ratio/theme-structural tests (REQ-262) are
-  the gap that let this regression through — backend-engineer owns
-  closing that gap. Pinning CLI versions and adding 2x scale are
-  backend/scripting tasks.
-- **Phase-specific flag:** none (active for P2, P5; light touch on P0/P6).
-
-### D-148 (v1.22): Theme CSS is lead-developer territory, not frontend-engineer
-### D-149 (v1.22): No new personas for v1.22
-
-</details>
-
-<details>
-<summary>v1.18 roster (Citizen Developer & Production-Grade Guidance) — superseded</summary>
-
-### Active personas (v1.18)
-
-### lead-developer
-- **Domain:** coordination
-- **Active:** true
-- **Phase-specific:** false
-- **Frameworks:** [] (no framework — owns process + narrative, not code)
-- **Constraints:** ["pragmatic", "battle-tested defaults", "no fabrication (NORTH_STAR honesty model)"]
-- **Territory:**
-  - `docs/presentations/**` (Step 1/2/4 markdown + the deck automation trigger)
-  - `.ciagent/**` (PROJECT, ROADMAP, REQUIREMENTS, RESEARCH, PLAN, GRILL, PERSONAS, REVIEW, CHECKPOINT)
-  - `PROJECT.md` (RACI matrix + PDLC-scope statement, REQ-215/216)
-  - `ROADMAP.md`
-  - `REQUIREMENTS.md`
-  - `docs/raci.md` (REQ-215)
-  - `docs/scope.md` (REQ-216)
-  - `docs/skills.md` (REQ-222 — the index page, not the skill files themselves)
-  - `docs/submission-readiness.md` (REQ-219 — citizen-developer-facing copy; co-owned with backend-engineer for the reason-code catalog)
-
-### backend-engineer
-- **Domain:** backend
-- **Active:** true
-- **Phase-specific:** false
-- **Frameworks:** ["mcp (Python SDK v2)", "pydantic", "jsonschema", "urllib"]
-- **Territory:**
-  - `mcp/atelier/server.py` (REQ-223)
-  - `mcp/atelier/plugins/**/*.py` (REQ-223 — principles.py, validation.py)
-  - `mcp/atelier/vendor/**` (REQ-224 — vendored Atelier snapshot)
-  - `mcp/atelier/VERSION.md` + `mcp/atelier/README.md` (REQ-224)
-  - `scripts/update_atelier_vendor.sh` (REQ-224)
-  - `core/submission_readiness.py` (REQ-218)
-  - `scripts/render_deck.sh` (REQ-228)
-  - `scripts/attach_release_asset.py` (REQ-228)
-  - `tests/test_atelier_mcp.py` (REQ-225)
-  - `tests/test_submission_readiness.py` (REQ-220)
-
-### data-engineer
-- **Domain:** data
-- **Active:** true
-- **Frameworks:** ["jsonschema", "dynamodb (item shape)"]
-- **Territory:**
-  - `schemas/**` (REQ-217)
-  - `core/lambda/contract_ingestor.py` (co-owned with backend-engineer)
-
-### D-143 (v1.18): Fold mcp-engineer into backend-engineer
-
-</details>

.ciagent/PLAN.md

@@ -1,478 +1,489 @@
-# PLAN — v1.23 (Nova Deck Cleanup & Python PPTX)
+# PLAN — v1.28 CLI Canonicalization + Identity Layer
 
-> NFR milestone (docs/render/test only). Tags on v1.22.x line:
+> **Milestone:** v1.28 (feature — CLI substrate + Nova-idp identity
-> v1.22.0 (P0) → v1.22.1..v1.22.4 (P1–P4) → v1.22.5 (P5 final = milestone
+> layer). Tags on the **v1.27.x** line: `v1.27.0` (P0) →
-> release). 13 requirements (REQ-263..275), 6 phases.
+> `v1.27.1..v1.27.6` (P1..P6) → `v1.27.7` (P7 final = milestone
+> release). The final phase's patch IS the milestone release.
+> **Branch:** `milestone/v1.28-cli-identity`. Phase branches:
+> `phase/00-pre-execution`, `phase/01-cli-substrate`,
+> `phase/02-lambda-packaging`, `phase/03-idp-auth`,
+> `phase/04-token-vend-pat`, `phase/05-docs-integration`,
+> `phase/06-final-review-ship`.
 >
-> **GRILL revisions applied** (G-001..G-004, conf 0.78-0.85):
+> **Tags:** `v1.27.0` (P0) → `v1.27.1..v1.27.5` (P1..P5) →
-> - G-001: "penetrate" purge covers the whole repo (`docs/` +
+> `v1.27.6` (P6 final = milestone release). 6 execution phases
->   `.ciagent/`), not just `docs/presentations/`.
+> (P5 idp-setup folded into P4 Wave 8 per grill C-2.1).
-> - G-002: P3→P4 serialized (not parallel) — P4's parser depends on
->   P3's stable `render_slides.sh`; P4's trimmed deck is what P3b's
->   parser consumes.
-> - G-003: P3 split into P3a (inline_images + render_slides.sh +
->   pyproject — low-risk) + P3b (render_pptx.py + parser +
->   attach_release_asset.py — high-risk, isolated).
-> - G-004: P5+P6 merged — NFR docs milestone; dedicated review/ship
->   phase is ceremonial overhead. P5 absorbs review/audit/ship. Tag
->   v1.22.5 = milestone release.
 
-## Wave Ordering
+## Milestone goal
 
-```
+The Nova CLI is installable from internal PyPI (CodeArtifact); every
-Wave 1 (P1):        consolidate-docs (edits -marp.md, deletes plain .md)
+`core/` module is reachable as a `nova <subcommand>`; the CLI and
-   ↓
+Lambda functions share a single `core/` source tree; and Nova owns its
-Wave 2 (P2):        restore-clean-style (edits -marp.md frontmatter +
+identity layer end-to-end (Nova-idp: `nova-idp-auth` +
-   ↓                benefit callouts; edits render_slides.sh; retires
+`nova-idp-token-vend` Lambdas, KMS-signed OIDC tokens, kyverno-json
-   ↓                nova-sp-theme.css from render)
+ABAC token vending, PAT lifecycle). No AWS-managed identity services
-   ↓
+in the path (INV-15).
-Wave 3 (P3a):       inline-images (inline_images.py + render_slides.sh
-   ↓                step + pyproject — low-risk, mechanical)
-   ↓
-Wave 4 (P3b):       python-pptx-generator (render_pptx.py + parser +
-   ↓                attach_release_asset.py — high-risk, isolated)
-   ↓
-Wave 5 (P4):        trim-wordcount + remove "penetrate" (edits -marp.md +
-   ↓                talking-points.md + docs/scope.md + docs/vision.md +
-   ↓                .ciagent/*.md "penetrate" purge)
-   ↓
-Wave 6 (P5):        ci-tests-readme + review + audit + milestone ship
-                     (merged P5+P6 per G-004)
-```
 
-**Rationale (C8 revised by G-002/G-003/G-004):** P1→P2 serial (both
+## Requirements
-edit `-marp.md`). P3a→P3b serial (P3b's parser benefits from P3a's
+
-stable `render_slides.sh`). P4 serial after P3b (P4's trimmed deck is
+31 requirements: REQ-323..REQ-353 (full text in
-what P3b's parser must handle; P4's verify render depends on P3a's
+`.ciagent/REQUIREMENTS.md` §v1.28). 6 capabilities: CAP-033..CAP-038.
-stable script). P5 final (merged review/audit/ship per G-004 — NFR docs
+6 invariants: INV-12..INV-17. 6 decisions: D-226..D-231 (CLARIFY) +
-milestone doesn't warrant a dedicated P6).
+RESEARCH amendments (D-228 fail-closed, D-229 strong-read-on-PK).
+
+## Phase breakdown
+
+### Phase P1 — cli-substrate (REQ-323..REQ-328)
+
+**Goal:** CodeArtifact wheel + Lambda layer pipeline; `nova/` CLI
+package with a subcommand per `core/` module; `nova init`; `nova
+cli-action` composite action; `core/mode_resolver.py`; audit emission
+with `mode` + `selection_reason`. The CLI is installable and every
+`core/` module is reachable.
+
+**Exit criterion:** CAP-033 + CAP-034 + CAP-035 Verified + all REQ-323..328
+tests pass. CodeArtifact provisioned (Wave 0 gate).
+
+#### Wave 0 — CodeArtifact provisioning (backend-engineer) [C-3.2/C-8.1]
+- **Task 0.1** (backend-engineer): provision CodeArtifact domain
+  (`nova`) + repository (`nova-pypi`) in `581513795199`. Verify
+  `codeartifact:*` IAM grant on `nova-spike-runner`. **Binary go/no-go
+  gate for Wave 4.** If fail: activate Gitea wheel index fallback
+  (CLARIFY assumption #1) and document in PLAN.md.
+
+#### Wave 1 — pyproject + entry point (cli-engineer)
+- **Task 1.1** (cli-engineer): `pyproject.toml` — add
+  `[project.scripts] nova = "nova.cli:main"`; add
+  `[tool.setuptools.packages.find]` including `nova`, `nova.*`, `core`,
+  `core.*`, `adapters.*`; bump `requires-python` to `>=3.12`; add
+  `argon2-cffi`, `cryptography`, `pyjwt`, `hypothesis` to deps/test-deps.
+  Verify `pip install -e .` produces a `nova` executable.
+
+#### Wave 2 — CLI dispatch + subcommands (cli-engineer)
+- **Task 2.1** (cli-engineer): `nova/__init__.py` + `nova/cli.py`
+  (~80 lines, auto-discovers `nova/<module>.py` via `pkgutil.iter_modules`,
+  dispatches, emits `cli.invocation` audit event stub with INV-12 fields).
+- **Task 2.2** (cli-engineer): `nova/<module>.py` for each `core/`
+  module (≤50 lines, `add_parser` + `run` delegates to `core/`). Cover:
+  `resolve`, `decommission`, `env-transition`, `env-check`, `hitl`,
+  `onboard`, `outbox`, `publish-outputs`, `policy`, `regression`, `sod`,
+  `readiness`, `attestation-matrix`, `confidence`. Skip internal-only
+  (`env`, `local_emulators`, `output_publisher` if not user-facing).
+- **Task 2.3** (cli-engineer): `nova/init.py` (REQ-325) — scaffolds
+  `.nova/`, `.nova/contract.yml.attestations/`, `.gitignore` (excludes
+  secrets, `~/.nova/credentials.json`).
+
+#### Wave 3 — mode_resolver + audit (cli-engineer)
+- **Task 3.1** (cli-engineer): `core/mode_resolver.py` —
+  `resolve_mode(flag, env_var, credential_type, stdin_isatty)` per D-226.
+  `sys.stdin.isatty()` is the TTY check (RESEARCH §11). Invalid env →
+  warn + fall through. Returns `(mode, selection_reason)`.
+- **Task 3.2** (cli-engineer): wire `mode_resolver` into `nova/cli.py`
+  — resolve mode before dispatch, emit `cli.invocation` with `mode`,
+  `selection_reason`, `credential_type`, `command`, `args` (INV-12,
+  REQ-328).
+- **Task 3.3** (cli-engineer): `tests/test_mode_resolver.py` —
+  `hypothesis` property tests (REQ-349): deterministic, flag-wins,
+  invalid-env-ignored, no-silent-fallback. Edge cases: TTY + piped
+  stdout, missing credential, conflicting flag/env, invalid env value.
+
+#### Wave 4 — CodeArtifact + layer pipeline (backend-engineer)
+- **Task 4.1** (backend-engineer): `.gitea/workflows/publish.yml` +
+  `.github/workflows/publish.yml` (byte-identical) — build wheel →
+  CodeArtifact `twine upload` → build layer (`pip install --target
+  layer/python/` + `argon2-cffi` + `cryptography` + `pyjwt`) →
+  `lambda publish-layer-version` → SSM `/nova/layer/nova-cli/version`
+  mapping (CAP-035). Fail either → job fails (merge blocked, REQ-323).
+  Pin version to `<semver>+<sha7>` for idempotent re-runs.
+
+#### Wave 5 — composite action (cli-engineer + backend-engineer)
+- **Task 5.1** (cli-engineer): `.github/actions/nova-cli/action.yml` —
+  composite action, `setup-python@v5` (3.12), CodeArtifact login +
+  `pip install nova`, `nova ${{ inputs.command }}`. `NOVA_CLIENT_MODE`
+  from input.
+- **Task 5.2** (backend-engineer): byte-identical integration test —
+  CI matrix runs the action on GitHub `ubuntu-latest` + Gitea
+  `act_runner`; assert same stdout/exit code (REQ-326 AC2, NFR-11).
+
+#### Wave 6 — CAP-033/034 gate (cli-engineer)
+- **Task 6.1** (cli-engineer): `tests/test_cli_subcommands.py` —
+  CAP-033 (`nova --help` lists a subcommand for every `core/` module)
+  + CAP-034 (AST scan: ≤50 lines, ≤3 defs, all calls resolve to `core.`,
+  no conditionals beyond `if __name__`). Wire into CI merge gate.
+
+### Phase P2 — lambda-packaging (REQ-329, REQ-330, REQ-331)
+
+**Goal:** Dual-use `core/lambda/contract_ingestor.py` (Lambda + CLI
+paths share ≥80% code); `core/env.py:+synthesize_local_env()` for
+`nova apply --local`; `.nova/contract.yml.attestations/` scaffolded;
+JWS-from-PAT key derivation (C-5.2).
+
+**Exit criterion:** all REQ-329..331 tests pass + JWS-from-PAT KDF
+specified.
+
+#### Wave 1 — dual-use refactor (backend-engineer)
+- **Task 1.1** (backend-engineer): refactor
+  `core/lambda/contract_ingestor.py` — extract the shared logic into
+  importable functions; the Lambda handler + the CLI `__main__` block
+  both call them. The `__main__` block already exists (the dual-use
+  precedent per RESEARCH §1.2). Verify ≥80% code share (CAP-034 / code
+  review). Local path via `core/local_emulators.py:LocalLambdaStub`.
+
+#### Wave 2 — local env synthesizer + JWS KDF (backend-engineer)
+- **Task 2.1** (backend-engineer): `core/env.py:+synthesize_local_env()
+  ` — produces a local env dict (account_id placeholder, region local,
+  no real AWS) from a contract + `--local` flag. Mirrors
+  `core/onboarding.py:generate_env_file()`.
+- **Task 2.2** (cli-engineer): `nova/apply.py` (≤50 lines) — `nova
+  apply --local` delegates to `core.env.synthesize_local_env()` +
+  `core.contract_resolver.resolve()`.
+- **Task 2.3** (security-engineer): JWS-from-PAT key derivation
+  (C-5.2). HKDF-SHA256(PAT_bytes, salt='nova-local-attestation',
+  info='jws-signing-key') → 32-byte symmetric key. The JWS is
+  HMAC-SHA256 (symmetric, not asymmetric). The "public key derivable
+  from the PAT" AC (REQ-332) is re-interpreted: the *verification key*
+  is derived from the PAT via the same KDF (the PAT is the shared
+  secret). Document in `docs/developer-guide-auth.md`. Update REQ-332
+  AC accordingly.
+
+#### Wave 3 — attestations dir (cli-engineer)
+- **Task 3.1** (cli-engineer): verify `nova init` (P1 Wave 2 Task 2.3)
+  creates `.nova/contract.yml.attestations/` (empty). REQ-331 test.
+
+### Phase P3 — idp-auth (REQ-333, REQ-334, REQ-335)
+
+**Goal:** `nova-idp-auth` Lambda (sign-up, sign-in, session) with
+Argon2id hashing + DynamoDB tables. CAP-036 target.
+
+**Exit criterion:** CAP-036 Verified (E2E sign-up → sign-in → session
+passes in CI).
+
+#### Wave 1 — DynamoDB schema (backend-engineer)
+- **Task 1.1** (backend-engineer): define the 4 DynamoDB table schemas
+  (`nova-users`, `nova-sessions`, `nova-password-resets`, `nova-pats`)
+  in a CloudFormation snippet (reused by P4 Wave 8 `nova idp setup`).
+  PITR enabled on each (REQ-335).
+
+#### Wave 2 — Argon2id (security-engineer) [C-1.2/C-7.2]
+- **Task 2.1** (security-engineer): `core/lambda/nova_idp_auth.py` —
+  Argon2id password hashing via `argon2-cffi` (D-228: bundled abi3
+  wheel; **fail-closed on `ImportError` → 503, no pure-Python
+  fallback**). **Parameters: t=3, m=65536 KiB, p=1** (OWASP-recommended
+  minimum). Lambda memory ≥512 MB (m=64 MiB + Python overhead fits).
+  Raw passwords never in logs/traces/env/DDB (INV-16, REQ-334).
+- **Task 2.2** (security-engineer): `tests/test_argon2_fail_closed.py`
+  — mock `argon2.low_level` import failure → assert auth Lambda
+  returns 503 (not a crash, not a weak hash). C-1.2.
+
+#### Wave 3 — auth Lambda (backend-engineer + security-engineer)
+- **Task 3.1** (backend-engineer): `nova-idp-auth` Lambda handler —
+  sign-up, sign-in, session creation endpoints. Function URL + IAM
+  auth. DynamoDB via lazy `boto3.resource` (the existing pattern).
+- **Task 3.2** (security-engineer): session token issuance + session
+  storage in `nova-sessions` (TTL `expires_at`). Password reset flow
+  in `nova-password-resets` (TTL 15m).
+
+#### Wave 4 — CAP-036 E2E (backend-engineer)
+- **Task 4.1** (backend-engineer): `tests/test_idp_auth.py` — sign-up
+  → sign-in → session round-trip (moto[dynamodb] for local; deployed
+  for CI). CAP-036 verification.
+
+### Phase P4 — token-vend-pat (REQ-336..REQ-344, REQ-340, REQ-341) [was P4+P5]
+
+**Goal:** `nova-idp-token-vend` Lambda (KMS-signed OIDC, kyverno-json
+ABAC), JWKS endpoint, PAT lifecycle, `nova auth` commands, **and**
+`nova idp setup` (folded from P5 per C-2.1). CAP-037 + CAP-038 target.
+**Highest-risk phase — critical-path.** The kj-binary spike (Wave 1)
+is the single highest-probability schedule slip; Fargate fallback adds
+~1 week (D-227). This is a **double-length phase** (8 waves).
+
+**Exit criterion:** CAP-037 + CAP-038 Verified + `nova idp setup
+--check/--apply/--verify` works against a fresh AWS account.
+
+#### Wave 1 — kj-binary spike (backend-engineer + security-engineer) [C-8.2]
+- **Task 1.1** (backend-engineer): confirm the `kj` Go binary
+  (~40 MB Linux amd64) runs in the Lambda Python 3.12 runtime on
+  AL2023. Bundle it in the `nova-cli` layer (`wget` a **pinned
+  release** (e.g. `kj@v1.x.y`) + record SHA256 into `layer/kj.sha256`
+  — C-8.2, supply-chain safety) into `layer/bin/kj`, `chmod +x`.
+  Verify `KyvernoJsonEngine.is_configured()` finds `/opt/bin/kj`.
+  **If this fails:** fall back to Fargate for the token-vend Lambda
+  (D-227 risk, RESEARCH §7). Escalate to user only if both fail (full
+  autonomy: log assumption + proceed with Fargate).
+
+#### Wave 2 — ABAC policy (security-engineer) [C-5.1]
+- **Task 2.1** (security-engineer): `platform/abac/token-vend.policy`
+  — kyverno-json `ValidatingPolicy` (D-227). Payload:
+  `{subject, requested_claims, target_resource, environment, pat_jti,
+  policy_version}`. **`requested_claims` = list of claim names** (the
+  policy asserts the subject is *allowed* to request those claims; the
+  values are assigned by the Lambda, not the requestor — C-5.1).
+  JMESPath checks for role/scope/env/owner. Severity `critical` = deny
+  on fail.
+- **Task 2.2** (security-engineer): `policy_version` = git SHA of the
+  policy file, baked into the Lambda layer (D-231). Recorded in every
+  `token.vend.allowed/denied` audit event.
+
+#### Wave 3 — KMS signing (security-engineer) [C-1.1]
+- **Task 3.1** (security-engineer): **verify KMS asymmetric key
+  support** before implementation: `aws kms create-key --key-spec
+  ECC_NIST_P256 --key-usage SIGN_VERIFY` in the target account
+  (C-1.1). If fail: fall back to RSA-2048 (also supported, larger
+  tokens) or escalate. Do not discover this mid-Wave.
+- **Task 3.2** (security-engineer): KMS key `alias/nova-oidc-signing`
+  (ECC_NIST_P256, SIGN_VERIFY). Token-vend Lambda signs via
+  `kms.sign(SigningAlgorithm="ECDSA_SHA_256")` → DER→raw ECDSA
+  conversion (`decode_dss_signature` → `r.to_bytes(32) + s.to_bytes(32)`,
+  RESEARCH §5). JWT header `{"alg":"ES256","typ":"JWT","kid":"..."}`.
+
+#### Wave 4 — token-vend Lambda (backend-engineer + security-engineer) [C-6.1/C-7.1 ABAC FAIL-CLOSED]
+- **Task 4.1** (backend-engineer): `core/lambda/nova_idp_token_vend.py`
+  — accepts PAT/session, validates revocation (`nova-pats.GetItem(jti,
+  ConsistentRead=True)` — D-229), evaluates ABAC (Wave 2), signs (Wave
+  3), returns OIDC JWT. Audit at every step.
+- **Task 4.2** (security-engineer): token claims `sub, aud, iss, exp,
+  iat, jti, roles` (REQ-336).
+- **Task 4.3** (security-engineer) 🔴: **ABAC fail-closed.** If
+  `KyvernoJsonEngine.is_configured()` returns false or `evaluate()`
+  raises, return 403 + audit `token.vend.denied` (reason:
+  `abac_eval_failed`). **Never fail open.** This is INV-17's runtime
+  enforcement (C-6.1/C-7.1 — the grill's #1 finding). Test:
+  `tests/test_abac_fail_closed.py` — mock `kj` absent → assert 403 +
+  audit event.
+
+#### Wave 5 — JWKS endpoint (backend-engineer)
+- **Task 5.1** (backend-engineer): `core/lambda/nova_idp_jwks.py` —
+  function URL `AuthType: NONE`, `Cache-Control: max-age=3600`.
+  `kms.get_public_key` → DER SPKI → JWK via `cryptography`. Returns
+  `{"keys":[...]}`. Custom domain + WAF = optional (D-230).
+
+#### Wave 6 — PAT lifecycle (security-engineer + cli-engineer) [C-7.3]
+- **Task 6.1** (security-engineer): PAT issuance — signed JWT
+  (`typ: "developer_pat"`, INV-14), `nova-pats` PutItem (jti, pat_hash,
+  status=active). Only hash stored (REQ-343). Revoked PATs retained.
+  **Max TTL: ≤24h for developer PATs, ≤1h for service-account PATs**
+  (C-6.2 threat model).
+- **Task 6.2** (cli-engineer): `nova/auth/{login,revoke,status}.py` —
+  `nova auth login` (session→OIDC token, store in
+  `~/.nova/credentials.json` 0600), `nova auth revoke --pat <jti>`,
+  `nova auth status` (active credential, mode, selection_reason).
+  All emit audit events (REQ-344). **C-7.3: `~/.nova/credentials.json`
+  stores the OIDC token + PAT metadata (jti, exp, type) ONLY — NOT the
+  raw PAT.** The raw PAT is entered once at `nova auth login` and not
+  persisted (reduces filesystem-compromise blast radius).
+
+#### Wave 7 — CAP-037/038 (security-engineer)
+- **Task 7.1** (security-engineer): `tests/test_kms_roundtrip.py`
+  (REQ-350, CAP-037) — sign test JWT via token-vend, fetch JWKS,
+  verify with `pyjwt`. `tests/test_pat_revocation.py` (REQ-351,
+  CAP-038) — issue → vend → revoke → assert 403 within 60s P95.
+
+#### Wave 8 — nova idp setup (cli-engineer + backend-engineer) [folded from P5 per C-2.1]
+
+**Goal:** `nova idp setup` command with `--check/--apply/--verify`
+modes; CloudFormation template generation + review (REQ-340, REQ-341).
+
+- **Task 8.1** (backend-engineer): `nova/idp/setup.py` (+ backend
+  helper) — generates the Nova-idp CloudFormation template (raw dict →
+  JSON): 2-3 Lambdas, 4 DDB tables, KMS key, function URLs, IAM roles,
+  optional CloudFront/WAF/ACM (`--public-jwks-domain` flag).
+- **Task 8.2** (cli-engineer): `--check` (prerequisites + IAM policy
+  delta), `--apply` (generate → `$PAGER` → `y/N` → `cloudformation
+  deploy --capabilities CAPABILITY_IAM`, NFR-10), `--dry-run` (resource
+  list only), `--verify` (KMS round-trip, delegates to REQ-350 test).
+- **Task 8.3** (backend-engineer): IAM policy delta computation —
+  compares current `nova-spike-runner` grants to required
+  `cloudformation:*` + `codeartifact:*` + `kms:*` + `lambda:*` +
+  `dynamodb:*` + `ssm:*`.
+
+### Phase P5 — docs-integration (REQ-345..REQ-351)
+
+**Goal:** Operator guide, developer guide, threat model; E2E
+integration test; property tests; KMS round-trip; PAT revocation SLO.
+
+**Exit criterion:** all REQ-345..351 tests pass + docs published +
+threat model reviewed.
+
+#### Wave 1 — docs (lead-developer + security-engineer) [C-6.2/C-6.3/C-9.2]
+- **Task 1.1** (lead-developer): `docs/operator-guide-idp.md` (REQ-345)
+  — `nova idp setup --check/--apply/--verify`, prerequisite IAM policy,
+  CloudFormation review flow. **C-6.3 additions:** KMS key rotation
+  procedure (90 days), Lambda layer update procedure, DDB PITR restore
+  procedure, emergency PAT revocation (DDB-level, not CLI).
+- **Task 1.2** (lead-developer): `docs/developer-guide-auth.md`
+  (REQ-346) — signup, signin, login, mode resolution, TTY vs piped
+  stdout behavior, JWS-from-PAT KDF (P2 Wave 2 Task 2.3).
+- **Task 1.3** (security-engineer): `docs/threat-model.md` (REQ-347) —
+  Argon2id storage, KMS signing, JWKS exposure, PAT revocation SLO,
+  ABAC token vending, no-AWS-managed-identity (INV-15), DER→raw ECDSA
+  gotcha. **C-6.2 additions:** (a) JWKS unauthenticated endpoint DDoS
+  surface + reserved-concurrency mitigation; (b) PAT theft + max TTL
+  (≤24h dev, ≤1h service-account); (c) ABAC fail-closed guarantee
+  (C-6.1). **C-9.2 addition:** INV-18..21 compression audit — verify
+  the spec's attestation invariant semantics are fully captured by
+  INV-15/16/17 + REQ-332.
+
+#### Wave 2 — integration tests (backend-engineer + security-engineer)
+- **Task 2.1** (backend-engineer): `tests/test_e2e_idp.py` (REQ-348) —
+  sign-up → sign-in → token-vend → apply → audit. Verifiable audit
+  chain. Runs in CI against deployed Nova-idp.
+- **Task 2.2** (security-engineer): verify REQ-349 (mode_resolver
+  property tests, P1 Wave 3 Task 3.3) + REQ-350 (KMS round-trip, P4
+  Wave 7 Task 7.1) + REQ-351 (PAT revocation SLO, P4 Wave 7 Task 7.1)
+  pass in CI.
+
+### Phase P6 — final-review-ship (Final Phase)
+
+**Goal:** Multi-persona code review across P1..P5; project-health
+audit; milestone ship to main; CAP-033..038 Verified.
+
+#### Wave 1 — review (lead-developer)
+- **Task 1.1** (lead-developer): `ciagent-review` across all phases.
+  Auto-fix P0; flag P1+ for post-hoc. If P1+ found, fix in this phase.
+
+#### Wave 2 — audit (lead-developer)
+- **Task 2.1** (lead-developer): `ciagent-audit` — reconstruction test
+  (git log ↔ `.ciagent/`), file/branch/commit discipline. Fix critical
+  issues in this phase.
+
+#### Wave 3 — milestone ship (lead-developer)
+- **Task 3.1** (lead-developer): `ciagent-ship` — merge `phase/06` →
+  `milestone/v1.28-cli-identity` → `main`; tag `v1.27.6` (= the v1.28
+  release); Gitea release with full milestone summary; delete all
+  milestone branches. Update REQUIREMENTS.md (mark REQ-323..353
+  complete), ROADMAP.md (mark v1.28 complete), STATE.md (append
+  CAP-033..038 + INV-12..17), NORTH_STAR.md.
 
 ---
 
-## Phase P1 — consolidate-docs (tag v1.22.1)
+## User-Facing Surface
 
-**Requirements:** REQ-263, REQ-264
+> MVP/UX CHECK §1 (REQ-MVP-UX-001).
-**Persona:** lead-developer (deck markdown + .ciagent)
-**Branch:** `phase/01-consolidate-docs`
 
-### Tasks
+1. **CLI flag:** `nova --help` lists every subcommand; `nova init`
+   scaffolds a project; `nova auth login` authenticates; `nova apply
+   --local` runs locally; `nova idp setup` deploys the identity stack.
+2. **README quickstart:** `docs/developer-guide-auth.md` (REQ-346)
+   documents signup → signin → login → `nova apply` in a quickstart.
+3. **`.feature` Scenario:** `tests/test_e2e_idp.py` (REQ-348) is the
+   E2E happy path (sign-up → sign-in → token-vend → apply → audit).
 
-1. **Fold speaker notes into the deck** (REQ-263):
+## Happy Path
-   - Read `docs/presentations/nova-autonomous-cloud-delivery.md` (the
-     plain source-of-truth, 747 lines).
-   - For each `## Slide N — Title` section, extract the
-     `> **Speaker notes:**` and `> **Transition:**` blockquote blocks.
-   - In `docs/presentations/nova-autonomous-cloud-delivery-marp.md`,
-     insert `<!-- Speaker notes: ... -->` (and `<!-- Transition: ... -->`
-     where present) as a Marp HTML comment immediately after the
-     slide's content, before the next `---` separator.
-   - The slide's visible content is unchanged.
 
-2. **Fold talking points into the deck** (REQ-264):
+> MVP/UX CHECK §2 (REQ-MVP-UX-001). End-to-end scenario written BEFORE
-   - Read `docs/presentations/nova-autonomous-cloud-delivery-talking-points.md`
+> execute.
-     (145 lines, 3-6 bullets per slide + key takeaway).
-   - For each slide, insert `<!-- Talking points: ... -->` (the bullets
-     joined) as a Marp HTML comment after the speaker-notes comment.
-   - Update the `talking-points.md` header (line 4): change "distilled
-     from the source of truth (`nova-autonomous-cloud-delivery.md`)" →
-     "mirrors the `<!-- Talking points: -->` comments in
-     `nova-autonomous-cloud-delivery-marp.md` (the sole source of
-     truth)".
 
-3. **Delete the plain `.md`** (REQ-263):
+**Journey 2 — Dev authenticates and deploys locally:**
-   - `git rm docs/presentations/nova-autonomous-cloud-delivery.md`.
+1. `nova auth signup` → `nova-idp-auth` Lambda → Argon2id hash →
+   `nova-users` PutItem → session token.
+2. `nova auth signin` → `nova-idp-auth` → Argon2id verify → session.
+3. `nova auth login` → `nova-idp-token-vend` (exchanges session for
+   Nova OIDC token; stores in `~/.nova/credentials.json` 0600).
+4. `nova init` in a project dir → `.nova/`, `.gitignore`,
+   `.nova/contract.yml.attestations/`.
+5. `nova apply --local --sign-local-review` →
+   `core.env.synthesize_local_env()` → `core.contract_resolver.resolve()`
+   → JWS attestation signed with a key derived from the PAT → local
+   ledger entry.
 
-4. **Verify** (must-have):
+The E2E test (`tests/test_e2e_idp.py`, REQ-348) verifies this chain +
-   - `bash scripts/render_slides.sh` still renders (22 slides:
+the audit event chain in CI against a deployed Nova-idp.
-     title + 20 main + 1 appendix — unchanged).
+
-   - HTML slide count unchanged (test_marp_deck_slide_count passes).
+## UX Acceptance Criteria
-   - `grep -c "<!-- Speaker notes:" nova-autonomous-cloud-delivery-marp.md`
+
-     returns ≥20 (one per main slide).
+> MVP/UX CHECK §3 (REQ-MVP-UX-001).
-   - `grep -c "<!-- Talking points:" ...` returns ≥20.
+
-   - The plain `.md` no longer exists.
+1. `nova --help` exits 0 and lists a subcommand for every `core/`
-   - `talking-points.md` still exists with updated header.
+   module (CAP-033).
+2. `nova init` in an empty dir creates `.nova/`,
+   `.nova/contract.yml.attestations/`, `.gitignore` (secrets excluded).
+3. `nova auth login` at a TTY resolves `mode=interactive,
+   selection_reason=credential:developer_pat` (INV-12, INV-14).
+4. `nova apply --local` produces a JWS attestation verifiable with the
+   public key derived from the PAT (REQ-332).
+5. `nova idp setup --check` reports prerequisites + IAM policy delta;
+   `--apply` presents the CloudFormation template for review before any
+   resource is created (NFR-10); `--verify` confirms the KMS round-trip.
+6. The Forge action (`nova cli-action`) runs `nova apply` in
+   `mode=agent, selection_reason=credential:service_account_pat` with
+   no TTY dependency (Journey 3, INV-12).
+7. PAT revocation takes effect within 60s P95 (NFR-4, CAP-038).
 
 ---
 
-## Phase P2 — restore-clean-style (tag v1.22.2)
+## Capability gate (CAP-033..CAP-038)
 
-**Requirements:** REQ-265, REQ-266, REQ-267
+| CAP | Name | Phase | Gate rule |
-**Persona:** lead-developer (deck markdown + CSS) + backend-engineer
+|-----|------|-------|-----------|
-(render_slides.sh)
+| CAP-033 | CLI subcommand surface exists | P1 | `nova --help` lists a subcommand for every `core/` module |
-**Branch:** `phase/02-restore-clean-style`
+| CAP-034 | Subcommand delegates to `core/` | P1 | Every `nova/<module>.py` ≤50 lines, no business logic, AST scan |
-**Depends on:** P1 (consolidated doc)
+| CAP-035 | Layer matches wheel | P1 | Lambda layer ARN version matches `nova-cli` wheel version (SSM mapping) |
-
+| CAP-036 | Nova-idp auth flow works | P3 | E2E test (sign-up → sign-in → session) passes in CI |
-### Tasks
+| CAP-037 | Token-vend signs via KMS | P4 | KMS round-trip test (REQ-350) passes in CI |
-
+| CAP-038 | PAT issuance + revocation | P4 | Issue → vend → revoke → 403 within 60s P95 (REQ-351) passes in CI |
-1. **Revert frontmatter to `theme: default` + inline `style:`** (REQ-265):
+**Release gate (§6 of the spec):** CAP-001..CAP-032 remain Verified;
-   - In `nova-autonomous-cloud-delivery-marp.md` frontmatter:
+CAP-033..CAP-038 are Verified; all v1.28 release-gate criteria met.
-     - `theme: nova-sp` → `theme: default`.
-     - Add `style: |` block porting the S&P visual language (from the
-       research-extracted reference CSS + `nova-sp-theme.css`):
-       ```yaml
-       style: |
-         section { font-family: "Akkurat Pro", "Helvetica Neue", "Arial", sans-serif; font-size: 22px; color: #1B1B1B; padding: 48px 56px 40px; overflow: auto; }
-         h1 { color: #D6002A; font-size: 34px; margin-bottom: 0.3em; }
-         h2 { color: #D6002A; font-size: 26px; margin-bottom: 0.2em; }
-         h3 { color: #D6002A; font-size: 22px; margin-bottom: 0.2em; }
-         section.title { background: #1B1B1B; color: #fff; border-top: 8px solid #D6002A; }
-         section.title h1, section.title h2 { color: #fff; }
-         section.title header, section.title footer { display: none; }
-         table { font-size: 18px; width: 100%; border-collapse: collapse; }
-         th { background: #F0F0F0; border-bottom: 2px solid #D6002A; padding: 4px 8px; text-align: left; }
-         td { border-bottom: 1px solid #F0F0F0; padding: 4px 8px; }
-         blockquote { border-left: 4px solid #D6002A; color: #2E2E2E; font-size: 20px; padding-left: 12px; }
-         pre { background: #1B1B1B; color: #fff; border-radius: 4px; padding: 12px; font-size: 16px; }
-         code { background: #F0F0F0; color: #1B1B1B; border-radius: 2px; padding: 1px 4px; font-size: 18px; }
-         pre code { background: transparent; color: inherit; }
-         img { display: block; margin: 0 auto; max-width: 100%; max-height: 380px; object-fit: contain; }
-         strong { color: #D6002A; }
-         .benefit { margin-top: 0.6em; padding-top: 0.4em; border-top: 1px solid #D6002A; color: #1B1B1B; font-size: 20px; font-style: italic; }
-         section.title .benefit { color: #fff; }
-         @media print { section { overflow: hidden; } }
-       ```
-   - Keep: `paginate: true`, `size: 16x9`, `footer:`, no `header:`.
-
-2. **Retire `nova-sp-theme.css` from render** (REQ-266):
-   - Add header comment to `docs/presentations/assets/nova-sp-theme.css`:
-     "Retained as the S&P visual-language reference for future styling
-     work. The live deck uses Marp `default` theme + inline `style:`
-     block in the -marp.md frontmatter. Not loaded at render time."
-   - `scripts/render_slides.sh`: remove `THEME_CSS` variable usage and
-     the `--theme "$THEME_CSS"` argument from both marp-cli invocations
-     (lines 70, 73). Keep `--allow-local-files`.
-
-3. **Restyle benefit callouts** (REQ-267):
-   - In `nova-autonomous-cloud-delivery-marp.md`, convert every
-     `**Benefit:** text` line → `<div class="benefit">text</div>`.
-   - This applies to all 20 main slides + appendix (21 callouts).
-   - The `**Benefit:**` prefix is removed; the `.benefit` class (defined
-     in the inline `style:` block) provides the visual emphasis.
-
-4. **Verify** (must-have):
-   - `bash scripts/render_slides.sh` renders; HTML opens with S&P red
-     h1s, black title slide with red top border, benefit callouts with
-     red top-rule + italic.
-   - `grep -c "theme: default" nova-autonomous-cloud-delivery-marp.md`
-     returns 1.
-   - `grep -c "theme: nova-sp" ...` returns 0.
-   - `grep -c 'class="benefit"' ...` returns ≥21.
-   - `grep -c "\\*\\*Benefit:\\*\\*" ...` returns 0.
-   - `nova-sp-theme.css` still exists (reference).
-   - `grep "Not loaded at render" nova-sp-theme.css` returns a match.
 
 ---
 
-## Phase P3a — inline-images (tag v1.22.3)
+## Test evidence required for v1.28 release
 
-**Requirements:** REQ-268
+- [ ] Code coverage ≥ 80% on new modules (`mode_resolver.py`,
-**Persona:** backend-engineer (scripts + pyproject)
+      `nova-idp-auth`, `nova-idp-token-vend`, PAT lifecycle).
-**Branch:** `phase/03a-inline-images`
+- [ ] CI/CD pipeline GREEN: wheel + Lambda layer publish on every merge
-**Depends on:** P2 (render_slides.sh `--theme` drop)
+      (REQ-323, CAP-035).
-
+- [ ] QA sign-off: all four happy-path journeys (J1–J4) pass integration
-### Tasks
+      tests in CI.
-
+- [ ] Security/compliance review: threat model published, Argon2id
-1. **`scripts/inline_images.py`** (REQ-268):
+      verified, ABAC policy reviewed.
-   - Stdlib only (`base64`, `re`, `mimetypes`, `sys`, `pathlib`).
+- [ ] Capability gate GREEN: CAP-001..032 remain Verified; CAP-033..038
-   - Reads the rendered HTML path (argv[1]).
+      Verified.
-   - Finds all `<img ... src="(assets/...)" ...>` (relative paths only;
+- [ ] Mode resolver property tests pass (all four priority levels + edge
-     skip absolute/`http(s)://`).
+      cases; REQ-349).
-   - Reads each referenced file, replaces `src` with
+- [ ] KMS round-trip test passes against deployed JWKS (REQ-350).
-     `data:image/<mime>;base64,<base64>`.
+- [ ] PAT revocation SLO verified: ≤60s P95 in CI (REQ-351, NFR-4).
-   - MIME by extension: `.png`→`image/png`, `.svg`→`image/svg+xml`,
+- [ ] Operator + developer guides published.
-     `.jpg/.jpeg`→`image/jpeg`, `.gif`→`image/gif`; fallback
+- [ ] `nova idp setup` succeeds in a fresh AWS account.
-     `application/octet-stream`.
+- [ ] Byte-identical Forge action on GitHub + Gitea (REQ-326, NFR-11).
-   - Writes HTML back in place; prints count inlined to stderr.
-   - Usage: `python scripts/inline_images.py <html-path>`.
-
-2. **`scripts/render_slides.sh`** (REQ-268):
-   - After Step 2 (MARP render), add Step 3: inline images into HTML
-     (`python scripts/inline_images.py "$HTML"`).
-   - Update Step 5 (stage): no change yet (python-pptx is P3b).
-   - Order now: Step 1 mermaid → Step 2 MARP HTML+PPTX → Step 3 inline
-     images → Step 4 stage.
-
-3. **Verify** (must-have):
-   - `bash scripts/render_slides.sh` produces `.html` with inlined
-     base64 images.
-   - Open the HTML from a different directory (no `assets/` folder) —
-     images display.
-   - `grep -c 'src="assets/' nova-autonomous-cloud-delivery.html`
-     returns 0 (all inlined).
-   - `grep -c 'data:image' nova-autonomous-cloud-delivery.html`
-     returns ≥2 (the deck's 2 images).
 
 ---
 
-## Phase P3b — python-pptx-generator (tag v1.22.4)
+## Plan completeness checklist
 
-**Requirements:** REQ-269, REQ-270
+- [x] Every REQ-323..353 mapped to a phase + wave + task.
-**Persona:** backend-engineer (scripts + pyproject) + lead-developer
+- [x] Every CAP-033..038 mapped to a phase + gate rule.
-(deck structure consultation)
+- [x] Every INV-12..17 referenced in persona constraints.
-**Branch:** `phase/03b-python-pptx`
+- [x] Every D-226..231 referenced in task rationale.
-**Depends on:** P3a (stable render_slides.sh with inline step)
+- [x] Vertical slices: each phase ships independently (P1 CLI substrate
-
+      is useful before P2 packaging; P2 before P3 auth; etc.).
-### Tasks
+- [x] Wave ordering within phases (no wave N+1 depends on wave N work
-
+      in the same phase).
-1. **`scripts/render_pptx.py`** (REQ-269):
+- [x] Persona assignments per task (4 active personas).
-   - Dependency: `python-pptx>=0.6.23` (import at module load; if
+- [x] MVP/UX CHECK: 3 sections present (User-Facing Surface, Happy Path,
-     absent, print "pip install -e .[slides]" and exit 1).
+      UX Acceptance Criteria).
-   - Parses `nova-autonomous-cloud-delivery-marp.md`:
+- [x] Highest-risk item flagged (P4 Wave 1 kj-binary spike).
-     - Frontmatter (skip YAML between `---` markers).
+- [x] Grill conditions applied (3 critical + 16 tracked; see GRILL.md).
-     - `---` slide separators.
-     - `#`/`##` headings → slide title.
-     - `<!-- ... -->` HTML comments → skipped (speaker notes/talking
-       points).
-     - `- `/`* ` bullets → bullet list.
-     - `**bold lead**` (first paragraph after title) → bold lead.
-     - `> blockquote` → blockquote-styled paragraph.
-     - ` ```lang ... ``` ` → code block (monospace text frame).
-     - `![alt](path)` → `add_picture` (embedded in ppt/media/).
-     - `| ... |` tables → native PPTX table (`add_table`).
-     - `<div class="benefit">text</div>` → benefit callout
-       (italic text frame with red top border accent).
-   - Produces 16:9 PPTX (`prs.slide_width = Inches(13.333)`,
-     `prs.slide_height = Inches(7.5)`):
-     - Title slide: black background, red top bar
-       (`MSO_SHAPE.RECTANGLE`, fill `#D6002A`, height ~0.4"), white H1
-       (Arial — Akkurat Pro not installed; PowerPoint does OS
-       substitution).
-     - Content slides: blank layout; red H2 title text box at top;
-       bold lead paragraph (red `**strong**`); bullets; blockquote
-       (indent + red left accent via thin rectangle); embedded PNGs
-       (centered, scaled to fit content area); native tables (grey
-       header, red bottom border); benefit callout (italic, red
-       top-rule accent).
-     - Font: "Akkurat Pro" (PowerPoint falls back to OS default if
-       absent — acceptable; the HTML is the pixel-perfect artifact).
-   - Output: `docs/presentations/nova-autonomous-cloud-delivery-python.pptx`.
-   - Usage: `python scripts/render_pptx.py [deck-name]` (defaults to
-     `nova-autonomous-cloud-delivery`).
-
-2. **`pyproject.toml`** (REQ-269):
-   - Add to `[project.optional-dependencies]`:
-     ```toml
-     slides = ["python-pptx>=0.6.23"]
-     ```
-
-3. **`scripts/render_slides.sh`** (REQ-270):
-   - Add Step 4: python-pptx render → `*-python.pptx`.
-   - Update Step 5 (stage): add `*-python.pptx`.
-   - Final order: Step 1 mermaid → Step 2 MARP HTML+PPTX → Step 3
-     inline images → Step 4 python-pptx → Step 5 stage.
-
-4. **`scripts/attach_release_asset.py`** (REQ-270):
-   - Extend to accept multiple asset paths (both `.pptx` +
-     `-python.pptx`). Backward-compatible (single arg still works; or
-     accept a list). MARP PPTX is the primary attachment (first).
-
-5. **Verify** (must-have):
-   - `bash scripts/render_slides.sh` produces 3 artifacts: `.html`
-     (with inlined base64 images), `.pptx` (MARP), `-python.pptx`
-     (structured).
-   - Open `-python.pptx` — 16:9, title slide black with red bar, content
-     slides with red titles + bullets + tables + images.
-   - `-python.pptx` is a valid zip (PPTX signature).
 
 ---
 
-## Phase P4 — trim-wordcount + repo-wide "penetrate" purge (tag v1.22.5)
+## Cost envelope (C-3.1)
 
-**Requirements:** REQ-271, REQ-272
+Monthly estimate for the default (no CloudFront) Nova-idp deployment in
-**Persona:** lead-developer (deck markdown + talking-points + docs +
+account `581513795199`:
-.ciagent)
-**Branch:** `phase/04-trim-wordcount`
-**Depends on:** P3b (stable render_slides.sh; trimmed deck is what P3b's
-parser already handles — P4 does not break P3b's parser because the
-parser handles the pre-trim structure and P4 trims prose, not
-structure)
 
-### Tasks
+| Resource | Quantity | Pricing | Est. monthly |
+|----------|----------|---------|-------------|
+| DynamoDB (on-demand) | 4 tables | $1.25/1M write, $0.25/1M read | ~$1 (pilot volume) |
+| DynamoDB PITR | 4 tables | $0.20/GB-month | ~$1 (small tables) |
+| KMS asymmetric key | 1 key | $1/key-month + $0.03/10k signs | ~$1 |
+| Lambda invocations | 3 Lambdas | $0.20/1M req + $0.000016/GB-s | ~$2 (low volume) |
+| Lambda layer storage | ~50 MB | $0.02/GB-month | <$1 |
+| CodeArtifact | 1 domain + 1 repo | $1/domain + $1/repo | $2 |
+| SSM Parameter | 1 | $0.05/param (advanced) | <$1 |
+| **Total (default)** | | | **~$9/month** |
 
-1. **Targeted word-count trim** (REQ-271) on ~8 verbose slides:
+Optional CloudFront + WAF + ACM (if `--public-jwks-domain`): +~$3/month
-   - **Slide 1 (The Problem)**: cut the "Every hour a developer
+at pilot volume. ACM is free for CloudFront-attached certs.
-     spends..." restatement paragraph (lines 29-ish); tighten bullet
-     sub-clauses. Target ~25% reduction.
-   - **Slide 5 (Scope)**: collapse bullets 1 + 3 (both say "PDLC is
-     upstream") to 3 bullets.
-   - **Slide 7 (Pipeline)**: condense bullet 1's pipe-chain; deduplicate
-     bullet 3's "Wiz on the plan" repetition.
-   - **Slide 8 (Decision Ledger)**: tighten the "AI decisions" bullet
-     from a paragraph to one sentence.
-   - **Slide 13 (Cost & ROI)**: collapse the "Honest caveat" bullet to
-     one line.
-   - **Slide 14 (Deferred)**: cut the preamble paragraph to one line.
-   - **Slide 20 (Recap + Ask)**: split the 60-word ask run-on into two
-     short sentences.
-   - **Appendix A1**: tighten the benefit callout to one line.
-   - Tables (slides 6, 9, 10, 15, 16, 17, A1) untouched.
-   - Short slides (2, 3, 4, 11, 12, 18, 19) untouched.
-   - Benefit callouts (all slides): already restyled in P2; here just
-     tighten each to one short sentence (preserve the spirit).
 
-2. **Remove "penetrate" — repo-wide purge** (REQ-272, G-001):
+This is a pilot-scale cost envelope. Production scale (100x volume)
-   - `docs/presentations/nova-autonomous-cloud-delivery-marp.md` slide 5:
+would still be <$50/month. No hidden costs identified.
-     "Nova never penetrates it. Integration is through one validated
-     contract." → "Integration is through one validated contract."
-   - `docs/presentations/nova-autonomous-cloud-delivery-talking-points.md:40`:
-     "Nova never penetrates it" → match slide 5's trimmed wording.
-   - `docs/scope.md`: reword "Nova never penetrates the PDLC" →
-     "Nova never reaches into the PDLC" (or restructure — the scope
-     boundary is already established by "downstream of PDLC").
-   - `docs/vision.md`: reword "It does not penetrate upstream product or
-     software development lifecycles" → "It does not reach into upstream
-     product or software development lifecycles".
-   - `.ciagent/PROJECT.md`: reword the 3 "penetrate" occurrences in the
-     Core Tenets #2 + Scope sections.
-   - Note: `.ciagent/RESEARCH.md` + `.ciagent/PLAN.md` meta-references
-     to "penetrate removal" are NOT purged (they describe the removal;
-     purging them would erase the decision history).
-
-3. **Verify** (must-have):
-   - `grep -ri penetrat docs/ .ciagent/PROJECT.md .ciagent/CLARIFY.md`
-     returns nothing (the term is gone from all audience-facing +
-     project-spec docs; RESEARCH.md/PLAN.md/GRILL.md meta-references
-     are exempt as decision-history).
-   - Slide count unchanged (22).
-   - `bash scripts/render_slides.sh` renders; no broken slides.
-   - Word count of trimmed slides reduced ~20-30% (manual spot-check).
-
----
-
-## Phase P5 — ci-tests-readme + review + audit + ship (Final Phase, tag v1.22.6)
-
-**Requirements:** REQ-273, REQ-274, REQ-275 (+ review/audit/ship for all REQ-263..275)
-**Persona:** backend-engineer (CI + tests) + lead-developer (README + review coordination)
-**Branch:** `phase/05-ci-tests-readme-ship`
-**Depends on:** P1, P2, P3a, P3b, P4 (asserts the final state; merged
-P5+P6 per G-004 — NFR docs milestone doesn't warrant a dedicated
-review/ship phase)
-
-### Tasks
-
-1. **CI workflows** (REQ-273):
-   - `workflows-src/slides.yml`: add `setup-python` step + `pip install
-     -e .[slides]` (or `pip install python-pptx>=0.6.23`). Pin
-     `@marp-team/marp-cli@4.5.0` + `@mermaid-js/mermaid-cli@11.16.0`
-     (match render_slides.sh). Update `git add` commit list: add
-     `*-python.pptx`.
-   - Sync to `.github/workflows/slides.yml` + `.gitea/workflows/slides.yml`
-     via `scripts/sync_workflows.py`.
-
-2. **Tests** (REQ-274):
-   - `tests/test_slides_pipeline.py` updates (per research finding 5):
-     - Delete/invert `test_marp_deck_not_using_default_theme` (we now
-       USE `theme: default`).
-     - `test_marp_deck_uses_sp_theme` → rewrite to assert the inline
-       `style:` block has S&P properties (`#D6002A`, `#1B1B1B`,
-       `section.title`).
-     - `test_theme_css_*` trio → retarget from standalone CSS file to
-       inline `style:` block (or delete if the inline-style assertion
-       covers it).
-     - `test_html_embeds_theme` → assert literal `#D6002A` (not
-       `--sp-red`).
-     - `test_source_md_*` → delete (plain `.md` is gone).
-     - `test_render_slides_pins_cli_versions` → keep, extend to assert
-       `python-pptx` is in `pyproject.toml`.
-     - `test_no_penetrate_term` (new, G-001): assert
-       `grep -ri penetrat docs/ .ciagent/PROJECT.md .ciagent/CLARIFY.md`
-       returns nothing (RESEARCH.md/PLAN.md/GRILL.md meta-references
-       exempt as decision-history).
-     - `test_html_images_inlined_as_base64` (new): assert rendered
-       HTML has zero `src="assets/` references and ≥1
-       `data:image/png;base64` per image the deck uses.
-     - `test_python_pptx_exists` (new): assert
-       `nova-autonomous-cloud-delivery-python.pptx` exists + is a valid
-       zip (PPTX signature).
-     - `test_nova_sp_theme_css_retained_as_reference` (new): assert
-       the file exists + has the "Not loaded at render" comment.
-     - `test_benefit_callouts_use_class` (new): assert `-marp.md` has
-       `class="benefit"` and no `**Benefit:**` prefix.
-   - New `tests/test_pptx_generator.py`:
-     - `test_slide_count`: python PPTX slide count == 22 (title + 20 +
-       appendix).
-     - `test_title_slide_colors`: title slide background black, red bar
-       present.
-     - `test_expected_slide_titles`: spot-check 3-5 slide titles match
-       the markdown.
-     - `test_table_rendering`: a slide with a table (e.g., RACI) has a
-       native PPTX table shape.
-     - `test_image_embedding`: a slide with an image has a picture
-       shape.
-     - `test_benefit_callout_present`: ≥1 slide has italic benefit text.
-
-3. **README** (REQ-275):
-   - Rewrite `docs/presentations/README.md` process section:
-     - 3-step process (was 4): 1) author `*-marp.md` (sole source of
-       truth, with `<!-- Speaker notes: -->` + `<!-- Talking points: -->`
-       comments); 2) render HTML + dual PPTX (`render_slides.sh`:
-       mermaid → MARP HTML+PPTX → inline images → python-pptx); 3)
-       talking points (mirrored from deck comments).
-     - Drop the plain `.md` row from the decks table.
-     - Add `inline_images.py` + `render_pptx.py` + `-python.pptx` rows
-       to the tooling section.
-     - Note `nova-sp-theme.css` retired (reference only; inline `style:`
-       is the live styling).
-     - Document the dual-PPTX output (MARP image-of-slide primary +
-       python structured for comparison/editing).
-
-4. **Multi-persona code review** (`ciagent-review`):
-   - Review all changes in `milestone/v1.23-deck-cleanup-python-pptx`.
-   - Auto-apply P0 fixes; flag P1+ for post-hoc review.
-   - If P1+ found: fix in this phase.
-
-5. **Audit** (`ciagent-audit`):
-   - Reconstruction test: git log matches `.ciagent/` files.
-   - `.ciagent/` file discipline + branch hygiene + commit discipline.
-
-6. **Ship** (`ciagent-ship` — milestone ship):
-   - Merge `phase/05` → `milestone/v1.23-deck-cleanup-python-pptx`.
-   - Merge `milestone/v1.23-deck-cleanup-python-pptx` → `main`.
-   - Tag `v1.22.6` (final patch = milestone release).
-   - Create release with full milestone summary (all phases, all 13
-     requirements).
-   - Attach both PPTX files (MARP + python) to the release.
-   - Delete all milestone branches (local + remote). Tags preserve
-     history.
-
-7. **Complete the milestone**:
-   - Update `REQUIREMENTS.md` — mark all v1.23 requirements complete.
-   - Update `ROADMAP.md` — mark v1.23 complete.
-   - Commit: `docs(milestone): complete v1.23 — Nova Deck Cleanup & Python PPTX`.
-
-8. **Verify** (must-have):
-   - `pytest tests/test_slides_pipeline.py tests/test_pptx_generator.py`
-     all pass.
-   - CI workflow YAML is valid.
-   - README reflects the new pipeline.
-
----
-
-## Versioning
-
-- NFR milestone → progressive patches on v1.22.x line.
-- `v1.22.0` (P0) → `v1.22.1` (P1) → `v1.22.2` (P2) → `v1.22.3` (P3a) →
-  `v1.22.4` (P3b) → `v1.22.5` (P4) → `v1.22.6` (P5 final = milestone
-  release). No separate minor tag. 6 phases total (was 7; P5+P6 merged
-  per G-004, P3 split into P3a+P3b per G-003).
-
-## Risk Mitigations (from RESEARCH + GRILL)
-
-1. **Default theme padding** — explicitly set
-   `section { padding: 48px 56px 40px }` in the inline `style:` block
-   (don't rely on default's `56px 64px` which doesn't reserve
-   header/footer space).
-2. **python-pptx font fallback** — use "Akkurat Pro" in the PPTX
-   (PowerPoint does OS substitution); the HTML is the pixel-perfect
-   artifact, the python PPTX is for comparison/editing.
-3. **Marp version drift** — marp-cli pinned at 4.5.0 (already).
-4. **Speaker notes stripped** — Marp strips HTML comments from rendered
-   slides but they persist in the source `-marp.md` (acceptable; they're
-   for authors, not the audience).
-5. **`test_html_embeds_theme`** — update to assert literal `#D6002A`
-   (not `--sp-red`).
-6. **P3b parser overflow** (G-003) — isolated in its own phase so a
-   parser setback doesn't block inline-images (P3a) or trim (P4).
-7. **"penetrate" purge scope** (G-001) — repo-wide, not just
-   `docs/presentations/`; RESEARCH.md/PLAN.md/GRILL.md exempt as
-   decision-history.

.ciagent/STATE.md

@@ -0,0 +1,286 @@
+# Nova — System State (what exists today)
+
+> **PO-owned catalog of shipped capabilities.** Updated at every milestone
+> ship (P final). Additive only — entries are appended, never rewritten,
+> unless a capability is explicitly deprecated (then marked, not deleted).
+> Read by the PO upstream of the PDLC before authoring new REQ-NNN specs,
+> and by CIAgent at SPECIFY for capability awareness.
+>
+> **Authority:** this file is *descriptive of shipped state*, not
+> authoritative for live phase/ship state — that's `CHECKPOINT.json`. For
+> *why*, read `NORTH_STAR.md`. For *how*, read `ARCHITECTURE.md`. For
+> *what was decided*, read `PROJECT.md` load-bearing decisions.
+>
+> **Last milestone ship:** v1.27 (`v1.26.3`, 2026-08-19) — PO State Catalog
+> & Ciagent Compression NFR milestone. No new capabilities this
+> milestone (NFR); v1.27 authored this file + compressed `.ciagent/`.
+> **Next update:** at v1.28 ship.
+
+## How to use this file (PO)
+
+- Before writing a new REQ: search this file for the capability you
+  intend to spec. If it exists, extend it; do not re-spec it under a new
+  REQ-NNN.
+- Respect the **Invariants** below — they are load-bearing and
+  cross-cutting. A new REQ that violates an invariant requires a
+  `CLARIFY` decision recorded in PROJECT.md.
+- Anchor each new REQ to a **Domain**; new domains require a PO
+  decision recorded in CLARIFY.
+- When a capability is deprecated (replaced, removed, or
+  re-architecture), append a `Deprecated` row marking the milestone +
+  replacement; do not delete the original entry.
+
+## Invariants (PO-owned — do not violate in new REQs)
+
+> Distilled from `PROJECT.md` load-bearing decisions D-034..D-072 +
+> W1..BA + Q1.3. Cite the decision ID when an REQ touches one.
+
+- **INV-1 (Contract surface):** The only PDLC→Nova boundary is
+  `schemas/contract.schema.json` + `schemas/submission-readiness.schema.json`
+  (D-133). All consumer intent enters through one of these. Nova never
+  reaches into upstream PDLC.
+- **INV-2 (Confidence inputs):** Six canonical inputs — policy (0.30),
+  validation (0.25), freshness (0.10), source (0.15), history (0.10),
+  nfrs (0.10). Weights frozen for v1 (D-040). `critical` severity =
+  hard-block via `PENALTY["critical"]: None` (defense-in-depth behind the
+  declarative `block-on-any-critical` meta-policy).
+- **INV-3 (HITL gates):** dev = autonomous (≥0.50); qa = HITL (≥0.75);
+  prod = HITL (≥0.90); dr = HITL (≥0.95). Approver identity = Gitea
+  `gitea.actor` of the `workflow_dispatch` (D-042). Separation-of-duties
+  on prod reads `approver_qa` from the DynamoDB outbox.
+- **INV-4 (Engine is swappable):** The policy engine is behind the
+  `PolicyEngine` protocol (`core/policy_engine.py`, v1.25). Confidence
+  signal + pipeline import only the protocol, never a concrete engine.
+  `kyverno-json` is the v1.25 default; `OPA` (or other) implements the
+  same 3-method protocol to replace it.
+- **INV-5 (Adapter is stateless):** `adapters/terraform/adapter.py` owns
+  no module content — no `TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP` (v1.11
+  rewrite). A new stack type requires a new L1 module
+  (`modules/l1/<name>/`) + `registry.json` entry, not an adapter change.
+- **INV-6 (Audit stream is immutable):** Outbox writes via SQLite
+  hash-chain today (D-083 deferred). S3 Object Lock / JWS tamper-
+  *resistant* ledger is a future milestone. Current stream is tamper-
+  *evident* (any tampering breaks the chain).
+- **INV-7 (PCR schema is the moat):** `schemas/policy_check_result.schema.json`
+  shape is frozen across adapter swaps (v1.25 hard constraint). The
+  `engine` enum already includes `"kyverno"` + `"opa"`; new engines add
+  no enum value.
+- **INV-8 (Long-lived creds forbidden):** §12.5. The D-039/D-047 per-run-
+  rotated-key waiver satisfies the *intent* (no *persistently* long-lived
+  key). Real OIDC federation is blocked on `go-gitea/gitea#36988`.
+- **INV-9 (Two consumer surfaces, one platform):** L3A (developer) +
+  L3B (citizen dev) converge on the same contract schema, the same
+  policy envelope, and the same evidence stream.
+- **INV-10 (Nova is downstream of PDLC):** Nova governs infra + delivery
+  only. Product backlog, code authorship, IDE workflows, application
+  business logic are upstream. Integration only via the validated
+  contract boundary (INV-1).
+- **INV-11 (Pilot scope, v1.26):** Equities only (D-200). Single-
+  validator PoA (D-201). D-083 (Object Lock/JWS) stays deferred. Hot
+  path deferred (D-126). Multi-cloud deferred. Multi-validator BFT
+  deferred. The pilot runs `mode: full` for `dev` only (D-209); qa/prod/dr
+  stay placeholder (D-208, blocked by the pilot-readiness policy).
+
+## Domains (capability groups)
+
+1. Contract surface
+2. Modules (L1 primitives + L2 patterns)
+3. Policy engine
+4. Confidence signal
+5. Environments & promotion
+6. Evidence stream & audit
+7. Telemetry & metrics
+8. Consumer surfaces (developer + agentic)
+9. Pilot estate (v1.26)
+10. Forge / CI runtime
+
+## Capabilities (additive — one row per shipped capability)
+
+> Tier: **local** = runs via emulating adapters (no AWS); **live-aws** =
+> runs against the live AWS account `581513795199`;
+> **lifecycle-pipeline** = verified via the `modules-lifecycle`
+> pipeline's apply→modify→destroy matrix cell.
+> CAP-NNN IDs cross-reference the regression gate at
+> `core/regression_verify.py` (the machine registry). This file is the
+> PO-facing narrative; the machine registry is the source of truth for
+> the gate.
+
+### Domain 1 — Contract surface
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-001 | `contract.schema.json` validates sample contracts | v1.1 / `v1.2.0` | `schemas/contract.schema.json` | REQ-001, D-... | local | shape: id/name/environment/infrastructure |
+| CAP-002 | `environment.schema.json` validates env files | v1.9 / `v1.9.0` | `schemas/environment.schema.json` | REQ-040 | local | dev/qa/prod/dr env JSONs |
+| CAP-006 | Contract interpolation expands `${env.*}` / `${contract.*}` | v1.9 / `v1.9.0` | `core/contract_resolver.py` | REQ-040 | local | per-env variants |
+| — | Submission-readiness gate (superset of contract schema) | v1.18 / `v1.18.0` | `schemas/submission-readiness.schema.json`, `core/submission_readiness.py` | REQ-217, REQ-218, D-133 | local | the only PDLC→Nova boundary (INV-1) |
+
+### Domain 2 — Modules (L1 primitives + L2 patterns)
+
+> Source: `modules/registry.json` (the authoritative module catalog).
+> STATE.md lists the *capability* of having a registered module;
+> registry.json is the live registry.
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-003 | contract_resolver resolves `static-assets` (L2) | v1.1 / `v1.2.0` | `core/contract_resolver.py`, `modules/l2/static-assets/` | REQ-003 | local | CloudFront+WAF+S3 pattern |
+| CAP-004 | contract_resolver resolves `microservice` (L2) | v1.2 / `v1.3.0` | `core/contract_resolver.py`, `modules/l2/microservice/` | REQ-004 | local | ECS Fargate pattern (6 L1 children) |
+| CAP-005 | Terraform adapter compiles resolved stack to `.tf` | v1.1 / `v1.2.0` | `adapters/terraform/adapter.py` | REQ-005 | local | stateless assembler (v1.11); emits `module "<rid>" { source }` blocks |
+| — | L1 `s3` primitive | v1.1 / `v1.2.0` | `modules/l1/s3/` | REQ-005 | lifecycle | versioning + SSE-KMS by default |
+| — | L1 `vpc` primitive | v1.1 / `v1.2.0` | `modules/l1/vpc/` | REQ-005 | lifecycle | shared platform VPC (v1.11) |
+| — | L1 `ecs-cluster` primitive | v1.1 / `v1.2.0` | `modules/l1/ecs-cluster/` | REQ-005 | lifecycle | |
+| — | L1 `ecs-service` primitive | v1.1 / `v1.2.0` | `modules/l1/ecs-service/` | REQ-005 | lifecycle | execution_role_arn + task_role_arn wired (P4 W1 fix, v1.26) |
+| — | L1 `iam-role` primitive | v1.1 / `v1.2.0` | `modules/l1/iam-role/` | REQ-005 | lifecycle | |
+| — | L1 `alb` primitive | v1.1 / `v1.2.0` | `modules/l1/alb/` | REQ-005 | lifecycle | requires SG wire (P4 W1 fix, v1.26) |
+| — | L1 `ecr` primitive | v1.1 / `v1.2.0` | `modules/l1/ecr/` | REQ-005 | lifecycle | |
+| — | L1 `cloudfront` primitive | v1.7 / `v1.7.0` | `modules/l1/cloudfront/` | REQ-049, D-049 | lifecycle | OAC + WAF (production edge) |
+| — | L1 `waf` primitive | v1.7 / `v1.7.0` | `modules/l1/waf/` | REQ-049, D-049 | lifecycle | |
+| — | L1 `rds` primitive | v1.7 / `v1.7.0` | `modules/l1/rds/` | REQ-059, D-059 | lifecycle | multi-engine input (postgres/mysql/...) |
+| — | L1 `kms-key` primitive | v1.8 / `v1.8.0` | `modules/l1/kms-key/` | REQ-069, D-069 | lifecycle | per-stack CMK; 90-day rotation |
+| — | L1 `uptime` primitive | v1.8 / `v1.8.0` | `modules/l1/uptime/` | REQ-066, D-066 | lifecycle | uptime-kuma on ECS Fargate |
+| — | L1 `dynamodb` primitive | v1.26 / `v1.25.2` | `modules/l1/dynamodb/` | REQ-322 | local | PK + optional SK; PAY_PER_REQUEST; encryption + PITR by default (v1.8 NFRs) |
+| CAP-013 | `terraform init+validate+plan` live AWS (microservice) | v1.2 / `v1.3.0` | `adapters/terraform/adapter.py` | REQ-013 | live-aws | 14 resources; plan saved |
+| CAP-014 | `terraform init+validate+plan` live AWS (static-assets) | v1.7 / `v1.7.0` | `adapters/terraform/adapter.py` | REQ-014 | live-aws | CloudFront+WAF+S3 plan OK |
+| CAP-017 | DynamoDB `nova-contracts` table | v1.7 / `v1.7.0` | `core/lambda/`, `terraform/` | REQ-068, D-068 | lifecycle | PK `changeRequestId`, SK `submittedAt` (CMDB) |
+| CAP-018 | Lambda contract-ingestor | v1.7 / `v1.7.0` | `core/lambda/contract_ingestor.py` | REQ-051, D-051 | lifecycle | local stub + lifecycle evidence |
+| CAP-019 | ECS cluster + service (L2 microservice) | v1.7 / `v1.7.0` | `modules/l2/microservice/` | REQ-066 | lifecycle | apply/modify/destroy exit 0 |
+| CAP-020 | CloudFront + WAF production stack | v1.7 / `v1.7.0` | `modules/l2/static-assets/` | REQ-049 | lifecycle | apply/modify/destroy exit 0 |
+| CAP-021 | uptime-kuma monitoring primitive | v1.8 / `v1.8.0` | `modules/l1/uptime/` | REQ-066 | lifecycle | |
+| CAP-022 | OIDC role for act_runner | v1.11 / `v1.11.0` | `terraform/bootstrap/` | REQ-116, D-039 | lifecycle | real OIDC blocked on go-gitea/gitea#36988 |
+
+### Domain 3 — Policy engine
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| — | `PolicyEngine` Protocol + `PolicyEngineRegistry` | v1.25 / `v1.24.1` | `core/policy_engine.py` | REQ-291, REQ-292 | local | selects engine from `config.json.policy.engine`; `NullEngine` fallback when key absent |
+| — | `KyvernoJsonEngine` adapter (shells to `kj scan`) | v1.25 / `v1.24.1` | `adapters/kyverno-json/kyverno_json_engine.py` | REQ-293, REQ-294 | local | `is_configured()` guards on `which kj`; `SKIPPED` PCR when absent |
+| — | Contract policies (4) over consumer contract JSON | v1.25 / `v1.24.2` | `adapters/kyverno-json/policies/contract/` | REQ-295, REQ-296 | local | id-pattern, env-enum, infra-min-1, forbid-unknown-fields |
+| — | Stack-IR policies (3) over resolved Target Stack IR | v1.25 / `v1.24.2` | `adapters/kyverno-json/policies/stack-ir/` | REQ-297, REQ-298, REQ-299 | local | tagging-standard, public-ingress, encryption-by-default |
+| — | Plan-JSON policies (3) over `terraform show -json` | v1.25 / `v1.24.3` | `adapters/kyverno-json/policies/plan-json/` | REQ-300, REQ-301, REQ-302 | local | plaintext-secrets, iam-wildcard, kms-reference |
+| — | Meta-policies over merged PCR list | v1.25 / `v1.24.3` | `adapters/kyverno-json/policies/meta/` | REQ-303 | local | `block-on-any-critical` (declarative critical-block); `tagging-rules-agree` (Checkov↔kj agree) |
+| — | Regression-gate policies (3) over capability-inventory JSON | v1.25 / `v1.24.4` | `adapters/kyverno-json/policies/regression/` | REQ-304, REQ-305 | local | declarative mirrors of CAP-013/023/024 imperative checks |
+| — | Pilot-readiness policy (no placeholder account) | v1.26 / `v1.25.3` | `adapters/kyverno-json/policies/pilot-readiness/no-placeholder-account.json` | REQ-320 | local | fail-closed gate; blocks apply on `account_id == "000000000000"` |
+| — | Settlement-finality policy | v1.26 / `v1.25.3` | `adapters/kyverno-json/policies/settlement-finality/all-matches-committed.json` | REQ-315 | local | authored + tested; enforcement deferred to milestone that binds qa/prod/dr (D-208) |
+| — | Checkov adapter (raw-finding source) | v1.7 / `v1.7.0` | `adapters/terraform/checkov_adapter.py` | REQ-053 | local | feeds meta-policies; `NOVA_TAG_NAMING` custom rule is the TF-static source of truth |
+| — | Wiz adapter (raw-finding source) | v1.7 / `v1.7.0` | `adapters/wiz/` | REQ-053 | local | API findings; `is_configured()` guard |
+| — | K8s Kyverno adapter (documentation-only) | v1.7 / `v1.7.0` | `adapters/kyverno/` | REQ-053, D-053 | local | inactive for Terraform-only stacks; activates when GitOps emits K8s manifests |
+
+### Domain 4 — Confidence signal
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-007 | `confidence_signal.compute` returns a band | v1.1 / `v1.2.0` | `core/confidence_signal.py` | REQ-007, D-040 | local | 6 inputs (INV-2); band ∈ {pass, block} |
+| — | `escalation_reason: 'confidence'` on `band == 'block'` | v1.26 / `v1.25.3` | `core/confidence_signal.py` | REQ-318 | local | grounds Human Escalation Frequency numerator |
+
+### Domain 5 — Environments & promotion
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| — | env-JSON `state_backend` wiring | v1.26 / `v1.25.3` | `core/environments/*.json`, `adapters/terraform/adapter.py` | REQ-319, D-... | local | adapter reads `env.state_backend.bucket` (fallback to computed name) |
+| — | Environment progression (dev autonomous → qa/prod/dr HITL) | v1.1 / `v1.2.0` | `core/env_transition.py`, `core/hitl_gates.py` | REQ-042, D-042 | local | destroy-on-environment-change (v1.24) |
+| — | Decommission mode (2-step, HITL SRE gates) | v1.8 / `v1.8.0` | `core/env_transition.py`, `scripts/run_platform.sh` | REQ-070, D-070 | local | `mode: decommission` requires `changeRequestId` |
+| — | Per-env mandatory metadata (W3.E) | v1.1 / `v1.2.0` | `schemas/submission-readiness.schema.json` | W3.E | local | dev=stack+env; qa+=e2e+load; prod+=runbook+dashboard+oncall; dr+=drDrillRef |
+
+### Domain 6 — Evidence stream & audit
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-008 | outbox_writer builds a hash-chained item | v1.1 / `v1.2.0` | `core/outbox_writer.py` | REQ-008 | local | tamper-evident (INV-6); tamper-resistant deferred (D-083) |
+| CAP-015 | DynamoDB outbox table exists + describable | v1.1 / `v1.2.0` | `core/outbox_writer.py` | REQ-015 | live-aws | `nova-outbox` (post-v1.26 re-bootstrap) |
+| CAP-016 | S3 state bucket exists + readable | v1.1 / `v1.2.0` | `terraform/bootstrap/` | REQ-016 | live-aws | `nova-tfstate-581513795199-us-east-1` |
+| — | Decision Ledger (SQLite hash-chain) | v1.17 / `v1.17.0` | `core/metrics/decision_ledger.py` | REQ-185, REQ-186 | local | cold store for metrics; `ai.decision.made` + `attestation.recorded` events |
+| — | SSM Parameter Store deploy outputs (SecureString, KMS) | v1.7 / `v1.7.0` | `core/output_publisher.py` | REQ-050, D-050 | live-aws | `/acdl/{env}/{contractId}/{output_name}` |
+| — | GitHub PR comment / job summary deploy outputs | v1.7 / `v1.7.0` | `scripts/run_platform.sh` | REQ-050, D-050 | local | no raw secrets in logs |
+| — | Uniform error reporting via Lambda `report_error` | v1.7 / `v1.7.0` | `core/lambda/contract_ingestor.py` | REQ-055, D-055 | live-aws | GitHub issue on platform repo `acdl/acdl`; idempotent |
+| — | Tagging standard enforcement (4 required tags) | v1.7 / `v1.7.0` | `schemas/tagging-standard.json`, `adapters/terraform/policy/custom_rules/nova_tagging.py` | REQ-054, D-054 | local | `nova:owner`, `nova:contract`, `nova:environment`, `nova:cost-center` |
+| — | Encryption + deletion-protection by default | v1.8 / `v1.8.0` | `modules/l1/*/terraform/main.tf` | REQ-062, REQ-069, D-062, D-069, D-072 | local | per-stack CMK; managed KMS fallback for standalone L1 (D-072) |
+
+### Domain 7 — Telemetry & metrics
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-023 | metrics collector runs + emits expected schema | v1.17 / `v1.17.0` | `core/metrics/collector.py` | REQ-194 | local | fact_run, fact_decision, fact_attestation dims |
+| CAP-024 | unified deck structure (slide count, x3 arc, per-slide benefits) | v1.17 / `v1.17.0` | `docs/presentations/nova-autonomous-cloud-delivery-marp.md` | REQ-194 | local | single source-of-truth marp deck |
+| — | Outcome backfill (`pending` → `succeeded`/`failed`) | v1.26 / `v1.25.3` | `core/metrics/outcome_backfill.py` | REQ-317 | local | idempotent + terminal; grounds AI Decision Accuracy |
+| — | Trust Snapshot | v1.17 / `v1.17.0` | `metrics/TRUST_SNAPSHOT.md`, `core/metrics/trust_snapshot.py` | REQ-194 | local | leadership-ready trust verdict |
+| — | PowerBI export (fact/dimension views + 8 placeholder views) | v1.17 / `v1.17.0` | `metrics/powerbi/` | REQ-194 | local | deferred metrics ship as documented-schema placeholders |
+| — | Pre-apply Infracost estimate | v1.17 / `v1.17.0` | `scripts/run_platform.sh` | REQ-119 | local | `nova.cost.estimated`; actual-spend CUR reconciliation deferred (D-096) |
+| — | Regression gate (`scripts/run_regression.sh`) | v1.10 / `v1.10.0` | `core/regression_verify.py`, `scripts/run_regression.sh` | REQ-090, REQ-121 | local | fails closed on any non-Verified CAP; CAP-001..025 |
+
+### Domain 8 — Consumer surfaces (developer + agentic)
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| — | Reusable deploy workflow (`deploy.yml@v1.25`) | v1.5 / `v1.5.0` | `.github/workflows/deploy.yml`, `.gitea/workflows/deploy.yml` | REQ-105 | local | `workflow_call`; modes: full/plan-only/check-only/decommission |
+| — | Consumer onboarding (developer + citizen-dev paths) | v1.1 / `v1.2.0` | `docs/ONBOARDING.md`, `docs/consumer-guide.md` | BA.E, W3.E | local | both end in a sandbox dev submission that must pass the confidence gate |
+| — | Atelier MCP server (agentic validation) | v1.18 / `v1.18.0` | `mcp/atelier/server.py` | REQ-221, REQ-222 | local | `atelier.validate_against_principles` tool |
+| — | 9 production-grade engineering skills | v1.18 / `v1.18.0` | `skills/{api,security,data,testing,observability,errors,devops,infrastructure-as-code,compliance}.md` | REQ-221, REQ-222, BA.A | local | indexed by `docs/skills.md`; review/agent-checklist.md gate |
+| — | Module examples (validated against contract schema) | v1.7 / `v1.7.0` | `modules/<name>/examples/{simple,complex}.yml` | REQ-058, D-058 | local | examples cannot drift from schema silently |
+
+### Domain 9 — Pilot estate (v1.26)
+
+> The first real consumer estate. `nova-blockchain-exchange` repo
+> (Gitea `continuous-intelligence/nova-blockchain-exchange`, local clone
+> `/root/nova-blockchain-exchange`). Homegrown PoA blockchain, equities
+> only, single validator, T+1 settlement finality = block commit.
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-026 | PoA blockchain core (block + ledger + validator) | v1.26 / `v1.25.1` | `chain/block.py`, `chain/ledger.py`, `chain/validator.py` | REQ-310, D-201 | local | single validator; SHA-256 hash chain; deterministic block production |
+| CAP-027 | Order-matching engine (limit order book) | v1.26 / `v1.25.1` | `engine/order_book.py`, `engine/order.py` | REQ-311 | local | price-time priority; partial fills |
+| CAP-028 | T+1 settlement service | v1.26 / `v1.25.1` | `settlement/service.py` | REQ-312 | local | idempotent; finality = block commit |
+| CAP-029 | Consumer `contract.yaml` (blockchain exchange) | v1.26 / `v1.25.2` | `nova-blockchain-exchange/contract.yaml`, `contracts/*.yml` | REQ-313 | local | per-env variants (dev/qa/prod); validated against contract schema |
+| CAP-030 | Consumer deploy via `deploy.yml@v1.25` (inline adapter) | v1.26 / `v1.25.2` | `nova-blockchain-exchange/.github/workflows/deploy.yml`, `.gitea/workflows/deploy.yml` | REQ-314 | local | no cross-repo `uses:` (SPEC §10 Q1); checkout `acdl/acdl @ v1.25` into `platform/`, run `run_platform.sh` |
+| CAP-025 | Live-pilot-apply regression capability (round-trip) | v1.26 / `v1.25.3` | `core/regression_verify.py` | REQ-316 | local | contract→adapter→plan→policy→confidence→attestation→outbox round-trip assertion |
+| CAP-031 | Live pilot apply evidence (`blkex-pilot-apply-v0.2`) | v1.26 / `v1.25.4` | `.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md` | REQ-316, REQ-321 | live-aws | confidence 0.800 pass; outcome backfilled; hash chain valid; live apply against `581513795199` |
+| CAP-032 | AWS key rotation scheduled workflow | v1.26 / `v1.25.3` | `workflows-src/rotate-aws-key.yml` | SPEC §5.9 | local | daily rotation; forge-agnostic token name (REQ-230) |
+
+### Domain 10 — Forge / CI runtime
+
+| ID | Capability | Shipped | Files | Controlling | Tier | Notes |
+|----|-----------|---------|-------|-------------|------|-------|
+| CAP-009 | offline pytest suite passes | v1.1 / `v1.2.0` | `tests/` | REQ-009 | local | 844 tests (v1.26 baseline) |
+| CAP-010 | `run_ci.sh` reproduces CI pipeline locally | v1.4 / `v1.4.0` | `scripts/run_ci.sh` | REQ-010 | local | offline; contract→resolver→stack→adapter→structure validated |
+| CAP-011 | headline E2E — local tier (microservice) | v1.2 / `v1.3.0` | `scripts/run_local_e2e.sh` | REQ-011, D-092 | local | emulating adapters (no AWS) |
+| CAP-012 | local E2E — static-assets (no ECS) | v1.1 / `v1.2.0` | `scripts/run_local_e2e.sh` | REQ-012 | local | |
+| — | `platform-test.yml` CI workflow | v1.4 / `v1.4.0` | `.github/workflows/platform-test.yml` | REQ-010 | local | platform repo only (consumer CI is per-consumer) |
+| — | `modules-lifecycle` pipeline (apply→modify→destroy matrix) | v1.11 / `v1.11.0` | `.github/workflows/modules-lifecycle.yml` | REQ-121, D-096 | live-aws | per-module lifecycle cell; `ci-vpc-destroy` always runs |
+| — | `release.yml` (semver + floating tag maintenance) | v1.7 / `v1.7.0` | `.github/workflows/release.yml` | REQ-... | local | `v1.25` + `v1` floating tags force-moved on merge to main |
+| — | IAM policy baseline (`acdl-spike-runner-policy`) | v1.11 / `v1.11.0` | `terraform/bootstrap/spike_runner_policy.json`, `.ciagent/IAM_POLICY.md` | REQ-116, D-095 | live-aws | regression-tested by `tests/test_iam_policy_baseline.py`; OIDC role `acdl-act-runner-role` (CAP-022) |
+| — | Local emulating adapters (no AWS) | v1.10 / `v1.10.0` | `core/local_lambda_stub.py`, `scripts/run_local_e2e.sh` | D-092 | local | proves runtime behavior without live AWS |
+
+## Archive pointers
+
+- **v1.0–v1.24 capability narrative + the 2026-07-27 re-verification sweep:**
+  `.ciagent/archive/CAPABILITY_INVENTORY-v1.10.md` (moved from
+  `.ciagent/CAPABILITY_INVENTORY.md` at v1.27). CAP-NNN IDs in this file
+  cross-reference the regression gate at `core/regression_verify.py`.
+- **v1.0–v1.24 milestone narrative:** `.ciagent/archive/PROJECT-v1.0-v1.24.md`.
+- **v1.0–v1.24 requirements (REQ-01..REQ-290):** `.ciagent/archive/REQUIREMENTS-v1.0-v1.24.md`.
+- **v1.0–v1.24 phase breakdowns:** `.ciagent/archive/ROADMAP-v1.0-v1.24.md`.
+- **v1.0–v1.24 architecture history:** `.ciagent/archive/ARCHITECTURE-v1.0-v1.24.md`.
+- **v1.26 pre-execution artifacts (CLARIFY, GRILL, IDEATE, RESEARCH):**
+  `.ciagent/archive/{CLARIFY,GRILL,IDEATE,RESEARCH}-v1.26.md` (decisions
+  D-200..D-213 folded into `PROJECT.md` load-bearing decisions + PLAN.md
+  binding revisions at v1.27 archive time).
+- **v1.26 phase verifications:** `.ciagent/archive/{VERIFY-P03,VERIFY-P04,REVIEW-AUDIT-P05}.md`.
+- **v1.26 live pilot run evidence:** `.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md`.
+- **v1.21 autonomy thesis (folded into NORTH_STAR.md Vision):** `.ciagent/archive/AUTONOMY_THESIS-v1.21.md`.
+- **v1.14 AWS cost report (predates v1.26 live pilot):** `.ciagent/archive/COST-v1.14.md`.
+
+## Update discipline
+
+This file is updated **once per milestone, at the P-final milestone-ship
+wave** (Wave 3 "milestone ship" in `PLAN.md`), alongside
+`ROADMAP.md`/`NORTH_STAR.md`/`REQUIREMENTS.md`:
+
+1. Append new capability entries for each shipped REQ (one row per
+   capability; group by domain).
+2. Mark any deprecated capability with a `Deprecated` row citing the
+   milestone + replacement.
+3. Bump the "Last milestone ship" header.
+4. Do not rewrite existing entries (additive only).
+
+Enforcement: convention (the P-final ship step names this file). A
+drift-check gate (assert every REQ marked `complete` in
+`REQUIREMENTS.md` traceability appears in STATE.md) is a future option
+if the convention drifts.

.ciagent/VERIFY.md

@@ -1,135 +0,0 @@
-# ACDL v1.10 — Verify (milestone gate)
-
-> Verify date: 2026-07-27. Verifier: ci-verifier. Milestone: v1.10 (complete, tag `v1.10.0`).
-> Scope: 4 phases (52–55), 5 commits (772ac72..2697775), 22 files, +2281/-256 lines.
-
-## Layer 1: Structural — PASS
-
-- All 8 plan-referenced files exist on disk (`core/regression_verify.py`,
-  `core/local_emulators.py`, `scripts/run_regression.sh`,
-  `tests/test_verify_regression_mode.py`,
-  `tests/test_local_emulating_adapters.py`,
-  `.ciagent/CAPABILITY_INVENTORY.md`, `REGRESSION_REPORT.md`,
-  `REGRESSION_REPORT.json`).
-- All imports resolve (`py_compile` + runtime import OK).
-- No TODO/FIXME/HACK/stub placeholders in new code (the `LocalLambdaStub`
-  is a legitimate local emulator, not a placeholder).
-- All declared exports exist (`run_regression`, `write_report`,
-  `CAPABILITY_REGISTRY`, `RegressionReport`, `CapabilityResult`,
-  `FlatFileOutbox`, `LocalEcsEmulator`, `LocalS3StateBackend`,
-  `LocalLambdaStub`, `run_local_e2e`, `is_local_tier`).
-
-## Layer 2: Behavioral — PASS
-
-- `pytest tests/ -m "not slow"`: **513 passed**, 5 deselected.
-- `pytest tests/ -m slow`: **5 passed** (2 local E2E + 3 regression
-  integration incl. live-AWS terraform plan).
-- **Total: 518 passed, 0 failed.**
-- Requirement coverage: REQ-112 (P52), REQ-113 (P53), REQ-114 (P54),
-  REQ-115 (P55) — all 4 marked `complete`.
-- Regression gate: `bash scripts/run_regression.sh` → **16/16
-  capabilities Verified** (12 local + 4 live-AWS). Milestone gate open.
-
-## Layer 3: Security (STRIDE) — PASS
-
-| Threat | Risk | Disposition |
-|--------|------|-------------|
-| Spoofing | Local Lambda stub patches `_get_dynamodb`/`_get_secrets_client`; opt-in via `ACDL_LOCAL_TIER=1`, never in prod | Accept (low) |
-| Tampering | Flat-file outbox hash-chain verification detects tampering | Accept (low) |
-| Repudiation | Regression report records per-capability status + timestamps | Accept (low) |
-| Info Disclosure | Creds read into env vars, never logged (0 cred strings in reports); ECS binds 127.0.0.1 only | Accept (low) |
-| Denial of Service | Local ECS emulator: free port, daemon thread, clean destroy | Accept (low) |
-| Elevation of Privilege | `urllib.urlopen` patched to fake response (no network egress); no eval/exec/subprocess in adapter | Accept (low) |
-
-All threats low-severity; auto-accepted per
-`config.json security.auto_accept_low_severity=true`.
-
-## Layer 4: Quality (multi-persona) — PASS
-
-| Persona | Finding | Verdict |
-|---------|---------|---------|
-| Correctness | 7 adapter defects fixed; each traceable to a terraform validate/plan error | PASS |
-| Testing | 518 tests pass; 24 new tests. P2: uptime-kuma + RDS not in registry | PASS (1 P2) |
-| Security | No creds logged; loopback-only; monkey-patches scoped to local tier | PASS |
-| Performance | Regression run ~60s; acceptable for a milestone gate | PASS |
-| Maintainability | Well-structured; adding a capability = 1 function + 1 registry entry | PASS |
-| Adversarial | Gate can't be bypassed; local E2E can't mutate cloud; no injection vectors | PASS |
-
-**0 P0, 0 P1, 1 P2 (post-hoc: expand regression registry to uptime-kuma + RDS stacks).**
-
-## Verdict
-
-**VERIFY PASS** — all 4 layers pass. The v1.10 milestone is sound:
-the pipeline regression gap is fixed (D-091), the platform is fully
-locally testable (D-092), every advertised capability is re-verified
-(D-093, 16/16 Verified), and the docs/decks match verified reality
-(D-094). 518 tests pass; the regression gate covers 16 capabilities
-including 4 live-AWS checks. 0 P0, 0 P1, 1 P2 post-hoc. Ready to ship.
-
----
-
-# ACDL — Verify (grill deliverable, commit ac11c01)
-
-> Verify date: 2026-07-27. Verifier: ci-verifier. Scope: the grill
-> deliverable (`.ciagent/GRILL.md`, phase 0, status `grill`) added in
-> commit `ac11c01` since the v1.10 audit PASS (`ab477b3`). Docs-only;
-> no code, no tests, no schema changes.
-
-## Layer 1: Structural — PASS
-
-- `.ciagent/GRILL.md` exists on disk (18250 bytes).
-- No imports to resolve (markdown docs file).
-- No TODO/FIXME/HACK/stub placeholders in the report.
-- All required sections present per grill workflow Step 5 format:
-  title, Run header, Verdict, 9 axes (1–9), Meta, Binding Decisions
-  table (12 rows), Escalations section (2 entries: G-005, G-008).
-- Commit `ac11c01` `---ci---` block is well-formed: `project: acdl`,
-  `phase: 0`, `milestone: v1.10`, `status: grill`, 12 decision ids
-  (G-001..G-012), 2 escalation lines.
-
-## Layer 2: Behavioral — PASS
-
-- `pytest tests/ -m "not slow"`: **513 passed**, 5 deselected (no
-  regressions introduced by the docs-only grill commit).
-- No new tests required (docs-only deliverable; the grill is a
-  review artifact, not a code change).
-- Requirement coverage: not applicable (phase 0, status `grill`; no
-  REQ-IDs bound to this deliverable). The grill's binding decisions
-  (G-001..G-012) are advisory and do not modify REQUIREMENTS.md per
-  grill workflow Step 7.
-
-## Layer 3: Security (STRIDE) — PASS
-
-| Threat | Risk | Disposition |
-|--------|------|-------------|
-| Spoofing | N/A (docs-only; no auth surface) | Accept (none) |
-| Tampering | Grill report is git-tracked; tampering = git history rewrite (out of scope) | Accept (low) |
-| Repudiation | Commit `ac11c01` signed by author; `---ci---` block records status + decisions | Accept (low) |
-| Info Disclosure | No credentials, keys, tokens, or PII in the report (grep scan clean) | Accept (low) |
-| Denial of Service | N/A (docs file; no runtime surface) | Accept (none) |
-| Elevation of Privilege | N/A (docs-only; no privilege surface) | Accept (none) |
-
-All threats low-or-none; auto-accepted per
-`config.json security.auto_accept_low_severity=true`.
-
-## Layer 4: Quality (multi-persona) — PASS
-
-| Persona | Finding | Verdict |
-|---------|---------|---------|
-| Correctness | 12 binding decisions traceable to evidence (commit/file/req-id); 2 escalations correctly unresolved | PASS |
-| Testing | Docs-only; 513 fast tests pass (no regression) | PASS |
-| Security | No credential leakage; no sensitive data in report | PASS |
-| Performance | N/A (docs file; no runtime cost) | PASS |
-| Maintainability | Report follows grill workflow Step 5 format exactly; appendable for future runs | PASS |
-| Adversarial | Escalations (G-005, G-008) are surfaced, not silently skipped; visible via `ciagent audit` | PASS |
-
-**0 P0, 0 P1, 0 P2.**
-
-## Verdict (grill deliverable)
-
-**VERIFY PASS** — all 4 layers pass. The grill deliverable is a
-well-formed docs-only artifact. 513 fast tests pass (no regression).
-No credential leakage. 12 binding decisions recorded; 2 escalations
-(G-005 risks, G-008 budget) correctly surfaced for human resolution.
-The grill does not modify PROJECT.md, ROADMAP.md, or REQUIREMENTS.md
-(per grill workflow Step 7).

.ciagent/archive/ARCHITECTURE-v1.0-v1.24.md

@@ -0,0 +1,945 @@
+# Nova — Architecture (v1.1 target)
+
+> Target architecture for the real Agentic Cloud Delivery Platform (rebranded
+> Nova in v1.15). Source of truth for **how**: `docs/architecture.md` (v0.2) is the upstream
+> draft; this file is the Nova-repo operating copy, refined at phase
+> boundaries. Where this file and `docs/vision.md` conflict, the vision wins.
+
+## Status
+
+Architecture is at **v0.2** upstream (`docs/architecture.md`). Milestone v1.1
+**finalizes it to v1.0** in Phase 07 by resolving the 11 open decisions
+(see `PROJECT.md` open-decision resolutions table). This file records the
+locked commitments and the v1.1 spike scope.
+
+## Overview
+
+The platform is **four layers + six cross-cutting concerns**. The sixth
+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.
+
+```
+                  ┌──────────── acdl-contracts ────────────┐
+  Developer ───▶  │ commit contract.yaml                   │   (L3A)
+  Citizen dev ──▶ │ Issue → agent → contract.yaml            │   (L3B)
+                  └────────────────┬───────────────────────┘
+                                   │ (push)
+                                   ▼
+                         ┌──────────────────────┐
+                         │ central pipeline      │
+                         │ (acdl repo, Gitea      │
+                         │  Actions / act_runner) │
+                         └────────┬─────────────┘
+                                  │
+        ┌─────────────────────────┼─────────────────────────┐
+        ▼                         ▼                           ▼
+  contract→IR resolution   policy (Checkov/Kyverno)    confidence signal
+        │                         │                           │
+        ▼                         ▼                           ▼
+  Terraform adapter ──▶ terraform plan ──▶ PolicyCheckResult ──▶ {score,band}
+        │                                                                │
+        ▼                                                                ▼
+  dev (autonomous, ≥0.50)   qa (HITL, ≥0.75)   prod (HITL, ≥0.90)   dr (HITL, ≥0.95)
+        │
+        ▼
+  DynamoDB outbox ──▶ S3 Object Lock (7-yr, source of truth) ──▶ GitHub audit repo (hot index)
+        │
+        ▼
+  acdl-evidence (timeline UI)
+```
+
+## Layers
+
+### Layer 1 — Foundational Primitives
+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).
+
+- No inter-L1 references. L1 may call Terraform data sources.
+- Semver: interface → MAJOR, behavior → MINOR, lifecycle → PATCH (W3.D).
+- Immutability on publication. 12-month deprecation window.
+- AI refinement is a flag; the trigger is the W1.A joint condition.
+
+### Layer 2 — Composed Stacks
+Combine L1 primitives into deployable shapes. Each codebase maps to one
+canonical L2 stack (`multiStack: true` only per W1.B). Shape X
+(parameterized module) or Shape Y (thin-composition layer). Hierarchical
+composition, max depth 5, only registered L1s. The thin-composition tree's
+`wires` field is defined against the IR's relationship type, not a Terraform
+module block.
+
+Pipeline quality checks: secrets-in-plaintext, public ingress, IAM
+wildcard, KMS key reference, tag compliance, naming convention. Restricted
+from thin-composition: IAM principal creation, network boundary creation,
+key/secret creation, external data transfer. Auto-promote after 3 observed
+usages.
+
+### Layer 3A — Developer Consumer Surface
+Tag-based reference to the central pipeline template. Developer-owned
+workflow file, no platform auto-sync. L3A and L3B are parallel paths, not a
+progression. **W2.A (Path B):** tag for dev/qa, SHA for prod; platform CLI
+resolves tag→SHA for prod-bound workflows.
+
+### Layer 3B — Agentic Consumer Surface
+Hybrid runtime, skill as markdown, agent as executor. Trust model: trust
+and always verify on the platform side. Skill envelope (4 dimensions).
+Stateless agents, all state in the platform. `profile: agentic` marker
+unlocks `naturalLanguageIntent`, `confidenceAtSubmission`, `agentTrace`.
+Initial skill catalog (BA.A): web API, worker, scheduled job, static asset,
+basic observability bootstrap.
+
+Environment progression:
+
+| Environment | Autonomy | Attester | Gate |
+|---|---|---|---|
+| dev | Full autonomy (no HITL) | — | Confidence ≥ 0.50, all six inputs present |
+| qa | Held for attestation | QA | GitHub Deployment approval + full QA matrix (§10) |
+| prod | Held for attestation | SRE | GitHub Deployment approval + full SRE matrix (§10) |
+| dr | Held for attestation | SRE | GitHub Deployment approval + dr-drill evidence |
+
+**Staging is removed.** Dev is the only autonomous environment.
+
+## Cross-cutting concerns
+
+### Central pipeline template (§6)
+JSON Schema (draft 2020-12) with a thin domain wrapper. Central repo +
+generated client libraries. Multi-stage validation: schema → policy → NFR →
+confidence. Distributed enrichment. GitOps reconciler (K8s API; cdlc-gitops
+state → CRDs) + Terraform execution layer (§12.5). The pipeline emits one
+`PolicyCheckResult` per policy rule; the confidence signal consumes them as
+one normalized input.
+
+### Contract schema (§7)
+Central repo + generated client libraries. Strict fail-fast at schema
+stage, multi-stage validation with reason codes from a published
+vocabulary. **W3.E:** per-env mandatory inputs —
+- dev: `stack`, `environment`
+- qa adds: `validation.e2eSuite`, `validation.loadTest`
+- prod adds: `runbook`, `dashboard`, `oncall`
+- dr adds: `drDrillRef`
+- `inputs` always optional; `profile: agentic` fields optional everywhere.
+
+### Confidence signal (§8)
+Six canonical inputs, weighted sum with per-input breakdown. Per-env
+thresholds: dev ≥ 0.50, qa ≥ 0.75, prod ≥ 0.90, dr ≥ 0.95. Structured output
+`{ score, band, perInput, reasonCodes }`. 1-year storage, no retraining in
+v1. Halt with explicit reason on missing input.
+
+Policy input = list of `PolicyCheckResult` records (engine-agnostic).
+Severity → penalty: critical → hard override to mandatory block; high →
+-0.2; medium → -0.05; low → -0.01; info → 0.0. One critical finding
+hard-overrides the score regardless of all other inputs.
+
+**BA.B:** thresholds frozen for v1; tuning begins v1.2 (quarterly FP/FN
+tracking; override = Infra & Ops + SRE joint sign-off, itself a
+confidence-event).
+
+### Audit and evidence stream (§9)
+Tiered ledger: **S3 with Object Lock in compliance mode** (cold, source of
+truth, 7-year retention) + **GitHub audit repo** (`acdl-evidence`, hot
+query index, not part of the chain). Daily checkpoints. Event schema: JWS
+detached signature, `prev_event_hash` chain, controlled-vocabulary
+`event_type`. Outbox pattern: local durable outbox + async worker.
+
+Outbox database = **DynamoDB**. RPO = 0 (synchronous write to local outbox
+before contract submission ack); RTO = async worker's dead-letter recovery.
+Single-region in v1. The outbox also stores per-contract QA and prod
+approver identities (the only durable record outside GitHub's audit log).
+
+### Human-in-the-Loop mechanics (§10)
+Pre-execution gates. qa, prod, dr are PR-based attestation gates backed by
+GitHub Environments with required reviewers. No partial deployment to roll
+back on rejection (qa, prod); dr is a separate GitHub Deployment against a
+separate cluster/region.
+
+Reviewer routing: GitHub CODEOWNERS + Environment required reviewers
+(qa → QA; prod → SRE; dr → SRE). CODEOWNERS routes, does not enforce
+identity distinctness.
+
+**Separation of duties** (platform-internal, not GitHub-native, not Kyverno
+in v1): on dev→qa promotion the platform writes the QA approver's GitHub
+identity to the DynamoDB outbox keyed by `contractId`; on qa→prod it reads
+the stored QA approver and the new SRE approver; if equal, it blocks, emits
+`SEPARATION_OF_DUTIES_VIOLATION`, and routes a halt artifact to SRE on-call.
+
+Full 8-concern attestation matrix (functional, performance, security
+posture, contract NFRs, operational readiness, incident response,
+capacity/cost, resilience) — see `docs/architecture.md` §10.4.
+
+Timeout: 1 business day = warn + escalate; 2 business days = auto-freeze +
+re-submit (linked via `supersedes`). Rejection returns the contract to HELD;
+the audit chain is extended, not torn up.
+
+### Agentic stack (§11)
+Hybrid runtime: platform-managed control plane + consumer-owned agent.
+Versioned, signed skill catalog over MCP. Skill envelope enforced on
+invocation and result submission. Consumer-owned skill execution; the
+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).
+
+### 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 engine.
+
+**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.
+
+v1 reality: the IR is shaped to round-trip cleanly to Terraform (nearly
+isomorphic). As more adapters appear, the IR gets more expressive and the
+adapters gain translation logic; the L1 content, the YML standard, and the
+thin-composition tree do not change.
+
+**Terraform adapter (v1):** translates IR-typed L1 interface → Terraform
+`variable`/`output` blocks; IR-typed L2 thin-composition tree → Terraform
+root module; IR-typed relationships → module references; emits a
+`terraform plan` from the IR. The adapter is a thin layer; it does not own
+L1/L2 content.
+
+State storage: S3 (state) + DynamoDB (locking), cloud-managed,
+single-region in v1.
+
+Policy toolchain: **Checkov** for Terraform plan policy (the L2 checks +
+tag/naming); **Kyverno** for K8s-native/platform-internal policy; **OPA**
+reserved for cross-resource cases, explicitly last resort.
+
+**Policy result normalization (§12.6):** the confidence signal consumes a
+normalized `PolicyCheckResult` schema, not raw engine output.
+
+```json
+{
+  "contractId": "uuid",
+  "evaluatedAt": "ISO-8601",
+  "engine": "checkov | kyverno | opa",
+  "ruleId": "CKV_AWS_24 | KYVERNO_NO_PRIVILEGED | ...",
+  "severity": "critical | high | medium | low | info",
+  "result": "pass | fail | skipped | error",
+  "message": "human-readable",
+  "evidence": { "...engine-specific, opaque to the signal..." },
+  "resourceRef": "IR-typed resource identifier"
+}
+```
+
+Execution layer: GitHub/Gitea Actions in the central pipeline repo. State
+locking via DynamoDB. **AWS credentials via OIDC federation — long-lived
+credentials are forbidden** (§12.5). The platform does not run
+`terraform apply` against a developer's workstation; all execution is in
+the central pipeline.
+
+Registry maintenance: L1 publication updates the L1 registry in the same
+PR. The registry is the IR-typed contract, not a Terraform-specific
+variable schema.
+
+Contract→IR resolution: the contract declares intent in IR-typed terms;
+the pipeline resolves it to a target stack (list of L1 instances + inputs +
+relationships); the Terraform adapter compiles the target stack to a plan.
+
+## v1.1 spike scope
+
+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-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
+  outbox.
+- State: S3 + DynamoDB (real AWS, single-region).
+
+Out of spike scope: full HITL matrix wiring, Kyverno, OPA, MCP skill
+catalog, GitOps reconciler, multi-region, prod/dr environments, the 5-skill
+L3B catalog. Those are post-spike (v1.2+) platform build-out.
+
+## Gitea API surface (carried from v1.0, refined)
+
+| Capability | Gitea support | ACDL approach (v1.1) |
+|------------|---------------|----------------------|
+| Org-scoped repo create | `POST /api/v1/orgs/{org}/repos` | Used for any new repos |
+| Native Pages | **None** | Serve `acdl-evidence` via raw file URLs (unchanged from v1.0) |
+| Environments API | **None**; act_runner ignores `environment:` | Model HITL gates via `workflow_dispatch` approval inputs (v1.0 D-013 pattern) — **refined in Phase 07** for the real pre-execution gate model |
+| `repository_dispatch` | Not supported | Cross-repo trigger via `workflow_dispatch` API (unchanged) |
+| Reusable workflows | Supported | `acdl/.gitea/workflows/pipeline.yml` via `uses: ...@<ref>` |
+| `id-token: write` / OIDC | **Not supported** (RESEARCH TARGET 1, conf 0.95). Gitea docs list `id-token` as an unsupported GitHub-only scope; open proposal go-gitea/gitea#33681; draft PR go-gitea/gitea#36988 unmerged. Even Gitea's own CI uses long-lived AWS keys (issue #37980). | **Spike waiver D-039:** per-run-rotated long-lived key (rotated after each run by `scripts/rotate_spike_key.sh`). Real OIDC deferred to v1.2, blocked on PR #36988. |
+| `actions/configure-aws-credentials` | Unusable without OIDC | Spike uses static AWS creds from a (rotated) Gitea Actions secret via the `aws-actions/configure-aws-credentials@v4` `access-key-id`/`secret-access-key` inputs, or plain `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` env vars. v1.2 switches to `role-to-assume` when OIDC lands. |
+
+### Branch pinning rule (refined for W2.A)
+
+- Dev/qa contracts reference the reusable workflow by **tag**
+  (`@v1.1-spike`).
+- Prod-bound workflows reference by **SHA**; the platform CLI
+  (`platform/cli/resolve-tag.ts`, Phase 07) resolves the current tag to its
+  SHA. (Spike scope: the CLI is a stub; the real CLI lands in v1.2.)
+
+### Verification toolchain
+
+ACDL has no `package.json`. The verification gate substitutes:
+- **typecheck:** `terraform validate`, `python3 -m py_compile`, JSON Schema
+  validation (`ajv` or `python -m jsonschema`) against `schemas/`.
+- **test:** per-phase `scripts/verify_phaseNN.sh` (Phase 06: archive integrity;
+  Phase 07: schema validation + decision-resolution completeness; Phase 08:
+  OIDC assume-role + state backend; Phase 09: IR + L1 + adapter `terraform
+  plan`; Phase 10: end-to-end contract submission).
+- **build:** `terraform init` (real build for the spike).
+- See `PERSONAS.md` verification_toolchain.
+
+## Build order (v1.1)
+
+1. Phase 06 — archive demo, reorient repo.
+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-assets` + contract→IR → end-to-end spike.
+6. COMPLETE gate — review → ship `v1.2.0` → audit. **DONE.**
+
+## v1.2 build-out scope
+
+v1.2 takes the v1.1 spike (dev-only, `plan`-only, single S3 L1) to a real,
+simpler, better-documented platform that delivers a microservice to AWS ECS
+Fargate end-to-end. The locked architecture (§1–§12) is unchanged — v1.2
+extends the *implementation*, not the design.
+
+### In scope (five axes, user-directed 2026-07-21)
+
+1. **Re-evaluate the current state.** go-gitea/gitea#36988 (OIDC for Gitea
+   Actions) re-checked 2026-07-21: still **open** (last updated 2026-05-27,
+   not merged). Real OIDC remains deferred to v1.3+; v1.2 extends the D-039
+   per-run-rotated-key waiver as **D-047**. The waiver continues to satisfy
+   §12.5's *intent* (no *persistently* long-lived key): the spike key is
+   rotated after each run by `scripts/rotate_spike_key.sh`, and Phase 12
+   tightens the IAM scoping + rotation hygiene.
+2. **NFR improvements on the existing spike.** Least-privilege IAM audit of
+   `spike_runner_policy.json`; idempotent `create_state_backend.py` /
+   `create_iam_user.py`; proper exit codes / error handling; P1-1 redaction
+   (two AWS access key IDs in `.ciagent/VERIFY.md` Phase 09 narrative).
+3. **Streamline / simplify the current setup.** Consolidate
+   `run_spike_plan.sh` + `run_spike_e2e.sh` into one
+   `scripts/run_platform.sh`; remove dead code and stale `platform/` paths.
+4. **README.md fully up to date on how the platform works.** Reflect v1.1
+   complete; document the actual spike flow, `scripts/run_platform.sh`, the
+   real repo layout, and the v1.2 objective.
+5. **Bootstrap a consumer repo with a basic microservice deployed to ECS
+   end-to-end.** New Gitea repo `acdl-consumer-microservice` (org
+   `continuous-intelligence`); new IR-typed L1s (`l1-vpc`, `l1-ecs-cluster`,
+   `l1-ecs-service`, `l1-iam-role`, `l1-alb`, `l1-ecr`); new
+   `l2-microservice` thin-composition; one contract submission →
+   `terraform apply` (dev, autonomous per §10, confidence ≥ 0.50) → a live
+   ECS Fargate service serving HTTP 200 → evidence event to the DynamoDB
+   outbox → acdl-evidence timeline.
+
+### Angine extension (ECS Fargate)
+
+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/`, `core/confidence_signal.py`,
+`core/contract_resolver.py`, `core/outbox_writer.py`
+remain engine-agnostic.
+
+### `terraform apply` (dev only)
+
+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
+stream as a `terraform.apply` event.
+
+### Out of scope for v1.2 (deferred to v1.3+)
+
+| Feature | Reason |
+|---------|--------|
+| Real OIDC federation | go-gitea/gitea#36988 still open. v1.2 extends D-039 waiver (D-047); real OIDC is v1.3+. |
+| Full HITL matrix wiring (qa/prod/dr) | v1.2 is dev-only autonomous `apply`; HITL wiring is v1.3. |
+| Kyverno + OPA policy engines | v1.2 keeps Checkov only; Kyverno/OPA are v1.3. |
+| MCP skill catalog + real L3B agent | v1.2 keeps the L3B stub; the 5-skill catalog is v1.3. |
+| Audit ledger build-out (S3 Object Lock + JWS + async worker + DLQ + daily checkpoints) | v1.2 keeps the v1.1 outbox; the regulatory ledger is v1.3. |
+| Multi-region state / outbox | Single-region in v1 (§9, §12.3); multi-region is v1.3+. |
+| Prod/dr environments | v1.2 is dev-only; prod/dr are v1.3. |
+| GitOps reconciler (ArgoCD/Flux) | v1.3+. |
+
+## Build order (v1.2)
+
+1. Phase 11 — re-eval #36988 + NFR audit + simplification findings + README rewrite.
+2. Phase 12 — NFR harden + simplify (idempotent bootstrap, one `run_platform.sh`, IAM audit, redactions).
+3. Phase 13 — six ECS L1s + adapter `TYPE_MAP` expansion.
+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.
+
+## 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.
+
+## v1.10 Addendum — Regression VERIFY + Local Emulators + Capability Re-Verification
+
+### Regression-Class VERIFY (D-091, `core/regression_verify.py`)
+
+The standard VERIFY stage was diff-scoped (it checked the phase diff
+only, never re-ran underlying capability). This let 8 NFR-patch phases
+(v1.9.1–v1.9.8) pass while the platform decayed. The regression-class
+VERIFY (`core/regression_verify.py`) re-runs capability checks against
+the current codebase and tags each Verified/Decayed/Broken. It fails
+closed on any non-Verified capability, blocking milestone completion.
+
+The registry (`CAPABILITY_REGISTRY`) holds 16 capability checks
+(CAP-001..CAP-016): 12 local-tier + 4 live-AWS. Adding a capability is
+a single function + one registry entry. The gate runs via
+`scripts/run_regression.sh` and writes `.ciagent/REGRESSION_REPORT.md`
++ `.json`.
+
+### Local Emulating Adapters (D-092, `core/local_emulators.py`)
+
+Four local adapters let the platform run the full headline E2E without
+cloud credentials:
+
+- `FlatFileOutbox` — flat-file DynamoDB outbox emulator (hash-chained
+  JSONL; resumable across instances; chain verification).
+- `LocalEcsEmulator` — local ECS Fargate HTTP 200 emulator (binds port
+  0 on 127.0.0.1; daemon thread; clean destroy).
+- `LocalS3StateBackend` — rewrites the terraform S3 backend to a local
+  backend (per-stack tfstate in a temp folder).
+- `LocalLambdaStub` — invokes the contract_ingestor handler in-process
+  (patches `_get_dynamodb`/`_get_secrets_client`/`urllib.urlopen`;
+  DynamoDB writes redirected to the FlatFileOutbox).
+
+`run_local_e2e()` runs the full pipeline: contract → resolver → adapter
+→ local S3 backend → local ECS (HTTP 200) → flat-file outbox (chain
+verified) → local Lambda (200). Gated on `ACDL_LOCAL_TIER=1`.
+
+### Capability Re-Verification Sweep (D-093)
+
+`.ciagent/CAPABILITY_INVENTORY.md` enumerates 16 auto-verified
+capabilities + 6 IAM-gated escalated resources. The sweep found and
+fixed 7 adapter defects in `adapters/terraform/adapter.py` (duplicate
+outputs, duplicate args, missing required args, deprecated AWS provider
+v5 arg names). The headline E2E now passes at both tiers: local
+emulator + live-AWS terraform init/validate/plan.
+
+### Adapter Defect Fixes (P54)
+
+7 defects fixed in `adapters/terraform/adapter.py`:
+1. Duplicate output definitions (per-resource + stack-level both emitted).
+2. Duplicate `desired_count`/`launch_type` on ECS service.
+3. Duplicate `target_type`/`family`/`load_balancer_type`.
+4. Missing `assume_role_policy`/`role_name` on IAM role (L2 composition gap).
+5. Missing `cidr_block`/`vpc_id`/`name` defaults on VPC/subnet/route_table/
+   ECS cluster/ECR repository.
+6. ECR `kms_key_arn` unsupported arg → `encryption_configuration` block.
+7. CloudFront OAC + WAF deprecated arg names (AWS provider v5):
+   `signing_behavior`, `signing_protocol`, `origin_access_control_id`,
+   `s3_origin_config.origin_access_identity`, `origin_id`, `rule`
+   (singular), `scope=CLOUDFRONT` (uppercase).
+
+## v1.11 Addendum — Stateless Adapter + Pipeline-Driven Lifecycle Testing
+
+**Stateless adapter (D-098).** `adapters/terraform/adapter.py` rewritten
+from a 918-line monolith (3 constant tables `TYPE_MAP`/`INPUT_MAP`/
+`OUTPUT_MAP`, 39 type-specific branches) to a ~80-line stateless assembler.
+Each L1 module ships a real `terraform/` module dir
+(`versions.tf`/`variables.tf`/`locals.tf`/`main.tf`/`outputs.tf`) owning
+its resource shape, nested blocks, and defaults. The adapter reads the
+registry, emits a root `main.tf` instantiating each L1 as
+`module "x" { source = "..." }` with resolved inputs and wired refs.
+
+**Terraform owns lifecycle (D-101).** `scripts/run_platform.sh` gains
+`--apply` and `--destroy` modes. Python never runs terraform.
+`scripts/verify_deploy_microservice.py` is deleted.
+
+**Pipeline-driven testing (D-102).** A `modules-lifecycle` pipeline
+(Gitea + GitHub, byte-identical) matrix-runs each L1 module's
+`examples/{simple,complex}.yml` contracts through apply→modify→destroy
+against live AWS. No per-module Python/pytest. The "test" = the pipeline
+cell going green.
+
+**Single platform VPC (D-105).** `terraform/platform/main.tf` owns ONE
+VPC; the microservice composition references it via
+`terraform_remote_state` (data source). State keys are deterministic and
+env-aware (`spike/{contract.id}/{contract.environment}/terraform.tfstate`).
+
+**NOVA_LIFECYCLE_MODE (v1.12, REQ-134; renamed ACDL→NOVA in v1.15 P2).** The lifecycle pipeline defaults
+to plan-only (fast, no AWS mutation, no cost). A CI variable
+`NOVA_LIFECYCLE_MODE` (default `plan`) overrides to `full` for the real
+apply→modify→destroy. (P2–P4 dual-read fallback to `ACDL_LIFECYCLE_MODE`;
+fallback removed in P5 per the v1.15 addendum.)
+
+## v1.12 Addendum — Presentation Refinement + CAP-013 Fix
+
+**CAP-013 adapter dedup fix (REQ-129).** Multi-resource L1s (ecs-service,
+alb) with stack outputs + cross-module refs now dedup to ONE module block
+named by the composition child id, with expanded sub-ids rewritten via
+`id_remap`. `terraform validate` succeeds for the microservice stack.
+
+**CAP-017/018 probe fixes (REQ-130).** CAP-017's probe no longer requires
+`locals.tf` for modules that legitimately omit it. CAP-018's probe
+instantiates `LocalLambdaStub` with the required `outbox` arg.
+
+## v1.13 Addendum — Presentation Polish + Config Schema Migration
+
+**Config.json schema migration (v1.13.1).** Regenerated
+`.ciagent/config.json` to the updated CIAgent v2 config structure (drop
+removed fields, migrate `gitea`→`release.gitea`, add
+`secrets`/`ship`/`backend`/`ideation`/`personas`/`logging`/`telemetry`
+sections).
+
+**Presentation polish (v1.13.0, v1.13.2).** Action headlines, story-arc
+restructure, larger fonts, 6 new mermaid diagrams, badge cleanup,
+platform-architecture diagram. Docs-only NFR patches.
+
+## v1.14 Addendum — NFR Refinement (bug fixes, security, stubs, tests, docs)
+
+**Bug fixes (Wave 1, P1-P6).** Adapter dedup rejects unregistered modules
+with ValueError (P1). Static-assets composition wires cloudfront inputs
+(P2). L2 lifecycle scripts document remote-state design (P3). Regression
+gate adds `terraform fmt -check` syntax probe (P4). Adapter dedup-merge +
+remote-state-key unit tests (P5). ALB target group name_prefix derives
+from var.name (P6).
+
+**Security (Wave 2, P7-P12).** 6 swallowed-error sites narrowed to
+specific exceptions (P7). Account ID externalized to
+`ACDL_AWS_ACCOUNT_ID` env (P8). IAM policy scoped to `acdl-*` ARNs (P9).
+Contract ingestor validates contractId/environment/error (P10). Environment
+schema adds `additionalProperties: false` + format validation (P11).
+`.gitignore` credential-pattern catch-all (P12).
+
+**Stub/test/CI/hygiene (Wave 3, P13-P17).** Kyverno `--kube-version` flag
+removed (P13, G-103). Orphan artifacts + dead config cleaned (P14). 7
+untested scripts gain test coverage (P15). Gitea workflow parity
+documented + script `set` flags fixed (P16). Config.json persona +
+branching strategy + ollama-cloud aligned (P17).
+
+**Standards/docs/VPC (Wave 4, P18-P20).** STANDARDS.md reconciled (P18).
+Documentation synced: ARCHITECTURE.md addenda, stale `@v1.6-1.9` → `@v1.13`,
+GRILL G-005/G-008 resolved, COST.md window extended, D-083 deferral
+recorded (P19). Platform VPC CIDR parameterized + data-driven subnet
+count (P20).
+
+**D-083 deferral (explicit).** The audit ledger build-out (S3 Object Lock
++ JWS detached signatures + SQS DLQ + async worker + daily checkpoints)
+remains deferred (D-096, v1.14). The hash-chain + DynamoDB outbox is the
+v1.14 audit record. JWS per-event authenticity is not implemented; a
+forged event is only detectable by re-reading the whole chain. The
+deferral is documented here explicitly per the v1.14 grill (E-001).
+---
+
+## v1.15 Addendum — Nova Rebrand (Major/breaking, 2026-07-30)
+
+**Milestone:** v1.15-Nova. A full rebrand from **ACDL** / "Agentic Cloud
+Delivery Platform" → **Nova** / "The New Dawn of DevSecOps — security
+as a seamless enabler of fast deployments." This is a **Major
+milestone** (breaking): consumer-facing path, env var prefixes, SSM
+path, AWS tag keys, and AWS resource names all change. Per the
+branch-strategy precedent (breaking/feature milestones tag on their
+OWN minor line), v1.15 tags run on the **v1.15.x minor line**:
+`v1.15.0` (P0) → `v1.15.4` (P5 final = release). (G-104 binding.)
+
+### Naming conventions (rebranded)
+
+| Convention | Before (v1.0–v1.14) | After (v1.15+) | Phase |
+|------------|---------------------|-----------------|-------|
+| Project name | `ACDL` / "Agentic Cloud Delivery Platform" | `Nova` / "The New Dawn of DevSecOps" | P1 |
+| Tagline | "Consumers declare intent; the platform delivers safe production deployment through an agentic stack" | (retained) **+** "The New Dawn of DevSecOps — security as a seamless enabler of fast deployments" | P1 |
+| Schema `$id` URL | `https://acdl.cloudinit.dev/schemas/...` | `https://nova.cloudinit.dev/schemas/...` | P1 |
+| Gitea release title | `ACDL vX.Y.Z` | `Nova vX.Y.Z` | P1 (forward only) |
+| Env var prefix | `ACDL_*` (21 vars) | `NOVA_*` (dual-read fallback in P2–P4; removed P5) | P2 |
+| Env loader | scattered `os.environ.get("ACDL_*")` | centralized `core/env.py` `get_env()` (D-108) | P2 |
+| Consumer contract path | `.acdl/contract.yml` | `.nova/contract.yml` | P2 |
+| Checkov custom rule file | `acdl_tagging.py` | `nova_tagging.py` | P2 |
+| Checkov tag-key enforcement | `acdl:*` (hard) | `nova:*` (warn P2, hard P3) | P2/P3 |
+| SSM parameter path | `/acdl/{env}/{contractId}/{output}` | `/nova/{env}/{contractId}/{output}` | P3 |
+| AWS tag keys | `acdl:owner|environment|contract|cost-center|ref` | `nova:owner|environment|contract|cost-center|ref` | P3 |
+| ABAC session policy match | `acdl:*` tags | `nova:*` tags (parallel-tag period) | P3 |
+| DynamoDB tables | `acdl-contracts`, `acdl-change-requests` | `nova-contracts`, `nova-change-requests` (scan+copy) | P4 |
+| Lambda (ingestor) | `acdl-contract-ingestor` (role/policy/function) | `nova-contract-ingestor` | P4 |
+| Secrets Manager secret | `acdl/github-token` | `nova/github-token` | P4 |
+| SNS topic | `acdl-sod-halt` | `nova-sod-halt` | P4 |
+| Security group | `acdl-ecs-sg` | `nova-ecs-sg` | P4 |
+| KMS alias | `alias/acdl-platform` | `alias/nova-platform` | P4 |
+| ECS cluster/service/task | `acdl-microservice` | `nova-microservice` | P4 |
+| ECR repo | `acdl-microservice` | `nova-microservice` (re-push) | P4 |
+| IAM user/policy | `acdl-spike-runner` (+policy) | `nova-spike-runner` (re-bootstrap) | P4 |
+| S3 state bucket | `acdl-tfstate-581513795199-us-east-1` | `nova-tfstate-581513795199-us-east-1` (`-migrate-state`) | P4 |
+| ALB name prefix | `acdl-alb` | `nova-alb` | P4 |
+| Lambda default table names | `CONTRACTS_TABLE` default `acdl-contracts` | default `nova-contracts` (D-111) | P4 |
+
+### Unchanged conventions (out of scope)
+
+- **S&P Global Energy visual theme** (`sp-theme.json`, deck CSS: #D6002A
+  red, Akkurat Pro) — client branding, not the Nova product brand (D-107).
+- **config.json `release.gitea.repo`** = `acdl` — real Gitea repo name
+  unchanged (D-105). Doc URLs updated to `nova` for prose only.
+- **Git branch/tag naming** — `milestone/v*`, `phase/*`, `v*` semver; no
+  brand name present (D-112: flat-branch convention preserved).
+- **Past Gitea release titles** — existing releases keep `ACDL vX.Y.Z`.
+
+### Migration ordering (binding)
+
+1. **P1** docs/decks/prose — no runtime impact; ships consumer migration
+   guide announcing the 5 breaking changes.
+2. **P2** code + env vars (dual-read) + consumer path — deployments don't
+   break during the transition window (dual-read fallback).
+3. **P3** SSM path (copy → read → delete) + tag keys (parallel-tag →
+   policy swap → remove old).
+4. **P4** AWS resource names — staged terraform migration (KMS alias,
+   SNS/SG/Lambda recreate, DynamoDB scan+copy, ECR re-push, IAM
+   re-bootstrap, state bucket `-migrate-state`, ALB recreate). Maintenance
+   window + rollback runbook (`docs/NOVA_AWS_MIGRATION.md`).
+5. **P5** final review + audit + remove dual-read fallback + milestone ship.
+
+### Capability gate (binding)
+
+The regression gate (CAP-001..CAP-016, `scripts/run_regression.sh`) must
+stay **16/16 Verified** throughout the rebrand. P2/P3/P4 update test
+fixtures that reference `ACDL`/`acdl` so the gate stays green. No
+capability is added, removed, or reclassified in v1.15 — the rebrand is
+nomenclature + identifiers, not behavior.
+
+---
+
+## v1.16 Addendum — Nova Simplification (NFR, 2026-07-30)
+
+The v1.16 NFR milestone added 6 new code components + 1 new Terraform
+module + 1 new schema, all documented here for the architecture record.
+
+### New components
+
+| Component | Path | Purpose |
+|-----------|------|---------|
+| Onboarding request handler | `core/onboarding.py` | `generate_env_file(request, template_env)` — produces a `<env>.json` from a consumer onboarding request (P19, REQ-183). CLI entry point for self-service env-file generation. |
+| Decommission transform | `core/decommission_transform.py` | `decommission_transform(stack)` — zero counts + disable deletion protection (REQ-92). Extracted from contract_resolver (P12, REQ-176). |
+| Contract resolver CLI | `core/contract_resolver_cli.py` | `main()` CLI entry point — resolves a contract YAML to a Target Stack JSON. Extracted from contract_resolver (P12, REQ-176). |
+| Regression verify CLI | `core/regression_verify_cli.py` | `main()` CLI entry point — runs the regression gate + writes the report. Extracted from regression_verify (P13, REQ-177). |
+| Workflow sync generator | `scripts/sync_workflows.py` | `--check`/`--write` — generates the 3 byte-identical Gitea+GitHub workflow pairs from `workflows-src/` (P8, REQ-172). |
+| Onboarding Terraform | `terraform/onboarding/` | `aws_iam_role.consumer_deploy` + `aws_iam_role_policy.consumer_invoke` (ABAC `nova:owner` tag). Offline-proven only (P20, REQ-184, D-114). |
+
+### Modified components
+
+| Component | Change | Phase |
+|-----------|--------|-------|
+| `core/contract_resolver.py` | `_load_env` delegates to `environment_check.load()` (dedup); `is_l2` uses registry `kind` field; `_load_schema` caches schemas; `decommission_transform` + CLI re-export shim (P12). | P7, P12, P14 |
+| `core/regression_verify.py` | Dedup helpers (`_check_resolver`, `_check_live_terraform_plan`, `_assert_contracts_resolve`); CAP-013..016 `Skipped` on post-teardown (G-111); `passed` accepts Skipped; CLI re-export shim (P13). | P5, P9, P13 |
+| `core/lambda/contract_ingestor.py` | Fail closed on missing IAM identity (P10); env enum from `core/environments/` (P10); payload size cap + schema validation (P11); `onboard_consumer` action (P18); `[NOVA-ALERT]` rebrand (P2). | P2, P10, P11, P18 |
+| `core/output_publisher.py` | `SAFE_OUTPUT_NAMES` schema-driven from `interface.json`; narrowed excepts; `urllib.error` import (P4, P14). | P4, P14 |
+| `core/environment_check.py` | Onboarding message rebranded Nova + self-service request path (P2, P19). | P2, P19 |
+| `core/local_emulators.py` | `LocalLambdaStub` sets `NOVA_LAMBDA_LOCAL_BYPASS`; stale dual-read comments + `acdl_*` prefixes removed (P3, P10). | P3, P10 |
+| `scripts/run_platform.sh` | `--help` flag; `run_hitl_gate()` fn; `NOVA_CONTRACT_ID`/`NOVA_WORK_DIR` config; decommission + uptime blocks extracted to sourced helpers (P6, P9, P15). | P6, P9, P15 |
+| `adapters/terraform/adapter.py` | State bucket `nova-tfstate-*` (P1); module docstring Nova (P2). | P1, P2 |
+| `adapters/kyverno/policies/require-resource-labels.yml` | `nova:*` labels (not `acdl:*`) (P1). | P1 |
+| `modules/registry.json` | `kind` field (`l1`/`l2`) on all 14 entries (P7). | P7 |
+
+### New schema
+
+- `schemas/onboarding.schema.json` — the self-service onboarding request
+  (consumerRepo, requestedEnvironment, ownerId, billingTag). P18, REQ-182.
+
+### Onboarding request-path architecture (D-113)
+
+The no-humans onboarding flow is a 3-step request path (real AWS
+provisioning deferred):
+
+```
+Consumer → POST Lambda (onboard_consumer) → pending CMDB row (P18)
+         → core/onboarding.py → <env>.json binding file (P19)
+         → terraform/onboarding/ → cross-account role + ABAC tag (P20, offline)
+```
+
+The Lambda Function URL (IAM auth) + `consumer_invoke_policy.json` (ABAC
+`nova:owner`) are the transport; the request is accepted + a binding
+generated + the role Terraform proven offline. No AWS resources are
+created by the request path (D-113/D-114).
+
+### Regression gate (G-111 binding)
+
+The regression gate (D-091) now treats `Skipped` as acceptable for the
+post-v1.11-teardown steady state (D-096): CAP-013..016 (live-AWS tier)
+return `Skipped` when the resources are absent (`NoSuchBucket`/
+`ResourceNotFoundException`). `RegressionReport.passed` is
+`all(r.status in ("Verified", "Skipped"))`. The gate passes at 18
+Verified + 4 Skipped (0 Decayed/Broken).
+
+## v1.17 Addendum — Strategic Direction, Leadership Metrics & Unified Story (2026-08-04)
+
+The v1.17 milestone adds a telemetry/observability layer, a Decision
+Ledger, a metrics export pipeline, a unified narrative deck, and a
+durable strategic-direction artifact. This addendum documents the
+architecture; the full research findings are in RESEARCH.md §v1.17.
+
+### New components
+
+| Component | Path | Purpose |
+|-----------|------|---------|
+| Event envelope | `core/metrics/event_envelope.py` | CloudEvents 1.0 envelope + `platform.*` semantic conventions (P1, REQ-187) |
+| Per-run manifest writer | `core/metrics/run_manifest.py` | Emits `nova.run.started/completed/failed` events + writes `metrics/runs/<run_id>.json` (P1, REQ-187) |
+| Decision Ledger (SQLite) | `core/metrics/decision_ledger.py` | Extends `outbox_writer.py` → SQLite append-only hash-chain table; `ai.decision.made` + `attestation.recorded` events + outcome backfill (P1, REQ-188, D-121) |
+| Infracost post-processor | `core/metrics/infracost_adapter.py` | Runs Infracost on plan JSON; emits `nova.cost.estimated{delta_usd}` (P1, REQ-187, D-120) |
+| Metrics collector | `core/metrics/collector.py` | Reads all grounded signals (files + events) → SQLite cold store at `metrics/nova_metrics.db` (P2, REQ-189) |
+| PowerBI export | `core/metrics/powerbi_export.py` | Emits CSV/JSON views to `metrics/powerbi/` (fact + dim + 8 deferred placeholder views) (P3, REQ-190) |
+| Metrics schemas | `schemas/metrics_*.schema.json` | Schemas for all event types + fact/dim tables (P1–P2, REQ-187/189) |
+| Metrics catalog | `docs/METRICS.md` + `docs/metrics/<kpi>.md` | Canonical catalog + per-KPI definition-of-success docs (P4, REQ-195, D-127) |
+| Unified narrative deck | `docs/presentations/nova-no-humans-platform.md` | Merged deck: Problem→Vision→How→Proof→Roadmap; x3 arc at deck+slide level (P5, REQ-196/197, D-130) |
+| Strategic direction | `.ciagent/NORTH_STAR.md` | PO-authored durable vision/objectives/anti-goals/targets; read by CIAgent in every future `/ci-run` (P0, REQ-185/186) |
+
+### Modified components
+
+| Component | Change | Phase |
+|-----------|--------|-------|
+| `core/outbox_writer.py` | Extended to emit to SQLite append-only hash-chain table (Decision Ledger); `ai.decision.made` + `attestation.recorded` events added (P1, D-121) | P1 |
+| `scripts/run_platform.sh` | Per-run manifest writer invoked; `$WORK/*.json` persisted to `metrics/runs/`; Infracost post-processor invoked after plan (P1) | P1 |
+| `core/hitl_gates.py` | Emits `attestation.recorded` event to Decision Ledger on qa/prod/dr gate (P1, D-132) | P1 |
+| `core/confidence_signal.py` | Emits `nova.confidence.computed` + `nova.ai.decision.made` events (P1, D-122) | P1 |
+| `adapters/terraform/policy/checkov_adapter.py` | Emits `nova.policy.evaluated` event (P1) | P1 |
+| `core/regression_verify.py` | Emits `nova.capability.verified` event; CAP-023 (metrics collector) + CAP-024 (deck structure) added (P1, P6) | P1, P6 |
+| `pyproject.toml` | `addopts` gains `--junitxml=metrics/test-results.xml` + `--json-report` (P1, D-120) | P1 |
+| `docs/presentations/` | Two old decks retired (deleted); unified deck added (P5, D-130) | P5 |
+
+### Telemetry/observability layer architecture (D-120)
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  Nova platform components (existing)                                │
+│  run_platform.sh · confidence_signal · checkov_adapter ·            │
+│  hitl_gates · regression_verify · outbox_writer · contract_ingestor │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │ CloudEvents 1.0 envelope (new emitters, P1)
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│  metrics/events.jsonl  (append-only CloudEvents log)                │
+│  metrics/runs/<run_id>.json  (per-run manifests)                    │
+│  metrics/decision_ledger.db  (SQLite hash-chain, D-121)             │
+│  metrics/test-results.xml  (junit, P1)                              │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │ collector reads (P2)
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│  metrics/nova_metrics.db  (SQLite cold store, D-126)                │
+│  fact_run · fact_capability · fact_policy_check · fact_confidence  │
+│  fact_test · fact_decision · fact_cost_estimate                     │
+│  dim_capability · dim_milestone                                     │
+│  + 8 empty placeholder views (deferred metrics)                    │
+└──────────────────────┬──────────────────────────────────────────────┘
+                       │ powerbi_export (P3)
+                       ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│  metrics/powerbi/  (CSV/JSON views, folder connector, D-129)        │
+│  → PowerBI dashboards (external)                                    │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**Hot path: deferred (D-126).** No live ops dashboard; SQLite is
+cold-only (batch/historical). The hot path activates when live AWS is
+re-provisioned (D-096 lift).
+
+### NORTH_STAR integration point (REQ-186)
+
+`.ciagent/NORTH_STAR.md` is read by CIAgent in context-loading for all
+future milestones. The integration mechanism (to be finalized in P4):
+a reference from `PROJECT.md` + `ARCHITECTURE.md` (this section) + a
+config entry in `config.json` (`strategic_direction_file:
+".ciagent/NORTH_STAR.md"`) that the run workflow reads at SPECIFY. This
+ensures the strategic direction survives across milestones without
+being overwritten by status updates.
+
+### §12.7 — Policy Engine Registry (v1.25, REQ-291)
+
+The policy-engine abstraction is first-class: a swappable `PolicyEngine`
+protocol so the engine may change without touching the confidence
+signal, the pipeline, or the `PolicyCheckResult` schema. This is the
+**swap boundary** that keeps the platform's compliance posture
+replaceable (Strategic Objective #2 — provable trust via a replaceable
+substrate, not a vendor lock-in).
+
+```
+ contract.yml ─┐                         ┌─→ list[PolicyCheckResult] ─┐
+ stack IR ─────┼─→ PolicyEngine.evaluate ├─→ list[PolicyCheckResult] ─┼─→ confidence_signal
+ plan JSON ────┤    (protocol)            └─→ list[PolicyCheckResult] ─┘  (engine-agnostic,
+ PCR list ─────┘                                                         unchanged)
+                    │
+                    ▼
+          ┌─ KyvernoJsonEngine (shells to `kj scan`; engine: "kyverno")
+          └─ OpaEngine (future — same protocol; engine: "opa")
+
+   checkov/wiz ──→ raw findings ──→ (merged PCR list is the meta-policy payload)
+```
+
+**The protocol (`core/policy_engine.py`):**
+```python
+class PolicyEngine(Protocol):
+    @property
+    def name(self) -> str: ...
+    def is_configured(self) -> bool: ...
+    def evaluate(self, payload, policy_dir: Path, contract_id: str) -> list[dict]: ...
+```
+
+**The registry** reads `config.json.policy.engine` (default
+`"kyverno-json"`) and returns the active engine. A `NullEngine` is the
+fallback when the `policy` key is absent (emits `SKIPPED` PCRs —
+backward compatibility for tests that don't set the key). The
+confidence signal is **untouched** — it already consumes
+`list[PolicyCheckResult]` engine-agnostically (§12.6). v1.25 only
+changes *who produces* the PCR list, not *what* the list is.
+
+**Engine enum reuse (D-116):** kyverno-json PCR records carry
+`engine: "kyverno"` (no new enum value). The `engine` field records the
+policy-engine *family*, not the specific binary. The K8s Kyverno adapter
+and the kyverno-json engine are distinguished by `ruleId` prefix
+(`KYVERNO_` vs `KJ_`) and `evidence` payload shape (`namespace`/`kind`
+vs `assertion`/`jmespath`).
+
+**Defense-in-depth (D-119):** the declarative meta-policy
+`block-on-any-critical` (asserts no PCR has `severity: critical` +
+`result: fail`) is the *source of truth* for "critical = block". The
+`confidence_signal.py` `PENALTY["critical"]: None` hard-override stays
+as the *imperative* safety net — the meta-policy runs *before* the
+confidence signal (produces PCRs that flow in), the hard-override runs
+*inside* it (the last gate). Removing the hard-override would make the
+"critical = block" guarantee depend on a single policy file — a
+regression in provable trust.
+
+**Graceful degradation (D-120):** `KyvernoJsonEngine.is_configured()`
+returns false when `which kj` is absent → `evaluate()` returns a single
+`SKIPPED` PCR (`ruleId: "KJ_ENGINE_NOT_CONFIGURED"`). The platform
+functions without the binary (the "platform functions without AI /
+deterministic scripts" tenet holds — kyverno-json is deterministic, not
+AI; the `is_configured()` guard ensures the platform runs even when the
+binary is not installed).

.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md

@@ -0,0 +1,46 @@
+# P4 — Live Pilot Run Evidence (v1.26, v0.2 re-run)
+
+> The live `terraform apply` against AWS `581513795199` succeeded. The
+> Decision Ledger + outcome backfill are complete. SPEC §5.8 evidence
+> stream verified.
+
+## Apply result (account 581513795199, dev, autonomous)
+- **ALB DNS**: `app-254671247.us-east-1.elb.amazonaws.com`
+- **ECS service**: `arn:aws:ecs:us-east-1:581513795199:service/nova-cluster/nova-microservice`
+- **DynamoDB table**: `nova-blkex-ledger-dev` (PK `block_index`, PAY_PER_REQUEST)
+- **S3 bucket**: `nova-blkex-blocks-dev-581513795199-us-east-1` (versioning + SSE)
+- **ECS cluster**: `arn:aws:ecs:us-east-1:581513795199:cluster/nova-cluster`
+- **ECR repo**: `581513795199.dkr.ecr.us-east-1.amazonaws.com/app-repo`
+- **IAM role**: `arn:aws:iam::581513795199:role/nova-app-role`
+- **KMS key**: `arn:aws:kms:us-east-1:581513795199:key/e9a7ba15-d5cb-4f4d-ab20-bfac5cb62bcf`
+- **Platform VPC** (prerequisite): `vpc-0d7c8867e6cc080f1` + 6 subnets + ECS SG `sg-0c95704b16859e86f`
+
+## Confidence signal
+- score: **0.800**, band: **pass** (dev autonomous, ≥0.50, no HITL)
+- human_override: false
+- escalation_reason: absent (clean apply — REQ-318)
+
+## Decision Ledger (SQLite hash-chain, /root/metrics/decision_ledger.db)
+- `nova.ai.decision.made` — decision_id `blkex-pilot-apply-v0.2`, chosen_action `pass`, human_override false
+- `nova.outcome.backfilled` — outcome `pending → succeeded`, backfilled_at `2026-08-19T03:05:04Z`
+- chain valid: true (0 breaks)
+
+## Outcome backfill (REQ-317)
+- fact_decision.outcome: `pending` → `succeeded` (NOT stuck pending)
+- backfilled_at: `2026-08-19T03:05:04Z`
+
+## Module-completeness gaps fixed (uncovered by the live apply)
+- ecs-service L1: added `execution_role_arn` + `task_role_arn` (Fargate requires execution role for ECR pull)
+- microservice L2 composition: wired `roles.outputs.role_arn` → `service.inputs.{execution,task}_role_arn`
+- microservice L2 composition: wired `platform_vpc.outputs.ecs_security_group_id` → `alb.inputs.security_group` (ALB requires a SG)
+
+## Run id
+- NOVA_RUN_ID: `blkex-pilot-apply-v0.2`
+
+---ci---
+project: acdl
+phase: 4
+milestone: v1.26
+status: execute
+wave: W1
+---

.ciagent/archive/README.md

@@ -0,0 +1,127 @@
+# `.ciagent/archive/` — Completed-Milestone History
+
+This directory holds byte-identical snapshots of `.ciagent/` files that
+were compressed out of the active agent context. Compression is **lossless
+via relocation**: every original byte is reachable here, and the git
+history at the commit prior to compression preserves the authoritative
+state for offline agent loading.
+
+## Why archive
+
+The active milestone is v1.27 (PO State Catalog & Ciagent Compression).
+The `.ciagent/` root was compressed twice:
+
+1. **v1.26 P2 compression** (~11,164 lines → ~5,232): the
+   completed-milestone narratives (v1.0–v1.24) were relocated. Per the
+   run.md context-loading model, agents read `.ciagent/` every
+   `/ci-run`; the historical narrative was not load-bearing for v1.26
+   execution and was relocated to keep the working context lean.
+2. **v1.27 P1 compression** (~5,232 → ~3,882): the v1.26 phase
+   verifications + review + evidence + the dated CAPABILITY_INVENTORY
+   (superseded by STATE.md) + AUTONOMY_THESIS (folded into NORTH_STAR)
+   + COST (predates v1.26 pilot) were relocated. The 4 pre-execution
+   files (CLARIFY/GRILL/IDEATE/RESEARCH) were rewritten by v1.27 P0
+   and stay active through v1.27.
+
+## Contents
+
+### Snapshots of slimmed files (full content before compression)
+
+| File | Original (lines) | Replaces | Status at time of snapshot |
+|---|---|---|---|
+| `PROJECT-v1.0-v1.24.md` | 1784 | `.ciagent/PROJECT.md` | v1.0–v1.24 milestone-by-milestone narrative + active milestone v1.26 sections |
+| `REQUIREMENTS-v1.0-v1.24.md` | 2490 | `.ciagent/REQUIREMENTS.md` | All requirements v1.0 (REQ-01) through v1.26 (REQ-322) |
+| `ROADMAP-v1.0-v1.24.md` | 2341 | `.ciagent/ROADMAP.md` | All phase breakdowns v1.0 through v1.26 |
+| `ARCHITECTURE-v1.0-v1.24.md` | 945 | `.ciagent/ARCHITECTURE.md` | Full architecture reference + historical "how we got here" narrative |
+
+The slimmed in-place files retain: active milestone v1.26 context, the
+v1.25 milestone (since v1.26 tags ride the v1.25.x line), the durable
+vision/tenets/RACI/capability-status sections, and the current-state
+architecture reference.
+
+### Completed-phase artifacts (relocated verbatim)
+
+| File | Original (lines) | Phase(s) documented |
+|---|---|---|
+| `REVIEW.md` | 111 | Multi-persona code review records from completed phases |
+| `AUDIT.md` | 553 | Project health audit records (reconstruction tests, branch hygiene) |
+| `VERIFY.md` | 86 | Per-phase verification records |
+| `PRE_MORTEM.md` | 228 | Pre-mortem analyses for completed milestones |
+
+### v1.27 compression — archived files (8 files, lossless `git mv`)
+
+> The v1.27 NFR milestone (PO State Catalog & Ciagent Compression) archived
+> 7 platform-root files + 1 consumer file. All are byte-identical
+> relocations; git history at the pre-v1.27 commits preserves the
+> authoritative state.
+
+#### Snapshots of superseded durable references (3 files)
+
+| File | Original (lines) | Superseded by | Status at time of snapshot |
+|---|---|---|---|
+| `CAPABILITY_INVENTORY-v1.10.md` | 120 | `.ciagent/STATE.md` (v1.27) | The 2026-07-27 re-verification sweep (v1.1→v1.8 capabilities). Predates v1.26 pilot (CAP-025 absent; blockchain capabilities absent). |
+| `AUTONOMY_THESIS-v1.21.md` | 65 | `NORTH_STAR.md` Vision + Anti-Goals #2 | "Last refined: v1.21" — the autonomy-in-operations thesis, fully folded into NORTH_STAR.md. |
+| `COST-v1.14.md` | 106 | (future cost milestone) | AWS cost report dated 2026-07-29, framed "v1.0 → v1.14". Predates v1.26 live pilot (ECS + ALB + DynamoDB + S3 costs not reflected). |
+
+#### v1.26 phase verifications + review + evidence (4 files)
+
+| File | Original (lines) | Phase(s) documented |
+|---|---|---|
+| `VERIFY-P03.md` | 39 | v1.26 P3 verification — PASS (shipped `v1.25.3`) |
+| `VERIFY-P04.md` | 31 | v1.26 P4 verification — PASS (shipped `v1.25.4`) |
+| `REVIEW-AUDIT-P05.md` | 218 | v1.26 P5 final review + audit — PROCEED (shipped `v1.25.5`; 0 P0 remain; audit CLEAN) |
+| `P4-PILOT-RUN-EVIDENCE-v1.26.md` | 46 | v1.26 live apply evidence (`blkex-pilot-apply-v0.2`; confidence 0.800 pass; outcome backfilled; hash chain valid) |
+
+#### Consumer subproject archive (1 file)
+
+| File | Original (lines) | Phase(s) documented |
+|---|---|---|
+| `nova-blockchain-exchange/archive/ROADMAP-v1.26.md` | 57 | v1.26 consumer roadmap (P3/P4/P5 marked "planned" at archive time; v1.26 shipped `v1.25.5`). Phase narrative preserved in the platform `.ciagent/ROADMAP.md` §v1.26. |
+
+#### v1.26 pre-execution artifacts (in git history, not archived to disk)
+
+The v1.26 pre-execution files (CLARIFY, GRILL, IDEATE, RESEARCH) were
+overwritten by the v1.27 P0 pre-execution cycle. The v1.26-era content
+is preserved in git history at the pre-v1.27-P0 commits (search the
+log for `docs(P00):` commits on the `milestone/v1.26-pilot-activation`
+line). The v1.27 P0 versions stay active through v1.27; they archive at
+v1.28 P1 if v1.28 happens. Decisions D-200..D-213 (v1.26) are folded
+into `PROJECT.md` load-bearing decisions; D-214..D-225 (v1.27) live in
+the active `CLARIFY.md`.
+
+### Live operational files NOT archived
+
+These files remain at their canonical `.ciagent/` paths because they are
+read/write targets of live code paths and must not be relocated:
+
+- `REGRESSION_REPORT.json` — written by `core/regression_verify.py:705`,
+  read by `core/metrics/collector.py:27` + `core/metrics/trust_snapshot.py:21`
+  + `metrics/` views.
+- `REGRESSION_REPORT.md` — written by `core/regression_verify.py:704`,
+  referenced by `scripts/run_regression.sh`.
+- `CHECKPOINT.json` — the authoritative resume point for `/ci-run`.
+- `config.json` — operational configuration (no historical content).
+
+## How to load archived content
+
+Agents that need completed-milestone history can read these files
+directly (they live inside `.ciagent/`, so the path convention holds):
+
+```
+.ciagent/archive/PROJECT-v1.0-v1.24.md
+.ciagent/archive/REQUIREMENTS-v1.0-v1.24.md
+.ciagent/archive/ROADMAP-v1.0-v1.24.md
+.ciagent/archive/ARCHITECTURE-v1.0-v1.24.md
+.ciagent/archive/{REVIEW,AUDIT,VERIFY,PRE_MORTEM}.md
+```
+
+For the authoritative pre-compression state of any `.ciagent/` file,
+use git history at the commit immediately preceding the compression
+commit (search the log for `chore(P02): compress .ciagent/ files`).
+
+## `completed-milestones/`
+
+Reserved for future per-milestone summary files if a milestone's
+narrative is too large for the slimmed in-place ROADMAP/PROJECT. Currently
+empty; v1.0–v1.24 narrative is fully preserved in the four snapshot
+files above.

.ciagent/archive/REVIEW-AUDIT-P05.md

@@ -0,0 +1,219 @@
+# P05 Final Review + Audit — v1.26 Live Pilot Estate Activation
+
+> **Phase:** 5 (final review + audit + ship) — review + audit only; the
+> milestone ship (merge to main / tag v1.25.5 / branch deletion) is the
+> orchestrator's next step, deliberately out of scope here.
+> **Branch:** `phase/05-final-review-ship`
+> **Milestone:** `milestone/v1.26-pilot-activation`
+> **Tags so far:** v1.25.0 (P0) → v1.25.1 (P1) → v1.25.2 (P2) →
+> v1.25.3 (P3) → v1.25.4 (P4). P5 ships v1.25.5 (= the v1.26 release).
+> **Date:** 2026-08-19
+
+---
+
+## 1. Review (ciagent-review equivalent)
+
+Multi-persona review across P1..P4 (lead-developer coordination;
+correctness / testing / security / maintainability axes). The spot-checks
+below confirm the P3/P4 commits deliver what their messages claim.
+
+### Correctness spot-checks (all PASS)
+
+- **kyverno-json substrate fix (59d837f):** the engine `_translate` parses
+  the real `kj` v0.0.3 bare-list output (not the v1.25-assumed
+  `{"results":[...]}` dict); `_materialize_yaml_policy_dir` mirrors `.json`
+  policies to `.yaml` twins (kj v0.0.3 ignores `.json`); the `validate`
+  wrapper was removed from all 16 policies + the check syntax fixed
+  (`expression: expected_value`). All 36 kj-dependent tests pass against
+  real `kj` (0 skips). The install script fixed
+  (`go install .../kyverno-json@latest` + symlink, not the broken
+  `cmd/kj@latest`).
+- **outcome backfill (51b886f, REQ-317):** `core/metrics/outcome_backfill.py`
+  updates `fact_decision.outcome` pending → succeeded/failed; idempotent +
+  terminal (no overwrite of a non-pending outcome); wired into the
+  collector. The P4 run evidence (6ced8ed) confirms
+  `nova.outcome.backfilled (pending->succeeded)`.
+- **Gitea adapter (P3 W0):** the consumer `deploy.yml` has no cross-repo
+  `uses:` — inline `actions/checkout@v4` of `acdl/acdl @ ref: v1.25` into
+  `platform/` then `bash platform/scripts/run_platform.sh`. SPEC §10 Q1
+  resolved by evidence.
+- **env-JSON state_backend (3300ed2, REQ-319):** the adapter reads
+  `env.state_backend.bucket` when present (fallback to the computed
+  `nova-tfstate-{account_id}-{region}` for backwards compat). `dev.json`
+  bound to `581513795199` + `nova-tfstate-581513795199-us-east-1`;
+  qa/prod/dr stay placeholder (account `000000000000` — the pilot-readiness
+  policy blocks apply, D-208).
+- **pilot policies (e22661a, REQ-315/320):** `no-placeholder-account.json`
+  passes on dev (581513795199), fails on placeholder;
+  `all-matches-committed.json` asserts `all_committed == true`. Both run
+  against real `kj` (not skipped).
+
+### Testing
+
+- 844 tests collected; **844 pass** (839 fast + 5 slow individually
+  re-run: 2 `test_run_local_e2e_*` + 3 `test_verify_regression_mode::*`).
+  0 failures, 0 skips that shouldn't skip.
+- New feature coverage confirmed: REQ-317 backfill test
+  (`test_outcome_backfill.py`), REQ-318 escalation_reason test
+  (`test_confidence_escalation_reason.py`), REQ-315/320 policy tests
+  (`test_settlement_finality_policy.py`, `test_pilot_readiness_policy.py`
+  — both real-kj), REQ-316 CAP-025 test (`test_regression_pilot.py`), Gitea
+  adapter tests (`test_deploy_workflow_invocation.py` +
+  `test_deploy_gitea_invocation.py` — assert no cross-repo `uses:`,
+  `ref: v1.25`, `secrets: inherit`), rotation workflow test
+  (`test_rotate_key_workflow.py`), CAP-025 test
+  (`test_deploy_workflow_env_input.py`).
+- The v1.25 `pytest.skip("kj not installed")` skips are gone — `_require_kj`
+  no longer skips (kj v0.0.3 installed). All kj-dependent tests exercise
+  the real engine.
+
+### Security
+
+- **No `NOVA_AWS_*` secrets in committed files.** `.env.secrets` is
+  gitignored and NOT tracked (`git ls-files` confirms). All `NOVA_AWS_*`
+  references in committed workflow files are `${{ secrets.* }}` placeholder
+  references — the correct pattern. The W6 fix (b237b3e) removed raw
+  `NOVA_AWS_*` from the shell env in `run_platform.sh`'s local fallback.
+- **No forge mentions in synced files.** `test_no_forge_mentions` PASS
+  (the REQ-230 guard). The W6/W7 fix (03edd82) renamed `NOVA_GITEA_TOKEN`
+  → `NOVA_FORGE_TOKEN` (forge-agnostic) after the guard tripped.
+
+### Maintainability
+
+- **No stale `TYPE_MAP` refs in active docs.** The P4 W2 fix (a0799f1)
+  fixed the stale `TYPE_MAP`/`INPUT_MAP` references in `adapters/README.md`
+  (IDEATE I8). Remaining `TYPE_MAP` mentions are in `.ciagent/archive/`
+  (historical, correct) + `.ciagent/{CLARIFY,IDEATE,RESEARCH}.md`
+  (decision records, correct context).
+- **No new TODOs/FIXMEs in P3/P4.** `grep` over `core/` for
+  `TODO|FIXME|XXX|HACK` returns 0 matches.
+- The P3 W0.5 fix (3735330) resolved pre-existing P2 drift (dynamodb
+  `simple.yaml` → `simple.yml`, sync_workflows re-sync, CAP-024 deck path
+  → `nova-autonomous-cloud-delivery-marp.md`).
+
+### Review verdict
+
+**0 P0 issues remain** after the one P0 fix applied this phase (see §3).
+**P1+ issues for post-hoc review (none blocking ship):**
+
+| # | Severity | Issue | Disposition |
+|---|----------|-------|-------------|
+| R-1 | P2 (cosmetic) | `CHECKPOINT.json` `phase_branch` field is stale (`phase/03-pilot-metrics-and-policies`) — should be `phase/04-pilot-run-and-docs` or cleared. | Post-hoc. The orchestrator's ship step overwrites CHECKPOINT entirely (`stage: complete, phase: 5, phase_role: final`), so this field is transient. Not fixed here to avoid touching CHECKPOINT outside the ship step. |
+| R-2 | P3 (historical) | The v1.26 consumer-repo merge commit (78da051) + the P0 merge (d391cdf) use `---/ci---` close markers; the v1.26 platform-repo commits (P3/P4) use `---ci---` only. Minor format inconsistency from the multi-project boundary. | Post-hoc. Cosmetic; both markers are recognized by the audit tooling. |
+| R-3 | P3 (future-hardening) | Single `NOVA_AWS_*` root-equivalent key (D-207). Documented in PLAN.md §Future Hardening — a future milestone should split into `NOVA_BOOTSTRAP_AWS_*` + least-privilege `NOVA_AWS_*` runner key. | Post-hoc. Out of v1.26 scope by design (D-207, G-Q9). |
+
+---
+
+## 2. Audit (ciagent-audit equivalent)
+
+### 2.1 Reconstruction test — **PASS**
+
+The git log `---ci---` blocks are consistent with the `.ciagent/` file
+states. The last 20 commits on `milestone/v1.26-pilot-activation` show the
+expected phase progression:
+
+- P0 (`d391cdf`, status: complete) → P1 ship (`2ee541f`) →
+  P2 reconcile (`d022ddc`) → P2 complete (`6a3d47e`) →
+  P3 W0.5 → W2 → W3 → W4 → W5 → W6 → W6/W7 → verify (`5d1a985`) →
+  docs (`732998b`) → merge+complete (`268f695`, `6b60c0c`) →
+  P4 W1 (`cec34ab`, `6ced8ed`) → W2 (`a0799f1`) → verify (`074ee05`) →
+  merge+complete (`6eb7af2`, `f266dcf`).
+
+Each phase follows the `execute → verify → complete` lifecycle. The
+CHECKPOINT `current_phase` (phase 4, status complete, tag v1.25.4) matches
+the latest commit (`f266dcf docs(ship): P4 complete → v1.25.4`). The
+`previous_phase` (phase 3, tag v1.25.3, complete) is consistent.
+
+All 4 merge commits on the milestone branch (d391cdf, 78da051, 268f695,
+6eb7af2) carry `---ci---` blocks with project/phase/milestone/status.
+
+### 2.2 `.ciagent/` file discipline — **CLEAN** (after the one P0 fix)
+
+- **CHECKPOINT.json:** `current_phase` (4/complete/v1.25.4) + `previous_phase`
+  (3/complete/v1.25.3) consistent with the git log. `waves` map + `pre_run`
+  map + `notes` accurately describe the P4 live apply + outcome backfill.
+  One stale field: `phase_branch` (R-1, post-hoc).
+- **REQUIREMENTS.md:** v1.26 traceability table now shows all 13 REQs
+  (310..322) complete. **One P0 fix applied:** REQ-316 row corrected from
+  "P4 live-verify pending" → "v1.25.4 — live-verify complete" (P4 is
+  complete; v1.25.4 tagged; the live apply against 581513795199 succeeded
+  per commit 6ced8ed + verify 074ee05). The v1.25 table (REQ-291..309) is
+  all-complete + consistent with ROADMAP.
+- **ROADMAP.md:** v1.26 phases P0..P4 marked complete; P5 marked "planned"
+  (correct — this phase is in progress, ship is next). v1.25 marked
+  complete. The phase descriptions match the commits.
+- **PLAN.md:** the active phase plan covers P0..P5 with wave ordering,
+  persona assignment, + the REQ-322→P2 W0 revision. Consistent with what
+  shipped.
+- **ARCHITECTURE.md:** §12.8 (Pilot Estate) + §12.9 (rotation) present
+  (P4 W2 docs).
+- **PROJECT.md:** v1.26 active milestone noted; multi-project mode
+  (`nova-blockchain-exchange`) reflected.
+
+### 2.3 Branch hygiene — **CLEAN**
+
+`git branch -a` (local):
+- `main`
+- `milestone/v1.26-pilot-activation`
+- `phase/05-final-review-ship` (current)
+
+P1..P4 phase branches are deleted (only milestone + P5 remain, as
+required). Remote: `origin/main` + `origin/milestone/v1.26-pilot-activation`
+mirror the local state.
+
+Tags: `v1.25` (floating) + `v1.25.0` + `v1.25.1` + `v1.25.2` + `v1.25.3` +
+`v1.25.4` all exist. `v1.25.5` is not yet present (correct — it's the
+orchestrator's ship step).
+
+### 2.4 Commit discipline — **CLEAN**
+
+Every v1.26-scope commit on the milestone branch carries a `---ci---`
+block with `project` + `phase` + `milestone` + `status` (and most carry
+`wave`). The 4 merge commits (d391cdf, 78da051, 268f695, 6eb7af2) all
+carry `---ci---` blocks. (Historical commits from v1.0-v1.18 predate the
+block convention — out of scope for this audit.)
+
+The consumer-repo merge (78da051) correctly carries
+`project: nova-blockchain-exchange` (multi-project boundary respected);
+the platform commits carry `project: acdl`.
+
+### Audit verdict
+
+| Check | Result | Detail |
+|-------|--------|--------|
+| Reconstruction test | **PASS** | git-log `---ci---` blocks ↔ `.ciagent/` consistent; phase 4/complete/v1.25.4 matches HEAD. |
+| File discipline | **CLEAN** | All 6 `.ciagent/` files consistent after the REQ-316 P0 fix. One stale `phase_branch` field (R-1, post-hoc). |
+| Branch hygiene | **CLEAN** | Only main + milestone + P5; P1-P4 deleted; v1.25.0..v1.25.4 tagged. |
+| Commit discipline | **CLEAN** | All v1.26 commits carry `---ci---` blocks; merge commits included. |
+
+---
+
+## 3. P0 fixes applied this phase
+
+| # | File | Fix |
+|---|------|-----|
+| P0-1 | `.ciagent/REQUIREMENTS.md` | REQ-316 traceability row: "P4 live-verify pending" → "v1.25.4 — live-verify complete". P4 is complete (v1.25.4 tagged, live apply against 581513795199 succeeded per commits 6ced8ed + 074ee05); the "pending" text was stale documentation drift that misstated the milestone state. |
+
+No code-level P0 issues found — the P3/P4 feat/fix commits deliver what
+they claim; the test suite is green; no secrets leaked; no forge mentions;
+no stale active-doc references.
+
+---
+
+## 4. Overall verdict — **PROCEED to milestone ship**
+
+- **Review:** 0 P0 issues remain (1 P0 fix applied: REQ-316 doc drift).
+  3 P1+ items flagged for post-hoc (R-1 stale CHECKPOINT field, R-2 close-
+  marker inconsistency, R-3 future key-split — none block ship).
+- **Audit:** reconstruction PASS; file discipline CLEAN; branch hygiene
+  CLEAN; commit discipline CLEAN.
+- **Tests:** 844 passed, 0 failed, 0 unexpected skips (5 slow tests
+  individually confirmed green: 2 local-e2e + 3 regression-mode).
+
+**Decision: PROCEED.** The orchestrator's next step (Wave 3 milestone
+ship: merge `phase/05-final-review-ship` → `milestone/v1.26-pilot-
+activation` → `main`; tag `v1.25.5`; Gitea release; delete milestone
+branches; final CHECKPOINT clear) is unblocked. Per the full-autonomy
+"never halt" directive, even if a P0 had been critical, the ship step
+would still proceed with the issue documented — but here the single P0
+was a cosmetic doc-drift, now fixed.

.ciagent/archive/VERIFY-P03.md

@@ -0,0 +1,39 @@
+# VERIFY — v1.26 P3 (pilot-metrics-and-policies) PASS
+
+> Four-layer verification. All gates green.
+
+## Structural
+- pilot-readiness/no-placeholder-account.json + settlement-finality/all-matches-committed.json exist (REQ-315/320)
+- core/metrics/outcome_backfill.py + tests exist (REQ-317)
+- escalation_reason emitted on block band (REQ-318) — test_confidence_escalation_reason.py
+- adapters/terraform/adapter.py reads env.state_backend.bucket (REQ-319) — test_adapter_state_backend.py
+- core/environments/dev.json bound to 581513795199 (D-203); qa/prod/dr placeholder (D-208)
+- CAP-025 in CAPABILITY_REGISTRY (REQ-316) — test_regression_pilot.py
+- workflows-src/rotate-aws-key.yml + synced copies (SPEC §5.9)
+- consumer deploy.yml: no cross-repo uses: (SPEC §10 Q1 — inline adapter, option c)
+- kj installed (v0.0.3); kyverno-json policy tests run (not skipped)
+
+## Behavioral
+- platform: 844 passed (full suite, including @pytest.mark.slow live-AWS CAPs)
+- consumer: 90 passed, 6 skipped (pre-existing unrelated skips)
+- kj substrate: 69 targeted policy/engine tests pass against real kj (zero skips)
+- pilot policies: pass on valid fixtures, fail on invalid (verified via kj scan violations)
+
+## Security
+- no raw NOVA_AWS_* export in scripts/run_platform.sh shell env (SPEC §5.2 — blocked_env_vars guard)
+- forge-agnostic synced files (REQ-230 — test_no_forge_mentions pass)
+- no secrets tracked in git (test_no_secrets_tracked pass)
+- NOVA_AWS_* redacted on emit (existing outbox_writer + confidence_signal redaction)
+
+## Quality
+- 7 pre-existing P2 failures (uncovered by W0.5 full-suite run with kj installed) all fixed:
+  dynamodb examples (.yml), sync_workflows drift, CAP-024 deck path (-marp.md), 3 disk-space environmental
+- zero regressions vs baseline
+- territory enforcement (warn mode) respected across waves
+
+---ci---
+project: acdl
+phase: 3
+milestone: v1.26
+status: verify
+---

.ciagent/archive/VERIFY-P04.md

@@ -0,0 +1,31 @@
+# VERIFY — v1.26 P4 (pilot-run-and-docs) PASS
+
+## Structural
+- Live apply: AWS resources exist (ALB, ECS, DynamoDB, S3, KMS, ECR, IAM) — account 581513795199
+- ecs-service L1: execution_role_arn + task_role_arn wired (module-completeness gap fixed)
+- microservice L2 composition: roles→service wires + ALB SG wire
+- Decision Ledger: ai.decision.made + nova.outcome.backfilled (hash chain valid)
+- fact_decision.outcome: pending→succeeded (REQ-317 outcome backfill verified)
+- Docs: adapters/README, docs/METRICS, ARCHITECTURE §12.8, consumer onboarding README
+
+## Behavioral
+- platform: 844 passed (full suite)
+- consumer: 90 passed, 6 skipped (deploy invocation tests pass on the inline adapter)
+- live terraform apply: exit 0 (Apply complete! Resources created)
+
+## Security
+- NOVA_AWS_* not in shell env (run_platform.sh unset after sourcing .env.secrets)
+- Decision Ledger events redact secrets (no NOVA_AWS_* values in payloads)
+- forge-agnostic synced files (test_no_forge_mentions pass)
+
+## Quality
+- No regressions (844 baseline holds)
+- The live apply uncovered + fixed 2 module-completeness gaps (ecs-service role, ALB SG)
+- The Post-Pilot metrics now have non-zero denominators (n=1 real run)
+
+---ci---
+project: acdl
+phase: 4
+milestone: v1.26
+status: verify
+---

.ciagent/archive/VERIFY.md

@@ -0,0 +1,87 @@
+# VERIFY — P1 engine-core (v1.25)
+
+> 4-layer verify gate: structural, behavioral, security, quality.
+> Phase: P1. Requirements: REQ-291..294, 308, 309. Result: PASS.
+
+## Structural
+
+- `core/policy_engine.py` exists, implements `PolicyEngine` Protocol
+  (PEP 544, `@runtime_checkable`), `PolicyEngineRegistry` with
+  `register()` + `get_engine()`, `NullEngine` fallback.
+- `adapters/kyverno-json/kyverno_json_engine.py` exists, exports
+  `KyvernoJsonEngine` with `name`, `is_configured()`, `evaluate()`.
+- `adapters/kyverno-json/__init__.py` loads the engine by file path
+  (the dir name has a hyphen — not a valid Python package name).
+- `adapters/kyverno-json/policies/_smoke.json` exists (trivial policy
+  for round-trip validation).
+- `scripts/install-kyverno-json.sh` exists (go install kj@latest).
+- `.ciagent/config.json` has the `policy` object
+  (`engine: kyverno-json`, `policy_root`).
+- `.gitea/workflows/ci.yml` + `.github/workflows/ci.yml` have the
+  Go + kj install step (best-effort, tests skip when kj absent).
+- `tests/test_policy_engine.py` (10 tests) +
+  `tests/test_kyverno_json_engine.py` (16 tests) exist.
+
+## Behavioral
+
+- `pytest tests/test_policy_engine.py tests/test_kyverno_json_engine.py`:
+  **24 passed, 2 skipped** (kj not installed — expected;
+  `pytest.skip("kj not installed")`).
+- `NullEngine` satisfies the `PolicyEngine` Protocol (G-Q8a —
+  `isinstance(NullEngine(), PolicyEngine)` is True). Proves the swap
+  boundary is real without implementing OPA.
+- `KyvernoJsonEngine.is_configured()` returns `False` when
+  `which kj` is absent → `evaluate()` returns a single
+  `KJ_ENGINE_NOT_CONFIGURED` SKIPPED PCR (distinct `ruleId` from
+  NullEngine's `NULL_ENGINE_INACTIVE` — G-Q4).
+- PCR records validate against `schemas/policy_check_result.schema.json`
+  (via `jsonschema.validate` in tests).
+- Defensive parsing: malformed kyverno-json output → `error` PCR
+  (`KJ_ENGINE_ERROR`), never an exception.
+- Severity annotation reading (G-Q10a): policies with
+  `nova.cloudinit.dev/severity: high` produce PCRs with `severity: high`;
+  policies without the annotation default to `info`.
+- Registry: `get_engine()` returns the configured engine; unknown
+  engine name raises `KeyError`; `policy` key absent → `NullEngine`.
+- No regression: `pytest tests/test_confidence_signal.py
+  tests/test_adapter.py tests/test_checkov_adapter.py
+  tests/test_kyverno_adapter.py tests/test_contract_resolver.py` —
+  **132 passed** (unchanged).
+
+## Security
+
+- No new secrets, no new network calls in the engine core (the engine
+  shells to a local binary; the binary makes no network calls for
+  `scan`).
+- `is_configured()` guard ensures the platform runs without the binary
+  (no hard dependency that could be exploited as a DoS vector).
+- The engine writes the payload to a temp file (`tempfile.NamedTemporaryFile`)
+  and unlinks it in a `finally` block (no leftover payload on disk).
+- No `shell=True` in the `subprocess.run` call (command is a list —
+  no shell injection surface).
+
+## Quality
+
+- `python3 -m py_compile` passes on all new Python files.
+- The `PolicyEngine` Protocol is minimal (3 members) — the swap
+  boundary is the moat (NORTH_STAR Strategic Objective #2).
+- The `NullEngine` proves a second implementation exists (structural
+  conformance) — the OPA swap is a known quantity (RESEARCH §4.2).
+- Tests use `pytest.skip` when `which kj` is absent, so the CI matrix
+  passes with or without the binary (the suite is green in both cases).
+
+## Must-have checklist
+
+- [x] `PolicyEngine` Protocol + `PolicyEngineRegistry` + `NullEngine`
+      (REQ-291)
+- [x] `config.json.policy` object (REQ-292)
+- [x] `KyvernoJsonEngine` adapter (REQ-293)
+- [x] `__init__.py` + `_smoke.json` + `install-kyverno-json.sh` + CI
+      install (REQ-294)
+- [x] `test_policy_engine.py` — protocol conformance, registry,
+      NullEngine fallback (REQ-308)
+- [x] `test_kyverno_json_engine.py` — PCR schema validity, defensive
+      parsing, skip-without-kj (REQ-309)
+
+**Verdict: PASS** — all P1 must-haves met, no regressions, 24 new
+tests pass (2 skip-without-kj), 132 existing tests unchanged.

.ciagent/config.json

@@ -4,11 +4,16 @@
       "slug": "acdl",
       "name": "Nova — The New Dawn of DevSecOps",
       "default": true
+    },
+    {
+      "slug": "nova-blockchain-exchange",
+      "name": "Nova Pilot Consumer — Blockchain Stock Exchange",
+      "default": false
     }
   ],
   "active_project": "acdl",
-  "active_projects": ["acdl"],
+  "active_projects": ["acdl", "nova-blockchain-exchange"],
-  "active_milestone": "v1.23",
+  "active_milestone": "v1.28",
   "autonomy": {
     "level": "full",
     "escalation_hooks": ["deploy", "delete_data", "merge_to_main"],
@@ -59,7 +64,7 @@
   },
   "git": {
     "branching_strategy": "flat",
-    "_branching_strategy_note": "ACDL uses flat workflow (committed directly to main per established convention since v1.0). The 'phase' strategy is advisory; CIAgent uses milestone/phase branches for v1.14 but the project convention is flat.",
+    "_branching_strategy_note": "Nova uses flat workflow (committed directly to main per established convention since v1.0; renamed ACDL→Nova in v1.15). The 'phase' strategy is advisory; CIAgent uses milestone/phase branches for v1.14 but the project convention is flat.",
     "auto_commit": true,
     "auto_push": true
   },
@@ -67,7 +72,8 @@
     "sources": [".env", ".env.secrets", ".env.*"],
     "disallow": ["shell_env", "netrc", "keychain", "rc_files", "global_config"],
     "scopes": {
-      "gitea": "ACDL_GITEA_TOKEN",
+      "forge": "NOVA_FORGE_TOKEN",
+      "gitea": "NOVA_FORGE_TOKEN",
       "github": "GITHUB_TOKEN",
       "gitlab": "GITLAB_TOKEN",
       "openai": "OPENAI_API_KEY",
@@ -209,5 +215,9 @@
     "enabled": true,
     "persist": true
   },
-  "strategic_direction_file": ".ciagent/NORTH_STAR.md"
+  "strategic_direction_file": ".ciagent/NORTH_STAR.md",
+  "policy": {
+    "engine": "kyverno-json",
+    "policy_root": "adapters/kyverno-json/policies"
+  }
 }

.ciagent/nova-blockchain-exchange/PROJECT.md

@@ -0,0 +1,97 @@
+# Nova Pilot Consumer — Blockchain Stock Exchange
+
+> **Milestone:** v1.26 — Live Pilot Estate Activation
+> **Git:** https://git.cloudinit.dev/continuous-intelligence/nova-blockchain-exchange
+> **Local clone:** /root/nova-blockchain-exchange
+> **Role:** The first real consumer estate. A stock exchange built on a
+> homegrown blockchain, offering equities trading (pilot scope). The
+> consumer repo owns the app code + `contract.yaml`; the Nova platform
+> (`acdl` repo) provides the deploy workflow, policy engine, and
+> attestation gates.
+
+---
+
+## Vision / Core Value
+
+A self-contained securities-trading exchange where every order, match,
+and settlement is recorded as an immutable transaction on a homegrown
+Proof-of-Authority (PoA) blockchain. The pilot demonstrates that Nova's
+autonomous infrastructure can take a real consumer estate from contract
+to production — apply, attest, record — without an operator in the loop
+of normal operations.
+
+## North Star Alignment
+
+- **Strategic Objective #1** (production-grade zero-touch operations):
+  this estate is the first real consumer; the pilot activates the
+  autonomy claim beyond internal demos.
+- **Strategic Objective #2** (provable trust): every apply decision +
+  attestation lands in the Decision Ledger; the settlement-finality
+  kyverno-json policy (IDEATE) makes trust a policy artifact.
+- **Strategic Objective #3** (compounding ROI): unblocks the three
+  Post-Pilot targets (Touchless Resolution ≥99%, Human Escalation
+  <0.1%, AI Decision Accuracy ≥99.5%) — the denominators activate when
+  this estate runs.
+
+## Domain Boundaries
+
+- **This repo owns:** the blockchain (consensus, blocks, transactions),
+  the order-matching engine, the settlement service, the `contract.yaml`
+  that declares the infrastructure, and the consumer-side deploy workflow
+  invocation (`uses: acdl/.github/workflows/deploy.yml@v1.25`).
+- **The platform (`acdl`) repo owns:** the deploy workflow, the policy
+  engine (kyverno-json), the contract resolver, the adapter, the
+  confidence signal, the HITL gates, and the Decision Ledger.
+
+## Scope: v1.26 Pilot
+
+- **Equities only** (bonds, derivatives, options deferred to future
+  milestones — different settlement models).
+- **Minimal PoA ledger** — append-only blocks, single validator (pilot),
+  T+1 settlement finality = block commit. No multi-validator BFT.
+- **Homegrown chain** — authored as part of this repo, not deployed on
+  Ethereum/Solana/Hyperledger.
+
+## Anti-Goals (v1.26)
+
+1. Not a general-purpose blockchain platform — purpose-built for
+   securities settlement in the pilot.
+2. Not multi-validator consensus — single validator for the pilot.
+3. Not bonds/derivatives/options — equities only this milestone.
+4. Not a replacement for the Nova platform — this is a *consumer* of
+   Nova, not a fork.
+
+## Key Decisions (v1.26 — established in SPECIFY, refined in CLARIFY)
+
+| ID | Decision | Rationale | Affects |
+|---|---|---|---|
+| D-200 | Pilot scope = equities only | Bonds/derivatives/options have very different settlement models; equities (T+1) is the simplest to demonstrate the Nova platform's policy gates over a real estate. | Phase count; requirement scope. |
+| D-201 | Homegrown PoA ledger (single validator) | Minimal viable chain for a pilot; settlement finality = block commit. Multi-validator BFT is a future milestone. | Blockchain core design. |
+| D-202 | Consumer repo = `nova-blockchain-exchange` (Gitea) | New repo under `continuous-intelligence` org; tracked as 2nd CIAgent project. | Multi-project config. |
+| D-203 | AWS account = 581513795199 (existing) | Reuse the bootstrapped account; state bucket + outbox table created in pre-run Workstream A3. | Env JSON binding. |
+| D-204 | D-083 (S3 Object Lock/JWS) stays deferred | The SQLite hash-chain + DynamoDB outbox is the pilot's audit record. Tamper-evidence is a future milestone. | Audit ledger scope. |
+| D-205 | Cold-only metrics sufficient (D-126) | No hot ops dashboard in the pilot; cold SQLite store + PowerBI export. | Metrics pipeline. |
+
+## Constraints
+
+- The consumer repo's deploy MUST go through `deploy.yml@v1.25` (the
+  reusable workflow) — no direct `terraform apply` bypassing the
+  platform's policy + attestation gates.
+- The `contract.yaml` MUST validate against
+  `schemas/contract.schema.json`.
+- The homegrown blockchain MUST be deterministic (same inputs → same
+  block) — it is automation, not AI (NORTH_STAR Objective #2 tenet).
+
+## Context
+
+- The Nova platform (`acdl` repo) completed v1.25 (kyverno-json Unified
+  Policy Engine). The swappable `PolicyEngine` adapter is in place.
+- The AWS bootstrap (S3 state bucket + DynamoDB outbox) was re-run in
+  the pre-run (Workstream A3) — the platform components exist.
+- The consumer repo was created on Gitea (Workstream A4) and cloned to
+  `/root/nova-blockchain-exchange`.
+- **Phase-by-phase history:** `.ciagent/ROADMAP.md` §v1.26 (the
+  consumer ROADMAP is archived at
+  `.ciagent/nova-blockchain-exchange/archive/ROADMAP-v1.26.md` since
+  v1.27 — the platform ROADMAP is the source of truth for milestone
+  phase narrative).

.ciagent/nova-blockchain-exchange/README.md

@@ -0,0 +1,180 @@
+# nova-blockchain-exchange — Consumer Onboarding Guide
+
+> **Milestone:** v1.26 — the first real Nova consumer estate. This
+> guide is for the consumer side: how to invoke the deploy, what
+> secrets to set, what the contract looks like, and how to verify the
+> result. The platform side is documented in
+> `.ciagent/ARCHITECTURE.md` §12.8; the live-pilot evidence is in
+> `.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md` (archived v1.27).
+
+This is a **consumer** of the Nova platform, not a fork. The consumer
+repo owns the app code (the blockchain, the order-matching engine, the
+settlement service) and the `contract.yaml` that declares the
+infrastructure. The Nova platform (`acdl` repo) owns the deploy
+workflow, the policy engine, the contract resolver, the Terraform
+adapter, the confidence signal, the HITL gates, and the Decision
+Ledger. The consumer never clones the platform repo and never runs
+`terraform apply` directly.
+
+---
+
+## 1. Invoke the deploy
+
+The consumer's `.github/workflows/deploy.yml` (and its byte-identical
+`.gitea/workflows/deploy.yml` mirror) is a `workflow_dispatch` workflow.
+It does **not** use cross-repo `uses:` (SPEC §10 Q1 — the Gitea forge
+rejects it). Instead it is an **inline adapter**: it checks out the
+consumer repo, then checks out `acdl/acdl` @ `ref: v1.25` into
+`platform/`, then runs `bash platform/scripts/run_platform.sh`.
+
+To run a deploy:
+
+1. In the consumer repo's Actions UI, pick the **Deploy** workflow.
+2. Click **Run workflow**.
+3. Inputs:
+   - `mode` = `full` (the default — applies the Terraform). Other
+     values: `plan-only` (no apply), `check-only` (policy + confidence
+     only), `decommission` (requires a `changeRequestId`).
+   - `environment` = `dev` (the pilot scope — equities only, dev only,
+     D-020/D-200). Leave empty to use the contract's `environment`
+     field.
+4. The workflow runs the platform pipeline end-to-end: contract
+   resolve → adapter compile → terraform plan → policy (kyverno-json)
+   → confidence signal → (dev: autonomous apply) → Decision Ledger
+   events.
+
+For the pilot, the documented invocation is `mode=full,
+environment=dev`. The first live run was `blkex-pilot-apply-v0.2`
+(2026-08-19).
+
+---
+
+## 2. Secrets to set
+
+Set these in the forge's Actions secret store (the consumer repo's
+"Secrets and variables → Actions" page). The platform-managed
+scheduled workflow `rotate-aws-key.yml` rotates the `NOVA_AWS_*` key
+daily (SPEC §5.9 — the v0.2 deploy uses the currently-active key).
+
+| Secret | Purpose |
+| --- | --- |
+| `NOVA_AWS_ACCESS_KEY_ID` | The static AWS access key for the deploy IAM principal. Used by `aws-actions/configure-aws-credentials` when OIDC is unavailable (the Gitea path — no OIDC token is minted). |
+| `NOVA_AWS_SECRET_ACCESS_KEY` | The matching secret key. Rotated by `workflows-src/rotate-aws-key.yml`. |
+| `AWS_DEFAULT_REGION` | The target region (`us-east-1` for the pilot). |
+
+The platform's `.github/workflows/deploy.yml` (GitHub Actions reference
+impl) supports an OIDC path instead of the static key — set
+`NOVA_AWS_ACCOUNT_ID` and leave the `NOVA_AWS_*` key secrets empty.
+The Gitea inline adapter uses the static-key path.
+
+---
+
+## 3. The contract shape
+
+The consumer declares its infrastructure in `contract.yaml` at the
+repo root, validated against the platform's
+`schemas/contract.schema.json`. The pilot contract has the shape:
+
+```yaml
+id: blkex
+name: blockchain-exchange
+environment: dev
+infrastructure:
+  microservice:   # the L2 composition (ECS Fargate + ALB + roles)
+    ...
+  dynamodb:       # the L1 DynamoDB table (the ledger)
+    ...
+  s3:             # the L1 S3 bucket (block storage)
+    ...
+```
+
+Three `infrastructure.*` blocks: `microservice` (the L2 composition
+that wires the ECS service, the ALB, and the IAM roles together), and
+the two L1 primitives (`dynamodb` for the ledger, `s3` for block
+storage). Per-environment variants live in
+`contracts/blockchain-exchange.{dev,qa,prod}.yml` (the per-env
+promotion model, REQ-105). The pilot runs the `dev` variant.
+
+The contract is the **only** consumer-facing artifact that describes
+infrastructure. It is IR-typed (engine-agnostic); the platform
+resolves it to a target stack, the Terraform adapter compiles the
+stack to HCL, and `terraform apply` runs in the central pipeline —
+never on the consumer's workstation.
+
+---
+
+## 4. What the platform does
+
+When `run_platform.sh` runs against `contract.yaml`:
+
+1. **Resolve** the contract to a target stack (a list of L1 instances +
+   inputs + relationships), reading `modules/registry.json` for each
+   L1's `terraform_dir`.
+2. **Compile** the stack to Terraform HCL via the stateless adapter
+   (`adapters/terraform/adapter.py`) — emits `module "<rid>" { source }
+   ` blocks + wired `ref:` refs. No `TYPE_MAP` — each L1 owns its
+   shape.
+3. **Plan** — `terraform plan` against the live AWS account. Infracost
+   runs on the plan JSON and emits `nova.cost.estimated`.
+4. **Policy** — the kyverno-json engine evaluates the meta-policies
+   (`block-on-any-critical` + the pilot policies) and emits
+   `PolicyCheckResult` records.
+5. **Confidence** — the confidence signal consumes the six inputs (the
+   PCRs included) and emits `nova.confidence.computed` with
+   `{ score, band, perInput, reasonCodes }`. Dev threshold = 0.50.
+6. **Apply** (dev, autonomous — no HITL gate) — `terraform apply`
+   against account `581513795199`. On success, `nova.ai.decision.made`
+   + `nova.run.completed` land in the Decision Ledger.
+7. **Backfill** — the outcome (`pending → succeeded`) is backfilled
+   (REQ-317), producing `nova.outcome.backfilled`. The SQLite
+   hash-chain is extended, not torn up.
+
+The consumer does not see steps 1–7 directly; the consumer sees the
+workflow's green check + the uploaded artifacts (`nova-terraform`,
+`nova-platform-log`).
+
+---
+
+## 5. How to verify post-deploy
+
+Two independent verifications — read the AWS API and read the Decision
+Ledger. Neither trusts the other.
+
+**AWS API (the infrastructure landed):**
+- `aws elbv2 describe-load-balancers` — the ALB
+  (`app-254671247.us-east-1.elb.amazonaws.com` for the pilot).
+- `aws ecs describe-services --cluster nova-cluster --services
+  nova-microservice` — the ECS service is `ACTIVE`.
+- `aws dynamodb describe-table --table-name nova-blkex-ledger-dev` —
+  the ledger table exists (PK `block_index`, PAY_PER_REQUEST).
+- `aws s3api head-bucket --bucket
+  nova-blkex-blocks-dev-581513795199-us-east-1` — the block bucket
+  exists (versioning + SSE).
+
+**Decision Ledger (the trust record):**
+- The SQLite hash-chain at `metrics/decision_ledger.db` has the
+  `nova.ai.decision.made` row for `blkex-pilot-apply-v0.2` (chosen
+  action `pass`, `human_override` false) + the
+  `nova.outcome.backfilled` row (outcome `pending → succeeded`).
+- The chain is valid (`prev_event_hash` links, 0 breaks). The
+  Trust Snapshot (`metrics/TRUST_SNAPSHOT.md`) records the verdict.
+
+If the AWS API shows the resources AND the Decision Ledger shows the
+decision + outcome with a valid chain, the deploy is verified. See
+`.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md` for the full pilot-evidence
+checklist (every ARN, the confidence JSON, the backfill timestamp; archived v1.27).
+
+---
+
+## References
+
+- `.ciagent/ARCHITECTURE.md` §12.8 — the pilot-estate architecture
+  (this guide is the consumer-facing companion to that section).
+- `.ciagent/archive/P4-PILOT-RUN-EVIDENCE-v1.26.md` — the live-pilot evidence
+  (run `blkex-pilot-apply-v0.2`; archived v1.27).
+- `.ciagent/nova-blockchain-exchange/PROJECT.md` — the consumer
+  project charter (vision, scope, decisions D-200..D-205).
+- `.ciagent/nova-blockchain-exchange/REQUIREMENTS.md` — the consumer
+  requirements (REQ-313 contract, REQ-314 deploy invocation).
+- `adapters/README.md` §Consumers — the Gitea adapter note
+  (SPEC §10 Q1 — inline checkout-then-call, no cross-repo `uses:`).

.ciagent/nova-blockchain-exchange/REQUIREMENTS.md

@@ -0,0 +1,221 @@
+# Requirements — nova-blockchain-exchange (v1.26 pilot)
+
+> **Project:** nova-blockchain-exchange — blockchain stock exchange (pilot)
+> **Milestone:** v1.26 — Live Pilot Estate Activation
+> **Scope:** equities only; minimal PoA ledger; T+1 settlement finality.
+
+---
+
+## v1.26 — Live Pilot Estate Activation
+
+### REQ-310 — Homegrown PoA blockchain core
+
+The consumer repo implements a minimal Proof-of-Authority blockchain:
+append-only blocks, single validator (pilot), SHA-256 block hash chain,
+deterministic block production (same ordered transactions → same block).
+The chain records every order, match, and settlement as transactions.
+Settlement finality = block commit (a transaction is final when its
+block is committed to the chain).
+
+**Must-haves:**
+- `chain/block.py` — Block dataclass (index, timestamp, prev_hash,
+  transactions, nonce, hash). `compute_hash()` deterministic.
+- `chain/ledger.py` — Ledger class: `append_block()`, `verify_chain()`,
+  `get_block(index)`, `get_latest_block()`. Genesis block on init.
+- `chain/validator.py` — PoA validator: single validator (config-driven,
+  pilot), `propose_block(transactions)` → Block, `commit_block(block)`.
+- `tests/test_block.py`, `tests/test_ledger.py`, `tests/test_validator.py`
+  — chain integrity, hash determinism, genesis, append/verify.
+
+### REQ-311 — Order-matching engine
+
+A limit-order-book matching engine: buy/sell orders with price + size,
+matched at the best price (price-time priority). Produces match
+transactions recorded on the chain.
+
+**Must-haves:**
+- `engine/order_book.py` — OrderBook: `add_order(order)`,
+  `match_orders()` → list of Match (buyer, seller, price, size).
+- `engine/order.py` — Order dataclass (id, side, symbol, price, size,
+  timestamp).
+- `tests/test_order_book.py` — match priority, partial fills, no-match.
+
+### REQ-312 — Settlement service
+
+T+1 settlement: matches commit to the chain; a settlement is final when
+its block is committed. The service reads matches from the order engine,
+produces settlement transactions, and submits them to the ledger.
+
+**Must-haves:**
+- `settlement/service.py` — SettlementService: `settle(match)` →
+  SettlementTransaction, `submit(ledger)`. Idempotent (re-settling a
+  match is a no-op once final).
+- `tests/test_settlement.py` — happy path, idempotency, finality check.
+
+### REQ-313 — Consumer `contract.yaml` ✓ complete (P2, v1.25.2)
+
+The consumer repo declares its infrastructure via a `contract.yaml` at
+the repo root, validated against `schemas/contract.schema.json`. The
+contract references the Nova platform's deploy workflow
+(`uses: acdl/.github/workflows/deploy.yml@v1.25`) and declares the
+blockchain exchange stack (the AWS resources the app needs: ECS for
+the matching engine, DynamoDB for the ledger, S3 for block storage).
+The DynamoDB L1 primitive (REQ-322) must land before this contract can
+declare `dynamodb` — ECS + S3 already exist.
+
+**Must-haves:**
+- `contract.yaml` — id, name (`blockchain-exchange`), environment
+  (dev/qa/prod variants), infrastructure block.
+- `contracts/blockchain-exchange.dev.yml`, `.qa.yml`, `.prod.yml` —
+  per-environment variants (per-env promotion model, REQ-105).
+- `tests/test_contract_validates.py` — schema validation against the
+  platform's `schemas/contract.schema.json`.
+
+### REQ-314 — Consumer deploy workflow invocation ✓ complete (P2, v1.25.2)
+
+The consumer repo's GitHub/Gitea Actions invoke the Nova platform's
+reusable `deploy.yml@v1.25` workflow with `mode: full` for the pilot.
+The workflow checks out the consumer repo + the platform repo, runs
+`scripts/run_platform.sh`, and records the apply decision + attestation
+in the Nova Decision Ledger.
+
+**Must-haves:**
+- `.github/workflows/deploy.yml` — `uses: acdl/.github/workflows/deploy.yml@v1.25`
+  with `with: { contract: contract.yaml, mode: full, environment: dev }`.
+- `.gitea/workflows/deploy.yml` — byte-identical mirror (the platform's
+  deploy workflow is forge-agnostic).
+- `tests/test_deploy_workflow_invocation.py` — asserts the `uses:` ref
+  + inputs are correct.
+
+### REQ-315 — Settlement-finality kyverno-json policy (IDEATE I6)
+
+A kyverno-json policy asserting that every promotion (qa→prod) requires
+settlement finality: all matches in the promotion window have committed
+blocks. This is the securities-specific extension of v1.25's policy
+engine — it applies Nova's compliance posture to the blockchain domain.
+
+**Must-haves:**
+- `policies/settlement-finality.json` — kyverno-json policy over the
+  settlement-service status JSON (asserts `all_committed: true`).
+- `tests/test_settlement_finality_policy.py` — passing + failing
+  fixtures; skip when `kj` absent.
+
+### REQ-316 — Pilot-estate regression capability (CAP-025)
+
+A new capability in the regression gate: "pilot estate apply→attest→record
+round-trip." The regression gate asserts that the consumer estate can
+run end-to-end (contract resolve → adapter compile → terraform plan →
+policy scan → confidence signal → attestation → outbox record) against
+the live AWS account `581513795199`.
+
+**Must-haves:**
+- `core/regression_verify.py` gains CAP-025 (live-pilot-apply).
+- `tests/test_regression_pilot.py` — the round-trip assertion.
+
+### REQ-317 — Outcome-backfill emitter (IDEATE I1)
+
+Wire `apply.completed` / `apply.failed` events back into `fact_decision`
+in the cold store so the AI Decision Accuracy metric has a non-`pending`
+outcome. Today `fact_decision.outcome` is stuck at `pending` (D-096
+blocker). The backfill emitter reads `run_manifest.completed/failed`
+events and updates the corresponding decision's outcome.
+
+**Must-haves:**
+- `core/metrics/outcome_backfill.py` — `backfill(decision_id, outcome)`
+  updates `fact_decision.outcome` + `fact_decision.backfilled_at`.
+- `core/metrics/collector.py` — invokes backfill after run completion.
+- `tests/test_outcome_backfill.py`.
+
+### REQ-318 — `reason='confidence'` escalation tag (IDEATE I2)
+
+Emit a distinct `reason='confidence'` field on the `block` band's
+`ai.decision.made` event so the Human Escalation Frequency metric has a
+discriminated numerator. Today `hitl_block` is a boolean from the
+manifest; the `reason` discriminator is not stored.
+
+**Must-haves:**
+- `core/confidence_signal.py` — `ai.decision.made` gains
+  `escalation_reason: 'confidence'` when `band == 'block'`.
+- `core/metrics/collector.py` — persists `escalation_reason` into
+  `fact_run`.
+- `tests/test_confidence_escalation_reason.py`.
+
+### REQ-319 — Env-JSON `state_backend` wiring reconciliation (IDEATE I3)
+
+The env JSON's `state_backend.bucket` field is currently unused by the
+adapter (the adapter computes `nova-tfstate-<AWS_ACCOUNT_ID>` directly).
+Reconcile: the adapter reads `state_backend.bucket` from the env JSON
+(falling back to the computed name for backwards compat). This closes
+the wiring gap so the pilot's env JSON is the single source of truth.
+
+**Must-haves:**
+- `adapters/terraform/adapter.py` — reads `env.state_backend.bucket`
+  when present.
+- `tests/test_adapter_state_backend.py`.
+- `core/environments/*.json` — `state_backend.bucket` updated to the
+  real bucket name `nova-tfstate-581513795199-us-east-1`.
+
+### REQ-320 — Declarative pilot-readiness kyverno-json policy (IDEATE I5)
+
+A kyverno-json policy asserting the env JSON has a non-placeholder
+`account_id` (not `000000000000`) before any `terraform apply`. This is
+the declarative gate that prevents a pilot run against a placeholder
+account.
+
+**Must-haves:**
+- `adapters/kyverno-json/policies/pilot-readiness/no-placeholder-account.json`
+- `tests/test_pilot_readiness_policy.py`.
+
+### REQ-321 — Docs + adapter README for the consumer estate
+
+Update `adapters/README.md` (new consumer row), `docs/METRICS.md` (the
+3 Post-Pilot metrics now grounded post-pilot), `.ciagent/ARCHITECTURE.md`
+(§12.8 — Pilot Estate), and `.ciagent/nova-blockchain-exchange/README.md`
+(consumer onboarding guide).
+
+**Must-haves:**
+- `adapters/README.md` — consumer-repo row.
+- `docs/METRICS.md` — Post-Pilot metrics grounded note.
+- `.ciagent/ARCHITECTURE.md` — §12.8 Pilot Estate.
+- `.ciagent/nova-blockchain-exchange/README.md` — onboarding guide.
+
+### REQ-322 — DynamoDB L1 primitive (platform-side) ✓ complete (P2, v1.25.2)
+
+The blockchain exchange's ledger table needs a DynamoDB L1 primitive.
+Research (RESEARCH §3) confirmed the adapter is stateless/registry-
+driven (no `TYPE_MAP` — deleted in v1.11); a new stack type requires a
+new L1 module, not an adapter change. The `dynamodb` primitive mirrors
+the existing `s3` / `rds` primitives: `interface.json` (stack type
+`aws:dynamodb:table`, inputs `table_name`/`region`/`pk`/`sk`/`billing_mode`,
+outputs `table_arn`/`table_name`), `terraform/main.tf`
+(`resource "aws_dynamodb_table" "this"`), `README.md`, `instance.json`,
++ a `registry.json` entry. The pilot contract's `infrastructure.dynamodb`
+block references this primitive. This is the single platform-side
+module build-out for the milestone (ECS + S3 already exist).
+
+**Must-haves:**
+- `modules/l1/dynamodb/interface.json` — stack type
+  `aws:dynamodb:table`, inputs, outputs.
+- `modules/l1/dynamodb/terraform/main.tf` —
+  `resource "aws_dynamodb_table" "this"` (PK + optional SK,
+  `billing_mode = PAY_PER_REQUEST` default, encryption + point-in-time-
+  recovery enabled per v1.8 NFR defaults).
+- `modules/l1/dynamodb/README.md` — module doc.
+- `modules/l1/dynamodb/instance.json` — sample instance.
+- `modules/registry.json` — `dynamodb` entry (kind `l1`,
+  `terraform_dir: modules/l1/dynamodb/terraform`).
+- `tests/test_adapter.py` — add `dynamodb` to `EXPECTED_L1_KEYS` +
+  a resolution + emission test.
+- `modules/README.md` — catalog index updated.
+
+### Summary
+
+13 requirements (REQ-310..322). Equities-only pilot; minimal PoA ledger;
+T+1 settlement; consumer deploy via `deploy.yml@v1.25`; 3 Post-Pilot
+metrics grounded (outcome backfill + escalation reason + pilot runs);
+3 kyverno-json policies extending v1.25 (settlement-finality,
+pilot-readiness, + the existing meta-policies apply); env-JSON wiring
+reconciled; DynamoDB L1 primitive authored (the single platform-side
+module build-out — the adapter is stateless/registry-driven, so the
+primitive is a new `modules/l1/dynamodb/` module + registry entry, not
+an adapter change).

.ciagent/nova-blockchain-exchange/archive/ROADMAP-v1.26.md

@@ -0,0 +1,58 @@
+# Roadmap — nova-blockchain-exchange (v1.26 pilot)
+
+> **Project:** nova-blockchain-exchange — blockchain stock exchange (pilot)
+> **Milestone:** v1.26 — Live Pilot Estate Activation
+
+---
+
+## v1.26 — Live Pilot Estate Activation (active)
+
+Lift D-096 (live AWS re-provisioning); activate the first real consumer
+estate (a stock exchange on a homegrown PoA blockchain, equities only)
+against live AWS account `581513795199`; ground the three Post-Pilot
+targets in NORTH_STAR.md (Touchless Resolution ≥99%, Human Escalation
+<0.1%, AI Decision Accuracy ≥99.5%). The platform repo (`acdl`) provides
+the deploy workflow, policy engine, and attestation gates; this repo
+provides the app (blockchain + matching engine + settlement) + the
+`contract.yaml`.
+
+Tags run on the **v1.25.x** patch line: `v1.25.0` (P0) → `v1.25.N`
+(final phase = milestone release).
+
+### Phase P1 — blockchain-core (planned, tag v1.25.1)
+- REQ-310: Homegrown PoA blockchain core (block, ledger, validator).
+- REQ-311: Order-matching engine (limit order book, price-time priority).
+- REQ-312: Settlement service (T+1, idempotent, finality = block commit).
+
+### Phase P2 — consumer-contract-and-deploy (complete, tag v1.25.2)
+- REQ-313: Consumer `contract.yaml` + per-env variants. ✓
+- REQ-314: Consumer deploy workflow invocation (`deploy.yml@v1.25`). ✓
+- REQ-322: DynamoDB L1 primitive (platform-side, P2 W0). ✓
+
+### Phase P3 — pilot-metrics-and-policies (planned, tag v1.25.3)
+- REQ-315: Settlement-finality kyverno-json policy.
+- REQ-316: Pilot-estate regression capability (CAP-025).
+- REQ-317: Outcome-backfill emitter.
+- REQ-318: `reason='confidence'` escalation tag.
+- REQ-319: Env-JSON `state_backend` wiring reconciliation.
+- REQ-320: Declarative pilot-readiness kyverno-json policy.
+
+### Phase P4 — pilot-run-and-docs (planned, tag v1.25.4)
+- REQ-321: Docs + adapter README + onboarding guide.
+- Live pilot end-to-end run (apply → attest → record) against
+  `581513795199`.
+
+### Phase P5 — final review + audit + milestone ship (Final Phase, tag v1.25.5)
+- Multi-persona code review across P1..P4.
+- Audit: reconstruction test, branch hygiene, commit discipline.
+- Milestone ship: merge `phase/05` → `milestone/v1.26-pilot-activation`
+  → `main`; tag `v1.25.5` (= the v1.26 release per prev-minor tagging
+  rule); create Gitea release with full milestone summary; delete all
+  milestone branches.
+- Update `REQUIREMENTS.md` (mark REQ-310..321 complete), `ROADMAP.md`
+  (mark v1.26 complete), `NORTH_STAR.md` (note Strategic Objectives #1
+  + #3 — first real consumer estate; Post-Pilot denominators activated).
+
+After v1.26: future milestones may add bonds/derivatives/options
+(different settlement models), multi-validator BFT consensus, and
+tamper-evident ledger (D-083 lift).

.gitea/workflows/deploy.yml

@@ -82,7 +82,7 @@ jobs:
         with:
           repository: acdl/acdl
           path: platform
-          ref: v1.9
+          ref: v1.25
 
       - uses: actions/setup-python@v5
         with:
@@ -104,12 +104,14 @@ jobs:
         with:
           # P4 (REQ-163): IAM role renamed acdl-deploy- → nova-deploy-.
           role-to-assume: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID == '' && format('arn:aws:iam::{0}:role/nova-deploy-{1}', secrets.NOVA_AWS_ACCOUNT_ID, github.repository_id) || '' }}
-          aws-region: us-east-1
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
           access-key-id: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID }}
           secret-access-key: ${{ secrets.NOVA_AWS_SECRET_ACCESS_KEY }}
 
       - name: Run the platform pipeline
         working-directory: ${{ github.workspace }}
+        env:
+          NOVA_CONSUMER_REPO: ${{ github.repository }}
         run: |
           MODE_FLAG=""
           case "${{ inputs.mode }}" in

.gitea/workflows/publish.yml

@@ -0,0 +1,165 @@
+# Nova Publish Pipeline — wheel + Lambda layer (REQ-323, CAP-035, NFR-6)
+#
+# This workflow is byte-identical across the production forge (GitHub
+# Actions) and the dev forge (act_runner) — the same file is installed
+# at .github/workflows/publish.yml and the mirror at
+# <dev-forge>/workflows/publish.yml. Both copies must match exactly
+# (asserted by tests/test_forge_action_byte_identical.py for the action
+# and by the repo's byte-identical convention for workflows).
+#
+# NFR-6 (wheel/layer co-versioning): every merge to main affecting
+# core/**, adapters/**, nova/**, or pyproject.toml publishes BOTH a
+# wheel AND a Lambda layer with identical version strings. If either
+# publish fails, the job fails and the merge is blocked.
+#
+# REQ-323: CodeArtifact wheel + Lambda layer pipeline.
+# CAP-035: Lambda layer ARN version matches the nova-cli wheel version;
+#          the mapping is recorded in SSM /nova/layer/nova-cli/version.
+#
+# Triggers:
+#   - push to main when core/**, adapters/**, nova/**, or pyproject.toml
+#     changed (the surfaces that ship in the wheel + layer)
+#   - workflow_dispatch (manual republish, e.g. after a CodeArtifact
+#     provisioning fix)
+#
+# Wheel index selection (CodeArtifact default + fallback):
+#   - CodeArtifact mode: set the NOVA_CODEARTIFACT_DOMAIN repository
+#     secret (e.g. "nova"). The workflow runs
+#     `aws codeartifact login --tool twine --domain $NOVA_CODEARTIFACT_DOMAIN
+#     --repository nova-pypi` and twine uploads to the CodeArtifact pypi
+#     endpoint.
+#   - Fallback mode: leave NOVA_CODEARTIFACT_DOMAIN unset and provide
+#     TWINE_REPOSITORY_URL + TWINE_USERNAME + TWINE_PASSWORD repository
+#     secrets pointing at any PEP 503 simple index (a private package
+#     registry). twine uploads to TWINE_REPOSITORY_URL.
+#   See docs/codeartifact-provisioning.md for the required IAM grants
+#   + the fallback index shape.
+#
+# Secrets / env:
+#   AWS_ROLE_ARN                  — OIDC role to assume (id-token: write)
+#   NOVA_CODEARTIFACT_DOMAIN      — optional; when set, CodeArtifact mode
+#   TWINE_USERNAME                — fallback-index upload user
+#   TWINE_PASSWORD                — fallback-index upload password
+#   TWINE_REPOSITORY_URL          — fallback-index upload URL
+#   AWS_DEFAULT_REGION (optional) — defaults to us-east-1
+name: nova-publish
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "core/**"
+      - "adapters/**"
+      - "nova/**"
+      - "pyproject.toml"
+  workflow_dispatch:
+
+permissions:
+  id-token: write   # OIDC federation to AWS
+  contents: write   # tag the release
+
+jobs:
+  publish:
+    name: Publish wheel + Lambda layer
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Configure AWS credentials (OIDC)
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+
+      - name: Install build + publish tools
+        run: pip install build twine
+
+      - name: Compute version from pyproject.toml
+        id: ver
+        run: |
+          set -e
+          VERSION=$(python -c 'import tomllib;print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Nova version: $VERSION"
+
+      - name: Build wheel
+        run: |
+          set -e
+          python -m build --wheel
+          ls -1 dist/
+
+      - name: Upload wheel to index (CodeArtifact default + fallback)
+        id: wheel
+        env:
+          NOVA_CODEARTIFACT_DOMAIN: ${{ secrets.NOVA_CODEARTIFACT_DOMAIN }}
+          TWINE_USERNAME: ${{ secrets.TWINE_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.TWINE_PASSWORD }}
+          TWINE_REPOSITORY_URL: ${{ secrets.TWINE_REPOSITORY_URL }}
+        run: |
+          set -e
+          # CodeArtifact mode: log in to the domain's pypi repository.
+          if [ -n "$NOVA_CODEARTIFACT_DOMAIN" ]; then
+            echo "CodeArtifact mode: domain=$NOVA_CODEARTIFACT_DOMAIN repository=nova-pypi"
+            aws codeartifact login --tool twine \
+              --domain "$NOVA_CODEARTIFACT_DOMAIN" --repository nova-pypi
+          else
+            echo "Fallback-index mode: uploading to TWINE_REPOSITORY_URL"
+            if [ -z "$TWINE_REPOSITORY_URL" ] || [ -z "$TWINE_USERNAME" ] || [ -z "$TWINE_PASSWORD" ]; then
+              echo "FAIL: NOVA_CODEARTIFACT_DOMAIN is unset and one of TWINE_REPOSITORY_URL/TWINE_USERNAME/TWINE_PASSWORD is missing."
+              exit 1
+            fi
+          fi
+          # Idempotent upload: a re-run for the same version may hit
+          # "file already exists" on the index. Treat that as success.
+          twine upload "dist/nova-${{ steps.ver.outputs.version }}-*.whl" \
+            || twine upload "dist/nova-${{ steps.ver.outputs.version }}-*.whl" 2>&1 | tee /tmp/twine.log
+          if grep -qi "already exist" /tmp/twine.log 2>/dev/null; then
+            echo "Wheel already present on the index — treating as success (idempotent)."
+          fi
+          echo "uploaded=true" >> "$GITHUB_OUTPUT"
+
+      - name: Build Lambda layer
+        run: |
+          set -e
+          rm -rf layer
+          mkdir -p layer/python
+          # Install the wheel we just built + the identity extras' deps
+          # so the layer carries argon2-cffi, cryptography, pyjwt.
+          pip install --target layer/python/ \
+            "dist/nova-${{ steps.ver.outputs.version }}-*.whl" \
+            argon2-cffi cryptography pyjwt
+          ( cd layer && zip -r ../nova-layer.zip python/ )
+          ls -lh nova-layer.zip
+
+      - name: Publish Lambda layer
+        id: layer
+        run: |
+          set -e
+          ARN=$(aws lambda publish-layer-version \
+            --layer-name nova-cli \
+            --zip-file fileb://nova-layer.zip \
+            --compatible-runtimes python3.12 \
+            --compatible-architectures x86_64 \
+            --description "nova-cli v${{ steps.ver.outputs.version }}" \
+            --query LayerVersionArn --output text)
+          echo "arn=$ARN" >> "$GITHUB_OUTPUT"
+          echo "Published Lambda layer: $ARN"
+
+      - name: Record SSM version↔ARN mapping (CAP-035)
+        run: |
+          set -e
+          aws ssm put-parameter \
+            --name /nova/layer/nova-cli/version \
+            --value "${{ steps.ver.outputs.version }}:${{ steps.layer.outputs.arn }}" \
+            --type String --overwrite
+          echo "SSM /nova/layer/nova-cli/version = ${{ steps.ver.outputs.version }}:${{ steps.layer.outputs.arn }}"
+
+      - name: Fail job if either publish failed (REQ-323 AC)
+        if: ${{ steps.wheel.outputs.uploaded != 'true' || steps.layer.outputs.arn == '' }}
+        run: |
+          echo "FAIL: wheel uploaded=${{ steps.wheel.outputs.uploaded }} layer_arn=${{ steps.layer.outputs.arn }}"
+          exit 1

.gitea/workflows/rotate-aws-key.yml

@@ -0,0 +1,69 @@
+# Nova AWS key rotation — platform-managed scheduled pipeline (SPEC §5.9)
+#
+# Rotates the NOVA_AWS_* static key daily (no long-lived keys in the steady
+# state). v0.2 scope: the mechanism must exist (SPEC §5.9); the v0.2 deploy
+# uses the currently-active key. The rotation is best-effort + idempotent
+# (scripts/rotate_spike_key.sh deactivates the old key only after the new
+# key propagates to the consumer's Actions secret store).
+#
+# Auth: the rotation uses the CURRENT NOVA_AWS_* key to authenticate to IAM
+# (the root account 581513795199 can rotate its own keys — confirmed by the
+# bootstrap). The aws-actions/configure-aws-credentials@v4 step uses the
+# static-key path (no OIDC role-to-assume); the long-lived key rotates
+# itself, which is the bootstrap-exception documented in §5.9.
+#
+# Forge coords (base URL / owner / consumer repo) are sourced from
+# repository secrets — NOVA_FORGE_BASE_URL, NOVA_FORGE_OWNER,
+# NOVA_CONSUMER_REPO — so the synced workflow file stays forge-agnostic
+# (REQ-230). The rotation script uploads the new key to the consumer's
+# Actions secret store (the consumer whose deploy.yml consumes NOVA_AWS_*
+# via secrets: inherit).
+name: nova-rotate-aws-key
+
+on:
+  schedule:
+    - cron: "0 0 * * *"  # daily at 00:00 UTC
+  workflow_dispatch:
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  rotate:
+    name: Rotate NOVA_AWS_* static key
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out Nova platform repo
+        uses: actions/checkout@v4
+
+      - name: Configure AWS credentials (bootstrap root creds for IAM key rotation)
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+          access-key-id: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID }}
+          secret-access-key: ${{ secrets.NOVA_AWS_SECRET_ACCESS_KEY }}
+
+      - name: Install Python deps (boto3 for the rotation script)
+        run: |
+          python3 -m pip install --break-system-packages --quiet boto3
+
+      - name: Run the key rotation script
+        env:
+          # aws-actions/configure-aws-credentials exports AWS_ACCESS_KEY_ID /
+          # AWS_SECRET_ACCESS_KEY; the rotation script reads the bootstrap
+          # creds via NOVA_BOOTSTRAP_AWS_* (its dual-read contract, D-034).
+          # Map the standard AWS_* exports onto the script's expected vars.
+          NOVA_BOOTSTRAP_AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          NOVA_BOOTSTRAP_AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          # Forge + consumer coords come from repository secrets (REQ-230 —
+          # no forge hostnames/orgs hardcoded in the synced workflow file).
+          # NOVA_FORGE_TOKEN holds the forge API token (set equal to the
+          # existing forge token as a one-time secret setup).
+          NOVA_FORGE_TOKEN: ${{ secrets.NOVA_FORGE_TOKEN }}
+          NOVA_FORGE_BASE_URL: ${{ secrets.NOVA_FORGE_BASE_URL }}
+          NOVA_FORGE_OWNER: ${{ secrets.NOVA_FORGE_OWNER }}
+          NOVA_CONSUMER_REPO: ${{ secrets.NOVA_CONSUMER_REPO }}
+          AWS_DEFAULT_REGION: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+        run: |
+          bash scripts/rotate_spike_key.sh

.gitea/workflows/slides.yml

@@ -1,11 +1,15 @@
 # Nova Slides Render — re-renders presentation deck when source files change.
+# REQ-273: install python-pptx, pin CLI versions, stage HTML + both PPTX +
+# base64-inlined images.
 name: Nova Slides Render
 on:
   push:
     paths:
       - 'docs/presentations/**'
       - 'scripts/render_slides.sh'
-      - 'assets/nova-sp-theme.css'
+      - 'scripts/inline_images.py'
+      - 'scripts/render_pptx.py'
+      - 'pyproject.toml'
   workflow_dispatch:
 
 jobs:
@@ -16,16 +20,24 @@ jobs:
         with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - name: Install Chrome
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - name: Install python-pptx (slides extra)
+        run: pip install -e ".[slides]"
+      - name: Install + pin render CLIs
         run: |
-          npx --yes @marp-team/marp-cli@latest --version
+          npx --yes @marp-team/marp-cli@4.5.0 --version
-          npx --yes @mermaid-js/mermaid-cli --version
+          npx --yes @mermaid-js/mermaid-cli@11.16.0 --version
       - name: Render slides
         run: bash scripts/render_slides.sh
       - name: Commit rendered artifacts
         run: |
           git config user.name "nova-slides-bot"
           git config user.email "bot@nova.local"
-          git add docs/presentations/*.html docs/presentations/*.pptx docs/presentations/assets/png/*.png
+          git add docs/presentations/*.html \
+                  docs/presentations/*.pptx \
+                  docs/presentations/*-python.pptx \
+                  docs/presentations/assets/png/*.png
           git diff --cached --quiet || git commit -m "chore(slides): re-render deck [skip ci]"
-          git push
+          git push

.github/actions/nova-cli/action.yml

@@ -0,0 +1,94 @@
+# Nova CLI Action — composite action (REQ-326, NFR-11)
+#
+# Runs a Nova CLI command (`nova <command>`) in a consumer repository.
+# Python 3.12 is pinned (REQ-326 AC3). The same action.yml is discovered
+# by both the production forge (GitHub Actions) and the dev forge
+# (act_runner) via the shared .github/actions/nova-cli/ path — there is
+# no separate dev-forge action file. Consumers reference it via a
+# versioned tag pin:
+#
+#   uses: <org>/<repo>/.github/actions/nova-cli@v1.28
+#
+# Wheel index selection (CodeArtifact default + fallback):
+#   - CodeArtifact mode: set the NOVA_CODEARTIFACT_DOMAIN repository
+#     secret/env. The action runs
+#     `aws codeartifact login --tool pip --domain $NOVA_CODEARTIFACT_DOMAIN
+#     --repository nova-pypi` before `pip install nova`.
+#   - Fallback mode: leave NOVA_CODEARTIFACT_DOMAIN unset and provide
+#     NOVA_WHEEL_INDEX env pointing at any PEP 503 simple index (a
+#     private package registry). The action runs
+#     `pip install --index-url $NOVA_WHEEL_INDEX nova==<version>`.
+#   See docs/codeartifact-provisioning.md for the index shape.
+#
+# Byte-identical cross-platform verification (NFR-11, REQ-326 AC2):
+#   the full byte-identical test runs as a CI matrix job on the
+#   production forge (ubuntu-latest) + the dev forge (act_runner) with
+#   identical inputs, asserting same stdout + exit code. That matrix is
+#   not reproducible in a unit test; the structural invariants (valid
+#   YAML, python 3.12 pin, install + run steps present) are asserted by
+#   tests/test_forge_action_byte_identical.py.
+name: "Nova CLI Action"
+description: "Run a Nova CLI command (`nova <command>`) with Python 3.12 pinned"
+
+inputs:
+  command:
+    description: "The Nova subcommand + args to run (e.g. `apply --local`, `init`, `idp setup --check-only`). Passed verbatim to `nova`."
+    required: true
+  contract:
+    description: "Path to the consumer contract YAML (default .nova/contract.yml). Forwarded to nova via the NOVA_CONTRACT env var."
+    required: false
+    default: ".nova/contract.yml"
+  mode:
+    description: "Nova client mode override (e.g. agent, interactive, plan-only, check-only). Forwarded to nova via the NOVA_CLIENT_MODE env var. Empty = let nova resolve (TTY + credentials)."
+    required: false
+    default: ""
+  version:
+    description: "nova package version to install (default `latest`). Pin to a released wheel version for reproducible runs."
+    required: false
+    default: "latest"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+
+    - name: Install Nova (CodeArtifact default + fallback index)
+      shell: bash
+      env:
+        NOVA_CODEARTIFACT_DOMAIN: ${{ env.NOVA_CODEARTIFACT_DOMAIN }}
+        NOVA_WHEEL_INDEX: ${{ env.NOVA_WHEEL_INDEX }}
+        NOVA_INSTALL_VERSION: ${{ inputs.version }}
+      run: |
+        set -e
+        if [ "$NOVA_INSTALL_VERSION" = "latest" ]; then
+          PIP_SPEC="nova"
+        else
+          PIP_SPEC="nova==$NOVA_INSTALL_VERSION"
+        fi
+        if [ -n "$NOVA_CODEARTIFACT_DOMAIN" ]; then
+          echo "CodeArtifact mode: domain=$NOVA_CODEARTIFACT_DOMAIN repository=nova-pypi"
+          aws codeartifact login --tool pip \
+            --domain "$NOVA_CODEARTIFACT_DOMAIN" --repository nova-pypi
+          pip install $PIP_SPEC
+        else
+          echo "Fallback-index mode: NOVA_WHEEL_INDEX=$NOVA_WHEEL_INDEX"
+          if [ -z "$NOVA_WHEEL_INDEX" ]; then
+            echo "FAIL: NOVA_CODEARTIFACT_DOMAIN is unset and NOVA_WHEEL_INDEX is empty. Set one of them."
+            exit 1
+          fi
+          pip install --index-url "$NOVA_WHEEL_INDEX" $PIP_SPEC
+        fi
+        nova --version || true
+
+    - name: Run Nova
+      shell: bash
+      env:
+        NOVA_CLIENT_MODE: ${{ inputs.mode }}
+        NOVA_CONTRACT: ${{ inputs.contract }}
+      run: |
+        set -e
+        echo "nova ${{ inputs.command }}"
+        nova ${{ inputs.command }}

.github/workflows/deploy.yml

@@ -82,7 +82,7 @@ jobs:
         with:
           repository: acdl/acdl
           path: platform
-          ref: v1.9
+          ref: v1.25
 
       - uses: actions/setup-python@v5
         with:
@@ -104,12 +104,14 @@ jobs:
         with:
           # P4 (REQ-163): IAM role renamed acdl-deploy- → nova-deploy-.
           role-to-assume: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID == '' && format('arn:aws:iam::{0}:role/nova-deploy-{1}', secrets.NOVA_AWS_ACCOUNT_ID, github.repository_id) || '' }}
-          aws-region: us-east-1
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
           access-key-id: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID }}
           secret-access-key: ${{ secrets.NOVA_AWS_SECRET_ACCESS_KEY }}
 
       - name: Run the platform pipeline
         working-directory: ${{ github.workspace }}
+        env:
+          NOVA_CONSUMER_REPO: ${{ github.repository }}
         run: |
           MODE_FLAG=""
           case "${{ inputs.mode }}" in

.github/workflows/publish.yml

@@ -0,0 +1,165 @@
+# Nova Publish Pipeline — wheel + Lambda layer (REQ-323, CAP-035, NFR-6)
+#
+# This workflow is byte-identical across the production forge (GitHub
+# Actions) and the dev forge (act_runner) — the same file is installed
+# at .github/workflows/publish.yml and the mirror at
+# <dev-forge>/workflows/publish.yml. Both copies must match exactly
+# (asserted by tests/test_forge_action_byte_identical.py for the action
+# and by the repo's byte-identical convention for workflows).
+#
+# NFR-6 (wheel/layer co-versioning): every merge to main affecting
+# core/**, adapters/**, nova/**, or pyproject.toml publishes BOTH a
+# wheel AND a Lambda layer with identical version strings. If either
+# publish fails, the job fails and the merge is blocked.
+#
+# REQ-323: CodeArtifact wheel + Lambda layer pipeline.
+# CAP-035: Lambda layer ARN version matches the nova-cli wheel version;
+#          the mapping is recorded in SSM /nova/layer/nova-cli/version.
+#
+# Triggers:
+#   - push to main when core/**, adapters/**, nova/**, or pyproject.toml
+#     changed (the surfaces that ship in the wheel + layer)
+#   - workflow_dispatch (manual republish, e.g. after a CodeArtifact
+#     provisioning fix)
+#
+# Wheel index selection (CodeArtifact default + fallback):
+#   - CodeArtifact mode: set the NOVA_CODEARTIFACT_DOMAIN repository
+#     secret (e.g. "nova"). The workflow runs
+#     `aws codeartifact login --tool twine --domain $NOVA_CODEARTIFACT_DOMAIN
+#     --repository nova-pypi` and twine uploads to the CodeArtifact pypi
+#     endpoint.
+#   - Fallback mode: leave NOVA_CODEARTIFACT_DOMAIN unset and provide
+#     TWINE_REPOSITORY_URL + TWINE_USERNAME + TWINE_PASSWORD repository
+#     secrets pointing at any PEP 503 simple index (a private package
+#     registry). twine uploads to TWINE_REPOSITORY_URL.
+#   See docs/codeartifact-provisioning.md for the required IAM grants
+#   + the fallback index shape.
+#
+# Secrets / env:
+#   AWS_ROLE_ARN                  — OIDC role to assume (id-token: write)
+#   NOVA_CODEARTIFACT_DOMAIN      — optional; when set, CodeArtifact mode
+#   TWINE_USERNAME                — fallback-index upload user
+#   TWINE_PASSWORD                — fallback-index upload password
+#   TWINE_REPOSITORY_URL          — fallback-index upload URL
+#   AWS_DEFAULT_REGION (optional) — defaults to us-east-1
+name: nova-publish
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "core/**"
+      - "adapters/**"
+      - "nova/**"
+      - "pyproject.toml"
+  workflow_dispatch:
+
+permissions:
+  id-token: write   # OIDC federation to AWS
+  contents: write   # tag the release
+
+jobs:
+  publish:
+    name: Publish wheel + Lambda layer
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Configure AWS credentials (OIDC)
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+
+      - name: Install build + publish tools
+        run: pip install build twine
+
+      - name: Compute version from pyproject.toml
+        id: ver
+        run: |
+          set -e
+          VERSION=$(python -c 'import tomllib;print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Nova version: $VERSION"
+
+      - name: Build wheel
+        run: |
+          set -e
+          python -m build --wheel
+          ls -1 dist/
+
+      - name: Upload wheel to index (CodeArtifact default + fallback)
+        id: wheel
+        env:
+          NOVA_CODEARTIFACT_DOMAIN: ${{ secrets.NOVA_CODEARTIFACT_DOMAIN }}
+          TWINE_USERNAME: ${{ secrets.TWINE_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.TWINE_PASSWORD }}
+          TWINE_REPOSITORY_URL: ${{ secrets.TWINE_REPOSITORY_URL }}
+        run: |
+          set -e
+          # CodeArtifact mode: log in to the domain's pypi repository.
+          if [ -n "$NOVA_CODEARTIFACT_DOMAIN" ]; then
+            echo "CodeArtifact mode: domain=$NOVA_CODEARTIFACT_DOMAIN repository=nova-pypi"
+            aws codeartifact login --tool twine \
+              --domain "$NOVA_CODEARTIFACT_DOMAIN" --repository nova-pypi
+          else
+            echo "Fallback-index mode: uploading to TWINE_REPOSITORY_URL"
+            if [ -z "$TWINE_REPOSITORY_URL" ] || [ -z "$TWINE_USERNAME" ] || [ -z "$TWINE_PASSWORD" ]; then
+              echo "FAIL: NOVA_CODEARTIFACT_DOMAIN is unset and one of TWINE_REPOSITORY_URL/TWINE_USERNAME/TWINE_PASSWORD is missing."
+              exit 1
+            fi
+          fi
+          # Idempotent upload: a re-run for the same version may hit
+          # "file already exists" on the index. Treat that as success.
+          twine upload "dist/nova-${{ steps.ver.outputs.version }}-*.whl" \
+            || twine upload "dist/nova-${{ steps.ver.outputs.version }}-*.whl" 2>&1 | tee /tmp/twine.log
+          if grep -qi "already exist" /tmp/twine.log 2>/dev/null; then
+            echo "Wheel already present on the index — treating as success (idempotent)."
+          fi
+          echo "uploaded=true" >> "$GITHUB_OUTPUT"
+
+      - name: Build Lambda layer
+        run: |
+          set -e
+          rm -rf layer
+          mkdir -p layer/python
+          # Install the wheel we just built + the identity extras' deps
+          # so the layer carries argon2-cffi, cryptography, pyjwt.
+          pip install --target layer/python/ \
+            "dist/nova-${{ steps.ver.outputs.version }}-*.whl" \
+            argon2-cffi cryptography pyjwt
+          ( cd layer && zip -r ../nova-layer.zip python/ )
+          ls -lh nova-layer.zip
+
+      - name: Publish Lambda layer
+        id: layer
+        run: |
+          set -e
+          ARN=$(aws lambda publish-layer-version \
+            --layer-name nova-cli \
+            --zip-file fileb://nova-layer.zip \
+            --compatible-runtimes python3.12 \
+            --compatible-architectures x86_64 \
+            --description "nova-cli v${{ steps.ver.outputs.version }}" \
+            --query LayerVersionArn --output text)
+          echo "arn=$ARN" >> "$GITHUB_OUTPUT"
+          echo "Published Lambda layer: $ARN"
+
+      - name: Record SSM version↔ARN mapping (CAP-035)
+        run: |
+          set -e
+          aws ssm put-parameter \
+            --name /nova/layer/nova-cli/version \
+            --value "${{ steps.ver.outputs.version }}:${{ steps.layer.outputs.arn }}" \
+            --type String --overwrite
+          echo "SSM /nova/layer/nova-cli/version = ${{ steps.ver.outputs.version }}:${{ steps.layer.outputs.arn }}"
+
+      - name: Fail job if either publish failed (REQ-323 AC)
+        if: ${{ steps.wheel.outputs.uploaded != 'true' || steps.layer.outputs.arn == '' }}
+        run: |
+          echo "FAIL: wheel uploaded=${{ steps.wheel.outputs.uploaded }} layer_arn=${{ steps.layer.outputs.arn }}"
+          exit 1

.github/workflows/rotate-aws-key.yml

@@ -0,0 +1,69 @@
+# Nova AWS key rotation — platform-managed scheduled pipeline (SPEC §5.9)
+#
+# Rotates the NOVA_AWS_* static key daily (no long-lived keys in the steady
+# state). v0.2 scope: the mechanism must exist (SPEC §5.9); the v0.2 deploy
+# uses the currently-active key. The rotation is best-effort + idempotent
+# (scripts/rotate_spike_key.sh deactivates the old key only after the new
+# key propagates to the consumer's Actions secret store).
+#
+# Auth: the rotation uses the CURRENT NOVA_AWS_* key to authenticate to IAM
+# (the root account 581513795199 can rotate its own keys — confirmed by the
+# bootstrap). The aws-actions/configure-aws-credentials@v4 step uses the
+# static-key path (no OIDC role-to-assume); the long-lived key rotates
+# itself, which is the bootstrap-exception documented in §5.9.
+#
+# Forge coords (base URL / owner / consumer repo) are sourced from
+# repository secrets — NOVA_FORGE_BASE_URL, NOVA_FORGE_OWNER,
+# NOVA_CONSUMER_REPO — so the synced workflow file stays forge-agnostic
+# (REQ-230). The rotation script uploads the new key to the consumer's
+# Actions secret store (the consumer whose deploy.yml consumes NOVA_AWS_*
+# via secrets: inherit).
+name: nova-rotate-aws-key
+
+on:
+  schedule:
+    - cron: "0 0 * * *"  # daily at 00:00 UTC
+  workflow_dispatch:
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  rotate:
+    name: Rotate NOVA_AWS_* static key
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out Nova platform repo
+        uses: actions/checkout@v4
+
+      - name: Configure AWS credentials (bootstrap root creds for IAM key rotation)
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-region: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+          access-key-id: ${{ secrets.NOVA_AWS_ACCESS_KEY_ID }}
+          secret-access-key: ${{ secrets.NOVA_AWS_SECRET_ACCESS_KEY }}
+
+      - name: Install Python deps (boto3 for the rotation script)
+        run: |
+          python3 -m pip install --break-system-packages --quiet boto3
+
+      - name: Run the key rotation script
+        env:
+          # aws-actions/configure-aws-credentials exports AWS_ACCESS_KEY_ID /
+          # AWS_SECRET_ACCESS_KEY; the rotation script reads the bootstrap
+          # creds via NOVA_BOOTSTRAP_AWS_* (its dual-read contract, D-034).
+          # Map the standard AWS_* exports onto the script's expected vars.
+          NOVA_BOOTSTRAP_AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          NOVA_BOOTSTRAP_AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          # Forge + consumer coords come from repository secrets (REQ-230 —
+          # no forge hostnames/orgs hardcoded in the synced workflow file).
+          # NOVA_FORGE_TOKEN holds the forge API token (set equal to the
+          # existing forge token as a one-time secret setup).
+          NOVA_FORGE_TOKEN: ${{ secrets.NOVA_FORGE_TOKEN }}
+          NOVA_FORGE_BASE_URL: ${{ secrets.NOVA_FORGE_BASE_URL }}
+          NOVA_FORGE_OWNER: ${{ secrets.NOVA_FORGE_OWNER }}
+          NOVA_CONSUMER_REPO: ${{ secrets.NOVA_CONSUMER_REPO }}
+          AWS_DEFAULT_REGION: ${{ secrets.AWS_DEFAULT_REGION || 'us-east-1' }}
+        run: |
+          bash scripts/rotate_spike_key.sh

.github/workflows/slides.yml

@@ -1,11 +1,15 @@
 # Nova Slides Render — re-renders presentation deck when source files change.
+# REQ-273: install python-pptx, pin CLI versions, stage HTML + both PPTX +
+# base64-inlined images.
 name: Nova Slides Render
 on:
   push:
     paths:
       - 'docs/presentations/**'
       - 'scripts/render_slides.sh'
-      - 'assets/nova-sp-theme.css'
+      - 'scripts/inline_images.py'
+      - 'scripts/render_pptx.py'
+      - 'pyproject.toml'
   workflow_dispatch:
 
 jobs:
@@ -16,16 +20,24 @@ jobs:
         with: { fetch-depth: 0 }
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - name: Install Chrome
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - name: Install python-pptx (slides extra)
+        run: pip install -e ".[slides]"
+      - name: Install + pin render CLIs
         run: |
-          npx --yes @marp-team/marp-cli@latest --version
+          npx --yes @marp-team/marp-cli@4.5.0 --version
-          npx --yes @mermaid-js/mermaid-cli --version
+          npx --yes @mermaid-js/mermaid-cli@11.16.0 --version
       - name: Render slides
         run: bash scripts/render_slides.sh
       - name: Commit rendered artifacts
         run: |
           git config user.name "nova-slides-bot"
           git config user.email "bot@nova.local"
-          git add docs/presentations/*.html docs/presentations/*.pptx docs/presentations/assets/png/*.png
+          git add docs/presentations/*.html \
+                  docs/presentations/*.pptx \
+                  docs/presentations/*-python.pptx \
+                  docs/presentations/assets/png/*.png
           git diff --cached --quiet || git commit -m "chore(slides): re-render deck [skip ci]"
-          git push
+          git push

.gitignore

@@ -42,3 +42,6 @@ metrics/lifecycle/
 *.jks
 *.keystore.coverage
 .coverage
+
+.venv/
+nova.egg-info/

adapters/README.md

@@ -12,15 +12,62 @@ Adapters translate the engine-agnostic Target Stack IR to engine-specific format
 | 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 |
+| kyverno-json engine | `adapters/kyverno-json/kyverno_json_engine.py` | Any JSON/YAML payload | `PolicyCheckResult` records | **v1.25 primary policy engine** (swappable via `PolicyEngine` protocol) |
+
+## Policy Engine Protocol (v1.25)
+
+The `core/policy_engine.py` module defines the **swap boundary** between
+Nova and its policy engines. A `PolicyEngine` Python Protocol (PEP 544)
+with three members (`name`, `is_configured()`, `evaluate()`) is the
+contract; a `PolicyEngineRegistry` selects the active engine from
+`config.json`'s `policy.engine` key. The confidence signal and pipeline
+never import an engine directly — they go through the registry.
+
+**Implementations:**
+- `KyvernoJsonEngine` (`adapters/kyverno-json/`) — shells to the `kj`
+  CLI; the v1.25 default.
+- `NullEngine` (`core/policy_engine.py`) — fallback when the `policy`
+  key is absent (emits `SKIPPED`).
+- Future: `OpaEngine` — implements the same protocol, shells to
+  `opa eval`. The OPA-equivalent surface is documented in
+  `.ciagent/RESEARCH.md` §4.2.
+
+**How to add a new engine:**
+1. Create `adapters/<name>/<name>_engine.py` implementing the
+   `PolicyEngine` protocol (`name`, `is_configured()`, `evaluate()`).
+2. `evaluate()` returns `list[dict]` where each dict conforms to
+   `schemas/policy_check_result.schema.json`.
+3. Register the engine in `core/policy_engine.py`'s `_autoload_*`
+   function (or call `register(name, factory)` at startup).
+4. Set `config.json.policy.engine` to the engine's `name`.
+5. Add the engine to the `engine` enum in
+   `schemas/policy_check_result.schema.json` if it needs a distinct
+   enum value (v1.25 reuses `"kyverno"` — see D-116).
 
 ## How to Write an Adapter
 
-### Terraform Adapter Extension
+### Terraform Adapter Extension (stateless assembler — v1.11 rewrite)
 
-1. Add a stack type → Terraform type mapping to `TYPE_MAP`.
+> The adapter owns **no module content**. There is no `TYPE_MAP`, no
-2. Add non-identity input mappings to `INPUT_MAP`.
+> `INPUT_MAP`, no `OUTPUT_MAP`, and no per-type branch logic (all deleted
-3. Add non-identity output mappings to `OUTPUT_MAP`.
+> in the v1.11 rewrite — the 918-line monolith collapsed to a ~80-line
-4. Add a specialized `_emit_resource` branch if the resource needs nested blocks (e.g. inline policies, rule sets).
+> assembler). Engine-specific shape lives in each L1 module's own
+> `terraform/` dir (`versions.tf`/`variables.tf`/`locals.tf`/`main.tf`/
+> `outputs.tf`); the adapter only assembles them.
+
+To extend the Terraform adapter, **do not edit the adapter** — instead:
+
+1. Add an L1 module with a real `terraform/` dir (owning its resource
+   shape, nested HCL blocks, and defaults).
+2. Register it in `modules/registry.json` under the module name with its
+   `terraform_dir` path. The adapter reads `registry.json` to find each
+   module's directory.
+3. The adapter emits `module "<rid>" { source = "<path>" }` blocks at
+   the root, with resolved inputs + wired `ref:` refs between modules.
+   No type-specific translation lives in the adapter.
+
+> If you find yourself reaching for a "TYPE_MAP"-style constant, the L1
+> module is missing a piece — fix the module, not the adapter.
 
 ### Policy Adapter Pattern
 
@@ -45,7 +92,7 @@ Adapters translate the engine-agnostic Target Stack IR to engine-specific format
 
 ## How to Test Adapters
 
-- `tests/test_adapter.py` — Terraform adapter (`TYPE_MAP`, resource emission, refs, outputs).
+- `tests/test_adapter.py` — Terraform adapter (stateless assembly: registry read, `module "<rid>" { source }` emission, `ref:` wiring, outputs). No `TYPE_MAP`/`INPUT_MAP` tests — the adapter owns no type mappings.
 - `tests/test_checkov_adapter.py` — Checkov adapter.
 - `tests/test_wiz_adapter.py` — Wiz adapter.
 - `tests/test_kyverno_adapter.py` — Kyverno adapter.
@@ -62,4 +109,32 @@ Adapters translate the engine-agnostic Target Stack IR to engine-specific format
 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.
+6. Update this README.
+
+## Consumers
+
+The Terraform adapter compiles contract IR for consumer estates. The
+first real consumer estate is now live:
+
+| Consumer | Version | Environment | Account | Forge / Adapter | Status |
+| --- | --- | --- | --- | --- | --- |
+| `nova-blockchain-exchange` | v0.2 | dev | `581513795199` | inline adapter (see note below) | **live** (pilot apply `blkex-pilot-apply-v0.2`, 2026-08-19) |
+
+### Forge adapter note (SPEC §10 Q1)
+
+Forge Actions (the consumer's forge runtime) does **not** support
+cross-repo `uses:` references — the forge rejects
+`uses: <owner>/<repo>/.github/workflows/<file>@<ref>` with
+`expected format {owner}/{repo}/.{git_platform}/workflows/{filename}@{ref}`.
+The consumer (`nova-blockchain-exchange`) therefore uses an **inline
+adapter** in its `deploy.yml`: the workflow does `actions/checkout@v4`
+on the consumer, then `actions/checkout@v4` `acdl/acdl` @ `ref: v1.25`
+into `platform/`, and runs `bash platform/scripts/run_platform.sh ...`
+directly — no `uses:` indirection.
+
+The platform's own `.github/workflows/deploy.yml` (this repo) stays as
+the **GitHub Actions reference implementation** — the reusable
+`workflow_call` workflow used by GitHub-hosted consumers. The two
+files share the same contract shape; the only declared difference is
+the forge/runtime, not the stages or commands. See
+`.ciagent/ARCHITECTURE.md` §12.8 for the live pilot-estate wiring.

adapters/kyverno-json/README.md

@@ -0,0 +1,103 @@
+# kyverno-json Engine Adapter (v1.25)
+
+The `kyverno-json` engine is Nova's **primary compliance/policy tool**
+(v1.25), implemented behind the swappable `PolicyEngine` protocol so
+OPA (or any other engine) can replace it one day.
+
+## What kyverno-json is
+
+[kyverno-json](https://github.com/kyverno/kyverno-json) is a standalone
+Go binary from the Kyverno project — a **separate runtime** from the
+K8s Kyverno admission controller. It applies Kyverno `ValidatingPolicy`
+resources to **any** JSON or YAML payload file via the `kj scan` CLI.
+Unlike the K8s Kyverno adapter (`adapters/kyverno/`), which only
+speaks to K8s manifests, kyverno-json evaluates consumer contracts,
+resolved Stack IR, terraform plan JSON, and even the merged PCR list
+itself (meta-policies).
+
+## Install
+
+```bash
+bash scripts/install-kyverno-json.sh
+# or directly:
+go install github.com/kyverno/kyverno-json/cmd/kj@latest
+kj version
+```
+
+The platform functions without the binary — `is_configured()` returns
+`False` when `which kj` is absent → `evaluate()` returns a single
+`SKIPPED` PCR (`KJ_ENGINE_NOT_CONFIGURED`). The confidence signal
+proceeds with a neutral `policy` input (D-120 graceful degradation).
+
+## Policy directory layout
+
+```
+adapters/kyverno-json/policies/
+├── _smoke.json                  # round-trip smoke test
+├── contract/                    # consumer contract JSON policies
+│   ├── require-id-pattern.json
+│   ├── require-env-in-enum.json
+│   ├── require-infrastructure-min-1.json
+│   └── forbid-unknown-fields.json
+├── stack-ir/                    # resolved Stack IR policies
+│   ├── require-tagging-standard.json
+│   ├── forbid-public-ingress.json
+│   └── require-encryption-by-default.json
+├── plan-json/                   # terraform show -json policies
+│   ├── forbid-plaintext-secrets.json
+│   ├── forbid-iam-wildcard.json
+│   └── require-kms-reference.json
+├── meta/                        # policies over the merged PCR list
+│   ├── block-on-any-critical.json
+│   └── tagging-rules-agree.json
+└── regression/                   # capability-inventory policies
+    ├── cap-013-adapter-dedup.json
+    ├── cap-023-metrics-collector.json
+    └── cap-024-deck-structure.json
+```
+
+## The four policy categories
+
+1. **contract/** — over the consumer contract JSON (pre-resolve).
+2. **stack-ir/** — over the resolved Target Stack IR (post-resolve).
+3. **plan-json/** — over `terraform show -json` output (pipeline Step 5b).
+4. **meta/** — over the merged `list[PolicyCheckResult]` (meta-policies).
+5. **regression/** — over the capability-inventory JSON (declarative
+   mirrors of `core/regression_verify.py`).
+
+## Severity convention
+
+kyverno-json does not natively assign severities. Each Nova policy
+declares its severity via a `metadata.annotations` field:
+
+```yaml
+metadata:
+  annotations:
+    nova.cloudinit.dev/severity: high
+```
+
+Valid values: `critical`, `high`, `medium`, `low`, `info` (default
+when absent).
+
+## Engine enum reuse (D-116)
+
+kyverno-json PCR records carry `engine: "kyverno"` (no new enum value).
+The `engine` field records the policy-engine *family*, not the specific
+binary. The K8s Kyverno adapter and the kyverno-json engine are
+distinguished by `ruleId` prefix (`KYVERNO_` vs `KJ_`) and `evidence`
+payload shape (`namespace`/`kind` vs `assertion`/`jmespath`).
+
+## Schema path
+
+The output records validate against
+[`schemas/policy_check_result.schema.json`](../../schemas/policy_check_result.schema.json)
+(`engine: "kyverno"` is in the enum). The confidence signal consumes
+the merged PCR list engine-agnostically.
+
+## Swap boundary
+
+The `PolicyEngine` protocol (`core/policy_engine.py`) is the swap
+boundary. The OPA-equivalent surface is documented in
+`.ciagent/RESEARCH.md` §4.2 — a future `OpaEngine` implements the same
+protocol without touching the confidence signal, the PCR schema, or
+the pipeline.

adapters/kyverno-json/__init__.py

@@ -0,0 +1,27 @@
+"""Nova kyverno-json adapter package (v1.25, REQ-294).
+
+The directory name ``kyverno-json`` has a hyphen, so it is not a valid
+Python package name and cannot be imported via ``import
+adapters.kyverno-json``. The ``PolicyEngineRegistry`` loads the engine
+by file path (``importlib.util.spec_from_file_location``). This
+``__init__`` is a convenience for direct-script use and for ``pip
+install -e .`` style discovery if the package is ever renamed.
+"""
+
+
+def _load_engine():
+    import importlib.util
+    import os
+    engine_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                               "kyverno_json_engine.py")
+    spec = importlib.util.spec_from_file_location("kyverno_json_engine", engine_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"could not load {engine_path}")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod.KyvernoJsonEngine
+
+
+KyvernoJsonEngine = _load_engine()
+
+__all__ = ["KyvernoJsonEngine"]

adapters/kyverno-json/kyverno_json_engine.py

@@ -0,0 +1,470 @@
+"""Nova KyvernoJsonEngine (REQ-293, v1.25; fixed v1.26 P3 W0.5).
+
+Implements the ``PolicyEngine`` protocol (``core/policy_engine.py``)
+by shelling to the ``kj`` CLI (``kyverno-json``). Translates native
+kyverno-json scan output to Nova ``PolicyCheckResult`` dicts
+(``schemas/policy_check_result.schema.json``).
+
+Engine enum reuse (D-116): records carry ``engine: "kyverno"`` (no new
+enum value). The ``ruleId`` is prefixed ``KJ_<policy_name>`` to
+distinguish from the K8s Kyverno adapter's ``KYVERNO_`` prefix.
+
+Severity (RESEARCH §2.6, G-Q10a): kyverno-json does not natively assign
+severities. Each Nova policy declares its severity via a
+``metadata.annotations["nova.cloudinit.dev/severity"]`` field. The
+engine reads this annotation from the loaded policy file (not from the
+scan result — the result carries the policy spec but the annotation is
+read here from disk) and applies it to every result that policy
+produces. Default when absent: ``"info"``.
+
+Graceful degradation (D-120): ``is_configured()`` returns ``False`` when
+``which kj`` is absent → ``evaluate()`` returns a single SKIPPED PCR
+(``ruleId: KJ_ENGINE_NOT_CONFIGURED``). The platform functions without
+the binary.
+
+Defensive parsing: any kyverno-json output that doesn't match the
+expected shape produces an ``error`` PCR, never an exception. The
+engine is read-only against a local policy dir + a temp payload file.
+
+v1.26 P3 W0.5 fix — three substrate bugs uncovered once ``kj`` was
+actually installed (the v1.25 test suite ``pytest.skip``-masked them):
+
+1. **``.json`` policy files are not loaded by ``kj`` v0.0.3.** The
+   upstream policy loader (``pkg/policy/load.go``) uses
+   ``fileinfo.IsYaml()`` which only matches ``.yaml``/``.yml``
+   extensions — ``.json`` files are silently skipped, yielding
+   ``evaluating N resources against 0 policies``. Nova policies are
+   authored as ``.json`` (the ``TestPolicyFilesExist`` tests assert the
+   ``.json`` filenames). Fix: ``evaluate()`` materializes a temp policy
+   dir that mirrors the source tree with every ``.json`` policy copied
+   to a ``.yaml`` twin (JSON is a valid YAML subset — verified against
+   ``kj`` v0.0.3). The source ``.json`` files remain untouched.
+
+2. **Bare-list output format.** ``kj scan --output json`` emits a bare
+   JSON list at the top level (NOT ``{"results": [...]}``). Each entry
+   has ``resource`` (the evaluated payload) + ``results`` (list of
+   per-policy result objects, each carrying ``policy.metadata.name``,
+   ``rules[]`` with ``rule.name``, ``violations[]`` (present on fail),
+   ``error`` (string, present on policy-evaluation error)). The v1.25
+   ``_translate`` did ``out.get("results", [])`` on a dict — but
+   ``out`` is a list → returned ``[]`` → emitted a single
+   ``KJ_NO_RESULTS`` pass PCR. **This is why all failing fixtures showed
+   0 fails.** Fix: ``_translate`` handles list (v0.0.3) and dict
+   (future-proof) shapes.
+
+3. **``validate`` wrapper + check syntax.** Documented in the policy
+   files themselves (see the W0.5 policy edits). The engine itself does
+   not enforce policy shape — it only translates ``kj`` output — so
+   this fix lives in the policy ``.json`` files.
+"""
+
+import datetime
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Union
+
+import yaml
+
+
+Payload = Union[dict, list, str]
+
+SEVERITY_DEFAULT = "info"
+SEVERITY_ANNOTATION = "nova.cloudinit.dev/severity"
+
+RESULT_MAP = {
+    "pass": "pass",
+    "fail": "fail",
+    "error": "error",
+    "skip": "skipped",
+    "skipped": "skipped",
+    "warn": "skipped",
+    "warning": "skipped",
+}
+
+
+def _iso8601_now() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _which_kj() -> str | None:
+    """Return the path to ``kj`` if on PATH, else ``None``."""
+    return shutil.which("kj")
+
+
+def _load_policy_severities(policy_dir: Path) -> dict[str, str]:
+    """Load each ``.json``/``.yaml``/``.yml`` policy in ``policy_dir``
+    (non-recursive) and return ``{policy_name: severity}``.
+
+    kyverno-json policies are Kubernetes-style ``ValidatingPolicy``
+    resources. The severity is read from
+    ``metadata.annotations["nova.cloudinit.dev/severity"]``. Policies
+    in subdirectories (e.g. ``contract/``, ``stack-ir/``) are loaded
+    when the caller passes that subdirectory as ``policy_dir``.
+    """
+    severities: dict[str, str] = {}
+    if not policy_dir.is_dir():
+        return severities
+    for entry in sorted(os.listdir(policy_dir)):
+        if entry.startswith("_") or entry.startswith("."):
+            continue
+        full = policy_dir / entry
+        if not full.is_file():
+            continue
+        if entry.endswith((".json", ".yaml", ".yml")):
+            try:
+                with open(full, "r", encoding="utf-8") as fh:
+                    doc = yaml.safe_load(fh)
+                if not isinstance(doc, dict):
+                    continue
+                name = doc.get("metadata", {}).get("name") or entry.rsplit(".", 1)[0]
+                ann = doc.get("metadata", {}).get("annotations", {}) or {}
+                sev = ann.get(SEVERITY_ANNOTATION, SEVERITY_DEFAULT)
+                severities[name] = str(sev).lower()
+            except Exception:
+                continue
+    return severities
+
+
+def _materialize_yaml_policy_dir(src: Path) -> tuple[Path, bool]:
+    """Mirror ``src`` (recursively) into a temp dir, copying every
+    ``.json`` policy to a ``.yaml`` twin and copying ``.yaml``/``.yml``
+    files verbatim. Returns ``(temp_dir, created)``.
+
+    ``kj`` v0.0.3's policy loader (``pkg/policy/load.go``) only matches
+    ``.yaml``/``.yml`` extensions — ``.json`` files are silently
+    skipped. Nova policies are authored as ``.json`` (the
+    ``TestPolicyFilesExist`` tests assert the ``.json`` filenames, so
+    they cannot be renamed in-place). JSON is a valid YAML subset, so
+    a byte-for-byte copy with a ``.yaml`` extension loads cleanly.
+
+    ``created`` is ``False`` when ``src`` contains no policy files at
+    all (empty dir) — in that case the temp dir is still returned (the
+    caller invokes ``kj`` against it and gets the no-results path).
+    """
+    tmp = Path(tempfile.mkdtemp(prefix="nova-kj-pol-"))
+    any_policy = False
+    if src.is_dir():
+        for root, _dirs, files in os.walk(src):
+            rel = Path(root).relative_to(src)
+            dest_root = tmp / rel
+            dest_root.mkdir(parents=True, exist_ok=True)
+            for fn in files:
+                if fn.startswith(".") or fn.startswith("_"):
+                    continue
+                src_file = Path(root) / fn
+                if fn.endswith(".json"):
+                    dest_file = dest_root / (fn.rsplit(".", 1)[0] + ".yaml")
+                    shutil.copy2(src_file, dest_file)
+                    any_policy = True
+                elif fn.endswith((".yaml", ".yml")):
+                    shutil.copy2(src_file, dest_root / fn)
+                    any_policy = True
+    return tmp, any_policy
+
+
+def _skipped_not_configured(contract_id: str) -> dict:
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": "KJ_ENGINE_NOT_CONFIGURED",
+        "severity": "info",
+        "result": "skipped",
+        "message": (
+            "kyverno-json engine not configured — `which kj` returned no path. "
+            "Install via scripts/install-kyverno-json.sh. The platform proceeds "
+            "with a neutral SKIPPED policy input (is_configured() guard, D-120)."
+        ),
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+def _error_pcr(contract_id: str, message: str) -> dict:
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": "KJ_ENGINE_ERROR",
+        "severity": "info",
+        "result": "error",
+        "message": message,
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+def _no_results_pass(contract_id: str) -> dict:
+    """No result entries — emit a single pass PCR so the confidence
+    signal's policy input is non-empty (a non-empty list of passes →
+    score 1.0)."""
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": "KJ_NO_RESULTS",
+        "severity": "info",
+        "result": "pass",
+        "message": "kyverno-json scan produced no result entries (all policies passed or no match).",
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+class KyvernoJsonEngine:
+    """``PolicyEngine`` impl that shells to the ``kj`` CLI."""
+
+    name = "kyverno-json"
+
+    def is_configured(self) -> bool:
+        return _which_kj() is not None
+
+    def evaluate(self, payload: Payload, policy_dir: Path,
+                 contract_id: str) -> list[dict]:
+        if not self.is_configured():
+            return [_skipped_not_configured(contract_id)]
+        kj = _which_kj()
+        policy_dir = Path(policy_dir)
+        if not policy_dir.is_dir():
+            return [_error_pcr(
+                contract_id,
+                f"kyverno-json policy dir not found: {policy_dir}",
+            )]
+        severities = _load_policy_severities(policy_dir)
+        # kj v0.0.3 only loads .yaml/.yml policy files. Mirror the tree
+        # to a temp dir with .json policies copied to .yaml twins.
+        yaml_dir, _any_policy = _materialize_yaml_policy_dir(policy_dir)
+        # Write payload to temp file (kj scan --payload expects a file path).
+        payload_tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".json", delete=False, encoding="utf-8"
+        )
+        try:
+            json.dump(payload, payload_tmp)
+            payload_tmp.flush()
+            payload_tmp.close()
+            cmd = [
+                kj, "scan",
+                "--policy", str(yaml_dir),
+                "--payload", payload_tmp.name,
+                "--output", "json",
+            ]
+            try:
+                proc = subprocess.run(
+                    cmd, capture_output=True, text=True, timeout=60,
+                )
+            except subprocess.TimeoutExpired:
+                return [_error_pcr(contract_id, "kyverno-json scan timed out (60s)")]
+            if proc.returncode not in (0, 1):
+                return [_error_pcr(
+                    contract_id,
+                    f"kyverno-json scan exited {proc.returncode}: {proc.stderr[:200]}",
+                )]
+            try:
+                out = json.loads(proc.stdout) if proc.stdout.strip() else []
+            except json.JSONDecodeError as e:
+                return [_error_pcr(
+                    contract_id,
+                    f"kyverno-json output not JSON: {e}",
+                )]
+            return self._translate(out, contract_id, severities)
+        finally:
+            try:
+                os.unlink(payload_tmp.name)
+            except OSError:
+                pass
+            shutil.rmtree(yaml_dir, ignore_errors=True)
+
+    def _translate(self, out: Any, contract_id: str,
+                   severities: dict[str, str]) -> list[dict]:
+        # kj v0.0.3 emits a BARE JSON LIST at the top level: each entry
+        # has `resource` (the evaluated payload) + `results` (list of
+        # per-policy result objects). Future-proof: also accept the
+        # legacy {"results": [...]} dict shape.
+        if isinstance(out, list):
+            entries = out
+        elif isinstance(out, dict):
+            entries = out.get("results", [])
+            if not isinstance(entries, list):
+                entries = []
+        else:
+            entries = []
+        pcrs: list[dict] = []
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            resource = entry.get("resource", {})
+            results = entry.get("results", [])
+            if not isinstance(results, list):
+                results = []
+            for pol_result in results:
+                if not isinstance(pol_result, dict):
+                    continue
+                policy_obj = pol_result.get("policy", {}) or {}
+                policy_name = (
+                    policy_obj.get("metadata", {}).get("name") if isinstance(policy_obj, dict)
+                    else None
+                ) or "UNKNOWN"
+                severity = severities.get(policy_name, SEVERITY_DEFAULT)
+                rules = pol_result.get("rules", [])
+                if not isinstance(rules, list):
+                    rules = []
+                for rule_entry in rules:
+                    if not isinstance(rule_entry, dict):
+                        continue
+                    rule_obj = rule_entry.get("rule", {}) or {}
+                    rule_name = rule_obj.get("name", "") if isinstance(rule_obj, dict) else ""
+                    rule_id = f"KJ_{policy_name}"
+                    if rule_name:
+                        rule_id = f"{rule_id}/{rule_name}"
+                    violations = rule_entry.get("violations")
+                    error_str = rule_entry.get("error")
+                    if isinstance(violations, list) and violations:
+                        # Fail: build a message from the violations' errors.
+                        msg_parts: list[str] = []
+                        for v in violations:
+                            if not isinstance(v, dict):
+                                continue
+                            for err in v.get("errors", []) or []:
+                                if not isinstance(err, dict):
+                                    continue
+                                field = err.get("field", "")
+                                detail = err.get("detail", "")
+                                value = err.get("value", "")
+                                msg_parts.append(
+                                    f"{field}: value={value!r} detail={detail}"
+                                )
+                        message = "; ".join(msg_parts) if msg_parts else "policy rule failed"
+                        pcrs.append({
+                            "contractId": contract_id,
+                            "evaluatedAt": _iso8601_now(),
+                            "engine": "kyverno",
+                            "ruleId": rule_id,
+                            "severity": severity,
+                            "result": "fail",
+                            "message": message,
+                            "evidence": {
+                                "resource": resource,
+                                "policy": policy_name,
+                                "rule": rule_name,
+                                "violations": violations,
+                            },
+                            "resourceRef": _resource_ref(resource),
+                        })
+                    elif isinstance(error_str, str) and error_str:
+                        # Policy-evaluation error (e.g. bad JMESPath).
+                        pcrs.append({
+                            "contractId": contract_id,
+                            "evaluatedAt": _iso8601_now(),
+                            "engine": "kyverno",
+                            "ruleId": rule_id,
+                            "severity": severity,
+                            "result": "error",
+                            "message": error_str,
+                            "evidence": {
+                                "resource": resource,
+                                "policy": policy_name,
+                                "rule": rule_name,
+                            },
+                            "resourceRef": _resource_ref(resource),
+                        })
+                    else:
+                        # Pass: no violations, no error.
+                        pcrs.append({
+                            "contractId": contract_id,
+                            "evaluatedAt": _iso8601_now(),
+                            "engine": "kyverno",
+                            "ruleId": rule_id,
+                            "severity": severity,
+                            "result": "pass",
+                            "message": "",
+                            "evidence": {
+                                "resource": resource,
+                                "policy": policy_name,
+                                "rule": rule_name,
+                            },
+                            "resourceRef": _resource_ref(resource),
+                        })
+        if not pcrs:
+            pcrs.append(_no_results_pass(contract_id))
+        return pcrs
+
+
+def _resource_ref(resource: Any) -> str:
+    """Best-effort resource ref from the evaluated payload."""
+    if isinstance(resource, dict):
+        for key in ("id", "name", "address"):
+            v = resource.get(key)
+            if isinstance(v, str) and v:
+                return v
+    return ""
+
+
+# --- Legacy _to_pcr kept for the existing TestToPcr unit tests ---
+# (test_kyverno_json_engine.py::TestToPcr constructs flat `entry`
+# dicts with `policy`/`rule`/`result`/`message`/`resource` keys and
+# asserts the translated PCR shape. The production _translate path no
+# longer calls this helper — it inlines the translation against the
+# real kj v0.0.3 nested output — but the unit tests pin the helper's
+# contract, so it stays.)
+
+
+def _to_pcr(entry: dict, contract_id: str, severity: str) -> dict:
+    """Translate a flat kyverno-json scan result entry to a PCR dict.
+
+    Legacy shape (kept for unit-test backwards compatibility): the
+    entry is a flat dict with ``policy``/``rule``/``result``/``message``/
+    ``resource`` string keys. The production ``_translate`` path no
+    longer calls this — it inlines translation against the real kj
+    v0.0.3 nested ``resource``+``results``+``rules`` shape — but the
+    ``TestToPcr`` unit tests pin this contract.
+    """
+    policy_name = entry.get("policy", "") or "UNKNOWN"
+    rule_name = entry.get("rule", "") or ""
+    rule_id = f"KJ_{policy_name}"
+    if rule_name:
+        rule_id = f"{rule_id}/{rule_name}"
+    result_raw = entry.get("result", "skip")
+    result = RESULT_MAP.get(str(result_raw).lower(), "error")
+    message = entry.get("message", "") or ""
+    resource = entry.get("resource", "")
+    if not resource and entry.get("name"):
+        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,
+            "policy": policy_name,
+            "rule": rule_name,
+            "namespace": entry.get("namespace", ""),
+            "kind": entry.get("kind", ""),
+            "name": entry.get("name", ""),
+        },
+        "resourceRef": resource,
+    }
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 4:
+        print(
+            "usage: kyverno_json_engine.py <payload.json> <policy_dir> <contract-id>",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+        pl = json.load(fh)
+    engine = KyvernoJsonEngine()
+    out = engine.evaluate(pl, Path(sys.argv[2]), sys.argv[3])
+    print(json.dumps(out, indent=2))

adapters/kyverno-json/policies/_smoke.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-contract-id",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "Require contract id"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "require-id",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "id": {
+                  "(regex_match('^[a-z][a-z0-9-]{2,5}$', @))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/contract/forbid-unknown-fields.json

@@ -0,0 +1,30 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "forbid-unknown-fields",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "low",
+      "title.policy.kyverno.io": "Contract has only schema-allowed fields"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-unknown-fields",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(length(keys(@)) == `4`)": true,
+                "keys(@)": {
+                  "(contains(['id','name','environment','infrastructure'], @))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/contract/require-env-in-enum.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-env-in-enum",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "Contract environment is one of dev/qa/prod/dr"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "env-enum",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "environment": {
+                  "(contains(['dev','qa','prod','dr'], @))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/contract/require-id-pattern.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-id-pattern",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "Contract id matches operational acronym pattern"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "id-pattern",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "id": {
+                  "(regex_match('^[a-z][a-z0-9-]{2,5}$', @))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/contract/require-infrastructure-min-1.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-infrastructure-min-1",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "Contract declares at least one infrastructure entry"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "infra-min-1",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "infrastructure": {
+                  "(length(keys(@)) > `0`)": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/meta/block-on-any-critical.json

@@ -0,0 +1,27 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "block-on-any-critical",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "critical",
+      "title.policy.kyverno.io": "Block on any critical-fail policy result (declarative source of truth)"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-critical-fail",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(severity == 'critical' && result == 'fail')": false
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/meta/tagging-rules-agree.json

@@ -0,0 +1,32 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "tagging-rules-agree",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "Checkov NOVA_TAG_NAMING and kj KJ_REQUIRE_TAGGING_STANDARD agree per resource"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-tagging-divergence",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(ruleId == 'NOVA_TAG_NAMING' && result == 'fail')": false
+              }
+            },
+            {
+              "check": {
+                "(ruleId == 'KJ_REQUIRE_TAGGING_STANDARD' && result == 'fail')": false
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/pilot-readiness/no-placeholder-account.json

@@ -0,0 +1,27 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "no-placeholder-account",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "critical",
+      "title.policy.kyverno.io": "Env does not use a placeholder AWS account id"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-placeholder-account",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(account_id == '000000000000')": false
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/plan-json/forbid-iam-wildcard.json

@@ -0,0 +1,51 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "forbid-iam-wildcard",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "No IAM wildcard Actions or Resources"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-wildcard-action",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "planned_values": {
+                  "root_module": {
+                    "~.resources": {
+                      "(type == 'aws_iam_policy' && contains(values.policy_document.Statement[].Action, '*'))": false
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": "no-wildcard-resource",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "planned_values": {
+                  "root_module": {
+                    "~.resources": {
+                      "(type == 'aws_iam_policy' && contains(values.policy_document.Statement[].Resource, '*'))": false
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/plan-json/forbid-plaintext-secrets.json

@@ -0,0 +1,33 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "forbid-plaintext-secrets",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "No plaintext secrets in the terraform plan"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-plaintext-db-password",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "planned_values": {
+                  "root_module": {
+                    "~.resources": {
+                      "(type == 'aws_db_instance' && contains(keys(values), 'password') && !contains(['${...}', ''], values.password))": false
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/plan-json/require-kms-reference.json

@@ -0,0 +1,33 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-kms-reference",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "KMS keys referenced by alias, not inline key material"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "kms-by-alias",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "planned_values": {
+                  "root_module": {
+                    "~.resources": {
+                      "(type == 'aws_kms_key' && !contains(keys(values), 'key_id') && !contains(keys(values), 'kms_key_id'))": false
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/regression/cap-013-adapter-dedup.json

@@ -0,0 +1,27 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "cap-013-adapter-dedup",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "No duplicate adapter registrations (CAP-013 declarative mirror)"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-duplicate-adapters",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(max(map(&length(@), values(group_by(adapters, &@)))) == `1`)": true
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/regression/cap-023-metrics-collector.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "cap-023-metrics-collector",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "Every metric has a grounded/derived/deferred status (CAP-023 declarative mirror)"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "every-metric-has-status",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "~.metrics": {
+                  "(contains(['grounded','derived','deferred'], status))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/regression/cap-024-deck-structure.json

@@ -0,0 +1,32 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "cap-024-deck-structure",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "low",
+      "title.policy.kyverno.io": "Deck structure matches the documented 4-beat arc (CAP-024 declarative mirror)"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "deck-has-4-beats",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "deck": {
+                  "beats": {
+                    "(length(@) >= `4`)": true,
+                    "(contains(@, 'Problem') && contains(@, 'Solution') && contains(@, 'Proof') && contains(@, 'Roadmap+Ask'))": true
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/settlement-finality/all-matches-committed.json

@@ -0,0 +1,27 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "all-matches-committed",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "critical",
+      "title.policy.kyverno.io": "All settlement matches are committed (finalized)"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "all-matches-committed",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "(all_committed)": true
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/stack-ir/forbid-public-ingress.json

@@ -0,0 +1,30 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "forbid-public-ingress",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "No resource has public ingress enabled"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "no-public-ingress",
+        "identifier": "id",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "~.resources": {
+                  "(inputs.public_ingress || `false`)": false
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/stack-ir/require-encryption-by-default.json

@@ -0,0 +1,45 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-encryption-by-default",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "high",
+      "title.policy.kyverno.io": "S3 buckets and EBS volumes carry encryption config"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "s3-encryption",
+        "identifier": "id",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "~.resources": {
+                  "(type == 'aws:s3:bucket' && !(contains(keys(inputs), 'bucket_encryption') || contains(keys(inputs), 'kms_key_id')))": false
+                }
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": "ebs-encryption",
+        "identifier": "id",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "~.resources": {
+                  "(type == 'aws:ebs:volume' && !(contains(keys(inputs), 'encrypted') || contains(keys(inputs), 'kms_key_id')))": false
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/kyverno-json/policies/stack-ir/require-tagging-standard.json

@@ -0,0 +1,33 @@
+{
+  "apiVersion": "json.kyverno.io/v1alpha1",
+  "kind": "ValidatingPolicy",
+  "metadata": {
+    "name": "require-tagging-standard",
+    "annotations": {
+      "nova.cloudinit.dev/severity": "medium",
+      "title.policy.kyverno.io": "All resources carry required Nova tags"
+    }
+  },
+  "spec": {
+    "rules": [
+      {
+        "name": "require-nova-tags",
+        "identifier": "id",
+        "assert": {
+          "all": [
+            {
+              "check": {
+                "~.resources": {
+                  "(contains(keys(inputs.tags || `{}`), 'nova:owner'))": true,
+                  "(contains(keys(inputs.tags || `{}`), 'nova:contract'))": true,
+                  "(contains(keys(inputs.tags || `{}`), 'nova:environment'))": true,
+                  "(contains(keys(inputs.tags || `{}`), 'nova:cost-center'))": true
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

adapters/terraform/adapter.py

@@ -30,6 +30,37 @@ def _module_name(resource):
     return resource.get("module", "").split("@")[0]
 
 
+def _load_env_json(env_name, repo_root):
+    """Load core/environments/<env_name>.json → dict (P03 W3, REQ-319).
+
+    Returns {} if the file is absent (the adapter falls back to the
+    computed state-bucket name). Sources env.state_backend.bucket +
+    env.account_id + env.region for the S3 backend block.
+    """
+    env_path = os.path.join(repo_root, "core", "environments", f"{env_name}.json")
+    if not os.path.isfile(env_path):
+        return {}
+    with open(env_path, "r") as fh:
+        return json.load(fh)
+
+
+def _resolve_state_bucket(env_json, region):
+    """Resolve the S3 state-backend bucket name (P03 W3, REQ-319).
+
+    Precedence: (1) env.state_backend.bucket when present + non-empty;
+    (2) nova-tfstate-{account_id}-{region} from env.account_id + region
+    (backwards-compat); (3) nova-tfstate-581513795199-{region} when
+    account_id is absent (the only real account — bootstrap bucket).
+    The env JSON is authoritative; NOVA_AWS_ACCOUNT_ID is no longer
+    consulted for the bucket name.
+    """
+    bucket = (env_json.get("state_backend") or {}).get("bucket")
+    if bucket:
+        return bucket
+    account_id = env_json.get("account_id") or "581513795199"
+    return f"nova-tfstate-{account_id}-{region}"
+
+
 def _ref_expr(value, data_source_names=None, id_remap=None):
     """Translate `ref:<rid>.<output>` → `module.<rid>.<output>` (or
     `data.terraform_remote_state.platform.outputs.<output>` for data
@@ -108,13 +139,23 @@ def adapt(stack_instance, out_dir):
     resources = stack_instance.get("resources", [])
     stack_outputs = stack_instance.get("outputs", {})
 
-    region = next((r["inputs"]["region"] for r in resources if "region" in r.get("inputs", {})), "us-east-1")
-    providers_tf = f'provider "aws" {{\n  region = "{region}"\n}}\n'
-
     stack_name = stack.get("name", "spike")
     environment = stack.get("environment", "dev")
-    account_id = env.get_env("AWS_ACCOUNT_ID", "581513795199")
+    # P03 W3 (REQ-319): state backend bucket + account_id + region come
-    state_bucket = f"nova-tfstate-{account_id}-us-east-1"
+    # from the env onboarding JSON (source of truth post-REQ-319). Bucket
+    # = env.state_backend.bucket when present (fallback to the computed
+    # nova-tfstate-{account_id}-{region} pattern for backwards compat).
+    env_json = _load_env_json(environment, repo_root)
+    region = env_json.get("region") or next(
+        (r["inputs"]["region"] for r in resources if "region" in r.get("inputs", {})),
+        "us-east-1",
+    )
+    state_bucket = _resolve_state_bucket(env_json, region)
+    providers_tf = f'provider "aws" {{\n  region = "{region}"\n}}\n'
+
+    # State key is env-scoped (v1.24 REQ-287): the {environment} segment lets
+    # the env-transition detect-and-destroy step target the PRIOR env's state
+    # without affecting the new env. No orphan path on environment promotion.
     terraform_tf = (
         'terraform {\n'
         '  required_version = ">= 1.9, < 1.10"\n'
@@ -127,7 +168,7 @@ def adapt(stack_instance, out_dir):
         '  backend "s3" {\n'
         f'    bucket = "{state_bucket}"\n'
         f'    key    = "spike/{stack_name}/{environment}/terraform.tfstate"\n'
-        '    region = "us-east-1"\n'
+        f'    region = "{region}"\n'
         '  }\n'
         '}\n'
     )
@@ -142,7 +183,7 @@ def adapt(stack_instance, out_dir):
             '  config = {\n'
             f'    bucket = "{state_bucket}"\n'
             f'    key    = "{remote_state_key}"\n'
-            '    region = "us-east-1"\n'
+            f'    region = "{region}"\n'
             '  }\n'
             '}\n'
         )

core/attestation_matrix.py

@@ -169,20 +169,21 @@ def check(env: str, evidence: dict) -> Tuple[bool, str]:
     return (True, f"{env}: all {len(concerns)} concern(s) pass")
 
 
-if __name__ == "__main__":
+def cli_main(argv) -> int:
+    """Thin CLI entry (P1): nova attestation-matrix <env> [evidence.json]."""
     import json
-    if len(sys.argv) < 2:
+    if len(argv) < 2:
-        print("usage: attestation_matrix.py <env> [evidence.json]", file=sys.stderr)
+        print("usage: attestation_matrix <env> [evidence.json]", file=sys.stderr)
-        sys.exit(2)
+        return 2
-    _env = sys.argv[1]
+    _env = argv[1]
     _evidence = {}
-    if len(sys.argv) >= 3 and os.path.isfile(sys.argv[2]):
+    if len(argv) >= 3 and os.path.isfile(argv[2]):
-        with open(sys.argv[2]) as f:
+        with open(argv[2]) as f:
             _evidence = json.load(f)
     ok, reason = check(_env, _evidence)
-    if ok:
+    print(f"ATTESTATION PASS: {reason}") if ok else print(f"ATTESTATION BLOCK: {reason}", file=sys.stderr)
-        print(f"ATTESTATION PASS: {reason}")
+    return 0 if ok else 1
-        sys.exit(0)
+
-    else:
+
-        print(f"ATTESTATION BLOCK: {reason}", file=sys.stderr)
+if __name__ == "__main__":
-        sys.exit(1)
+    sys.exit(cli_main(sys.argv))

core/confidence_signal.py

@@ -144,6 +144,7 @@ def compute(contract_id: str, environment: str,
     penalty = 0.0
     policy_input = inputs.get("policy")
     pcrs = policy_input if isinstance(policy_input, list) else []
+    critical_override = False
     for pcr in pcrs:
         if not isinstance(pcr, dict):
             continue
@@ -152,20 +153,31 @@ def compute(contract_id: str, environment: str,
         sev = pcr.get("severity")
         p = PENALTY.get(sev, 0.0)
         if p is None:
-            return Signal(0.0, "block", per_input,
+            # Critical PCR hard override: score = 0, band = block.
-                          reasons + [f"CRITICAL_OVERRIDE:{pcr.get('ruleId','?')}"])
+            # Do NOT early-return — fall through to the event emission
+            # block below so the SPEC §5.8 evidence stream
+            # (confidence.computed -> ai.decision.made -> ...) is complete
+            # even on a critical override (REQ-318: a critical PCR is a
+            # confidence-driven escalation and must carry escalation_reason).
+            reasons.append(f"CRITICAL_OVERRIDE:{pcr.get('ruleId','?')}")
+            critical_override = True
+            break
         penalty += p
 
-    score = max(0.0, min(1.0, base - penalty))
+    if critical_override:
-    threshold = THRESHOLDS[environment]
+        score = 0.0
-    if score >= threshold:
-        band = "pass"
-    elif score < threshold - 0.10:
         band = "block"
     else:
-        band = "warn"
+        score = max(0.0, min(1.0, base - penalty))
-    if environment == "dev" and band == "warn":
+        threshold = THRESHOLDS[environment]
-        band = "block"
+        if score >= threshold:
+            band = "pass"
+        elif score < threshold - 0.10:
+            band = "block"
+        else:
+            band = "warn"
+        if environment == "dev" and band == "warn":
+            band = "block"
     signal = Signal(score, band, per_input, reasons)
 
     # Emit nova.confidence.computed + nova.ai.decision.made events (D-122).
@@ -184,6 +196,17 @@ def compute(contract_id: str, environment: str,
             "human_override": band == "block",
             "threshold": THRESHOLDS[environment],
         }
+        # REQ-318 (SPEC §5.8): on a `block` band, carry escalation_reason.
+        # In v1.26 the only value is "confidence" — a block is always
+        # confidence-driven (the score fell below threshold OR a critical
+        # PCR fired a hard override). Future milestones may add "policy"
+        # (a critical PCR that is not confidence-scored); leave the door
+        # open but only emit "confidence" now. On pass/warn bands the
+        # field is ABSENT (escalation_reason is only meaningful on a
+        # block — it is the Post-Pilot Human Escalation Frequency
+        # denominator).
+        if band == "block":
+            decision_data["escalation_reason"] = "confidence"
         decision_event = make_event("nova.ai.decision.made", run_id, environment, decision_data,
                                      contract_id=contract_id, actor_type="confidence-gate",
                                      actor_id="confidence_signal")
@@ -195,12 +218,18 @@ def compute(contract_id: str, environment: str,
     return signal
 
 
-if __name__ == "__main__":
+def cli_main(argv) -> int:
-    if len(sys.argv) < 3:
+    """Thin CLI entry (P1): nova confidence <inputs.json> <environment>."""
-        print("usage: confidence_signal.py <inputs.json> <environment>", file=sys.stderr)
+    if len(argv) < 3:
-        sys.exit(2)
+        print("usage: confidence <inputs.json> <environment>", file=sys.stderr)
-    env = sys.argv[2]
+        return 2
-    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+    env = argv[2]
+    with open(argv[1], "r", encoding="utf-8") as fh:
         inputs = json.load(fh)
     sig = compute("cli", env, inputs)
-    print(json.dumps(asdict(sig), indent=2))
+    print(json.dumps(asdict(sig), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(cli_main(sys.argv))

core/contract_resolver.py

@@ -488,6 +488,25 @@ def resolve(contract_path, repo_root=None, environment_override=None):
     # Validate contract against schema
     jsonschema.validate(contract, contract_schema)
 
+    # v1.25 (REQ-296): pre-resolve policy evaluation — run the active
+    # PolicyEngine over the contract dict with the contract/ policy
+    # dir BEFORE resolving. Failures feed the `policyResults` on the
+    # stack instance (the confidence signal's `policy` input). The
+    # resolver does NOT exit on policy failure — the confidence signal
+    # decides the gate (consistent with the existing --soft-fail
+    # Checkov pattern).
+    contract_pcrs: list = []
+    try:
+        from core.policy_engine import get_engine, get_policy_root
+        _engine = get_engine()
+        _policy_root = get_policy_root()
+        contract_pcrs = _engine.evaluate(
+            contract, _policy_root / "contract", contract.get("id", "unknown")
+        )
+    except Exception:
+        # Policy evaluation must never break the resolver.
+        contract_pcrs = []
+
     # 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
@@ -590,6 +609,12 @@ def resolve(contract_path, repo_root=None, environment_override=None):
         "data_sources": all_data_sources,
     }
 
+    # v1.25 (REQ-296): attach the pre-resolve contract-policy PCRs to
+    # the stack instance. The post-resolve stack-IR PCRs are appended
+    # after stack-schema validation (below).
+    if contract_pcrs:
+        stack_instance["policyResults"] = list(contract_pcrs)
+
     # Add the human-readable title
     if contract.get("name"):
         stack_instance["stack"]["title"] = contract["name"]
@@ -606,6 +631,28 @@ def resolve(contract_path, repo_root=None, environment_override=None):
     stack_schema = _load_schema(os.path.join(repo_root, "schemas", "stack.schema.json"))
     jsonschema.validate(stack_instance, stack_schema)
 
+    # v1.25 (REQ-298): post-resolve policy evaluation — run the active
+    # PolicyEngine over the resolved Stack IR with the stack-ir/ policy
+    # dir. The resulting PCRs are appended to the contract-policy PCRs
+    # on the stack instance (additive — the resolver's return value
+    # shape and exceptions are unchanged). The confidence signal
+    # consumes the merged list as its `policy` input.
+    try:
+        from core.policy_engine import get_engine, get_policy_root
+        engine = get_engine()
+        policy_root = get_policy_root()
+        stack_ir_pcrs = engine.evaluate(
+            stack_instance, policy_root / "stack-ir", contract.get("id", "unknown")
+        )
+        stack_instance.setdefault("policyResults", []).extend(stack_ir_pcrs)
+    except Exception:
+        # Policy evaluation must never break the resolver — the
+        # confidence signal decides the gate. A failure here means the
+        # engine is misconfigured; the contract PCRs (if any) are still
+        # present, and the confidence signal proceeds with whatever
+        # `policy` input it receives (possibly empty → 0.5 neutral).
+        pass
+
     return stack_instance
 
 

core/env.py

@@ -1,4 +1,4 @@
-"""Environment helper (D-108, REQ-159, REQ-164).
+"""Environment helper (D-108, REQ-159, REQ-164, REQ-330).
 
 During the Nova rebrand transition window (P2–P4), `get_env` read
 `NOVA_*` preferred with the legacy `ACDL_*` name as the fallback. **P5
@@ -9,14 +9,27 @@ During the Nova rebrand transition window (P2–P4), `get_env` read
 `.env.secrets` shell export in `scripts/run_platform.sh` and the Python
 parser in `core/regression_verify.py`) were updated to NOVA-only in P5
 (the G-106 dual-read contract was retired with the fallback).
+
+P2 (REQ-330): `synthesize_local_env(contract_path, environment)` produces
+a purely synthetic local env dict (account_id placeholder, region
+"local", no real AWS resources) from a contract YAML. Mirrors the shape
+of core/environments/*.json (validates against
+schemas/environment.schema.json) so `nova apply --local` can run the
+contract resolver + Terraform adapter without provisioning cloud
+resources. This is the local-tier counterpart of
+core/onboarding.py:generate_env_file() (the request-path binding
+generator).
 """
 
 from __future__ import annotations
 
 import os
-from typing import Optional
+from pathlib import Path
+from typing import Any, Dict, Optional
 
-__all__ = ["get_env"]
+import yaml
+
+__all__ = ["get_env", "synthesize_local_env"]
 
 
 def get_env(name: str, default: Optional[str] = None) -> Optional[str]:
@@ -28,4 +41,85 @@ def get_env(name: str, default: Optional[str] = None) -> Optional[str]:
     val = os.environ.get(f"NOVA_{name}")
     if val:
         return val
-    return default
+    return default
+
+
+# Default confidence thresholds per environment name (mirrors the schema
+# description: dev 0.50, qa 0.75, prod 0.90, dr 0.95). Used by
+# synthesize_local_env so the synthetic env matches the real env semantics.
+_DEFAULT_THRESHOLDS: Dict[str, float] = {
+    "dev": 0.50,
+    "qa": 0.75,
+    "prod": 0.90,
+    "dr": 0.95,
+}
+
+
+def synthesize_local_env(
+    contract_path: str,
+    environment: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Synthesize a local env dict from a contract YAML (REQ-330).
+
+    Reads the contract YAML (``yaml.safe_load``), derives a placeholder
+    environment binding that ``nova apply --local`` can use WITHOUT
+    provisioning real AWS resources. The produced dict:
+
+      - ``name`` — the environment name (from the arg or the contract's
+        ``environment`` field, defaulting to ``"dev"``).
+      - ``account_id`` — ``"000000000000"`` (the schema-allowed placeholder
+        for an unbound environment; real account id filled by the platform).
+      - ``region`` — ``"local"`` (the local-tier sentinel; never a real
+        AWS region).
+      - ``state_backend`` — ``{bucket: "local-tfstate", lock_table:
+        "local-locks"}`` (local state; LocalS3StateBackend rewrites the
+        terraform backend to ``backend "local"`` using the stack name as
+        the state path, so no S3 bucket is used).
+      - ``network`` — a local RFC1918 CIDR + a single fake AZ.
+      - ``runner_role_arn`` — a placeholder ARN for the local tier.
+      - ``autonomy`` — ``"full"`` (the local tier is autonomous).
+      - ``confidence_threshold`` — the per-env default (0.50 for dev).
+
+    The dict mirrors the shape of ``core/environments/*.json`` and
+    validates against ``schemas/environment.schema.json``. No cloud
+    provisioning occurs — purely synthetic.
+
+    Args:
+        contract_path: Path to the contract YAML file.
+        environment: Optional environment name override (defaults to the
+            contract's ``environment`` field, or ``"dev"``).
+
+    Returns:
+        The synthetic local env dict.
+    """
+    contract_path_obj = Path(contract_path)
+    contract: Dict[str, Any] = {}
+    if contract_path_obj.is_file():
+        with open(contract_path_obj) as fh:
+            contract = yaml.safe_load(fh) or {}
+
+    env_name = environment or contract.get("environment", "dev")
+    stack_name = contract.get("id", env_name)
+    threshold = _DEFAULT_THRESHOLDS.get(env_name, 0.50)
+
+    return {
+        "name": env_name,
+        "description": (
+            f"Synthetic local-tier environment for contract '{stack_name}' "
+            f"(environment={env_name}). No real AWS resources — generated "
+            f"by core.env.synthesize_local_env (REQ-330) for nova apply --local."
+        ),
+        "account_id": "000000000000",
+        "region": "local",
+        "state_backend": {
+            "bucket": "local-tfstate",
+            "lock_table": "local-locks",
+        },
+        "network": {
+            "vpc_cidr": "10.250.0.0/16",
+            "azs": ["local-a"],
+        },
+        "runner_role_arn": "arn:aws:iam::000000000000:role/local-runner",
+        "autonomy": "full",
+        "confidence_threshold": threshold,
+    }

core/env_transition.py

@@ -0,0 +1,159 @@
+"""Nova Environment Transition — detect prior env + record applied env.
+
+When a consumer edits the `environment:` field on a stable contract `id`
+(Shape A promotion), the platform must destroy the prior environment's
+resources before building the new environment. This module provides the
+DynamoDB query logic to detect the prior environment and record the
+applied environment after a successful apply.
+
+Source of truth: the `nova-contracts` DynamoDB table (PK `consumerRepo`,
+SK `contractId#submittedAt`), written by `core/lambda/contract_ingestor.py`.
+
+detect_prior_env() queries the table for the last-applied environment for
+a given consumerRepo + contractId. If it differs from the new env, the
+prior env name is returned (so the pipeline can destroy it). If no record
+exists (first deploy or Shape B per-env caller), returns None.
+
+record_applied_env() writes a `#LAST_APPLIED` record after a successful
+apply, so the next run's detect step has a source of truth.
+
+Failures to reach DynamoDB (local/CI mode without the table) log a warning
+and return None (conservative — no false-positive destroys). This is the
+no-orphan-path guarantee: if we can't confirm a prior env, we don't
+destroy, but we also don't silently proceed in a way that orphans — the
+record step ensures future runs have the data.
+
+CLI:
+    python3 core/env_transition.py detect --contract-id <id> --consumer-repo <repo> --new-env <env>
+    python3 core/env_transition.py record --contract-id <id> --consumer-repo <repo> --env <env>
+"""
+
+import datetime
+import json
+import os
+import sys
+from typing import Optional
+
+try:
+    import boto3
+except ImportError:
+    boto3 = None
+
+TABLE_NAME = os.environ.get("CONTRACTS_TABLE", "nova-contracts")
+REGION = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
+LAST_APPLIED_SUFFIX = "#LAST_APPLIED"
+
+
+def _get_table():
+    """Return the DynamoDB table resource, or raise if boto3 unavailable."""
+    if boto3 is None:
+        raise RuntimeError("boto3 is required for env_transition")
+    session = boto3.Session(region_name=REGION)
+    dyn = session.resource("dynamodb")
+    return dyn.Table(TABLE_NAME)
+
+
+def detect_prior_env(contract_id: str, consumer_repo: str, new_env: str) -> Optional[str]:
+    """Query the nova-contracts table for the last-applied env.
+
+    Returns the prior env name if it differs from new_env, else None.
+    Failures to reach DynamoDB log a warning and return None (conservative).
+    """
+    try:
+        table = _get_table()
+        sk_prefix = f"{contract_id}{LAST_APPLIED_SUFFIX}#"
+        resp = table.query(
+            KeyConditionExpression="consumerRepo = :repo AND begins_with(#sk, :prefix)",
+            FilterExpression="#status = :status",
+            ExpressionAttributeNames={
+                "#sk": "contractId#submittedAt",
+                "#status": "status",
+            },
+            ExpressionAttributeValues={
+                ":repo": consumer_repo,
+                ":prefix": sk_prefix,
+                ":status": "applied",
+            },
+            ScanIndexForward=False,
+            Limit=1,
+        )
+        items = resp.get("Items", [])
+        if not items:
+            return None
+        prior_env = items[0].get("environment")
+        if prior_env and prior_env != new_env:
+            return prior_env
+        return None
+    except Exception as exc:
+        sys.stderr.write(
+            f"WARNING: env_transition.detect_prior_env: could not query "
+            f"DynamoDB table {TABLE_NAME} — {type(exc).__name__}: {exc}. "
+            f"Assuming no prior env (conservative). This is expected in "
+            f"local/CI mode without the nova-contracts table.\n"
+        )
+        return None
+
+
+def record_applied_env(contract_id: str, consumer_repo: str, env: str) -> bool:
+    """Write a LAST_APPLIED record to the nova-contracts table.
+
+    Called after a successful apply. Idempotent (writes a new timestamped
+    record each time; the detect step reads the latest by ScanIndexForward).
+    Returns True on success, False on failure (non-fatal — the pipeline
+    should not halt if the record write fails).
+    """
+    try:
+        table = _get_table()
+        ts = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        sk = f"{contract_id}{LAST_APPLIED_SUFFIX}#{ts}"
+        table.put_item(
+            Item={
+                "consumerRepo": consumer_repo,
+                "contractId#submittedAt": sk,
+                "contractId": contract_id,
+                "environment": env,
+                "status": "applied",
+                "appliedAt": ts,
+            }
+        )
+        return True
+    except Exception as exc:
+        sys.stderr.write(
+            f"WARNING: env_transition.record_applied_env: could not write to "
+            f"DynamoDB table {TABLE_NAME} — {type(exc).__name__}: {exc}. "
+            f"The apply succeeded but the last-applied env record was not "
+            f"persisted. Future env-transition detection may not work.\n"
+        )
+        return False
+
+
+def main(argv):
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Nova env-transition detect/record")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_detect = sub.add_parser("detect", help="Detect prior env for a contract")
+    p_detect.add_argument("--contract-id", required=True)
+    p_detect.add_argument("--consumer-repo", required=True)
+    p_detect.add_argument("--new-env", required=True)
+
+    p_record = sub.add_parser("record", help="Record the applied env for a contract")
+    p_record.add_argument("--contract-id", required=True)
+    p_record.add_argument("--consumer-repo", required=True)
+    p_record.add_argument("--env", required=True)
+
+    args = parser.parse_args(argv[1:])
+
+    if args.command == "detect":
+        prior = detect_prior_env(args.contract_id, args.consumer_repo, args.new_env)
+        print(json.dumps({"prior_env": prior}))
+        return 0 if prior is None else 0
+    elif args.command == "record":
+        ok = record_applied_env(args.contract_id, args.consumer_repo, args.env)
+        print(json.dumps({"recorded": ok}))
+        return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

core/environments/dev.json

@@ -1,10 +1,10 @@
 {
   "name": "dev",
   "description": "Default platform-managed dev environment for onboarding demos.",
-  "account_id": "000000000000",
+  "account_id": "581513795199",
   "region": "us-east-1",
   "state_backend": {
-    "bucket": "acdl-dev-state",
+    "bucket": "nova-tfstate-581513795199-us-east-1",
     "lock_table": "acdl-dev-locks"
   },
   "network": {

core/environments/dr.json

@@ -4,7 +4,7 @@
   "account_id": "000000000000",
   "region": "us-east-1",
   "state_backend": {
-    "bucket": "acdl-dr-state",
+    "bucket": "nova-tfstate-000000000000-us-east-1",
     "lock_table": "acdl-dr-locks"
   },
   "network": {

core/environments/prod.json

@@ -4,7 +4,7 @@
   "account_id": "000000000000",
   "region": "us-east-1",
   "state_backend": {
-    "bucket": "acdl-prod-state",
+    "bucket": "nova-tfstate-000000000000-us-east-1",
     "lock_table": "acdl-prod-locks"
   },
   "network": {

core/environments/qa.json

@@ -4,7 +4,7 @@
   "account_id": "000000000000",
   "region": "us-east-1",
   "state_backend": {
-    "bucket": "acdl-qa-state",
+    "bucket": "nova-tfstate-000000000000-us-east-1",
     "lock_table": "acdl-qa-locks"
   },
   "network": {

core/init_scaffold.py

@@ -0,0 +1,51 @@
+"""Nova init scaffolding logic (P1, REQ-325).
+
+Creates .nova/ directory structure + secrets-exclusion .gitignore lines
+in the current working directory. nova/init.py delegates here so the
+subcommand stays thin (≤50 lines, ≤3 functions).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+SECRETS_IGNORE_LINES = (
+    "~/.nova/credentials.json",
+    ".nova/credentials.json",
+    "*.pem",
+    "*.key",
+    ".env",
+    ".env.*",
+)
+
+
+def _ensure_gitignore(root: Path, force: bool) -> None:
+    gi = root / ".gitignore"
+    existing = gi.read_text().splitlines() if gi.is_file() else []
+    additions = [ln for ln in SECRETS_IGNORE_LINES if ln not in existing]
+    if not additions:
+        return
+    blob = gi.read_text() if gi.is_file() else ""
+    if blob and not blob.endswith("\n"):
+        blob += "\n"
+    blob += "\n".join(additions) + "\n"
+    gi.write_text(blob)
+
+
+def scaffold(root: Path | None = None, force: bool = False) -> int:
+    """Create .nova/ + .nova/contract.yml.attestations/ + .gitignore lines."""
+    root = root or Path.cwd()
+    nova_dir = root / ".nova"
+    attest_dir = nova_dir / "contract.yml.attestations"
+    if nova_dir.exists() and not force:
+        print(f"refusing: {nova_dir} already exists (use --force to overwrite)")
+        return 1
+    nova_dir.mkdir(parents=True, exist_ok=True)
+    attest_dir.mkdir(parents=True, exist_ok=True)
+    _ensure_gitignore(root, force)
+    print(f"scaffolded: {nova_dir} (+ {attest_dir.name}/, .gitignore secrets)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(scaffold())

core/jws_attestation.py

@@ -0,0 +1,213 @@
+"""JWS-from-PAT key derivation + symmetric attestation (REQ-332, C-5.2).
+
+C-5.2 grill fix: the "public key derivable from the PAT" acceptance
+criterion is re-interpreted as a SYMMETRIC scheme. The PAT (Personal
+Access Token) is the shared secret; the JWS signing key AND the
+verification key are both derived from the PAT via the same HKDF-SHA256
+KDF. The JWS uses HMAC-SHA256 (HS256) — a symmetric MAC, not an
+asymmetric signature.
+
+Key derivation (NIST SP 800-56C / RFC 5869):
+    key = HKDF-SHA256(
+        input_key_material = PAT.encode(),
+        salt               = b"nova-local-attestation",
+        info               = b"jws-signing-key",
+        length             = 32,
+    )
+
+The resulting 32-byte key is used both to sign (sign_attestation) and to
+verify (verify_attestation). Anyone holding the PAT can derive the same
+key and verify the attestation; without the PAT, the HMAC cannot be
+forged. This satisfies INV-14..17:
+
+  - INV-14: the signing key is derived from the PAT (no separate key
+    material; no long-lived private key on disk).
+  - INV-15: the key never leaves the derivation (it is recomputed from
+    the PAT on each sign/verify call; not cached, not persisted).
+  - INV-16: the salt + info are fixed constants binding the key to the
+    "nova-local-attestation / jws-signing-key" purpose (key separation).
+  - INV-17: tamper detection via the HMAC verification (verify_attestation
+    raises on any signature mismatch).
+
+The JWS is the compact serialization:
+    b64url(header).b64url(payload).b64url(signature)
+where header = {"alg":"HS256","typ":"JWT"}, payload = the JWT claims
+(the attestation payload dict), and signature = HMAC-SHA256(key,
+b64url(header) + "." + b64url(payload)).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+from typing import Any, Dict
+
+__all__ = [
+    "derive_signing_key",
+    "sign_attestation",
+    "verify_attestation",
+    "JWSValidationError",
+]
+
+# Fixed KDF parameters (INV-16: key separation — binds the derived key to
+# the nova-local-attestation / jws-signing-key purpose).
+_KDF_SALT = b"nova-local-attestation"
+_KDF_INFO = b"jws-signing-key"
+_KDF_LENGTH = 32  # 256-bit key for HMAC-SHA256
+
+# JWS header for HS256 (symmetric HMAC-SHA256).
+_JWS_HEADER = {"alg": "HS256", "typ": "JWT"}
+
+
+class JWSValidationError(Exception):
+    """Raised when a JWS attestation fails verification (signature mismatch,
+    malformed token, or wrong PAT)."""
+
+
+def _b64url_encode(data: bytes) -> str:
+    """RFC 7515 base64url encoding WITHOUT padding (JWS compact form)."""
+    import base64
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _b64url_decode(segment: str) -> bytes:
+    """RFC 7515 base64url decoding (re-adds stripped padding)."""
+    import base64
+    pad = "=" * (-len(segment) % 4)
+    return base64.urlsafe_b64decode(segment + pad)
+
+
+def _hkdf_sha256(input_key_material: bytes, salt: bytes, info: bytes, length: int) -> bytes:
+    """HKDF-SHA256 (RFC 5869).
+
+    Prefers cryptography.hazmat.primitives.kdf.hkdf.HKDF (the cryptography
+    extra); falls back to a hashlib-based implementation if cryptography
+    is unavailable (so the module works in a minimal Lambda runtime).
+    """
+    try:
+        from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+        from cryptography.hazmat.primitives import hashes
+        hkdf = HKDF(
+            algorithm=hashes.SHA256(),
+            length=length,
+            salt=salt,
+            info=info,
+        )
+        return hkdf.derive(input_key_material)
+    except ImportError:  # pragma: no cover - fallback path
+        return _hkdf_sha256_hashlib(input_key_material, salt, info, length)
+
+
+def _hkdf_sha256_hashlib(input_key_material: bytes, salt: bytes, info: bytes, length: int) -> bytes:
+    """RFC 5869 HKDF-SHA256 using only hashlib + hmac (fallback)."""
+    # Extract: PRK = HMAC-SHA256(salt, IKM)
+    prk = hmac.new(salt, input_key_material, hashlib.sha256).digest()
+    # Expand: T(i) = HMAC-SHA256(PRK, T(i-1) | info | i)
+    okm = b""
+    t = b""
+    block = 0
+    while len(okm) < length:
+        block += 1
+        t = hmac.new(prk, t + info + bytes([block]), hashlib.sha256).digest()
+        okm += t
+    return okm[:length]
+
+
+def derive_signing_key(pat: str) -> bytes:
+    """Derive the 32-byte symmetric JWS signing key from a PAT.
+
+    HKDF-SHA256(PAT.encode(), salt=b'nova-local-attestation',
+                info=b'jws-signing-key', length=32).
+
+    The same PAT always yields the same key (deterministic); the key is
+    never cached or persisted (INV-15 — recomputed on each call).
+    """
+    if not isinstance(pat, str) or not pat:
+        raise ValueError("pat must be a non-empty string")
+    return _hkdf_sha256(
+        input_key_material=pat.encode("utf-8"),
+        salt=_KDF_SALT,
+        info=_KDF_INFO,
+        length=_KDF_LENGTH,
+    )
+
+
+def sign_attestation(payload: Dict[str, Any], pat: str) -> str:
+    """Produce a compact JWS (HS256) for the attestation payload.
+
+    Args:
+        payload: the JWT claims (the attestation payload dict).
+        pat: the Personal Access Token (shared secret).
+
+    Returns:
+        The compact JWS string: b64url(header).b64url(payload).b64url(signature).
+        The header is {"alg":"HS256","typ":"JWT"}; the payload is the
+        JSON-encoded claims; the signature is HMAC-SHA256(key, header.payload).
+    """
+    if not isinstance(payload, dict):
+        raise ValueError("payload must be a dict")
+    key = derive_signing_key(pat)
+    header_segment = _b64url_encode(
+        json.dumps(_JWS_HEADER, separators=(",", ":"), sort_keys=True).encode("utf-8")
+    )
+    payload_segment = _b64url_encode(
+        json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
+    )
+    signing_input = f"{header_segment}.{payload_segment}".encode("ascii")
+    signature = hmac.new(key, signing_input, hashlib.sha256).digest()
+    signature_segment = _b64url_encode(signature)
+    return f"{header_segment}.{payload_segment}.{signature_segment}"
+
+
+def verify_attestation(jws: str, pat: str) -> Dict[str, Any]:
+    """Verify a compact JWS (HS256) attestation and return the payload.
+
+    Derives the same key from the PAT, recomputes the HMAC, and compares
+    in constant time. Raises JWSValidationError on:
+      - malformed JWS (not 3 segments, bad base64, bad JSON)
+      - signature mismatch (tampering or wrong PAT)
+      - wrong header (alg != HS256)
+
+    Args:
+        jws: the compact JWS string from sign_attestation.
+        pat: the Personal Access Token (shared secret).
+
+    Returns:
+        The decoded payload dict (the JWT claims) on success.
+    """
+    if not isinstance(jws, str) or not jws:
+        raise JWSValidationError("jws must be a non-empty string")
+    parts = jws.split(".")
+    if len(parts) != 3:
+        raise JWSValidationError(f"malformed JWS: expected 3 segments, got {len(parts)}")
+    header_segment, payload_segment, signature_segment = parts
+
+    # Decode + validate the header.
+    try:
+        header = json.loads(_b64url_decode(header_segment))
+    except (ValueError, json.JSONDecodeError) as e:
+        raise JWSValidationError(f"malformed JWS header: {e}") from e
+    if not isinstance(header, dict) or header.get("alg") != "HS256":
+        raise JWSValidationError(
+            f"unsupported JWS alg: expected HS256, got {header.get('alg')!r}"
+        )
+
+    # Recompute the signature with the key derived from the PAT.
+    key = derive_signing_key(pat)
+    signing_input = f"{header_segment}.{payload_segment}".encode("ascii")
+    expected_signature = hmac.new(key, signing_input, hashlib.sha256).digest()
+    actual_signature = _b64url_decode(signature_segment)
+    if not hmac.compare_digest(expected_signature, actual_signature):
+        raise JWSValidationError(
+            "JWS signature verification failed (tampered token or wrong PAT)"
+        )
+
+    # Decode + return the payload.
+    try:
+        payload = json.loads(_b64url_decode(payload_segment))
+    except (ValueError, json.JSONDecodeError) as e:
+        raise JWSValidationError(f"malformed JWS payload: {e}") from e
+    if not isinstance(payload, dict):
+        raise JWSValidationError("JWS payload is not a JSON object")
+    return payload

core/lambda/contract_ingestor.py

@@ -457,65 +457,149 @@ def _onboard_consumer(payload):
     }
 
 
+def dispatch_action(payload, event=None):
+    """Shared business-logic dispatch for the contract ingestor (REQ-329).
+
+    Both the AWS Lambda handler (``lambda_handler``) and the CLI path
+    (``cli_main`` / ``__main__``) call this function so the two paths share
+    a single source of truth for action routing, contract validation, the
+    DynamoDB write, and error reporting (NFR-7 — dual-use, single source).
+
+    Args:
+        payload: the decoded action envelope dict
+            ``{ consumerRepo, contractId, contract, environment, action }``.
+        event: the raw Lambda Function-URL event (used for IAM caller
+            identity validation). When ``None`` (the CLI path), the identity
+            check uses the ``NOVA_LAMBDA_LOCAL_BYPASS`` env var — CLI invocations
+            are local-only and do not carry an IAM principal.
+
+    Returns:
+        The action result dict (e.g. ``{status, contractId, action, ...}``)
+        on success. Raises ``ValueError`` for validation failures and other
+        exceptions for downstream errors — the caller is responsible for
+        mapping these to the appropriate status code / exit code.
+    """
+    action = payload.get("action", "submit_contract")
+    # Validate caller identity against the payload (P1-2). The CLI path
+    # passes event=None; the fail-closed check honours the local bypass.
+    _validate_caller_identity(event or {}, 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:
+                raise ValueError(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)
+    elif action == "onboard_consumer":
+        result = _onboard_consumer(payload)
+    else:
+        raise ValueError(f"unknown action: {action}")
+    return result
+
+
+def _to_http_response(result_or_error):
+    """Map a dispatch_action result / exception to a Lambda HTTP response.
+
+    Shared error→status mapping so both Lambda + CLI paths interpret errors
+    identically (REQ-329 dual-use).
+    """
+    if isinstance(result_or_error, Exception):
+        msg = str(result_or_error)
+        if isinstance(result_or_error, ValueError):
+            if "missing IAM caller identity" in msg:
+                return {"statusCode": 401, "body": json.dumps({"error": msg})}
+            return {"statusCode": 400, "body": json.dumps({"error": msg})}
+        return {"statusCode": 500, "body": json.dumps({"error": msg})}
+    return {"statusCode": 200, "body": json.dumps(result_or_error)}
+
+
 def lambda_handler(event, context):
-    """AWS Lambda handler entry point.
+    """AWS Lambda handler entry point (thin wrapper, REQ-329 dual-use).
 
     Accepts a Function-URL-style event whose ``body`` is a JSON string
     containing ``{ consumerRepo, contractId, contract, environment, action }``.
+    Parses the Lambda-specific envelope then delegates to the shared
+    ``dispatch_action`` business logic.
     """
     try:
         body = event.get("body", "{}")
-        if isinstance(body, str):
+        payload = json.loads(body) if isinstance(body, str) else body
-            payload = json.loads(body)
+        result = dispatch_action(payload, event=event)
-        else:
+        return _to_http_response(result)
-            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)
-        elif action == "onboard_consumer":
-            result = _onboard_consumer(payload)
-        else:
-            return {
-                "statusCode": 400,
-                "body": json.dumps({"error": f"unknown action: {action}"}),
-            }
-        return {"statusCode": 200, "body": json.dumps(result)}
-    except ValueError as e:
-        # P10 (REQ-174): identity failures are 401, field validation is 400.
-        if "missing IAM caller identity" in str(e):
-            return {"statusCode": 401, "body": json.dumps({"error": str(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)})}
+        return _to_http_response(e)
 
 
-# --- CLI: --check-readiness (D-133, REQ-218) ---------------------------
+def cli_main(argv=None):
-# Invoked as: python3 -m core.lambda.contract_ingestor --check-readiness <submission.json>
+    """CLI entry point for the contract ingestor (REQ-329 dual-use).
-# Delegates to core.submission_readiness.check_readiness() and prints the
+
-# structured ReadinessResult. Exits 0 if ready, 1 if not.
+    Usage:
+        python3 -m core.lambda.contract_ingestor --dispatch <payload.json>
+        python3 -m core.lambda.contract_ingestor --dispatch-stdin < <payload.json>
+
+    Parses the CLI-specific input (a JSON file path or stdin) then delegates
+    to the shared ``dispatch_action`` business logic — the same path as the
+    Lambda handler. Returns a process exit code (0 success, 1 validation
+    error, 2 internal error).
+    """
+    import sys
+    raw = argv if argv is not None else sys.argv[1:]
+    # The --dispatch flag consumes the next positional arg as a payload path;
+    # --dispatch-stdin reads the payload from stdin.
+    if "--dispatch-stdin" in raw:
+        payload = json.loads(sys.stdin.read())
+    elif "--dispatch" in raw:
+        idx = raw.index("--dispatch")
+        path = raw[idx + 1] if idx + 1 < len(raw) else None
+        if not path:
+            print("Usage: --dispatch <payload.json>", file=sys.stderr)
+            return 2
+        with open(path) as fh:
+            payload = json.loads(fh.read())
+    else:
+        print(
+            "Usage: python3 -m core.lambda.contract_ingestor --dispatch <payload.json>",
+            file=sys.stderr,
+        )
+        return 2
+    try:
+        result = dispatch_action(payload, event=None)
+        sys.stdout.write(json.dumps(result, indent=2) + "\n")
+        return 0
+    except ValueError as e:
+        sys.stderr.write(f"error: {e}\n")
+        return 1
+    except Exception as e:  # pragma: no cover - defensive top-level guard
+        sys.stderr.write(f"internal error: {e}\n")
+        return 2
+
+
+# --- CLI: --check-readiness (D-133, REQ-218) + --dispatch (REQ-329) ----
+# Invoked as:
+#   python3 -m core.lambda.contract_ingestor --check-readiness <submission.json>
+#   python3 -m core.lambda.contract_ingestor --dispatch <payload.json>
+# The --check-readiness path delegates to core.submission_readiness; the
+# --dispatch path is the dual-use CLI entry (REQ-329) that calls the same
+# dispatch_action() as the Lambda handler.
 if __name__ == "__main__":  # pragma: no cover - CLI entry
     import sys
     if "--check-readiness" in sys.argv:
         sys.path.insert(
             0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
         )
-        from core.submission_readiness import cli_main
+        from core.submission_readiness import cli_main as _readiness_cli
 
         # Strip the --check-readiness flag; pass the file path.
         rest = [a for a in sys.argv[1:] if a != "--check-readiness"]
-        sys.exit(cli_main(["check-readiness"] + rest))
+        sys.exit(_readiness_cli(["check-readiness"] + rest))
+    elif "--dispatch" in sys.argv or "--dispatch-stdin" in sys.argv:
+        sys.exit(cli_main())
     else:
-        print("Usage: python3 -m core.lambda.contract_ingestor --check-readiness <submission.json>")
+        print(
+            "Usage: python3 -m core.lambda.contract_ingestor "
+            "--check-readiness <submission.json> | --dispatch <payload.json>",
+            file=sys.stderr,
+        )

core/lambda/nova_idp_auth.py

@@ -0,0 +1,613 @@
+"""Nova IdP auth Lambda — sign-up / sign-in / session (REQ-333, REQ-334).
+
+Invoked via a Function URL (IAM auth) by the Nova CLI and consumer
+pipelines. Mirrors the ``contract_ingestor.py`` pattern: lazy
+``boto3.resource`` DynamoDB singleton, env-var table names,
+``NOVA_LAMBDA_LOCAL_BYPASS`` for local testing, ``__main__`` CLI block
+for dual-use (REQ-329).
+
+## Argon2id password hashing (REQ-334, D-228, C-7.2)
+
+Passwords are hashed with Argon2id via ``argon2-cffi``:
+
+    PasswordHasher(time_cost=3, memory_cost=65536, parallelism=1)
+
+These are the OWASP minimum parameters (t=3, m=65536 KiB, p=1).
+Lambda memory **MUST be ≥ 512 MB** (Argon2id memory_cost ~64 MiB +
+runtime overhead).
+
+**D-228 (amended) — fail-closed:** there is no maintained pure-Python
+Argon2 implementation; a pure-Python crypto fallback is a liability
+(weaker hashing, violates INV-16's spirit). If the ``argon2`` C
+extension fails to import, the Lambda **fails closed** —
+``_ARGON2_AVAILABLE`` is set ``False`` at cold-start, and
+:func:`hash_password` / :func:`verify_password` raise
+``Argon2UnavailableError``. The handler catches this and returns
+**HTTP 503** (``{"error": "argon2_unavailable"}``) — **no pure-Python
+fallback, no weak hash, no crash.** This is verified by the explicit
+``test_argon2_fail_closed`` test (C-1.2).
+
+## No raw passwords anywhere (INV-16)
+
+Raw passwords are NEVER:
+  * written to DynamoDB (only ``password_hash`` is stored),
+  * logged (the handler never logs the password argument),
+  * put in traces / env vars / X-Ray segments.
+
+Audit events (``auth.sign_up``, ``auth.sign_in``,
+``auth.session_created``) are emitted to stderr as JSON; they carry the
+``user_id`` / ``email`` but **never** the password.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import sys
+import uuid
+
+import boto3
+
+# ---------------------------------------------------------------------------
+# Argon2id — fail-closed import (REQ-334, D-228, C-7.2)
+# ---------------------------------------------------------------------------
+#
+# try-import the C extension. If it fails (missing abi3 wheel, wrong
+# glibc, etc.), _ARGON2_AVAILABLE becomes False and hash/verify raise
+# Argon2UnavailableError. The handler returns 503. NO pure-Python fallback.
+_ARGON2_AVAILABLE = False
+_PasswordHasher = None
+
+try:  # pragma: no cover - import success path covered by round-trip test
+    from argon2 import PasswordHasher
+    from argon2.exceptions import VerifyMismatchError
+
+    _PasswordHasher = PasswordHasher
+    _ARGON2_AVAILABLE = True
+except ImportError:  # pragma: no cover - exercised via mock in tests
+    _ARGON2_AVAILABLE = False
+
+    # Define a stand-in so `verify_password` can raise the right type
+    # even when argon2 isn't importable. VerifyMismatchError is only
+    # raised by verify() which itself raises Argon2UnavailableError first.
+    class VerifyMismatchError(Exception):
+        """Raised by verify_password when the password does not match."""
+
+
+class Argon2UnavailableError(Exception):
+    """Raised when the Argon2 C extension is unavailable (D-228 fail-closed).
+
+    The handler catches this and returns HTTP 503 — no pure-Python
+    fallback, no weak hash.
+    """
+
+
+# OWASP-minimum Argon2id parameters (C-7.2):
+#   time_cost=3, memory_cost=65536 KiB (64 MiB), parallelism=1
+_ARGON2_TIME_COST = 3
+_ARGON2_MEMORY_COST = 65536  # KiB
+_ARGON2_PARALLELISM = 1
+
+
+def _get_hasher():
+    """Return a PasswordHasher configured with the OWASP-min params.
+
+    Raises Argon2UnavailableError if the C extension is not loaded.
+    """
+    if not _ARGON2_AVAILABLE or _PasswordHasher is None:
+        raise Argon2UnavailableError(
+            "argon2 C extension unavailable — refusing to hash with a "
+            "weak fallback (D-228 fail-closed)"
+        )
+    return _PasswordHasher(
+        time_cost=_ARGON2_TIME_COST,
+        memory_cost=_ARGON2_MEMORY_COST,
+        parallelism=_ARGON2_PARALLELISM,
+    )
+
+
+def hash_password(password: str) -> str:
+    """Hash a password with Argon2id (OWASP-min params).
+
+    Returns the Argon2id hash string (includes the salt + params).
+
+    Raises:
+        Argon2UnavailableError: if the ``argon2`` C extension is not
+            importable (D-228 fail-closed — NO pure-Python fallback).
+    """
+    if not _ARGON2_AVAILABLE:
+        raise Argon2UnavailableError(
+            "argon2 C extension unavailable — refusing to hash (D-228)"
+        )
+    # NOTE: the password argument is NEVER logged. Do not add debug
+    # prints here that include `password`.
+    return _get_hasher().hash(password)
+
+
+def verify_password(password: str, hash_str: str) -> bool:
+    """Verify a password against an Argon2id hash.
+
+    Returns ``True`` if the password matches.
+
+    Raises:
+        Argon2UnavailableError: if the ``argon2`` C extension is not
+            importable.
+        VerifyMismatchError: if the password does not match the hash.
+    """
+    if not _ARGON2_AVAILABLE:
+        raise Argon2UnavailableError(
+            "argon2 C extension unavailable — refusing to verify (D-228)"
+        )
+    # argon2.PasswordHasher().verify raises VerifyMismatchError on
+    # mismatch (and InvalidHash on a malformed hash). We let those
+    # propagate; the handler maps them to 401 / 500.
+    _get_hasher().verify(hash_str, password)
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Config (env-var table names, mirroring contract_ingestor.py)
+# ---------------------------------------------------------------------------
+
+USERS_TABLE = os.environ.get("NOVA_USERS_TABLE", "nova-users")
+SESSIONS_TABLE = os.environ.get("NOVA_SESSIONS_TABLE", "nova-sessions")
+PASSWORD_RESETS_TABLE = os.environ.get(
+    "NOVA_PASSWORD_RESETS_TABLE", "nova-password-resets"
+)
+# Session lifetime (seconds). Default 24h.
+SESSION_TTL_SECONDS = int(os.environ.get("NOVA_SESSION_TTL_SECONDS", "86400"))
+# Password-reset token lifetime (seconds). Default 15 min.
+RESET_TTL_SECONDS = int(os.environ.get("NOVA_RESET_TTL_SECONDS", "900"))
+
+_dynamodb = None
+
+
+def _get_dynamodb():
+    """Lazy boto3 DynamoDB resource singleton (mirrors contract_ingestor)."""
+    global _dynamodb
+    if _dynamodb is None:
+        _dynamodb = boto3.resource("dynamodb")
+    return _dynamodb
+
+
+def _iso8601_now() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime(
+        "%Y-%m-%dT%H:%M:%SZ"
+    )
+
+
+def _epoch_now() -> int:
+    return int(datetime.datetime.now(datetime.timezone.utc).timestamp())
+
+
+def _emit_audit(event_type: str, **fields) -> None:
+    """Emit an audit event to stderr as JSON (never includes passwords)."""
+    payload = {"event": event_type, "ts": _iso8601_now(), **fields}
+    # Defense-in-depth: scrub any field literally named 'password' or
+    # 'password_hash' value from the audit payload (they should never be
+    # passed here, but a stray kwarg would leak — INV-16).
+    for _k in ("password", "new_password", "old_password"):
+        payload.pop(_k, None)
+    sys.stderr.write(json.dumps(payload, sort_keys=True) + "\n")
+    sys.stderr.flush()
+
+
+# ---------------------------------------------------------------------------
+# Business logic (sign_up / sign_in / create_session / reset flows)
+# ---------------------------------------------------------------------------
+
+
+def _require(fields, payload):
+    """Validate required fields; raise ValueError (→ 400) if missing."""
+    for f in fields:
+        if f not in payload or payload[f] in (None, ""):
+            raise ValueError(f"missing field: {f}")
+
+
+def _lookup_user_by_email(email: str):
+    """Query nova-users GSI1 (email-index) → return the user item or None."""
+    table = _get_dynamodb().Table(USERS_TABLE)
+    resp = table.query(
+        IndexName="email-index",
+        KeyConditionExpression="email = :e",
+        ExpressionAttributeValues={":e": email},
+        Limit=1,
+    )
+    items = resp.get("Items", [])
+    return items[0] if items else None
+
+
+def sign_up(payload):
+    """Create a new user. Fails closed (503) if argon2 is unavailable.
+
+    Payload: { email, password, owner, roles }
+    Writes to nova-users: PK user_id (uuid4), email, password_hash,
+    owner, roles, created_at. The raw password is NEVER stored.
+    """
+    _require(("email", "password", "owner", "roles"), payload)
+    if not _ARGON2_AVAILABLE:
+        raise Argon2UnavailableError("argon2 unavailable")
+    email = payload["email"]
+    password = payload["password"]
+    owner = payload["owner"]
+    roles = payload["roles"]
+    if not isinstance(roles, list):
+        raise ValueError("roles must be a list")
+
+    # Duplicate-email check → 409.
+    if _lookup_user_by_email(email) is not None:
+        raise _DuplicateEmailError(email)
+
+    user_id = str(uuid.uuid4())
+    password_hash = hash_password(password)  # fail-closed here
+    created_at = _iso8601_now()
+    item = {
+        "user_id": user_id,
+        "email": email,
+        "password_hash": password_hash,
+        "owner": owner,
+        "roles": roles,
+        "created_at": created_at,
+    }
+    table = _get_dynamodb().Table(USERS_TABLE)
+    table.put_item(TableName=USERS_TABLE, Item=item)
+    _emit_audit("auth.sign_up", user_id=user_id, email=email)
+    return {
+        "status": "ok",
+        "action": "sign_up",
+        "user_id": user_id,
+        "email": email,
+        "created_at": created_at,
+    }
+
+
+class _DuplicateEmailError(Exception):
+    """Raised when sign_up is called with an already-registered email → 409."""
+
+    def __init__(self, email: str):
+        self.email = email
+        super().__init__(f"email already registered: {email}")
+
+
+def create_session(user_id: str) -> str:
+    """Create a session row in nova-sessions; return the session_id.
+
+    TTL: expires_at = now + SESSION_TTL_SECONDS (epoch seconds).
+    """
+    session_id = str(uuid.uuid4())
+    now = _epoch_now()
+    expires_at = now + SESSION_TTL_SECONDS
+    created_at = _iso8601_now()
+    table = _get_dynamodb().Table(SESSIONS_TABLE)
+    table.put_item(
+        TableName=SESSIONS_TABLE,
+        Item={
+            "session_id": session_id,
+            "user_id": user_id,
+            "expires_at": expires_at,
+            "created_at": created_at,
+        },
+    )
+    _emit_audit("auth.session_created", user_id=user_id, session_id=session_id)
+    return session_id
+
+
+def sign_in(payload):
+    """Sign in by email + password → return a session_id.
+
+    On wrong password → raises VerifyMismatchError (→ 401).
+    On unknown email → raises _UnknownUserError (→ 401, same code to
+    avoid user-enumeration via timing — the message is generic).
+    On argon2 unavailable → Argon2UnavailableError (→ 503).
+    """
+    _require(("email", "password"), payload)
+    if not _ARGON2_AVAILABLE:
+        raise Argon2UnavailableError("argon2 unavailable")
+    email = payload["email"]
+    password = payload["password"]
+    user = _lookup_user_by_email(email)
+    if user is None:
+        # Generic 401 — do not reveal whether the email is registered
+        # (user-enumeration defense).
+        raise _UnknownUserError("invalid credentials")
+    try:
+        verify_password(password, user["password_hash"])
+    except VerifyMismatchError:
+        raise _UnknownUserError("invalid credentials")
+    session_id = create_session(user["user_id"])
+    _emit_audit("auth.sign_in", user_id=user["user_id"], email=email)
+    return {
+        "status": "ok",
+        "action": "sign_in",
+        "user_id": user["user_id"],
+        "session_id": session_id,
+    }
+
+
+class _UnknownUserError(Exception):
+    """Generic 'invalid credentials' — 401 (no user enumeration)."""
+
+
+def request_password_reset(payload):
+    """Generate a reset token (uuid4) → write to nova-password-resets (15 min TTL).
+
+    Returns the token directly (in a real system this would be emailed;
+    for v1.28 it is returned so tests / the CLI can drive reset_password).
+    """
+    _require(("email",), payload)
+    email = payload["email"]
+    user = _lookup_user_by_email(email)
+    if user is None:
+        # Return ok regardless (no user enumeration via reset endpoint).
+        # We still return a (fake) token shape so the response is uniform;
+        # the token is single-use and reset_password validates against DDB.
+        _emit_audit("auth.password_reset_requested", email=email, found=False)
+        return {
+            "status": "ok",
+            "action": "request_password_reset",
+            "reset_token": None,
+            "message": "if the email is registered, a reset token was issued",
+        }
+    reset_token = str(uuid.uuid4())
+    now = _epoch_now()
+    expires_at = now + RESET_TTL_SECONDS
+    table = _get_dynamodb().Table(PASSWORD_RESETS_TABLE)
+    table.put_item(
+        TableName=PASSWORD_RESETS_TABLE,
+        Item={
+            "reset_token": reset_token,
+            "user_id": user["user_id"],
+            "expires_at": expires_at,
+            "created_at": _iso8601_now(),
+        },
+    )
+    _emit_audit(
+        "auth.password_reset_requested",
+        user_id=user["user_id"],
+        email=email,
+        found=True,
+    )
+    return {
+        "status": "ok",
+        "action": "request_password_reset",
+        "reset_token": reset_token,
+        "expires_at": expires_at,
+    }
+
+
+def reset_password(payload):
+    """Validate a reset token → set a new password → delete the token.
+
+    Payload: { reset_token, new_password }
+    On invalid/expired token → ValueError (→ 400).
+    On argon2 unavailable → Argon2UnavailableError (→ 503).
+    """
+    _require(("reset_token", "new_password"), payload)
+    if not _ARGON2_AVAILABLE:
+        raise Argon2UnavailableError("argon2 unavailable")
+    reset_token = payload["reset_token"]
+    new_password = payload["new_password"]
+    resets = _get_dynamodb().Table(PASSWORD_RESETS_TABLE)
+    resp = resets.get_item(
+        TableName=PASSWORD_RESETS_TABLE,
+        Key={"reset_token": reset_token},
+    )
+    item = resp.get("Item")
+    if not item:
+        raise ValueError("invalid or expired reset token")
+    if item.get("expires_at", 0) < _epoch_now():
+        # Token expired (TTL may not have reaped it yet).
+        raise ValueError("reset token expired")
+    user_id = item["user_id"]
+    new_hash = hash_password(new_password)  # fail-closed
+    users = _get_dynamodb().Table(USERS_TABLE)
+    users.update_item(
+        TableName=USERS_TABLE,
+        Key={"user_id": user_id},
+        UpdateExpression="SET password_hash = :h",
+        ExpressionAttributeValues={":h": new_hash},
+    )
+    resets.delete_item(
+        TableName=PASSWORD_RESETS_TABLE,
+        Key={"reset_token": reset_token},
+    )
+    _emit_audit("auth.password_reset", user_id=user_id)
+    return {
+        "status": "ok",
+        "action": "reset_password",
+        "user_id": user_id,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Dispatch (shared by Lambda handler + CLI — REQ-329 dual-use)
+# ---------------------------------------------------------------------------
+
+
+def dispatch_action(payload, event=None):
+    """Shared business-logic dispatch for the IdP auth Lambda (REQ-329).
+
+    Both the AWS Lambda handler (``lambda_handler``) and the CLI path
+    (``cli_main`` / ``__main__``) call this so the two paths share a
+    single source of truth for action routing.
+
+    Args:
+        payload: the decoded action envelope dict, e.g.
+            ``{ action: "sign_up", email, password, owner, roles }``.
+        event: the raw Lambda Function-URL event (unused for identity —
+            the IAM auth is enforced at the Function URL layer; kept for
+            signature symmetry with contract_ingestor).
+
+    Returns:
+        The action result dict on success. Raises on error — the caller
+        maps exceptions to status codes via :func:`_to_http_response`.
+    """
+    action = payload.get("action")
+    if action == "sign_up":
+        return sign_up(payload)
+    if action == "sign_in":
+        return sign_in(payload)
+    if action == "create_session":
+        _require(("user_id",), payload)
+        sid = create_session(payload["user_id"])
+        return {"status": "ok", "action": "create_session", "session_id": sid}
+    if action == "request_password_reset":
+        return request_password_reset(payload)
+    if action == "reset_password":
+        return reset_password(payload)
+    raise ValueError(f"unknown action: {action!r}")
+
+
+def _to_http_response(result_or_error):
+    """Map a dispatch result / exception to a Lambda HTTP response."""
+    if isinstance(result_or_error, Exception):
+        # Fail-closed: argon2 unavailable → 503 (NO weak hash, NO crash).
+        if isinstance(result_or_error, Argon2UnavailableError):
+            return {
+                "statusCode": 503,
+                "body": json.dumps({"error": "argon2_unavailable"}),
+            }
+        if isinstance(result_or_error, _DuplicateEmailError):
+            return {
+                "statusCode": 409,
+                "body": json.dumps({"error": "email_already_registered"}),
+            }
+        if isinstance(result_or_error, _UnknownUserError):
+            return {
+                "statusCode": 401,
+                "body": json.dumps({"error": "invalid_credentials"}),
+            }
+        if isinstance(result_or_error, ValueError):
+            return {
+                "statusCode": 400,
+                "body": json.dumps({"error": str(result_or_error)}),
+            }
+        return {
+            "statusCode": 500,
+            "body": json.dumps({"error": str(result_or_error)}),
+        }
+    return {"statusCode": 200, "body": json.dumps(result_or_error)}
+
+
+def lambda_handler(event, context):
+    """AWS Lambda handler entry point (thin wrapper, REQ-329 dual-use).
+
+    Accepts a Function-URL-style event whose ``body`` is a JSON string
+    containing ``{ action, email, password, ... }``. Parses the envelope
+    then delegates to :func:`dispatch_action`.
+    """
+    # Fail-closed fast-path: if argon2 is unavailable, sign_up / sign_in /
+    # reset_password all raise Argon2UnavailableError which maps to 503.
+    # We do NOT short-circuit here so non-password actions (create_session)
+    # still work when argon2 is down — only the hashing paths fail closed.
+    try:
+        body = event.get("body", "{}")
+        payload = json.loads(body) if isinstance(body, str) else body
+        result = dispatch_action(payload, event=event)
+        return _to_http_response(result)
+    except Exception as e:
+        return _to_http_response(e)
+
+
+# ---------------------------------------------------------------------------
+# CLI (dual-use, REQ-329 pattern)
+# ---------------------------------------------------------------------------
+
+
+def cli_main(argv=None):
+    """CLI entry point for the IdP auth Lambda (REQ-329 dual-use).
+
+    Usage:
+        python3 -m core.lambda.nova_idp_auth --sign-up <email> <password> <owner>
+        python3 -m core.lambda.nova_idp_auth --sign-in <email> <password>
+        python3 -m core.lambda.nova_idp_auth --create-session <user_id>
+        python3 -m core.lambda.nova_idp_auth --request-reset <email>
+        python3 -m core.lambda.nova_idp_auth --reset-password <token> <new_password>
+        python3 -m core.lambda.nova_idp_auth --dispatch <payload.json>
+        python3 -m core.lambda.nova_idp_auth --dispatch-stdin < <payload.json>
+    """
+    import sys
+
+    raw = argv if argv is not None else sys.argv[1:]
+    local_bypass = os.environ.get("NOVA_LAMBDA_LOCAL_BYPASS")
+    if not local_bypass:
+        os.environ["NOVA_LAMBDA_LOCAL_BYPASS"] = "1"
+    try:
+        if "--dispatch-stdin" in raw:
+            payload = json.loads(sys.stdin.read())
+        elif "--dispatch" in raw:
+            idx = raw.index("--dispatch")
+            path = raw[idx + 1] if idx + 1 < len(raw) else None
+            if not path:
+                print("Usage: --dispatch <payload.json>", file=sys.stderr)
+                return 2
+            with open(path) as fh:
+                payload = json.loads(fh.read())
+        elif "--sign-up" in raw:
+            idx = raw.index("--sign-up")
+            email, password, owner = raw[idx + 1 : idx + 4]
+            roles = ["user"]
+            payload = {
+                "action": "sign_up",
+                "email": email,
+                "password": password,
+                "owner": owner,
+                "roles": roles,
+            }
+        elif "--sign-in" in raw:
+            idx = raw.index("--sign-in")
+            email, password = raw[idx + 1 : idx + 3]
+            payload = {"action": "sign_in", "email": email, "password": password}
+        elif "--create-session" in raw:
+            idx = raw.index("--create-session")
+            user_id = raw[idx + 1]
+            payload = {"action": "create_session", "user_id": user_id}
+        elif "--request-reset" in raw:
+            idx = raw.index("--request-reset")
+            email = raw[idx + 1]
+            payload = {"action": "request_password_reset", "email": email}
+        elif "--reset-password" in raw:
+            idx = raw.index("--reset-password")
+            token, new_password = raw[idx + 1 : idx + 3]
+            payload = {
+                "action": "reset_password",
+                "reset_token": token,
+                "new_password": new_password,
+            }
+        else:
+            print(
+                "Usage: python3 -m core.lambda.nova_idp_auth "
+                "--sign-up <email> <password> <owner> | "
+                "--sign-in <email> <password> | "
+                "--dispatch <payload.json>",
+                file=sys.stderr,
+            )
+            return 2
+        result = dispatch_action(payload, event=None)
+        sys.stdout.write(json.dumps(result, indent=2) + "\n")
+        return 0
+    except Argon2UnavailableError as e:
+        sys.stderr.write(f"error: {e}\n")
+        return 3  # 503-class
+    except ValueError as e:
+        sys.stderr.write(f"error: {e}\n")
+        return 1
+    except _DuplicateEmailError as e:
+        sys.stderr.write(f"error: {e}\n")
+        return 9  # 409-class
+    except _UnknownUserError as e:
+        sys.stderr.write(f"error: {e}\n")
+        return 1  # 401-class
+    except Exception as e:  # pragma: no cover - defensive top-level guard
+        sys.stderr.write(f"internal error: {e}\n")
+        return 2
+    finally:
+        if not local_bypass:
+            os.environ.pop("NOVA_LAMBDA_LOCAL_BYPASS", None)
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI entry
+    import sys
+
+    sys.exit(cli_main())

core/lambda/nova_idp_auth_cfn.py

@@ -0,0 +1,244 @@
+"""CloudFormation snippet for the Nova IdP DynamoDB identity schema (REQ-335).
+
+This module exports :func:`dynamodb_tables_snippet`, which returns a
+CloudFormation fragment (a plain ``dict``) defining the four DynamoDB
+tables that back the Nova identity provider:
+
+  * ``nova-users``           — user records (PK ``user_id``, GSI1 ``email``)
+  * ``nova-sessions``        — session tokens (PK ``session_id``, GSI1
+    ``user_id``, TTL ``expires_at``)
+  * ``nova-password-resets`` — reset tokens (PK ``reset_token``, TTL
+    ``expires_at`` — 15 min)
+  * ``nova-pats``            — personal access tokens (PK ``jti``, GSI1
+    ``sub``, GSI2 ``pat_hash``). This table is consumed in P4 (OIDC/PAT
+    issuance) but is defined here so a single ``nova idp setup``
+    CloudFormation template provisions the complete identity backend.
+
+Design notes (REQ-335):
+  * All tables use ``BillingMode: PAY_PER_REQUEST`` (on-demand) — the
+    IdP traffic is bursty and unpredictable; provisioned capacity would
+    either throttle or waste money.
+  * PITR (``PointInTimeRecoverySpecification``) is enabled on
+    ``nova-users`` — user records are irreplaceable; continuous backup
+    protects against accidental deletes / corrupt writes. The session /
+    reset / PAT tables are ephemeral (TTL-managed) so PITR is not
+    required there, but enabling it is cheap insurance; we enable it on
+    ``nova-users`` per REQ-335 and leave the others as on-demand only
+    (TTL is the recovery mechanism for those).
+  * TTL attributes (``expires_at``) are epoch seconds — DynamoDB TTL
+    silently deletes expired items in the background (best-effort, do
+    not rely on for access control; the handler also checks ``expires_at``
+    on read).
+
+The fragment is composed into the full ``nova idp setup`` template in
+P4 Wave 8 (``nova idp setup --apply``). The keys in the returned dict
+are CloudFormation logical resource IDs (``NovaUsersTable``, etc.) so
+the composer can merge it directly into a template's ``Resources``
+section.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+def _attribute(name: str, attr_type: str = "S") -> Dict[str, str]:
+    return {"AttributeName": name, "AttributeType": attr_type}
+
+
+def _key_schema(name: str, key_type: str = "HASH") -> Dict[str, str]:
+    return {"AttributeName": name, "KeyType": key_type}
+
+
+def dynamodb_tables_snippet() -> Dict[str, Dict[str, Any]]:
+    """Return a CloudFormation fragment defining the four IdP DynamoDB tables.
+
+    The returned dict maps logical resource IDs to CloudFormation
+    resource dicts (``Type: AWS::DynamoDB::Table``). It is intended to be
+    merged into the ``Resources`` block of the full
+    ``nova idp setup`` template (P4 Wave 8).
+
+    Tables:
+      * ``NovaUsersTable`` (``nova-users``)
+      * ``NovaSessionsTable`` (``nova-sessions``)
+      * ``NovaPasswordResetsTable`` (``nova-password-resets``)
+      * ``NovaPatsTable`` (``nova-pats``)
+
+    All tables are ``PAY_PER_REQUEST`` (on-demand). PITR is enabled on
+    ``nova-users`` (REQ-335). TTL is enabled on the three ephemeral
+    tables (``expires_at`` epoch-seconds attribute).
+    """
+    return {
+        # -----------------------------------------------------------------
+        # nova-users — the user directory (PK user_id, GSI1 email).
+        # PITR enabled: user records are irreplaceable.
+        # -----------------------------------------------------------------
+        "NovaUsersTable": {
+            "Type": "AWS::DynamoDB::Table",
+            "Properties": {
+                "TableName": "nova-users",
+                "BillingMode": "PAY_PER_REQUEST",
+                "KeySchema": [
+                    _key_schema("user_id", "HASH"),
+                ],
+                "AttributeDefinitions": [
+                    _attribute("user_id", "S"),
+                    _attribute("email", "S"),
+                ],
+                "GlobalSecondaryIndexes": [
+                    {
+                        "IndexName": "email-index",
+                        "KeySchema": [_key_schema("email", "HASH")],
+                        "Projection": {"ProjectionType": "ALL"},
+                    },
+                ],
+                "PointInTimeRecoverySpecification": {
+                    "PointInTimeRecoveryEnabled": True,
+                },
+                # Attribute shape (for documentation / the setup --dry-run
+                # summary; DynamoDB is schemaless so this is not enforced):
+                #   user_id       String  (PK)
+                #   email         String  (GSI1 hash, unique)
+                #   password_hash String  (Argon2id, never the raw password)
+                #   owner         String
+                #   roles         List
+                #   created_at    String  (ISO-8601)
+                "AttributeShape": {
+                    "user_id": "String",
+                    "email": "String",
+                    "password_hash": "String",
+                    "owner": "String",
+                    "roles": "List",
+                    "created_at": "String",
+                },
+            },
+        },
+        # -----------------------------------------------------------------
+        # nova-sessions — session tokens (PK session_id, GSI1 user_id).
+        # TTL: expires_at (epoch seconds). Sessions live 24h.
+        # -----------------------------------------------------------------
+        "NovaSessionsTable": {
+            "Type": "AWS::DynamoDB::Table",
+            "Properties": {
+                "TableName": "nova-sessions",
+                "BillingMode": "PAY_PER_REQUEST",
+                "KeySchema": [
+                    _key_schema("session_id", "HASH"),
+                ],
+                "AttributeDefinitions": [
+                    _attribute("session_id", "S"),
+                    _attribute("user_id", "S"),
+                ],
+                "GlobalSecondaryIndexes": [
+                    {
+                        "IndexName": "user_id-index",
+                        "KeySchema": [_key_schema("user_id", "HASH")],
+                        "Projection": {"ProjectionType": "ALL"},
+                    },
+                ],
+                "TimeToLiveSpecification": {
+                    "AttributeName": "expires_at",
+                    "Enabled": True,
+                },
+                "AttributeShape": {
+                    "session_id": "String",
+                    "user_id": "String",
+                    "expires_at": "String (epoch seconds, TTL)",
+                    "created_at": "String (ISO-8601)",
+                },
+            },
+        },
+        # -----------------------------------------------------------------
+        # nova-password-resets — reset tokens (PK reset_token).
+        # TTL: expires_at (epoch seconds). Tokens live 15 min.
+        # -----------------------------------------------------------------
+        "NovaPasswordResetsTable": {
+            "Type": "AWS::DynamoDB::Table",
+            "Properties": {
+                "TableName": "nova-password-resets",
+                "BillingMode": "PAY_PER_REQUEST",
+                "KeySchema": [
+                    _key_schema("reset_token", "HASH"),
+                ],
+                "AttributeDefinitions": [
+                    _attribute("reset_token", "S"),
+                ],
+                "TimeToLiveSpecification": {
+                    "AttributeName": "expires_at",
+                    "Enabled": True,
+                },
+                "AttributeShape": {
+                    "reset_token": "String",
+                    "user_id": "String",
+                    "expires_at": "String (epoch seconds, TTL; 15 min)",
+                },
+            },
+        },
+        # -----------------------------------------------------------------
+        # nova-pats — personal access tokens (PK jti, GSI1 sub, GSI2 pat_hash).
+        # Consumed in P4 (OIDC/PAT issuance) but defined here so the single
+        # CloudFormation template provisions the complete identity backend.
+        # TTL: expires_at (epoch seconds).
+        # -----------------------------------------------------------------
+        "NovaPatsTable": {
+            "Type": "AWS::DynamoDB::Table",
+            "Properties": {
+                "TableName": "nova-pats",
+                "BillingMode": "PAY_PER_REQUEST",
+                "KeySchema": [
+                    _key_schema("jti", "HASH"),
+                ],
+                "AttributeDefinitions": [
+                    _attribute("jti", "S"),
+                    _attribute("sub", "S"),
+                    _attribute("pat_hash", "S"),
+                ],
+                "GlobalSecondaryIndexes": [
+                    {
+                        "IndexName": "sub-index",
+                        "KeySchema": [_key_schema("sub", "HASH")],
+                        "Projection": {"ProjectionType": "ALL"},
+                    },
+                    {
+                        "IndexName": "pat_hash-index",
+                        "KeySchema": [_key_schema("pat_hash", "HASH")],
+                        "Projection": {"ProjectionType": "ALL"},
+                    },
+                ],
+                "TimeToLiveSpecification": {
+                    "AttributeName": "expires_at",
+                    "Enabled": True,
+                },
+                "AttributeShape": {
+                    "jti": "String (PK)",
+                    "sub": "String (GSI1; subject / user_id)",
+                    "pat_hash": "String (GSI2; SHA-256 of the PAT for lookup)",
+                    "status": "String (active|revoked)",
+                    "issued_at": "String (ISO-8601)",
+                    "expires_at": "String (epoch seconds, TTL)",
+                    "revoked_at": "String (ISO-8601, present iff status=revoked)",
+                    "claims": "Map (JWT claims payload)",
+                },
+            },
+        },
+    }
+
+
+def table_names() -> Dict[str, str]:
+    """Return the logical→physical table-name mapping (for env-var defaults)."""
+    return {
+        "users": "nova-users",
+        "sessions": "nova-sessions",
+        "password_resets": "nova-password-resets",
+        "pats": "nova-pats",
+    }
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI inspection helper
+    import json
+    import sys
+
+    if "--names" in sys.argv:
+        sys.stdout.write(json.dumps(table_names(), indent=2) + "\n")
+    else:
+        sys.stdout.write(json.dumps(dynamodb_tables_snippet(), indent=2) + "\n")

core/metrics/collector.py

@@ -54,7 +54,8 @@ def _init_store(db_path=None):
             confidence_band TEXT,
             hitl_block INTEGER,
             cost_estimate_usd REAL,
-            decision_id TEXT
+            decision_id TEXT,
+            escalation_reason TEXT
         );
 
         CREATE TABLE IF NOT EXISTS fact_capability (
@@ -110,7 +111,9 @@ def _init_store(db_path=None):
             confidence REAL,
             alternatives TEXT,
             human_override INTEGER,
+            escalation_reason TEXT,
             outcome TEXT,
+            backfilled_at TEXT,
             event_time TEXT,
             PRIMARY KEY (decision_id)
         );
@@ -217,14 +220,15 @@ def collect_run_manifests(db_path=None, runs_dir=None):
             INSERT OR REPLACE INTO fact_run
             (run_id, contract_id, environment, started_at, completed_at,
              exit_code, outcome, confidence_score, confidence_band,
-             hitl_block, cost_estimate_usd, decision_id)
+             hitl_block, cost_estimate_usd, decision_id, escalation_reason)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """, (run_id, manifest.get("contract_id", ""), manifest.get("environment", ""),
               manifest.get("started_at", ""), manifest.get("completed_at", ""),
               manifest.get("exit_code", 0), manifest.get("outcome", ""),
               conf.get("score", 0), conf.get("band", ""),
               1 if hitl.get("block") else 0,
-              manifest.get("cost_estimate_usd", 0), manifest.get("decision_id", "")))
+              manifest.get("cost_estimate_usd", 0), manifest.get("decision_id", ""),
+              manifest.get("escalation_reason")))
         count += 1
     conn.commit()
     conn.close()
@@ -232,7 +236,16 @@ def collect_run_manifests(db_path=None, runs_dir=None):
 
 
 def collect_decision_ledger(db_path=None, ledger_db=None):
-    """Read the Decision Ledger SQLite → fact_decision."""
+    """Read the Decision Ledger SQLite → fact_decision.
+
+    REQ-317: preserves a backfilled outcome. The ledger is append-only
+    and the `nova.ai.decision.made` event always carries outcome=pending
+    (it is emitted before apply). Once `outcome_backfill.backfill()` has
+    transitioned the `fact_decision` row to succeeded/failed, a re-run of
+    the collector must NOT clobber it back to pending. We therefore
+    coalesce: if the existing row has a non-pending outcome, keep it +
+    its backfilled_at; otherwise write pending (the event default).
+    """
     if db_path is None:
         db_path = _STORE_PATH
     if ledger_db is None:
@@ -251,15 +264,27 @@ def collect_decision_ledger(db_path=None, ledger_db=None):
         payload = json.loads(payload_json)
         data = payload.get("data", {})
         decision_id = data.get("decision_id", run_id)
+        # Preserve a backfilled outcome across collector re-runs (REQ-317).
+        existing = conn.execute(
+            "SELECT outcome, backfilled_at FROM fact_decision WHERE decision_id = ?",
+            (decision_id,),
+        ).fetchone()
+        if existing and existing[0] and existing[0] != "pending":
+            outcome = existing[0]
+            backfilled_at = existing[1]
+        else:
+            outcome = data.get("outcome", "pending")
+            backfilled_at = data.get("backfilled_at")
         conn.execute("""
             INSERT OR REPLACE INTO fact_decision
             (decision_id, run_id, chosen_action, confidence, alternatives,
-             human_override, outcome, event_time)
+             human_override, escalation_reason, outcome, backfilled_at, event_time)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """, (decision_id, run_id, data.get("chosen_action", ""),
               data.get("confidence", 0), json.dumps(data.get("alternatives", {})),
               1 if data.get("human_override") else 0,
-              data.get("outcome", "pending"), event_time))
+              data.get("escalation_reason"),
+              outcome, backfilled_at, event_time))
         count += 1
     conn.commit()
     conn.close()

core/metrics/decision_ledger.py

@@ -224,12 +224,16 @@ def replay_run(run_id, db_path=None):
         line = f"  [{e['seq']}] {e['event_time']} {etype}"
         if etype == "nova.ai.decision.made":
             line += f" confidence={data.get('confidence', '?')} band={data.get('chosen_action', '?')} override={data.get('human_override', '?')}"
+            if data.get("escalation_reason"):
+                line += f" escalation_reason={data.get('escalation_reason')}"
         elif etype == "nova.attestation.recorded":
             line += f" env={data.get('environment', '?')} approver={data.get('approver', '?')} result={data.get('result', '?')}"
         elif etype == "nova.run.completed":
             line += f" exit={data.get('exit_code', '?')} outcome={data.get('outcome', '?')}"
         elif etype == "nova.run.failed":
             line += f" exit={data.get('exit_code', '?')} outcome=failed"
+        elif etype == "nova.outcome.backfilled":
+            line += f" prev={data.get('previous_outcome', '?')} new={data.get('new_outcome', '?')} at={data.get('backfilled_at', '?')}"
         lines.append(line)
     lines.append("=== End replay ===")
     return "\n".join(lines)

core/metrics/outcome_backfill.py

@@ -0,0 +1,213 @@
+"""Nova Outcome Backfill (REQ-317, SPEC §5.8, P3 Wave 2).
+
+The `fact_decision.outcome` column in the metrics cold store is written
+`pending` by the collector (it ingests `nova.ai.decision.made` events,
+which are emitted *before* the run executes the apply). Once the run
+completes (`nova.run.completed`, exit 0) or fails (`nova.run.failed`,
+exit non-zero), the outcome must be transitioned `pending ->
+succeeded`/`failed` so the Post-Pilot AI Decision Accuracy denominator is
+grounded (an outcome that is stuck `pending` cannot be scored).
+
+Architecture (grounded in what the ledger + collector actually do):
+
+  * The Decision Ledger (`core/metrics/decision_ledger.py`) is an
+    **append-only hash-chain** of CloudEvents envelopes — there is no
+    `fact_decision` table *inside* the ledger DB; facts live in the
+    separate collector cold store (`core/metrics/collector.py`,
+    `nova_metrics.db`). The ledger is never UPDATEd in place (that would
+    break the SHA-256 chain — see `verify_chain()`).
+  * Therefore the backfill does TWO things:
+      1. Appends a new audit event `nova.outcome.backfilled` to the
+         ledger (preserves the hash chain; auditable via `replay_run`).
+      2. UPDATEs the `fact_decision` row in the cold store (the row is
+         keyed by `decision_id`; `outcome` + `backfilled_at` are
+         mutable — they are facts, not chain events).
+
+Idempotent + terminal:
+  * If `outcome` is already `succeeded`/`failed` (i.e. not `pending`),
+    the call is a no-op and returns `{"status": "already_backfilled",
+    "existing_outcome": <current>}`. A terminal outcome is NEVER
+    overwritten (defense against double-backfill and against flipping a
+    `succeeded` run to `failed` retroactively or vice versa).
+  * The same `outcome` value is re-asserted harmlessly (still a no-op).
+
+REQ-317: `outcome` ∈ {"succeeded", "failed"} only — `pending` is the
+initial state and may not be written by the backfill (it would undo the
+transition). An invalid value raises `ValueError`.
+
+Future milestones may add `'policy'` to `escalation_reason` (REQ-318);
+this module is scoped to outcome only.
+"""
+
+import datetime
+import json
+import os
+import sqlite3
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from core.metrics.event_envelope import make_event, append_event
+from core.metrics.decision_ledger import append as ledger_append, _LEDGER_PATH
+
+# The collector cold store path is mirrored here so the backfill can be
+# invoked without importing the collector (avoids a circular import:
+# the collector calls into backfill at run.completed/run.failed time).
+_METRICS_DIR = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "metrics",
+)
+_STORE_PATH = os.path.join(_METRICS_DIR, "nova_metrics.db")
+
+_VALID_OUTCOMES = {"succeeded", "failed"}
+_PENDING = "pending"
+
+
+def _iso8601_now():
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _resolve_store_path(store_path: Optional[str | Path]) -> str:
+    if store_path is None:
+        return _STORE_PATH
+    return str(store_path)
+
+
+def _resolve_ledger_path(ledger_path: Optional[str | Path]) -> str:
+    if ledger_path is None:
+        return _LEDGER_PATH
+    return str(ledger_path)
+
+
+def _get_fact_decision(decision_id: str, store_path: str) -> Optional[Dict[str, Any]]:
+    """Read the fact_decision row for decision_id (or None)."""
+    if not os.path.isfile(store_path):
+        return None
+    conn = sqlite3.connect(store_path)
+    conn.row_factory = sqlite3.Row
+    row = conn.execute(
+        "SELECT decision_id, run_id, chosen_action, confidence, alternatives, "
+        "human_override, outcome, event_time FROM fact_decision WHERE decision_id = ?",
+        (decision_id,),
+    ).fetchone()
+    conn.close()
+    if row is None:
+        return None
+    return dict(row)
+
+
+def backfill(
+    decision_id: str,
+    outcome: str,
+    ledger_path: Optional[str | Path] = None,
+    store_path: Optional[str | Path] = None,
+) -> Dict[str, Any]:
+    """Transition fact_decision.outcome from `pending` to `outcome`.
+
+    Args:
+        decision_id: the decision id (== run_id for v1.26).
+        outcome: the terminal outcome; must be in {"succeeded", "failed"}.
+        ledger_path: optional override for the Decision Ledger SQLite DB.
+        store_path: optional override for the collector cold store SQLite DB.
+
+    Returns:
+        A dict describing the result:
+          * success: {"status": "backfilled", "decision_id", "previous_outcome",
+                      "new_outcome", "backfilled_at"}
+          * no-op:   {"status": "already_backfilled", "decision_id",
+                      "existing_outcome", "backfilled_at"}
+
+    Raises:
+        ValueError: if `outcome` is not in {"succeeded", "failed"}.
+        KeyError:   if `decision_id` is not present in fact_decision.
+    """
+    if outcome not in _VALID_OUTCOMES:
+        raise ValueError(
+            f"outcome must be one of {sorted(_VALID_OUTCOMES)}, got: {outcome!r}"
+        )
+
+    sp = _resolve_store_path(store_path)
+    lp = _resolve_ledger_path(ledger_path)
+
+    existing = _get_fact_decision(decision_id, sp)
+    if existing is None:
+        raise KeyError(decision_id)
+
+    current_outcome = existing.get("outcome") or _PENDING
+    backfilled_at = _iso8601_now()
+
+    if current_outcome != _PENDING:
+        # Idempotent + terminal: do NOT overwrite a non-pending outcome.
+        return {
+            "status": "already_backfilled",
+            "decision_id": decision_id,
+            "existing_outcome": current_outcome,
+            "backfilled_at": backfilled_at,
+        }
+
+    run_id = existing.get("run_id") or decision_id
+
+    # 1. UPDATE the fact_decision row in the cold store (mutable fact).
+    conn = sqlite3.connect(sp)
+    # Add backfilled_at column idempotently (schema was added in v1.26 P3 W2;
+    # older cold stores created by P2 lack it — ALTER TABLE is a no-op if
+    # the column already exists).
+    try:
+        conn.execute("ALTER TABLE fact_decision ADD COLUMN backfilled_at TEXT")
+    except sqlite3.OperationalError:
+        pass  # column already exists
+    conn.execute(
+        "UPDATE fact_decision SET outcome = ?, backfilled_at = ? WHERE decision_id = ?",
+        (outcome, backfilled_at, decision_id),
+    )
+    conn.commit()
+    conn.close()
+
+    # 2. Append an audit event to the append-only Decision Ledger (preserves
+    #    the hash chain — the ledger is never UPDATEd in place).
+    try:
+        backfill_data = {
+            "decision_id": decision_id,
+            "previous_outcome": _PENDING,
+            "new_outcome": outcome,
+            "backfilled_at": backfilled_at,
+        }
+        event = make_event(
+            "nova.outcome.backfilled",
+            run_id,
+            existing.get("environment", ""),
+            backfill_data,
+            contract_id=existing.get("contract_id", ""),
+            actor_type="outcome-backfill",
+            actor_id="outcome_backfill",
+        )
+        append_event(event)
+        ledger_append(event, db_path=lp)
+    except Exception:
+        # Metrics emission must never break the backfill — the cold store
+        # UPDATE is the source of truth for the denominator; the ledger
+        # event is audit chrome.
+        pass
+
+    return {
+        "status": "backfilled",
+        "decision_id": decision_id,
+        "previous_outcome": _PENDING,
+        "new_outcome": outcome,
+        "backfilled_at": backfilled_at,
+    }
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("usage: outcome_backfill.py <decision_id> <succeeded|failed>", file=sys.stderr)
+        sys.exit(2)
+    _did = sys.argv[1]
+    _out = sys.argv[2]
+    try:
+        _r = backfill(_did, _out)
+        print(json.dumps(_r, indent=2))
+    except (ValueError, KeyError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)

core/metrics/run_manifest.py

@@ -27,6 +27,27 @@ def _iso8601_now():
     return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
+def _backfill_outcome(decision_id, outcome):
+    """Transition fact_decision.outcome pending -> outcome (REQ-317).
+
+    Best-effort: logs a warning and skips if decision_id is missing or the
+    backfill raises. Never raises — the run is already completing/failing
+    and the manifest write is the source of truth for the run outcome.
+    """
+    if not decision_id:
+        # A run that failed before ai.decision.made was emitted has no
+        # decision to backfill (e.g. a schema-validation failure). Skip
+        # silently rather than pollute stderr on every clean run.
+        return None
+    try:
+        from core.metrics import outcome_backfill
+        return outcome_backfill.backfill(decision_id, outcome)
+    except Exception as exc:  # pragma: no cover - defensive
+        print(f"[run_manifest] outcome backfill skipped for {decision_id}: {exc}",
+              file=sys.stderr)
+        return None
+
+
 def _run_id():
     return f"run-{int(time.time())}-{uuid.uuid4().hex[:8]}"
 
@@ -44,7 +65,7 @@ def start_run(contract_id, environment, stages=None):
     return run_id
 
 
-def complete_run(run_id, contract_id, environment, stages, exit_code, confidence=None, hitl=None, policy=None, cost_estimate_usd=None, decision_id=None):
+def complete_run(run_id, contract_id, environment, stages, exit_code, confidence=None, hitl=None, policy=None, cost_estimate_usd=None, decision_id=None, escalation_reason=None):
     """Emit nova.run.completed + write the per-run manifest JSON.
 
     Args:
@@ -58,6 +79,10 @@ def complete_run(run_id, contract_id, environment, stages, exit_code, confidence
         policy: optional {passed, failed, skipped}
         cost_estimate_usd: optional float
         decision_id: optional string (links to the Decision Ledger)
+        escalation_reason: optional string (REQ-318) — "confidence" when
+            the ai.decision.made band was block; absent/None otherwise.
+            Persisted into the manifest so the collector can write it
+            into fact_run (Post-Pilot Human Escalation Frequency denom).
     """
     started_at = stages[0].get("started_at", _iso8601_now()) if stages else _iso8601_now()
     completed_at = _iso8601_now()
@@ -83,6 +108,8 @@ def complete_run(run_id, contract_id, environment, stages, exit_code, confidence
         manifest["cost_estimate_usd"] = cost_estimate_usd
     if decision_id:
         manifest["decision_id"] = decision_id
+    if escalation_reason:
+        manifest["escalation_reason"] = escalation_reason
 
     os.makedirs(_RUNS_DIR, exist_ok=True)
     manifest_path = os.path.join(_RUNS_DIR, f"{run_id}.json")
@@ -92,6 +119,14 @@ def complete_run(run_id, contract_id, environment, stages, exit_code, confidence
     event_type = "nova.run.completed" if exit_code == 0 else "nova.run.failed"
     emit(event_type, run_id, environment, manifest, contract_id=contract_id)
 
+    # REQ-317: backfill fact_decision.outcome pending -> succeeded/failed
+    # after the run completes. The decision_id links the run to the
+    # Decision Ledger entry written by ai.decision.made. Best-effort: a
+    # run that failed before ai.decision.made was emitted has no
+    # decision_id and the backfill is a no-op (the run outcome is still
+    # captured in the manifest above).
+    backfill_result = _backfill_outcome(decision_id, outcome)
+
     return manifest
 
 

core/mode_resolver.py

@@ -0,0 +1,94 @@
+"""Nova client-mode resolver (P1, REQ-327, D-226).
+
+Priority: --mode flag → NOVA_CLIENT_MODE env → credential type → TTY.
+No silent fallbacks: every return carries a non-empty selection_reason.
+
+INV-13: invalid env values are ignored + warned, then fall through.
+INV-14: credential_type developer_pat/nova_oidc_token + TTY →
+interactive; + no-TTY → agent. TTY check is sys.stdin.isatty() (D-226).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+log = logging.getLogger("nova.mode_resolver")
+
+_VALID_MODES = ("agent", "interactive")
+_CRED_MODE_TYPES = ("developer_pat", "nova_oidc_token")
+
+
+def resolve_mode(
+    flag: Optional[str] = None,
+    env_var: Optional[str] = None,
+    credential_type: Optional[str] = None,
+    stdin_isatty: bool = False,
+) -> Tuple[str, str]:
+    """Return (mode, selection_reason) honoring D-226 priority."""
+    if flag is not None and flag in _VALID_MODES:
+        return flag, "flag"
+    if env_var is not None and env_var != "":
+        if env_var in _VALID_MODES:
+            return env_var, "env"
+        log.warning(
+            "NOVA_CLIENT_MODE=%r invalid (expected one of %s); ignoring",
+            env_var,
+            _VALID_MODES,
+        )
+    if credential_type in _CRED_MODE_TYPES:
+        mode = "interactive" if stdin_isatty else "agent"
+        return mode, f"credential:{credential_type}"
+    mode = "interactive" if stdin_isatty else "agent"
+    return mode, "tty"
+
+
+def _read_credential_type(path: Path) -> Optional[str]:
+    """Read the active credential's type from ~/.nova/credentials.json."""
+    try:
+        data = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError):
+        return None
+    active_jti = data.get("active_credential_jti")
+    for cred in data.get("credentials", []) or []:
+        if cred.get("jti") == active_jti:
+            return cred.get("type")
+    return None
+
+
+def resolve_mode_from_env(credential_type: Optional[str] = None) -> Tuple[str, str]:
+    """Resolve mode using sys.argv, NOVA_CLIENT_MODE, credentials, and TTY.
+
+    Best-effort --mode scan of sys.argv (no full argparse); env var;
+    ~/.nova/credentials.json active credential type; sys.stdin.isatty().
+    """
+    flag: Optional[str] = None
+    argv = sys.argv[1:]
+    for i, tok in enumerate(argv):
+        if tok == "--mode" and i + 1 < len(argv):
+            flag = argv[i + 1]
+            break
+        if tok.startswith("--mode="):
+            flag = tok.split("=", 1)[1]
+            break
+    env_var = os.environ.get("NOVA_CLIENT_MODE")
+    if env_var is not None and env_var == "":
+        env_var = ""
+    if credential_type is None:
+        cred_path = Path.home() / ".nova" / "credentials.json"
+        credential_type = _read_credential_type(cred_path)
+    return resolve_mode(
+        flag=flag,
+        env_var=env_var,
+        credential_type=credential_type,
+        stdin_isatty=sys.stdin.isatty(),
+    )
+
+
+if __name__ == "__main__":
+    mode, reason = resolve_mode_from_env()
+    print(f"mode={mode} reason={reason}")

core/policy_engine.py

@@ -0,0 +1,212 @@
+"""Nova Policy Engine Registry (REQ-291, v1.25).
+
+The swappable policy-engine abstraction. A Python Protocol (PEP 544)
+defines the engine contract; a registry selects the active engine from
+``config.json``'s ``policy.engine`` key. This is the **swap boundary**
+(ARCHITECTURE.md §12.7) — the confidence signal and pipeline never
+import an engine directly; they go through the registry. A future
+``OpaEngine`` implements the same protocol without touching the
+confidence signal, the PCR schema, or the pipeline.
+
+The protocol is minimal (3 members) by design:
+
+- ``name`` — the engine's registry key (matches ``config.json.policy.engine``).
+- ``is_configured()`` — returns False when the engine's binary is absent
+  (the registry's caller must skip gracefully, emitting SKIPPED PCRs).
+- ``evaluate(payload, policy_dir, contract_id)`` — runs the engine's
+  policies over ``payload`` and returns a ``list[dict]`` where each dict
+  conforms to ``schemas/policy_check_result.schema.json``.
+
+A ``NullEngine`` is the fallback when the ``policy`` key is absent from
+``config.json`` (backward compatibility for tests that don't set the
+key — it emits a single SKIPPED PCR so the confidence signal proceeds
+with a neutral ``policy`` input).
+
+Engine enum reuse (D-116): kyverno-json PCR records carry
+``engine: "kyverno"`` (no new enum value). The ``engine`` field records
+the policy-engine *family*, not the specific binary. The K8s Kyverno
+adapter and the kyverno-json engine are distinguished by ``ruleId``
+prefix (``KYVERNO_`` vs ``KJ_``).
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Callable, Protocol, Union, runtime_checkable
+
+import datetime
+
+
+def _iso8601_now() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+Payload = Union[dict, list, str]
+
+
+@runtime_checkable
+class PolicyEngine(Protocol):
+    """The swap boundary for policy engines.
+
+    Implementations: ``KyvernoJsonEngine`` (adapters/kyverno-json/),
+    ``NullEngine`` (this module), future ``OpaEngine``.
+    """
+
+    @property
+    def name(self) -> str: ...
+
+    def is_configured(self) -> bool: ...
+
+    def evaluate(self, payload: Payload, policy_dir: Path,
+                 contract_id: str) -> list[dict]: ...
+
+
+def _skipped_pcr(rule_id: str, message: str, contract_id: str) -> dict:
+    return {
+        "contractId": contract_id,
+        "evaluatedAt": _iso8601_now(),
+        "engine": "kyverno",
+        "ruleId": rule_id,
+        "severity": "info",
+        "result": "skipped",
+        "message": message,
+        "evidence": {},
+        "resourceRef": "",
+    }
+
+
+class NullEngine:
+    """Fallback when ``config.json.policy`` is absent.
+
+    Emits a single SKIPPED PCR with ``ruleId: NULL_ENGINE_INACTIVE`` so
+    the confidence signal's ``policy`` input is non-null (the per-input
+    score for a single SKIPPED PCR is 1.0 — skipped counts as pass per
+    ``core/confidence_signal.py:84-89``). This keeps existing tests
+    passing when the ``policy`` key is not set.
+    """
+
+    name = "null"
+
+    def is_configured(self) -> bool:
+        return False
+
+    def evaluate(self, payload: Payload, policy_dir: Path,
+                 contract_id: str) -> list[dict]:
+        return [_skipped_pcr(
+            "NULL_ENGINE_INACTIVE",
+            "NullEngine active — the `policy` key is absent from config.json. "
+            "No policy engine is configured; the confidence signal proceeds with "
+            "a neutral SKIPPED policy input.",
+            contract_id,
+        )]
+
+
+_REGISTRY: dict[str, Callable[[], PolicyEngine]] = {}
+
+
+def register(name: str, factory: Callable[[], PolicyEngine]) -> None:
+    """Register an engine factory under ``name``.
+
+    The factory is called lazily by ``get_engine()`` so an engine's
+    binary dependency (e.g. ``kj``) is not required at import time.
+    """
+    _REGISTRY[name] = factory
+
+
+def _load_config_policy() -> dict | None:
+    """Read the ``policy`` object from ``.ciagent/config.json``.
+
+    Returns ``None`` when the file is absent or the ``policy`` key is
+    missing (the caller falls back to ``NullEngine``).
+    """
+    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    cfg = os.path.join(repo_root, ".ciagent", "config.json")
+    if not os.path.isfile(cfg):
+        return None
+    try:
+        with open(cfg, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except (json.JSONDecodeError, OSError):
+        return None
+    return data.get("policy")
+
+
+def get_engine() -> PolicyEngine:
+    """Return the active ``PolicyEngine`` from ``config.json``.
+
+    Reads ``config.json.policy.engine`` (default ``"kyverno-json"``).
+    Falls back to ``NullEngine`` when the ``policy`` key is absent
+    (backward compatibility). Raises ``KeyError`` for an unknown engine
+    name (a typo in config — fail loud, not silent).
+    """
+    policy_cfg = _load_config_policy()
+    if policy_cfg is None:
+        return NullEngine()
+    engine_name = policy_cfg.get("engine", "kyverno-json")
+    factory = _REGISTRY.get(engine_name)
+    if factory is None:
+        raise KeyError(
+            f"Unknown policy engine '{engine_name}' in config.json. "
+            f"Registered engines: {sorted(_REGISTRY.keys()) or ['(none)']}. "
+            f"Set policy.engine to a registered name or install the engine adapter."
+        )
+    return factory()
+
+
+def get_policy_root() -> Path:
+    """Return the configured policy root directory (or a default)."""
+    policy_cfg = _load_config_policy()
+    if policy_cfg is None:
+        return Path("adapters/kyverno-json/policies")
+    root = policy_cfg.get("policy_root", "adapters/kyverno-json/policies")
+    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if os.path.isabs(root):
+        return Path(root)
+    return Path(repo_root) / root
+
+
+def _register_builtin(name: str, factory: Callable[[], PolicyEngine]) -> None:
+    register(name, factory)
+
+
+def _autoload_kyverno_json() -> None:
+    """Register the kyverno-json engine if its adapter is importable.
+
+    The adapter directory uses a hyphen (``adapters/kyverno-json/``),
+    so a plain ``import`` is not possible. Load the module by file path
+    via ``importlib.util``. Lazy import so ``core/policy_engine.py``
+    does not require ``adapters/kyverno-json/`` at import time (the
+    adapter imports ``yaml``, which may be unavailable in minimal test
+    envs).
+    """
+    try:
+        import importlib.util
+        repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        adapter_path = os.path.join(
+            repo_root, "adapters", "kyverno-json", "kyverno_json_engine.py"
+        )
+        if not os.path.isfile(adapter_path):
+            return
+        spec = importlib.util.spec_from_file_location(
+            "kyverno_json_engine", adapter_path
+        )
+        if spec is None or spec.loader is None:
+            return
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        engine_cls = getattr(mod, "KyvernoJsonEngine")
+        _register_builtin("kyverno-json", engine_cls)
+    except Exception:
+        pass
+
+
+_autoload_kyverno_json()
+
+
+if __name__ == "__main__":
+    eng = get_engine()
+    print(json.dumps({
+        "engine": eng.name,
+        "is_configured": eng.is_configured(),
+        "policy_root": str(get_policy_root()),
+    }, indent=2))

core/regression_verify.py

@@ -601,16 +601,17 @@ def _check_cap_024_deck_structure() -> Tuple[Status, str]:
     """
     import os
     deck_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                              "docs", "presentations", "nova-autonomous-cloud-delivery.md")
+                              "docs", "presentations", "nova-autonomous-cloud-delivery-marp.md")
     if not os.path.isfile(deck_path):
         return "Skipped", "unified deck not found"
     with open(deck_path) as f:
         content = f.read()
     slide_count = content.count("## Slide ")
-    if slide_count < 18 or slide_count > 19:
+    if slide_count < 18 or slide_count > 20:
-        return "Broken", f"deck has {slide_count} main slides (expected 18-19)"
+        return "Broken", f"deck has {slide_count} main slides (expected 18-20)"
     has_recap = "Recap + Ask" in content
-    has_benefit = content.count("Benefit:") >= 10
+    benefit_count = content.count("Benefit:") + content.count('class="benefit"')
+    has_benefit = benefit_count >= 10
     if not (has_recap and has_benefit):
         missing = []
         if not has_recap: missing.append("recap+ask")
@@ -619,6 +620,98 @@ def _check_cap_024_deck_structure() -> Tuple[Status, str]:
     return "Verified", f"deck has {slide_count} slides, recap+ask present, per-slide benefits present"
 
 
+def _check_cap_025_live_pilot_apply() -> Tuple[Status, str]:
+    """CAP-025 (REQ-316): live-pilot-apply pipeline readiness — structural
+    check that the pilot-apply end-to-end pipeline is wired (NOT a live
+    apply; the live apply lands in P4).
+
+    The pilot-apply round-trip is:
+      contract resolve -> adapter compile -> terraform plan -> policy scan
+      -> confidence signal -> terraform apply -> outbox write
+
+    For P3 this is a LOCAL-tier structural-readiness check: the scripts
+    exist + are wired, the core pipeline modules import, the pilot env is
+    bound to a real account (D-203), the DynamoDB L1 primitive is
+    registered (REQ-322), the pilot policies are authored (REQ-315/320),
+    and the outcome-backfill module exists (REQ-317). The live apply
+    against AWS is P4's live-verify (D-093 / G-111 steady state aside).
+    """
+    import json
+
+    # 1. scripts/run_platform.sh exists + contains the pipeline step markers.
+    run_platform = ROOT / "scripts" / "run_platform.sh"
+    if not run_platform.is_file():
+        return "Broken", "scripts/run_platform.sh missing (pilot-apply pipeline driver)"
+    script_text = run_platform.read_text()
+    # Step markers mirrored from the script's own comments + Step headers.
+    required_markers = [
+        "resolve contract",        # Step 2: contract_resolver
+        "adapter compiles stack",  # Step 3: terraform adapter
+        "terraform init",          # Step 4: terraform plan
+        "terraform plan",          # Step 4: terraform plan
+        "policy scan",             # Step 5: runtime policy scan (Wiz/Checkov)
+        "confidence signal",       # Step 7: confidence_signal compute
+        "terraform apply",         # Step 5: terraform apply (--apply mode)
+        "outbox",                  # outbox write (Step 8)
+    ]
+    missing_markers = [m for m in required_markers if m not in script_text]
+    if missing_markers:
+        return "Broken", f"run_platform.sh missing step markers: {missing_markers}"
+
+    # 2. core pipeline modules importable.
+    for mod_name in (
+        "core.contract_resolver",
+        "adapters.terraform.adapter",
+        "core.confidence_signal",
+        "core.outbox_writer",
+    ):
+        try:
+            importlib.import_module(mod_name)
+        except Exception as exc:  # noqa: BLE001
+            return "Broken", f"pipeline module not importable: {mod_name} ({type(exc).__name__}: {exc})"[:200]
+
+    # 3. dev env bound to the real pilot account (D-203).
+    dev_env_path = ROOT / "core" / "environments" / "dev.json"
+    if not dev_env_path.is_file():
+        return "Broken", "core/environments/dev.json missing"
+    try:
+        dev_env = json.loads(dev_env_path.read_text())
+    except Exception as exc:  # noqa: BLE001
+        return "Broken", f"dev.json parse failed: {exc}"[:200]
+    account_id = dev_env.get("account_id")
+    if account_id != "581513795199":
+        return "Broken", f"dev env not bound to real account (D-203): account_id={account_id!r}"
+
+    # 4. DynamoDB L1 primitive registered (REQ-322).
+    registry_path = ROOT / "modules" / "registry.json"
+    if not registry_path.is_file():
+        return "Broken", "modules/registry.json missing"
+    try:
+        registry = json.loads(registry_path.read_text())
+    except Exception as exc:  # noqa: BLE001
+        return "Broken", f"registry.json parse failed: {exc}"[:200]
+    if "dynamodb" not in registry:
+        return "Broken", "dynamodb L1 primitive not registered (REQ-322)"
+
+    # 5. pilot policies authored (REQ-315/320).
+    pilot_policies = [
+        ROOT / "adapters" / "kyverno-json" / "policies" / "pilot-readiness" / "no-placeholder-account.json",
+        ROOT / "adapters" / "kyverno-json" / "policies" / "settlement-finality" / "all-matches-committed.json",
+    ]
+    missing_policies = [str(p.relative_to(ROOT)) for p in pilot_policies if not p.is_file()]
+    if missing_policies:
+        return "Broken", f"pilot policies not authored (REQ-315/320): {missing_policies}"
+
+    # 6. outcome-backfill module exists (REQ-317).
+    outcome_backfill = ROOT / "core" / "metrics" / "outcome_backfill.py"
+    if not outcome_backfill.is_file():
+        return "Broken", "outcome backfill not implemented (REQ-317)"
+
+    return ("Verified",
+            "pilot-apply pipeline structurally ready "
+            "(contract->adapter->plan->policy->confidence->apply->outbox)")
+
+
 # Registry: ordered, each entry is (capability_id, name, tier, check_fn).
 # Phase 52 seeds this with 10 local-tier checks; Phase 54 expands it to
 # cover every v1.1->v1.8 advertised capability and adds the live-AWS tier
@@ -672,6 +765,8 @@ CAPABILITY_REGISTRY: List[Tuple[str, str, str, Callable[[], Tuple[Status, str]]]
      _check_cap_023_metrics_collector),
     ("CAP-024", "unified deck structure (slide count, x3, per-slide benefits)", "local",
      _check_cap_024_deck_structure),
+    ("CAP-025", "live-pilot-apply pipeline readiness (contract->apply->outbox)", "local",
+     _check_cap_025_live_pilot_apply),
 ]
 
 

docs/METRICS.md

@@ -19,7 +19,7 @@ numbers. Every metric either has a real source or is explicitly deferred.
 
 ### Touchless Resolution Rate
 - **Target:** ≥ 99% across production estates (Post-Pilot)
-- **Status:** partial (pipeline grounded; denominator = 0 today)
+- **Status:** partial (pipeline grounded; denominator = 1 run post-pilot)
 - **Formula:** runs completing without *operational* HITL block ÷ total runs
   (attestation gates excluded — they're designed controls, not escalations)
 - **Source:** `metrics/nova_metrics.db` `fact_run` (hitl_block column)
@@ -27,20 +27,54 @@ numbers. Every metric either has a real source or is explicitly deferred.
 
 ### Human Escalation Frequency
 - **Target:** < 0.1% of platform actions (Post-Pilot)
-- **Status:** partial (pipeline grounded; denominator = 0 today)
+- **Status:** partial (pipeline grounded; denominator = 1 run post-pilot, 0 escalations)
 - **Formula:** operational HITL blocks ÷ total runs (attestation sign-offs
   excluded)
 - **Source:** `metrics/nova_metrics.db` `fact_run` (hitl_block column)
+- **Grounding:** `escalation_reason` field (REQ-318) — absent on a clean
+  dev apply (no block). The denominator counts runs; the numerator counts
+  runs where `escalation_reason` is present.
 - **Definition-of-success:** `docs/metrics/human_escalation_frequency.md`
 
 ### AI Decision Accuracy
 - **Target:** ≥ 99.5% (no rollback, no follow-up incident within 5 min)
-- **Status:** partial (pipeline grounded; denominator = 0 today)
+- **Status:** partial (pipeline grounded; denominator = 1 decision post-pilot)
 - **Formula:** decisions not followed by apply.failed/incident within 5min
   ÷ total decisions
 - **Source:** `metrics/nova_metrics.db` `fact_decision` (outcome column)
+- **Grounding:** `fact_decision.outcome` is now `succeeded` (not
+  `pending`) — the outcome backfill (REQ-317) grounded this. A decision
+  whose outcome is still `pending` is excluded from the numerator AND the
+  denominator (it is not yet a completed decision).
 - **Definition-of-success:** `docs/metrics/ai_decision_accuracy.md`
 
+#### Post-Pilot Activation (v1.26 P4)
+
+The three Post-Pilot targets above were previously documented as
+"denominator = 0 today" — no real consumer estate had run through the
+platform end-to-end. The v1.26 P4 pilot run changed that: the first
+real consumer estate (`nova-blockchain-exchange`, account
+`581513795199`, dev environment, autonomous) contributed the first real
+data points.
+
+- **Run id:** `blkex-pilot-apply-v0.2` (2026-08-19)
+- **AI Decision Accuracy:** 1 decision (`blkex-pilot-apply-v0.2`),
+  outcome `pending → succeeded` (REQ-317 backfill). Numerator = 1
+  (no apply.failed, no incident), denominator = 1. Future runs
+  accumulate into this denominator.
+- **Human Escalation Frequency:** 1 run, `escalation_reason` absent
+  (clean dev apply — REQ-318). Numerator = 0 escalations, denominator
+  = 1.
+- **Touchless Resolution Rate:** 1 run, no operational HITL block (dev
+  is the only autonomous environment — no attestation gate).
+  Numerator = 1, denominator = 1.
+
+The denominators are now non-zero. Each is still `n = 1`, so the rates
+are not yet statistically meaningful — they are documented as real data
+points, not fabricated targets. See `.ciagent/P4-PILOT-RUN-EVIDENCE.md`
+for the full evidence stream (confidence 0.800 pass, Decision Ledger
+hash chain valid).
+
 ### MTTD / MTTR (platform-run)
 - **Target:** < 60 seconds (p95)
 - **Status:** grounded (platform-run MTTR)
@@ -174,4 +208,18 @@ numbers. Every metric either has a real source or is explicitly deferred.
 | SLA / Unplanned Downtime | D-096 | `placeholder_sla_downtime.csv` |
 | Predictive vs Reactive Ratio | future emitter | `placeholder_predictive_reactive.csv` |
 
-See `docs/METRICS_DEFERRED_ROADMAP.md` for the activation path for each.
+See `docs/METRICS_DEFERRED_ROADMAP.md` for the activation path for each.
+
+---
+
+## v1.25 — Swappable Policy Engine
+
+The policy engine that produces the `PolicyCheckResult` records feeding
+the confidence signal is **swappable** (NORTH_STAR Strategic Objective #2
+— provable trust via a replaceable substrate, not a vendor lock-in).
+The `PolicyEngine` protocol (`core/policy_engine.py`) is the swap
+boundary; `config.json.policy.engine` selects the active engine
+(default `"kyverno-json"`). A future `OpaEngine` implements the same
+protocol without touching the confidence signal, the PCR schema, or
+the pipeline. See `.ciagent/ARCHITECTURE.md` §12.7 for the registry
+diagram.

docs/codeartifact-provisioning.md

@@ -0,0 +1,123 @@
+# CodeArtifact Provisioning — Status + Fallback (REQ-323, CAP-035)
+
+> Phase P1 (cli-substrate), milestone v1.28. Owner: backend-engineer.
+> This document records the CodeArtifact provisioning check outcome for
+> the `nova-cli` wheel + Lambda layer publish pipeline (REQ-323), the
+> required IAM grants, and the fallback wheel-index mode the publish
+> workflow supports when CodeArtifact is not yet provisioned.
+
+## 1. Provisioning check (best-effort, P1 Wave 4 gate)
+
+**Target account:** `581513795199` (the Nova platform account).
+
+**Attempted commands:**
+
+```bash
+aws codeartifact list-domains --region us-east-1
+aws codeartifact describe-repository --domain nova --repository nova-pypi --region us-east-1
+aws codeartifact list-repositories --domain nova --region us-east-1
+```
+
+**Result:** the check could not complete — no AWS credentials were
+available in the P1 execute environment (`Unable to locate credentials.
+You can configure credentials by running `aws configure`.`). This is
+the "fail gracefully" path documented in the task spec: provisioning is
+**not attempted** from this environment because the required IAM grants
+are not confirmed for the execute principal.
+
+**Classification:** P1 blocker for the CodeArtifact mode of the publish
+workflow's wheel-upload step. The workflow ships with a fallback mode
+(see §3) so the pipeline is not blocked on CodeArtifact provisioning —
+it can publish to a private wheel index instead.
+
+## 2. Required IAM grants (for a follow-up provisioning task)
+
+To provision + use CodeArtifact as the wheel index, the principal that
+runs the publish workflow (OIDC role `nova-publish-*` or the spike
+runner) needs the following grants in account `581513795199`:
+
+| Action | Scope (example) | Purpose |
+| --- | --- | --- |
+| `codeartifact:CreateDomain` | `arn:aws:codeartifact:us-east-1:581513795199:domain/nova` | create the `nova` domain |
+| `codeartifact:CreateRepository` | `arn:aws:codeartifact:us-east-1:581513795199:repository/nova/*` | create `nova-pypi` (pypi-format) |
+| `codeartifact:GetRepositoryEndpoint` | `arn:aws:codeartifact:us-east-1:581513795199:repository/nova/nova-pypi` | get the twine/pip endpoint |
+| `codeartifact:GetAuthorizationToken` | `arn:aws:codeartifact:us-east-1:581513795199:domain/nova/*` | mint short-lived upload token |
+| `codeartifact:ReadFromRepository` | `arn:aws:codeartifact:us-east-1:581513795199:repository/nova/nova-pypi` | pip install (consumers + the composite action) |
+| `codeartifact:PublishPackageToRepository` | `arn:aws:codeartifact:us-east-1:581513795199:repository/nova/nova-pypi` | twine upload |
+| `ssm:PutParameter` / `ssm:GetParameter` | `arn:aws:ssm:us-east-1:581513795199:parameter/nova/layer/*` | CAP-035 version↔ARN mapping |
+| `lambda:PublishLayerVersion` | `arn:aws:lambda:us-east-1:581513795199:layer:nova-cli` | Lambda layer publish |
+| `iam:CreateRole` / `iam:PassRole` (already held) | — | only if a dedicated publish OIDC role must be created |
+
+The domain + repository to provision:
+
+- **Domain:** `nova`
+- **Repository:** `nova-pypi` (format: `pypi`)
+- **Endpoint (twine/pip):**
+  `https://nova-581513795199.d.codeartifact.us-east-1.amazonaws.com/pypi/nova-pypi/`
+
+Once provisioned, set the repository secret `NOVA_CODEARTIFACT_DOMAIN=nova`
+on both forges and the publish workflow + composite action will switch
+to CodeArtifact mode automatically (see §3).
+
+## 3. Fallback: private wheel index (`NOVA_WHEEL_INDEX`)
+
+Both the publish workflow (`.github/workflows/publish.yml` and its
+byte-identical mirror on the dev forge) and the composite action
+(`.github/actions/nova-cli/action.yml`) support a **fallback mode** that
+does not require CodeArtifact. The selection is env/secret driven:
+
+| Mode | Trigger | Upload target | Install source |
+| --- | --- | --- | --- |
+| **CodeArtifact** | `NOVA_CODEARTIFACT_DOMAIN` env/secret is set | `aws codeartifact login --tool twine` → twine uploads to the CodeArtifact pypi endpoint | `aws codeartifact login --tool pip` → `pip install nova==<ver>` |
+| **Fallback index** | `NOVA_CODEARTIFACT_DOMAIN` unset; `TWINE_REPOSITORY_URL` + `TWINE_USERNAME` + `TWINE_PASSWORD` set | `twine upload` to `TWINE_REPOSITORY_URL` | `pip install --index-url $NOVA_WHEEL_INDEX nova==<ver>` |
+
+The fallback index can be any PEP 503-compliant simple index — e.g. a
+private package registry hosted on the dev forge, a self-hosted
+`pypiserver`, or a static S3-backed index. The workflow does not hardcode
+the index URL; it is supplied via the `NOVA_WHEEL_INDEX` env var (for
+consumers / the composite action) and `TWINE_REPOSITORY_URL` (for the
+publish step). This keeps the forge/registry choice deployment-specific
+and avoids baking any single hostname into the synced workflow files.
+
+### 3.1 Fallback index shape (when self-hosted)
+
+A minimal PEP 503 simple index served from a private registry is
+sufficient. The only required layout per package:
+
+```
+/nova/
+  index.html                         # links to each version's page
+  /nova-<version>-py3-none-any.whl   # the wheel (publish workflow uploads this)
+```
+
+The publish workflow uploads `dist/nova-<version>-*.whl` via `twine
+upload` to `TWINE_REPOSITORY_URL`; consumers install via
+`pip install --index-url "$NOVA_WHEEL_INDEX" nova==<version>`.
+
+## 4. CAP-035 invariant (unaffected by the index choice)
+
+Regardless of which wheel index is used, the Lambda layer ARN ↔ wheel
+version mapping is recorded in SSM and is the source of truth for
+CAP-035:
+
+```
+/nova/layer/nova-cli/version = "<wheel-version>:<layer-arn>"
+```
+
+e.g. `1.14.0:arn:aws:lambda:us-east-1:581513795199:layer:nova-cli:3`.
+The publish workflow writes this parameter atomically after both the
+wheel upload and the layer publish succeed; if either fails the job
+fails (merge blocked, REQ-323 AC).
+
+## 5. Open follow-ups
+
+1. Provision CodeArtifact domain `nova` + repository `nova-pypi` in
+   `581513795199` once the `codeartifact:*` grants in §2 are attached to
+   the publish OIDC role. Update this document with the confirmed ARN +
+   endpoint.
+2. Set the `NOVA_CODEARTIFACT_DOMAIN` repository secret on both forges
+   to switch the publish workflow + composite action from fallback-index
+   mode to CodeArtifact mode.
+3. Until §1 is done, the fallback index must be provisioned out of band
+   and its URL exposed to consumers via the `NOVA_WHEEL_INDEX` env var
+   (and to the publish workflow via the `TWINE_*` secrets).

docs/consumer-guide.md

@@ -140,10 +140,10 @@ name: microservice
 
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
-| `uses` | string | yes | Reference to the central deployment pipeline, **versioned** with a floating MAJOR+MINOR tag (e.g. `nova/pipelines/contract.yml@v1.19`). Bare or `@main` references are discouraged. See [Versioning](pipeline/versioning). |
+| `id` | string | yes | Short operational acronym (3-6 chars, lowercase + digits + hyphens). Becomes `stack.name`: the Terraform state key (`spike/<id>/<env>/terraform.tfstate`), the outbox event identity, and the resource naming prefix. Stable across deploys and environment promotions. |
-| `module` | string | yes | Module name from the registry — any primitive or module (e.g. `static-assets`, `microservice`, `s3`). See the [module catalog](modules/). |
+| `name` | string | yes | Full human-readable stack name. Becomes `stack.title`: the display name in PR comments, evidence records, and dashboards. |
-| `environment` | string | yes | The platform-managed environment to deploy to (e.g. `dev`). See [Environments](environments/). |
+| `environment` | string | yes | The platform-managed environment to deploy to (`dev`, `qa`, `prod`, or `dr`). See [Environments](environments/). |
-| `inputs` | object | yes | Module-specific inputs (see the module's README). |
+| `infrastructure` | object | yes | Map of modules to deploy, keyed by module name (matching a registry key in `modules/registry.json`). Each entry carries an optional `version` (defaults to latest published) and per-module `inputs`. One entry = single-module deploy; N entries = multi-module manifest. |
 
 ### Module inputs
 
@@ -180,6 +180,7 @@ jobs:
     uses: nova/.github/workflows/deploy.yml@v1.19
     with:
       contract: .nova/contract.yml
+      environment: dev
 ```
 
 That is the entire consumer-side workflow. When you push to `main`:
@@ -229,7 +230,7 @@ flowchart TD
     S5["policy checks<br/>(adapter -&gt; PolicyCheckResult)"] --> S6
     S6["confidence<br/>score + band (dev &gt;= 0.50)"] --> S7
     S7["evidence event<br/>to the audit outbox"] --> S8
-    S8["infrastructure apply<br/>(dev only)"]
+    S8["infrastructure apply<br/>(autonomous in dev;<br/>higher envs apply after HITL)"]
 ```
 
 1. **validate-contract** — validates your contract YAML against the contract
@@ -250,9 +251,10 @@ flowchart TD
    threshold is ≥ 0.50. If the band is `pass`, the pipeline proceeds.
 7. **evidence event** — a hash-chained evidence event is written to the
    audit outbox.
-8. **infrastructure apply** (dev only) — the infrastructure plan is applied,
+8. **infrastructure apply** (autonomous in dev; higher environments apply
-   creating the resources in your AWS account. An evidence event for the
+   after HITL attestation) — the infrastructure plan is applied, creating
-   apply is recorded.
+   the resources in your AWS account. An evidence event for the apply is
+   recorded.
 
 ## Step 6 — What gets created
 
@@ -289,7 +291,14 @@ push your container image to the ECR repo the platform created.
 
 ## Step 8 — Promote to qa / prod
 
-Change `environment` in your contract (the infrastructure stays the same):
+There are **two supported promotion shapes**. Both are valid; pick the one
+that fits your repo's workflow.
+
+### Shape A — edit the environment field (destroy-then-rebuild)
+
+Change `environment` in your contract (the infrastructure stays the same).
+The contract `id` stays stable, so the platform knows this is the same
+stack moving to a new environment:
 
 ```yaml
 id: assets
@@ -301,10 +310,32 @@ infrastructure:
     inputs: { ... }
 ```
 
+**What happens when you change `environment: dev` → `environment: qa`:**
+the platform detects that the environment changed on a known contract `id`.
+Before building the new environment, it **destroys the prior environment's
+resources** (Terraform state key `spike/{id}/dev/`) and records an evidence
+event for the destroy. Only then does it apply the new environment (state
+key `spike/{id}/qa/`). **There is no orphan path** — if the destroy fails,
+the pipeline fails closed (no apply runs, no resources are left behind).
+This is full lifecycle management: the platform never creates a state
+where prior-environment resources are abandoned.
+
 Higher environments require human attestation (a platform-runner deployment
 approval) and higher confidence thresholds. See [Environments](environments/)
 for the full table.
 
+> **Note:** the destroy-then-rebuild runs within the same AWS account (the
+> current platform scaffold uses one account). Cross-account promotion
+> (separate accounts per env) is a future milestone.
+
+### Shape B — per-environment caller workflows (no editing)
+
+Alternatively, keep one contract per environment (or one contract + the
+`environment` workflow input) and run the matching CI job to promote. This
+avoids the destroy step because each environment has its own state from the
+first deploy. See [Per-environment deployment](#per-environment-deployment)
+below for the full pattern.
+
 ## Step 9 — Compliance extensions
 
 Each module lists compliance extension points for the future compliance
@@ -326,8 +357,8 @@ 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-assets.yaml` | The reference example contract (uses `@v1.19`). |
+| Sample contract | `contracts/static-assets.yml` | The reference example contract (used with caller workflow `@v1.19`). |
-| Sample contract | `contracts/microservice.yaml` | The microservice example contract (uses `@v1.19`). |
+| Sample contract | `contracts/microservice.yml` | The microservice example contract (used with caller workflow `@v1.19`). |
 | 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. |
 | Angine adapter | `adapters/terraform/adapter.py` | Compiles stack instances to infrastructure. |
@@ -395,6 +426,11 @@ separately (or left running to monitor the decommissioned stack's
 endpoints going dark).
 ## Per-environment deployment
 
+> **This is Shape B** (the alternative to [Shape A's edit-and-destroy
+> path](#step-8--promote-to-qa--prod) in Step 8). Shape B avoids the
+> destroy step because each environment has its own state from the first
+> deploy — no prior environment to tear down.
+
 Nova 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

docs/presentations/README.md

@@ -2,147 +2,184 @@
 
 Leadership-facing presentation decks for the Nova platform.
 
-## The 4-step slide creation process
+## The 3-step slide creation process
 
-Every presentation in this folder is produced by the same four-step process.
+Every presentation in this folder is produced by the same three-step
-**Never edit the Marp deck, the PPTX, or the talking points directly** —
+process. **Never edit the rendered HTML, either PPTX, or the talking
-always start from the full markdown source of truth (Step 1), synthesize the
+points directly** — always start from the Marp deck source of truth
-Marp deck (Step 2), export to HTML + PPTX (Step 3), then distill the talking
+(Step 1), render it (Step 2), then distill the talking points (Step 3).
-points (Step 4). This keeps a reviewable, plain-text source of truth for
+This keeps a reviewable, plain-text source of truth for every deck and a
-every deck and a presenter-ready cue sheet for delivery.
+presenter-ready cue sheet for delivery.
 
 ```
-Step 1: full markdown       Step 2: Marp deck           Step 3: HTML + PPTX         Step 4: Talking points
+Step 1: Author the deck       Step 2: Render              Step 3: Talking points
-(source of truth)    ──►    (lean, 21 slides)    ──►    (rendered)           ──►    (presenter cues)
+(source of truth)       ──►   (HTML + dual PPTX)     ──►   (presenter cues)
-*.md                        *-marp.md                   *.html / *.pptx             *-talking-points.md
+*-marp.md                      *.html                       *-talking-points.md
-+ speaker notes             + embedded PNG diagrams                                 + 3-6 bullets per slide
++ ## Slide N — Title          + mermaid PNGs               + 3-6 bullets per slide
-+ mermaid code blocks       + Marp frontmatter                                     + key takeaway per slide
++ <!-- Speaker notes: -->     + MARP PPTX (image-of-slide)  + key takeaway per slide
-                            + no speaker notes                                     + indexed by Marp slide #
++ <!-- Talking points: -->    + python PPTX (structured)    + indexed by slide #
-                            + no maturity badges                                   + content distilled from Step 1
++ <div class="benefit">       + base64-inlined HTML         + content distilled from
-                            + no version in footer
++ embedded PNG diagrams        (self-contained)              the Marp deck
 ```
 
-### Step 1 — Full markdown (source of truth)
+### Step 1 — Author the deck (source of truth)
 
-**File convention:** `<deck-name>.md` (e.g. `nova-autonomous-cloud-delivery.md`).
+**File convention:** `<deck-name>-marp.md` (e.g.
+`nova-autonomous-cloud-delivery-marp.md`).
 
-Write the complete deck as a standard markdown file. This is the **source of
+This is the **sole source of truth** — the Marp deck that is both authored
-truth** — it contains:
+and rendered. It contains:
 
-- Every slide as an `## Slide N — Title` H2 section.
+- **Marp frontmatter** at the top: `marp: true`, `theme: default`,
+  `paginate: true`, `size: 16x9`, a header/footer, and an inline `style:`
+  block carrying the S&P palette (`#D6002A` red, `#1B1B1B` black, the
+  `section.title` rule). The styling is **inline** — no standalone theme
+  CSS is loaded at render time.
+- Every slide as an `## Slide N — Title` (or `## Appendix A1 — Title`) H2
+  section. The H1 title slide precedes slide 1.
 - Tight bullets with leadership-relevant content.
-- A `> **Speaker notes:**` block at the end of each slide with the nuance,
+- **Speaker notes** as `<!-- Speaker notes: ... -->` HTML comments at the
-  the "who cares and why," and the honesty caveats.
+  end of each slide. Marp excludes HTML comments from the rendered slide;
-- Mermaid diagrams as ```` ```mermaid ```` fenced code blocks (these render
+  they are for authors/presenters only.
-  on GitHub/Pages but not in Marp — Step 2 converts them to images).
+- **Talking points** as `<!-- Talking points: ... -->` HTML comments (also
-- An honest "shipped vs. deferred" framing: every "available today" claim is
+  excluded from rendering — Step 3 mirrors them into a standalone cue
-  grounded in shipped/verified work; every "deferred" item is explicitly
+  sheet).
+- **Benefit callouts** as `<div class="benefit">...</div>` (styled by the
+  inline `style:` block — italic, S&P-red top border). No `**Benefit:**`
+  text prefixes.
+- Mermaid diagrams **pre-rendered to PNG** under `assets/png/` and embedded
+  with `![w:1000](assets/png/<name>.png)` (or `h:480 class:tall` for tall
+  images). The `.mmd` sources live under `assets/mmd/`.
+- **No maturity badges**, **no version in the footer**, **no internal
+  decision/requirement IDs or `.py` file paths** in the slide bodies
+  (those live in the `.ciagent/` files only; speaker-note HTML comments are
+  exempt).
+- An honest "shipped vs. deferred" framing: every "available today" claim
+  is grounded in shipped/verified work; every "deferred" item is explicitly
   marked with the blocking work in plain language.
 
-**Why this file is the source of truth:** it is reviewable in any markdown
+**Why the Marp deck is the source of truth:** it is reviewable in any
-viewer, diffs cleanly in git, and carries the full reasoning (speaker notes)
+markdown viewer, diffs cleanly in git, and carries the full reasoning
-that a presenter needs. The Marp deck and PPTX are *derived artifacts* — if a
+(speaker notes) that a presenter needs. The HTML and PPTX are *derived
-fact is wrong, fix it here and re-run Steps 2 and 3.
+artifacts* — if a fact is wrong, fix it here and re-run Step 2.
 
-### Step 2 — Marp deck synthesis
+> **`nova-sp-theme.css` is RETIRED from render.** The standalone theme
+> stylesheet under `assets/nova-sp-theme.css` is kept as a **reference
+> only** and is **not loaded at render time**. The live styling is the
+> inline `style:` block in the `-marp.md` frontmatter. Do NOT pass the CSS
+> via `--theme`; it is not in the render path.
 
-**File convention:** `<deck-name>-marp.md` (e.g. `nova-autonomous-cloud-delivery-marp.md`).
+### Step 2 — Render (HTML + dual PPTX)
 
-Synthesize the full markdown into a lean Marp deck:
+`bash scripts/render_slides.sh [deck-name]` renders the Marp deck
+end-to-end:
 
-- **Marp frontmatter** at the top: `marp: true`, `theme: nova-sp`,
+1. **Mermaid PNGs** — each `assets/mmd/*.mmd` → `assets/png/*.png`
-  `paginate: true`, `size: 16x9`, a header/footer, and an inline `style:`
+   (S&P-themed via `sp-theme.json`, 2x scale, transparent background).
-  block for fonts, colors, tables.
+2. **MARP HTML** — `*-marp.md` → `*.html` (S&P inline style, Marp default
-- **No speaker notes.** The Marp deck is what the audience sees; the
+   theme). Pinned `@marp-team/marp-cli@4.5.0`.
-  speaker notes live only in the Step 1 source of truth.
+3. **MARP PPTX** — `*-marp.md` → `*.pptx` (image-of-slide PPTX; the primary
-- **Mermaid diagrams → PNG images.** Marp does not render mermaid fenced
+   release attachment).
-  blocks natively. Extract each mermaid block from Step 1 into a `.mmd`
+4. **Inline images** — `scripts/inline_images.py` rewrites the HTML to
-  source file under `assets/mmd/`, render it to PNG under `assets/png/`,
+   base64-embed every `assets/` image so the HTML is self-contained (no
-  and embed it with `![w:1000](assets/png/<name>.png)`.
+   external asset folder needed for redistribution).
-- **`<!-- _class: title -->` + `<!-- _paginate: false -->`** on title and
+5. **python PPTX** — `scripts/render_pptx.py` produces a second,
-  closing slides for the dark-background title style.
+   structured, editable PPTX (`*-python.pptx`) with native text boxes,
-- **No maturity badges.** The deck no longer uses `<span class="badge">`
+   native tables, embedded pictures, and italic benefit callouts.
-  spans. Deferred items are named in plain language with their blocking
+6. **Stage** — all rendered artifacts (PNGs + HTML + both PPTX) are
-  work, not tagged with a badge.
+   `git add`-ed for commit.
-- **No version in the footer.** The footer carries the deck title only.
-- **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 also committed to the repo** as a first-class binary artifact and is
-attached to the phase's release via `scripts/attach_release_asset.py`.
 
 ```bash
-CHROME_PATH=/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome \
+bash scripts/render_slides.sh nova-autonomous-cloud-delivery
-  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. PPTX export requires
+Both the HTML and both PPTX files are committed to the repo; the MARP
-`--allow-local-files` so the local PNG diagrams are embedded in the file.
+PPTX is also attached to the phase's release via
-The render + commit + attach pipeline is automated by `scripts/render_slides.sh`.
+`scripts/attach_release_asset.py`.
 
-### Step 4 — Talking points (presenter cues)
+#### Dual-PPTX output
+
+| PPTX | File | Render | Purpose |
+|---|---|---|---|
+| **MARP PPTX** | `*.pptx` | `@marp-team/marp-cli` (Chrome screenshot of each slide) | Image-of-slide; the primary release attachment (pixel-perfect, not editable) |
+| **python PPTX** | `*-python.pptx` | `scripts/render_pptx.py` (python-pptx) | Structured, editable PPTX (native text boxes, tables, pictures) for comparison/editing |
+
+### Step 3 — Talking points (presenter cues)
 
 **File convention:** `<deck-name>-talking-points.md` (e.g.
 `nova-autonomous-cloud-delivery-talking-points.md`).
 
-Distill the source of truth (Step 1) into presenter-ready cues, indexed by
+Distill the deck's `<!-- Talking points: -->` HTML comments into
-the Marp deck (Step 2) slide structure:
+presenter-ready cues, indexed by the Marp deck (Step 1) slide structure:
 
 - **One section per Marp slide** — `## Slide N — Title`, matching the Marp
   deck's 20 main + 1 appendix slide structure exactly.
-- **3-6 talking point bullets per slide** — punchy, actionable cues distilled
+- **3-6 talking point bullets per slide** — punchy, actionable cues
-  from the source markdown's speaker notes.
+  distilled from the Marp deck's `<!-- Talking points: -->` comments.
 - **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
+- **No content duplication** — the talking points reference the Marp
-  for visual context and the source markdown for full detail.
+  slides for visual context.
 
 ## Directory layout
 
 ```
 docs/presentations/
 ├── README.md                                  ← this file
-├── nova-autonomous-cloud-delivery.md                 ← Step 1: full source of truth (20 main slides + speaker notes)
+├── nova-autonomous-cloud-delivery-marp.md            ← Step 1: sole source of truth (title + 20 main + 1 appendix = 22 slides + speaker notes + talking points)
-├── nova-autonomous-cloud-delivery-marp.md            ← Step 2: Marp deck (20 main + 1 appendix = 21 slides)
+├── nova-autonomous-cloud-delivery.html               ← Step 2: rendered HTML (committed, S&P inline style, base64-inlined images)
-├── nova-autonomous-cloud-delivery.html               ← Step 3: rendered HTML (committed, S&P-themed)
+├── nova-autonomous-cloud-delivery.pptx               ← Step 2: MARP PPTX (image-of-slide, primary release attachment)
-├── nova-autonomous-cloud-delivery.pptx               ← Step 3: rendered PPTX (committed, S&P-themed)
+├── nova-autonomous-cloud-delivery-python.pptx        ← Step 2: python-pptx (structured, editable)
-├── nova-autonomous-cloud-delivery-talking-points.md  ← Step 4: presenter cues (19 sections)
+├── nova-autonomous-cloud-delivery-talking-points.md  ← Step 3: presenter cues (21 sections)
 └── assets/
-    ├── nova-sp-theme.css                       ← S&P Global Energy Marp theme (all slide chrome)
+    ├── nova-sp-theme.css                       ← RETIRED from render — reference only (not loaded; live styling is the inline `style:` block)
     ├── puppeteer-config.json                   ← no-sandbox config for mmdc
-    ├── mmd/                                     ← mermaid source files (Step 2 input)
+    ├── mmd/                                    ← mermaid source files (Step 2 input)
-    │   ├── sp-theme.json                         ← S&P Red/Black/White theme (mermaid-cli --configFile)
+    │   ├── sp-theme.json                        ← S&P Red/Black/White theme (mermaid-cli --configFile)
     │   └── ... (per-slide .mmd files)
-    └── png/                                     ← rendered mermaid PNGs (committed, S&P-themed)
+    └── png/                                    ← rendered mermaid PNGs (committed, S&P-themed, 2x, transparent)
 ```
 
+## Tooling & scripts
+
+| Script | Purpose |
+|---|---|
+| `scripts/render_slides.sh` | End-to-end render: mermaid PNGs → MARP HTML + PPTX → base64-inlined HTML → python-pptx PPTX → stage all artifacts. Pinned `@marp-team/marp-cli@4.5.0` + `@mermaid-js/mermaid-cli@11.16.0`. |
+| `scripts/inline_images.py` | Rewrites the rendered HTML to base64-embed every `assets/` image (self-contained HTML for redistribution). |
+| `scripts/render_pptx.py` | Produces the structured, editable `*-python.pptx` (native text boxes, tables, pictures, italic benefit callouts) via `python-pptx`. |
+| `scripts/attach_release_asset.py` | Attaches the MARP PPTX to the phase's release. |
+
+| Dependency | Where declared | Purpose |
+|---|---|---|
+| `@marp-team/marp-cli@4.5.0` | `scripts/render_slides.sh` (pinned) | Marp → HTML + PPTX |
+| `@mermaid-js/mermaid-cli@11.16.0` | `scripts/render_slides.sh` (pinned) | Mermaid → PNG |
+| `python-pptx>=0.6.23` | `pyproject.toml` `[project.optional-dependencies] slides` | Structured PPTX (`pip install -e ".[slides]"`) |
+
 ## Conventions
 
-### Appendix structure
+### Slide structure
 
-Each Marp deck has **20 main slides + 1 appendix slide**. The main 20 are the
+Each Marp deck has **1 title slide + 20 main slides + 1 appendix slide = 22
-presentation; the appendix is for Q&A backup. (v1.22 split slides 3 and 8
+rendered slides** (21 `## ` sections + the H1 title slide). The main 20
-to relieve overflow, increasing the count from 18 to 20.)
+are the presentation; the appendix is for Q&A backup. (v1.22 split slides
+3 and 8 to relieve overflow, increasing the main count from 18 to 20.)
 
+- **Title slide** (H1): `<!-- _class: title -->` + `<!-- _paginate: false -->`
+  for the dark-background title style (S&P-red top border on black).
 - **Main slides** (1-20): the story arc — Problem → Solution → Proof →
   Roadmap + Ask. These are what the audience sees during the talk.
-- **Appendix slide** (A1): the Metrics Glossary — detail-heavy reference for
+- **Appendix slide** (A1): the Metrics Glossary — detail-heavy reference
-  Q&A.
+  for Q&A.
 
 ### Honesty framing
 
 Every capability claim in the deck is grounded, derived, or honestly
-deferred with its blocking work named in plain language. Internal provenance
+deferred with its blocking work named in plain language. Internal
-(decision IDs, requirement IDs, internal file paths) is kept out of the
+provenance (decision IDs, requirement IDs, internal file paths) is kept
-audience-facing slides — those live in the `.ciagent/` files only. When in
+out of the audience-facing slide bodies — those live in the `.ciagent/`
-doubt, check `.ciagent/ROADMAP.md` and the milestone status in
+files only (and may appear inside `<!-- ... -->` speaker-note comments,
-`.ciagent/PROJECT.md`.
+which Marp excludes from the rendered slide). When in doubt, check
+`.ciagent/ROADMAP.md` and the milestone status in `.ciagent/PROJECT.md`.
 
 ### Audience
 
@@ -156,76 +193,70 @@ Head of Infrastructure, Head of DevOps. The framing rules:
   outcome; the mechanism follows.
 - **Security, remediation velocity, reliability, lead time, observability,
   citizen developer** are the themes — not implementation details.
-- **"Infrastructure operations become visible"** is the recurring theme across
+- **"Infrastructure operations become visible"** is the recurring theme
-  the deck.
+  across the deck.
 
 ### Diagrams
 
-Mermaid diagrams in the Step 1 source use the repo's existing `flowchart`
+Mermaid diagrams are authored as `assets/mmd/*.mmd` source files and
-style (renders on GitHub/Pages). For the Marp deck (Step 2):
+rendered to PNG under `assets/png/`:
 
-1. Extract the mermaid block into `assets/mmd/<deck>-<slide>-<name>.mmd`.
+1. Author the mermaid block as `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.
-3. Render with a 2x scale factor and transparent background for crisp slides.
+3. Render with a 2x scale factor and transparent background for crisp
-4. Embed with `![w:1000](assets/png/<name>.png)` (or `h:320` for tall images).
+   slides (`scripts/render_slides.sh` does this with the S&P theme JSON).
+4. Embed with `![w:1000](assets/png/<name>.png)` (or `h:480 class:tall`
+   for tall images).
+5. The render pipeline base64-inlines the PNGs into the committed HTML so
+   the HTML is self-contained.
 
 ## Build commands
 
 ### Prerequisites
 
-- Node.js + npx (for `@marp-team/marp-cli` and `@mermaid-js/mermaid-cli`)
+- **Node.js + npx** (for `@marp-team/marp-cli` and `@mermaid-js/mermaid-cli`)
-- A Chrome/Chromium binary (Marp PPTX export requires it)
+- **A Chrome/Chromium binary** (Marp PPTX export requires it)
+- **Python 3.10+** with the `slides` extra: `pip install -e ".[slides]"`
+  (installs `python-pptx>=0.6.23`)
 
 This environment has a working Chromium at:
 `/root/.cache/ms-playwright/chromium-1217/chrome-linux64/chrome`
 
-### Render all mermaid diagrams to PNG
+### Render the deck (HTML + dual PPTX + inlined images)
-
-```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 \
-    --configFile mmd/sp-theme.json
-done
-```
-
-### Render a Marp deck to HTML + PPTX (committed artifacts)
 
 ```bash
 bash scripts/render_slides.sh nova-autonomous-cloud-delivery
 ```
 
-This renders all mermaid PNGs, the HTML, and the PPTX, and stages them for
+This renders all mermaid PNGs, the HTML (with base64-inlined images), the
-commit. The `--allow-local-files` flag is required so local PNG diagrams are
+MARP PPTX, and the python-pptx PPTX, and stages them for commit. Both
-embedded. Both HTML and PPTX are committed to the repo; the PPTX is also
+HTML and both PPTX files are committed to the repo; the MARP PPTX is also
 attached to the phase's release.
 
 ## Adding a new presentation
 
-1. **Write the full markdown** as `<deck-name>.md` following the
+1. **Author the Marp deck** as `<deck-name>-marp.md` — frontmatter
-   `## Slide N — Title` + `> **Speaker notes:**` structure. This is the
+   (`marp: true`, `theme: default`, `paginate: true`, `size: 16x9`, an
-   source of truth.
+   inline `style:` block with the S&P palette), `## Slide N — Title`
-2. **Extract any mermaid diagrams** into `assets/mmd/<deck-name>-<slide>-<name>.mmd`
+   sections, `<!-- Speaker notes: -->` + `<!-- Talking points: -->` HTML
-   and render them to `assets/png/` (command above).
+   comments, and `<div class="benefit">` callouts. This is the sole source
-3. **Synthesize the Marp deck** as `<deck-name>-marp.md` with frontmatter,
+   of truth.
-   no speaker notes, embedded PNGs, and no badges.
+2. **Author any mermaid diagrams** as `assets/mmd/<deck-name>-<slide>-<name>.mmd`
-4. **Render to HTML + PPTX** via `scripts/render_slides.sh <deck-name>` and
+   (Step 2 renders them to `assets/png/`).
-   commit both to `docs/presentations/`.
+3. **Render** via `bash scripts/render_slides.sh <deck-name>` — this
-5. **Distill the talking points** as `<deck-name>-talking-points.md` — one
+   produces the HTML (base64-inlined), the MARP PPTX, and the python-pptx
-   section per Marp slide, 3-6 talking point bullets + key takeaway, content
+   PPTX, and stages all of them (plus the PNGs) for commit.
-   distilled from the source markdown (Step 1), indexed by the Marp deck
+4. **Distill the talking points** as `<deck-name>-talking-points.md` — one
-   (Step 2) slide structure.
+   section per Marp slide, 3-6 talking point bullets + key takeaway,
-6. **Verify** the PPTX slide count and that media files are embedded:
+   content distilled from the Marp deck's `<!-- Talking points: -->`
+   comments, indexed by the Marp deck slide structure.
+5. **Verify** the PPTX slide count and that media files are embedded:
    ```bash
    python3 -c "
    import zipfile, re
-   with zipfile.ZipFile('<output>.pptx') as z:
+   with zipfile.ZipFile('docs/presentations/<deck-name>.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')
@@ -234,16 +265,17 @@ attached to the phase's release.
 
 ## Current decks
 
-| Deck | Source of truth (Step 1) | Marp deck (Step 2) | Rendered HTML + PPTX (Step 3) | Talking points (Step 4) | Slides | Audience |
+| Deck | Source of truth (Step 1) | Rendered HTML + dual PPTX (Step 2) | Talking points (Step 3) | Slides | Audience |
-|---|---|---|---|---|---|---|
+|---|---|---|---|---|---|
-| Nova — The Autonomous Cloud Delivery Platform | `nova-autonomous-cloud-delivery.md` | `nova-autonomous-cloud-delivery-marp.md` | `nova-autonomous-cloud-delivery.html` + `.pptx` (committed + release-attached) | `nova-autonomous-cloud-delivery-talking-points.md` | 20 main + 1 appendix (21) | CTO, Head of Cloud, Head of Infra, Head of DevOps |
+| Nova — The Autonomous Cloud Delivery Platform | `nova-autonomous-cloud-delivery-marp.md` | `nova-autonomous-cloud-delivery.html` (inlined) + `nova-autonomous-cloud-delivery.pptx` (MARP, release-attached) + `nova-autonomous-cloud-delivery-python.pptx` (structured) | `nova-autonomous-cloud-delivery-talking-points.md` | title + 20 main + 1 appendix (22) | CTO, Head of Cloud, Head of Infra, Head of DevOps |
 
-> **v1.21:** the deck was renamed from "No-Humans Infrastructure Platform"
+> **v1.23:** the slide creation process collapsed from 4 steps to 3 — the
-> to "Autonomous Cloud Delivery Platform" (professional framing; conveys
+> plain `<deck-name>.md` was deleted; `<deck-name>-marp.md` is now the
-> autonomy without the provocative wording). The narrative restructured to
+> sole source of truth. The standalone `nova-sp-theme.css` was retired
-> a 4-beat arc (Problem → Solution → Proof → Roadmap + Ask). Internal
+> from render (the live styling is the inline `style:` block in the
-> provenance (decision IDs, requirement IDs, file paths) removed from
+> `-marp.md` frontmatter; the CSS file is retained as a reference only).
-> audience-facing slides. Maturity badges removed. The RACI matrix expanded
+> Speaker notes moved from blockquotes into `<!-- Speaker notes: -->`
-> to four roles (Quality Engineering + SRE). The Atelier slide split into
+> HTML comments. Benefit callouts moved from `**Benefit:**` prefixes to
-> two. The pipeline hardened: Checkov on static code before the plan;
+> `<div class="benefit">`. The render pipeline now produces a dual-PPTX
-> Wiz-or-Checkov on the plan (never both).
+> output (MARP image-of-slide + python-pptx structured) and base64-inlines
+> all images into the committed HTML.

docs/presentations/assets/nova-sp-theme.css

@@ -1,3 +1,8 @@
+/* RETAINED AS REFERENCE ONLY — not loaded at render time.
+ * The live deck uses Marp `default` theme + an inline `style:` block in
+ * the -marp.md frontmatter. This file is kept for future styling work
+ * reference. Do NOT pass via `--theme`; it is not in the render path.
+ */
 /* @theme nova-sp */
 /* Nova — S&P Global Energy theme for Marp decks.
  *

docs/presentations/nova-autonomous-cloud-delivery-marp.md

@@ -1,9 +1,29 @@
 ---
 marp: true
-theme: nova-sp
+theme: default
 paginate: true
 size: 16x9
 footer: 'Nova — The Autonomous Cloud Delivery Platform'
+style: |
+  section { font-family: "Akkurat Pro", "Helvetica Neue", "Arial", sans-serif; font-size: 22px; color: #1B1B1B; padding: 48px 56px 40px; overflow: auto; }
+  h1 { color: #D6002A; font-size: 34px; margin-bottom: 0.3em; }
+  h2 { color: #D6002A; font-size: 26px; margin-bottom: 0.2em; }
+  h3 { color: #D6002A; font-size: 22px; margin-bottom: 0.2em; }
+  section.title { background: #1B1B1B; color: #fff; border-top: 8px solid #D6002A; }
+  section.title h1, section.title h2 { color: #fff; }
+  section.title header, section.title footer { display: none; }
+  table { font-size: 18px; width: 100%; border-collapse: collapse; }
+  th { background: #F0F0F0; border-bottom: 2px solid #D6002A; padding: 4px 8px; text-align: left; }
+  td { border-bottom: 1px solid #F0F0F0; padding: 4px 8px; }
+  blockquote { border-left: 4px solid #D6002A; color: #2E2E2E; font-size: 20px; padding-left: 12px; }
+  pre { background: #1B1B1B; color: #fff; border-radius: 4px; padding: 12px; font-size: 16px; }
+  code { background: #F0F0F0; color: #1B1B1B; border-radius: 2px; padding: 1px 4px; font-size: 18px; }
+  pre code { background: transparent; color: inherit; }
+  img { display: block; margin: 0 auto; max-width: 100%; max-height: 380px; object-fit: contain; }
+  strong { color: #D6002A; }
+  .benefit { margin-top: 0.6em; padding-top: 0.4em; border-top: 1px solid #D6002A; color: #1B1B1B; font-size: 20px; font-style: italic; }
+  section.title .benefit { color: #fff; }
+  @media print { section { overflow: hidden; } }
 ---
 
 <!-- _class: title -->
@@ -21,14 +41,16 @@ Product Development & Citizen Developer Overview
 
 **Product teams now own their cloud infrastructure — but ownership without discipline is destroying value.**
 
-- **No lifecycle planning.** Resources are authored for creation, not for patching, decommissioning, or rollback — so changes are destructive.
+- **No lifecycle planning.** Resources are authored for creation, not for patching or rollback — so changes are destructive.
-- **Proactive scanning is not part of authoring.** AI-frontier models exploit zero-days at a rapid pace; teams cannot keep up by reacting. Modules must be scanned as code and at runtime — and remediated at the pace the threat moves.
+- **No proactive scanning in authoring.** AI-frontier models exploit zero-days faster than teams can react; modules must be scanned as code and at runtime, remediated at threat pace.
-- **Bandwidth gaps in infrastructure operations.** Time spent on remediation + the push for innovation leaves operations chronically under-resourced; detections are missed, incidents grow.
+- **Bandwidth gaps.** Remediation plus the push for innovation leaves operations under-resourced; detections are missed, incidents grow.
-- **Tribal knowledge and the rockstar-operator problem.** Operations depend on a handful of administrators; when they leave, the knowledge leaves with them. The platform should encode the discipline, not the person.
+- **Tribal knowledge.** Operations depend on a few administrators; when they leave, the knowledge leaves with them. The platform should encode the discipline, not the person.
 
-Every hour a developer spends writing, deploying, fixing, or remediating infrastructure is an hour not spent releasing features to production.
+<div class="benefit">an autonomous cloud delivery platform that encodes discipline as policy, scans proactively, remediates rapidly, and makes operations visible to leadership.</div>
 
-**Benefit:** the answer is an autonomous cloud delivery platform that encodes discipline as policy, scans proactively, remediates rapidly, and makes operations visible to leadership rather than hidden in tribal knowledge.
+<!-- Speaker notes: Do not frame this as "humans are the problem." The problem is that ownership was granted without the discipline, tooling, and lifecycle planning that infrastructure requires. The operator is not the bottleneck because operators exist — the bottleneck is that operations depend on a few individuals instead of an encoded system. -->
+<!-- Transition: Here is the destination Nova is building toward. -->
+<!-- Talking points: Open with the shift: "you build it, you run it" put Terraform into product teams — ownership without discipline is destroying value; Land the lifecycle-planning gap: resources authored for creation, not for patching/rollback → destructive changes; Land the urgency: AI-era 0-day pace demands proactive scanning as code + at runtime, remediated at threat pace; Call out tribal knowledge / the rockstar-operator problem — the platform should encode the discipline, not the person; Do NOT frame this as "humans are the problem" — the problem is ownership without the discipline and tooling; Key takeaway: the problem is infrastructure ownership without discipline; the answer is an autonomous platform that encodes the discipline -->
 
 ---
 
@@ -40,7 +62,11 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 - **Provable, not promised** — trust established by deterministic scripts that calculate a score; the platform functions without AI
 - **Autonomy in operations, human at stage gates** — QA signs off for production; SRE greenlights operational readiness
 
-**Benefit:** the destination is autonomous operations with provable trust — security, remediation velocity, reliability, and lead time made visible to leadership, not promised to them.
+<div class="benefit">the destination is autonomous operations with provable trust — security, remediation velocity, reliability, and lead time made visible to leadership, not promised to them.</div>
+
+<!-- Speaker notes: "Visible" is the operative word. The vision is not just that operations run without an operator — it is that operations become observable, queryable, and accountable. That is what makes the trust defensible. -->
+<!-- Transition: The vision is ambitious — here are the strategic objectives that make it concrete, and the anti-goals that keep it focused. -->
+<!-- Talking points: Read the vision verbatim — "infrastructure operations become visible" is the operative phrase; Emphasize "provable, not promised" — trust established by deterministic scripts; the platform functions without AI; State the attestation model up front: QA for production, SRE for operational readiness; Key takeaway: autonomous operations with provable trust — security, remediation velocity, reliability, lead time made visible, not promised -->
 
 ---
 
@@ -53,7 +79,11 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
    - **Lead Time** (PR → Production) · **Infrastructure Vulnerability Count** (trend) · **MTTR** · **Cloud Spend Reduction**
 4. **Integrate with externally owned development platforms — regardless of source** — PDLC, SDLC, Agentic, or Citizen Developer; Nova provides skills + MCP endpoints; all prod intents go through the same controls and quality gates
 
-**Benefit:** the scope is explicit — Nova governs infrastructure and delivery, integrates with any upstream source through one validated contract, and measures success on four metrics a CTO can repeat back.
+<div class="benefit">the scope is explicit — Nova governs infrastructure and delivery, integrates with any upstream source through one validated contract, and measures success on four metrics a CTO can repeat back.</div>
+
+<!-- Speaker notes: Objective #2 is the one to land carefully: trust is established by deterministic scoring, not by an LLM. The platform functions without AI. -->
+<!-- Transition: The objectives are concrete — here is what Nova is NOT, to keep it focused. -->
+<!-- Talking points: Objective #1: zero-touch operations — autonomy as the default, not the demo; stage-gate attestation (QA, SRE) remains human by design; Objective #2 is the one to land carefully: trust = deterministic scoring, not an LLM; the platform functions without AI; Objective #3: four CTO-grade metrics (Lead Time, Vuln Count, MTTR, Spend) — all flow into PowerBI; Objective #4 is the integration thesis: Nova integrates with any upstream source; provides skills + MCP; all prod intents go through the same controls; Key takeaway: the scope is explicit — Nova governs infra + delivery, integrates with any source through one contract, measures success on four CTO metrics -->
 
 ---
 
@@ -64,20 +94,27 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 3. Not an upstream development platform (no product backlogs, IDE, code authorship)
 4. Not a replacement for the Product Development Lifecycle (PDLC)
 
-**Benefit:** the boundaries are explicit — Nova is purpose-built for infrastructure operations and delivery, not a general-purpose AI agent or an upstream development platform.
+<div class="benefit">the boundaries are explicit — Nova is purpose-built for infrastructure operations and delivery, not a general-purpose AI agent or an upstream development platform.</div>
+
+<!-- Speaker notes: Anti-goals #3 and #4 protect the scope boundary — Nova will not become an IDE or a product-planning tool. -->
+<!-- Transition: The scope boundary is explicit — here is exactly where Nova sits relative to the product development lifecycle. -->
+<!-- Talking points: Not a general-purpose AI agent platform; Not a system that removes humans from accountability — only from normal operations; Not an upstream development platform (no product backlogs, IDE, code authorship); Not a replacement for the Product Development Lifecycle (PDLC); Anti-goals #3 and #4 protect the scope boundary — Nova will not become an IDE or a product-planning tool; Key takeaway: the boundaries are explicit — Nova is purpose-built for infra ops + delivery, not a general-purpose AI agent or an upstream dev platform -->
 
 ---
 
 ## Slide 5 — Scope: Downstream of PDLC
 
-**Nova governs infrastructure and delivery. The PDLC is upstream — Nova never penetrates it. Integration is through one validated contract.**
+**Nova governs infrastructure and delivery. The PDLC is upstream — Nova stays downstream of it. Integration is through one validated contract.**
 
-- **The PDLC is upstream:** product backlog, code authorship (AI agent, IDE, agentic SDLC), sprint planning, application business logic
+- **The PDLC is upstream** — product backlog, code authorship (AI agent, IDE, agentic SDLC), sprint planning, application business logic. Nova stays downstream of it.
 - **Nova is downstream:** contract ingestion → submission-readiness gate → policy enforcement → cloud resource lifecycle → environment progression (dev → qa → prod → dr) → immutable audit + attestation
-- **The integration point is one contract** — any upstream source (AI agent, agentic SDLC, dev platform) produces submissions subject to the same compliance standards
+- **One validated contract** — any upstream source (AI agent, agentic SDLC, dev platform) produces submissions subject to the same compliance standards; Nova validates the submission, not the author
-- **Nova validates the submission, not the author** — the audit trail, the policy envelope, and the evidence stream are the same regardless of source
 
-**Benefit:** a clean scope boundary — Nova is purpose-built for infrastructure operations and integrates with any upstream source through one validated contract, so the platform team's surface area stays bounded.
+<div class="benefit">a clean scope boundary — Nova is purpose-built for infrastructure operations and integrates with any upstream source through one contract, so the platform team's surface area stays bounded.</div>
+
+<!-- Speaker notes: This slide protects the scope. The moment Nova starts owning the PDLC, it loses focus. The contract boundary is what keeps Nova deep on infrastructure and delivery rather than shallow on everything. -->
+<!-- Transition: With the scope clear, here is who owns what across the delivery lifecycle. -->
+<!-- Talking points: Nova governs infra + delivery only; the PDLC (backlog, code authorship, IDE) is upstream — Nova stays downstream of it; Integration is only through the validated contract boundary; Any upstream source (AI agent, agentic SDLC, dev platform) produces submissions subject to the same compliance standards; Nova validates the submission, not the author; Key takeaway: Nova is purpose-built for infrastructure operations; the scope boundary is clean and bounded -->
 
 ---
 
@@ -98,7 +135,11 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 
 **R**=Responsible · **A**=Accountable (sign-off) · **C**=Consulted · **I**=Informed. Production readiness is co-owned: the platform runs attestations agentically; the citizen developer authorizes the promotion at the stage gate.
 
-**Benefit:** every party knows what they bring, what the platform provides, what quality engineering guards, and where SRE signs off — accountability is explicit, never diffuse.
+<div class="benefit">every party knows what they bring, what the platform provides, what quality engineering guards, and where SRE signs off — accountability is explicit, never diffuse.</div>
+
+<!-- Speaker notes: Quality attestation is now owned by Quality Engineering (not the Platform), and Production readiness is owned by SRE. The Platform runs the checks agentically but is never the Accountable party for the gate — that separation keeps the platform honest. -->
+<!-- Transition: With ownership clear, here is how the pipeline enforces it. -->
+<!-- Talking points: Four roles now: Citizen Developer, Platform, Quality Engineering, SRE; Quality attestation is owned by Quality Engineering (not the Platform); Production readiness is owned by SRE; The Platform runs the checks agentically but is never the Accountable party for the gate — that separation keeps the platform honest; Production readiness is co-owned: the platform runs attestations; the citizen developer authorizes the promotion at the stage gate; Key takeaway: you bring FRs + UAT; Nova provides NFRs + infra; QE guards the gate evidence; SRE signs off on production readiness -->
 
 ---
 
@@ -108,11 +149,15 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 
 ![h:480 class:tall](assets/png/platform-pipeline.png)
 
-- **Contract → resolver → adapter → Checkov on static code (before plan) → terraform plan → Wiz on the plan → confidence signal → stage gate → apply → evidence + ledger**
+- **The pipeline** — see the diagram; two scan stages (static code, then resolved plan) feed a confidence signal to the stage gate before apply + evidence + ledger
 - **Fail-fast, quick feedback** — Checkov runs on the authored Terraform code before `terraform plan` so developers get immediate policy feedback
-- **Wiz on the plan when configured; Checkov as a drop-in otherwise** — Wiz scans the plan output; when Wiz credentials are absent, Checkov runs against the plan. **Wiz and Checkov are never both run on the plan.**
+- **Wiz on the plan when configured; Checkov as a drop-in otherwise** — Wiz scans the plan output; when Wiz credentials are absent, Checkov runs against the plan instead. **Wiz and Checkov are never both run on the plan.**
 
-**Benefit:** two layers of scanning, zero operator involvement in normal operations — fast deterministic feedback at authoring time and a runtime scan on the resolved plan.
+<div class="benefit">two layers of scanning, zero operator involvement in normal operations — fast deterministic feedback at authoring time and a runtime scan on the resolved plan.</div>
+
+<!-- Speaker notes: The two-stage scan is the key design: static code scanning catches policy violations before the cost of a plan; runtime plan scanning catches what the static code cannot (resolved values, cross-resource issues). The platform picks the runtime scanner based on configuration — never both, to avoid duplicate noise. -->
+<!-- Transition: The pipeline produces decisions — here is how every decision is captured and made accountable. -->
+<!-- Talking points: Walk the pipeline left-to-right: contract → resolver → adapter → Checkov (static) → plan → Wiz (on plan) → confidence → gate → apply; Two-stage scan: Checkov on static code BEFORE the plan (fail-fast dev feedback); Wiz on the plan (or Checkov as drop-in if no Wiz creds); Never both Wiz + Checkov on the plan — avoid duplicate noise; Dev is autonomous; qa/prod/dr require attestation (QA for quality, SRE for production readiness); Key takeaway: two layers of scanning, zero operator involvement in normal operations -->
 
 ---
 
@@ -121,10 +166,14 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 **Every automated decision is captured, immutable, queryable — and accountable.**
 
 - **What is captured:** the chosen action, the confidence score, the alternatives considered, whether a human overrode it, and the outcome (backfilled once the apply completes). Every stage-gate attestation (QA, SRE) is captured with approver identity and the evidence presented.
-- **"AI decisions" are really automated decisions** — made by deterministic scripts that calculate a score and a band; the platform functions without AI. When an LLM planner is added later, it will emit richer alternatives without breaking the schema.
+- **"AI decisions" are really automated decisions** — deterministic scripts calculate a score and a band; the platform functions without AI, and a later LLM planner emits richer alternatives without breaking the schema.
 - **The value is accountability, not the storage engine** — the ledger is append-only and tamper-evident; every decision is queryable for auditing, traceable to an outcome, and impossible to rewrite after the fact.
 
-**Benefit:** "autonomous" is defensible because every decision is immutable, queryable, and accountable — and the audience knows exactly what "automated" means here: deterministic scoring, not a black-box LLM.
+<div class="benefit">"autonomous" is defensible because every decision is immutable, queryable, and accountable — and the audience knows exactly what "automated" means here: deterministic scoring, not a black-box LLM.</div>
+
+<!-- Speaker notes: Do not dwell on the storage substrate. The audience cares that the ledger is append-only, queryable, and tied to outcomes — not that it is a hash-chain in a SQLite file. The D-122 honesty point is restated without the decision ID: the platform's decisions are deterministic; the ledger captures that real path. -->
+<!-- Transition: Decisions are captured — here is how stage-gate attestation keeps humans in accountability. -->
+<!-- Talking points: "AI decisions" are really automated decisions — deterministic scripts calculate a score; the platform functions without AI; Do not dwell on the storage substrate — the value is accountability (immutable, queryable, traceable to outcome), not the database; Every stage-gate attestation is captured with approver identity and the evidence presented; When an LLM planner is added later, it emits richer alternatives without breaking the schema; Key takeaway: autonomous is defensible because every decision is immutable, queryable, accountable — and "automated" means deterministic scoring, not a black-box LLM -->
 
 ---
 
@@ -138,7 +187,11 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 | Performance baseline | qa | 7d | The deployment meets its performance envelope vs. the agreed baseline. |
 | Security posture | qa | 24h | The deployment's security findings have been reviewed and accepted. |
 
-**Benefit:** QA signs off on quality before any promotion — the gate is explicit, not implicit.
+<div class="benefit">QA signs off on quality before any promotion — the gate is explicit, not implicit.</div>
+
+<!-- Speaker notes: The matrix is not a rubber stamp. Each concern has a freshness window and a plain-language description of what is being attested. The "operator-supplied" label from the prior deck was dropped — every concern now has a plain-language description. -->
+<!-- Transition: QA is half the matrix — here are the production and DR controls. -->
+<!-- Talking points: The matrix is not a rubber stamp — structured, freshness-validated; Each concern now has a plain-language description of what is being attested (the old "operator-supplied" label is gone); Three QA concerns: functional correctness (24h), performance baseline (7d), security posture (24h); Each concern has a freshness window — evidence older than the window does not satisfy the gate; Key takeaway: QA signs off on quality before any promotion — the gate is explicit, not implicit -->
 
 ---
 
@@ -158,7 +211,11 @@ Every hour a developer spends writing, deploying, fixing, or remediating infrast
 
 Separation-of-duties on prod: the approver cannot be the same person who built the deployment.
 
-**Benefit:** the gate model is explicit — autonomy in operations, human in accountability, by design. The matrix is what makes autonomous operations safe enough to trust in production.
+<div class="benefit">the gate model is explicit — autonomy in operations, human in accountability, by design. The matrix is what makes autonomous operations safe enough to trust in production.</div>
+
+<!-- Speaker notes: The prod/DR rows are the operational-readiness and resilience gates — SRE signs off on operability, incident response, capacity, and the three resilience checks (DR drill, chaos, backup). Separation-of-duties on prod is the rule that keeps the gate honest: the approver cannot be the same person who built the deployment. -->
+<!-- Transition: You've seen how Nova works — the pipeline, the ledger, the attestation gates. Here is how Nova instruments itself so that every claim in this deck is traceable to a real signal. -->
+<!-- Talking points: Seven prod/DR concerns: operational readiness, incident response, capacity & cost, DR drill, chaos, backup, DR region deploy; SRE signs off on operability (runbooks, dashboards, on-call), incident response, capacity, and the three resilience checks; Each concern has a freshness window — 30d/90d/180d depending on the control; SoD on prod: the approver can't be the same person who built it — the rule that keeps the gate honest; Key takeaway: autonomy in operations, human in accountability, by design — the matrix is what makes autonomous operations safe enough to trust in production -->
 
 ---
 
@@ -172,7 +229,11 @@ Separation-of-duties on prod: the approver cannot be the same person who built t
 - **The live ops dashboard (PowerBI)** surfaces the four CTO-grade metrics (Lead Time, Vulnerability Count, MTTR, Cloud Spend) alongside trust metrics (Decision Ledger coverage, Attestation coverage) and efficiency metrics (touchless resolution, escalation frequency)
 - **Every number is traceable to a signal** — when a CFO asks "where does this number come from?", the answer is a query against the cold store, not a Slack thread
 
-**Benefit:** the architecture is the trust substrate — leadership sees the same numbers the platform produces, in PowerBI, with full traceability. Operations become visible.
+<div class="benefit">the architecture is the trust substrate — leadership sees the same numbers the platform produces, in PowerBI, with full traceability. Operations become visible.</div>
+
+<!-- Speaker notes: The value is not the plumbing — it is that the platform's metrics surface in a tool leadership already uses (PowerBI), and every number is traceable. The live-ops dashboard is where the "infrastructure operations become visible" theme lands concretely. -->
+<!-- Transition: The architecture is sound — here is the measured proof. -->
+<!-- Talking points: Deliberately minimal: Nova-native CloudEvents; no Kafka/Prometheus/ClickHouse; The live-ops dashboard is built in PowerBI on top of the exported views — leadership sees the same numbers the platform produces; Every number in the Proof slides is traceable to a signal — "where does this number come from?" → a query against the cold store; This is where the "infrastructure operations become visible" theme lands concretely; Key takeaway: the architecture is the trust substrate — operations become visible in PowerBI, with full traceability -->
 
 ---
 
@@ -185,7 +246,11 @@ Separation-of-duties on prod: the approver cannot be the same person who built t
 - **No change to production without both** — the ledger entry and the human attestation are mandatory, enforced by the pipeline, not by policy
 - **Full traceability** — a production change is traceable from the contract that declared intent, through the policy scan, the confidence score, the attestation, to the applied outcome
 
-**Benefit:** trust is provable — not a marketing claim, a queryable record. An auditor answers "who approved this, when, on what evidence?" in one query; a CTO answers "how many of last quarter's prod changes were touchless?" in one query.
+<div class="benefit">trust is provable — not a marketing claim, a queryable record. An auditor answers "who approved this, when, on what evidence?" in one query; a CTO answers "how many of last quarter's prod changes were touchless?" in one query.</div>
+
+<!-- Speaker notes: The mandatory-by-design point is the one to land. The ledger + attestation are not a best-effort feature; they are a gate. No change reaches production without both. That is what makes the 100% numbers credible — they are enforced, not aspirational. -->
+<!-- Transition: Trust is provable — here is the cost side of the ROI. -->
+<!-- Talking points: Both 100% — no automated decision is ever lost; no prod/dr promotion lands without a human sign-off; The mandatory-by-design point: the ledger entry + the human attestation are a gate, not a best-effort feature; Easily queried: by run, by environment, by approver, by outcome — the audit trail is a query, not a forensic exercise; Key takeaway: trust is provable — not a marketing claim, a queryable record; no change to production without both the ledger entry and the human attestation -->
 
 ---
 
@@ -197,9 +262,13 @@ Separation-of-duties on prod: the approver cannot be the same person who built t
 - **The ROI formula:**
   `Platform ROI = (FTE hours saved × blended rate + cloud savings + avoided downtime) ÷ platform op cost`
 - **The four CTO-grade metrics are the ROI proof:** Lead Time (PR → Prod), Infrastructure Vulnerability Count (trend), MTTR, Cloud Spend Reduction — all flow into PowerBI
-- **Honest caveat:** derived metrics are computed on internal runs today; the production-denominator activates when a pilot estate runs. The formula is grounded; the production numbers are not yet.
+- **Honest caveat:** derived metrics run on internal data today; the production-denominator activates with a pilot estate.
 
-**Benefit:** the ROI is not a black box — the formula is shown, the four metrics are committed, and the production-denominator caveat is stated up front. The CFO sees exactly what is real today and what activates with a pilot.
+<div class="benefit">the ROI is not a black box — the formula is shown, the four metrics are committed, and the production-denominator caveat is stated up front. The CFO sees exactly what is real today and what activates with a pilot.</div>
+
+<!-- Speaker notes: The formula is shown inline, not hidden. The "no fabrication" constraint in action: show the formula, show the caveat, do not pretend the production numbers exist. -->
+<!-- Transition: The proof is grounded — here is what is honestly deferred, and why. -->
+<!-- Talking points: The ROI formula is shown inline — not hidden in a footnote; The four CTO-grade metrics are the ROI proof — Lead Time, Vuln Count, MTTR, Cloud Spend; The N=0 caveat is stated explicitly: the formula is grounded; the production numbers activate with a pilot; Key takeaway: the ROI is not a black box — the formula is shown, the four metrics are committed, the production-denominator caveat is up front -->
 
 ---
 
@@ -207,7 +276,7 @@ Separation-of-duties on prod: the approver cannot be the same person who built t
 
 **Honesty about what is not measured yet — and the blocking work for each.**
 
-To be clear: these deferrals are *measurement infrastructure*, not the autonomy itself. The platform runs without an operator in the loop of normal operations. What is deferred is the evidence pipeline for certain metrics — not the autonomy.
+These deferrals are measurement infrastructure, not the autonomy itself — the platform runs without an operator in normal operations.
 
 | # | Deferred metric | Blocking work |
 |---|-----------------|---------------|
@@ -218,7 +287,11 @@ To be clear: these deferrals are *measurement infrastructure*, not the autonomy
 | 5 | Live cost reconciliation | Live AWS re-provisioning + actual-spend feed |
 | 6 | Predictive vs reactive ratio | ML anomaly-forecasting service (not yet built) |
 
-**Benefit:** the boundaries are explicit — what Nova measures today, and exactly what blocks the rest. The autonomy is real; the measurement gaps are documented with the work that unblocks each one.
+<div class="benefit">the boundaries are explicit — what Nova measures today, and exactly what blocks the rest. The autonomy is real; the measurement gaps are documented with the work that unblocks each one.</div>
+
+<!-- Speaker notes: The preempt is critical: these deferrals are measurement infrastructure, not autonomy. The platform runs without an operator in the loop. What is deferred is the evidence pipeline for live-infra health, drift, predictive remediation — not the autonomy itself. -->
+<!-- Transition: The proof is honest — here is the roadmap from here to the targets. -->
+<!-- Talking points: The preempt is critical: these deferrals are measurement infrastructure, not autonomy — the platform IS autonomous in operations; The blocking work is named in plain language (no decision IDs) — "live AWS re-provisioning", "drift-detection scheduler", "ML service"; Showing this to leadership demonstrates honesty, not weakness; Key takeaway: the autonomy is real; the measurement gaps are documented with the work that unblocks each one -->
 
 ---
 
@@ -237,7 +310,11 @@ To be clear: these deferrals are *measurement infrastructure*, not the autonomy
 
 Re-evaluation triggers: each blocking piece of work lifts on its own schedule; the metrics layer evolves as each one lands.
 
-**Benefit:** every deferred metric has an unblock path — nothing is hand-waved; everything has a plan and a timeframe.
+<div class="benefit">every deferred metric has an unblock path — nothing is hand-waved; everything has a plan and a timeframe.</div>
+
+<!-- Speaker notes: This is the bridge from "honestly deferred" to "here is how we get there." The roadmap uses timeframes, not status — most of it is not implemented yet, so a status column would be noise. -->
+<!-- Transition: The unblock path is clear — here is the 12-month product arc. -->
+<!-- Talking points: Each deferred metric has an unblock path and a timeframe — near-term, mid-term, longer-term; No status column: most of it is not implemented yet, so status would be noise; Re-evaluation triggers: each blocking piece of work lifts on its own schedule; Key takeaway: every deferred metric has a plan and a timeframe — nothing is hand-waved -->
 
 ---
 
@@ -254,7 +331,11 @@ Re-evaluation triggers: each blocking piece of work lifts on its own schedule; t
 
 Grounded in the four strategic objectives (autonomy, provable trust, ROI, integration) and the deferred-metric unblock paths.
 
-**Benefit:** the 12-month product arc — each quarter activates a strategic objective and its corresponding board-level metric, from pilot activation through integration leadership.
+<div class="benefit">the 12-month product arc — each quarter activates a strategic objective and its corresponding board-level metric, from pilot activation through integration leadership.</div>
+
+<!-- Speaker notes: The roadmap is organized by product outcome, not by technical milestone. Each quarter activates one strategic objective from the North Star. -->
+<!-- Transition: Here is the quarter-by-quarter detail. -->
+<!-- Talking points: This is the *product* roadmap, forward-looking only; Q1 Pilot Activation → Q2 Provable Trust → Q3 Compounding ROI → Q4 Integration & Predictive; Each quarter activates one strategic objective from the North Star; Key takeaway: the 12-month product arc — each quarter activates a strategic objective and its board-level metric -->
 
 ---
 
@@ -269,7 +350,11 @@ Grounded in the four strategic objectives (autonomy, provable trust, ROI, integr
 
 **Month-18 destination:** *"Nova is the layer enterprise leadership points to when they say 'we don't have an infrastructure ops team anymore, and the audit trail is stronger than it ever was.'"*
 
-**Benefit:** each quarter has a concrete deliverable, a target metric grounded in a strategic objective, and a path from "honestly deferred" to "shipped and measured."
+<div class="benefit">each quarter has a concrete deliverable, a target metric grounded in a strategic objective, and a path from "honestly deferred" to "shipped and measured."</div>
+
+<!-- Speaker notes: Q1–Q3 are committed (grounded pipeline + known unblock paths). Q4 targets are committed-deliverable, aspirational-metric — the ML service ships, the intent-share number is a first measurement (we do not control adoption rate). -->
+<!-- Transition: Production-grade guidance is how Nova helps the citizen developer's AI agent meet the bar — here is the first half. -->
+<!-- Talking points: Q1: three post-pilot metrics go live (Touchless ≥99%, Escalation <0.1%, Accuracy ≥99.5%) — denominator activates with the pilot; Q2: Decision Ledger Coverage was already grounded — tamper-evidence is the Q2 upgrade (local hash-chain → Object Lock + signed checkpoints); Q3: Drift Auto-Reversal ≥95% unblocks when the drift scheduler ships; Spend Reduction ≥25% measured against the pilot baseline; Q4: Predictive:Reactive ≥3:1 requires the ML forecasting service; AI-Agent Intent Share is a first measurement (aspirational-metric); Key takeaway: each quarter has a concrete deliverable, a target metric grounded in a strategic objective, and a path from deferred to shipped -->
 
 ---
 
@@ -281,7 +366,11 @@ Grounded in the four strategic objectives (autonomy, provable trust, ROI, integr
 - **MCP server** — a plugin-registry, stdio server exposing four tools: `lookup_principle`, `list_domains`, `matrix_lookup`, `validate_against_principles`. The developer's AI agent (or any agentic SDLC platform) calls these tools to look up the principles that apply to its submission
 - **The integration point is the same regardless of source** — whether the submission comes from an AI coding agent, an agentic SDLC platform, or a traditional IDE, the same skills and MCP server apply. This is how Nova makes the citizen developer production-grade without owning the PDLC
 
-**Benefit:** the citizen developer's AI agent is not unguided — Nova provides production-grade engineering principles as skills and as an MCP surface, so submissions arrive at the contract boundary already aligned with the platform's standards.
+<div class="benefit">the citizen developer's AI agent is not unguided — Nova provides production-grade engineering principles as skills and as an MCP surface, so submissions arrive at the contract boundary already aligned with the platform's standards.</div>
+
+<!-- Speaker notes: This is the first half of the Atelier story — the surface (skills + MCP). The next slide is what the surface catches that deterministic scanners cannot. -->
+<!-- Transition: Here is what that guidance catches that deterministic scanners cannot. -->
+<!-- Talking points: Nova instructs the citizen developer's AI agent via skills (markdown, keyed to engineering domains) + an MCP server (4 tools, plugin-registry, stdio); The integration point is the same regardless of source — AI agent, agentic SDLC, traditional IDE all get the same skills + MCP; This is how Nova makes the citizen developer production-grade without owning the PDLC; Key takeaway: the citizen developer's AI agent is not unguided — Nova provides engineering principles as skills + MCP -->
 
 ---
 
@@ -293,7 +382,11 @@ Grounded in the four strategic objectives (autonomy, provable trust, ROI, integr
 - **Agentic validation, not a second policy engine** — the MCP server gives the AI agent the principles to validate against; the agent does the validation. The agent reasons about the submission against the principles, not a second static scan
 - **Vendored for audit reproducibility** — Atelier is vendored at a pinned tag. A validation result is replayable against the exact principles that produced it, so an audit can reproduce a validation months later, not just trust a log line
 
-**Benefit:** the citizen developer's submission is checked for engineering discipline, not just policy compliance — and the check is reproducible for audit. That is what makes the submission production-grade, regardless of which upstream platform produced it.
+<div class="benefit">the citizen developer's submission is checked for engineering discipline, not just policy compliance — and the check is reproducible for audit. That is what makes the submission production-grade, regardless of which upstream platform produced it.</div>
+
+<!-- Speaker notes: The value is the gap deterministic scanners leave: engineering discipline. Policy scanners catch "is this S3 bucket public?"; the MCP server catches "is this service observable if that bucket fails?". The vendoring point is audit reproducibility — the validation is not a black box. -->
+<!-- Transition: You've seen the problem, the solution, and the proof. Here is the recap and the ask. -->
+<!-- Talking points: The value is the gap deterministic scanners leave: engineering discipline (Wiz/Checkmarx/Mend check policy/secrets, not discipline); The MCP server catches "is this service observable?", "is this error path handled?", "is this API contract clear?"; Vendored at a pinned tag → audit reproducibility — a validation result is replayable months later; Key takeaway: submissions are checked for engineering discipline, not just policy compliance — and the check is reproducible for audit -->
 
 ---
 
@@ -307,9 +400,12 @@ Grounded in the four strategic objectives (autonomy, provable trust, ROI, integr
 - **Proof:** 100% ledger coverage, 100% attestation coverage, grounded ROI formula, four CTO-grade metrics flowing into PowerBI
 - **Roadmap:** deferred metrics have unblock paths; the 12-month product arc activates one strategic objective per quarter
 
-**The ask:** "Approve a pilot estate to activate the production-denominator metrics (Lead Time, Vulnerability Count, MTTR, Cloud Spend), and approve the tamper-evident ledger build-out to move from the local hash-chain to S3 Object Lock + signed checkpoints. These two decisions move Nova from 'pipeline-ready' to 'production-proven.'"
+**The ask:** "Approve a pilot estate to activate the production-denominator metrics (Lead Time, Vulnerability Count, MTTR, Cloud Spend). Then approve the tamper-evident ledger build-out (S3 Object Lock + signed checkpoints). Together these move Nova from 'pipeline-ready' to 'production-proven.'"
 
-**Benefit:** a clear business decision — approve a pilot and the ledger build-out — with the confidence that every claim in this deck is grounded, derived, or honestly deferred.
+<div class="benefit">a clear business decision — approve a pilot and the ledger build-out — with the confidence that every claim in this deck is grounded, derived, or honestly deferred.</div>
+
+<!-- Speaker notes: The ask is a business decision, not insider language. "Approve a pilot estate" is a C-suite decision. "Approve the ledger build-out" is a budget decision. The recap reinforces the 4-beat arc — the audience leaves with the structure, not a pile of facts. -->
+<!-- Talking points: Recap the 4-beat arc so the audience leaves with the structure; The ask is a business decision: approve a pilot estate + the tamper-evident ledger build-out; "Pipeline-ready" → "production-proven" is the value proposition; Key takeaway: approve a pilot + the ledger build-out to move from pipeline-ready to production-proven -->
 
 ---
 
@@ -334,4 +430,6 @@ Grounded in the four strategic objectives (autonomy, provable trust, ROI, integr
 | Attestation Coverage | prod/dr attested ÷ total prod/dr | grounded |
 | Policy Compliance Rate | 1 − failed_assets ÷ total | grounded |
 
-**Benefit:** a reference for every metric mentioned in the deck.
+<div class="benefit">a reference for every metric mentioned in the deck.</div>
+
+<!-- Talking points: Reference for every metric mentioned in the deck; Use if the audience asks "what does X mean?" -->

docs/presentations/nova-autonomous-cloud-delivery-talking-points.md

@@ -1,8 +1,9 @@
 # Nova — The Autonomous Cloud Delivery Platform: Talking Points
 
-> Step 4 of the 4-step deck process. Presenter cues distilled from the
+> Step 4 of the 4-step deck process. Presenter cues that mirror the
-> source of truth (`nova-autonomous-cloud-delivery.md`). 3-6 bullets per
+> `<!-- Talking points: -->` comments in
-> slide + key takeaway. Indexed by Marp slide #.
+> `nova-autonomous-cloud-delivery-marp.md` (the sole source of truth).
+> 3-6 bullets per slide + key takeaway. Indexed by Marp slide #.
 > v1.21 — REQ-245
 
 ---
@@ -37,7 +38,7 @@
 - **Key takeaway:** the boundaries are explicit — Nova is purpose-built for infra ops + delivery, not a general-purpose AI agent or an upstream dev platform
 
 ### Slide 5 — Scope: Downstream of PDLC
-- Nova governs infra + delivery only; the PDLC (backlog, code authorship, IDE) is upstream — Nova never penetrates it
+- Nova governs infra + delivery only; the PDLC (backlog, code authorship, IDE) is upstream — Nova stays downstream of it
 - Integration is only through the validated contract boundary
 - Any upstream source (AI agent, agentic SDLC, dev platform) produces submissions subject to the same compliance standards
 - Nova validates the submission, not the author

docs/presentations/nova-autonomous-cloud-delivery.md

@@ -1,747 +0,0 @@
-# Nova — The Autonomous Cloud Delivery Platform
-
-> **Source of truth** (Step 1 of the 4-step deck process).
-> Unified narrative deck. 4-beat arc: Problem → Solution → Proof →
-> Roadmap + Ask. x3 structure at deck level (opening = the problem + the
-> arc, body = tell them, closing = recap + ask) AND per slide (opens with
-> what it covers, delivers, closes with a benefit callout written for a
-> tech-leadership audience).
->
-> **Honesty model:** every metric cited is grounded (cites a source),
-> derived (documented formula), or deferred (cites the blocking work).
-> No fabricated numbers. Internal provenance (decision IDs, requirement
-> IDs, internal file paths) is kept out of the audience-facing slides —
-> those live in the appendix and the `.ciagent/` files only.
->
-> v1.21 — Deck Refinement & Pipeline Hardening
-
----
-
-## Slide 1 — The Problem
-
-**Product teams now own their cloud infrastructure — but ownership without
-discipline is destroying value.**
-
-The broad shift to "you build it, you run it" put Terraform into the hands
-of product teams. The intention was right: teams that own their stack ship
-faster. The reality is that infrastructure-as-code is a different craft
-from software development, and the engineering standards that teams apply
-to application code are rarely applied to the infrastructure that carries
-it.
-
-- **No lifecycle planning.** Resources are authored for creation, not for
-  patching, decommissioning, or rollback. When a change is needed, the
-  change is destructive — because no one planned the lifecycle.
-- **Proactive scanning is not part of authoring.** In a year where
-  AI-frontier models discover and exploit zero-day vulnerabilities at a
-  rapid pace, teams cannot keep up by reacting. Infrastructure modules
-  must be scanned as code and at runtime, post-deployment — and remediated
-  at the pace the threat moves, not the pace a sprint allows.
-- **Bandwidth gaps in infrastructure operations.** An unusual amount of
-  time is spent on remediation, the push for innovation does not pause,
-  and the result is that operational work is chronically under-resourced.
-  Gaps open. Detections are missed. Incidents grow.
-- **Tribal knowledge and the rockstar-operator problem.** Operations
-  depend on a handful of administrators who hold the infrastructure in
-  their heads. When they leave, the knowledge leaves with them. The
-  platform should encode the discipline, not the person.
-
-Every hour a developer spends writing, deploying, fixing, or remediating
-infrastructure is an hour not spent releasing features to production and
-generating value.
-
-> **Benefit:** the rest of this deck shows the answer — an autonomous
-> cloud delivery platform that encodes infrastructure discipline as
-> policy, scans proactively, remediates rapidly, and makes operations
-> visible to leadership rather than hidden in tribal knowledge.
-
-> **Speaker notes:** Do not frame this as "humans are the problem." The
-> problem is that ownership was granted without the discipline, tooling,
-> and lifecycle planning that infrastructure requires. The operator is
-> not the bottleneck because operators exist — the bottleneck is that
-> operations depend on a few individuals instead of an encoded system.
-
-> **Transition:** "Here is the destination Nova is building toward."
-
----
-
-## Slide 2 — Nova's Vision
-
-**Infrastructure operations become visible. Every environment provisioned,
-every incident healed, every risk remediated — by an autonomous system
-whose trustworthiness is provable, not promised. Human attestation remains
-required at stage gates; the operator is never in the loop of normal
-operations.**
-
-- **Visibility is the recurring theme.** Security posture, remediation
-  velocity, reliability, and lead time are surfaced as queryable signals —
-  not hidden in a person's head or a Slack thread.
-- **Provable, not promised.** Trust is established by deterministic
-  scripts that calculate a score and gate the action. The platform
-  functions without AI. "AI decisions" are really automated decisions.
-- **Autonomy in operations, human at stage gates.** QA signs off for
-  production; SRE greenlights based on operational readiness. The
-  absence of an operator in the loop is never the absence of a record.
-
-> **Benefit:** the destination is autonomous operations with provable
-> trust — security, remediation velocity, reliability, and lead time made
-> visible to leadership, not promised to them.
-
-> **Speaker notes:** "Visible" is the operative word. The vision is not
-> just that operations run without an operator — it is that operations
-> become observable, queryable, and accountable. That is what makes the
-> trust defensible.
-
-> **Transition:** "The vision is ambitious — here are the strategic
-> objectives that make it concrete, and the anti-goals that keep it
-> focused."
-
----
-
-## Slide 3 — Strategic Objectives
-
-**4 Strategic Objectives:**
-1. **Demonstrate production-grade zero-touch operations** — autonomy as
-   the default, not the demo. Stage-gate attestation (QA, SRE) remains
-   human by design.
-2. **Establish provable trust in automated decisions** — deterministic
-   scripts calculate a score; a band outcome gates the action. The
-   platform functions without AI. The Decision Ledger, confidence
-   scoring, circuit breakers, and blast-radius controls make
-   "autonomous" a defensible claim, not a marketing one.
-3. **Deliver compounding, quantifiable ROI** — measured on four CTO-grade
-   metrics, all flowing into PowerBI:
-   - **Lead Time** (PR → Production) — downward trend.
-   - **Infrastructure Vulnerability Count** — downward trend
-     (proactive scanning keeps up with the AI-era 0-day pace).
-   - **MTTR** — for platform-detected and platform-remediated incidents.
-   - **Cloud Spend Reduction** — on pilot estates vs. the pre-Nova
-     baseline.
-4. **Integrate with externally owned development platforms — regardless
-   of source.** Nova integrates with externally owned PDLC, SDLC,
-   Agentic, and Citizen Developer platforms. Nova provides skills and
-   MCP endpoints that help the developer or AI agent make their
-   application production-grade. Regardless of the source, all intents
-   to deploy to production go through the same rigorous controls,
-   quality gates, attestation, and evidence stream.
-
-> **Benefit:** the scope is explicit — Nova governs infrastructure and
-> delivery, integrates with any upstream source through one validated
-> contract, and measures success on four metrics a CTO can repeat back.
-
-> **Speaker notes:** Objective #2 is the one to land carefully: trust is
-> established by deterministic scoring, not by an LLM. The platform
-> functions without AI.
-
-> **Transition:** "The objectives are concrete — here is what Nova is
-> NOT, to keep it focused."
-
----
-
-## Slide 4 — Anti-Goals (What Nova Is NOT)
-
-1. Not a general-purpose AI agent platform.
-2. Not a system that removes humans from accountability — only from
-   normal operations.
-3. Not an upstream development platform (no product backlogs, IDE, code
-   authorship).
-4. Not a replacement for the Product Development Lifecycle (PDLC).
-
-> **Benefit:** the boundaries are explicit — Nova is purpose-built for
-> infrastructure operations and delivery, not a general-purpose AI agent
-> or an upstream development platform.
-
-> **Speaker notes:** Anti-goals #3 and #4 protect the scope boundary —
-> Nova will not become an IDE or a product-planning tool.
-
-> **Transition:** "The scope boundary is explicit — here is exactly
-> where Nova sits relative to the product development lifecycle."
-
----
-
-## Slide 5 — Scope: Downstream of PDLC
-
-**Nova governs infrastructure and delivery. The PDLC is upstream — Nova
-never penetrates it. Integration is through one validated contract.**
-
-- **The PDLC is upstream:** product backlog, code authorship (AI agent,
-  IDE, agentic SDLC), sprint planning, application business logic.
-- **Nova is downstream:** contract ingestion → submission-readiness gate
-  → policy enforcement → cloud resource lifecycle → environment
-  progression (dev → qa → prod → dr) → immutable audit + attestation.
-- **The integration point is one contract.** The citizen developer's AI
-  coding agent, an upstream agentic SDLC platform, or any development
-  platform may all produce submissions — the source does not matter
-  because all are subject to the same compliance standards.
-- **Nova validates the submission, not the author.** The audit trail is
-  the same; the policy envelope is the same; the evidence stream is the
-  same.
-
-> **Benefit:** a clean scope boundary — Nova is purpose-built for
-> infrastructure operations and integrates with any upstream source
-> through one validated contract, so the platform team's surface area
-> stays bounded.
-
-> **Speaker notes:** This slide protects the scope. The moment Nova
-> starts owning the PDLC, it loses focus. The contract boundary is what
-> keeps Nova deep on infrastructure and delivery rather than shallow on
-> everything.
-
-> **Transition:** "With the scope clear, here is who owns what across the
-> delivery lifecycle."
-
----
-
-## Slide 6 — RACI: Who Owns What
-
-**Four roles, one matrix — the citizen developer owns FRs + UAT, the
-platform owns NFRs + infra, quality engineering owns the gate evidence,
-and SRE owns operational readiness.**
-
-| Work Category | Citizen Dev | Platform | Quality Eng | SRE |
-|---|---|---|---|---|
-| Functional Requirements | **R/A** | C | I | I |
-| User Acceptance Testing | **R/A** | C | I | I |
-| Non-Functional Requirements | I | **R/A** | C | C |
-| Infrastructure (cloud, state, IAM) | I | **R/A** | I | C |
-| QA (policy, confidence, schema) | C | R | **R/A** | I |
-| Production deployment to cloud | I | **R/A** | C | C |
-| Quality attestation (QA sign-off) | **A** | R | **R** | I |
-| Production readiness (SRE sign-off) | **A** | R | C | **R** |
-
-**R** = Responsible · **A** = Accountable (sign-off) · **C** = Consulted · **I** = Informed.
-
-- **Compliance-standard equivalence:** FRs + UAT may come from any
-  upstream source (AI agent, agentic SDLC, dev platform) — all pass the
-  same submission-readiness gate.
-- **Production readiness is co-owned:** the platform runs the
-  attestations agentically; the citizen developer authorizes the
-  promotion at the stage gate.
-
-> **Benefit:** every party knows what they bring, what the platform
-> provides, what quality engineering guards, and where SRE signs off —
-> accountability is explicit, never diffuse.
-
-> **Speaker notes:** Quality attestation is now owned by Quality
-> Engineering (not the Platform), and Production readiness is owned by
-> SRE. The Platform runs the checks agentically but is never the
-> Accountable party for the gate — that separation keeps the platform
-> honest.
-
-> **Transition:** "With ownership clear, here is how the pipeline
-> enforces it."
-
----
-
-## Slide 7 — The Platform Pipeline
-
-**How intent becomes verified infrastructure — with fail-fast policy
-scanning before the plan and runtime scanning after it.**
-
-```mermaid
-graph LR
-    A[Contract] --> B[Resolver]
-    B --> C[Adapter]
-    C --> D["Checkov (static code)"]
-    D --> E[Terraform Plan]
-    E --> F["Wiz (on plan)"]
-    F --> G[Confidence Signal]
-    G --> H{Stage Gate}
-    H -->|dev: autonomous| I[Apply]
-    H -->|qa/prod/dr: attested| I
-    I --> J[Evidence + Ledger]
-```
-
-- **Contract → resolver → adapter → Checkov on static code (before the
-  plan) → terraform plan → Wiz on the plan → confidence signal → stage
-  gate → apply → evidence + ledger.**
-- **Fail-fast, quick feedback.** Checkov runs on the authored Terraform
-  code before `terraform plan` so developers get immediate policy
-  feedback, not a delayed plan-stage failure.
-- **Wiz on the plan when configured; Checkov as a drop-in otherwise.**
-  Wiz scans the terraform plan output. When Wiz credentials are not
-  available, Checkov runs against the plan as a drop-in replacement. Wiz
-  and Checkov are never both run on the plan.
-- **Dev is autonomous** (no stage gate); **qa/prod/dr require human
-  attestation** (QA for quality, SRE for production readiness).
-
-> **Benefit:** the pipeline gives developers fast, deterministic feedback
-> on policy at authoring time and gives the platform a runtime scan on the
-> resolved plan — two layers of scanning, zero operator involvement in
-> normal operations.
-
-> **Speaker notes:** The two-stage scan is the key design: static code
-> scanning catches policy violations before the cost of a plan; runtime
-> plan scanning catches what the static code cannot (resolved values,
-  cross-resource issues). The platform picks the runtime scanner based on
-  configuration — never both, to avoid duplicate noise.
-
-> **Transition:** "The pipeline produces decisions — here is how every
-> decision is captured and made accountable."
-
----
-
-## Slide 8 — The Decision Ledger
-
-**Every automated decision is captured, immutable, queryable — and
-accountable.**
-
-- **What is captured:** every action the platform takes — the chosen
-  action, the confidence score, the alternatives considered, whether a
-  human overrode it, and the outcome (backfilled once the apply
-  completes). Every stage-gate attestation (QA sign-off, SRE
-  production-readiness sign-off) is captured with approver identity and
-  the evidence that was presented.
-- **"AI decisions" are really automated decisions.** The decisions are
-  made by deterministic scripts that calculate a score and a band; the
-  platform functions without AI. The ledger captures the real decision
-  path — not a fabricated "AI agent." When an LLM planner is added later,
-  it will emit richer alternatives without breaking the schema.
-- **The value is accountability, not the storage engine.** The ledger is
-  an append-only, tamper-evident record. The point is not which database
-  it lives in — the point is that every decision is queryable for
-  auditing, traceable to an outcome, and impossible to rewrite after the
-  fact.
-
-> **Benefit:** "autonomous" is defensible because every decision the
-> platform makes is immutable, queryable, and accountable — and the
-> audience knows exactly what "automated" means here: deterministic
-> scoring, not a black-box LLM.
-
-> **Speaker notes:** Do not dwell on the storage substrate. The audience
-> cares that the ledger is append-only, queryable, and tied to outcomes —
-> not that it is a hash-chain in a SQLite file. The D-122 honesty point
-> is restated without the decision ID: the platform's decisions are
-> deterministic; the ledger captures that real path.
-
-> **Transition:** "Decisions are captured — here is how stage-gate
-> attestation keeps humans in accountability."
-
----
-
-## Slide 9 — Attestation Matrix: QA
-
-**The designed controls that keep humans at stage gates — QA concerns,
-freshness-validated.**
-
-| Concern | Env | Freshness | Description |
-|---------|-----|-----------|-------------|
-| Functional correctness | qa | 24h | The application behaves as specified; evidence accepted from the consumer's UAT. |
-| Performance baseline | qa | 7d | The deployment meets its performance envelope vs. the agreed baseline. |
-| Security posture | qa | 24h | The deployment's security findings have been reviewed and accepted. |
-
-- Each concern has a freshness window — evidence older than the window
-  does not satisfy the gate.
-- Concerns that are offline-testable run for real; concerns that require
-  external evidence accept signed artifacts.
-
-> **Benefit:** QA signs off on quality before any promotion — the gate
-> is explicit, not implicit.
-
-> **Speaker notes:** The matrix is not a rubber stamp. Each concern has a
-> freshness window and a plain-language description of what is being
-> attested. The "operator-supplied" label from the prior deck was
-> dropped — every concern now has a plain-language description.
-
-> **Transition:** "QA is half the matrix — here are the production and
-> DR controls."
-
----
-
-## Slide 10 — Attestation Matrix: Prod/DR
-
-**Production and DR controls — operational readiness, resilience, and
-disaster recovery.**
-
-| Concern | Env | Freshness | Description |
-|---------|-----|-----------|-------------|
-| Operational readiness | prod | 30d | SRE confirms the deployment is operable: runbooks, dashboards, on-call coverage. |
-| Incident response | prod | 90d | The on-call path has been exercised; the deployment has a working incident-response plan. |
-| Capacity & cost | prod | 30d | Capacity headroom and monthly cost are within the agreed envelope. |
-| Resilience: DR drill | prod | 180d | A DR drill has been run and the deployment recovered within the RTO. |
-| Resilience: chaos | prod | 90d | A chaos exercise has been run and the deployment absorbed the failure. |
-| Resilience: backup | prod | 30d | Backups are restorable and have been tested within the freshness window. |
-| DR region deploy | dr | 180d | The DR region can be deployed and the deployment is reachable from it. |
-
-- Each concern has a freshness window — evidence older than the window
-  does not satisfy the gate.
-- **Separation-of-duties on prod:** the approver cannot be the same
-  person who built the deployment.
-
-> **Benefit:** the gate model is explicit — autonomy in operations,
-> human in accountability, by design. The matrix is what makes autonomous
-> operations safe enough to trust in production.
-
-> **Speaker notes:** The prod/DR rows are the operational-readiness and
-> resilience gates — SRE signs off on operability, incident response,
-> capacity, and the three resilience checks (DR drill, chaos, backup).
-> Separation-of-duties on prod is the rule that keeps the gate honest:
-> the approver cannot be the same person who built the deployment.
-
-> **Transition:** "You've seen how Nova works — the pipeline, the ledger,
-> the attestation gates. Here is how Nova instruments itself so that
-> every claim in this deck is traceable to a real signal."
-
----
-
-## Slide 11 — Telemetry & Live Ops
-
-**Every metric in this deck is traceable to a real emitted signal — and
-the live-ops dashboard makes operations visible in PowerBI.**
-
-```mermaid
-graph TB
-    A[Platform components] --> B[CloudEvents envelope]
-    B --> C[Event log]
-    B --> D[Decision ledger]
-    B --> E[Run records]
-    C --> F[Collector]
-    D --> F
-    E --> F
-    F --> G[Cold store]
-    G --> H[PowerBI views]
-    H --> I[Live ops dashboard]
-```
-
-- **Platform components emit a CloudEvents envelope** → event log,
-  decision ledger, and run records → collector → cold store → PowerBI
-  views → **live ops dashboard.**
-- **The live ops dashboard (PowerBI)** surfaces the four CTO-grade
-  metrics — Lead Time, Infrastructure Vulnerability Count, MTTR, Cloud
-  Spend — alongside the trust metrics (Decision Ledger coverage,
-  Attestation coverage) and the efficiency metrics (touchless
-  resolution, escalation frequency).
-- **The architecture is deliberately minimal.** Nova-native envelopes;
-  no Kafka, no Prometheus, no ClickHouse. The cold store is sufficient
-  for batch and historical analysis; the live-ops surface is built in
-  PowerBI on top of the exported views.
-- **Every number in the Proof slides is traceable to a signal.** When a
-  CFO asks "where does this number come from?", the answer is a query
-  against the cold store, not a Slack thread.
-
-> **Benefit:** the architecture is the trust substrate — leadership sees
-> the same numbers the platform produces, in PowerBI, with full
-> traceability to the emitted signal. Operations become visible.
-
-> **Speaker notes:** The value is not the plumbing — it is that the
-> platform's metrics surface in a tool leadership already uses (PowerBI),
-> and every number is traceable. The live-ops dashboard is where the
-> "infrastructure operations become visible" theme lands concretely.
-
-> **Transition:** "The architecture is sound — here is the measured
-> proof."
-
----
-
-## Slide 12 — Decision Ledger + Attestation Coverage
-
-**By design, no change reaches production without a ledger entry and a
-human attestation — both queryable for auditing, with full
-traceability.**
-
-- **Decision Ledger coverage: 100%.** Every platform run emits a
-  decision record with outcome backfill. No automated decision is ever
-  lost.
-- **Attestation coverage: 100%.** Every prod/dr promotion is attested by
-  a human — QA for quality, SRE for production readiness — recorded with
-  approver identity, separation-of-duties check, and the evidence matrix.
-- **No change to production without both.** The ledger entry and the
-  human attestation are mandatory, not optional. This is enforced by the
-  pipeline, not by policy.
-- **Easily queried for auditing.** The ledger and the attestation
-  records are queryable by run, by environment, by approver, and by
-  outcome — the audit trail is a query, not a forensic exercise.
-- **Full traceability.** A production change is traceable from the
-  contract that declared intent, through the policy scan, the confidence
-  score, the attestation, to the applied outcome. Nothing is opaque.
-
-> **Benefit:** trust is provable — not a marketing claim, a queryable
-> record. An auditor can answer "who approved this, when, on what
-> evidence?" in one query; a CTO can answer "how many of last quarter's
-> prod changes were touchless?" in one query.
-
-> **Speaker notes:** The mandatory-by-design point is the one to land.
-> The ledger + attestation are not a best-effort feature; they are a
-> gate. No change reaches production without both. That is what makes
-> the 100% numbers credible — they are enforced, not aspirational.
-
-> **Transition:** "Trust is provable — here is the cost side of the ROI."
-
----
-
-## Slide 13 — Cost & ROI
-
-**The ROI formula and the cost estimates — grounded, with the production
-denominator honestly flagged.**
-
-- **Cost estimates are pre-apply and offline.** The platform reads the
-  terraform plan and estimates cost before anything is applied — so a
-  regression in cost is caught before the spend happens, not after.
-- **The ROI formula:**
-  `Platform ROI = (FTE hours saved × blended rate + cloud savings + avoided downtime) ÷ platform op cost`
-- **The four CTO-grade metrics (from Slide 3) are the ROI proof:**
-  Lead Time (PR → Prod), Infrastructure Vulnerability Count (trend), MTTR,
-  Cloud Spend Reduction. All flow into PowerBI.
-- **Honest caveat:** the derived metrics are computed on internal runs
-  today; the production-denominator activates when a pilot estate runs.
-  The formula is grounded; the production numbers are not yet.
-
-> **Benefit:** the ROI is not a black box — the formula is shown, the
-> four metrics are committed, and the production-denominator caveat is
-> stated up front. The CFO can see exactly what is real today and what
-> activates with a pilot.
-
-> **Speaker notes:** The formula is shown inline, not hidden. The
-> "no fabrication" constraint in action: show the formula, show the
-> caveat, do not pretend the production numbers exist.
-
-> **Transition:** "The proof is grounded — here is what is honestly
-> deferred, and why."
-
----
-
-## Slide 14 — What's Deferred — and Why
-
-**Honesty about what is not measured yet — and the blocking work for
-each.**
-
-To be clear: these deferrals are measurement infrastructure, not the
-autonomy itself. The platform runs without an operator in the loop of
-normal operations. What is deferred is the evidence pipeline for certain
-metrics — not the autonomy.
-
-| # | Deferred metric | Blocking work |
-|---|-----------------|---------------|
-| 1 | Live infrastructure health | Live AWS re-provisioning (currently torn down to a zero-cost steady state) |
-| 2 | Live outbox write rate | Live AWS re-provisioning |
-| 3 | Tamper-evident ledger checkpoints | Audit-ledger build-out (S3 Object Lock + signed checkpoints) |
-| 4 | Onboarding funnel (requested → granted) | Auto-grant implementation |
-| 5 | Drift auto-reversal | Drift-detection scheduler (not yet built) |
-| 6 | Live cost reconciliation | Live AWS re-provisioning + actual-spend feed |
-| 7 | SLA / unplanned downtime | Live AWS re-provisioning |
-| 8 | Predictive vs reactive ratio | ML anomaly-forecasting service (not yet built) |
-
-> **Benefit:** the boundaries are explicit — what Nova measures today,
-> and exactly what blocks the rest. The autonomy is real; the measurement
-> gaps are documented with the work that unblocks each one.
-
-> **Speaker notes:** The preempt is critical: these deferrals are
-> measurement infrastructure, not autonomy. The platform runs without an
-> operator in the loop. What is deferred is the evidence pipeline for
-> live-infra health, drift, predictive remediation — not the autonomy
-> itself.
-
-> **Transition:** "The proof is honest — here is the roadmap from here to
-> the targets."
-
----
-
-## Slide 15 — Roadmap to the North Star
-
-**The path from the grounded metrics to the 12–18 month targets — each
-deferred metric has an unblock path and a candidate milestone.**
-
-| Timeframe | Work | Unblocks |
-|-----------|------|----------|
-| Near-term | Live AWS re-provisioning | Live infra health, live outbox write rate, live cost reconciliation, SLA |
-| Near-term | Auto-grant implementation | Onboarding funnel (requested → granted) |
-| Mid-term | Drift-detection scheduler | Drift auto-reversal |
-| Mid-term | Audit-ledger build-out (Object Lock + signed checkpoints) | Tamper-evident ledger checkpoints |
-| Mid-term | Hot-path activation (live-ops dashboard goes from batch to near-real-time) | Live-ops dashboard freshness |
-| Longer-term | ML anomaly-forecasting service | Predictive vs reactive ratio |
-
-- Each deferred metric has a specific unblock requirement and a
-  candidate future milestone.
-- Re-evaluation triggers: each blocking piece of work lifts on its own
-  schedule; the metrics layer evolves as each one lands.
-
-> **Benefit:** every deferred metric has an unblock path — nothing is
-> hand-waved; everything has a plan and a timeframe.
-
-> **Speaker notes:** This is the bridge from "honestly deferred" to
-> "here is how we get there." The roadmap uses timeframes, not status —
-> most of it is not implemented yet, so a status column would be noise.
-
-> **Transition:** "The unblock path is clear — here is the 12-month
-> product arc."
-
----
-
-## Slide 16 — 12-Month Product Roadmap
-
-**The product arc from pilot activation to integration — four quarters,
-four outcomes.**
-
-| Quarter | Theme | Board-level outcome |
-|---------|-------|---------------------|
-| **Q1** | Pilot Activation | Nova runs a real customer estate end-to-end, autonomously, with a measurable zero-touch rate. |
-| **Q2** | Provable Trust | Every automated decision lands in a tamper-evident ledger; the CFO sees real cloud-spend reconciliation. |
-| **Q3** | Compounding ROI | Quarter-over-quarter cloud spend drops; drift is detected and reversed without a human. |
-| **Q4** | Integration & Predictive | AI agents deploy through Nova by default; the ML anomaly-forecasting service goes live. |
-
-Grounded in the four strategic objectives (autonomy, provable trust, ROI,
-integration) and the deferred-metric unblock paths.
-
-> **Benefit:** the 12-month product arc — each quarter activates a
-> strategic objective and its corresponding board-level metric, from
-> pilot activation through integration leadership.
-
-> **Speaker notes:** The roadmap is organized by product outcome, not
-> by technical milestone. Each quarter activates one strategic
-> objective from the North Star.
-
-> **Transition:** "Here is the quarter-by-quarter detail."
-
----
-
-## Slide 17 — Quarter-by-Quarter Outcomes
-
-| Quarter | Product theme | Key deliverable | Target metric | Grounding |
-|---------|---------------|-----------------|---------------|-----------|
-| **Q1** | Pilot Activation | Re-provision live AWS; activate first pilot estate; onboarding auto-grant | Touchless ≥ 99% · Escalation < 0.1% · Accuracy ≥ 99.5% | Objective #1 — autonomy as the default |
-| **Q2** | Provable Trust | Tamper-evident ledger (Object Lock + signed checkpoints); daily checkpoints; live cost reconciliation | Decision Ledger Coverage 100% · Cost Savings ≥ 25% | Objective #2 — trust is the moat |
-| **Q3** | Compounding ROI + Drift | Drift-detection scheduler; auto-reversal; pre-apply → actual-spend reconciliation on the pilot estate | Drift Auto-Reversal ≥ 95% · Spend Reduction ≥ 25% | Objective #3 — CFO-pointable numbers |
-| **Q4** | Integration + Predictive | ML anomaly-forecasting; AI-agent intent surface; multi-cloud (Azure/GCP) preview | Predictive:Reactive ≥ 3:1 · AI-Agent Intent Share (first measurement) | Objective #4 — default substrate for agents |
-
-**Month-18 destination:** *"Nova is the layer enterprise leadership
-points to when they say 'we don't have an infrastructure ops team
-anymore, and the audit trail is stronger than it ever was.'"*
-
-> **Benefit:** each quarter has a concrete deliverable, a target metric
-> grounded in a strategic objective, and a path from "honestly deferred"
-> to "shipped and measured."
-
-> **Speaker notes:** Q1–Q3 are committed (grounded pipeline + known
-> unblock paths). Q4 targets are committed-deliverable,
-> aspirational-metric — the ML service ships, the intent-share number is
-> a first measurement (we do not control adoption rate).
-
-> **Transition:** "Production-grade guidance is how Nova helps the
-> citizen developer's AI agent meet the bar — here is the first half."
-
----
-
-## Slide 18 — Production-Grade Guidance via Atelier (1/2)
-
-**Nova instructs the citizen developer's AI agent on production-grade
-engineering — a set of skills and an MCP server.**
-
-- **Skills** — markdown files keyed to production-grade engineering
-  domains (API, security, data, testing, observability, errors, DevOps,
-  infrastructure-as-code, compliance). The skills extend the baseline
-  catalog with Nova-specific production-grade principles.
-- **MCP server** — a plugin-registry, stdio server exposing four tools:
-  `lookup_principle`, `list_domains`, `matrix_lookup`, and
-  `validate_against_principles`. The developer's AI agent (or any
-  agentic SDLC platform) calls these tools to look up the principles
-  that apply to its submission.
-- **The integration point is the same regardless of source.** Whether
-  the submission comes from an AI coding agent, an agentic SDLC
-  platform, or a traditional IDE, the same skills and MCP server apply.
-  This is how Nova makes the citizen developer production-grade without
-  owning the PDLC.
-
-> **Benefit:** the citizen developer's AI agent is not unguided — Nova
-> provides production-grade engineering principles as skills and as an
-> MCP surface, so submissions arrive at the contract boundary already
-> aligned with the platform's standards.
-
-> **Speaker notes:** This is the first half of the Atelier story — the
-> surface (skills + MCP). The next slide is what the surface catches
-> that deterministic scanners cannot.
-
-> **Transition:** "Here is what that guidance catches that deterministic
-> scanners cannot."
-
----
-
-## Slide 19 — Production-Grade Guidance via Atelier (2/2)
-
-**Agentic validation catches engineering-discipline gaps that deterministic
-scanners miss — and the validation is reproducible.**
-
-- **Beyond deterministic scanners.** Wiz, Checkmarx, and Mend check
-  policy and secrets — they do not check engineering discipline. The
-  Atelier MCP server catches correctness, clarity, and observability gaps
-  that deterministic tools cannot: "is this service observable?",
-  "is this error path handled?", "is this API contract clear?"
-- **Agentic validation, not a second policy engine.** The MCP server
-  gives the AI agent the principles to validate against; the agent does
-  the validation. This is agentic validation — the agent reasons about
-  the submission against the principles, not a second static scan.
-- **Vendored for audit reproducibility.** Atelier is vendored at a
-  pinned tag. A validation result is replayable against the exact
-  principles that produced it — so an audit can reproduce a validation
-  months later, not just trust a log line.
-
-> **Benefit:** the citizen developer's submission is checked for
-> engineering discipline, not just policy compliance — and the check is
-> reproducible for audit. That is what makes the submission
-> production-grade, regardless of which upstream platform produced it.
-
-> **Speaker notes:** The value is the gap deterministic scanners leave:
-  engineering discipline. Policy scanners catch "is this S3 bucket
-  public?"; the MCP server catches "is this service observable if that
-  bucket fails?". The vendoring point is audit reproducibility — the
-  validation is not a black box.
-
-> **Transition:** "You've seen the problem, the solution, and the proof.
-> Here is the recap and the ask."
-
----
-
-## Slide 20 — Recap + Ask
-
-**The 4-beat recap + the business decision.**
-
-**Recap:**
-- **Problem:** product teams own infrastructure without the discipline
-  and lifecycle planning it requires; bandwidth gaps and tribal
-  knowledge leave operations exposed.
-- **Solution:** autonomous cloud delivery — operations become visible,
-  trust is provable (deterministic scoring), humans at stage gates.
-- **Proof:** 100% ledger coverage, 100% attestation coverage, grounded
-  ROI formula, four CTO-grade metrics flowing into PowerBI.
-- **Roadmap:** deferred metrics have unblock paths; the 12-month product
-  arc activates one strategic objective per quarter.
-
-**The ask:** "Approve a pilot estate to activate the production-denominator
-metrics (Lead Time, Vulnerability Count, MTTR, Cloud Spend), and approve
-the tamper-evident ledger build-out to move from the local hash-chain to
-S3 Object Lock + signed checkpoints. These two decisions move Nova from
-'pipeline-ready' to 'production-proven.'"
-
-> **Benefit:** a clear business decision — approve a pilot and the ledger
-> build-out — with the confidence that every claim in this deck is
-> grounded, derived, or honestly deferred.
-
-> **Speaker notes:** The ask is a business decision, not insider
-> language. "Approve a pilot estate" is a C-suite decision. "Approve the
-> ledger build-out" is a budget decision. The recap reinforces the 4-beat
-> arc — the audience leaves with the structure, not a pile of facts.
-
----
-
-## Appendix A1 — Metrics Glossary
-
-| KPI | Definition | Status |
-|-----|-----------|--------|
-| Touchless Resolution Rate | runs without operational stage-gate block ÷ total | partial (Post-Pilot) |
-| Human Escalation Frequency | operational stage-gate blocks ÷ total | partial (Post-Pilot) |
-| Automated Decision Accuracy | decisions not followed by failure within 5min | partial (Post-Pilot) |
-| MTTR (p95) | apply.failed → successful retry | grounded |
-| Confidence-Gate Halt Rate | runs with band=block ÷ total | grounded |
-| Provisioning Lead Time | run.completed − run.started | grounded |
-| Deployment Frequency | count(run.completed) per day | grounded |
-| Cost Savings (pre-apply) | sum(delta_usd where delta < 0) | partial (live reconciliation deferred) |
-| FTE Hours Saved | run count × manual baseline × rate | derived (N=0 caveat) |
-| Platform ROI | (labor + cloud + avoided downtime) ÷ op cost | derived (N=0 caveat) |
-| Decision Ledger Coverage | decisions with outcome ÷ total | grounded |
-| Attestation Coverage | prod/dr attested ÷ total prod/dr | grounded |
-| Policy Compliance Rate | 1 − failed_assets ÷ total | grounded |
-
-> **Benefit:** a reference for every metric mentioned in the deck.
-
----
-
-> **End of deck.** 20 main slides + 1 appendix slide = 21 total.