Write a SAR narrative

# Decosa SAR narrative desk: use the hosted API (synthetic case files only)

You are wiring Decosa's SAR narrative desk into this project. From an alert's case file (a transactions CSV, customer
profile and alert fields, the investigator's notes) it drafts a suspicious-activity narrative in FinCEN's structure (who,
what, when, where, why, how), or a no-file rationale, or checks a narrative the investigator wrote. Every sentence cites
the rows, fields or notes it rests on; every amount, date, count and total is recomputed in code from the cited rows;
the other facts are judged against only the cited evidence. It returns a filing copy, a cited workpaper and a report
signed by the server, with a signed receipt for every model call. 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 takes synthetic case files only.** SAR information is confidential (31 U.S.C. 5318(g)(2); 31 CFR
  1020.320(e)). Every request must carry `"synthetic": true`; anything else gets HTTP 400. Real cases belong on a
  self-hosted box (see the self-host prompt). Never send real names, accounts or transactions here.
- This is a drafting aid, not a filing and never a compliance determination. Say so wherever you show results; an
  investigator decides whether to file and files.

## 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": "sar-narrative-desk"}` returns `{"token", "expires_at", "budget"}`.
   Sessions per IP are limited; over a limit you get HTTP 429 with `Retry-After`.
3. A full draft needs about 7,000 generated tokens of budget (402 otherwise); a check needs about 260 per sentence. One
   run at a time per demo token (409 while one is going).

## Endpoints
- `POST /sar/draft` (token). Body:
  ```json
  {"transactions": "id,date,type,direction,amount,channel,location,counterparty,memo\nT1,2026-03-04,cash deposit,in,9400.00,branch,Main St branch,,",
   "kyc": {"name": "...", "occupation": "...", "annual_income": "$38,000.00", "expected_activity": "..."},
   "alert": {"case_id": "...", "alert_rule": "...", "alert_date": "2026-03-20", "institution": "..."},
   "notes": "The investigator's notes.", "mode": "draft | no_file | check",
   "narrative": "only for mode check: sentences ending with [T3, K.occupation, N2]", "synthetic": true, "stream": false}
  ```
  CSV needs `date` and `amount` columns (other columns optional); ≤ 400 rows, ≤ 120,000 characters. Rows are cited
  `T1..Tn` (or the CSV's own `T` ids); profile fields `K.<name>`; alert fields `A.<name>`; note sentences `N1..`; the
  screen's computed facts `F1..`.
- JSON answer: `{status: held | needs_review | all_checked, counts, numbers: {ok, mismatch, unverified}, typologies,
  warnings, screen: {facts, typologies, indicated, possible}, sections, sentences: [{sid, section, text, clean, cites,
  status: checked | flagged | held | not_checked | no_claim, reasons, numeric: {mentions: [{text, kind, status,
  derivation | detail}]}, grounding, receipt_ids}], narrative_md (workpaper), narrative_plain (filing copy), report,
  receipts, budget}`. Show `held` sentences with their `reasons` and the figure in `detail`; never show a held sentence
  as part of the filing copy.
- SSE: send `Accept: text/event-stream` (or `"stream": true`): `ready`, `section`, `receipt`, `sentence`, `report`,
  `budget`, `done`.
- `POST /sar/numbers` (token): the same body with `narrative`; the numeric check only, no model call.
- `POST /sar/verify` (no token): `{report, narrative_md?, narrative_plain?, transactions?}` → `{valid_signature,
  signed_by_this_server, ...matches}`.
- `GET /sar/info`, `GET /sar/samples` (no token): the checks, thresholds, limits, sources, and six synthetic samples.

## Errors
400 bad input (the message names the field or the limit, or says the case is not marked synthetic), 401/403 token,
402 budget, 409 a run already going on this demo token, 413 body over 512 KB, 429 busy (`Retry-After`).

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 SAR narrative desk: run it yourself (containers)

You are setting up the Decosa SAR narrative desk on this machine, so case files never leave it. SAR information is
confidential (31 U.S.C. 5318(g)(2); 31 CFR 1020.320(e)). From a transactions CSV, the customer profile and the
investigator's notes it drafts a cited suspicious-activity narrative (or a no-file rationale, or checks a draft),
recomputes every number from the cited rows, and returns a filing copy, a cited workpaper and a signed report. Nothing
is sent to Decosa's hosted API. It is a drafting aid: an investigator decides and files.

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/sar-narrative-desk.zip (4 KB, 15 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 sar-narrative-desk` (the api image carries the same bundle under /app/rehearsal/sar-narrative-desk/;
   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 sar-narrative-desk --bundle sar-narrative-desk.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 run holds sentences back", "the wrong total is held as a number mismatch", "the held total names the figure the rows give"). 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`,
   `DECOSA_SAR_SYNTHETIC_ONLY=0` (so this box accepts real cases) and bind every port to 127.0.0.1. Never set the
   gateway route on this box: it would send case data 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>/sar/info` lists the modes, the checks, the screen thresholds, the limits
   and `synthetic_only: false`; `GET /attest/signing-key` shows this box's public key. Show me the key: it is what a
   reviewer pins to verify my reports.
5. Smoke test: get a token with `POST /demo/session {"vertical":"sar-narrative-desk"}`, fetch `GET /sar/samples`, and
   send the `planted-errors` sample (transactions, kyc, alert, notes, mode, narrative, synthetic) to `POST /sar/draft`.
   Expect `status: "held"`: the wrong total and the shifted date held as `number_mismatch` with the right figures, and
   the invented $25,000.00 wire held. Then send the `structuring` sample (mode `draft`): expect eight sections and
   `screen.indicated: ["structuring"]`. Then `POST /sar/verify` with the report, narrative_md and narrative_plain:
   `valid_signature`, `signed_by_this_server` and both matches must be true.
6. Report back: the public key, both statuses, the held sentences and how long each run took.

Off by default. Joining as a provider serves other people's requests on this GPU; never do it on a box that holds SAR
case data. 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/sar-narrative-desk-mac.md instead.