settld 0.1.1 → 0.1.5

package/docs/QUICKSTART_MCP.md

@@ -0,0 +1,337 @@
+# Quickstart: MCP (Stdio Spike)
+
+This quickstart connects an MCP-compatible agent/client to Settld using the Sprint 23 `stdio` MCP spike server.
+
+For host-specific setup (Claude, Cursor, Codex, OpenClaw), see `docs/QUICKSTART_MCP_HOSTS.md`.
+
+## Prerequisites
+
+- Node.js 20+
+- A Settld API key with appropriate scopes (`keyId.secret` format)
+- Settld API reachable (local `npm run dev:api` or hosted)
+
+## One-Command Local Demo (Paid MCP Exa Flow)
+
+Boots local API + provider wrapper + x402 gateway, runs MCP `settld.exa_search_paid`, verifies signatures/tokens, and writes an artifact bundle.
+
+To scaffold your own paid tool server quickly:
+
+```bash
+npx create-settld-paid-tool my-paid-tool
+```
+
+Run provider conformance/publish with machine-readable artifacts:
+
+```bash
+npm run provider:conformance -- \
+  --manifest ./paid-tool-manifest.json \
+  --base-url http://127.0.0.1:9402 \
+  --api-url http://127.0.0.1:3000 \
+  --api-key "$SETTLD_API_KEY" \
+  --json-out artifacts/provider-conformance.json
+
+npm run provider:publish -- \
+  --manifest ./paid-tool-manifest.json \
+  --base-url http://127.0.0.1:9402 \
+  --api-url http://127.0.0.1:3000 \
+  --api-key "$SETTLD_API_KEY" \
+  --json-out artifacts/provider-publication.json \
+  --conformance-json-out artifacts/provider-conformance-from-publish.json
+```
+
+Notes:
+
+- `provider:conformance` exits non-zero when verdict is not `ok` (use `--allow-fail` to keep exit code `0`).
+- `provider:publish` exits non-zero when `runConformance` is enabled and publication is not `certified` (use `--allow-fail` to keep exit code `0`).
+
+```bash
+npm run demo:mcp-paid-exa
+npm run demo:mcp-paid-weather
+npm run demo:mcp-paid-llm
+```
+
+Circle sandbox mode (real reserve path):
+
+```bash
+SETTLD_DEMO_CIRCLE_MODE=sandbox \
+X402_REQUIRE_EXTERNAL_RESERVE=1 \
+npm run demo:mcp-paid-exa -- --circle=sandbox
+```
+
+Circle sandbox mode with batch settlement execution:
+
+```bash
+SETTLD_DEMO_CIRCLE_MODE=sandbox \
+SETTLD_DEMO_RUN_BATCH_SETTLEMENT=1 \
+SETTLD_DEMO_BATCH_PROVIDER_WALLET_ID="$CIRCLE_WALLET_ID_ESCROW" \
+X402_REQUIRE_EXTERNAL_RESERVE=1 \
+npm run demo:mcp-paid-exa -- --circle=sandbox
+```
+
+Success output:
+
+```text
+PASS artifactDir=artifacts/mcp-paid-exa/...
+gateId=...
+decisionId=...
+settlementReceiptId=...
+```
+
+Artifact bundle includes:
+
+- `summary.json`
+- `mcp-call.raw.json`
+- `mcp-call.parsed.json`
+- `response-body.json`
+- `gate-state.json`
+- `reserve-state.json`
+- `provider-signature-verification.json`
+- `settld-pay-token-verification.json`
+- `batch-payout-registry.json` (when `SETTLD_DEMO_RUN_BATCH_SETTLEMENT=1`)
+- `batch-worker-state.json` (when `SETTLD_DEMO_RUN_BATCH_SETTLEMENT=1`)
+- `batch-settlement.json` (when `SETTLD_DEMO_RUN_BATCH_SETTLEMENT=1`)
+
+## Authority + Pinning Notes
+
+- Authority enforcement in this flow is API key scope + tenant-bound policy checks at Settld API/gateway surfaces.
+- Replay-critical settlement policy pinning is captured in `SettlementDecisionRecord.v2` (`policyHashUsed`, `verificationMethodHashUsed`), so decisions remain auditable and deterministic.
+- Receipts and exports bind the paid call to decision + settlement artifacts:
+  - `decisionId` (printed by demo and present in receipt data)
+  - `settlementReceiptId` (printed by demo and present in receipt data)
+
+Reference specs:
+
+- `docs/spec/SettlementDecisionRecord.v2.md`
+- `docs/spec/SettlementReceipt.v1.md`
+- `docs/spec/SettlementKernel.v1.md`
+
+## Run The MCP Server
+
+Set environment variables:
+
+```bash
+export SETTLD_BASE_URL='https://api.settld.work'   # or http://127.0.0.1:3000
+export SETTLD_TENANT_ID='tenant_default'
+export SETTLD_API_KEY='sk_live_xxx.yyy'            # keyId.secret (do not commit)
+export SETTLD_PROTOCOL='1.0'                       # optional; server will try to auto-discover
+export SETTLD_PAID_TOOLS_BASE_URL='http://127.0.0.1:8402' # optional; paid x402 tools
+```
+
+Start the server:
+
+```bash
+npm run mcp:server
+```
+
+The server speaks JSON-RPC 2.0 over `stdio` and exposes curated tools.
+If you run it in a normal terminal, it will just sit waiting for JSON-RPC input (this is expected). Use `mcp:probe` below to validate it end-to-end.
+
+## Optional: HTTP Gateway (HTTP -> MCP stdio)
+
+This is useful if you can do HTTP calls but cannot spawn a local MCP process.
+
+```bash
+export MCP_HTTP_PORT=8787
+npm run mcp:http
+```
+
+Then send JSON-RPC requests:
+
+```bash
+curl -sS http://127.0.0.1:8787/rpc \
+  -H 'content-type: application/json' \
+  -d '{"jsonrpc":"2.0","id":"1","method":"initialize","params":{"protocolVersion":"2024-11-05","clientInfo":{"name":"curl","version":"0"},"capabilities":{}}}' | jq .
+```
+
+## Sanity Check (No Manual JSON Copy/Paste)
+
+```bash
+npm run mcp:probe
+```
+
+This spawns the MCP server, runs `initialize` and `tools/list`, prints the responses, and exits.
+
+## x402 Gate Smoke (create -> verify -> get)
+
+Run an end-to-end x402 gate flow over MCP with explicit idempotency keys:
+
+```bash
+npm run -s mcp:probe -- --x402-smoke
+```
+
+This performs:
+
+1. `settld.x402_gate_create`
+2. `settld.x402_gate_verify` (auto-authorize enabled by default)
+3. `settld.x402_gate_get`
+
+You can override payloads from a JSON file:
+
+```bash
+cat > /tmp/settld-mcp-x402-smoke.json <<'JSON'
+{
+  "create": {
+    "amountCents": 250,
+    "idempotencyKey": "mcp_probe_create_custom_1"
+  },
+  "verify": {
+    "idempotencyKey": "mcp_probe_verify_custom_1",
+    "authorizeIdempotencyKey": "mcp_probe_auth_custom_1"
+  }
+}
+JSON
+
+npm run -s mcp:probe -- --x402-smoke --x402-smoke-file /tmp/settld-mcp-x402-smoke.json
+```
+
+## Agreement Delegation Tools (create/list)
+
+Create a delegation edge and list it via MCP:
+
+```bash
+cat > /tmp/settld-mcp-delegation-create.json <<'JSON'
+{
+  "parentAgreementHash": "1111111111111111111111111111111111111111111111111111111111111111",
+  "childAgreementHash": "2222222222222222222222222222222222222222222222222222222222222222",
+  "delegatorAgentId": "agt_parent",
+  "delegateeAgentId": "agt_child",
+  "budgetCapCents": 500,
+  "idempotencyKey": "mcp_probe_delegation_create_1"
+}
+JSON
+
+npm run -s mcp:probe -- --call-file settld.agreement_delegation_create /tmp/settld-mcp-delegation-create.json
+npm run -s mcp:probe -- --call settld.agreement_delegation_list '{"agreementHash":"1111111111111111111111111111111111111111111111111111111111111111","status":"active","limit":20,"offset":0}'
+```
+
+`settld.agreement_delegation_create` responses include `delegation.delegationHash` for deterministic orchestration and audit bindings.
+
+## Live Call Without Shell-JSON Footguns
+
+If your terminal copy/paste keeps inserting line breaks, pass tool arguments via a JSON file:
+
+```bash
+cat > /tmp/settld-mcp-create-agreement.json <<'JSON'
+{"amountCents":500,"currency":"USD","title":"MCP live probe","capability":"agent-task:demo","disputeWindowDays":7}
+JSON
+
+npm run -s mcp:probe -- --call-file settld.create_agreement /tmp/settld-mcp-create-agreement.json
+```
+
+Alternative that avoids paste issues entirely:
+
+```bash
+jq -n '{amountCents:500,currency:"USD",title:"MCP live probe",capability:"agent-task:demo",disputeWindowDays:7}' \
+  > /tmp/settld-mcp-create-agreement.json
+```
+
+## Tool Flow (Typical)
+
+1. Create an agreement (marketplace-backed) and a run:
+
+Method: `tools/call`
+
+Tool: `settld.create_agreement`
+
+Arguments example:
+
+```json
+{
+  "amountCents": 500,
+  "currency": "USD",
+  "title": "MCP spike agreement",
+  "capability": "agent-task:demo",
+  "disputeWindowDays": 7
+}
+```
+
+2. Submit evidence for the run:
+
+Tool: `settld.submit_evidence`
+
+```json
+{
+  "agentId": "<payeeAgentId from create_agreement>",
+  "runId": "<runId from create_agreement>",
+  "evidenceRef": "evidence://demo/step-1"
+}
+```
+
+3. Settle the run:
+
+Tool: `settld.settle_run`
+
+```json
+{
+  "agentId": "<payeeAgentId>",
+  "runId": "<runId>",
+  "outcome": "completed",
+  "outputRef": "evidence://demo/output"
+}
+```
+
+4. Resolve the settlement (so it is no longer `locked`):
+
+Tool: `settld.resolve_settlement`
+
+```json
+{
+  "runId": "<runId>",
+  "status": "released",
+  "reason": "demo settlement resolution"
+}
+```
+
+5. Open a dispute (only valid within the dispute window):
+
+Tool: `settld.open_dispute`
+
+```json
+{
+  "runId": "<runId>",
+  "reason": "Disputing for demo purposes",
+  "evidenceRefs": ["evidence://demo/dispute/1"],
+  "waitMs": 5000
+}
+```
+
+## Paid Tool Flows (`settld.exa_search_paid`, `settld.weather_current_paid`)
+
+Both paid tools exercise the same x402 path from MCP:
+
+1. First call returns `402` from the paid endpoint.
+2. MCP wrapper retries with `x-settld-gate-id`.
+3. Gateway returns `200` and `x-settld-*` verification/settlement headers.
+
+Run the local paid upstream + gateway from `docs/QUICKSTART_X402_GATEWAY.md`, then invoke:
+
+```bash
+cat > /tmp/settld-mcp-exa-search.json <<'JSON'
+{"query":"dentist near me chicago","numResults":3}
+JSON
+
+SETTLD_PAID_TOOLS_BASE_URL='http://127.0.0.1:8402' \
+npm run -s mcp:probe -- --call-file settld.exa_search_paid /tmp/settld-mcp-exa-search.json
+```
+
+Exa call result includes:
+
+- `response`: Exa-style search body.
+- `headers`: captured `x-settld-*` verification/settlement headers.
+
+Weather call example:
+
+```bash
+cat > /tmp/settld-mcp-weather.json <<'JSON'
+{"city":"Chicago","unit":"f"}
+JSON
+
+SETTLD_PAID_TOOLS_BASE_URL='http://127.0.0.1:8402' \
+npm run -s mcp:probe -- --call-file settld.weather_current_paid /tmp/settld-mcp-weather.json
+```
+
+## Notes
+
+- Writes require `x-settld-protocol`. The MCP server sets this automatically for write calls.
+- Run event appends require `x-proxy-expected-prev-chain-hash`. The MCP server fetches the current head and supplies it.
+- This is a spike (Sprint 23). Production hardening (SSE transport, rate limiting, etc.) is planned for Sprint 25.

package/docs/QUICKSTART_MCP_HOSTS.md

@@ -0,0 +1,143 @@
+# Quickstart: MCP Host Integrations (Claude, Cursor, Codex, OpenClaw)
+
+Use this when you want to connect a real agent host to Settld MCP in under 5 minutes.
+
+For core MCP flow details and paid-tool artifacts, see `docs/QUICKSTART_MCP.md`.
+
+## 0) Prerequisites
+
+- Node.js 20+
+- Settld API reachable (`http://127.0.0.1:3000` for local or your hosted API)
+- A tenant-scoped Settld API key (`keyId.secret` format)
+
+Export env once in your shell:
+
+```bash
+export SETTLD_BASE_URL='http://127.0.0.1:3000'
+export SETTLD_TENANT_ID='tenant_default'
+export SETTLD_API_KEY='sk_live_xxx.yyy'
+export SETTLD_PAID_TOOLS_BASE_URL='http://127.0.0.1:8402'
+```
+
+Sanity check the server before wiring any host:
+
+```bash
+npm run mcp:probe
+```
+
+## 1) Canonical MCP Server Definition
+
+Most hosts that support MCP stdio need a command, args, and env.
+Use this as your default server config:
+
+```json
+{
+  "name": "settld",
+  "command": "npx",
+  "args": ["-y", "settld-mcp"],
+  "env": {
+    "SETTLD_BASE_URL": "http://127.0.0.1:3000",
+    "SETTLD_TENANT_ID": "tenant_default",
+    "SETTLD_API_KEY": "sk_live_xxx.yyy",
+    "SETTLD_PAID_TOOLS_BASE_URL": "http://127.0.0.1:8402"
+  }
+}
+```
+
+If your host cannot spawn stdio commands, use HTTP bridge:
+
+```bash
+MCP_HTTP_PORT=8787 npm run mcp:http
+```
+
+Then point the host at:
+
+- MCP endpoint: `http://127.0.0.1:8787/rpc`
+- Health endpoint: `http://127.0.0.1:8787/healthz`
+
+## 2) Claude
+
+1. Open Claude MCP settings.
+2. Add a new MCP server using the canonical config above.
+3. Save and reconnect.
+4. Ask Claude to call:
+   - `settld.about`
+   - `settld.exa_search_paid` with `{"query":"dentist near me chicago","numResults":3}`
+
+Expected behavior:
+
+- First paid call triggers x402 challenge/authorize/retry automatically in the MCP wrapper.
+- Tool result includes Settld verification/settlement headers.
+
+## 3) Cursor
+
+1. Open Cursor MCP settings.
+2. Add an MCP server using the same canonical stdio definition.
+3. Reconnect tools.
+4. Run:
+   - `settld.about`
+   - `settld.weather_current_paid` with `{"city":"Chicago","unit":"f"}`
+
+Expected behavior:
+
+- Paid tool returns response body plus `x-settld-*` headers captured by the tool bridge.
+
+## 4) Codex
+
+1. Open Codex MCP/tooling configuration.
+2. Register Settld with the canonical stdio definition.
+3. Reload tool discovery.
+4. Run:
+   - `settld.about`
+   - `settld.exa_search_paid`
+
+Expected behavior:
+
+- Paid call resolves through the same x402 autopay flow.
+
+## 5) OpenClaw
+
+For OpenClaw, package Settld as a skill that declares MCP setup instructions.
+Reference skill payload:
+
+- `docs/integrations/openclaw/settld-mcp-skill/SKILL.md`
+- `docs/integrations/openclaw/settld-mcp-skill/mcp-server.example.json`
+- `docs/integrations/openclaw/CLAWHUB_PUBLISH_CHECKLIST.md`
+
+Minimum skill payload should include:
+
+- Name/description
+- MCP server command (`npx -y settld-mcp`)
+- Required env vars (`SETTLD_BASE_URL`, `SETTLD_TENANT_ID`, `SETTLD_API_KEY`, optional `SETTLD_PAID_TOOLS_BASE_URL`)
+- A smoke prompt using `settld.about`
+
+You can test locally first with:
+
+```bash
+npm run mcp:probe -- --call settld.about '{}'
+```
+
+## 6) 5-Minute Validation Checklist
+
+0. (CI/local gate) run hosted-style smoke once:
+
+```bash
+npm run test:ci:mcp-host-smoke
+```
+
+1. `npm run mcp:probe` passes locally.
+2. Host discovers Settld tools (`tools/list` includes `settld.*`).
+3. `settld.about` succeeds.
+4. One paid tool call succeeds (`settld.exa_search_paid` or `settld.weather_current_paid`).
+5. You can see a resulting artifact bundle from paid demo runs:
+   - `artifacts/mcp-paid-exa/.../summary.json`
+   - `artifacts/mcp-paid-weather/.../summary.json`
+
+## 7) Troubleshooting
+
+- `SETTLD_API_KEY must be a non-empty string`
+  - API key not injected into MCP server env.
+- Host cannot run `npx`
+  - Install Node 20+ and ensure `npx` is on PATH, or run HTTP bridge mode.
+- Paid tool returns gateway/connectivity errors
+  - Confirm `SETTLD_PAID_TOOLS_BASE_URL` points to a running gateway.

package/docs/QUICKSTART_PRODUCE.md

@@ -0,0 +1,61 @@
+# Quickstart: Produce + verify a bundle (bootstrap)
+
+This quickstart is for design partners who want an end-to-end “from zero” flow:
+
+1) initialize trust + keys
+2) produce a bundle
+3) verify it strictly and archive the JSON output
+
+## 0) Install (from this repo)
+
+From a checkout:
+
+```sh
+npm ci
+```
+
+## 1) Initialize trust
+
+```sh
+node packages/artifact-produce/bin/settld-trust.js init --out out/trust --format json --force
+```
+
+This writes:
+
+- `out/trust/trust.json` (public trust anchors; safe to commit)
+- `out/trust/keypairs.json` (private keys; **do not commit**)
+
+For production deployments, use remote signing so no private keys touch disk:
+
+- RemoteSigner contract: `docs/spec/REMOTE_SIGNER.md`
+- Operator notes: `docs/OPERATIONS_SIGNING.md`
+
+## 2) Produce a JobProof bundle
+
+```sh
+node packages/artifact-produce/bin/settld-produce.js jobproof \
+  --out out/jobproof \
+  --keys out/trust/keypairs.json \
+  --format json \
+  --deterministic \
+  --force
+```
+
+The output JSON is `ProduceCliOutput.v1` (see `docs/spec/ProduceCliOutput.v1.md`).
+
+## 3) Verify strictly
+
+Export trust anchors from `trust.json`:
+
+```sh
+export SETTLD_TRUSTED_GOVERNANCE_ROOT_KEYS_JSON="$(node -e \"const fs=require('fs'); const t=JSON.parse(fs.readFileSync('out/trust/trust.json','utf8')); process.stdout.write(JSON.stringify(t.governanceRoots||{}))\")"
+export SETTLD_TRUSTED_TIME_AUTHORITY_KEYS_JSON="$(node -e \"const fs=require('fs'); const t=JSON.parse(fs.readFileSync('out/trust/trust.json','utf8')); process.stdout.write(JSON.stringify(t.timeAuthorities||{}))\")"
+```
+
+Then verify and archive machine output:
+
+```sh
+node packages/artifact-verify/bin/settld-verify.js --format json --strict --job-proof out/jobproof > out/verify.json
+```
+
+`out/verify.json` is `VerifyCliOutput.v1` and is intended to be archived as audit evidence.

package/docs/QUICKSTART_RELEASE_VERIFY.md

@@ -0,0 +1,39 @@
+# Quickstart: Verify a Settld Release (Authenticity)
+
+This verifies Settld **distribution artifacts** (npm tarballs, conformance pack, audit packet) using a signed `ReleaseIndex.v1` rooted in a release trust file.
+
+## Offline verification (recommended)
+
+1) Download a release’s assets into a directory (example: `./release/`), including:
+
+- `release_index_v1.json`
+- `release_index_v1.sig`
+- every artifact listed in `release_index_v1.json.artifacts[]`
+
+2) Verify using the pinned release trust roots:
+
+```sh
+settld-release verify --dir ./release --trust-file trust/release-trust.json --format json --explain
+```
+
+- Exit code `0` means verified.
+- `--format json` prints `VerifyReleaseOutput.v1` to stdout (pipe-safe, deterministic).
+- `--explain` prints deterministic diagnostics to stderr.
+
+## Mirror/HTTP verification (base URL)
+
+If your org mirrors release assets under a single base URL:
+
+```sh
+settld-release verify --base-url https://example.com/settld/releases/v1.0.0-rc.1/ --trust-file trust/release-trust.json --format json --explain
+```
+
+This downloads `release_index_v1.json`, `release_index_v1.sig`, then downloads every artifact referenced by the index (relative to the base URL) into a temp directory before verifying.
+
+## Trust domains (important)
+
+Release authenticity trust roots are **separate** from bundle verification trust roots.
+
+- Release trust: `trust/release-trust.json`
+- Bundle verification trust: `SETTLD_TRUSTED_GOVERNANCE_ROOT_KEYS_JSON` / `trust.json` (see `docs/spec/TRUST_ANCHORS.md`)
+

package/docs/QUICKSTART_SDK.md

@@ -0,0 +1,125 @@
+# Quickstart: First verified agent run with the SDK
+
+Goal: run one end-to-end agent transaction (register identities, append run events, verify `green`, release settlement) using `SettldClient.firstVerifiedRun(...)`.
+
+## 0) Install deps
+
+```sh
+npm ci
+```
+
+## Fast Path (recommended)
+
+Use the helper scripts to avoid manual export churn across shells:
+
+```sh
+npm run dev:env:init
+# edit .env.dev with your DATABASE_URL once
+```
+
+Start API:
+
+```sh
+npm run dev:start
+```
+
+In another shell:
+
+```sh
+source scripts/dev/env.sh
+npm run dev:sdk:first-run
+```
+
+Run the full billing + dispute + arbitration doctor flow:
+
+```sh
+source scripts/dev/env.sh
+npm run dev:billing:doctor
+```
+
+Optional: make `sdk:first-run` create a disputable settlement window:
+
+```sh
+SETTLD_SDK_DISPUTE_WINDOW_DAYS=3 npm run sdk:first-run
+```
+
+## 1) Start the API with a local ops token
+
+```sh
+export PROXY_OPS_TOKEN=dev_ops_token
+npm run dev:api
+```
+
+## 2) Create an API key for SDK calls
+
+In a second shell:
+
+```sh
+export SETTLD_BASE_URL=http://127.0.0.1:3000
+export SETTLD_TENANT_ID=tenant_default
+export SETTLD_API_KEY="$(
+  curl -sS -X POST "$SETTLD_BASE_URL/ops/api-keys" \
+    -H "authorization: Bearer $PROXY_OPS_TOKEN" \
+    -H "x-proxy-tenant-id: $SETTLD_TENANT_ID" \
+    -H "content-type: application/json" \
+    -d '{"scopes":["ops_read","ops_write","finance_read","finance_write","audit_read"],"description":"sdk quickstart"}' \
+  | jq -r '.keyId + "." + .secret'
+)"
+```
+
+## 3) Run the SDK example
+
+```sh
+node scripts/examples/sdk-first-verified-run.mjs
+```
+
+Expected output:
+
+```json
+{
+  "runId": "run_sdk_...",
+  "payeeAgentId": "agt_payee_...",
+  "payerAgentId": "agt_payer_...",
+  "runStatus": "completed",
+  "verificationStatus": "green",
+  "settlementStatus": "released"
+}
+```
+
+## 4) Use the helper directly in code
+
+```js
+import { SettldClient } from "./packages/api-sdk/src/index.js";
+
+const client = new SettldClient({
+  baseUrl: process.env.SETTLD_BASE_URL,
+  tenantId: process.env.SETTLD_TENANT_ID,
+  apiKey: process.env.SETTLD_API_KEY,
+  xApiKey: process.env.SETTLD_X_API_KEY // optional for Magic Link deployments that enforce x-api-key
+});
+
+const result = await client.firstVerifiedRun({
+  payeeAgent: { publicKeyPem: "...", owner: { ownerType: "service", ownerId: "svc_a" } },
+  payerAgent: { publicKeyPem: "...", owner: { ownerType: "service", ownerId: "svc_b" } },
+  payerCredit: { amountCents: 5000 },
+  settlement: { amountCents: 1200 },
+  run: { taskType: "translation" }
+});
+```
+
+## 5) Pull tenant analytics + trust graph (Magic Link)
+
+```js
+const analytics = await client.getTenantAnalytics("tenant_default", { month: "2026-02", bucket: "day", limit: 20 });
+const graph = await client.getTenantTrustGraph("tenant_default", { month: "2026-02", minRuns: 1, maxEdges: 200 });
+const diff = await client.diffTenantTrustGraph("tenant_default", { baseMonth: "2026-01", compareMonth: "2026-02", limit: 50 });
+```
+
+Or run the prebuilt script:
+
+```sh
+SETTLD_BASE_URL=http://127.0.0.1:8787 \
+SETTLD_TENANT_ID=tenant_default \
+SETTLD_X_API_KEY=test_key \
+npm run sdk:analytics
+```