acdl/.ciagent/PLAN.md

phase, name, milestone, requirements, wave, depends_on

phase	name	milestone	requirements	wave	depends_on
P0	pre-execution	v1.17	REQ-185 REQ-186 REQ-187 REQ-188 REQ-189 REQ-190 REQ-191 REQ-192 REQ-193 REQ-194 REQ-195 REQ-196 REQ-197 REQ-198 REQ-199 REQ-200 REQ-201 REQ-202 REQ-203 REQ-204 REQ-205 REQ-206 REQ-207 REQ-208 REQ-209 REQ-210 REQ-211 REQ-212 REQ-213	0

v1.17 — Strategic Direction, Leadership Metrics & Unified Story (Plan)

Milestone: v1.17 — Strategic Direction, Leadership Metrics & Unified Story Type: Feature (P1–P3 feat; P4 docs; P5 docs+test; P6 test; P7 review+audit+ship; P8 final). Progressive patches; the final phase's patch IS the milestone release. Tags run on the v1.16.x line: v1.16.0 (P0) → v1.16.1..v1.16.7 (P1–P7) → v1.16.8 (P8 final = milestone release). Branch: milestone/v1.17-strategic-metrics-deck (branched off the v1.16 complete merge). Execution phases branch phase/NN-* → merge to milestone branch → tag patch on the v1.16.x line. Tags: metrics, telemetry, decision-ledger, powerbi, deck, north-star, no-humans-thesis, regression-capability Decisions (locked, D-120..D-132 — do NOT re-open): D-120 Nova-native + Infracost, drift deferred · D-121 Decision Ledger = outbox_writer → SQLite hash-chain · D-122 AI decision = confidence_signal + HITL gate · D-123 8 deferred metrics ship as empty placeholder views · D-125 Hybrid events/files · D-126 Cold-only SQLite · D-127 Per-KPI definition-of-success docs · D-128 metrics/ at repo root · D-129 PowerBI = CSV/JSON folder connector · D-130 Deck arc Problem→Vision→How→Proof→Roadmap, both old decks retired · D-131 MTTR = platform-run only · D-132 Attestation instrumentation = emit attestation.recorded events.

Objective (three pillars):

• (A) Strategic Direction — encode the PO's strategic direction in a durable NORTH_STAR.md read by CIAgent in every future /ci-run.
• (B) Leadership Metrics + PowerBI — instrument Nova to collect, aggregate, and surface leadership-grade metrics that prove the "no-humans" autonomous-infrastructure value proposition — grounded in signals Nova actually emits, derived via documented formulas, or explicitly deferred with a decision ID — flowing into PowerBI-ready views.
• (C) Unified Narrative Deck — merge the two existing decks into one unified narrative deck with the "tell them x3" arc at deck + slide level, per-slide benefit callouts, and fluid transitions.

Hard constraint: DO NOT make anything up. Every metric carries a grounded / derived / deferred status with a source file or decision ID. Deferred metrics ship as empty PowerBI placeholder views with documented schemas.

---

Wave Overview

Wave	Phases	Theme	Dependency rationale
Wave 1	P1	Event emitters — the foundation	Everything depends on events being emitted. P1 establishes the CloudEvents envelope, per-run manifests, Decision Ledger, Infracost adapter, and attestation/confidence/policy event emission. P2/P3/P4/P5 all consume P1's event formats.
Wave 2	P2, P3	Collector + PowerBI export	P2 (collector) reads P1's events/files → SQLite cold store. P3 (export) reads P2's SQLite → CSV/JSON views. P2 + P3 can partially parallelize: P3's view schemas can be authored against P2's schemas before P2's collector code is complete, but P3's export code needs P2's SQLite to exist.
Wave 3	P4, P5	Metrics catalog + deck rebuild	P4 (catalog + NORTH_STAR integration) depends on metrics being grounded (P2/P3 done). P5 (deck) depends on P4's METRICS.md for the Proof section's grounded citations. P4 + P5 can partially parallelize: P5's Problem/Vision/How acts don't need P4; P5's Proof act needs P4's catalog.
Wave 4	P6, P7	Regression capability + final review/ship	P6 (CAP-023/024) depends on P2/P3 (collector) + P5 (deck) existing. P7 (review/audit/ship) depends on all prior phases.
Final	P8	Milestone ship	Merge to main, tag v1.16.8, Gitea release, delete milestone branches.

Dependency chain (critical path): P1 → P2 → P3 → P4 → P5(Proof) → P6 → P7 → P8

Parallelization opportunities:

• P2 schemas + P3 view schemas can be authored concurrently (Wave 2 entry).
• P4 docs/metrics/*.md per-KPI docs + P5 Problem/Vision/How acts can be authored concurrently (Wave 3 entry); P5 Proof act waits for P4 METRICS.md.
• P6 CAP-023 (collector) test can be drafted while P5 finishes (the test needs P2's collector to exist, which it does by Wave 4).

---

Per-Phase Vertical-Slice Plans

Phase P1 — event-emitters (Wave 1, feat)

Goal: Instrument every Nova decision point to emit structured CloudEvents 1.0 events + persist ephemeral $WORK/*.json as durable artifacts + extend outbox_writer.py into the SQLite Decision Ledger. After P1, the metrics layer has all the raw signals it needs — no downstream phase invents new signals.

Requirements covered: REQ-187, REQ-188, REQ-205 (emitter half), REQ-206 (emitter half).

Primary persona: backend-engineer. Supporting: data-engineer (event schemas).

Tasks (vertical slices):

1. CloudEvents envelope + schemas — core/metrics/event_envelope.py defines the CloudEvents 1.0 envelope + platform.* semantic conventions (specversion, id, source, type, time, subject, datacontenttype, platform block, data). schemas/metrics_event.schema.json validates the envelope. schemas/metrics_run_manifest.schema.json validates per-run manifests.

   • Acceptance: python -m jsonschema validates a sample event against the schema; tests/test_metrics_emitters.py::test_envelope passes.

2. Per-run manifest writer — core/metrics/run_manifest.py emits nova.run.started, nova.run.completed, nova.run.failed events with (run_id, contractId, env, stages×durations, exit, confidence, HITL block count). Writes metrics/runs/<run_id>.json. scripts/run_platform.sh invokes the writer at run start + run end.

   • Acceptance: a --check-only run produces metrics/runs/<run_id>.json with a valid manifest; test_run_manifest passes.

3. Persist ephemeral $WORK/*.json — run_platform.sh copies $WORK/pcr.json, signal.json, event.json, outbox_item.json, stack.json to metrics/runs/<run_id>/ as durable artifacts (the ephemeral $WORK copies remain for the running pipeline; the persisted copies are the metrics source of truth).

   • Acceptance: after a run, metrics/runs/<run_id>/pcr.json exists and matches $WORK/pcr.json; a test asserts the copy.

4. pytest addopts — pyproject.toml addopts gains --junitxml=metrics/test-results.xml --json-report --cov=core --cov=adapters --cov-report=json:metrics/coverage.json. CAP-009 (offline pytest suite passes) must remain Verified (assumption A5 — additive flags).

   • Acceptance: bash scripts/run_ci.sh exits 0; metrics/test-results.xml
     • metrics/coverage.json exist; regression gate 22/22 (run at P6, but P1 must not break any cap locally).

5. Infracost post-processor — core/metrics/infracost_adapter.py runs Infracost on terraform show -json plan.tfplan (offline, reads plan JSON, no live AWS). Emits nova.cost.estimated{delta_usd}. Degrades gracefully (omits the event, logs a warning) when Infracost CLI is absent (A6). run_platform.sh invokes it after the plan stage.

   • Acceptance: when Infracost is available, metrics/runs/<run_id>/ contains a cost_estimate.json; when absent, the run still exits 0; test_infracost_adapter passes (mock the CLI).

6. Decision Ledger (SQLite hash-chain) — core/metrics/decision_ledger.py extends outbox_writer.py to emit to a SQLite append-only table (metrics/decision_ledger.db) with a hash chain (prev_hash + own hash, SHA-256). Emits ai.decision.made events (decision_id=run_id, chosen_action=band outcome, confidence=score, alternatives=perInput breakdown, human_override=HITL block) with outcome backfill from apply.completed. Honors D-083 (no S3 Object Lock/JWS — local SQLite hash-chain only).

   • Acceptance: metrics/decision_ledger.db exists after a run; the hash chain verifies (verify-chain returns 0 broken); test_decision_ledger passes.

7. Attestation event emission — core/hitl_gates.py emits attestation.recorded events to the Decision Ledger on qa/prod/dr gates (approver, env, concerns, result). D-132. (Dev skips — autonomous.)

   • Acceptance: a mocked qa gate produces an attestation.recorded row in the Decision Ledger; test_attestation_event passes.

8. Confidence decision event emission — core/confidence_signal.py emits nova.confidence.computed + nova.ai.decision.made events (D-122: the "AI decision" is the confidence-gated policy engine, not an LLM).

   • Acceptance: a confidence computation produces both events in metrics/events.jsonl; test_confidence_event passes.

9. Policy event emission — adapters/terraform/policy/checkov_adapter.py emits nova.policy.evaluated events (rule count, pass/fail/skipped, severity breakdown).

   • Acceptance: a Checkov run produces a nova.policy.evaluated event; test_policy_event passes.

10. Lifecycle success-rate emitter — each lifecycle run writes metrics/lifecycle/<module>-<env>.json (module, env, phase apply/modify/destroy, result, duration_ms). REQ-205 emitter half.

    • Acceptance: a mocked lifecycle run produces the JSON; the emitter test passes.

11. Capability event emission — core/regression_verify.py emits nova.capability.verified events (capability ID, status, tier, duration).

    • Acceptance: a regression run produces nova.capability.verified events; test_capability_event passes.

Must-haves (phase ships only if ALL true):

• core/metrics/event_envelope.py, run_manifest.py, infracost_adapter.py, decision_ledger.py exist and are tested.
• metrics/events.jsonl is appended to on every run (CloudEvents 1.0 envelope, valid against schemas/metrics_event.schema.json).
• metrics/runs/<run_id>.json manifest exists after every run.
• metrics/decision_ledger.db exists with a verified hash chain.
• outbox_writer.py extended to write to the SQLite Decision Ledger.
• hitl_gates.py emits attestation.recorded (D-132).
• confidence_signal.py emits nova.confidence.computed + nova.ai.decision.made (D-122).
• checkov_adapter.py emits nova.policy.evaluated.
• pyproject.toml addopts include --junitxml + --json-report + --cov.
• bash scripts/run_ci.sh exits 0.
• No existing capability regresses (22/22 locally).

Risks + mitigations:

• Risk: --junitxml/--cov addopts break the existing test suite. Mitigation: A5 (additive flags); verify CAP-009 stays Verified locally before merging.
• Risk: Infracost CLI not available in CI. Mitigation: A6 — degraded mode (omit event, log warning, don't fail the run).
• Risk: SQLite hash-chain corruption on concurrent writes. Mitigation: single-writer model (the run manifest writer is the only writer per run); WAL mode + BEGIN IMMEDIATE.
• Risk: Event schema drift between emitters and collector. Mitigation: schemas authored first (task 1); all emitters validate against the schema before writing.

---

Phase P2 — metrics-collector (Wave 2, feat)

Goal: Read all grounded signals (files + events) into a normalized SQLite cold store at metrics/nova_metrics.db with idempotent re-runs. After P2, the metrics layer has a queryable store — P3 exports it, P4 catalogs it.

Requirements covered: REQ-189, REQ-200, REQ-201, REQ-205 (collector half), REQ-206 (collector half), REQ-207.

Primary persona: data-engineer. Supporting: backend-engineer (event formats).

Tasks (vertical slices):

1. Fact/dimension schemas — schemas/metrics_fact_run.schema.json, schemas/metrics_fact_capability.schema.json, schemas/metrics_fact_policy_check.schema.json, schemas/metrics_fact_confidence.schema.json, schemas/metrics_fact_test.schema.json, schemas/metrics_fact_decision.schema.json, schemas/metrics_fact_cost_estimate.schema.json, schemas/metrics_fact_lifecycle.schema.json, schemas/metrics_dim_capability.schema.json, schemas/metrics_dim_milestone.schema.json. Schema-first (data-engineer constraint): all schemas exist before any collector code.

   • Acceptance: all schemas validate sample rows; python -m jsonschema passes for each.

2. Collector core — core/metrics/collector.py reads:

   • REGRESSION_REPORT.json → fact_capability + dim_capability.
   • metrics/runs/*.json → fact_run.
   • metrics/test-results.xml (junit) → fact_test.
   • metrics/coverage.json → fact_test.coverage column.
   • metrics/runs/<run_id>/pcr.json → fact_policy_check.
   • metrics/runs/<run_id>/signal.json → fact_confidence.
   • metrics/decision_ledger.db → fact_decision.
   • metrics/runs/<run_id>/cost_estimate.json → fact_cost_estimate.
   • metrics/lifecycle/*.json → fact_lifecycle.
   • CHECKPOINT.json → dim_milestone. Writes to metrics/nova_metrics.db (SQLite cold store, D-126).
   • Acceptance: after a run + collector invocation, metrics/nova_metrics.db has all fact/dim tables populated; test_metrics_collector passes.

3. Idempotent re-runs — the collector is idempotent: re-running it produces identical row counts + a verified chain. REQ-200.

   • Acceptance: test_metrics_collector_idempotent passes (two runs → identical row counts + chain verified).

4. Decision Ledger CLI — core/metrics/decision_ledger_cli.py supports query, verify-chain, stats, export, replay. verify-chain detects broken hashes; replay prints ordered events. REQ-207.

   • Acceptance: decision_ledger_cli.py verify-chain exits 0 on a clean chain, exits 1 on a tampered chain; test_decision_ledger_cli passes.

5. Metrics README — metrics/README.md documents regenerable vs append-only artifacts + the restore procedure (the cold store is regenerable from the raw signals; the Decision Ledger is append-only). REQ-201.

   • Acceptance: metrics/README.md exists with the two categories + a restore procedure section.

Must-haves:

• core/metrics/collector.py exists and is tested.
• metrics/nova_metrics.db is produced with all fact/dim tables.
• Idempotent re-runs (REQ-200) verified by test.
• core/metrics/decision_ledger_cli.py exists with all 5 subcommands.
• metrics/README.md documents regenerable vs append-only + restore.
• bash scripts/run_ci.sh exits 0.

Risks + mitigations:

• Risk: Schema drift between P1's event formats and P2's fact schemas. Mitigation: data-engineer authors both; backend-engineer reviews the event-format alignment.
• Risk: Junit XML parsing edge cases (test names with special chars). Mitigation: use xml.etree.ElementTree with XPath; test with a fixture containing edge-case names.

---

Phase P3 — powerbi-export (Wave 2, feat)

Goal: Emit CSV/JSON views from the SQLite cold store to metrics/powerbi/ — fact + dimension views + 8 empty placeholder views for deferred metrics. After P3, a PowerBI folder-connector dashboard can be built.

Requirements covered: REQ-190, REQ-199, REQ-208, REQ-209 (P3 half), REQ-205 (view half).

Primary persona: data-engineer.

Tasks (vertical slices):

1. PowerBI export core — core/metrics/powerbi_export.py reads metrics/nova_metrics.db and emits CSV/JSON views to metrics/powerbi/: fact_run.csv, fact_capability.csv, fact_policy_check.csv, fact_confidence.csv, fact_test.csv, fact_decision.csv, fact_cost_estimate.csv, fact_lifecycle.csv, dim_capability.csv, dim_milestone.csv. D-129 (CSV/JSON folder connector).

   • Acceptance: after powerbi_export.py runs, all 10 CSV files exist in metrics/powerbi/ with non-empty content (given a populated cold store); test_powerbi_export passes.

2. 8 deferred placeholder views — empty CSV files with documented schemas (headers only, no data rows) for the 8 deferred metrics: (1) Live Infrastructure Health, (2) Live Outbox Write Rate, (3) Tamper-Evident Ledger Checkpoints, (4) Onboarding Funnel (requested→granted), (5) Drift Auto-Reversal Rate, (6) Live CUR Reconciliation, (7) SLA / Unplanned Downtime, (8) Predictive vs Reactive Ratio. D-123. Each has a header row documenting the columns + a comment row citing the blocking decision ID.

   • Acceptance: all 8 placeholder CSVs exist with header rows + a decision-ID comment; test_placeholder_views passes.

3. METRICS_VIEWS.md data dictionary — docs/METRICS_VIEWS.md has a per-column data-dictionary table (column, type, source/formula, unit, grounded/derived/deferred status) for every view. REQ-209 (P3 half).

   • Acceptance: docs/METRICS_VIEWS.md exists with a complete per-column table covering all 18 views (10 fact/dim + 8 placeholder).

4. NOVA_DASHBOARD_README.md — metrics/powerbi/NOVA_DASHBOARD_README.md documents the folder-connector import path + a starter visual model + a reference screenshot placeholder. REQ-208.

   • Acceptance: the README exists with import steps + visual model description.

5. Schema validation in CI — run_ci.sh validates metrics/powerbi/*.json + a sample metrics/events.jsonl against their schemas; exits 0. REQ-199.

   • Acceptance: bash scripts/run_ci.sh validates the PowerBI JSON exports + a sample events file; exits 0.

Must-haves:

• core/metrics/powerbi_export.py exists and is tested.
• metrics/powerbi/ contains all 10 fact/dim CSVs + 8 placeholder CSVs.
• docs/METRICS_VIEWS.md has the per-column data dictionary.
• metrics/powerbi/NOVA_DASHBOARD_README.md exists.
• run_ci.sh schema validation (REQ-199) passes.
• bash scripts/run_ci.sh exits 0.

Risks + mitigations:

• Risk: Placeholder view schemas diverge from what the future emitter will produce. Mitigation: the schema is documented in the header row
  • METRICS_VIEWS.md; the future emitter must conform to the documented schema.
• Risk: PowerBI folder connector quirks (CSV encoding, delimiters). Mitigation: UTF-8 + comma-delimited; documented in the README.

---

Phase P4 — metrics-catalog + north-star-integration (Wave 3, docs)

Goal: Catalog every executive KPI in docs/METRICS.md with grounded/derived/deferred status + per-KPI definition-of-success docs. Wire NORTH_STAR.md into CIAgent context-loading so every future /ci-run reads it. Produce the trust-snapshot report, the deferred-metrics roadmap, the confidence-gate halt rate metric, and the no-humans thesis brief. After P4, the metrics layer is fully documented and the strategic direction is durable.

Requirements covered: REQ-186, REQ-191, REQ-192, REQ-193, REQ-194, REQ-195, REQ-204, REQ-209 (P4 half), REQ-210, REQ-211, REQ-212, REQ-213 (P4 half).

Primary persona: lead-developer. Supporting: data-engineer (metric definitions).

Tasks (vertical slices):

1. METRICS.md catalog — docs/METRICS.md catalogs every executive KPI with: name, NORTH_STAR target, grounded/derived/deferred status, source file or decision ID, and a link to the per-KPI definition doc. REQ-195. Covers all metrics from the scorecard (RESEARCH.md §3): Touchless Resolution Rate, Human Escalation Frequency, MTTR (platform-run), AI Decision Accuracy, Decision Ledger Coverage, Attestation Coverage, Capability Health, Confidence Distribution, Policy Pass Rate, Test Count/Pass Rate, Provisioning Lead Time, Deployment Frequency, Cost Estimates (Infracost), FTE Hours Saved, Platform ROI, Confidence-Gate Halt Rate, + the 8 deferred metrics.

   • Acceptance: docs/METRICS.md exists; every KPI has a status badge
     • a source link; a grep confirms no KPI is missing a status.

2. Per-KPI definition-of-success docs — docs/metrics/<kpi>.md for every KPI (D-127). Each doc defines: the metric, the formula, the grounding status, the source file, the definition of success (what number = "won"), and the deferred dependency (if applicable).

   • Acceptance: docs/metrics/ contains one .md per KPI; each doc has all 5 sections.

3. Zero-touch efficiency metrics docs — REQ-191: Autonomous Resolution Rate, Human Escalation Frequency, AI Decision Accuracy, MTTD/MTTR (platform-run, D-131). Documented in METRICS.md + per-KPI docs with the attestation exclusion clarification (attestation gates are designed controls, not escalations).

   • Acceptance: the 4 metrics have per-KPI docs with the correct formulas + attestation exclusion language.

4. Velocity metrics docs — REQ-192: Provisioning Lead Time (apply.completed.time − intent.received.time), Deployment Frequency (count(apply.completed) per day). Self-Healing Velocity deferred.

   • Acceptance: the 2 metrics have per-KPI docs; the deferral is documented.

5. Financial & cost-ROI metrics docs — REQ-193: FTE Hours Saved (derived), Cost Savings via Infracost (grounded), Cost Efficiency Ratio (derived), Platform ROI (derived formula). Live CUR deferred (D-096).

   • Acceptance: the 4 metrics have per-KPI docs with formulas; the CUR deferral cites D-096.

6. Reliability, security & compliance metrics docs — REQ-194: Zero-Trust Policy Compliance Rate (from pcr.json), Attestation Coverage (prod/dr promotions attested by a human ÷ total prod/dr promotions; grounded in hitl_gates.py + outbox approver_* attributes). Uptime, Patch Remediation, SLA/downtime deferred (D-096). Attestation Coverage is canonically owned here (REQ-194), not in REQ-191.

   • Acceptance: the 2 grounded metrics have per-KPI docs; the 3 deferred metrics have deferral docs citing D-096.

7. NORTH_STAR integration — REQ-186: NORTH_STAR.md is referenced from PROJECT.md (a "Strategic Direction" section pointing to it) + ARCHITECTURE.md (the v1.17 addendum already references it). config.json gains strategic_direction_file: ".ciagent/NORTH_STAR.md" so the run workflow reads it at SPECIFY.

   • Acceptance: PROJECT.md has a Strategic Direction section; config.json has the strategic_direction_file key; a test confirms the file is readable.

8. NORTH_STAR diff-check in CI — REQ-204: run_ci.sh includes check_north_star_diff that fails when Vision/Objectives/Anti-Goals/ Targets sections change without a NORTH_STAR-CHANGE: commit trailer.

   • Acceptance: a test commit changing a Target without the trailer fails the check; a commit with the trailer passes.

9. Deferred-metrics activation roadmap — docs/METRICS_DEFERRED_ROADMAP.md lists 8 deferred metrics + onboarding-grant half with {blocking decision, unblock requirement, candidate milestone} + a "Hot-Path Activation (post-D-096)" section (Nova-native only, D-120) + "Re-evaluation Triggers" section. REQ-210.

   • Acceptance: the roadmap exists with all 8 + the onboarding-grant half + the 2 sections.

10. Trust-snapshot report — core/metrics/trust_snapshot.py emits metrics/TRUST_SNAPSHOT.md with 5 trust metrics (Decision Ledger Coverage, Attestation Coverage, Capability Health, AI Decision Accuracy, Confidence-Gate Halt Rate) + chain-integrity verdict + snapshot hash. Runs offline. REQ-211.

    • Acceptance: metrics/TRUST_SNAPSHOT.md exists after running trust_snapshot.py; the 5 metrics + verdict + hash are present; test_trust_snapshot passes.

11. Confidence-Gate Halt Rate metric — REQ-212: docs/METRICS.md + trust snapshot include "Confidence-Gate Halt Rate" (signal.json band=halt ÷ total runs). PowerBI view includes it (added to fact_confidence projection in P3's export — coordinate with P3).

    • Acceptance: METRICS.md has the metric; the trust snapshot includes it; the PowerBI export includes a column for it.

12. No-humans thesis brief — docs/NO_HUMANS_THESIS.md defines the thesis, grounded proof metrics, deferred proof metrics, and explicit anti-claims (incl. D-122 honesty: the "AI" is the confidence-gated policy engine, not an LLM). REQ-213 (P4 half). The unified deck's Vision act cites it (P5).

    • Acceptance: docs/NO_HUMANS_THESIS.md exists with all 4 sections; the anti-claims section explicitly addresses D-122.

Must-haves:

• docs/METRICS.md catalogs every KPI with status + source.
• docs/metrics/*.md per-KPI docs exist for every KPI.
• NORTH_STAR.md referenced from PROJECT.md + ARCHITECTURE.md + config.json.
• run_ci.sh includes check_north_star_diff (REQ-204).
• docs/METRICS_DEFERRED_ROADMAP.md exists (REQ-210).
• core/metrics/trust_snapshot.py + metrics/TRUST_SNAPSHOT.md (REQ-211).
• Confidence-Gate Halt Rate in METRICS.md + trust snapshot + PowerBI (REQ-212).
• docs/NO_HUMANS_THESIS.md exists (REQ-213 P4 half).
• bash scripts/run_ci.sh exits 0.

Risks + mitigations:

• Risk: KPI definitions drift from NORTH_STAR targets. Mitigation: the catalog cross-references NORTH_STAR target rows; the diff-check (REQ-204) catches NORTH_STAR changes.
• Risk: The no-humans thesis overclaims. Mitigation: D-122 honesty constraint — the anti-claims section explicitly states the "AI" is the confidence-gated policy engine; A3.

---

Phase P5 — deck-rebuild (Wave 3, docs+test)

Goal: Merge the two existing decks into one unified narrative deck "Nova — The No-Humans Infrastructure Platform" with the 5-act arc (Problem → Vision → How → Proof → Roadmap), x3 structure at deck + slide level, per-slide benefit callouts, fluid transitions, a metrics glossary appendix slide, a "what's deferred" slide, and the no-humans thesis cited in the Vision act. Retire both old decks. Re-run the 4-step deck process (source .md → Marp → HTML → talking-points).

Requirements covered: REQ-196, REQ-197, REQ-202, REQ-203, REQ-213 (P5 half).

Primary persona: lead-developer.

Tasks (vertical slices):

1. Unified deck source markdown — docs/presentations/nova-no-humans-platform.md is the single source of truth (the full slide-by-slide plan is in the "Deck Rebuild Plan" section below). The 5-act arc with x3 at deck level (opening = arc preview, body = tell them, closing = recap + ask) + x3 per slide (opens with what it covers, delivers, closes with benefit callout). Fluid transitions written into each slide's opening line. REQ-196, REQ-197.

   • Acceptance: the source .md exists with all slides from the deck plan below; each slide has the 3-part structure; transitions are written.

2. Marp deck — docs/presentations/nova-no-humans-platform-marp.md (Marp-formatted with the S&P visual theme, sp-theme.json unchanged).

   • Acceptance: the Marp deck renders to HTML with the correct slide count + theme.

3. HTML render — docs/presentations/nova-no-humans-platform.html (re-rendered from the Marp deck).

   • Acceptance: the HTML exists and opens with the correct title slide.

4. Talking points — docs/presentations/nova-no-humans-platform-talking-points.md (distilled from the Marp deck, one section per slide with speaker notes).

   • Acceptance: the talking-points file exists with one section per slide.

5. Metrics glossary appendix slide — REQ-202: the deck has a "Metrics Glossary" appendix slide with one-line KPI definitions + grounding badges (grounded/derived/deferred).

   • Acceptance: the glossary slide exists with all KPIs + badges.

6. "What's Deferred — and Why" slide — REQ-203: the deck has a slide pairing each of 8 deferred metrics with its blocking decision ID.

   • Acceptance: the deferred slide exists with all 8 + decision IDs.

7. No-humans thesis cited in Vision act — REQ-213 (P5 half): the Vision act cites docs/NO_HUMANS_THESIS.md (the thesis, grounded proof, deferred proof, anti-claims).

   • Acceptance: the Vision act slides reference the thesis brief.

8. Retire both old decks — delete how-the-platform-works.md + -marp.md + .html + -talking-points.md + the-developer-experience.md

   • -marp.md + .html + -talking-points.md. D-130.
   • Acceptance: a grep confirms the old deck files are deleted; no references to them remain in the repo.

Must-haves:

• docs/presentations/nova-no-humans-platform.md (+ marp + html + talking-points) exists with the full slide plan.
• x3 structure at deck + slide level (REQ-197).
• Per-slide benefit callouts (REQ-197).
• Fluid transitions written into each slide (REQ-197).
• Metrics glossary appendix slide (REQ-202).
• "What's Deferred" slide (REQ-203).
• No-humans thesis cited in Vision act (REQ-213 P5 half).
• Both old decks deleted (D-130).
• bash scripts/run_ci.sh exits 0.

Risks + mitigations:

• Risk: The deck claims a metric that isn't grounded yet. Mitigation: P5 Proof act depends on P4's METRICS.md; every cited metric has a grounded source file verified by the catalog.
• Risk: The old decks are referenced by other docs. Mitigation: grep for references before deletion; update or remove them.

---

Phase P6 — regression-capability (Wave 4, test)

Goal: Add CAP-023 (metrics collector runs, emits expected schema) + CAP-024 (deck structure: slide count, x3 present, per-slide benefit present) to core/regression_verify.py. After P6, the regression gate protects the metrics layer + the deck structure.

Requirements covered: REQ-198.

Primary persona: backend-engineer. Supporting: data-engineer (CAP-023 schema).

Tasks (vertical slices):

1. CAP-023 — metrics collector — core/regression_verify.py gains a CAP-023 check: runs core/metrics/collector.py against a fixture metrics dir, asserts the SQLite cold store has all fact/dim tables with the expected schema, asserts idempotent re-run. Tags Verified/Decayed/Broken.

   • Acceptance: CAP-023 returns Verified when the collector produces the correct schema; test_regression_cap023 passes.

2. CAP-024 — deck structure — core/regression_verify.py gains a CAP-024 check: parses docs/presentations/nova-no-humans-platform.md, asserts (a) slide count is in the expected range (12–20), (b) the x3 structure is present (opening arc preview + closing recap), (c) each slide has a benefit callout. Tags Verified/Decayed/Broken.

   • Acceptance: CAP-024 returns Verified when the deck meets all 3 criteria; test_regression_cap024 passes.

3. Regression gate run — bash scripts/run_regression.sh runs the full gate (22 prior capabilities + CAP-023 + CAP-024 = 24 total). All must pass (Verified or Skipped per D-118).

   • Acceptance: the regression report shows 24 capabilities, all Verified or Skipped, 0 Decayed/Broken.

Must-haves:

• CAP-023 + CAP-024 in core/regression_verify.py.
• bash scripts/run_regression.sh passes (24 capabilities, 0 Broken).
• bash scripts/run_ci.sh exits 0.

Risks + mitigations:

• Risk: CAP-024's slide-count range is too tight and breaks on minor deck edits. Mitigation: the range is 12–20 (generous); the check focuses on structure (x3 + benefit callouts), not exact count.

---

Phase P7 — final-review-ship (Wave 4, review+audit+ship)

Goal: Multi-persona review (incl. deck story quality), audit, and milestone ship. After P7, v1.17 is complete and ready for the final merge.

Requirements covered: all (review gate).

Primary persona: lead-developer. Supporting: all active personas (review participation).

Tasks (vertical slices):

1. Multi-persona review — each active persona reviews their territory:

   • backend-engineer: event emitters, Decision Ledger, Infracost adapter, regression CAP-023/024 code.
   • data-engineer: collector, PowerBI export, schemas, data dictionary.
   • lead-developer: NORTH_STAR integration, METRICS.md catalog, deck narrative, no-humans thesis.
   • Deck story quality review: the lead-developer reviews the deck for narrative coherence, fluidity, and benefit-callout quality.
   • Acceptance: review findings recorded; P0/P1 findings fixed before ship; P2 findings logged for future milestones.

2. Audit — verify:

   • All 29 requirements (REQ-185..213) have a status of complete in the traceability table.
   • No stale claims in the deck (every metric citation has a grounded source).
   • NORTH_STAR.md is readable + referenced.
   • The regression gate passes (24 capabilities).
   • bash scripts/run_ci.sh exits 0.
   • Acceptance: audit PASS recorded in ---ci--- block.

3. Milestone completion — update PROJECT.md, ROADMAP.md, REQUIREMENTS.md traceability to mark v1.17 complete. Tag v1.16.7 (P7 patch on the v1.16.x line).

   • Acceptance: PROJECT.md reflects v1.17 complete; tag v1.16.7 exists.

Must-haves:

• All 29 requirements marked complete.
• Multi-persona review complete (incl. deck story quality).
• Audit PASS.
• Regression gate 24/24 (Verified or Skipped).
• bash scripts/run_ci.sh exits 0.
• Tag v1.16.7 exists.

Risks + mitigations:

• Risk: Review surfaces a P0 finding late. Mitigation: the review is scoped to each persona's territory; findings are fixed before the audit step.

---

Phase P8 — milestone-ship (Final)

Goal: Merge the milestone branch to main, tag v1.16.8 (the milestone release), publish the Gitea release, and delete the milestone branches.

Requirements covered: all (ship gate).

Primary persona: lead-developer.

Tasks (vertical slices):

1. Merge to main — merge milestone/v1.17-strategic-metrics-deck → main.

   • Acceptance: main contains all v1.17 commits; git log main shows the milestone merge.

2. Tag + release — tag v1.16.8 on main; publish the Gitea release (Nova v1.16.8 — Strategic Direction, Leadership Metrics & Unified Story) with the release notes summarizing the three pillars.

   • Acceptance: tag v1.16.8 exists; Gitea release published (release ID recorded).

3. Delete milestone branches — delete milestone/v1.17-strategic-metrics-deck

   • all phase/NN-* branches.
   • Acceptance: git branch -r shows no v1.17 milestone/phase branches.

Must-haves:

• main has the v1.17 merge.
• Tag v1.16.8 exists.
• Gitea release published.
• Milestone + phase branches deleted.

Risks + mitigations:

• Risk: Merge conflicts on main. Mitigation: the milestone branch is off the v1.16 complete merge; rebase before merge if needed.

---

Deck Rebuild Plan

The unified deck: "Nova — The No-Humans Infrastructure Platform." 5-act arc: Problem → Vision → How → Proof → Roadmap. x3 at deck level (opening = arc preview, body = tell them, closing = recap + ask) + x3 per slide (opens with what it covers, delivers, closes with benefit callout). Fluid transitions written into each slide's opening line. Act indicator in the Marp footer (Act N/5: <act name>).

Deck-level x3 structure

Level	"What I'm going to tell you"	"Tell them"	"What I told you"
Deck	Slide 1 (arc preview: Problem→Vision→How→Proof→Roadmap; with 18V+0-consumer stake line)	Slides 2–15 (the 5 acts, 14 slides)	Slide 16 (recap of 5 acts + the business-decision ask)
Per slide	Opening line: "This slide shows X"	Body: bullets/diagram/table	Closing line: "Benefit: you now know Y"

Act 1 — Problem (2 slides)

Transition into Act 1: (none — this is the opening; the arc preview slide sets up all 5 acts).

Slide 1 — Arc Preview (the "what I'm going to tell you" deck-level opening)

• Opens: "This deck proves Nova is the no-humans infrastructure platform — and shows you the metrics that make the claim defensible."
• Stake line (G-Q8 binding): "Today: 18 capabilities verified, 0 consumer estates in production. This deck shows what's proven, what's pipeline-ready, and what's honestly deferred."
• Delivers: The 5-act arc as a visual roadmap: Problem → Vision → How → Proof → Roadmap. One-line summary per act.
• Closes: "Benefit: you leave this deck knowing which claims are proven today, which are pipeline-ready, and which are deferred with a documented unblock path — no marketing, just grounded evidence."
• Grounded metrics cited: 18 Verified + 4 Skipped (source: REGRESSION_REPORT.json); 0 consumers (source: PROJECT.md:495).
• Deferred metrics: none.

Slide 2 — The No-Humans Imperative

• Opens: "This slide shows why the operator is the bottleneck — and why removing them from operations (not accountability) is the imperative."
• Delivers: The cost of humans-in-the-loop: L1/L2 ops hours, escalation latency, the trust gap (autonomous claims without proof). Cites the no-humans thesis (docs/NO_HUMANS_THESIS.md).
• Closes: "Benefit: you now know the problem framing — autonomy in operations, human at stage gates, is the path forward."
• Grounded metrics cited: none (problem framing).
• Deferred metrics: none.
• Transition into Act 2: "Having defined the problem, here is Nova's strategic direction toward solving it."

Act 2 — Vision/Direction (3 slides)

Transition into Act 2: "Having defined the problem, here is Nova's strategic direction toward solving it."

Slide 3 — Nova's Vision

• Opens: "This slide states Nova's vision — infrastructure operations become invisible, with provable trust."
• Delivers: The NORTH_STAR vision statement verbatim. The attestation model: human attestation required at stage gates (QA for production, SRE for operational readiness); autonomy in operations, not in accountability. Cites docs/NO_HUMANS_THESIS.md (the thesis, grounded proof, deferred proof, anti-claims incl. D-122 honesty).
• Closes: "Benefit: you now know the destination — invisible operations with provable trust, not promised trust."
• Grounded metrics cited: none (vision).
• Deferred metrics: none.
• Transition: "The vision is ambitious — here are the 4 strategic objectives that make it concrete."

Slide 4 — Strategic Objectives + Anti-Goals

• Opens: "This slide pairs what Nova is building toward (4 objectives) with what Nova refuses to build (5 anti-goals)."
• Delivers: The 4 strategic objectives (zero-touch ops, provable trust, compounding ROI, default substrate for agentic consumption) + the 5 anti-goals (not a hyperscaler competitor, not a general AI platform, not removing humans from accountability, not for legacy infra, not sold to operators). From NORTH_STAR.md.
• Closes: "Benefit: you now know the scope boundaries — Nova is purpose-built for infrastructure operations, sold to leadership on outcomes, and explicitly not a general-purpose AI platform or a hyperscaler competitor."
• Grounded metrics cited: none (direction).
• Deferred metrics: none.
• Transition: "The objectives are committed to measurable targets — here is the 12–18 month scorecard, with honest grounding status."

Slide 5 — 12–18 Month Targets (the scorecard)

• Opens: "This slide shows the committed targets — numbers a board member can repeat back — with their grounding status."
• Delivers: The NORTH_STAR targets table with the grounding column: Touchless Resolution Rate ≥99% (grounded), Human Escalation <0.1% (grounded), MTTR <60s (grounded, platform-run), AI Decision Accuracy ≥99.5% (grounded), Decision Ledger Coverage 100% (grounded), Attestation Coverage 100% (grounded), Cloud Spend Reduction ≥25% (partial — Infracost grounded, CUR deferred), Platform ROI ≥250% (derived), + deferred targets (Predictive vs Reactive, Drift Auto-Reversal, AI-Agent Intent Share) marked Planned.
• Closes: "Benefit: you now know the destination numbers — and which ones are measurable today vs deferred honestly."
• Grounded metrics cited: Touchless Resolution Rate, Human Escalation Frequency, MTTR, AI Decision Accuracy, Decision Ledger Coverage, Attestation Coverage — all grounded with source files.
• Deferred metrics marked Planned: Predictive vs Reactive, Drift Auto-Reversal, AI-Agent Intent Share.
• Transition into Act 3: "The targets are committed — here is how Nova works to achieve them."

Act 3 — How it works (4 slides)

Transition into Act 3: "The targets are committed — here is how Nova works to achieve them."

Slide 6 — The Platform Pipeline

• Opens: "This slide shows the contract-to-evidence pipeline — how intent becomes verified infrastructure without an operator."
• Delivers: The pipeline flow: contract → resolver → adapter → terraform plan → Checkov (policy) → confidence signal → HITL gate (dev autonomous; qa/prod/dr attested) → apply → evidence. Mermaid diagram. Grounded in scripts/run_platform.sh + core/contract_resolver.py + adapters/terraform/adapter.py + core/confidence_signal.py.
• Closes: "Benefit: you now know the path from intent to evidence — and where the human appears (stage gates only)."
• Grounded metrics cited: none (architecture).
• Deferred metrics: none.
• Transition: "The pipeline produces decisions — here is how every decision is captured and made accountable."

Slide 7 — The Decision Ledger

• Opens: "This slide shows the Decision Ledger — every AI decision captured with confidence, alternatives, and outcome."
• Delivers: The Decision Ledger architecture: outbox_writer.py extended → SQLite append-only hash-chain table. ai.decision.made events (decision_id=run_id, chosen_action=band, confidence=score, alternatives=perInput, human_override=HITL block) with outcome backfill from apply.completed. attestation.recorded events for qa/prod/dr. D-121, D-122, D-132. Honors D-083 (no S3 Object Lock/JWS — local hash-chain this milestone).
• D-122 honesty sentence (G-Q4 binding): "Nova's 'AI' is the confidence-gated policy engine (confidence_signal + HITL gate), not an LLM planner. The Decision Ledger captures this real decision path — not a fabricated 'AI agent' that doesn't exist yet."
• Closes: "Benefit: you now know why 'autonomous' is defensible — every decision is immutable, queryable, and accountable. And you know exactly what 'AI' means here: a confidence-gated policy engine, not a black-box LLM."
• Grounded metrics cited: Decision Ledger Coverage 100% (source: core/metrics/decision_ledger.py + metrics/decision_ledger.db).
• Deferred metrics marked Planned: Tamper-Evident Ledger Checkpoints (D-083).
• Transition: "Decisions are captured — here is how stage-gate attestation keeps humans in accountability."

Slide 8 — The 8-Concern Attestation Matrix

• Opens: "This slide shows the 8-concern attestation matrix — the designed controls that keep humans at stage gates."
• Delivers: The 8 concerns (functional, performance, security posture, contract NFRs, operational readiness, incident response, capacity/cost, resilience). Offline-testable concerns run for real; operator-supplied concerns accept signed evidence artifacts. Separation-of-duties on prod. Grounded in core/attestation_matrix.py + core/hitl_gates.py.
• Closes: "Benefit: you now know the gate model — autonomy in operations, human in accountability, by design."
• Grounded metrics cited: Attestation Coverage 100% (source: core/hitl_gates.py + outbox approver_* attributes).
• Deferred metrics: none.
• Transition into Act 4 (G-Q13 binding — rewritten): "You've now seen how Nova works — the pipeline, the Decision Ledger, the attestation gates. But 'how it works' is not 'proof it works.' The next four slides show the measured evidence: capability health, trust metrics, efficiency, and cost — every number grounded in a real file, not a marketing claim."

Slide 9 — Telemetry Architecture (G-Q14 binding — benefit reframed from data plumbing to trust)

• Opens: "This slide shows how Nova instruments itself — the CloudEvents envelope, the cold store, and the PowerBI export."
• Delivers: The telemetry architecture diagram (from ARCHITECTURE.md v1.17 addendum): platform components → CloudEvents 1.0 envelope → metrics/events.jsonl + metrics/runs/ + metrics/decision_ledger.db → collector → metrics/nova_metrics.db (SQLite cold store) → metrics/powerbi/ (CSV/JSON views) → PowerBI. D-120 (Nova-native), D-125 (hybrid events/files), D-126 (cold-only).
• Closes: "Benefit: you now know that every metric in this deck is traceable to a real emitted event — the architecture IS the trust substrate. When a CFO asks 'where does this number come from?', the answer is a file path, not a Slack thread."
• Grounded metrics cited: none (architecture).
• Deferred metrics marked Planned: Hot-path (live ops dashboard) — D-126.
• Transition into Act 4: "The architecture is sound — here is the measured proof."

Act 4 — Proof (4 slides)

Transition into Act 4: "The architecture is sound — here is the measured proof."

Slide 10 — Capability Health + Confidence Distribution

• Opens: "This slide shows the grounded proof: capability health and confidence distribution from real runs."
• Delivers: Capability health: 18 Verified + 4 Skipped (post-D-096 teardown) from .ciagent/REGRESSION_REPORT.json. Confidence distribution: from metrics/nova_metrics.db fact_confidence — score histogram, band breakdown (pass/halt). The honesty model: Skipped is honest (resources torn down per D-096), not a failure.
• Closes: "Benefit: you now know the platform is verified — 18 capabilities pass, 4 are honestly skipped, 0 broken."
• Grounded metrics cited: Capability Health (source: REGRESSION_REPORT.json), Confidence Distribution (source: metrics/nova_metrics.db fact_confidence).
• Deferred metrics: none.
• Transition: "Capability health is necessary — here is the trust substrate that makes autonomy defensible."

Slide 11 — Decision Ledger + Attestation Coverage

• Opens: "This slide shows the trust metrics — Decision Ledger coverage and attestation coverage, both 100%."
• Delivers: Decision Ledger Coverage: 100% of platform runs emit ai.decision.made with outcome backfill (source: metrics/decision_ledger.db). Attestation Coverage: 100% of prod/dr promotions attested by a human (source: hitl_gates.py + outbox approver_* attributes). AI Decision Accuracy: decisions not followed by apply.failed/incident within 5min. The trust-snapshot report (metrics/TRUST_SNAPSHOT.md) with chain-integrity verdict.
• Closes: "Benefit: you now know the trust is provable — not a marketing claim, a queryable record."
• Grounded metrics cited: Decision Ledger Coverage, Attestation Coverage, AI Decision Accuracy (source: metrics/decision_ledger.db + metrics/TRUST_SNAPSHOT.md).
• Deferred metrics: Tamper-Evident Ledger Checkpoints (D-083) — Planned.
• Transition: "Trust is provable — here is the operational efficiency that makes the ROI real."

Slide 12 — Zero-Touch Efficiency (G-Q10 binding — split from old slide 12)

• Opens: "This slide shows the zero-touch efficiency metrics — touchless resolution, human escalation, and MTTR."
• Delivers: Touchless Resolution Rate (runs without operational HITL block ÷ total; attestation gates excluded). Human Escalation Frequency (operational HITL blocks only). MTTR (platform-run: apply.failed → successful retry, D-131). Post-Pilot caveat (G-Q5 binding): these three metrics are computed on N internal runs today; the production-denominator activates when a pilot estate runs (see NORTH_STAR Post-Pilot Targets section).
• Closes: "Benefit: you now know the zero-touch efficiency is measurable — the pipeline works today on internal runs, and the denominator expands to production estates when a pilot activates."
• Grounded metrics cited: Touchless Resolution Rate, Human Escalation Frequency, MTTR (source: metrics/nova_metrics.db fact_run).
• Derived metrics: none on this slide.
• Deferred metrics marked Planned: Self-Healing Velocity (no auto-remediator).
• Transition: "Efficiency is half the ROI story — here is the cost side."

Slide 13 — Cost & ROI (G-Q10 binding — split from old slide 12; G-Q15 binding — formula inline + N=0 caveat)

• Opens: "This slide shows the cost estimates and the ROI formula — with honest caveats about the current denominator."
• Delivers: Cost Estimates via Infracost (pre-apply, grounded). ROI formula shown inline (G-Q15 binding): Platform ROI = (FTE hours saved × blended rate + cloud savings + avoided downtime) ÷ platform op cost. N=0 caveat (G-Q5/G-Q15 binding): "These derived metrics are computed on N internal runs today; the production-denominator activates post-pilot. The formula is grounded; the production numbers are not yet." FTE Hours Saved (derived). Platform ROI (derived formula). The grounded/derived/deferred honesty model.
• Closes: "Benefit: you now know the ROI formula — and you know it's computed on internal runs today, not fabricated production numbers. The formula is ready; the production denominator activates with a pilot."
• Grounded metrics cited: Cost Estimates (source: metrics/nova_metrics.db fact_cost_estimate).
• Derived metrics: FTE Hours Saved, Platform ROI (formula shown inline).
• Deferred metrics marked Planned: Live CUR Reconciliation (D-096), Drift Auto-Reversal (D-096).
• Transition: "The proof is grounded — here is what is honestly deferred."

Slide 14 — What's Deferred — and Why (G-Q11 binding — preempt: deferrals are measurement infra, not whether the platform runs without humans)

• Opens: "This slide pairs each deferred metric with its blocking decision — honesty about what isn't measured yet."
• Preempt (G-Q11 binding): "To be clear: these deferrals are measurement infrastructure, not whether the platform runs without humans. The platform IS autonomous in operations. What's deferred is the evidence pipeline for certain metrics (live infra health, drift detection, predictive remediation) — not the autonomy itself."
• Delivers: The 8 deferred metrics + onboarding-grant half, each paired with its blocking decision ID: (1) Live Infrastructure Health — D-096, (2) Live Outbox Write Rate — D-096, (3) Tamper-Evident Ledger Checkpoints — D-083, (4) Onboarding Funnel (granted) — D-113/D-114/D-119, (5) Drift Auto-Reversal — D-096 + no scheduler, (6) Live CUR Reconciliation — D-096, (7) SLA / Unplanned Downtime — D-096, (8) Predictive vs Reactive — future emitter. From docs/METRICS_DEFERRED_ROADMAP.md.
• Closes: "Benefit: you now know the boundaries — what Nova measures today, and exactly what blocks the rest. The autonomy is real; the measurement gaps are documented."
• Grounded metrics cited: none (deferral honesty).
• Deferred metrics: all 8 + onboarding-grant half, each with decision ID.
• Transition into Act 5: "The proof is honest — here is the roadmap from here to the 12–18 month targets."

Act 5 — Roadmap/Ask (2 slides)

Transition into Act 5: "The proof is honest — here is the roadmap from here to the 12–18 month targets."

Slide 15 — Roadmap to the North Star

• Opens: "This slide shows the path from v1.17's grounded metrics to the 12–18 month targets — the unblock path for each deferred metric."
• Delivers: The deferred-metrics activation roadmap (from docs/METRICS_DEFERRED_ROADMAP.md): each deferred metric → blocking decision → unblock requirement → candidate milestone. The hot-path activation section (post-D-096, Nova-native only, D-120). Re-evaluation triggers.
• Closes: "Benefit: you now know the path — every deferred metric has an unblock requirement and a candidate milestone."
• Grounded metrics cited: none (roadmap).
• Deferred metrics: all 8 referenced with unblock paths.
• Transition: "The roadmap is clear — here is the recap and the ask."

Slide 16 — Recap + Ask (the "what I told you" deck-level closing; G-Q16 binding — ask reframed as a business decision)

• Opens: "This slide recaps the 5 acts and states the ask."
• Delivers: Recap: Problem (operator bottleneck) → Vision (invisible ops, provable trust) → How (pipeline + Decision Ledger + attestation) → Proof (18V+4S, 100% ledger coverage, 100% attestation, grounded ROI formula) → Roadmap (deferred metrics have unblock paths). The ask (G-Q16 binding — reframed as a business decision, not insider language): "The ask is a business decision: approve a pilot estate to activate the production-denominator metrics (Touchless Resolution, Human Escalation, AI Decision Accuracy), and approve the tamper- evident ledger build-out (D-083 lift) to move from local hash-chain to S3 Object Lock + JWS. These two decisions move Nova from 'pipeline-ready' to 'production-proven.'"
• Closes: "Benefit: you leave with a clear business decision to make — approve a pilot + the ledger build-out — and the confidence that every claim in this deck is grounded, derived, or honestly deferred."
• Grounded metrics cited: Capability Health, Decision Ledger Coverage, Attestation Coverage (recap).
• Deferred metrics: referenced as the ask.

Appendix slides (2 slides)

Slide A1 — Metrics Glossary

• Opens: "This appendix defines every KPI in one line with its grounding badge."
• Delivers: One-line definitions for all KPIs with grounded/derived/ deferred badges. REQ-202.
• Closes: "Benefit: you now have a reference for every metric mentioned in the deck."
• Grounded metrics cited: all (glossary).
• Deferred metrics: all (badged).

Slide A2 — Operating Model & Cost

• Opens: "This appendix shows the real cost figures + the zero-cost steady state."
• Delivers: COST.md figures ($0.001883 / 8 days, ~$0.007/mo, S3-dominated, zero BAU compute) + the zero-cost-steady-state / D-096 teardown claim. References the pre-mortem (PRE_MORTEM.md: v1.10 decay root cause + four forward failure modes + structural mitigations).
• Closes: "Benefit: you now know the operating cost is negligible — and the structural mitigation that prevents decay."
• Grounded metrics cited: Cost figures (source: COST.md).
• Deferred metrics: none.

Fluidity strategy

1. Every slide's opening line references the previous slide's close. Each slide above has an explicit transition sentence. No disjointed jumps. The Act 3→4 boundary (slide 9→10) was rewritten per G-Q13 binding: "But 'how it works' is not 'proof it works.'"
2. Act indicator in the Marp footer. Act N/5: <act name> keeps the audience oriented. Configured in the Marp theme.
3. The arc is visible. Slide 1 (arc preview + stake line) + slide 16 (recap + business-decision ask) bookend the deck. The audience always knows where they are in the 5-act structure.
4. Per-slide benefit callout is the last line. Every slide closes with "Benefit: ..." — the audience leaves each slide with a takeaway, not a cliffhanger. Benefit callouts rewritten per G-Q9 binding (slides 1, 4, 13, 16 now give specific value, not generic restatements).
5. The Proof act is the centerpiece. It is 5 slides (the longest act, expanded from 4 per G-Q10 binding: slide 12 split into Zero-Touch Efficiency + Cost & ROI) because the PO's direction is "prove it, don't promise it." The grounded/derived/deferred honesty model is the narrative spine of the Proof act.
6. Deferred metrics are shown, not hidden. Slide 14 ("What's Deferred — and Why") pairs each deferred metric with its blocking decision, with a preempt (G-Q11 binding) clarifying that deferrals are measurement infrastructure, not whether the platform runs without humans.
7. The D-122 honesty sentence on slide 7. The deck explicitly states that Nova's "AI" is the confidence-gated policy engine, not an LLM planner — per G-Q4 binding. This prevents the "no fabrication" constraint from being violated by implication.
8. Derived metrics carry the N=0 caveat. Slides 12 and 13 annotate derived metrics (FTE, ROI) with "computed on N internal runs; production-denominator activates post-pilot" — per G-Q5/G-Q15 binding. The ROI formula is shown inline (G-Q15).

Deck file inventory (after P5)

File	Status
docs/presentations/nova-no-humans-platform.md	NEW (source of truth, 16 main + 2 appendix slides per G-Q10 split)
docs/presentations/nova-no-humans-platform-marp.md	NEW (Marp)
docs/presentations/nova-no-humans-platform.html	NEW (rendered)
docs/presentations/nova-no-humans-platform-talking-points.md	NEW (talking points)
docs/presentations/how-the-platform-works.md	DELETED (retired, D-130)
docs/presentations/how-the-platform-works-marp.md	DELETED
docs/presentations/how-the-platform-works.html	DELETED
docs/presentations/how-the-platform-works-talking-points.md	DELETED
docs/presentations/the-developer-experience.md	DELETED (retired, D-130)
docs/presentations/the-developer-experience-marp.md	DELETED
docs/presentations/the-developer-experience.html	DELETED
docs/presentations/the-developer-experience-talking-points.md	DELETED

---

Wave Dependency Graph

Wave 1                 Wave 2                 Wave 3                 Wave 4              Final
                      ┌──────────────────┐   ┌──────────────────┐   ┌──────────────┐
P1 (event emitters)──┤P2 (collector)    │   │P4 (catalog +     │   │P6 (regression│   P8
                      │  P3 (powerbi     │──▶│  NORTH_STAR     │──▶│  capability) │──▶(ship)
                      │   export)        │   │  integration)    │   │P7 (review +  │
                      └──────────────────┘   │P5 (deck rebuild) │   │  audit + ship)│
                                             └──────────────────┘   └──────────────┘

Critical path:
P1 ──▶ P2 ──▶ P3 ──▶ P4 ──▶ P5(Proof) ──▶ P6 ──▶ P7 ──▶ P8

Parallelization:
  Wave 2: P2 schemas + P3 view schemas can be authored concurrently.
  Wave 3: P4 docs/metrics/*.md + P5 Problem/Vision/How acts can be authored
          concurrently; P5 Proof act waits for P4 METRICS.md.
  Wave 4: P6 CAP-023 test can be drafted while P5 finishes.

Dependency details:

Phase	Depends on	Blocks
P1	(none — foundation)	P2, P3, P4, P5, P6
P2	P1 (event formats)	P3 (SQLite store), P4 (catalog sources), P6 (CAP-023)
P3	P2 (SQLite store)	P4 (PowerBI view references), P6 (CAP-023 schema)
P4	P2 + P3 (grounded metrics)	P5 (Proof act citations), P6 (CAP-024 deck structure)
P5	P4 (METRICS.md for Proof act)	P6 (CAP-024 deck structure)
P6	P2 + P3 (CAP-023) + P5 (CAP-024)	P7 (regression gate must pass)
P7	P1–P6 (all prior phases)	P8 (audit must pass)
P8	P7 (milestone complete)	(none — terminal)

---

Execution approach

• Per-phase ship: each execution phase merges phase/NN-* → milestone/v1.17-strategic-metrics-deck and tags a patch on the v1.16.x line (v1.16.1 = P1 ... v1.16.7 = P7, v1.16.8 = P8 final).
• Verification: 4-layer verify (structural/behavioral/security/quality) per phase; the regression gate (D-091, 22 prior + CAP-023 + CAP-024 = 24 capabilities) runs at P6 and P7.
• No live AWS: NOVA_LIFECYCLE_MODE=plan default; all metrics that require live AWS ship as placeholder views (D-096). Infracost runs offline (reads plan JSON, A6).
• Test discipline: each phase that changes runtime code adds/updates tests; bash scripts/run_ci.sh exits 0 at every phase boundary.
• No fabrication: every metric carries a grounded/derived/deferred status with a source file or decision ID. No fabricated numbers in any deck slide or METRICS.md entry.
• Decision discipline: D-120..D-132 are locked. This plan does not re-open any locked decision. If a decision needs revisiting, it goes through the GRILL, not the plan.