diff --git a/.ciagent/REQUIREMENTS.md b/.ciagent/REQUIREMENTS.md index c350a58..d41283a 100644 --- a/.ciagent/REQUIREMENTS.md +++ b/.ciagent/REQUIREMENTS.md @@ -455,3 +455,61 @@ | REQ-113 | 53 | complete (v1.9.10) | | REQ-114 | 54 | complete (v1.9.11) | | REQ-115 | 55 | complete (v1.9.12) | + +## v1.11 (active — RESTART: stateless adapter + pipeline-driven module lifecycle testing, tag `v1.11.0`) + +The v1.11 milestone closes G-005 (CAP-017..022 deploy-unverified) and G-008 +(no cost docs) via a corrected architecture. The first v1.11 attempt is +abandoned (branches `phase/56-iam-re-bootstrap` + `phase/57-live-deploy-microservice`); +the restart branches off `v1.10.2`. + +### Category: Stateless Adapter +- **REQ-123** — The terraform adapter (`adapters/terraform/adapter.py`) is 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 owning its resource shape, nested blocks, and defaults. The adapter reads the registry and emits `module "x" { source = ... }` blocks. No type-specific logic in the adapter. (Phase P56a) + +### Category: Per-Module Terraform +- **REQ-124** — All 12 L1 modules have a `terraform/` subdir (`versions.tf`/`variables.tf`/`locals.tf`/`main.tf`/`outputs.tf`) with defaults centralized in `locals.tf` (heavy interpolation of vars against sensible defaults). `interface.json` stays engine-agnostic. The registry has a `terraform_dir` field per entry. (Phase P56b) + +### Category: Shell Lifecycle Modes +- **REQ-125** — `scripts/run_platform.sh` gains `--apply` and `--destroy` modes; the shell owns all terraform lifecycle. Python never runs terraform. `scripts/verify_deploy_microservice.py` is deleted. (Phase P57) + +### Category: Single Platform VPC + Deterministic State +- **REQ-126** — `terraform/platform/main.tf` owns ONE VPC; the microservice composition references it via `data` source (no inline VPC). State keys are deterministic and env-aware (`spike/{id}/{env}/terraform.tfstate`), stable across apply/modify/destroy. (Phase P58) + +### Category: L1 Lifecycle Pipeline +- **REQ-127** — 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. The "test" = the pipeline cell going green. (Phases P59–P60) + +### Category: L2 Lifecycle Pipeline +- **REQ-128** — The lifecycle pipeline extends to L2 modules (static-assets, microservice). L2 = composition only (no L2 terraform files); the composition is deterministic (same contract → same stack → same state key). (Phases P61–P62) + +### Category: Operating Model + G-005/G-008 Closure +- **REQ-116** — CAP-017..022 marked Verified in CAPABILITY_INVENTORY + PROJECT + decks with "Verified live-aws via lifecycle pipeline; torn down to zero-cost" note. (Phase P65) +- **REQ-118** — Both leadership decks rewritten to reflect verified-then-torn-down status; no stale "deploy-unverified" claims. (Phase P65) +- **REQ-119** — `.ciagent/COST.md` documents the v1.0→v1.10 AWS spend window (Cost Explorer query). (Phase P63) +- **REQ-120** — `.ciagent/PRE_MORTEM.md` documents the v1.10 decay root cause + forward pre-mortem. (Phase P64) +- **REQ-121** — CAP-017..022 added to the regression registry (evidence = lifecycle pipeline green). (Phase P63) +- **REQ-122** — All deployed stacks torn down via `--decommission` (D-070 two-step, CR CHG0680001); zero live ACDL resources remain. (Phase P64) + +### v1.11 Traceability + +| Requirement | Phase | Status | +|-------------|-------|--------| +| REQ-123 | P56a | active | +| REQ-124 | P56b | pending | +| REQ-125 | P57 | pending | +| REQ-126 | P58 | pending | +| REQ-127 | P59, P60 | pending | +| REQ-128 | P61, P62 | pending | +| REQ-116 | P65 | pending | +| REQ-118 | P65 | pending | +| REQ-119 | P63 | pending | +| REQ-120 | P64 | pending | +| REQ-121 | P63 | pending | +| REQ-122 | P64 | pending | + +### Out of Scope (v1.11) +- OIDC act_runner adoption (pending go-gitea/gitea#36988). +- Per-phase regression (G-007: milestone-level regression gate is correct). +- Audit ledger build-out (D-083). +- Operator-supplied evidence. +- Pilot onboarding (G-001). +- Boto3 post-deploy verification probes (CAP-017..022 live-verify via boto3) — deferred to a future QA milestone. The lifecycle pipeline apply→destroy IS the verification for v1.11. diff --git a/.ciagent/ROADMAP.md b/.ciagent/ROADMAP.md index 1817348..38d3cde 100644 --- a/.ciagent/ROADMAP.md +++ b/.ciagent/ROADMAP.md @@ -21,7 +21,8 @@ - **v1.9.8 (complete, tag `v1.9.8`):** full presentation rework — scope, story arc, visuals, appendix. 6 new mermaid diagrams (scope boundary x2, confidence signal, attestation flow, promotion journey, road to north star). Both decks restructured to 10 main + 6 appendix slides. NEW scope slide clarifying ACDL is infrastructure only. Story beat lines on every slide. Contract examples fixed (image: removed, infra inputs instead). QA attestation reclassified (Design tested → Planned). Confidence signal + attestation flow + promotion journey visuals added. Road to the North Star phased timeline in appendix. Full Testing vs. Planned inventory + glossary in appendix. Source markdown + talking points + README all updated. Docs-only NFR patch. **Last deck-polish phase before the v1.10 deck-freeze.** - **v1.10 (complete, tag `v1.10.0`):** pipeline regression fix + capability re-verification + verified-reality rewrite. The v1.9.1–v1.9.8 deck work is **superseded-by-reverification**: the decks presented advertised capability as current without disclosing that the platform had decayed (7 adapter defects prevented `terraform init/validate/plan` against live AWS). v1.10 re-verified every advertised capability, fixed all 7 defects in-sweep (D-090: no cap), and rewrote PROJECT/ROADMAP/decks to match verified reality. Decks unfrozen only after Phase 55 lands. See the v1.10 section below for the 4-phase breakdown. - **v1.10.1 (complete, tag `v1.10.1`):** post-v1.10 NFR patch — adversarial grill review (12 challenges, 10 binding decisions, 2 escalations: G-005 risks, G-008 budget), 4-layer verify gate (PASS), multi-persona code review (1 P1 auto-fixed: mis-citation PROJECT.md:6 → PROJECT.md:487). ACDL reclassified as OSS reference implementation (G-003). Docs-only; 518 tests pass; regression gate 16/16 Verified. Gitea release id 236. -- **v1.10.2 (complete, tag `v1.10.2`):** contract surface redesign + rename + .yml repo-wide + deck polish. **Breaking contract schema change**: new top-level fields `id` (3-6 char acronym → stack.name), `name` (full → stack.title), `infrastructure` (map keyed by module name, replaces `module:`). Dropped `uses:` (dead reference — version pin lives in CI workflow), top-level `module:`/`inputs:`. Per-module `version` defaults to latest published. Multi-module contracts deploy N modules in one pipeline run with namespaced resource IDs. Rename: `pipelines/deploy.yaml` → `pipelines/contract.yml`. All 44 `.yaml` → `.yml` repo-wide. Deck polish: contract examples updated to new shape, S&P Red/Black/White mermaid theme (all 10 diagrams), GRILL G-005 Verification Coverage block, GRILL G-008 A6 Operating Model & Cost appendix slide, story beat prefix stripped, ACDL spelled out on DX slide 2. Code review: 3 P0 auto-fixed, 2 P1+ flagged. 494 tests pass. Gitea release id 237. +- **v1.10.2 (complete, tag `v1.10.2`):** contract surface redesign + rename + .yml repo-wide + deck polish. Breaking contract schema change: new top-level fields `id`/`name`/`infrastructure`; dropped `uses:`/`module:`/`inputs:`. All 44 `.yaml` → `.yml`. Code review: 3 P0 auto-fixed, 2 P1+ flagged. 494 tests pass. Gitea release id 237. +- **v1.11 (active, tag `v1.11.0`):** RESTART — stateless adapter + pipeline-driven module lifecycle testing. Closes G-005 (CAP-017..022 deploy-unverified) and G-008 (no cost docs) via a corrected architecture, not the failed v1.11 first attempt (which produced 4 drifted VPCs, ran terraform apply from Python, and had no module lifecycle tests). The restart branches off `v1.10.2` and rebuilds v1.11 on three corrections: (1) the terraform adapter becomes a stateless assembler — each L1 module ships a real `terraform/` module dir (variables/locals/main/outputs) owning its resource shape, nested blocks, and defaults; the adapter deletes `TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP` and all 39 type-specific branches, becoming a ~80-line assembler that emits `module "x" { source = ... }` blocks; (2) lifecycle is owned by terraform via the shell orchestrator (`run_platform.sh --apply`/`--destroy`), never by Python — `verify_deploy_microservice.py` is deleted; (3) testing is pipeline-driven — 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. A single platform VPC (`terraform/platform`) is shared by all stacks via `data` source — no per-contract VPC. State keys are deterministic and env-aware (`spike/{id}/{env}/terraform.tfstate`), stable across lifecycle changes. 13 phases (P56a–P65). See the v1.11 section below for the phase breakdown. - **v1.0 demo URL:** https://git.cloudinit.dev/continuous-intelligence/acdl-evidence/raw/branch/main/index.html --- @@ -708,3 +709,180 @@ adapters), D-093 (re-verify v1.1→v1.8; v1.0 demo excluded), D-094 After Phase 55: COMPLETE gate — review → ship `v1.10.0` (next minor; fix/test/docs, not a breaking schema change) → audit. **DONE.** + +--- + +## v1.11 (active — RESTART: stateless adapter + pipeline-driven module lifecycle testing, tag `v1.11.0`) + +The v1.11 milestone closes the two GRILL escalations blocking the leadership +pitch: G-005 (6 IAM-gated cloud capabilities CAP-017..022 deploy-unverified) +and G-008 (no cost documentation despite live AWS resources). + +**Why a restart.** The first v1.11 attempt (P56 IAM re-bootstrap + P57 +live-deploy-microservice, branches `phase/56-iam-re-bootstrap` + +`phase/57-live-deploy-microservice`, now abandoned) produced five defects: +(1) 4 VPCs created when 1 should have — the adapter emitted per-contract +state keys with no VPC sharing; (2) Python scripts made lifecycle changes +directly to the cloud (`verify_deploy_microservice.py` ran `terraform apply +-auto-approve`); (3) no L1 module lifecycle testing — `tests/test_adapter.py` +only string-validated HCL, never ran terraform apply/modify/destroy; (4) no +L2 integration testing; (5) lifecycle was managed by Python, not terraform. +The restart branches off `v1.10.2` and rebuilds v1.11 on three corrections. + +**The three corrections.** +1. **Stateless adapter.** `adapters/terraform/adapter.py` (918 lines, 3 + hardcoded constant tables `TYPE_MAP`/`INPUT_MAP`/`OUTPUT_MAP`, 39 + type-specific branches) is rewritten 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 HCL 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. + `interface.json` stays engine-agnostic; the terraform dir is the engine + binding. Defaults move into `locals.tf` (heavy interpolation of vars + against sensible defaults). +2. **Terraform owns lifecycle.** `scripts/run_platform.sh` gains `--apply` + and `--destroy` modes. Python never runs terraform. + `scripts/verify_deploy_microservice.py` is deleted. The shell owns all + apply/modify/destroy; Python only orchestrates the shell (and may use + boto3 for read-only verify probes in a future QA milestone, not this one). +3. **Pipeline-driven testing.** 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 (terraform apply exit 0 → modify exit 0 → destroy exit 0). + +**Single platform VPC.** `terraform/platform/main.tf` owns ONE VPC; the +microservice composition drops its `vpc` child and references the platform +VPC via `data` source. The standalone `vpc` L1 module stays (consumers +deploy their own VPCs). State keys are deterministic and env-aware +(`spike/{contract.id}/{contract.environment}/terraform.tfstate`), stable +across apply/modify/destroy — the same contract+env always hits the same +state key, so terraform modifies rather than duplicates. + +**L2 = composition only.** L2 modules keep `composition.json` only (no L2 +terraform files). The composition must be deterministic: same contract → +same resolved stack → same state key, every time. + +**Versioning.** Feature milestone (P56a/P56b/P57/P58/P59/P60/P61/P62 are +feat). Ship tag at milestone COMPLETE: `v1.11.0` (v1.10.2 → v1.11.0). + +**Wave ordering.** Wave 1 (P56a → P56b → P57 → P58) is sequential — the +stateless adapter, shell lifecycle modes, and platform VPC are prerequisites +for all testing. Wave 2 (P59 → P60) authors then runs the L1 lifecycle +pipeline. Wave 3 (P61 → P62) authors then runs the L2 lifecycle pipeline. +Wave 4 (P63 → P64 → P65) closes G-005/G-008 + teardown + deck rewrite. + +### Phase P56a — stateless-adapter-rewrite (Wave 1) +- **Description:** Rewrite `adapters/terraform/adapter.py` from a 918-line monolith (3 constant tables + 39 type-specific branches) to a ~80-line stateless assembler. Author `modules/l1/s3/terraform/` (`versions.tf`/`variables.tf`/`locals.tf`/`main.tf`/`outputs.tf`) as the reference module proving the assembly path end-to-end. Extend `modules/registry.json` with a `terraform_dir` field. Rewrite `modules/STANDARDS.md` §8 from "three tables + specialized branches" to "stateless assembler + per-module terraform dir". Rewrite `tests/test_adapter.py` to assert module-instantiation assembly (root `main.tf` contains `module "x" { source = ... }` blocks with correct inputs + refs), not HCL string matching. +- **Status:** active +- **Depends on:** — +- **Requirements:** REQ-123 +- **Success Criteria:** + - `grep -n "TYPE_MAP\|INPUT_MAP\|OUTPUT_MAP\|rtype ==" adapters/terraform/adapter.py` returns nothing. + - `wc -l adapters/terraform/adapter.py` < 100. + - `modules/l1/s3/terraform/` passes `terraform init + validate` standalone. + - Adapter, given the s3 instance, emits a root `main.tf` that `terraform init + validate` accepts. + +### Phase P56b — l1-module-terraform-authoring (Wave 1) +- **Description:** Author the remaining 11 L1 module terraform subdirs (`vpc`, `ecs-cluster`, `ecs-service`, `iam-role`, `alb`, `ecr`, `cloudfront`, `waf`, `rds`, `kms-key`, `uptime`) with the full `versions.tf`/`variables.tf`/`locals.tf`/`main.tf`/`outputs.tf` split. Defaults currently hardcoded in the adapter (CIDR blocks, assume_role_policy JSON, ECR/logs inline policy, Fargate requires_compatibilities, assign_public_ip, listener/target ports) move into `locals.tf` as heavy interpolation of vars against sensible defaults. Multi-resource modules get the full split; trivial single-resource modules (kms-key, ecr) may inline locals in main.tf. Each module's `interface.json` stays engine-agnostic. Add `terraform_dir` to each registry entry. +- **Status:** pending +- **Depends on:** [P56a] +- **Requirements:** REQ-124 +- **Success Criteria:** + - All 12 `terraform/` subdirs pass `terraform init + validate` standalone. + - No defaults remain in the adapter. + - Each registry entry has a `terraform_dir` field. + +### Phase P57 — shell-orchestrator-lifecycle-modes (Wave 1) +- **Description:** `scripts/run_platform.sh` gains `--apply ` and `--destroy ` modes. `--apply` runs resolve → adapter → `terraform init` → `terraform apply -auto-approve` (HITL gate for qa/prod/dr). `--destroy` runs resolve → adapter → `terraform destroy -auto-approve` (gated behind `--decommission` + CR validation, D-070 two-step). `--modify` is implicit (a second `--apply` with a changed contract produces a terraform diff). Delete `scripts/verify_deploy_microservice.py` (the offending script that ran `terraform apply` from Python). +- **Status:** pending +- **Depends on:** [P56b] +- **Requirements:** REQ-125 +- **Success Criteria:** + - `run_platform.sh --apply` and `--destroy` modes exist and are the ONLY path to terraform apply/destroy. + - `grep -rn "terraform apply\|terraform destroy" scripts/*.py` returns nothing. + - `verify_deploy_microservice.py` no longer exists. + +### Phase P58 — single-platform-vpc-deterministic-state (Wave 1) +- **Description:** Add a single VPC (`aws_vpc.acdl_shared` 10.0.0.0/16, 2 public subnets, IGW, route table, ECS security group) to `terraform/platform/main.tf`; output `vpc_id`, `public_subnet_ids`, `ecs_security_group_id`. `modules/l2/microservice/composition.json` drops the `vpc` child and references the platform VPC via a `data_sources` block. `core/contract_resolver.py` resolves `data:platform/vpc` references. The adapter emits `data "terraform_remote_state" "platform"` + `data "aws_vpc"`/`data "aws_subnets"` blocks, never an inline `aws_vpc` for the microservice stack. State key fix: `spike/{contract.id}/{contract.environment}/terraform.tfstate` (deterministic, env-aware, stable across lifecycle). Add `state_key` derivation to `schemas/contract.schema.json`. +- **Status:** pending +- **Depends on:** [P57] +- **Requirements:** REQ-126 +- **Success Criteria:** + - `terraform/platform` apply creates exactly ONE VPC. + - `contracts/microservice.yml` resolution produces NO `aws:ec2:vpc` resource. + - Two contract applies (dev + prod) → ONE VPC, two state keys, two ECS services. + - Same contract+env re-applied → same state key → terraform modifies, never duplicates. + +### Phase P59 — l1-lifecycle-pipeline-author (Wave 2) +- **Description:** Author `pipelines/modules-lifecycle.yml` (declarative contract: validate → resolve → apply → modify → destroy) + byte-identical `.gitea/workflows/modules-lifecycle.yml` + `.github/workflows/modules-lifecycle.yml`. Matrix over 12 L1 modules × {simple, complex} example contracts. Each cell: `run_platform.sh --apply examples/simple.yml` → `run_platform.sh --apply examples/complex.yml` (same state key → terraform modifies) → `run_platform.sh --destroy examples/complex.yml`. VPC-dependent L1s (alb, ecs-service, rds, uptime) reference the platform VPC applied by a prerequisite job; standalone `vpc` L1 applies its own. Trigger: `pull_request: [main]` + `workflow_dispatch`. Author `schemas/modules-lifecycle-pipeline.schema.json`. Extend `tests/test_pipeline_contract.py` (offline: validate schema + byte-identical). +- **Status:** pending +- **Depends on:** [P58] +- **Requirements:** REQ-127 +- **Success Criteria:** + - Pipeline YAML validates against its schema. + - Gitea + GitHub workflows are byte-identical. + - `test_pipeline_contract.py` passes (offline). + - Matrix lists all 12 L1 modules × 2 examples. + +### Phase P60 — l1-lifecycle-pipeline-live-run (Wave 2) +- **Description:** Run the P59 pipeline against live AWS; fix every module whose apply/modify/destroy fails. Each failing cell is a module defect: bad `terraform/` subdir (resource shape, nested blocks, defaults), bad example contract, or bad adapter assembly. Fixes land in `modules/l1//terraform/*.tf`, `modules/l1//examples/*.yml`, and rarely the adapter assembler. No new Python files. +- **Status:** pending +- **Depends on:** [P59] +- **Requirements:** REQ-127 +- **Success Criteria:** + - Full L1 lifecycle matrix green: 12 modules × 2 examples = 24 cells, each apply→modify→destroy exit 0. + - No live resources remain after the run (destroy enforced). + - `primitives-plan.yml` (plan-only) still passes. + +### Phase P61 — l2-lifecycle-pipeline-author (Wave 3) +- **Description:** Extend `pipelines/modules-lifecycle.yml` + both forge workflows with an L2 matrix: `static-assets` × `contracts/static-assets.yml` (apply → modify: add WAF rule → destroy) and `microservice` × `contracts/microservice.yml` (apply → modify: `desired_count` 1→2 → destroy, references platform VPC). Author `modules/l2/static-assets/examples/complex.yml` + `modules/l2/microservice/examples/complex.yml` (modify variants, defined within the modules). L2 = composition only (no L2 terraform files); the composition must be deterministic (same contract → same resolved stack → same state key, every time). +- **Status:** pending +- **Depends on:** [P60] +- **Requirements:** REQ-128 +- **Success Criteria:** + - L2 matrix lists both modules with apply→modify→destroy cells. + - Composition resolution is deterministic (same contract → same stack, byte-identical). + +### Phase P62 — l2-lifecycle-pipeline-live-run (Wave 3) +- **Description:** Run the L2 lifecycle pipeline live; fix composition wiring + adapter assembly until green. This replaces the deleted `verify_deploy_microservice.py` — the pipeline IS the verify. CAP-017..022 boto3 probes are deferred to a future QA milestone. Fixes land in `modules/l2//composition.json`, `modules/l2//examples/*.yml`, `core/contract_resolver.py`, and rarely the adapter. No new Python files. +- **Status:** pending +- **Depends on:** [P61] +- **Requirements:** REQ-128 +- **Success Criteria:** + - L2 matrix green: static-assets + microservice, each apply→modify→destroy exit 0. + - Microservice apply creates NO inline VPC (references platform VPC). + - Same state key across apply/modify/destroy (deterministic). + - `patterns-plan.yml` (plan-only) still passes. + +### Phase P63 — regression-registry-cost-docs (Wave 4) +- **Description:** Add CAP-017..022 to `core/regression_verify.py` registry (evidence = lifecycle pipeline green, not boto3 probes). Author `.ciagent/COST.md` (AWS Cost Explorer 6-day window query: v1.0 ship 2026-07-21 → v1.10 complete 2026-07-27; document monthly + per-day if available). Closes G-008. +- **Status:** pending +- **Depends on:** [P62] +- **Requirements:** REQ-119, REQ-121 +- **Success Criteria:** + - Regression registry includes CAP-017..022 with "lifecycle pipeline green" evidence. + - `COST.md` documents the v1.0→v1.10 spend window. + +### Phase P64 — pre-mortem-teardown (Wave 4) +- **Description:** Author `.ciagent/PRE_MORTEM.md` (v1.10 decay root cause + forward pre-mortem for the OSS reference + leadership pitch). `run_platform.sh --decommission` with CR CHG0680001 — tears down ALL deployed stacks INCLUDING the 4 drifted VPCs from the failed first attempt. HITL SRE gates (D-070 two-step). D-096 enforced (live resources do not persist past v1.11). +- **Status:** pending +- **Depends on:** [P63] +- **Requirements:** REQ-120, REQ-122 +- **Success Criteria:** + - `PRE_MORTEM.md` documents the decay root cause + forward pre-mortem. + - All deployed stacks torn down; zero live ACDL resources remain. + +### Phase P65 — rewrite-caps-decks (Wave 4) +- **Description:** Rewrite `CAPABILITY_INVENTORY.md`, `PROJECT.md` §Capability Status, and both leadership decks: CAP-017..022 → "Verified live-aws via lifecycle pipeline ; torn down to zero-cost steady state." Remove the IAM-drift framing. Add the cost appendix slide (P63) + pre-mortem reference (P64). Re-render HTML; upload PPTX to the v1.11.0 release. `ci-doc-verifier` confirms no stale "deploy-unverified" claims remain. +- **Status:** pending +- **Depends on:** [P64] +- **Requirements:** REQ-116, REQ-118 +- **Success Criteria:** + - CAPABILITY_INVENTORY + PROJECT + decks all reflect "Verified live-aws via lifecycle pipeline; torn down to zero-cost." + - `ci-doc-verifier` confirms no stale "deploy-unverified" claims. + - HTML re-rendered; PPTX uploaded to v1.11.0 release. + +After Phase P65: COMPLETE gate — review → ship `v1.11.0` (next minor; +feature milestone) → audit. **DONE.** diff --git a/.ciagent/config.json b/.ciagent/config.json index 2a1e0d4..ce3213a 100644 --- a/.ciagent/config.json +++ b/.ciagent/config.json @@ -4,8 +4,11 @@ { "slug": "acdl", "name": "Agentic Cloud Delivery Platform", - "milestone": "v1.10", - "status": "complete" + "milestone": "v1.11", + "status": "active", + "restart": true, + "restart_branch": "milestone/v1.11-restart", + "restart_base": "v1.10.2" } ], "active_project": "acdl",