cadora 0.1.0__tar.gz

cadora-0.1.0/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3 -m venv .venv)",
+      "Bash(.venv/bin/python -m pip install -q --upgrade pip)",
+      "Bash(.venv/bin/python -m pip install -q -e \".[dev]\")",
+      "Bash(.venv/bin/python -m pytest -q)",
+      "Bash(.venv/bin/ruff check *)"
+    ]
+  }
+}

cadora-0.1.0/.gitattributes

@@ -0,0 +1,8 @@
+# Keep private strategy/planning out of any `git archive` export (defense in
+# depth — the real boundary is scripts/publish.sh's allowlist + a PRIVATE remote
+# on this repo). See RELEASE-PLAN.md.
+strategy/        export-ignore
+scripts/         export-ignore
+RELEASE-PLAN.md  export-ignore
+RELEASE-RUNBOOK.md export-ignore
+EOD_*.md         export-ignore

cadora-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -q

cadora-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+runs/
+.pytest_cache/
+.ruff_cache/
+.DS_Store
+.env

cadora-0.1.0/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## v0.1.0 — unreleased
+
+First public release of **Cadora** — an AI-DLC workflow conductor that drives the AWS AI-DLC
+method on a headless coding agent (Claude Code), gates the result, and captures every run.
+
+### Added
+- **AI-DLC conductor** — vendors the AWS AI-DLC rule-set (`awslabs/aidlc-workflows`, MIT-0) and
+  installs it per run (`CLAUDE.md` + `.aidlc-rule-details/`); drives the full lifecycle
+  (Inception → Construction → Build & Test) from a `vision.md`.
+- **`cadora aidlc-init`** — set up an AI-DLC workspace (rules + inputs).
+- **`cadora run`** — drive the workflow on Claude Code (`claude -p`), autonomous and
+  **subscription-funded by default** (metered API opt-in via `--funding api`); `--cwd`,
+  `--gate-cmd`, `--timeout`.
+- **Deterministic `build-test` gate** — blocks the run on non-zero exit.
+- **Run archive** — `runs/<id>/manifest.json` + per-node `aidlc-docs/` snapshot + event stream
+  + cost; inspect with `cadora archive ls` / `cadora archive show`.
+- **`NodeExecutor` seam** — backend-agnostic; Claude Code shipping, with codex / kiro /
+  antigravity adapters behind it.
+- Examples: `aidlc.topology.yaml` (single-session) and `aidlc-stages.topology.yaml`
+  (per-stage DAG); CI (ruff + pytest on Python 3.10–3.12).
+
+### Roadmap
+- `cadora eval` / `compare` (AI-DLC compliance + LLM-judge over captured runs), the per-stage
+  DAG + wave concurrency, `--hitl` human approval, more backends, a consulting deliverable pack.

cadora-0.1.0/EOD_2026-06-19.md

@@ -0,0 +1,40 @@
+# EOD — 2026-06-19
+
+**Status:** Cadora v0.1.0 — **week-1 ("make it real") complete, live-proven, merged to `main`** (week-1 tip `6023ba0`, + this checkpoint). Week-2 (release) is next.
+
+> Private working log (excluded from the public release via `publish.sh` allowlist + `.gitattributes`).
+
+## Shipped today (10 commits on `main`)
+- **Design pass** — `docs/DESIGN.md` (private): `NodeExecutor` contract, verified `claude`/`codex` event schemas, AI-DLC alignment (§0) + decisions ledger.
+- **AI-DLC is the product** — Cadora implements the AWS AI-DLC method (`awslabs/aidlc-workflows`, rules v1.0.0), vendored under `cadora/aidlc_rules/` (MIT-0, pinned `e273af0`) via `scripts/refresh-aidlc-rules.sh`.
+- **`ClaudeCodeExecutor`** hardened — `stream-json --verbose`, stdin DEVNULL, `--dangerously-skip-permissions` (autonomous), full `result` parsing, `ok = exit0 && !is_error`, **subscription-default funding** (drops ambient `ANTHROPIC_API_KEY`; metered = explicit opt-in), `apiKeySource` capture; primary-model reporting fix.
+- **Workspace setup** — `cadora aidlc-init` / `cadora run --vision` installs `CLAUDE.md` + `.aidlc-rule-details/` + inputs.
+- **Runner** — pre-flight gate check, `build-test` gate fires/blocks, `aidlc-docs/` + cost capture, funding-visible console; `--timeout`.
+- **Archive inspector** — `cadora archive ls` / `show`.
+- **CI** — GitHub Actions ruff + pytest, Py 3.10–3.12 (ships to public repo too).
+- **Examples** — `aidlc.topology.yaml` (A, ships) + `aidlc-stages.topology.yaml` (B, destination, 13 stage-nodes).
+- **Public-surface scrub** — no "AO"/"Agent Orchestrator" names, no private cross-refs; `DESIGN.md` kept private.
+
+## Key decisions (DESIGN §0 ledger)
+- Architecture: ship **(A)** single-session run for v0.1.0; **(B)** per-stage DAG is the intended destination.
+- Backend: **Claude Code only** this cycle (codex/kiro/antigravity stay in the seam).
+- Language: **Python** for v0.1.0; **Rust deferred** (trigger-gated runner-core migration).
+- Funding: **subscription token by default**, console-visible; metered API opt-in only.
+
+## Live validation
+- `adder` (haiku): full lifecycle, $0.41/65 turns, generated code runs (`python -m adder 2 3 → 5`).
+- **Secrets Vault (sonnet, $3.05/54 turns):** full AI-DLC → CDK (3 stacks) + Lambda + Next.js; **`cdk synth` offline OK**, **17/17 unit tests pass**, Cognito `AllowAdminCreateUserOnly=True` honored; AWS creds stripped → no deploy. Inspect: `cadora archive show vault1 --archive-dir /tmp/cadora-vault/runs`.
+- Suite: **36 tests green**, ruff clean.
+
+## Left for v0.1.0 (week-2 — see RELEASE-PLAN.md)
+- README + `docs/ARCHITECTURE.md` AI-DLC reframe; verify quickstart; retire toy `examples/topology.example.yaml`.
+- `python -m build` → publish **PyPI** `cadora`; tag `v0.1.0`; `scripts/publish.sh` → public repo + release notes; hold npm name.
+- Post-v0.1.0 backlog: `cadora compare`/`eval`; per-unit Construction fan-out (B); read-only archive web browser; `codex` live-verify.
+
+## Repo state
+- `main` = week-1 (`6023ba0`) + this EOD checkpoint; pushed to `origin` (private `cadora-dev`).
+- `feat/claude-executor` merged into `main` (safe to delete).
+- `/tmp/cadora-vault` and `/tmp/cadora-live` left in place for inspection (ephemeral).
+
+## Resume next session
+Start from RELEASE-PLAN.md week-2; the design spine is `docs/DESIGN.md` (§0 ledger first).

cadora-0.1.0/EOD_2026-06-21.md

@@ -0,0 +1,37 @@
+# EOD — 2026-06-21
+
+**Status:** Cadora v0.1.0 — **release-ready. Only the outward-facing launch remains** (PyPI
+publish + public repo + tag, gated on a PyPI token → tomorrow). `main` @ `f1c6db4` (+ this
+checkpoint), in sync with private `cadora-dev`; 36 tests green, ruff clean.
+
+> Private working log (excluded from the public release).
+
+## Done today (week-2 prep, on `main`)
+- **Plan reconciled** — RELEASE-PLAN DoD → claude-only / AI-DLC (matches DESIGN §0); backlog
+  sharpened into the AO-skill-derived capabilities.
+- **Intel captured to memory:**
+  - Competitor `ijin/aidlc-cc-plugin-v2` = adjacent **interactive CC plugin**; Cadora differentiates
+    as the **headless, backend-agnostic conductor** (capture/compare/eval). Loose, not direct.
+  - AO `aidlc-check` skill = blueprint for `cadora eval` (wraps upstream `aidlc-traceability`, MIT-0).
+  - AO skills import backlog: `cadora eval` / `--hitl` / `cadora deliverable` / `doctor` + monitoring.
+- **Docs reframe (week-2 #1)** — README + ARCHITECTURE reframed to the AI-DLC conductor (claude-first,
+  A-ships/B-destination, differentiated vs a plugin); retired the toy example; quickstart →
+  `aidlc-init` + `aidlc.topology.yaml` + `archive show`. Merged → `main`.
+- **Release prep** — version `0.1.0` (pyproject + `__init__`); sharpened PyPI description + URLs;
+  `CHANGELOG.md` (+ in the public cut). Build verified: `cadora-0.1.0` wheel ships the 32 vendored
+  rule files; sdist + publish cut clean. **PyPI name `cadora` is AVAILABLE.**
+- **`RELEASE-RUNBOOK.md`** (private) — PyPI token → TestPyPI → publish → public repo → tag.
+- Pushed the checkpoint to private `cadora-dev`.
+
+## Tomorrow — the launch (~15 min; see RELEASE-RUNBOOK.md)
+1. PyPI token (one-time): account + 2FA → API token (account-scoped for the first upload) → `~/.pypirc` or `TWINE_*` env.
+2. `rm -rf dist && python -m build` → (optional TestPyPI dry-run) → `twine upload dist/*` (IRREVERSIBLE).
+3. `gh repo create yeychenne/cadora --public` → `scripts/publish.sh` → push the *separate* `../cadora-public/` (never add the public remote here; re-audit before push).
+4. Tag `v0.1.0`; flip CHANGELOG `unreleased`→date + README pre-release→released; GitHub release notes.
+
+**Caveat:** `cadora` is free on PyPI now but only *locked* on first publish — low risk over a day for a niche name.
+
+## Repo state
+- `main` @ `f1c6db4` (+ this EOD checkpoint), in sync with `origin` (private `cadora-dev`); 36 tests green, ruff clean.
+- Branches `feat/claude-executor` + `docs/aidlc-reframe` merged (safe to delete).
+- `/tmp/cadora-vault`, `/tmp/cadora-live`, `/tmp/cadora-dist` are ephemeral (rebuild tomorrow).

cadora-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yves Eychenne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cadora-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: cadora
+Version: 0.1.0
+Summary: An AI-DLC workflow conductor — drive the AWS AI-DLC method on a headless coding agent (Claude Code), with deterministic gates and run capture.
+Project-URL: Homepage, https://github.com/yeychenne/cadora
+Project-URL: Repository, https://github.com/yeychenne/cadora
+Author-email: Yves Eychenne <yeychenne@yahoo.fr>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai-dlc,claude-code,dag,kiro,orchestration,workflow
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Cadora
+
+**An AI-DLC workflow conductor — drive the AWS AI-DLC method on a coding agent, headlessly, and capture every run.**
+
+Cadora implements the [AWS AI-DLC method](https://github.com/awslabs/aidlc-workflows) (AI-Driven Development Life Cycle) as a thin, **backend-agnostic conductor**. Point it at a product vision and it drives a coding agent through the full AI-DLC lifecycle — 🔵 Inception (requirements → planning → design) then 🟢 Construction (code generation → build & test) — **autonomously and headlessly**, applies a deterministic gate, and captures the whole run (artifacts, events, cost) for inspection and comparison.
+
+Cadora is the **conductor**, not the agent: it doesn't implement the agent loop (the backend CLI does), and it isn't an in-session/in-IDE assistant. It installs the AI-DLC rules into a workspace, drives an external headless coding-agent CLI, gates the result, and archives it — so runs are **reproducible, scriptable, gate-able, and comparable**.
+
+**v0.1.0 backend:** Claude Code (`claude -p`, subscription-funded by default). The `NodeExecutor` seam is backend-agnostic — `codex` / `kiro` / `antigravity` adapters sit behind it (roadmap); the same workflow is meant to run across them and be A/B-compared.
+
+## Status
+
+**Early (pre-v0.1.0).** The Claude Code path works and is live-proven end-to-end — it has driven the full AI-DLC lifecycle on real projects, from a tiny CLI to a multi-stack AWS app (CDK + Lambda + Next.js, `cdk synth` + unit tests passing). `pytest` green, `ruff` clean, CI on Python 3.10–3.12. Not yet on PyPI (coming with v0.1.0).
+
+## How it works
+
+```
+vision.md ─▶ install AI-DLC rules (CLAUDE.md + .aidlc-rule-details/) into a workspace
+          ─▶ drive `claude -p` through the AI-DLC lifecycle (autonomous, subscription-funded)
+          ─▶ deterministic build-test gate (blocks on failure)
+          ─▶ run archive: aidlc-docs/ + events + cost   →   cadora archive show
+```
+
+## Install
+
+Requires **Python 3.10+** and the [`claude`](https://docs.claude.com/claude-code) CLI on PATH.
+
+```bash
+git clone https://github.com/yeychenne/cadora.git && cd cadora
+python3 -m venv .venv && source .venv/bin/activate   # Python 3.10+
+pip install -e ".[dev]"
+```
+
+_(PyPI: `pip install cadora` — coming with v0.1.0.)_
+
+## Quickstart
+
+```bash
+# 1. Set up an AI-DLC workspace from your product vision.
+cadora aidlc-init ./my-project --vision vision.md
+
+# 2. Drive the full AI-DLC lifecycle on Claude Code (autonomous, subscription-funded).
+cadora run examples/aidlc.topology.yaml --vision vision.md --cwd ./my-project
+
+# 3. Inspect what happened.
+cadora archive ls
+cadora archive show <run-id>
+```
+
+The run lands in `runs/<run-id>/` — `manifest.json` (ok, cost, model, gate, funding) + a per-node `aidlc-docs/` snapshot + the event stream. The generated application code lands in your workspace.
+
+### Funding (Claude Code)
+
+Cadora **defaults to your Claude Code subscription** — it removes any ambient `ANTHROPIC_API_KEY` from the run so a stray key can't silently meter you. Metered API is explicit opt-in (`--funding api`). Set the subscription token once with `claude setup-token`, or just be logged in to Claude Code.
+
+## The AI-DLC method
+
+Cadora vendors the AWS AI-DLC rule-set ([`awslabs/aidlc-workflows`](https://github.com/awslabs/aidlc-workflows), MIT-0) under `cadora/aidlc_rules/` and installs it per run as `CLAUDE.md` (the core workflow, auto-loaded) + `.aidlc-rule-details/` (per-stage rules). v0.1.0 drives the lifecycle as a **single autonomous session** (`examples/aidlc.topology.yaml`); the **per-stage DAG** (`examples/aidlc-stages.topology.yaml`, one node per stage) is the roadmap.
+
+## Architecture
+
+- `cadora/topology.py` — the workflow DAG (schema + loader + dependency-ordered waves).
+- `cadora/executors/` — the `NodeExecutor` seam + the Claude Code backend (codex/kiro/antigravity adapters behind it).
+- `cadora/workspace.py` — install the AI-DLC rules + inputs into a run workspace.
+- `cadora/gates.py` — deterministic-first gates (shell checks that block).
+- `cadora/archive.py` — run capture (`runs/<id>/manifest.json` + artifacts) + `cadora archive ls/show`.
+- `cadora/runner.py` — wires it together.
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## Roadmap
+
+`cadora eval` / `compare` (deterministic AI-DLC compliance + LLM-judge over captured runs), the per-stage DAG + wave concurrency, `--hitl` human approval, more backends (codex/kiro/antigravity), and a consulting deliverable pack.
+
+## License
+
+MIT — see [LICENSE](LICENSE). The vendored AI-DLC rules are MIT-0 (`cadora/aidlc_rules/LICENSE`).

cadora-0.1.0/README.md

@@ -0,0 +1,77 @@
+# Cadora
+
+**An AI-DLC workflow conductor — drive the AWS AI-DLC method on a coding agent, headlessly, and capture every run.**
+
+Cadora implements the [AWS AI-DLC method](https://github.com/awslabs/aidlc-workflows) (AI-Driven Development Life Cycle) as a thin, **backend-agnostic conductor**. Point it at a product vision and it drives a coding agent through the full AI-DLC lifecycle — 🔵 Inception (requirements → planning → design) then 🟢 Construction (code generation → build & test) — **autonomously and headlessly**, applies a deterministic gate, and captures the whole run (artifacts, events, cost) for inspection and comparison.
+
+Cadora is the **conductor**, not the agent: it doesn't implement the agent loop (the backend CLI does), and it isn't an in-session/in-IDE assistant. It installs the AI-DLC rules into a workspace, drives an external headless coding-agent CLI, gates the result, and archives it — so runs are **reproducible, scriptable, gate-able, and comparable**.
+
+**v0.1.0 backend:** Claude Code (`claude -p`, subscription-funded by default). The `NodeExecutor` seam is backend-agnostic — `codex` / `kiro` / `antigravity` adapters sit behind it (roadmap); the same workflow is meant to run across them and be A/B-compared.
+
+## Status
+
+**Early (pre-v0.1.0).** The Claude Code path works and is live-proven end-to-end — it has driven the full AI-DLC lifecycle on real projects, from a tiny CLI to a multi-stack AWS app (CDK + Lambda + Next.js, `cdk synth` + unit tests passing). `pytest` green, `ruff` clean, CI on Python 3.10–3.12. Not yet on PyPI (coming with v0.1.0).
+
+## How it works
+
+```
+vision.md ─▶ install AI-DLC rules (CLAUDE.md + .aidlc-rule-details/) into a workspace
+          ─▶ drive `claude -p` through the AI-DLC lifecycle (autonomous, subscription-funded)
+          ─▶ deterministic build-test gate (blocks on failure)
+          ─▶ run archive: aidlc-docs/ + events + cost   →   cadora archive show
+```
+
+## Install
+
+Requires **Python 3.10+** and the [`claude`](https://docs.claude.com/claude-code) CLI on PATH.
+
+```bash
+git clone https://github.com/yeychenne/cadora.git && cd cadora
+python3 -m venv .venv && source .venv/bin/activate   # Python 3.10+
+pip install -e ".[dev]"
+```
+
+_(PyPI: `pip install cadora` — coming with v0.1.0.)_
+
+## Quickstart
+
+```bash
+# 1. Set up an AI-DLC workspace from your product vision.
+cadora aidlc-init ./my-project --vision vision.md
+
+# 2. Drive the full AI-DLC lifecycle on Claude Code (autonomous, subscription-funded).
+cadora run examples/aidlc.topology.yaml --vision vision.md --cwd ./my-project
+
+# 3. Inspect what happened.
+cadora archive ls
+cadora archive show <run-id>
+```
+
+The run lands in `runs/<run-id>/` — `manifest.json` (ok, cost, model, gate, funding) + a per-node `aidlc-docs/` snapshot + the event stream. The generated application code lands in your workspace.
+
+### Funding (Claude Code)
+
+Cadora **defaults to your Claude Code subscription** — it removes any ambient `ANTHROPIC_API_KEY` from the run so a stray key can't silently meter you. Metered API is explicit opt-in (`--funding api`). Set the subscription token once with `claude setup-token`, or just be logged in to Claude Code.
+
+## The AI-DLC method
+
+Cadora vendors the AWS AI-DLC rule-set ([`awslabs/aidlc-workflows`](https://github.com/awslabs/aidlc-workflows), MIT-0) under `cadora/aidlc_rules/` and installs it per run as `CLAUDE.md` (the core workflow, auto-loaded) + `.aidlc-rule-details/` (per-stage rules). v0.1.0 drives the lifecycle as a **single autonomous session** (`examples/aidlc.topology.yaml`); the **per-stage DAG** (`examples/aidlc-stages.topology.yaml`, one node per stage) is the roadmap.
+
+## Architecture
+
+- `cadora/topology.py` — the workflow DAG (schema + loader + dependency-ordered waves).
+- `cadora/executors/` — the `NodeExecutor` seam + the Claude Code backend (codex/kiro/antigravity adapters behind it).
+- `cadora/workspace.py` — install the AI-DLC rules + inputs into a run workspace.
+- `cadora/gates.py` — deterministic-first gates (shell checks that block).
+- `cadora/archive.py` — run capture (`runs/<id>/manifest.json` + artifacts) + `cadora archive ls/show`.
+- `cadora/runner.py` — wires it together.
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## Roadmap
+
+`cadora eval` / `compare` (deterministic AI-DLC compliance + LLM-judge over captured runs), the per-stage DAG + wave concurrency, `--hitl` human approval, more backends (codex/kiro/antigravity), and a consulting deliverable pack.
+
+## License
+
+MIT — see [LICENSE](LICENSE). The vendored AI-DLC rules are MIT-0 (`cadora/aidlc_rules/LICENSE`).

cadora-0.1.0/RELEASE-PLAN.md

@@ -0,0 +1,96 @@
+# Cadora — release plan (public v0.1.0 in two weeks)
+
+**Objective:** ship one public open-source release of Cadora within **two weeks (by ~2026-07-03)** — a credible, usable artifact for the consulting funnel.
+
+## Repo model — private dev, public release
+
+This directory (`cadora/`) is the **PRIVATE** repo and the single source of truth: code, `strategy/`, planning, release tooling. **Its git remote must be a PRIVATE GitHub repo.**
+
+The **public release** is a SEPARATE repo containing only the releasable subset — `cadora/`, `examples/`, `tests/`, `docs/`, `README.md`, `LICENSE`, `pyproject.toml`. **`strategy/` and `scripts/` never go public.** `scripts/publish.sh` produces that subset.
+
+```
+cadora/  (PRIVATE remote)  ──scripts/publish.sh──▶  cadora-public/  (PUBLIC remote)
+  cadora/ examples/ tests/ docs/ ───────────────────▶  copied
+  strategy/  scripts/  RELEASE-PLAN.md ──────────────▶  excluded (stays private)
+```
+
+### One-time GitHub setup
+```bash
+# Private source-of-truth repo (this directory)
+gh repo create <you>/cadora-dev --private --source . --remote origin --push
+
+# Public release repo (the name people see; PyPI package is also `cadora`)
+gh repo create <you>/cadora --public \
+  --description "An AI-DLC workflow conductor for agentic delivery"
+scripts/publish.sh                       # stages ../cadora-public/
+cd ../cadora-public && git init && git remote add origin <public-url>
+```
+> Safety: **never add the public remote to THIS repo.** Publish only via the separate `cadora-public/` working copy, so `strategy/` cannot leak.
+
+## License
+**MIT** (in `LICENSE`) — simplest permissive default for adoption. Switch to **Apache-2.0** if you want an explicit patent grant (recommended if you later commercialize). Keep `pyproject.toml`'s `license` field in sync.
+
+## Definition of done — v0.1.0 (public)
+
+Cadora implements the **AWS AI-DLC method**, driven on **Claude Code** — the sole v0.1.0
+backend (codex / kiro / antigravity remain in the backend-agnostic seam; see backlog).
+Decisions: `docs/DESIGN.md` §0.
+
+- ✅ `cadora run examples/aidlc.topology.yaml --vision <vision.md> --executor claude` drives the
+  full AI-DLC lifecycle end-to-end against a real `claude` (proven on a trivial app + the
+  Secrets Vault).
+- ✅ Subscription-funded by default (console-visible; metered API opt-in only).
+- ✅ AI-DLC rules vendored + workspace setup (`cadora aidlc-init`).
+- ✅ Deterministic `build-test` gate wired + fires/blocks.
+- ✅ Real `claude` event parsing (final text + usage + cost + model).
+- ✅ Run archive + `cadora archive ls/show`.
+- ✅ `pytest` green; `ruff` clean; GitHub Actions CI (ruff + pytest, Py 3.10–3.12).
+- ⬜ README + `docs/ARCHITECTURE.md` reframed to AI-DLC + quickstart verified; `LICENSE` present;
+  published to **PyPI** as `cadora`; npm name held.
+
+## Two-week plan
+**Week 1 — make it real (private repo). ✅ DONE — merged to `main`, live-proven.**
+- AI-DLC alignment + decisions ledger (`docs/DESIGN.md` §0); vendored rules + `cadora aidlc-init`.
+- Hardened `ClaudeCodeExecutor` (stream-json, subscription funding, full parsing, ok semantics).
+- Runner: `build-test` gate + `aidlc-docs`/cost capture + funding console; `cadora archive ls/show`; `--timeout`.
+- Tests (executor / workspace / runner / archive / topology) + CI.
+- Deferred by decision: wave concurrency; `codex` / `kiro` live-verify (see backlog).
+
+**Week 2 — release.**
+7. Reframe README + `docs/ARCHITECTURE.md` to the AI-DLC conductor (claude-only, A ships / B
+   destination); verify the quickstart against `examples/aidlc.topology.yaml`; retire the toy
+   `examples/topology.example.yaml`; optional asciinema of a run.
+8. `python -m build` → publish to **PyPI** (`cadora`); hold the npm name.
+9. One-time public-repo setup → `scripts/publish.sh` → push the public repo; tag `v0.1.0`; GitHub release notes.
+10. Soft announce (consulting funnel): one post framing Cadora as an AI-DLC delivery conductor.
+
+## Out of scope for v0.1.0 (post-release backlog)
+
+Several items port AO's eval/skills layer — the differentiated asset the pivot keeps
+(`~/projects/AgentOrchestrator/.claude/skills/`).
+
+**Architecture — decision B:** per-stage DAG (each AI-DLC stage a node; conditional self-skip;
+runtime per-unit Construction fan-out; wave concurrency). See `docs/DESIGN.md` §0.1.
+
+**Verification — `cadora eval`** (port AO `aidlc-check` + `eval-pipeline`):
+- `aidlc-check` gate/command — deterministic phase-artifact presence + Requirements→Code
+  traceability, vendoring upstream `aidlc-traceability` (MIT-0); grep-for-orphaned-`US-XXX` fallback.
+- LLM-as-Judge graders — ground-truth, trajectory, multi-run consistency, scoring rubrics.
+- `cadora compare <a> <b>` — diff two runs (same topology, different model/backend) on cost +
+  outcome + artifacts.
+
+**HITL — `cadora run --hitl`** (port AO `monitor-r-run-hitl`): surface AI-DLC
+`request_input` / approval gates to the operator for typed answers; auto-approve only go/no-go.
+
+**Consulting — `cadora deliverable`** (port AO `produce-solution-docs`): a finished run's
+`aidlc-docs/` + code → a client pack (md / Word / PPT / draw.io / HTML). Consulting-funnel differentiator.
+
+**Ops:** `cadora doctor` — env preflight (claude on PATH, auth/token, rules vendored; reframes
+AO `deploy-check` minus the infra); run monitoring (port AO `babysit-pipeline`, lighter); archive
+reuse (port AO `prepare-test`).
+
+**Backends & runtime:** `codex` / `kiro` live-verify; `antigravity` hardening once `agy` fixes
+stdout/JSON; an Agent-SDK executor (own-the-loop) alongside `claude -p`; Rust runner-core
+migration (trigger-gated — `docs/DESIGN.md` §11).
+
+**UI:** read-only archive browser (the AO-dashboard successor — no live control plane).

cadora-0.1.0/RELEASE-RUNBOOK.md

@@ -0,0 +1,68 @@
+# Cadora — v0.1.0 release runbook (PRIVATE)
+
+Prep is **done and committed**: version `0.1.0`, CHANGELOG, build verified (wheel ships the 32
+vendored rule files), publish cut clean, PyPI name `cadora` free. What remains is the
+outward-facing launch — do it in order. (Private: excluded from the public cut + `git archive`.)
+
+> **Can this wait until tomorrow?** Yes. All prep is committed/pushed; tomorrow you just rebuild
+> (§0) and run the steps. Caveat: `cadora` is *available* now but only *locked* once you first
+> publish — small risk someone takes it first. Niche name, ~a day → low risk. To lock it
+> immediately, publish today.
+
+## 0. Rebuild fresh (the /tmp build is ephemeral)
+```bash
+cd ~/projects/cadora && source .venv/bin/activate
+rm -rf dist && python -m build            # -> dist/cadora-0.1.0-{py3-none-any.whl,tar.gz}
+pip install -q twine && twine check dist/*
+```
+
+## 1. PyPI API token (one-time)
+1. Account: https://pypi.org/account/register/ (skip if you have one) → verify email.
+2. **Enable 2FA** (PyPI requires it to upload): Account settings → Two-factor authentication.
+3. Create the token: Account settings → **API tokens** → **Add API token**.
+   - Name: `cadora-publish`.
+   - **Scope: "Entire account"** for the FIRST upload — the `cadora` project doesn't exist on
+     PyPI yet, so you can't scope to it. After the first publish, create a NEW token scoped to
+     project `cadora` and delete the account-wide one.
+   - Copy the token (`pypi-AgEI…`) — shown only once.
+4. Configure it — **never paste the token into chat or a commit**:
+   - `~/.pypirc`:
+     ```ini
+     [pypi]
+       username = __token__
+       password = pypi-AgEI…
+     ```
+     then `chmod 600 ~/.pypirc`
+   - or env: `export TWINE_USERNAME=__token__ TWINE_PASSWORD=pypi-AgEI…`
+
+## 2. (Recommended) TestPyPI dry-run — de-risk the irreversible upload
+1. Separate account + token at https://test.pypi.org/.
+2. `twine upload --repository testpypi dist/*`
+3. In a clean venv: `pip install -i https://test.pypi.org/simple/ cadora` → sanity check `cadora --help`.
+
+## 3. Publish to PyPI (IRREVERSIBLE — a version number can't be reused)
+```bash
+twine upload dist/*
+```
+Verify: https://pypi.org/project/cadora/ and `pip install cadora` in a clean venv.
+Then rotate to a **project-scoped** token (§1.3) and delete the account-wide one.
+
+## 4. Public GitHub repo (publish ONLY via the separate working copy)
+```bash
+gh repo create yeychenne/cadora --public \
+  --description "An AI-DLC workflow conductor for agentic delivery"
+scripts/publish.sh                                  # stages ../cadora-public/
+# re-audit the staged cut before pushing:
+grep -rniE "agent[ -]?orchestrator|\bAO\b|strategy|DESIGN\.md|this machine" ../cadora-public && echo "STOP: leak" || echo "clean"
+cd ../cadora-public && git init && git add -A && git commit -m "release v0.1.0"
+git branch -M main && git remote add origin https://github.com/yeychenne/cadora.git
+git push -u origin main
+```
+**SAFETY:** never add the public remote to THIS repo; publish only from `../cadora-public/`.
+
+## 5. Tag + finalize
+- In THIS repo: flip `CHANGELOG.md` `unreleased` → the date; README `Status: Early (pre-v0.1.0)`
+  → released + `pip install cadora`; commit; re-run `scripts/publish.sh`; push public.
+- Tag: `git tag v0.1.0 && git push origin v0.1.0` (private) and tag the public repo.
+- GitHub release on the public repo using the CHANGELOG v0.1.0 notes.
+- (Optional) hold the npm name; soft-announce.

cadora-0.1.0/cadora/__init__.py

@@ -0,0 +1,3 @@
+"""Cadora — an AI-DLC workflow conductor for agentic delivery."""
+
+__version__ = "0.1.0"

cadora-0.1.0/cadora/aidlc_rules/LICENSE

@@ -0,0 +1,17 @@
+MIT No Attribution
+
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

cadora-0.1.0/cadora/aidlc_rules/RULES_VERSION

@@ -0,0 +1,7 @@
+ai-dlc-rules: 1.0.0
+source: https://github.com/awslabs/aidlc-workflows
+commit: e273af0a310ef3968d3636acc7e0afec6f7dad22
+ref: main
+retrieved: 2026-06-19T15:29:29Z
+license: MIT-0 (see ./LICENSE)
+note: vendored by scripts/refresh-aidlc-rules.sh — do not edit by hand