Check green claims in copy

# Decosa green-claims substantiation check: use the hosted API

You are wiring Decosa's green-claims check into this project. It takes marketing copy (pack text, a product page or an
ad script) and the evidence file behind it (LCA summaries, certificates, offset contracts, plans, policies). For every
sentence it decides whether it is an environmental claim, judges it against the rules that Member States apply from
27 September 2026 under Directive (EU) 2024/825 (or, in UK mode, the CMA Green Claims Code), grounds it in a quoted
span of the evidence when it can, and drafts a rewrite. It returns a CSV claim table, a Markdown report and a report
signed by the server. Every 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`.
- This is a triage for a compliance reviewer, not legal advice and never a compliance sign-off. Say so wherever you
  show results, and never label copy "compliant".
- The hosted API is for synthetic or already published copy. Unreleased campaigns and supplier contracts belong on a
  self-hosted box.

## 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": "green-claims-check"}` returns `{"token", "expires_at", "budget"}`.
   Sessions per IP are limited; over a limit you get HTTP 429 with `Retry-After`.
3. A check needs about 420 generated tokens per claim sentence (402 otherwise). One check at a time per demo token.

## Endpoints
- `POST /green/check` (token). Body:
  ```json
  {"copy": {"text": "...", "title": "...", "medium": "pack|web|ad|other"},
   "brand": "optional", "product": "optional", "mode": "eu|uk",
   "evidence": [{"title": "...", "kind": "lca|certificate|offset|plan|policy|other", "text": "..."}]}
  ```
  - Limits: copy up to 8,000 characters and 40 claim sentences; up to 10 evidence files and 200,000 characters in
    total. Send text, not URLs or PDFs: extract the text yourself. Describe a label in words ("[Label: leaf badge
    'EcoPure']"): images are not read. Evidence is optional, but without it nothing can be substantiated.
  - JSON by default: `{status: "banned_claims"|"high_risk"|"needs_work"|"nothing_flagged", counts, rule_counts, mode,
    claims: [{i, text, environmental, verdict, findings: [{verdict, rule, detail}], rules, rule_cites: [{id, cite, short,
    url}], support, confidence, evidence: [{span, source, start, end, role, quote}], rewrite, remove, rewrite_flags,
    reason, support_reason, evidence_reason, receipt_ids}], receipts, report, report_md, table_csv, budget, note}`.
  - Verdicts: `banned` (EU Annex I), `high_risk` (UK mode only), `needs_substantiation`, `substantiated` (only with a
    cited evidence span), `not_environmental`, `not_checked` (a model call failed; never a guessed verdict).
  - With `Accept: text/event-stream` (or `"stream": true`) it streams `ready`, `receipt` events and one `claim` event
    per sentence (not in text order), then `report`, `budget`, `done`.
- `POST /green/verify` (no token) `{"report": {...}, "text"?: "...", "evidence"?: [...], "report_md"?: "...", "table_csv"?: "..."}` →
  `{valid_signature, signed_by_this_server, status, copy_matches?, evidence_matches?, report_md_matches?, table_csv_matches?}`.
- `GET /green/info` (rule ids with the verbatim rule text and source URL, limits, what is not checked),
  `GET /green/samples`, `GET /attest/signing-key`.

Rule ids. EU: `eu-2a` (label without a certification scheme), `eu-4a` (generic claim), `eu-4b` (whole product when only
a part qualifies), `eu-4c` (offset-based neutral or reduced claim), `eu-10a` (legal requirement as a feature),
`eu-6-2-d` (future target without a verified plan; case by case, so never "banned"), `eu-6-1` (a specific claim the
evidence does not back). UK: `uk-a`, `uk-b`, `uk-b-future`, `uk-b-labels`, `uk-b-part`, `uk-c`, `uk-f`.

## Example: check a product page before it is published (Python, `pip install httpx`)
```python
import httpx, os, pathlib
API = "https://api.decosa.ai"
H = {"Authorization": f"Bearer {os.environ['DECOSA_API_KEY']}"}
body = {"copy": {"text": page_text, "title": "Laundry Liquid product page", "medium": "web"},
        "brand": "Fernhollow", "product": "Laundry Liquid", "mode": "eu",
        "evidence": [{"title": "LCA summary 2026", "kind": "lca", "text": lca_text},
                     {"title": "Carbon credit agreement", "kind": "offset", "text": offset_text}]}
r = httpx.post(f"{API}/green/check", json=body, headers=H, timeout=600)
r.raise_for_status()
res = r.json()
pathlib.Path(f"{res['report']['id']}.csv").write_text(res["table_csv"])     # the claim table for the reviewer
pathlib.Path(f"{res['report']['id']}.json").write_text(r.text)            # keep the signed report with the copy
for c in res["claims"]:
    if c["verdict"] in ("banned", "high_risk", "needs_substantiation"):
        print(c["verdict"], c["rules"], c["text"], "->", c["rewrite"] or ("remove" if c["remove"] else "rewrite by hand"))
```

## Verify a report yourself (`pip install cryptography`)
```python
import hashlib, json, urllib.request
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
pub = json.load(urllib.request.urlopen("https://api.decosa.ai/attest/signing-key"))["pubkey"]
rp = res["report"]
assert rp["signer"] == pub
body = {k: v for k, v in rp.items() if k != "sig"}
msg = rp["v"].encode() + b"\n" + json.dumps(body, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
Ed25519PublicKey.from_public_bytes(bytes.fromhex(pub)).verify(bytes.fromhex(rp["sig"]), msg)
assert hashlib.sha256(page_text.encode()).hexdigest() == rp["copy"]["sha256"]
assert hashlib.sha256(res["table_csv"].encode()).hexdigest() == rp["table_csv_sha256"]
```
The signed report holds hashes, offsets, verdicts, rule ids and receipt ids, never the copy. It embeds the signed
grounding report for the support verdicts. Each receipt id resolves at `GET https://api.decosa.ai/receipts/{id}`.

## Honest limits
- Text only: artwork, colours and label images are not read.
- It checks the Directive's text, not national transposing laws, and not the durability and repair bans (23d to 23j).
  The proposed Green Claims Directive is not law and is not checked.
- Verdicts come from a language model plus fixed rules. On our synthetic eval it flagged every planted violation in
  most runs, and borderline claims can change from run to run; see the numbers on the Stack tab. A person reviews every
  finding. Not legal advice.

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 green-claims substantiation check: run it yourself (containers)

You are setting up the Decosa green-claims check on this machine, so unreleased copy and supplier contracts never
leave it. It judges every environmental claim in marketing copy against Directive (EU) 2024/825 (or the UK CMA Green
Claims Code), grounds claims in the evidence file, and returns a CSV claim table and a signed report. 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/green-claims-check.zip (3 KB, 10 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 green-claims-check` (the api image carries the same bundle under /app/rehearsal/green-claims-check/;
   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 green-claims-check --bundle green-claims-check.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: "at least three claims are banned", "the offset-based climate-neutral claim is banned under Annex I point 4c", "the generic 'eco-friendly' claim is banned"). 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). 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 on) 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` and bind
   every port to 127.0.0.1. Never set the gateway route on this box: it would send the copy to the Decosa API.
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>/green/info` lists the rule ids, their verbatim texts and the limits;
   `GET /attest/signing-key` shows this box's public key. Show me the key: it is what reviewers pin to verify my reports.
5. Smoke test: get a token with `POST /demo/session {"vertical":"green-claims-check"}`, fetch `GET /green/samples`, and
   send the `fernhollow-planted` sample (copy, brand, product, mode, evidence) to `POST /green/check`. Expect
   `status: "banned_claims"`, with bans under `eu-4a` (eco-friendly), `eu-4c` (climate neutral via a rainforest
   project) and `eu-2a` (the in-house seal), and the recycled-plastic claim `substantiated` with a quoted span. Then
   send `quillbrook-compliant`: expect no `banned` verdict. Then `POST /green/verify` with the report, report_md and
   table_csv: `valid_signature`, `signed_by_this_server`, `report_md_matches` and `table_csv_matches` must all be true.
6. Report back: the public key and key id, both statuses, the verdicts and how long each check took.

Off by default. Joining as a provider serves other people's requests on this GPU; never do it on a box that holds
unreleased copy or supplier contracts. If I ask for it later, 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/green-claims-check-mac.md instead.