Chart claim support in a patent spec

# Decosa Patent claim-support checker: use the hosted API

You are wiring Decosa's patent claim-support checker into this project. It takes a patent specification and its
claims, and returns a claim chart that maps every claim element to the specification paragraphs that describe it
(cited by number, like [0012]) with a support strength, plus an issue list: elements with no support, "the X" with no
earlier "a X" (antecedent basis), dependent claims that point at a missing or later claim, and claim words the
specification never uses. It ends with a signed record. 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 published patents and applications and for testing your integration. An unfiled invention is
  confidential and may be export-controlled: for unpublished text use the self-host prompt instead. Never send an
  unfiled application here.
- It is evidence for a registered practitioner, not a legal opinion. Show every result as something to check.

## 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": "patent-claim-support"}` 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`) (about 120 claim elements). Over a limit: HTTP 429 with `Retry-After`.
3. One check at a time per demo token (409 otherwise).

## Endpoints
- `POST /patent/check` (token). Body:
  `{"spec": "...", "claims": "1. A device comprising ...\n2. The device of claim 1, ...", "only_claims"?: [1, 2, 3], "support"?: true, "title"?: "...", "stream"?: true}`,
  or `{"application": "..."}` (one text, cut at "What is claimed is:"), or `{"sample": "ladar-planted"}`.
  - Each claim starts on its own line with its number. Paragraphs numbered like `[0012]` are cited by that number.
  - Limits: 150,000 characters of specification, 40,000 of claims, 60 claims, 120 elements per request (use
    `only_claims` for more). `"support": false` runs the code checks only (no model call, no budget).
  - With `"stream": true` (or `Accept: text/event-stream`) it streams `ready` (claims split into elements with
    offsets, paragraphs, the code issues), a `receipt` after each model call, an `element` event per element
    (`{id: "2.1", strength, paragraphs: [{n, role}], reason}`), then `report`, `done` and `budget`. With
    `"stream": false`: one JSON object `{run_id, claims, elements, receipts, report, budget}`.
  - Strengths: `strong` (supported), `moderate` (supported, some doubt), `weak` (partly: a limitation is missing),
    `none` (no support found), `conflict` (the specification says otherwise), `error` (the call failed; nothing is guessed).
  - `report.issues`: `[{id, claim, kind: support|antecedent|dependency|multiple_dependency|numbering|term, severity: error|warning, message, offset?}]`.
- `POST /patent/parse` (token): the same body, code checks only, always JSON.
- `POST /patent/runs/{run_id}/decisions` `{"decisions": [{"target": "2.1" | "I3", "decision": "agree"|"disagree", "reviewer", "note"?}]}`: the practitioner's calls.
- `GET /patent/runs/{run_id}/export?format=csv` (claim chart), `md` (issues and chart), `record` (signed), `ledger` (signed, with the decisions).
- `POST /record/verify` (no token) `{"record": {...}}` → `{ok, summary, bad}`.
- `GET /patent/info`, `GET /patent/samples`, `GET /patent/samples/{id}`, `GET /attest/signing-key` (no token).

## Example: check a published patent and save the chart (Python, `pip install httpx`)
```python
import httpx, os, pathlib
API = "https://api.decosa.ai"
H = {"Authorization": f"Bearer {os.environ['DECOSA_API_KEY']}"}
s = httpx.get(f"{API}/patent/samples/filter").json()        # your own published patent has the same shape
r = httpx.post(f"{API}/patent/check", headers=H, timeout=600,
               json={"spec": s["spec"], "claims": s["claims"], "stream": False})
r.raise_for_status()
run = r.json()
for x in run["report"]["issues"]:
    print(x["severity"], x["kind"], x["message"])
pathlib.Path("claim-chart.csv").write_text(httpx.get(f"{API}{run['export']['csv']}", headers=H).text)
```

## Honest limits
- The support map finds the paragraphs that describe an element well, but misses many elements a practitioner would
  call only partly supported (a limitation described only in another embodiment, for example); see the measured rates
  on the Stack tab.
- The antecedent check is lenient on purpose; about half of what it flags on granted claims is a genuine slip, and a
  clean result is not proof of definiteness.
- Text only: paste or send the specification and claims; no DOCX, PDF or figures.

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 Patent claim-support checker: run it yourself (containers)

You are setting up the Decosa patent claim-support checker on this machine, so unfiled inventions never leave it. It
maps every claim element to the specification paragraphs that describe it, checks antecedent basis, claim references
and claim terms, 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/patent-claim-support.zip (15 KB, 13 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 patent-claim-support` (the api image carries the same bundle under /app/rehearsal/patent-claim-support/;
   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 patent-claim-support --bundle patent-claim-support.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: "planted: claim 3 depends on a later claim (12)", "planted: claim 7 depends on a claim that does not exist (30)", "planted: "the clock signal" in claim 5 has no antecedent"). 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, with prefix caching) 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`,
   `DECOSA_PATENT_MAX_ELEMENTS=400` 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>/patent/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":"patent-claim-support"}` and run
   `POST /patent/check {"sample": "ladar-planted", "stream": false}`. Expect 13 elements; 2.1 (a cryocooler the
   specification never mentions) and 5.1 (its paragraphs were deleted) marked `none`; antecedent issues in claims 1, 5
   and 6; dependency errors for claims 3 and 7; every receipt `attested`. Then `POST /record/verify` with
   `report.record`: `ok` must be true.
6. Report back: the public key and key id, the totals, the issues and how long the run took.

Off, and keep it off on a box that holds unfiled inventions: 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/patent-claim-support-mac.md instead.