Redline from firm precedents

# Decosa Privileged drafting editor: use the hosted API

You are wiring Decosa's drafting editor into this project. It takes a contract (a .docx, plain text or a sample) and a
law firm's playbook, and returns a Word file with real tracked changes (w:ins / w:del) and a margin comment on each
change naming the playbook rule, the position and the precedent it came from. New wording comes only from the firm's
precedent clauses: code traces every inserted word to one, and checks that reject-all gives back the input and
accept-all gives exactly the proposal. Each model call has its own signed receipt. Use only what is listed below. If
you need something else, stop and ask me.

- Base URL: `https://api.decosa.ai`
- Health check: `GET https://api.decosa.ai/healthz`.
- The hosted API is for public contracts (the CUAD samples), fictional ones, and testing your integration. Client
  contracts are confidential and often privileged: for real matters use the self-host prompt instead. Never send client
  documents here.
- It proposes; a lawyer decides. Show every change as a proposal to accept or reject, never as final.

## Auth: API key (or a demo session)
1. Preferred: an API key (`dk_…`) from "Get an API key" on the tool page. Keep it in an environment variable,
   `DECOSA_API_KEY`, never in code. Send `Authorization: Bearer $DECOSA_API_KEY`.
2. Without a key: `POST https://api.decosa.ai/demo/session` with `{"vertical": "legal-drafting-editor"}` returns `{"token", "expires_at", "budget"}`.
   a limited number of sessions per network per hour (the current limits are in `demo_sessions` of GET /healthz); each session has a token allowance (its `budget`) (one review of the full ten-rule playbook uses about
   2,000). Over a limit: HTTP 429 with `Retry-After`; not enough budget: HTTP 402.
3. One review at a time per demo token (409 otherwise).

## Endpoints
- `POST /drafting/review` (token). Body: exactly one of `{"docx_b64": "<base64 .docx>"}`, `{"text": "..."}` or
  `{"sample": "northwind-msa"}`, plus optional `"rules": ["GL", "CAP", ...]`, `"parties": {"client": "<defined term>", "counterparty": "<defined term>"}`,
  `"playbook": {...}`, `"precedents": {...}` (the shapes of `GET /drafting/playbook`), `"title"`, `"stream"`.
  - Limits: .docx up to 2 MB, text up to 200,000 characters, 3,000 paragraphs, 20 rules, 80 precedent clauses.
  - With `"stream": true` (or `Accept: text/event-stream`): `ready`, `parties`, a `receipt` after each model call, a
    `finding` per rule `{rule, position: preferred|fallback|outside|walk_away|absent|error, paragraphs, quote, reason, action}`,
    an `edit` per change `{id, rule, action: edit|replace_clause|delete|insert|comment|flag, status: tracked|comment_only|flag, ops, before, after, precedent, trace, checks, comment}`,
    `validation`, `report` (totals, usage, signed record), `done` (run id and export links), `budget`.
    With `"stream": false`: one JSON object `{run_id, export, findings, edits, validation, report, ...}`.
- `GET /drafting/runs/{run_id}/export?format=docx` (the redline), `md` (review memo), `record` (signed), `ledger` (signed, with decisions).
- `POST /drafting/runs/{run_id}/reconcile` `{"docx_b64", "reviewer"}`: the file back from Word; which changes were
  accepted, rejected or left open, sealed into the ledger. `POST /drafting/runs/{run_id}/decisions` records them by hand.
- `POST /drafting/validate` `{"docx_b64"}` (token, no model): structural check of any DOCX with tracked changes.
- `GET /drafting/info`, `/drafting/playbook`, `/drafting/samples`, `/drafting/samples/{id}`, `/drafting/samples/{id}/docx` (no token).
- `POST /record/verify` (no token) `{"record": {...}}` → `{ok, summary, bad}`.

## Example: redline a contract and save the .docx (Python, `pip install httpx`)
```python
import base64, httpx, os, pathlib
API = "https://api.decosa.ai"
H = {"Authorization": f"Bearer {os.environ['DECOSA_API_KEY']}"}
docx = base64.b64encode(pathlib.Path("contract.docx").read_bytes()).decode()   # a public or test contract
r = httpx.post(f"{API}/drafting/review", headers=H, timeout=900, json={"docx_b64": docx, "stream": False})
r.raise_for_status()
run = r.json()
for f in run["findings"]:
    print(f["rule"], f["position"], f["action"])
assert run["validation"]["ok"] and run["report"]["totals"]["untraced_insertions"] == 0
pathlib.Path("redline.docx").write_bytes(httpx.get(f"{API}{run['export']['docx']}", headers=H).content)
```

## Honest limits
- Positions come from an open model and can be wrong; see the measured rates on the Stack tab. The lawyer reviews every change.
- It edits paragraphs of plain text runs in place; a paragraph with fields, hyperlinks or earlier tracked changes gets a
  comment with the proposed wording instead. Numbering of inserted clauses is left to the lawyer.
- It only uses the precedents you give it. With no precedent for a rule, it comments or flags; it never writes new clause text.

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 Privileged drafting editor: run it yourself (containers)

You are setting up the Decosa drafting editor on this machine, so client contracts never leave it. It applies the
firm's playbook to a contract and returns a .docx with Word tracked changes and a margin comment per change, using only
the firm's precedent clauses for new wording, and signs a record. 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. Do not substitute other images.

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/legal-drafting-editor.zip (11 KB, 12 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 legal-drafting-editor` (the api image carries the same bundle under /app/rehearsal/legal-drafting-editor/;
   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 legal-drafting-editor --bundle legal-drafting-editor.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: "Texas governing law is placed outside the playbook", "the governing-law clause is redlined from Texas to New York as a tracked change", "the 30-day warranty is flagged"). 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.

## Steps
1. Docker: if `docker compose version` fails, install Docker Engine and the compose plugin using Docker's official
   instructions for this distribution (docs.docker.com/engine/install). Also install the NVIDIA container toolkit and
   check `docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi`.
2. Fetch the compose file:
   `mkdir -p ~/decosa && cd ~/decosa && curl -fsSL "${DECOSA_COMPOSE_URL}" -o compose.yaml`
   Read it. Keep the `llm` service (Qwen3.8-27B on vLLM) and the `api` service. For the `api` service set
   `DECOSA_LLM_ROUTE=direct`, `DECOSA_LLM_URL=http://llm:8000/v1`, `DECOSA_LLM_MODEL=qwen3.8-27b`, use a named volume
   for `/data`, and bind every port to 127.0.0.1. Nothing in this tool needs the internet after the weights are
   downloaded.
3. Pull and start: `docker compose pull && docker compose up -d`. Wait for the `llm` health check (the first start
   downloads about 20 GB of weights).
4. Check: `curl -fsS http://127.0.0.1:<PORT>/drafting/info` shows `"route": "direct"`; `GET /attest/signing-key` shows
   this box's public key. Show me the key: it is what others pin to verify my records.
5. Smoke test: get a token with `POST /demo/session {"vertical":"legal-drafting-editor"}` and run
   `POST /drafting/review {"sample": "northwind-msa", "stream": false}`. Expect governing law (Texas) outside and
   redlined to New York, the one-month liability cap and the 30-day warranty at walk-away, confidentiality and the IP
   indemnity inserted from precedents, `report.totals.untraced_insertions` 0, and `validation.ok`,
   `reject_all_is_input` and `accept_all_is_proposal` all true. Download `export.docx` and open it in Word. Then
   `POST /record/verify` with `report.record`: `ok` must be true.
6. Load the firm's playbook and precedent library (`GET /drafting/playbook` shows the shape) and send them with each
   review as `playbook` and `precedents`.
7. Report back: the public key and key id, the findings, the file checks and how long the run took.

Off, and keep it off on a box that holds client contracts: joining serves other people's requests on this GPU.
If I ask for it later, on a separate machine, follow the Provide page instead of improvising.

No NVIDIA GPU? This tool also runs entirely on an Apple Silicon Mac (MLX, 32 GB of unified memory or more): use https://decosa.ai/prompts/legal-drafting-editor-mac.md instead.