phase: 6, status: plan-as-execute, persona: lead-developer, task: T-6.1..T-6.4

---ci---
project: acdl
phase: 6
milestone: v1.1
status: plan-as-execute
persona: lead-developer
tasks: [T-6.1, T-6.2, T-6.3, T-6.4]
---/ci---

Archive the v1.0 demo under demo/ (D-037) and reorient the repo to the
real platform. Wave 1 of the Phase 06 plan.

- T-6.1: git mv modules/, scripts/, evidence-ui/, contracts/,
  contracts-repo/, .gitea/ -> demo/; mv ACDL_DEMO.md + runner-data/ -> demo/
- T-6.2: scaffold new v1.1 top-level dirs (platform/, schemas/, adapters/,
  terraform/, modules-ir/) with .gitkeep
- T-6.3: create top-level scripts/verify_phase06.sh (v1.1 verify scripts
  live at top-level, NOT demo/scripts/ which holds the v1.0 demo verify
  scripts)
- T-6.4: rewrite README.md to reflect the real platform (vision +
  architecture links, new layout, status v1.1 active); add runner-data/
  to .gitignore

All moves via git mv (history preserved). Repo root now contains only
README.md, demo/, docs/, .ciagent/, and the new empty v1.1 dirs.

.gitignore

@@ -7,3 +7,4 @@ state.json
 audit.json
 *.tmp
 .DS_Store
+runner-data/

README.md

@@ -1,55 +1,52 @@
 # ACDL — Agentic Cloud Delivery Platform
 
-A 30-minute executive demo proving that infrastructure can be delivered
+Consumers declare intent; the platform delivers safe production deployment
-**automatically, safely, and with a complete audit trail** — without the
+through an agentic stack — automatically, safely, and with a complete audit
-usual weeks of manual tickets, reviews, and copy-pasted configuration.
+trail. A merged change progresses through lower environments end-to-end
+without a platform engineer joining a thread; a non-technical consumer ships
+a production deployment by declaring intent, without authoring a workflow,
+a configuration file, or a Terraform module.
 
-The demo runs entirely on **local stubs** (no AWS/GCP/Azure, no external LLM
+- **Vision** (the why): [`docs/vision.md`](docs/vision.md)
-APIs). It shows intent and safety behavior rather than provisioning real
+- **Architecture** (the how): [`docs/architecture.md`](docs/architecture.md)
-cloud resources.
+- **Decisions**: [`.ciagent/PROJECT.md`](.ciagent/PROJECT.md)
+- **Target architecture**: [`.ciagent/ARCHITECTURE.md`](.ciagent/ARCHITECTURE.md)
+- **Phase plan**: [`.ciagent/ROADMAP.md`](.ciagent/ROADMAP.md)
 
-## Four acts
+## Status
 
-1. **Act 1 — The Friction:** the old manual 2-week deployment process.
+- **v1.1 (active):** architecture finalization + v1 spike. Finalize the
-2. **Act 2 — Developer Self-Service:** commit a valid `contract.yaml` for
+  architecture to v1.0 (resolve the 11 open design decisions) and prove the
-   `l2-commodity-price-feed`, watch Dev auto-run, QA + Prod approval gates,
+  locked commitments with one end-to-end implementation spike
-   then the evidence timeline.
+  (`l1-s3` + `l2-static-asset` + Terraform adapter → real `terraform plan`
-3. **Act 3 — Citizen Developer:** open a GitHub/Gitea Issue with natural-
+  against AWS).
-   language intent; the Python keyword parser generates the same
+- **v1.0 demo (complete, archived):** tag `v1.1.0`. The 30-minute
-   `contract.yaml` and triggers the identical pipeline.
+  stub-driven executive demo is preserved under `demo/` as the intent
-4. **Act 4 — The Safety Net:** commit a malicious `contract.yaml`
+  reference; it is not the platform.
-   (`public-ingress: true`) for `l2-regulatory-reporting`; the pipeline
-   halts in Dev because the confidence signal drops below 0.50, and the
-   rejection is visible on the evidence stream.
 
-## Repositories
+## Repository layout
 
-All under the `continuous-intelligence` Gitea org at
+| Path | Purpose | Populated |
-`https://git.cloudinit.dev`:
+|------|---------|-----------|
+| `platform/` | Platform code: confidence signal, contract resolver, outbox, HITL/ledger designs | Phase 07+ |
+| `schemas/` | JSON Schemas: IR, PolicyCheckResult, contract | Phase 07 |
+| `adapters/` | Substrate adapters (Terraform adapter in v1; the only substrate-specific code per §12) | Phase 09 |
+| `terraform/` | State backend + provider config (S3 state + DynamoDB lock) | Phase 08+ |
+| `modules-ir/` | IR-typed L1/L2 modules (`l1-s3`, `l2-static-asset`) | Phase 09–10 |
+| `scripts/` | v1.1 verify scripts (`verify_phaseNN.sh`) | Phase 06+ |
+| `demo/` | Archived v1.0 executive demo (tag `v1.1.0`); runs locally via `demo/scripts/run_demo.sh --no-upload` | complete |
+| `.ciagent/` | CIAgent metadata (plans, decisions, personas, roadmap, research) | active |
+| `docs/` | Upstream vision + architecture sources | active |
 
-- `acdl` (this repo) — platform + stubs + reusable workflows
+## Running the archived demo
-- `acdl-contracts` — developer surface (`contract.yaml` + issue trigger)
-- `acdl-evidence` — audit timeline (served via raw file URLs; Gitea has no
-  native Pages — see `.ciagent/ARCHITECTURE.md` Gitea API Surface table)
 
-## Project metadata
+The v1.0 demo is an archived artifact. To re-run it locally:
-
-See `.ciagent/PROJECT.md` for the full spec, `.ciagent/ROADMAP.md` for the
-5-phase breakdown, `.ciagent/REQUIREMENTS.md` for traceable requirements,
-and `.ciagent/PERSONAS.md` for the active persona roster.
-
-## Phase 01 verification
-
-After running `scripts/gitea_setup.sh` (which creates `acdl-contracts` and
-`acdl-evidence` in the org and pushes the placeholder `index.html`), run:
 
 ```bash
-ACDL_GITEA_TOKEN=<token> scripts/verify_phase01.sh
+bash demo/scripts/run_demo.sh --no-upload
 ```
 
-The script confirms:
+The demo deck is at [`demo/ACDL_DEMO.md`](demo/ACDL_DEMO.md). The demo runs
-- both new repos exist via the Gitea API
+entirely on local stubs — no AWS, no AI — and shows intent and safety
-- the raw `index.html` URL on `acdl-evidence` returns HTTP 200
+behavior rather than provisioning real cloud resources. It is the reference
-- the `qa` and `prod` branches exist on `acdl-contracts`
+of intent for the real platform; it is not the platform itself.
-
-Exit 0 = Phase 01 success criteria met.

demo/ACDL_DEMO.md

@@ -0,0 +1,368 @@
+---
+marp: true
+theme: default
+paginate: true
+size: 16:9
+header: 'ACDL · Agentic Cloud Delivery Platform'
+footer: 'Executive Demo · v1.0'
+style: |
+  /* S&P Global-inspired palette */
+  :root {
+    --sp-red: #C8102E;
+    --sp-red-dark: #8E0B20;
+    --sp-ink: #1A1A1A;
+    --sp-slate: #4A4A4A;
+    --sp-gray: #6E6E6E;
+    --sp-line: #D6D6D6;
+    --sp-bg: #FFFFFF;
+    --sp-tint: #F4F4F4;
+  }
+  section {
+    font-size: 24px;
+    color: var(--sp-ink);
+    background: var(--sp-bg);
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    padding: 50px 60px;
+  }
+  section.title {
+    text-align: center;
+    background: var(--sp-red);
+    color: #FFFFFF;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+  }
+  section.title h1 {
+    color: #FFFFFF;
+    font-size: 64px;
+    margin-bottom: 0;
+    border: none;
+  }
+  section.title h2 {
+    color: #FFFFFF;
+    border: none;
+    font-weight: 400;
+  }
+  section.title strong { color: #FFFFFF; }
+  h1 {
+    color: var(--sp-red);
+    font-size: 40px;
+    font-weight: 700;
+    margin-bottom: 12px;
+  }
+  h2 {
+    color: var(--sp-red);
+    border-bottom: 3px solid var(--sp-red);
+    padding-bottom: 6px;
+    font-weight: 700;
+  }
+  h3 {
+    color: var(--sp-red-dark);
+    font-weight: 600;
+    margin-top: 24px;
+  }
+  ul, ol { color: var(--sp-slate); }
+  li { margin-bottom: 6px; }
+  strong { color: var(--sp-ink); }
+  table {
+    font-size: 18px;
+    width: 100%;
+    border-collapse: collapse;
+    margin: 12px 0;
+  }
+  th {
+    background: var(--sp-red);
+    color: #FFFFFF;
+    text-align: left;
+    padding: 10px 12px;
+    font-weight: 600;
+    border: 1px solid var(--sp-red-dark);
+  }
+  td {
+    padding: 8px 12px;
+    border: 1px solid var(--sp-line);
+    color: var(--sp-slate);
+  }
+  tr:nth-child(even) td { background: var(--sp-tint); }
+  pre {
+    font-size: 13px;
+    background: var(--sp-tint);
+    border-left: 4px solid var(--sp-red);
+    padding: 14px 16px;
+    border-radius: 0;
+    color: var(--sp-ink);
+  }
+  code {
+    background: var(--sp-tint);
+    color: var(--sp-red-dark);
+    padding: 1px 5px;
+    border-radius: 2px;
+    font-family: 'Menlo', 'Consolas', monospace;
+  }
+  pre code {
+    background: none;
+    color: var(--sp-ink);
+    padding: 0;
+  }
+  blockquote {
+    border-left: 5px solid var(--sp-red);
+    background: var(--sp-tint);
+    padding: 10px 16px;
+    color: var(--sp-slate);
+    font-style: italic;
+    border-radius: 0;
+  }
+  header {
+    color: var(--sp-red);
+    font-weight: 700;
+    font-size: 14px;
+  }
+  footer {
+    color: var(--sp-gray);
+    font-size: 12px;
+  }
+  section::after {
+    color: var(--sp-red);
+    font-weight: 700;
+  }
+---
+
+<!-- _class: title -->
+
+# ACDL
+## Agentic Cloud Delivery Platform
+
+Automatic. Safe. Audited. — in 30 minutes, on stubs.
+
+v1.0 · GitHub Actions · stub-driven
+
+<!--
+30-min exec demo. Emphasize: we prove INTENT and SAFETY, not provision real infra.
+Everything runs as local stubs on Linux via GitHub Actions. No AWS.
+-->
+
+---
+
+# The Problem
+
+### Today, deploying infrastructure takes **weeks**
+
+- Ticket → triage queue → copy-paste config → peer review → security review → waiting for central IT to release
+
+> Two weeks of human latency for a service that should take minutes.
+
+### What we want instead
+
+- Developer commits a **contract** → pipeline runs
+- Safety **computed** automatically (confidence signal)
+- Manual gates only where they matter (QA, Prod)
+- Every step written to a tamper-evident **evidence stream**
+
+<!--
+Set the pain. Ask: who has lived this? Then pivot to the vision.
+-->
+
+---
+
+# How It Works
+
+```
+              ┌────────────── acdl-contracts ──────────────┐
+ Developer ──▶│ commit contract.yaml                     │
+              └───────┬───────────────────────────────────┘
+                      │ (push)
+ Citizen    ┌─────────┴──────────┐
+  │ "ingest gas pricing into data lake"
+  ▼
+ Claude agent ──▶ contract.yaml ─┘
+                      │ (push)
+                      ▼
+            ┌─────────────────┐
+            │ reusable         │
+            │ GitHub Actions   │
+            │ pipeline         │
+            └────────┬────────┘
+                     │
+       ┌─────────────┼─────────────┐
+       ▼             ▼             ▼
+ Dev (auto)   QA (approval)   Prod (approval)
+       │
+       ▼
+ evidence_writer ─▶ audit.json (hash-chained) ─▶ Pages timeline
+```
+
+Two entry paths, **one** pipeline, **one** audit trail — developer via GitHub, citizen developer via their own Claude agent.
+
+<!--
+Two surfaces: developers push contracts directly to GitHub; citizen developers prompt a Claude agent they own, which writes and pushes the contract for them.
+Both converge on one GitHub Actions pipeline with three stages.
+-->
+
+---
+
+# The Safety Story
+
+### Computed, not requested
+
+| Signal | Behavior |
+|--------|----------|
+| **Base confidence** | 0.90 |
+| **On policy violation** | drop to 0.40 + reason code |
+| **Gate threshold** | ≥ 0.50 to proceed past Dev |
+
+### Policy (v1)
+- `public-ingress: true` → `POLICY_VIOLATION:PUBLIC_INGRESS`
+
+### Evidence
+- Each event appended to `audit.json` with SHA-256 link to previous (`prev_hash` + `hash`)
+- Published to Pages → vanilla-JS timeline
+
+<!--
+Safety is computed by the platform, not asked of the developer.
+Threshold 0.50 is exact → 0.90 passes, 0.40 halts. That's what makes the three scenarios deterministic.
+-->
+
+---
+
+# Scenario 1 — Developer Self-Service
+
+### Trigger
+Developer commits a valid `contract.yaml` requesting **`l2-commodity-price-feed`** via **GitHub**.
+
+### What you'll see
+- **Dev:** policy ✅ → apply api-gateway, lambda, s3 → confidence **0.90** → proceed
+- **QA:** pipeline pauses → click **Approve**
+- **Prod:** pipeline pauses → click **Approve**
+- **Finalize:** `audit.json` committed → Pages timeline updates
+
+### Evidence outcome
+Timeline shows: contract received → policy pass → apply × 3 → confidence 0.90 → QA → Prod → published.
+
+<!--
+Normal developer flow: human writes the contract, pushes to GitHub, the GitHub Action pipeline runs.
+Narrate: developer commits and walks away; platform does the rest.
+Pause visibly at each gate so the audience sees human-in-the-loop.
+End by refreshing the Pages timeline.
+-->
+
+---
+
+# Scenario 1 — Journey
+
+```mermaid
+flowchart LR
+  classDef gh fill:#F4F4F4,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
+  classDef stage fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
+  classDef gate fill:#FFFFFF,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
+  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A
+
+  D["Developer"]:::gh -->|"writes contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::gh
+  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
+  DEV -->|"policy ✅ · confidence 0.90"| QA["QA<br/>approval gate"]:::gate
+  QA -->|"approve"| PROD["Prod<br/>approval gate"]:::gate
+  PROD -->|"approve"| FIN["Finalize<br/>commit audit.json"]:::stage
+  FIN --> TL["GitHub Pages<br/>timeline"]:::evidence
+```
+
+<!--
+Point to the two approval gates — QA and Prod — both human clicks.
+The whole chain from commit to timeline is one GitHub Actions workflow.
+-->
+
+---
+
+# Scenario 2 — Citizen Developer
+
+### Trigger
+Non-technical user prompts their **own Claude agent** in natural language:
+
+> "I need a new service to ingest real-time natural gas pricing data into our data lake."
+
+### What you'll see
+- Claude agent parses intent, writes `contract.yaml` for **`l2-commodity-price-feed`**, pushes a branch
+- Issue **closed**; branch push triggers the **identical** pipeline from Scenario 1
+- Citizen developer follows the run all the way to **Prod**
+
+### Evidence outcome
+Timeline is **indistinguishable** from Scenario 1 — the agentic surface is first-class, not a bolt-on.
+
+<!--
+Punchline: same timeline, same safety, same audit — different entry.
+The citizen developer owns and drives their own Claude agent; they are the actor, not the platform.
+Normal developers (Scenario 1) keep using GitHub directly — two surfaces, one pipeline, one audit.
+-->
+
+---
+
+# Scenario 2 — Journey
+
+```mermaid
+flowchart LR
+  classDef cit fill:#F4F4F4,stroke:#C8102E,stroke-width:2px,color:#1A1A1A
+  classDef agent fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
+  classDef stage fill:#1A1A1A,stroke:#1A1A1A,stroke-width:1px,color:#FFFFFF
+  classDef gate fill:#FFFFFF,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
+  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A
+
+  CD["Citizen developer"]:::cit -->|"natural-language<br/>prompt"| CL["Claude agent<br/>(citizen-owned)"]:::agent
+  CL -->|"generates<br/>contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::cit
+  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
+  DEV -->|"policy ✅ · confidence 0.90"| QA["QA<br/>approval gate"]:::gate
+  QA -->|"approve"| PROD["Prod<br/>approval gate"]:::gate
+  PROD -->|"approve"| FIN["Finalize<br/>commit audit.json"]:::stage
+  FIN --> TL["GitHub Pages<br/>timeline"]:::evidence
+```
+
+<!--
+Highlight the red Claude-agent node — owned by the citizen, not by the platform.
+From GitHub onward the journey is identical to Scenario 1.
+-->
+
+---
+
+# Scenario 3 — The Safety Net
+
+### Trigger
+Developer commits a **malicious** `contract.yaml` for `l2-regulatory-reporting` via **GitHub**:
+
+```yaml
+stack: l2-regulatory-reporting
+public-ingress: true
+```
+
+### What you'll see
+- **Dev:** `policy_checker` → `POLICY_VIOLATION:PUBLIC_INGRESS`
+- `confidence_signal` drops 0.90 → **0.40**
+- `0.40 < 0.50` → pipeline **halts in Dev**
+- Rejection reason written to the evidence stream
+
+### Evidence outcome
+Timeline shows the attempted deploy, the violation, the confidence drop, and the **halt** — visible and explained.
+
+<!--
+The safety money shot. The platform said NO, and said WHY, on the record.
+No human had to catch it — the confidence signal computed the risk.
+Contrast with The Problem's old-world review queue.
+-->
+
+---
+
+# Scenario 3 — Journey
+
+```mermaid
+flowchart LR
+  classDef gh fill:#F4F4F4,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
+  classDef stage fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
+  classDef halt fill:#1A1A1A,stroke:#1A1A1A,stroke-width:1px,color:#FFFFFF
+  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A
+
+  D["Developer"]:::gh -->|"writes malicious<br/>contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::gh
+  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
+  DEV -->|"POLICY_VIOLATION:PUBLIC_INGRESS<br/>confidence 0.90 → 0.40"| HALT["Halt in Dev<br/>+ rejection reason"]:::halt
+  HALT --> TL["GitHub Pages<br/>timeline"]:::evidence
+```
+
+<!--
+The black halt node is the whole point — pipeline stops, evidence records why.
+Notice there are no QA/Prod gates on this path; the journey ends at Dev.
+-->

scripts/verify_phase06.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# scripts/verify_phase06.sh - Phase 06 archive regression + layout check.
+# Lives at TOP-LEVEL scripts/ (v1.1 verify scripts), NOT demo/scripts/.
+set -u
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+fail() { echo "FAIL: $*" >&2; exit 1; }
+ok()   { echo "ok: $*"; }
+
+# --- Check 1: demo/ contains the full v1.0 demo tree ---
+for d in demo/modules demo/scripts demo/evidence-ui demo/contracts \
+         demo/contracts-repo demo/.gitea/workflows; do
+  [ -d "$d" ] || fail "missing $d"
+done
+[ -f demo/ACDL_DEMO.md ] || fail "missing demo/ACDL_DEMO.md"
+[ -f demo/scripts/run_demo.sh ] || fail "missing demo/scripts/run_demo.sh"
+ok "demo/ contains the full v1.0 demo"
+
+# --- Check 2: regression - the archived demo still runs from demo/ ---
+out=$(ACDL_GITEA_TOKEN= bash demo/scripts/run_demo.sh --no-upload 2>&1); rc=$?
+[ "$rc" -eq 0 ] || { echo "$out" >&2; fail "demo/scripts/run_demo.sh --no-upload exited $rc"; }
+ok "demo/scripts/run_demo.sh --no-upload exits 0"
+
+# --- Check 3: new top-level dirs exist and are scaffolded ---
+for d in platform schemas adapters terraform modules-ir; do
+  [ -d "$d" ] || fail "missing new top-level dir $d"
+  [ -f "$d/.gitkeep" ] || fail "missing $d/.gitkeep"
+done
+ok "new top-level dirs exist: platform/ schemas/ adapters/ terraform/ modules-ir/"
+
+# --- Check 4: no stray v1.0 dirs left at repo root ---
+for stray in modules evidence-ui contracts contracts-repo ACDL_DEMO.md; do
+  [ -e "$stray" ] && fail "stray $stray left at repo root (should be under demo/)"
+done
+[ -e ".gitea" ] && fail "stray .gitea/ left at repo root (moved to demo/.gitea/)"
+ok "no stray v1.0 dirs at repo root"
+
+# --- Check 5: README reflects the real platform ---
+grep -q "Agentic Cloud Delivery Platform" README.md || fail "README missing platform name"
+grep -q "demo/" README.md || fail "README does not reference the archived demo/"
+grep -qi "vision\|architecture" README.md || fail "README missing vision/architecture links"
+ok "README reflects the real platform (name + demo/ ref + vision/arch links)"
+
+echo "Phase 06: ALL CHECKS PASS"