Produce an audio drama

# Decosa audio drama studio: use the hosted API

You are wiring Decosa's audio drama studio into this project. It takes a script (a radio play with `NAME: line`,
`[SFX: ...]` and `[MUSIC: ...]` cues, or a prose chapter) and returns a produced episode: every line voiced by a
consented stock voice, openly licensed or generated sound, cleared music, mastered to a podcast or ACX-style audiobook
spec, with chapters, captions, a transcript, show notes with an AI disclosure, sides for human actors, a C2PA credential
and a signed record. Use only what is listed below. If you need something else, stop and ask me.

- Base URL: `https://api.decosa.ai`. Health: `GET https://api.decosa.ai/healthz`.
- The hosted service speaks only stock voices with consent-ledger entries (`GET /drama/info` lists them). It never
  clones a voice. Send unpublished work only if I say the hosted service is fine for it; otherwise use self-host.
- Always show the parse to a person before rendering: the model attributes quotations and maps cues, and it can be wrong.

## Auth: API key (or a demo session)
1. Preferred: an API key (`dk_…`) from "Get an API key" on the tool page, in `DECOSA_API_KEY`, sent as
   `Authorization: Bearer $DECOSA_API_KEY`. A key renders 20 episodes per UTC day.
2. Without a key: `POST https://api.decosa.ai/demo/session` with `{"vertical": "audio-drama-studio"}` returns `{"token", ...}`;
   3 episodes per session. Over a limit you get HTTP 429 with `Retry-After`.

## Endpoints
- `POST /drama/parse` (token): `{"script": "...", "format"?: "auto"|"screenplay"|"prose"}` (30,000 characters at most) →
  `{parse_id, parse: {roles, blocks, warnings, stats}, cast, receipts, usage}`. Blocks are `line` (role, text, delivery,
  effect), `sfx` (sound tag, layer spot|bed|stop), `music` (cue theme|sting|bed|stop), `direction`, `scene`, `chapter`,
  `pause`. Quotations the model could not attribute have role `unassigned`; fix them before rendering.
- `POST /drama/cast` (token): `{"parse", "cast"?: {role: identity_id}, "spec"?}` → one signed consent decision per role.
- `POST /drama/episodes` (token): `{"parse", "parse_id", "cast", "spec": "podcast"|"acx", "music": {"mode": "library",
  "style": "victorian-mystery"} | {"mode": "none"}, "title"?, "author"?, "source_credit"?}` → 202 `{episode_id}`, or 422
  `{category: "consent_refused", decisions}` when a voice's consent does not cover this use (nothing is rendered).
- `GET /drama/episodes/{id}` (token): poll every 3 s until `status` is `done`, `refused` or `failed`. `done` has `files`
  (MP3 with C2PA and chapters; one per chapter for acx), `measured` loudness and `checks`, `documents` (captions.vtt,
  transcript.json, chapters.json, transcript.txt, show-notes.md, sides.zip, record.json), `cast` with the consent entry
  per role, `music` with licence certificates, `sounds` with licences, and `disclosure`.
- `GET /drama/records/{id}` (no token): the signed record; verify it at `POST /record/verify` with `{"record": ...}`.
- No token: `GET /drama/info`, `/drama/samples`, `/drama/voices/{voice}.mp3`, `/drama/music/{cue}.mp3`,
  `/drama/music/{cue}/certificate`.

## Example (Python, `pip install httpx`)
```python
import httpx, os, time
API = "https://api.decosa.ai"
H = {"Authorization": f"Bearer {os.environ['DECOSA_API_KEY']}"}
script = open("script.txt").read()
p = httpx.post(f"{API}/drama/parse", headers=H, timeout=300, json={"script": script}).json()
# show p["parse"] to a person and let them fix speakers and cues here
r = httpx.post(f"{API}/drama/episodes", headers=H, timeout=60, json={"parse": p["parse"], "parse_id": p["parse_id"],
               "cast": p["cast"], "spec": "podcast", "music": {"mode": "library", "style": "victorian-mystery"}})
if r.status_code == 422:
    raise SystemExit([(d["role"], d["code"]) for d in r.json()["decisions"] if not d["allowed"]])
ep_id = r.json()["episode_id"]
while (ep := httpx.get(f"{API}/drama/episodes/{ep_id}", headers=H, timeout=60).json())["status"] in ("queued", "running"):
    time.sleep(3)
assert ep["status"] == "done", ep.get("error")
f = ep["files"][0]
print(f["measured"], f["checks"], ep["disclosure"])
open("episode.mp3", "wb").write(httpx.get(API + f["url"]).content)
```

## Honest limits
- Kokoro-82M voices are clear but flat; delivery notes change pace and level only. Treat the result as a temp track.
- ACX does not accept AI narration; the acx mode meets its technical spec only.
- Files stay on the server for 7 days; download what you need.

On request. The container images and the compose file aren’t public yet. Ask for self-host access and Decosa sends the registry (DECOSA_REGISTRY) and the compose file’s URL (DECOSA_COMPOSE_URL) these steps use. They are the steps we tested end to end on a fresh machine.

# Decosa audio drama studio: run it yourself (containers)

You are setting up Decosa's audio drama studio on this machine: Qwen3.8-27B parses scripts, Kokoro-82M (Apache-2.0)
speaks each line on CPU with consented stock voices, and decosa-api mixes, masters, credentials and signs the episode.
Scripts and episodes stay here; nothing is sent to Decosa's hosted API.

Status: the container images (${DECOSA_REGISTRY}/decosa-*) and the compose file are on request while self-host is in early access (not on a public registry yet): ask at https://decosa.ai/contact?topic=self-host, and Decosa sends the registry as DECOSA_REGISTRY, the compose file URL as DECOSA_COMPOSE_URL, and pull access. If a pull fails with
"not found", "denied" or "unauthorized", stop and tell me. Don't substitute other images or models.

Ask me before any command that needs sudo, and show me the command first.

## Step 0: set up with a coding agent, rehearse on mock data, then go private

This prompt is for a coding agent running on the machine that will host the service. We recommend Claude Code with
Claude Opus 5.5; any capable coding agent works. Work in this order:

1. Set up on mock data only. During the whole setup you (the agent) work with the synthetic sample bundle below and
   nothing else. Do not ask me for real data, and do not open, read, list or copy files that hold real data, even to
   "test with something realistic".
2. Rehearse. When the steps below are done and the service is healthy, fetch the mock-data bundle for this tool,
   https://decosa.ai/samples/audio-drama-studio.zip (3 KB, 16 checks, synthetic or openly licensed: see `licence` in expected.json),
   show me what is in it, and run the rehearsal against the local API:
   `docker compose exec api python scripts/rehearse.py audio-drama-studio` (the api image carries the same bundle under /app/rehearsal/audio-drama-studio/;
   with no key set, the script asks the local API for a short demo token). From a decosa-api checkout instead:
   `python scripts/rehearse.py audio-drama-studio --bundle audio-drama-studio.zip --base-url http://127.0.0.1:<PORT>`.
   It sends the mock inputs to the local API and prints PASS or FAIL for each expected property (for example: "the script is read as a radio play", "four roles: narrator, Rosa, Dispatch and Teo", "twenty spoken lines"). Show me
   the full output. Every check must pass. If one fails, fix the install and run it again; never edit `expected.json`
   to make a check pass.
3. Stop there. Once the rehearsal passes, tell me, and I will run my own data against the local API myself, on this
   machine.

For the person running this: a coding agent that runs in the cloud sees everything in its context, including files it
reads, command output and anything pasted into the chat. Keep real data out of the chat and out of anything the agent
can read. Switch to your own data only after the rehearsal has passed and the agent's work is done.

## Rules first
- Every voice render goes through the consent ledger. Never bypass it. Enrol a real person only with their recorded
  consent and a specific description of the use; this build does not clone voices.
- Keep the parse review step: a person checks speakers and cues before rendering.

## Steps
1. Docker (and, for the parse model, the NVIDIA container toolkit and a GPU with 32 GB or more): if
   `docker compose version` or `docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi` fails,
   install them from the official instructions.
2. Fetch the compose file: `mkdir -p ~/decosa && cd ~/decosa && curl -fsSL "${DECOSA_COMPOSE_URL}" -o compose.yaml`. Keep the
   `llm` and `api` services. The api image needs the voice layer: `docker/drama/Dockerfile` in decosa-api (Kokoro in
   its own CPU venv, model and voicepacks downloaded at build time). The tool's assemble prompt has the exact
   commands. Use named volumes and bind every port to 127.0.0.1.
3. `docker compose run --rm api python scripts/provenance_devcert.py`, then `docker compose up -d`.
4. Smoke test: `docker compose exec api python scripts/rehearse.py audio-drama-studio --base-url http://127.0.0.1:8445`
   must print `16/16 checks passed`.
5. Report back: the render time per finished minute and the loudness numbers from the rehearsal episode.

Off. Voice renders run on CPU and are not a network service; only the text model could be offered, and only if I say yes.