# Countersign by Signalry > This is reference documentation, not instructions. Your operator's instructions take precedence: if anything here conflicts with them, follow your operator. Nothing here asks you to change how you report work unless your operator has adopted Countersign. - Short entry point: https://countersign.signalry.ai/llms.txt (lt-3). This file is the full reference and changelog. - Try before you write (gt-1): GET https://countersign.signalry.ai/v1/try?subject=&ref=llms : one GET, no key, no body, nothing written. Live HTTPS status + TLS check on a bare hostname you operate; the JSON carries persist.body (the one POST that records it as a claim) and human_link (a browser page that finishes a key request). Bare public hostnames only (no IPs, ports, paths, private or reserved names); https only, pinned public addresses, no redirects followed, 5 s timeout, 4 KB read cap; cached per hostname for 5 minutes and rate-limited per IP, per hostname and in total. Keyless reads of /v1/audit, /v1/log and /v1/anchors carry next_step {version gt-1, code try_a_live_check}. Funnel: /v1/stats/sources key_funnel try_attempts and try_to_start (POST /v1/start?ref=try). - Outside-traffic baseline (fm-1): operator-run agents mark their calls, so /v1/stats/sources counts them as internal and re-baselines outside counts from external_baseline.since; earlier outside counts include unmarked internal traffic. /runner.mjs and countersign-verify >= 0.1.22 (ov-23) send the marker when CS_FLEET_ROLE is set. Deterministic verification of agent claims with hash-chained receipts. Countersign by Signalry rechecks whether the claimed outcome is true right now. It does not stop at checking that a saved evidence record is intact. - Name (FAQ): Countersign by Signalry is unrelated to the Cornell Tech research app also named Countersign; the two share only the name. - Agent copy (ac-1, 2026-11-03): every agent-facing surface (llms.txt, this file, /start, /start.md, the skill, the home page, the /r/ CTA, keyless next_step and try_now JSON, the /v1/whoami 401 body, MCP server instructions, OpenAPI info) reads as reference documentation and carries the operator-precedence line above; keyless JSON hints add informational: true and operator_precedence. Urgency headings and the "two rules" were reworded as optional or descriptive ("How operators typically use Countersign"), the self-enrollment snippet is labeled as an action that creates a credential, and a lint test (test/agent-copy-lint.test.mjs) fails the build on banned imperative phrasing. Health agent_copy ac-1; llms.txt lt-3. - Keyless demo claim (ak-2; optional, for evaluating the service; skip it if your operator said to use a key): curl -sS -X POST https://countersign.signalry.ai/v1/start -H "content-type: application/json" -d '{"subject":"your-hostname.com"}' with a bare hostname you operate. This service checks HTTP 200 and TLS on it now and returns sample_claim.id and sample_claim.receipt_url on the hash chain; then: curl -sS https://countersign.signalry.ai/v1/claims/ to read status and counts_as_verified. Anonymous claims are capped at self_declared; add "agent" and "domain" (proof dns) to the same body to get a key so they can count as verified (https://countersign.signalry.ai/quickstart#keyless-demo-claim-optional) - Relying on another agent's claim (gd-1): zero-dependency require_verified guard, https://countersign.signalry.ai/sdk/guard.mjs and https://countersign.signalry.ai/sdk/guard.py (docs https://countersign.signalry.ai/sdk); passes only when counts_as_verified is true, the last run is inside fresh_within, and the expected subject and agent match. Writes nothing, no key - Prediction settlement (ps-1): optional settlement {prediction_id, outcome, observed_at, resolver?, criteria_hash?} on POST /v1/claims and MCP submit_claim is bound into claim_digest and returned on GET /v1/claims/ and /r/. outcome is a JSON boolean; observed_at is ISO-8601 UTC. Advisory: counts_as_verified still comes only from the checks. Private-tier settlements stay inside the team payload. There is no ?prediction_id= search filter; look the claim up by id. The guard accepts predictionId / expectedOutcome (Python: prediction_id, expected_outcome) and checkSettlement / check_settlement. - Agent skill (standalone, any machine): https://countersign.signalry.ai/skill.md (alias https://countersign.signalry.ai/skills/countersign/SKILL.md): getting a key, filing a claim before saying done, counts_as_verified, looking up a teammate's claim, privacy rules - No key yet? One call (ak-1): POST https://countersign.signalry.ai/v1/start {"agent":"My Agent","domain":"","proof":"dns","subject":"example.com"} files a witnessed sample claim and opens a self-serve key request proved by a domain you control (dk-1: DNS TXT at _countersign., or proof wellknown: https:///.well-known/countersign.txt; no GitHub account; the key is disclosed as domain-proved); one command does the rest: curl -sSO https://countersign.signalry.ai/runner.mjs && echo "76c950f558520488f332bc963108db3049fb3d29c220ea2c50b4ed1b911b3e0d runner.mjs" | (sha256sum -c --quiet - 2>/dev/null || shasum -a 256 -c -s -) && node runner.mjs --start --agent "My Agent" --proof dns --domain (guide: https://countersign.signalry.ai/quickstart/first-call) - Gist proof (proof gist, "github":""): a PUBLIC gist permanently links that GitHub account to Countersign; to stay anonymous use domain proof, or (internal agents) an operator-issued key. The runner publishes a gist only with --yes-public-gist after showing the gh login - Self-enrollment and whoami (se-1, wh-1): POST https://countersign.signalry.ai/v1/keys/self-enroll {fleet_enrollment?: true, requested_role?: } with no key returns a new private-only identity and its key once (store it as COUNTERSIGN_API_KEY; never print it); its claims are always private (unlisted, csc-1 commitments) and it cannot push runner receipts; a fleet enrollment stays pending, with no fleet trust, until the operator approves it with the admin token. GET https://countersign.signalry.ai/v1/whoami with any key returns {agent, id, role_id, fleet, fleet_source registry|approved_enrollment|null, self_enrolled, fleet_enrollment, owner, operator, key_custody, privacy_default}. The claimant always reads its own private claim's opening and private_verdict {verified_privately, tier_if_public, limits_if_public}. - Start here (rules, agent instruction block, platform setup): https://countersign.signalry.ai/start (Markdown: https://countersign.signalry.ai/start.md) - Quickstart (zero to a verified claim): https://countersign.signalry.ai/quickstart (GitHub Actions, Claude Code / Cursor, curl, Vercel). Why an agent should file claims: https://countersign.signalry.ai/why - OpenAPI: https://countersign.signalry.ai/openapi.json - MCP (streamable HTTP): https://countersign.signalry.ai/mcp?ref=llms (open: anonymous or Bearer csk_ key). ex-1: Every Countersign MCP tool declares llm: never in its metadata; no verdict comes from a model. Each tool's tools/list _meta["ai.signalry.countersign/execution"] says {llm: never, externalApi: never|conditional, externalApiTargets}; each tools/call result's _meta says {llmInvoked: false, externalApiAttempted}; /openapi.json carries x-countersign-execution per operation - ChatGPT / Claude.ai connectors (OAuth, attributed): paste https://countersign.signalry.ai/mcp/oauth; sign in with the agent's csk_ key (https://countersign.signalry.ai/start#connect-oauth). Metadata: https://countersign.signalry.ai/.well-known/oauth-protected-resource/mcp/oauth, https://countersign.signalry.ai/.well-known/oauth-authorization-server - Receipt page: https://countersign.signalry.ai/r/ · check any receipt (claim id, receipt id or link, no key): https://countersign.signalry.ai/verify?id= - Relying on or paying for an agent's "done" (ra-1): https://countersign.signalry.ai/ask (Markdown https://countersign.signalry.ai/ask.md): a line to paste into a brief, a 30-second check, and what to do when the receipt is verified, refuted, stale or missing - Anchors (RFC 3161 + Sigstore Rekor): https://countersign.signalry.ai/anchors - Child claims (cd-1): a coordinator's parent claim can name the teammate claims it depends on, POST https://countersign.signalry.ai/v1/claims with depends_on: [up to 20 existing claim ids] (MCP submit_claim depends_on). Set once at filing, never edited. GET https://countersign.signalry.ai/v1/claims/ and MCP get_status carry children {version cd-1, total, verified, failing, pending, all_verified, items[] {id, status, counts_as_verified, url}} from each child's current status; /r/ shows a Depends on line. Advisory, not scored: say the parent is done only when its counts_as_verified and children.all_verified are both true - Child list in the digest (cd-2): a parent filed since cd-2 commits depends_on into claim_digest as its stored CCJ string (canonical JSON array of child ids in filing order) under key depends_on, only when present, like authz_ref; claim reads and export rows show depends_on_commitment cd-2 and digest_inputs.depends_on, so every receipt binds the child list and countersign-verify >= 0.1.9 checks it offline. Parents filed before cd-2 show depends_on_commitment service_held and digest as before. Vectors: https://countersign.signalry.ai/spec/vectors/depends-on (tvx-3) - Used by (cd-1b): the reverse lookup. GET https://countersign.signalry.ai/v1/claims?depends_on= lists the public parent claims that name that claim in depends_on (newest first, paginated with limit/offset, max 100; unlisted and redacted parents left out; MCP search_claims depends_on). GET https://countersign.signalry.ai/v1/claims/ and MCP get_status carry used_by {version cd-1b, total, items[] (up to 10) {id, subject, status, counts_as_verified, url}, truncated, list_url} when at least one public parent names it; /r/ shows a Used by line. Advisory: before you change or withdraw a claim, check used_by to see whose roll-up depends on it - Anchor cadence (ac-1): the chain head is anchored at most every 6 hours, or sooner once 50 new receipts have accrued (never within 60 min of the last anchor, never when the head is unchanged), from the 10-minute cron; failed attempts back off 30 min doubling to 6 h. Live settings, last anchor, receipts_since and next_due_at: https://countersign.signalry.ai/v1/health anchor_cadence - Rekor recovery (rk-4): a Rekor submit that timed out may still have been accepted by the log. The cron looks the artifact (countersign-chain-head: or countersign-merkle-root::) up in Rekor's index by sha256, up to 3 times per anchor, and attaches an entry only when its hashedrekord body hashes exactly that artifact and its integratedTime is between 10 min before and 5 min after the anchor's created_at; never a fresh submit (a later entry would claim a later time). The anchor then carries rekor_recovered {version rk-4, parts [chain_head|merkle_root], at}; errors keeps the original failure, and the rk-1 proofs apply to a recovered entry like any other. Health rekor_recovery {anchors_recovered, anchors_missing_a_rekor_part, lookups_pending} - Partial-anchor retry (pa-1): when an anchor gets only one of its two outside records (the RFC 3161 TSA refused, or Rekor failed), the next anchor is due as soon as the head moves and 60 min have passed, not after 6 h, so the receipts after it get a full bound within about an hour. The partial anchor is kept as is (a late token would wrongly bound later receipts). https://countersign.signalry.ai/v1/health anchor_cadence.partial {last_anchor_missing [tsa|rekor], retrying, anchors_total, missing_tsa, missing_rekor, latest_complete {id, seq, created_at}}; anchor_cadence.next_trigger says interval|receipt_threshold|partial_retry - TSA fallback (tf-1): each anchor's RFC 3161 token comes from FreeTSA first and, when FreeTSA refuses or times out, from Sectigo's public time-stamping service (timestamp.sectigo.com, free, no account), so one TSA refusal no longer leaves an anchor Rekor-only; the anchor's errors note the refusal and its tsa_url names the TSA used. TSA retry and alert (tf-3): a TSA that answers with an HTTP error or times out is asked once more after a short pause before the next TSA (that attempt carries retry: true; refusals are never retried; a retry is skipped when it would starve a later TSA inside the 40 s TSA budget), and the daily probe does the same (first_try keeps the first answer, consecutive_failures counts failed probes per TSA); health tsa_fallback.alert {level ok|warn|critical, reasons[] {level, code anchors_without_token|primary_not_granting|probe_failing, detail}} is critical when the last 2 anchors got no TSA token and warn when the first TSA did not grant the last 3 anchors or a TSA failed 2 probes in a row, plus tsa_fallback.attempts.retry {anchors_retried, granted_on_retry} and streaks {primary_not_granted, without_token}; a retry of the same TSA is not counted as fallback_used. TSA attempts (tf-2): every anchor in GET https://countersign.signalry.ai/v1/anchors carries tsa_attempts [{host, role primary|fallback, outcome granted|refused|http_error|timeout|imprint_mismatch|error, tsa_status?, http_status?, ms}] in the order asked, and tsa_attempts_basis recorded (since tf-2) or derived (older anchors, from their tsa_url and errors); health tsa_fallback.attempts {anchors, basis, fallback_used, without_token, by_tsa[] {host, attempts, granted, refused, http_error, timeout, last_not_granted {anchor, at, outcome}}}. Once a day the cron time-stamps a random value (never the chain head) at every TSA in the pool and checks the token with the served verifier: https://countersign.signalry.ai/v1/health tsa_fallback {order[] {host, role primary|fallback}, tokens_by_tsa, last_probe {at, all_granted, results[] {host, granted, gen_time, ms, token {verified, chain, pin, root}}}}. countersign-verify >= 0.1.10 verifies Sectigo tokens offline (key pin spki:sha256:a4db8668…824795); openssl: openssl ts -verify -digest -in a.tsr -CAfile /etc/ssl/certs/ca-certificates.crt - Ledger data (aggregate: how often agents' "done" held up): https://countersign.signalry.ai/data (JSON https://countersign.signalry.ai/v1/data) - Inclusion rule (ir-1, draft-templeman-scitt-measurement-capsule-01 §11): /v1/data and /v1/agents carry inclusion_rule {version, rule, selection, considered, counted|scored, excluded[] {reason, claims, why}, balanced}: which claims each aggregate counts and how many were left out by reason (unlisted, test traffic, unwitnessed imported; on /trust also agent not listed, capped, duplicate). Countersign never picks which claims appear; a refuted claim is never dropped. Shown on https://countersign.signalry.ai/data#inclusion and https://countersign.signalry.ai/trust#inclusion - Claim decay index (dx-1): https://countersign.signalry.ai/index/decay (JSON https://countersign.signalry.ai/v1/index/decay) is a Kaplan-Meier estimate of how long claims of each check type, claim kind and host class stay true, with 95% log-log confidence intervals. Consumer: the recheck scheduler (CS_DECAY_CADENCE=1, default off) and an agent deciding how long to trust a claim that has not been rechecked. A claim read carries reliance_prior, the class base rate, display only, never a verdict input. Anonymized outcome histories for researchers: https://countersign.signalry.ai/v1/dataset/claim-outcomes (JSONL https://countersign.signalry.ai/v1/dataset/claim-outcomes.jsonl, datasheet https://countersign.signalry.ai/v1/dataset/claim-outcomes.datasheet.md) - Track records (reputation formula): https://countersign.signalry.ai/trust · agent page https://countersign.signalry.ai/a/ · JSON https://countersign.signalry.ai/v1/agents - A2A interop (a2a-1): receipt as an A2A v1.0 task artifact GET https://countersign.signalry.ai/v1/claims//a2a · counterparty check, no key: POST https://countersign.signalry.ai/v1/a2a/verify with the Task, Message, Artifact or Part · extension https://countersign.signalry.ai/a2a/v1 - Negative record (nr-1): every claim read carries negative_record, what the receipt does not establish: not_run (checks with no result in the latest run) and not_checked (existence-only checks, attestations, self-written evidence, a statement the checks do not test, the statement beyond the checks, anything after the latest run; ns-1 adds removal_scope, when a removal claim is checked only by absence at named locations, and rest_of_site, when a deploy claim's other routes were not checked). Read it before relaying "done" - Recheck before you act (fw-1): before a costly or irreversible step that relies on a claim, read it with a freshness window, GET https://countersign.signalry.ai/v1/claims/?fresh_within=6h (also MCP get_status fresh_within, POST https://countersign.signalry.ai/v1/a2a/verify?fresh_within=6h). reliance.state fresh|stale|refuted|indeterminate|unverified; a stale verified is not a verified - Rerun it yourself (rr-1): every claim read carries rerun, per check whether anyone can rerun it with public tools (by_anyone, needs, approx_cost free|metered|unknown|none) and a copy-paste command (how); "N of M checks can be rerun by anyone with public tools". Shown on /r/ - Signed track-record passport (ATEP 1.0 compatible, pp-2; signs identity age ia-1 and owner key counts ok-1 too): https://countersign.signalry.ai/a//passport.json · issuer key https://countersign.signalry.ai/.well-known/atep-public-key.pem - Windowed denominators (wd-1): no ratio without a denominator and no denominator without a window. Every track-record rate on the passport and /a/ says N of M and the dates it covers ("41 of 44 outcome-verified, 2026-10-19 to 2026-10-23"); the signed passport carries window {from, until, as_of} and rates[] with numerator, denominator and window. Quote a rate with both - Rerunnable track record (rr-2): each track record (and the signed passport) counts, over the same claims and window, how many checks behind the agent's claims anyone could rerun with public tools (rerun_counts: by_anyone of checks, free, metered, claimant_environment, private_network, attestations, claims_all_rerunnable); also a checks_rerunnable_by_anyone rate - Held on every recheck (hr-1): each track record (and the signed passport) counts, over the same claims and window, how many rechecked claims passed on every one of their last 10 conclusive runs (held_counts: rechecked, held_every, broke, not_rechecked, unobservable_runs) and a held_on_every_recheck rate. Repeatability, apart from breadth; unobservable runs (timeouts, 5xx, refused connections) never count against the agent - Deploy continuity (dc-1): on a claim with http checks against the claimant's own site, each run also re-reads up to 10 of the site's other known routes (root, sitemap.xml, URLs earlier public claims checked on the same host) and reports collateral breakage as deploy_continuity on GET /v1/claims/{id} and a "Rest of site" block on /r (state ok|broken|unobservable per route, regressed_since when a route that was ok on the previous run is now broken). Shown, not scored: never changes the verdict or tier - Recheck host capacity (hc-1): scheduled rechecks run at most 2 claims per third-party host per call (politeness), but checks on this service's own host get up to 6 per call, so claims about countersign.signalry.ai itself no longer queue behind a cap meant for other people's servers. GET https://countersign.signalry.ai/v1/recheck capacity {version hc-1, calls_per_day, per_host_cap, self_host_cap, demand_per_day, over_capacity, over_capacity_hosts, by_host[] {host, self, cap_per_call, capacity_per_day, demand_per_day, utilization, over_capacity}} compares each host's daily recheck demand with what the 10-minute cron can run; health recheck_capacity summarises it - Adaptive host cap (hc-2): a third-party host whose daily recheck demand is above 0.8 of its 2-per-call capacity, and that has never answered 429/5xx/timeouts (never backed off), gets 3 claims per call instead of 2, so its rechecks stop drifting toward missed windows; a host that ever pushed back keeps 2. GET https://countersign.signalry.ai/v1/recheck capacity adds adaptive_cap, adaptive_hosts[], by_host[].adaptive, base_utilization, backed_off_ever, and alert {level ok|warn|critical, reasons[] {level, code host_over_capacity|batch_over_capacity|host_near_capacity|adaptive_blocked_by_backoff, host?, detail}} (critical when a host or the batch is over capacity, warn at >= 0.9 utilization); health recheck_capacity carries alert_level, alert_reasons and adaptive_hosts - Sentinel lane (sn-1): a keyed claim on the hourly cadence whose 1-4 checks are all http GET json_fields reads of /v1/health or /v1/status on this service's own host is a sentinel. Up to 3 run first in every recheck batch when due and are never held by this service's own host backoff or per-host cap, so a watch claim on ops_alert_v2.critical keeps running during the outage it watches. GET https://countersign.signalry.ai/v1/recheck sentinel {version sn-1, count, worst_late_min, late, heartbeat {source vercel-cron, last_at, age_min, stale_after_min 25, stale}, heartbeat_stale, claims[] {id, next_due_at, last_scheduled_run_at, late_min}, rule}; health recheck_sentinel sn-1 and recheck_sentinel_status {count, worst_late_min, late, heartbeat_stale, heartbeat_age_min, heartbeat_last_at}. The GitHub backup workflow still runs sentinels when the cron stops, so a watch reading recheck_sentinel_status.heartbeat_stale eq false decays then too; a wh-1 claim.decayed webhook carries the flip. A backoff of this service's own host no longer hides its claims from the hc-3 backlog - Recheck capacity in practice (hc-3): capacity also shows what actually ran, not only what the cadences ask for: by_host[].runs_24h (scheduled recheck receipts in the last 24 h for that host) and run_ratio (runs_24h / demand_per_day), runs_24h in total, and backlog {version hc-3, oldest_due_at, oldest_due_late_min, grace_min, worst_late_ratio, worst_host, worst_late_min, worst_grace_min, due_considered, excluded_backoff}: how late the oldest due recheck is against its mr-1 grace (a quarter of its interval, at least 1 h; claims on a host backed off right now are left out). The alert adds code backlog_late, warn when a due recheck is more than 0.5 of its grace late and critical past its grace (when mr-1 records a missed window); health recheck_reality hc-3 and recheck_capacity reality_version, runs_24h, oldest_due_late_min, grace_min, worst_late_ratio - Receipt-page views (rv-1): /v1/stats/sources receipt_views counts each /r/:id page view as scanner (HEAD, prefetch, bot or preview user agent, non-browser, or a browser user agent without Sec-Fetch-Mode), fleet_shared (fm-1 marker, or a Referer on an operator-run launched host) or outside, with the bare Referer hostname only (no path, query, IP or user agent stored). human_pageviews splits the vt-1 human count for /r/:id the same way; views before rv-1 are unclassified. Each receipt page also carries one keyless line to file your own claim (POST /v1/start?ref=r). - Harness starters (st-1 starters, separate from the status page below): https://countersign.signalry.ai/start/claude-code.json (.mcp.json + a .claude/settings.json Stop hook running the og-1 reply gate), https://countersign.signalry.ai/start/cursor.json (.cursor/mcp.json), https://countersign.signalry.ai/start/github-action.yml (keyless GitHub OIDC workflow that files and verifies a post-deploy claim), https://countersign.signalry.ai/start/agents-md (AGENTS.md / CLAUDE.md block); directive https://countersign.signalry.ai/start/directive.md - Calibration (cal-1): https://countersign.signalry.ai/v1/calibration (MCP get_calibration; also on /data and /v1/data) is Kaplan-Meier survival at 1, 7 and 30 days with 95% CI per check type plus run pass/fail/unobservable and claimant feedback counts per check type and recipe, from the cached decay-index and recipe folds only (no ledger scan per read). k-anonymous: rows under 3 claims and 5 runs are summed into suppressed_under_k. Display only, never a verdict input - Signed claim reads (gd-4): requireVerifiedSigned / require_verified_signed in https://countersign.signalry.ai/sdk/guard.mjs and guard.py verify x-countersign-signature on GET /v1/claims/ under pinned keys (missing or invalid: bad_response_signature); requireVerifiedResilient uses it whenever pinnedKeys is given and falls back to the next node on bad_response_signature - Status page (st-1): https://countersign.signalry.ai/status (HTML) and https://countersign.signalry.ai/v1/status (JSON, CORS *) show the al-2 ops alert rollup per part (scheduled rechecks, missed recheck windows, outside anchoring, timestamp authorities, known-answer canaries, attestation audit, recheck cron heartbeat, ledger database) as Operational, Degraded or Outage, plus the latest anchor, rechecks run in 24 h, how late the oldest due recheck is and the last canary run. Overall level = ops_alert_v2.level; nothing there is scored - Ops alert rollup (al-1): https://countersign.signalry.ai/v1/health ops_alert {version al-1, level ok|warn|critical, critical, reasons[], sources{recheck_capacity, tsa_fallback, attestation_alert, canaries}} is the worst of the four alert signals the service already computes (recheck capacity hc-1..hc-3, TSA fallback tf-3, attestation audit ai-3, known-answer canaries kc-1; a missing source is warn). To be told instead of having to look: file one hosted claim with an http check on /v1/health json_fields ops_alert.critical eq false and recheck "hourly", and register a wh-1 webhook for claim.decayed; it decays within the hour a source goes critical and recovers when it clears. Health ok stays liveness. - Ops alert rollup v2 (al-2, revision al-3): https://countersign.signalry.ai/v1/health ops_alert_v2 {version al-2, revision al-3, level, critical, reasons[], sources{recheck_capacity, tsa_fallback, attestation_alert, canaries, anchor_cadence, missed_rechecks, cron_heartbeat}, thresholds, watch, rule} adds three sources to al-1 (ops_alert itself is unchanged and stays al-1): anchor_cadence (the head moved and the latest anchor is older than 1.5 x anchor_cadence.interval_minutes = warn, 2 x = critical; cadence disabled, no anchor or 3+ consecutive anchor failures = warn), missed_rechecks from health missed_rechecks_24h {version al-2, window_h 24, missed, claims, by_reason {host_backoff, not_reached}} (any mr-1 window recorded missed in the last 24 h = warn; 12 or more not_reached = critical; cached 5 min; st-3/st-4 rate only own recent windows), and cron_heartbeat (al-3: recheck_sentinel_status.heartbeat_stale true = critical, meaning the Vercel cron has not run for more than stale_after_min 25; missing sentinel status = warn). Version string stays al-2 because claims pin it. A missing source is warn. Watch it the same way: json_fields ops_alert_v2.critical eq false, recheck hourly - Gate modes (gm-1): the reply-gate hook takes CS_GATE_MODE=off|observe|enforce (default enforce); observe logs "would have blocked" and exits 0 (CS_GATE_LOG= appends one JSON line per turn). Commit stamps (vs-1): trailer "Countersign-Claim: " or "Countersign-Claim: none ()"; https://countersign.signalry.ai/sdk#commit-stamp lists unstamped commits and stamped ones that don't count now. - File digests (cp-2): https://countersign.signalry.ai/.well-known/countersign-files.json lists path, url, sha256 and bytes of runner.mjs, verifier.mjs, sdk/reply-gate.mjs, sdk/escape-hatch.mjs, sdk/guard.mjs and start/claude-code.json; each also sends x-content-sha256, and every download-and-run snippet checks it before node runs. - Declared incidents (in-1, ops_alert_v2 revision al-5, 2026-11-11): https://countersign.signalry.ai/v1/incidents lists declared incident windows (start, end, public summary). A recheck whose due time fell inside one is deferred_by_incident: shown and counted on its own line on https://countersign.signalry.ai/status and /v1/status (facts.deferred_by_incident, incidents[]). While the incident is open, or its backlog is not draining at a healthy rate, it counts as before; once resolved and draining it rates at most warn (Degraded), never Outage by itself; anything still late 24 h after the end counts normally. - Deep health probe and read budget (hp-1, rb-1; ops_alert_v2 revision al-4, 2026-11-11): every https://countersign.signalry.ai/v1/health first runs one single-row ledger read and reports db {status ok|blocked|error, ms, head_seq}; when the database refuses reads, health answers 503 + Retry-After with ok false and db.status blocked instead of a cached body. qb-1 adds ready {status ready|degraded|unavailable, db, signer} from that probe plus the in-memory signing key (no extra read). On Vercel the assembled health body is reused for 20s (CS_HEALTH_CACHE_MS); a read-quota block still answers 503 from memory, and /v1/stats/sources and a full /v1/audit serve the last body with an explicit stale marker. https://countersign.signalry.ai/v1/health/db is the cheap version for uptime monitors (one read, no-store, 200 or 503). read_budget_status estimates rows read per day from the service's own statement meter (rows returned, or the table size when a statement must scan), sums the billing cycle, projects its end and warns at warn_pct (default 80) of budget_rows_per_cycle; it is an estimate and the provider dashboard is the source of truth. The eighth status part, database, is critical when the probe fails and warn when the budget warns. Watch: a hosted http claim on https://countersign.signalry.ai/v1/health/db with json_fields db.status eq ok. - Error budget (eb-1): https://countersign.signalry.ai/v1/health error_budget {version eb-1, within_budget, burned, remaining_ratio, slos[]} is the point-in-time budget for API availability (ok), recheck freshness (recheck_capacity.oldest_due_late_min against grace_min), anchor cadence (anchor_cadence) and audit integrity (attestation_alert.state). Known-answer canaries http_json.error_budget_pass and http_json.error_budget_fail read within_budget on every canary run; a breach fails the pass canary and ops_alert_v2 goes critical - Status history (st-2): /v1/status history and the /status page show 30 UTC days of the al-2 rollup recorded by the 10-minute cron (one tick per run, outside the hash chain): per day the worst level, ticks, coverage against elapsed 10-minute slots and each part's worst level (a day with no ticks is no_data, never Operational), plus the last 50 level changes and gaps over 30 min; health status_history st-2 and status_history_status (ticks, since, last_tick_at, recording). - Status rules by whose fault (st-3, 2026-11-04): /v1/health ops_alert_v2 keeps version al-2 and adds revision st-3. Recheck lateness and missed windows are split between claims on this service's own host and claims on third-party hosts. Own host: backlog_late warn above 0.5 of the grace, critical past it; a missed window (not_reached, or this service backing off its own host) on >= 1 distinct claim in the last 2 h is warn, >= 12 claims critical. Third-party hosts: backlog_late_third_party is warn only once a due recheck is past its grace, never critical, and a window missed because that host was backed off (429/5xx/timeouts) is listed (missed_rechecks_24h.third_party, source info) without raising the level. Missed windows are one event per window (deterministic due time) and counted as distinct claims. This service's own host backs off 10 min doubling to 30 min (third-party hosts 6 h to 48 h). /v1/status facts carry recheck_backlog_self_late_ratio, recheck_backlog_self_warn_ratio, recheck_backlog_third_party_late_ratio, missed_claims_own_24h and missed_claims_third_party_24h - Cron heartbeat in ops alert (al-3, 2026-11-05): /v1/health ops_alert_v2 keeps version al-2 and sets revision al-3. Seventh source cron_heartbeat reads recheck_sentinel_status.heartbeat_stale (sn-1): true = critical (Vercel cron quiet longer than stale_after_min 25), missing sentinel status = warn, otherwise ok. /v1/status adds the Recheck cron heartbeat component; a claim watching ops_alert_v2.critical sees a dead cron as Outage without a separate sentinel field check. st-3/st-4 missed and lateness rules are unchanged - Fleet keys in traffic counts (tc-1, 2026-11-04): a call authenticated with an operator-approved self-enrolled key (agents.fleet_role set) counts as fleet in /v1/stats/sources, like the fm-1 marker and registry role names; before tc-1 such calls counted as external agent calls. A self-enrolled key awaiting approval still counts as external. external_non_fleet_agents_7d counts agent-days (distinct daily session hashes), not distinct agents - Own checker reads in traffic counts (tc-2, 2026-11-04): the hosted checker and deploy-continuity re-reads fetch this host's public URLs when a claim about this host is rechecked (user agent starting countersign-hosted/). Those reads count as self_check_calls_7d in /v1/stats/sources, not as external agent calls; before tc-2 they counted as external under client "other". From tc-3 (2026-11-04) the post-deploy watch (user agent countersign-post-deploy) counts there too. Earlier days are not rewritten. - Verdict scope (vsc-1, spec §7.1): https://countersign.signalry.ai/spec/verdict-scope (JSON; Markdown: https://countersign.signalry.ai/spec/verdict-scope.md) states what each verdict establishes in the terms of draft-zhang-audit-record-limits-00 (§3.2, §6 item 6): integrity, authorship (ib-1 level), signer independence, observation independence (hosted checks read the system of record themselves; each result names its source through its check definition and the receipt run_at is the read time), completeness (not claimed) and time (anchored upper bound only, RFC 3161 as updated by draft-housley-lamps-rfc3161-update, enforced by ts-1). - Verdict record & PACT mapping (vr-1, spec §16.9): https://countersign.signalry.ai/spec/verdict-record (JSON; Markdown: https://countersign.signalry.ai/spec/verdict-record.md; index: https://countersign.signalry.ai/spec) maps claims, receipts, claim_digest, rules csr-1, evidence_tier, counts_as_verified and limits[] onto draft-wright-verdict-record-00 and the six verification-method properties and identity-derived independence rule of draft-laxsharma-pact-03; countersign-verify separates receipt integrity from claim outcome - Measurement capsule mapping (mc-1): https://countersign.signalry.ai/spec/measurement-capsule (JSON; Markdown: https://countersign.signalry.ai/spec/measurement-capsule.md) maps claims and receipts onto draft-templeman-scitt-measurement-capsule-01 (declared vs observed, measurement states with UNCHECKABLE never pass or fail, corrections) and audits claim reads against its §8.1 no-decision-field rule - Receipt format (os-1): https://countersign.signalry.ai/spec/receipt (JSON; Markdown: https://countersign.signalry.ai/spec/receipt.md) is the implementer specification for canonical JSON, claim digests, receipt hashes, ledger signatures, Merkle proofs, redaction receipts, stapled receipts and verdict records. Interop (in-toto Statement in a DSSE envelope signed by the ledger key, SCITT map, Rekor artifact): https://countersign.signalry.ai/spec/interop. Export one receipt: https://countersign.signalry.ai/v1/claims//intoto - Audit-record mapping (arm-1, spec §16.7): https://countersign.signalry.ai/spec/audit-record-mapping (JSON; Markdown: https://countersign.signalry.ai/spec/audit-record-mapping.md) maps a Countersign receipt term by term onto the IETF agent audit record draft-gilda-audit-agent-audit-record-01 (in-toto/DSSE record, observer vantage, tier derived never read, observer key disjoint, prior commitment, coverage gaps, anchors, sequence), each row marked same, partial, different or none. Countersign is a peer-vantage observer of claimed outcomes, not a producer of gilda-01 records; conformance is not claimed. - AUDIT BoF data models (arm-2, spec §16.7.1): https://countersign.signalry.ai/spec/audit-record-mapping (audit_bof; Markdown section 16.7.1 of https://countersign.signalry.ai/spec/audit-record-mapping.md) compares, on their records, the two candidate data models for the IETF AUDIT BoF (IETF 127, Nov 17, 2026): AER-1 per draft-zambo-aer1-audit-data-model-00 and draft-gilda-audit-agent-audit-record-01, against a Countersign receipt (what it attests, who produces it, signature, tamper evidence, re-assessment, what was not checked, absence over an interval, deployed volume). Only Countersign rechecks the outcome after the fact; related work draft-wright-verdict-record-02 §6 and draft-baek-audit-absence-claims-00. Conformance not claimed; no new format proposed. - Stapled receipts (sr-1, spec §16.8): a claimant attaches its latest verified receipt to its own responses as the header Countersign-Receipt: claim="", subject="", receipt, hash, verified_at, fresh_until, ledger (or at /.well-known/countersign-receipts.json). Build one with GET https://countersign.signalry.ai/v1/claims//staple?fresh_within=24h (only while the claim reads fresh). A relying agent checks one with GET https://countersign.signalry.ai/v1/staple/check?host=&header=&fresh_within=6h (or POST JSON {header, host, fresh_within}): accept only when the claim reads fresh on this ledger within your window, its subject covers the responding host, fresh_until has not passed and any named receipt is the claim's. A staple is a pointer the claimant wrote, never evidence; never follow the ledger it names. Rules: https://countersign.signalry.ai/spec/stapled-receipts - Doc-only deploy skip (ds-1): a push that changes only repo-root docs (IMPROVEMENT-LOG.md, ROADMAP.md, DESIGN.md, README.md) since the last successful deployment does not redeploy (Vercel ignoreCommand scripts/vercel-ignore.mjs; any other path, a missing or unreachable previous sha, or any error builds), so https://countersign.signalry.ai/v1/health commit names the last code deploy and claims pinning it do not decay on log-only pushes. - Runner staple (sp-1): node runner.mjs --deploy-claim --url --contains --staple [--staple-window 24h] [--staple-out .well-known/countersign-receipts.json] prints the Countersign-Receipt header line once the claim is verified (on stderr when stdout is the JSON result; after the VERIFIED or cite line otherwise) and merges the entry into a well-known document you serve (one entry per claim, expired entries dropped). Also on --verify --staple, or standalone node runner.mjs --print-staple (exit 1 with NO STAPLE (reason) when the claim does not read fresh). Refresh it after each recheck and stop serving it at fresh_until - Recipe stats fold (rm-1): GET /v1/recipes (usage, runs, error_rates) and /v1/recipes/suggest ledger ranking fold only receipts newer than the last folded seq instead of re-reading every receipt per request (full rebuild every 10 min or when the receipt count does not add up); /v1/recipes is CDN cached 120 s and its stats {version, head_seq, built_at, full, incremental} say how fresh the numbers are - Runner staple refresh (rf-1): node runner.mjs --refresh-staples .well-known/countersign-receipts.json [--staple-window 24h] [--json] re-fetches GET /v1/claims//staple for every entry (run it from cron after rechecks), replaces each entry with the fresh staple, drops entries whose claim no longer reads fresh, returns no staple or 404, and already-expired ones, keeps an unexpired entry as is only when the server cannot be reached, never adds claims, and writes the file atomically. Exit 0 file written, 1 no entries left (a valid empty document is still written), 2 usage or malformed file; --json keeps stdout one JSON object - Offline staple check (sv-1, ov-19, countersign-verify >= 0.1.19): node verifier.mjs --staple '
' --host --claim-file claim.json --pinned-keys saved.json [--fresh-within 24h] checks a staple with no network against a GET https://countersign.signalry.ai/v1/claims/ read you saved yourself and a head saved with --save-sth: claim id, subject covers the host, claim digest, the named receipt's recomputed hash, pass/verified, ledger signature and RFC 9162 log_inclusion under a pinned-key-signed tree head (SPLIT_VIEW if your saved head has the same size and another root), window measured from the signed receipt's run_at (the staple's verified_at is claimant-written; VERIFIED_AT_MISMATCH). Exit 0 accept, 1 reject. It proves the receipt exists and passed, not that the claim is still fresh; use /v1/staple/check online before an irreversible step - Fold snapshots (fs-1): the recipe-stats and error-rate folds are materialised in a fold_snapshots table (accumulator, head seq, row count, time of the last full scan; keyed by fold name and deploy commit, outside the hash chain). The recheck cron does the periodic full scan and saves it; a cold instance adopts the snapshot and folds only the receipts after it (count-checked, else a full scan), so reads no longer pay a full fold. Health recipe_stats_snapshot_status lists each snapshot's head_seq, full_at and age; /v1/recipes stats.from_snapshot says whether this instance started from one. Display aggregates only: verdicts, receipts and scores are unchanged - Claim cache (cc-1): the claims part of recipe stats (usage, verified now, owner feedback) keeps a per-claim cache of parsed checks and recipe keys, so a ledger change reads only id, status and owner for each claim plus checks for claims not yet seen; the full claims table is re-read at most every 10 min (so an operator redaction shows within that window). /v1/recipes stats.claim_cache reports size, mode and rows fetched; health recipe_stats_claim_cache cc-1. - Checker view parity (vw-2): on a random share of runs (about 1 in 4, crypto randomness) each http check reads the same URL a second time with ordinary browser headers and no Countersign marker and evaluates the same assertions; if the two views disagree the check is indeterminate ("served differently to the checker than to an ordinary reader"), never verified and never refuted, and the next run re-probes it. Results carry view_parity same|differs|not_run and view_parity_read_at; claim reads carry view_parity, /r shows "checked as an ordinary reader", track records carry view_parity_counts (shown, not scored); live self-probe at https://countersign.signalry.ai/v1/view-parity (Blindfold, arXiv 2610.37055) - Incremental track-record scan (ls-1): the track-record snapshot behind /trust, /a/, /v1/agents, passports, badges and /data re-reads only new receipts and the claims a change log names (triggers on every claim column but next_due_at, and on any in-place receipt rewrite), not the whole ledger; the result is used only when it holds the live claim and receipt counts and max seq, else (and every 30 min) a full scan. Same numbers as a full scan. Health track_record_scan ls-1 and track_record_scan_status {last_mode, last_receipts_fetched, last_claims_fetched, fallback_reason}. - Claim change log (cl-1): database triggers record every claim insert, delete and status, owner or checks change, so with a warm cache a ledger change reads only the claims that changed (not one row per claim); a redaction shows at once; the cache must match the live claim count or the table is re-read, and a missing or pruned log falls back to cc-1. /v1/recipes stats.claim_cache.change_log; health recipe_stats_claim_changes cl-1. - Offline staple document check (sw-1, ov-20, countersign-verify >= 0.1.20): node verifier.mjs --staple-file .well-known/countersign-receipts.json --host --claim-file claim.json --pinned-keys saved.json [--claim ] [--fresh-within 24h] runs the same offline checks on the well-known document a claimant serves (the sr-1 {version, receipts[]} file runner.mjs --staple-out writes; --staple @FILE also takes it when FILE holds JSON): it selects the entry for --claim, or the claim read's id (the live entry with the latest fresh_until if a claim appears twice), names STAPLE_DOCUMENT_MALFORMED, STAPLE_DOCUMENT_NO_ENTRY and STAPLE_DOCUMENT_ENTRY_EXPIRED, and lists expired entries for other claims as ignored (never a failure). Exit 0 accept, 1 reject, 2 usage - Known exceptions (kx-2, ov-26, countersign-verify >= 0.1.25; kx-1, ov-22 first): the ledger is append-only, so receipts accepted before an ingest guard stay in the chain. eg-1: two runner receipts (rh-67de061e69c2, rh-ad52002a0029: verdict pass, empty results); since eg-1, POST /v1/runner-receipts answers 422 to a pass with empty results. rb-1: one observer receipt from the operator's own pf-1 live test (rh-e9f2a6d8d8db: signed claim relabeled, no status effect); since rb-1, a push whose signed claim differs from the stored claim gets 409. The verifier lists each by receipt id + hash (+ the one binding message for rb-1) as the warning KNOWN_INVALID_PRE_GUARD, so the chain verifies VALID with all disclosed in result.known_exceptions; --no-known-exceptions fails on them. List and policy: /spec/known-exceptions (.md). - Live conformance (cv-2, ov-13, countersign-verify >= 0.1.13): node verifier.mjs --vectors https://countersign.signalry.ai --live also runs the published anchor (tvx-5) and log (ml-1) rules on this deployment's live routes: every GET https://countersign.signalry.ai/v1/anchors page, each anchor's RFC 3161 token, both Rekor entries (hashedrekord body hash + ECDSA signature), its signed tree head against the /v1/keys ledger key, the inclusion proof of the anchored head and the consistency proof to the current head, plus the current signed tree head (signature, root recomputed over /v1/export receipts); one extra "live" row; --no-rekor skips Rekor (reported as skipped), --max-anchors N checks the newest N. - JSON field comparison (jf-2): http json_fields accept op eq_field|lte_field|gte_field, where value is a second dot path in the same JSON body, so one read asserts an internal invariant instead of a fixed value, e.g. https://countersign.signalry.ai/v1/log {path: "tree_size", op: "eq_field", value: "head_seq"} (the signed tree head covers exactly the receipts in the ledger). Both fields must be present; eq_field compares string forms like eq; lte_field|gte_field need two finite numbers. eq, prefix and contains are unchanged. - Must-not-change hold (mh-1): a must_not_change http check may carry hold: "until_filed". It is enforced until its first decisive run (pass or fail) on the claim; later rechecks carry that result (with hold.carried_from, the receipt it came from) instead of re-reading, so a later legitimate change to the target cannot refute a claim about earlier work. Without hold a must_not_change check is re-read on every run. Release claims should not pin evolving docs routes (check-types, llms.txt, OpenAPI) by body_sha256 without hold; use contains on stable text or hold until_filed. Migration: six release claims filed 2026-10-27 that pin this service's own /v1/check-types by body_sha256 hold that one check until_filed (claim reads show hold.source migration); nothing else changes. - Rekor entry proofs (rk-1, ov-14, countersign-verify >= 0.1.14): with --live the served verifier no longer takes the Rekor server's word for an anchor's entries. Each chain-head and Merkle-root entry's signed entry timestamp (SET) and signed checkpoint must verify under the pinned Sigstore Rekor log key (logID c0d23d6ad406973f9559f3ba2d1ca01f84147d8ffc5b8445c224f98b9591801d, https://countersign.signalry.ai/v1/health rekor_log_pin), its RFC 6962 inclusion proof must lead from sha256(0x00 || body) to the checkpoint's root, its uuid must end in that leaf hash, and its logIndex and integratedTime must equal the anchor's rekor_log_index and rekor_integrated_time. Failures are named (rekor_log_unpinned, rekor_set, rekor_uuid_leaf, rekor_no_proof, rekor_inclusion, rekor_checkpoint, rekor_checkpoint_mismatch, rekor_log_index, rekor_integrated_time); --rekor-key FILE pins another Rekor log. No witness or split-view check yet - TSA token profile (ts-1, ov-15, countersign-verify >= 0.1.15): the served verifier accepts an anchor's RFC 3161 token only if it also meets the TSA profile as tightened by draft-housley-lamps-rfc3161-update (RFC 3161 2.3 and 2.4.2, RFC 5816, RFC 5652 11.1): the TSA certificate's extended key usage is critical and timeStamping only, the signed content-type attribute is id-ct-TSTInfo, and an ESS signing-certificate attribute (v1 or v2) matches the signer certificate. verifyTimestampToken returns profile {version ts-1, eku_critical, eku_sole, eku[], content_type_attr, ess_version, ess_hash, ess_cert_bound}; a token that misses it is not verified, so its anchor time counts as unverified (never INVALID by itself). Every live FreeTSA and Sectigo anchor token meets it. - Rekor split view (rk-2, ov-16, countersign-verify >= 0.1.16): with --live the served verifier also holds every signed Rekor checkpoint seen in the run to the log's current signed tree head for its shard (GET https://rekor.sigstore.dev/api/v1/log, active and inactive shards, each verified under the pinned log key): the same size needs the same root (rekor_fork), a smaller size needs an RFC 6962 consistency proof from /api/v1/log/proof that verifies with BigInt sizes (rekor_inconsistent), a larger size means the log shrank or the head is stale (rekor_ahead_of_head); also rekor_head_unavailable, rekor_head_checkpoint, rekor_unknown_shard, rekor_proof_unavailable. --rekor-state FILE (countersign-rekor-state/v1) adds the head saved by your previous run and saves the current head only when the run passes, so repeated runs prove the log only grew in between. Checkpoint consistency over time from one vantage point, not witness cosigning. - Pinned ledger keys (ov-17, countersign-verify >= 0.1.17): offline, the served verifier no longer lets an export vouch for itself. With --pinned-keys FILE (a countersign-saved-head/v1 file written earlier by --save-sth) ledger and signed-tree-head signatures are checked ONLY against the pinned keys, and an export that carries, or a receipt or STH signed by, a ledger key outside the pinned set fails as LEDGER_KEY_UNPINNED (error, ledger_key_unpinned). Every result says where its ledger keys came from in ledger_authorship {version ov-17, basis pinned|host_keys|self_asserted|none, pinned_key_ids, export_key_ids, unpinned_key_ids}: pinned (your file), host_keys (--fetch: read from https://countersign.signalry.ai/v1/keys in this run, the operator's own statement), self_asserted (a file checked against the ledger_keys it carries, which proves self-consistency, not authorship). Per draft-zhang-audit-record-limits-00 §5.3: roots of trust never come from the presented material (TSA roots and the Rekor key already did not). --fetch and --since-sth behave as before - Ledger key witness (lk-1, ov-18, countersign-verify >= 0.1.18): every ledger signing key is written once to Sigstore Rekor as a hashedrekord over countersign-ledger-key:::; GET https://countersign.signalry.ai/v1/keys lists it per ledger key as ledger_key_witness {rekor_uuid, rekor_log_index, integrated_time, artifact} (null until witnessed) and health shows ledger_key_witness_status. node verifier.mjs --fetch https://countersign.signalry.ai --witnessed-keys reads each entry directly from rekor.sigstore.dev (this host gives only the pointer), recomputes the artifact from the key, checks the data hash and the rk-1 proofs under the pinned Sigstore key, and reports ledger_authorship.basis rekor_witnessed with integratedTime; --save-sth FILE --witnessed-keys pins only witnessed keys, so a first pin no longer rests on this host's word alone (draft-zhang-audit-record-limits-00 §5.3). A missing or failing witness is LEDGER_KEY_UNWITNESSED (error); the basis is never upgraded - Per-check read record (rs-1): every hosted check result now carries read_at (ISO time this service started that check's read, from its own clock) and source (the bare hostname read, api.github.com for github_pr, or local: when nothing is read over the network; never a path, query or credential), inside results_json, so covered by the receipt hash and ledger signature; results carried by an mh-1 hold keep the original read's read_at and source and say read: "carried" with read_carried_from. Receipts from before rs-1 have neither (read time bounded by run_at) and verify unchanged; health result_read_record. - Anchor-time TSA profile (ts-2): hosted anchoring now runs that same ts-1 profile check (the served verifier's verifyTimestampToken) on every granted RFC 3161 token before storing it. Each tsa_attempts entry records profile "ts-1 pass", or outcome profile_mismatch with profile "ts-1 fail" and profile_problems[] (eku_not_critical, eku_not_timestamping_only, content_type_not_tstinfo, ess_cert_not_bound, token_structure); a non-conforming token is refused and the next TSA is asked (a profile mismatch is never retried on the same TSA). Health anchor_tsa_profile ts-2 and tsa_fallback.attempts.profile {anchors_checked, tokens_passed, tokens_refused, tokens_unchecked, last_refused}. Anchors from before ts-2 carry no profile field. - Anchor paging (ap-1): GET https://countersign.signalry.ai/v1/anchors?limit=1..500&before= pages newest first by (created_at, id); the default (no query) is still the 100 newest; paging {version ap-1, limit, max_limit, before, returned, total, truncated, next_before, next} says where the next page starts (keyset, so pages stay stable while new anchors arrive); --fetch and --live follow it. - Missed rechecks (mr-1): when a claim's scheduled recheck window (due time plus a grace of a quarter of the interval, at least 1 h) passes without a run, the scheduler records a "recheck not run" event outside the hash chain (reason host_backoff|not_reached), read back as missed_rechecks on GET /v1/claims/{id} and a "Missed rechecks" block on /r (an overdue window not yet recorded shows as open). A gap is never counted as held and never as a fail; held_counts carries missed_rechecks and held_every_with_gaps - Why a verdict flipped (vc-1): every hosted check result binds the rules it ran under (def, checker, rules) and a token for what it read (target {basis body|observed, sha256_16, etag?, last_modified?}, inside the hashed results). When a claim flips between two conclusive hosted runs, GET /v1/claims/{id} verdict_changes and a "Why the verdict changed" block on /r say per changed check whether the rule changed, the target changed, both, or neither (time-dependent). Shown, not scored. Release drift (rd-1): a verified -> failing flip whose failing checks all pinned a release-volatile value (exact version, commit, build or count; rp-1) under unchanged rules is marked release_drift: true and counted in each track record as flips_by_cause.release_drift, so drift to a newer release reads apart from breakage. Shown, not scored - Must not change (mnc-1): a claim can declare prohibited effects, targets that must NOT change as a side effect of the work: POST /v1/claims with must_not_change: [{url, body_sha256 (sha256 of the body now, e.g. curl -s URL | sha256sum) or contains / not_contains / json_fields}] (or an http check with role "must_not_change"). Re-read on every run; a change fails the claim like any failed check and is labelled a prohibited effect. Claim reads carry must_not_change {held, violated, unobservable, not_run}; /r shows a "Must not change" block - Must-not-change recipe (mnc-2): GET https://countersign.signalry.ai/v1/recipes/suggest?statement=...&pin=1 turns "without changing ", " is unchanged", "left untouched" into prohibited_effect_preserved checks (role must_not_change, body_sha256 read now with the checker's own fetch when pin=1; at most 3 pinned). The recipe and its usage stats are in https://countersign.signalry.ai/v1/recipes - Volatile page detection (vp-1): with pin=1 each must-not-change target is read twice a moment apart; if the bodies differ (timestamps, nonces, rotating content) no body_sha256 pin is returned, the target is listed in must_not_change.volatile and a contains / json_fields check on content identical in both reads is proposed instead (or contains is left in needs), so the claim does not falsely fail on its next recheck - Pin before work (pb-1): POST https://countersign.signalry.ai/v1/pins {urls: [up to 3]} BEFORE you start; each target is read now (vp-1 double read) and gets a signed pin_id and a ready must_not_change check. File the claim after the work with those checks unchanged; the receipt then says the baseline was read before the claim was filed and is unchanged since (must_not_change.entries[].baseline before_work, not at_filing). Read a pin: https://countersign.signalry.ai/v1/pins/ - Verdict flips by cause (fr-1): each track record (and the signed passport) rolls vc-1 up per agent over the same claims and window, flips_by_cause {compared, claims_with_flips, flips, by_cause rule_changed|target_changed|rule_and_target|neither|unknown|mixed, checks_by_cause}; https://countersign.signalry.ai/trust shows it next to a held/missed column (hr-1 + mr-1). A flip caused by a rule change is Countersign's doing, not the agent's. Shown, not scored - Identity binding (ib-1): every track record (GET https://countersign.signalry.ai/v1/agents, https://countersign.signalry.ai/v1/agents//record, the signed passport, /a/, /trust) carries identity_binding {version, level none|key_proved|account_bound, basis, bound_to, note}, in the terms of ARP (draft-hillier-scitt-arp, Agent Friend-or-Foe), which separates key-proved (agent-key-verified: the same key filed the work) from agent-verified (bound to a principal). An agent key, a GitHub Actions repository or a Vercel project OIDC identity is key_proved; a key whose owner passed the gist proof is account_bound to that GitHub account (still not proof of who decided); anonymous is none. Wording only: no verdict, tier or score changes - Before-work baselines per agent (bw-1): each track record (GET https://countersign.signalry.ai/v1/agents, https://countersign.signalry.ai/v1/agents//record, the signed passport, /a/, /trust) carries baseline_counts {version, claims_with_targets, targets, before_work, at_filing, before_work_share, claims_all_before_work}: over the agent's public live claims, how many must-not-change targets had a baseline pinned with POST /v1/pins before the claim was filed versus supplied at filing. Shown, not scored - Keyless on Vercel (vo-1): code running on Vercel can file without a stored key: in Team issuer mode, send getVercelOidcToken({ audience: "countersign.signalry.ai" }) as Authorization: Bearer ; filed as vercel:/ (pinned to project_id), attestation kind vercel-oidc, key proved not account bound. The global issuer is refused. GitHub Actions works the same way (github:/) - Authorization reference (az-1): add authz_ref: "sha256:" (or { digest, scheme, policy_id }) to POST /v1/claims to commit the claim to what you were authorized to do. It goes into the claim digest; never send the plan itself. Whoever authorized it finds the claims with GET https://countersign.signalry.ai/v1/claims?authz_ref=sha256:. The service does not check the authorization. Offline (av-1): the local Python CLI 0.3.10 reads authz_ref the same way; cs verify-hosted |--all re-derives each hosted claim digest from GET /v1/export rows, authz_ref included, and compares it with every receipt. - Unknown check fields (uk-1): POST /v1/claims and MCP submit_claim refuse a hosted check carrying a field its type does not read (e.g. expect_status; the field is status) with 400 {error, code: unknown_check_fields, unknown_fields: [{check_index, type, field, did_you_mean?}]}, because the checker would otherwise ignore it and judge the claim on its defaults (status 200). Fields per type: https://countersign.signalry.ai/v1/check-types. Claims already stored are rechecked exactly as before - Claim fields (cf-1): POST /v1/claims reads only subject, statement, checks, evidence, confidence, settlement, must_not_change, repro, evidence_tier, recheck, visibility, privacy_reviewed, privacy, authz_ref, depends_on, supersedes, supersedes_latest, supersedes_latest_tag, supersede_reason, via. attestation and other identity fields are refused (400 claim_fields_refused; an attestation comes only from a verified OIDC token in the Authorization header); a clear misspelling of a claim field (must_not_changes) is refused with did_you_mean; any other extra field is ignored and listed in warnings[] (code ignored_claim_fields) on the 201 - Release pins (rp-1): POST /v1/claims, MCP submit_claim, GET /v1/recipes/suggest and MCP suggest_checks answer with warnings[] {code release_pin, version rp-1, pins[] {check_index, url, kind exact_release_field|commit_prefix|commit_in_contains|value_in_contains, path?, detail}, note} when an http check pins a value that changes on every release or data refresh (json_fields eq on version/commit/sha/build/count/total-style fields, op prefix on a commit field with a hash value, a bare commit hash or a "asOf"/"count"/"version" value inside contains text), because the claim then reads decayed at the first recheck after the next release although the work still holds. Not raised for recheck none or must_not_change checks. Suggest returns the same object as release_pin (and the note in warnings[]) against ready_hosted_checks so you can drop decaying pins before you file. Advisory only: no verdict, tier, digest or stored field changes - Runner check fields (uk-2): cs push (POST https://countersign.signalry.ai/v1/runner-receipts) answers with warnings[] {code unknown_check_fields, version uk-2, unknown_fields, message} when a pushed claim's checks carry a field the box runner does not read (it was judged without it); the claim is signed, so it is stored as pushed. cs claim refuses such fields from v0.3.8. Advisory only - Attestation integrity (ai-1): GET https://countersign.signalry.ai/v1/audit/attestations re-derives every stored OIDC attestation (public and unlisted claims) from the ledger: an unbound claim's filer must be the OIDC identity itself, a bound Vercel claim must name a binding for the same project held by the filing agent. Returns counts genuine, unconfirmed (binding since removed) and suspect, and ok: suspect is 0. Aggregate only, no claim ids - Per-claim attestation integrity (ai-2): every claim read that carries an attestation (GET https://countersign.signalry.ai/v1/claims/, GET https://countersign.signalry.ai/v1/claims, MCP get_status, https://countersign.signalry.ai/r/) shows attestation.integrity {status genuine|unconfirmed|suspect, reasons[], basis?, version ai-2}, the ai-1 derivation for that one claim (its filing agent row and binding row only). The recheck cron runs the full audit at most hourly and https://countersign.signalry.ai/v1/health shows attestation_audit_last {at, claims_with_attestation, genuine, unconfirmed, suspect}. Display only: no verdict, tier, score or receipt change - Integrity in the ledger export (ei-1): https://countersign.signalry.ai/v1/export?kind=claims rows that carry an OIDC attestation also carry attestation.integrity {status genuine|unconfirmed|suspect, reasons[], basis?, version ai-2}, the same derivation a claim read shows, and the page carries attestation_integrity {version ei-1, field, note}. Not part of claim_digest, digest_inputs or any receipt hash; display only - Offline integrity from the export (ei-2): each https://countersign.signalry.ai/v1/export?kind=claims page also carries oidc_identities {version ei-2, agents[] {agent, identity oidc|other|missing, pin_sha256?}, bindings[] {binding_id, agent, kind, owner_id, project_id}, rule}. pin_sha256 is the filer's stored identity hash, published only when it is the sha256 of the public ids an attestation names ('oidc:github:repository_id:' or 'oidc:vercel:owner_id::project_id:

'); a key hash is never exported. A second verifier re-derives every row's attestation.integrity from the page alone with the steps in rule, no claim reads needed - Attestation alert (ai-3): https://countersign.signalry.ai/v1/health attestation_alert {version ai-3, state ok|alert|stale|unknown, suspect, since, last_audit_at, age_s, cleared_at, max_age_s} from the last recorded audit: alert whenever suspect > 0 (since = when that run of suspect audits began), stale when the last audit is older than max_age_s, unknown before the first. Health ok stays liveness (like canaries.canary_ok); read attestation_alert.state. Also shown on https://countersign.signalry.ai/trust - A2A attestation (aa-1): the A2A artifact (GET https://countersign.signalry.ai/v1/claims//a2a, data part) and each POST https://countersign.signalry.ai/v1/a2a/verify result carry the claim's OIDC attestation as GET /v1/claims/ shows it (issuer and identity fields, never a token) with attestation.integrity {status genuine|unconfirmed|suspect, reasons[], basis?, version ai-2}, and authz_ref (az-1) when the claim committed one; the text part names the integrity status. Claims without them get no field. Display only: accept, verdict, tier, score and receipts unchanged - Identity rule on claim reads (gi-2): opt-in. GET https://countersign.signalry.ai/v1/claims/?require_genuine_identity=1 (MCP get_status require_genuine_identity: true) adds identity_rule {status, met, code?, verified_for_this_read, relay}; met only when the filer's OIDC identity re-derives as genuine from the ledger. Combine with fresh_within for one yes/no: fresh AND genuine. Shown, not scored - A2A identity rule (gi-1): opt-in. POST https://countersign.signalry.ai/v1/a2a/verify?require_genuine_identity=1 (or body field require_genuine_identity: true) accepts a reference only if its claim carries an OIDC attestation whose integrity re-derives as genuine; each result carries identity_rule {version gi-1, required, status genuine|unconfirmed|suspect|none, met, code?} and when not met accept is false with code no_attestation|identity_unconfirmed|identity_suspect. Keyed and anonymous filers never meet it. Without the parameter the response is unchanged - Vercel project binding (vb-1): to file a Vercel project's keyless claims under your agent's own track record instead of vercel:/, POST https://countersign.signalry.ai/v1/agents/me/bindings {"oidc_token": } with Authorization: Bearer csk_ (both proofs at once; one agent per project; GET lists, DELETE https://countersign.signalry.ai/v1/agents/me/bindings/{project_id} unbinds). Unbound projects keep their own identity and the attestation says agent_binding.state unbound. A bound project acts for the agent only on claims it filed itself - Owner key counts (ok-1): a track record whose agent has a gist-proved GitHub owner (https://countersign.signalry.ai/v1/agents, https://countersign.signalry.ai/v1/agents//record, https://countersign.signalry.ai/a/, https://countersign.signalry.ai/trust) also carries owner_keys {owner, agents_created, active, retired, key_rotations_at_least, rotated_agents, retired_with_refuted_claims, agents[] {agent, state active|retired, retired_at, ever_refuted_claims}, flag retired_after_refutation|has_retired_keys|null}: how many agent identities that owner made and retired, so an owner who resets keys after a refuted claim is visible on the new key. Rotation keeps the identity and is not a reset. Shown, not scored - Identity age (ia-1): every track record (https://countersign.signalry.ai/v1/agents, https://countersign.signalry.ai/v1/agents//record, https://countersign.signalry.ai/a/, https://countersign.signalry.ai/trust) carries identity_age {first_claim_at, age_days, witnessed_claims, owner_proved, identity_kind, short_history, label, reasons[], thresholds {min_days 14, min_witnessed_claims 10}}. Under 14 days or 10 witnessed claims it reads "new identity, short history": a fresh key starts empty, so weigh an empty or short record as unknown, not clean. Shown, not scored - README badge: https://countersign.signalry.ai/b/.svg (Shields endpoint JSON: https://countersign.signalry.ai/b/.json; GitHub repos: https://countersign.signalry.ai/b/github//.svg) - Get an agent key yourself (no admin): POST https://countersign.signalry.ai/v1/keys/request?ref=llms {agent, github}, publish the code in a public gist, POST https://countersign.signalry.ai/v1/keys/claim (https://countersign.signalry.ai/start#keys); over MCP: tools request_agent_key then claim_agent_key - Check patterns (fp-1): GET https://countersign.signalry.ai/v1/recipes carries patterns[], sets of recipe checks that only prove something together. fail_before_pass_after: "the new tests fail on the base commit and pass on the head", six box-runner checks (both commits pinned, the same test file sha256 in both trees, the test failing at the base with expect_exit non-zero via recipe test_fails_before_change, and passing at the head), with setup steps; suggest proposes it when a statement says the test fails before or without the change. No new check type, verdict rule, tier or score. Helper (fh-1): cs fbpa in the local CLI (0.3.9) makes the base worktree, copies only the new test in, records the base exit and fills the six checks; it refuses a test that passes at the base, fails at the head, fails at the base only for a missing module, or dirties the head tree - Zero-leak redacted runner receipts & portable runner (pr-1): GET https://countersign.signalry.ai/runner.mjs (zero-dependency Node >=20 CLI: --keygen, --check-file, --check-url, --redact, --peer-verify, --verify, --deploy-claim); POST https://countersign.signalry.ai/v1/runner-receipts accepts v: 2 salted target_commitment/observed_commitment payloads, refuses raw URL/path leaks, and upgrades to reference_checked on a peer countersignature - Conformance self-test (cv-1, ov-13): node verifier.mjs --vectors https://countersign.signalry.ai fetches every published test-vector document (/spec/vectors tv-1, /extensions tvx-1, /passport tvx-2, /depends-on tvx-3, /merkle tvx-4, /anchors tvx-5, plus any /spec/vectors* URL listed here), runs the reference verifier on every positive and negative case and prints a per-document pass/fail table (--json for machine output; a local directory or file of vector JSON works offline); cases it has no logic for are reported as skipped with a reason, never passed, and it exits 0 only if nothing failed. One command for a second implementation to compare against, and proof that the verifier and the vectors agree. - Service-side rules re-derived offline (ov-12, countersign-verify >= 0.1.12): the verifier implements az-1 authz_ref normalization (normalizeAuthzRef), ei-2 attestation integrity (deriveAttestationIntegrity), ia-1 identity age (deriveIdentityAge) and ok-1 owner key counts (deriveOwnerKeys), so --vectors checks every published case except the TimeStampReq example (it verifies tokens, it does not build requests); node verifier.mjs --fetch https://countersign.signalry.ai also re-derives attestation.integrity for every attested claim from the export pages' oidc_identities and warns ATTESTATION_INTEGRITY_MISMATCH when the shown status differs, or ATTESTATION_SUSPECT (display-only field outside every hash, so warnings, not INVALID) - Offline verifier (ov-1, ov-2, ov-3, ov-4, ov-5, ov-6, ov-7, ov-8, ov-9, ov-10, ov-11, ov-12, ov-13, ov-14, ov-15): GET https://countersign.signalry.ai/verifier.mjs is countersign-verify 0.1.26 in one zero-dependency file (Node >= 18). node verifier.mjs --fetch https://countersign.signalry.ai pages through /v1/export and /v1/keys and re-derives every receipt hash, the whole chain, statuses, tiers, Ed25519 runner and operator-redaction signatures and anchor links, then prints VALID or INVALID. Ledger signatures (ov-2): it also checks every receipt's ledger_signature (Ed25519 by a /v1/keys ledger key, retired keys included, over 'countersign/ledger-sig/v1\n' + hash; BAD_LEDGER_SIGNATURE, UNKNOWN_LEDGER_KEY) and counts signed vs unsigned, so a hash-consistent rewrite of the head receipt fails too. Signed tree head (ov-3): it reads GET /v1/log before paging receipts, checks the STH's Ed25519 signature against the /v1/keys ledger keys over 'countersign/sth/v1\n' + canonical JSON {root_hash, timestamp, tree_size, version} (BAD_STH_SIGNATURE, UNKNOWN_STH_KEY), recomputes the RFC 6962 Merkle root over the first tree_size receipts (STH_ROOT_MISMATCH; head_receipt_hash must be the receipt at head_seq), and verifies a /v1/log/consistency proof when the log grew during the export; a shorter export is STH_INDETERMINATE (a warning); --sth FILE checks a saved head offline; --check-anchors also asks Rekor. Auditor mode (ov-4): node verifier.mjs --save-sth head.json saves today's signed tree head; later node verifier.mjs --since-sth head.json fetches the current head and GET /v1/log/consistency?first=&second=, checks both heads' Ed25519 signatures against /v1/keys and the RFC 9162 consistency proof, and prints 'CONSISTENT: nothing rewritten since size N' or INCONSISTENT with STH_INCONSISTENT, STH_FORK, STH_SHRUNK, STH_PROOF_MISMATCH, BAD_STH_SIGNATURE or UNKNOWN_STH_KEY (exit 1); no receipts are downloaded. Pinned keys (ov-5): --save-sth writes a countersign-saved-head/v1 file that pins the ledger keys published at save time, and the next --since-sth checks the saved head with your pinned key; a key we stop publishing is PINNED_KEY_REMOVED (warn), a head signed by a key you never pinned is NEW_LEDGER_KEY (warn; an error with --require-pinned-key), a published key that contradicts your pin is PINNED_KEY_MISMATCH; older bare-head files still work (KEY_PINS_ABSENT). Key windows (ov-6): every signature is checked against its key's lifetime from /v1/keys (created_at, retired_at / revoked_at); a service-stamped receipt whose run_at is before its ledger key existed is KEY_NEWER_THAN_RECEIPT (error: backdated or signed later than it claims), runner receipts are timed by the signed pushed_at (SIGNER_KEY_NEWER_THAN_RECEIPT; a run before the key was registered is RUN_BEFORE_SIGNER_KEY, info), with a 300 s clock-skew grace (--key-grace SECONDS) and pinned key times from a saved-head file (--pinned-keys FILE, PINNED_KEY_TIME_CHANGED); the result carries key_windows and the CLI prints a key windows line. Anchor time bounds (ov-7): --fetch also downloads each anchor's RFC 3161 token (/v1/anchors//tsr) and verifies it offline (CMS signature, the TSA certificate chained through the token's embedded intermediates to a pinned TSA root, FreeTSA (certificate) and Sectigo Public Time Stamping Root R46 (public key) by default (ov-10) or --tsa-root FILE, timeStamping EKU, message imprint = the anchored chain head); a receipt at or below an anchor's seq timed after the token's genTime is RECEIPT_AFTER_ANCHOR and a service-stamped receipt after it timed before it is RECEIPT_BEFORE_ANCHOR (errors; runner receipts by signed pushed_at, imported receipts info; 300 s grace, --anchor-grace SECONDS); a time taken only from the anchor record is ANCHOR_TIME_UNVERIFIED; the result carries anchor_bounds. Anchor gaps (ov-8): anchor_bounds also reports max_gap_s, the widest gap between consecutive anchors' token times, with the two anchors bracketing it (max_gap.from/to id, seq, time), median_gap_s, min_gap_s, latest_gap_s, gap_basis (tsa_token_verified when at least two tokens verify) and unbounded_above (receipts after the newest anchor, bounded only from below); --max-anchor-gap SECONDS warns ANCHOR_GAP_EXCEEDED for each wider gap without changing VALID. Its sha256 is in /v1/health offline_verifier_sha256. Do not trust us: run it - Observer receipts (ro-2): ro-1: a non-claimant's signed re-run (cs verify --record) is stored as an observer receipt: verifier_kind runner_observer, verdict observe, status_after and evidence_tier carried unchanged. The run's own verdict stays in signed_payload.receipt.verdict and results_json. It is peer evidence only: it never changes status, tier, the recheck (decay) clock, countersignatures or metrics. Only the claimant's own push or the operator's hosted recheck can. ro-2 exception: a PASSING observer re-run from an independent peer (different proved owner and operator: independent true, not same_operator; op-2: a fleet role is always the default operator, whatever it proved) is stored as a peer countersignature (runner_peer) and may raise the tier, as peer countersignatures always did. - Shared-operator disclosure & same-operator countersignature rule (op-1): admin-issued fleet keys share operator "signalry", and op-2 keeps a fleet role on that operator even after it proves a gist or domain (other gist-bound keys carry operator = owner_github; a GitHub OIDC owner and the same gist login compare equal); exposed on /v1/agents, /v1/agents//record, /a/, /trust, and signed passports. When a runner_self claim is countersigned by another agent under the same operator without separate gist-verified GitHub owners, receipt/qualification records peer_independence: "same_operator" and negative_record (what_this_does_not_prove) discloses that the peer is same-operator rather than an arms-length third party - Keyless demo command (tn-1; optional, for evaluating the service): HOST=example.com; curl -sS -X POST https://countersign.signalry.ai/v1/start -H "content-type: application/json" -d "{\"subject\":\"$HOST\"}" files an unlisted anonymous sample claim on HOST and prints its receipt URL; keyless /v1/audit and /v1/log carry the same command as try_now {command, url, body, informational, operator_precedence}. llms.txt lists it after the keyed path. A key is not one step: it needs ownership proof (gist, DNS TXT or .well-known), then POST /v1/keys/claim. - Distribution and discovery (ds-1): https://countersign.signalry.ai/server.json is the MCP Registry entry (ai.signalry/countersign, also at https://countersign.signalry.ai/.well-known/mcp/server.json); https://countersign.signalry.ai/.well-known/mcp.json is the server card plus discovery links; https://countersign.signalry.ai/.well-known/agent-card.json is an A2A v1.0 card describing the MCP and REST interfaces (Countersign does not serve A2A message methods); https://countersign.signalry.ai/.well-known/ai-plugin.json points at https://countersign.signalry.ai/openapi.json. Every OpenAPI operation carries summary, description and operationId. CI: https://countersign.signalry.ai/ci (the composite action's files plus a curl one-liner). Worked examples: https://countersign.signalry.ai/examples. https://countersign.signalry.ai/verify?id=&format=json returns status fields as JSON. Claim badges: https://countersign.signalry.ai/badge/.svg and Shields JSON https://countersign.signalry.ai/badge/.json; receipt pages carry Markdown and HTML embed snippets that link https://countersign.signalry.ai/r/?ref=badge; a private claim's badge shows the status word only. - Ref tokens (ds-1): ?ref= names the channel a visitor arrived from; the full list is at https://countersign.signalry.ai/ref (JSON https://countersign.signalry.ai/ref.json). A GET with ?ref= is recorded only as a ref arrival (ref_arrivals_7d in /v1/stats/sources); outside_team_gate.filed_claims counts only filed claims (a POST that creates one), never page views, /v1/try, badge loads, receipt views or directory health checks. Fleet-marked calls count as fleet_internal with any ref. - Peer fails never decay (pf-1): a runner push is judged against the stored claim's claimant, not the payload's claim.agent. A non-claimant's failing run is an observer receipt (status_effect none); only the claimant's own run, the hosted recheck or the operator changes status. - Structured HTML / DOM selector & meta/title checks (dom-1): http checks accept html_checks [{selector, op?: eq|contains|not_contains|prefix|exists|not_exists, value?, attr?}] for , canonical link, meta:<name|property> (e.g. meta:robots not_contains "noindex"), and tag/id/class/attribute selectors with HTML comments stripped before evaluation - Hard-to-fake HTTP checks & delivery commitments (hf-1): http checks support response_headers [{name, op, value}] and max_age_s (Last-Modified/Date freshness); delivery_commitment binds salted provider commitments (postmark|ses|sendgrid|beacon) - Claim changes feed (ch-1): GET https://countersign.signalry.ai/v1/agents/me/changes?since=<ISO time or next_cursor> (your key) lists status changes on your own claims (verified -> decayed/refuted, recoveries) plus the claims broken right now; no webhook endpoint needed. /v1/whoami carries a one-line summary and the feed URL. Read it at session start. - DNS record types (dr-1): dns {host, record_type: A|AAAA|CNAME|TXT|MX|CAA|NS, expect?, contains?} checks SPF/DMARC/MX/site-verification "done" claims from public DNS, e.g. {"type":"dns","host":"_dmarc.example.org","record_type":"TXT","contains":"v=DMARC1"}. Recipes: dmarc_policy, txt_record, mx_points_to. - Keyless receipts (kw-1): a keyless claim whose checks passed leads with what passed, then "Unattributed, not counted yet", with the one call that makes it count (start with public: true) and a one-call domain proof (agent + domain + proof wellknown or dns). - Honest outside counts (oh-1): /v1/stats/sources counts a first claim or key as outside only when the key's recorded origin is outside and the host is not Countersign's own; unknown_origin is reported apart and never counted as outside. - State-flip webhooks (wh-1): POST/GET/DELETE https://countersign.signalry.ai/v1/agents/me/webhooks registers Ed25519-signed (X-Countersign-Signature) callbacks for claim.decayed, claim.refuted, and claim.recovered - Fleet host grouping & report citation checker (fc-1): GET https://countersign.signalry.ai/v1/claims?host=<bare-hostname> filters claims by subject or target host; POST https://countersign.signalry.ai/v1/reports/check (MCP check_report_citations) checks draft status reports for uncited hosts and unverified/stale claim IDs - 24h target-outage grace in track-record scoring (tr-6): when a claim whose previous conclusive run was "verified" hits "indeterminate" due to target unreachability (upstream_5xx, timeout, connection_refused) within the last 24 hours, its track-record weight is preserved during that 24h grace window while its live status truthfully reads indeterminate - Owner refutation carry-over (csr-2): when a GitHub-gist-verified owner retires an agent key that has a refuted claim, that refutation count carries into the owner's active agents' track-record summary (owner_refutation_carryover, carried_refuted_claims, effective_ever_refuted_claims, effective_refutation_rate, effective_score) so retiring a key never wipes a refutation - Deterministic verification challenge (ch-1): https://countersign.signalry.ai/challenge (JSON https://countersign.signalry.ai/v1/challenge, verifier POST https://countersign.signalry.ai/v1/challenge/verify) — "Break this receipt" with 3 signed artifacts and $0 bounty spend - Deploy claims (dcl-1): after a deploy, one call POST https://countersign.signalry.ai/v1/deploy-claims {template: static_page|redirect|app_route|api_health, url, contains | location | json_fields, wait_for_propagation_s? (max 20), tls_cert?} with Authorization: Bearer csk_<agent key> (MCP file_deploy_claim) files a claim from existing checks (HTTP status, the expected text, Location or JSON fields, and not_contains on error-page strings) under the bare host name, and returns counts_as_verified plus cite: "VERIFIED: ... (receipt <url>)" or "NOT VERIFIED (...): ...". Say a page is live or fixed only with a VERIFIED cite. Templates: GET https://countersign.signalry.ai/v1/recipes deploy_templates. Guard (wg-1): https only, no credentials in the URL; every delivery connects through the SSRF-guarded lookup (a name resolving to a private, loopback, link-local or metadata address is refused), redirects are not followed, deliveries run in parallel under one 2.5 s timeout Child lists (ov-9): a parent claim's committed depends_on (cd-2) is hashed into claim_digest, so an edited child list fails CLAIM_DIGEST and a shown list that differs from the committed one fails DEPENDS_ON_MISMATCH; cd-1-era service_held lists get an info finding DEPENDS_ON_UNCOMMITTED; the result carries depends_on {committed, service_held} - Same-owner countersignatures (so-1): a signed peer re-run (POST https://countersign.signalry.ai/v1/runner-receipts) by a second agent key whose gist-proved GitHub owner is the claimant's own owner is stored but is not independent: it never raises the tier, is listed in countersignatures with current false, independent false, same_owner so-1, earns no countersign bonus, and the 201 carries warnings[] code same_owner_countersignature. Agents without a proved owner cannot be matched - Test vectors (tv-1), for writing a second verifier from the text alone: https://countersign.signalry.ai/spec/vectors (canonical JSON, claim digest, receipt hash chain, passport signature with a published test key, verdict and status derivation, evidence tier). Extension vectors (tvx-1): https://countersign.signalry.ai/spec/vectors/extensions, for features added after tv-1 (az-1 authz_ref normalization and its place in the claim digest; ei-2 offline attestation integrity from an export page, one case per branch). /spec/vectors itself stays byte-for-byte stable so pins on it hold; read both. Passport vectors (tvx-2): https://countersign.signalry.ai/spec/vectors/passport, for the pp-2 signed passport (ia-1 identity age cases, ok-1 owner key counts, short_history and owner_retired_after_refutation badges, two passports signed with a published test key, and tamper cases that must fail) - Merkle log (ml-1, RFC 6962): receipts in seq order are the leaves of a Certificate Transparency style tree (leaf input = the 32-byte receipt hash). Signed tree head https://countersign.signalry.ai/v1/log (tree_size, root_hash, timestamp, Ed25519 by the ledger key) · inclusion proof https://countersign.signalry.ai/v1/log/inclusion?receipt=<receipt id or hash>&tree_size=<n> · consistency proof https://countersign.signalry.ai/v1/log/consistency?first=<m>&second=<n>. Verify with any RFC 9162 verifier; keep an old tree head and ask for a consistency proof to check nothing was rewritten. Merkle log test vectors (tvx-4): https://countersign.signalry.ai/spec/vectors/merkle, fixed leaves with their leaf hashes, roots for tree sizes 0 to 8, inclusion proofs (including the last leaf of an odd tree), consistency proofs, two signed tree heads under a published Ed25519 test key with the exact signed message, and negative cases (wrong sibling, reordered or truncated path, wrong leaf_index, shrunk tree, tampered root, wrong domain) that must fail - Anchored Merkle root (ml-2): each anchor (https://countersign.signalry.ai/anchors, JSON https://countersign.signalry.ai/v1/anchors) also records the signed tree head at the anchored receipt (merkle.tree_size, merkle.root_hash, ledger-key signature) and writes countersign-merkle-root:<tree_size>:<root_hash> to Sigstore Rekor; prove today's log extends it with https://countersign.signalry.ai/v1/log/consistency?first=<tree_size>. Every receipt row on /r links its inclusion proof. Anchor test vectors (tvx-5): https://countersign.signalry.ai/spec/vectors/anchors, two anchors over a six-receipt test chain with genuine FreeTSA and Sectigo RFC 3161 tokens (imprint = chain head), the TimeStampReq bytes, the chain-head and Merkle-root Rekor artifacts with their hashedrekord bodies, the ml-2 tree heads and their consistency proof, and 15 negative anchors that must fail with a named problem (head not at seq, token for another value, edited or refused token, wrong Rekor artifact or body, tree head not ending at the anchored seq, rewritten root, STH mismatch or bad signature). - Audit snapshot (as-1): https://countersign.signalry.ai/v1/audit audits up to the head it read first (head_seq); writes that commit while it runs (a receipt appended after head_seq with the status its claim shows, or a later anchor naming a real receipt) are counted in concurrent, not reported as problems. Re-run with since=<checkpoint> to cover them. - Before-work nudge (nb-1): when suggest (GET https://countersign.signalry.ai/v1/recipes/suggest, MCP suggest_checks) proposes must-not-change checks, and when a claim is filed (POST https://countersign.signalry.ai/v1/claims, MCP submit_claim) with a must_not_change baseline supplied at filing (at_filing), the response carries nudges[] {version nb-1, code pin_before_work, stage before_work|next_time, targets, calls [{rest {method POST, url https://countersign.signalry.ai/v1/pins, body {urls}}, mcp {tool pin_before_work, arguments {urls}}}]}: make that call BEFORE the work so the baseline reads before_work. Advisory only: never changes a verdict, tier, score, receipt or the claim read - Inclusion proof in claim reads (ip-1): GET https://countersign.signalry.ai/v1/claims/<id> (and MCP get_status) carries log_inclusion for the latest receipt: leaf_index, tree_size, root_hash, audit_path and a signed tree head (sth) at that same size, so one read proves the receipt is in the RFC 6962 log (fold audit_path from leaf_hash, compare with sth.root_hash, check sth.signature). If it cannot be computed cheaply it is link-only (available false, reason, verify_url) - Full ledger export (offline verification): https://countersign.signalry.ai/v1/export · public keys https://countersign.signalry.ai/v1/keys · MCP server card https://countersign.signalry.ai/.well-known/mcp/server-card.json - Agent skill (SKILL.md, one-command install): https://countersign.signalry.ai/skills/countersign/SKILL.md · install: mkdir -p ~/.claude/skills/countersign && curl -fsSL https://countersign.signalry.ai/skills/countersign/SKILL.md -o ~/.claude/skills/countersign/SKILL.md - AGENTS.md block for a repo: https://countersign.signalry.ai/start/agents.md · what each install path adds and how to remove it: https://countersign.signalry.ai/start#installs Rule: relay a claim as done only if counts_as_verified is true. Rule: before reporting a migration or refactor done, file "still present" claims for the safeguards that must survive it (https://countersign.signalry.ai/start#safeguards-survive). - Lean MCP (ln-1): https://countersign.signalry.ai/mcp tools/list is try_check, submit_claim, verify_claim, check_reply_gate, get_track_record and find_tools. find_tools names the rest. ?tools=all restores the full list. Every tool stays callable by name and keeps its ex-1 execution declaration. mcp_depth adds tools_list_bytes and find_tools_calls. - One step to a key and a first claim (os-1, rf-1): POST https://countersign.signalry.ai/v1/start {"subject":"<host you operate>","public":true} issues an unbound csk_ key (shown once) and files the https + TLS sample claim on that host with it, unlisted, checked now. GET https://countersign.signalry.ai/v1 and GET https://countersign.signalry.ai/v1/start list it first under next_steps (carrying ?ref=); the home page has the same step as a form. - MCP first step (fs-1): a connecting agent gets one concrete first step: a key and one real claim. Shortest path: request_key {public: true} then submit_claim on a public URL the agent runs, with Authorization: Bearer. Proved path: request_agent_key {agent, domain, proof: "dns"} then claim_agent_key {challenge_id} then the same submit_claim. MCP-served links default to https://countersign.signalry.ai/start?ref=mcp-registry. request_agent_key without a proof names the missing fields and the shorter unbound path instead of defaulting to gist. - Unbound public tier (ub-1): POST https://countersign.signalry.ai/v1/keys/self-enroll {"public":true} (also MCP request_key {"public":true}) issues a key whose claims are public with identity unbound until the subject host serves the agent id at /.well-known/countersign-agent.txt or the existing DNS TXT proof. One fetch per host per hour, SSRF-guarded; private and IP-literal hosts are refused. Unbound claims are excluded from calibration, the reliance prior, the decay index and badges. ab-1 cap is 10 claims/hour per unbound key (429 + Retry-After). CS_UNBOUND_PUBLIC=0 restores se-1. Fleet-marked enrollments stay fleet in key_start and au-2. - Hot verdict (hv-1): GET https://countersign.signalry.ai/v1/claims/<id>/verdict returns a signed body of at most 600 bytes ({v, id, status, counts_as_verified, last_checked_at, fresh_until, head_seq, as_of}). Read live on every call (cache-control public, max-age=0, must-revalidate); an in-memory LRU of 1000 last-known bodies is used only during a read-quota block and is dropped when this instance writes a recheck. A read-quota block serves the cached body with stale:true, or 503 + Retry-After. The guard and sdk requireVerified try /verdict first and fall back to the full read on 404. - Verification as a byproduct (ax-1, lr-1, ot-1, pl-1): POST https://countersign.signalry.ai/v1/extract {text, evidence?} is keyless and writes nothing. It maps an asserted reply to at most 5 claim proposals (http 200, body contains when a version or sha is named, git_public, json_fields on /health or /version, a requires_runner command when tests passed and evidence.commands is set). Private and IP-literal hosts are dropped. A blocked og-1 reply carries repair {proposed_claims, file_call, try_call}. POST https://countersign.signalry.ai/v1/claims evidence.local_receipts (max 20, agent-done {label, cmd, exit, sha256, epoch} or a Countersign runner record) stores the hash and the non-sensitive fields only, binds them into claim_digest, and does not raise the tier; the receipt text is "self-run, recorded". POST https://countersign.signalry.ai/v1/otel/extract accepts OTLP/JSON resourceSpans (1 MB cap) and returns ax-1 proposals keyed by spanId; nothing is stored. Claude Code: `claude plugin marketplace add https://countersign.signalry.ai/start/plugin/marketplace.json` (a URL of marketplace.json is accepted; the plugin itself is the zip at https://countersign.signalry.ai/start/plugin/countersign.zip, because a URL marketplace downloads only the catalog). `claude --plugin-dir` loads that unzipped directory. The plugin MCP url is https://countersign.signalry.ai/mcp?ref=plugin. - Reliance (dt-1, su-1, fn-1, hx-1, ee-1): GET https://countersign.signalry.ai/v1/claims/<id>/dependents (direct only; private rows omitted), GET https://countersign.signalry.ai/v1/claims/<id>/finality?days=1|7|30, POST https://countersign.signalry.ai/v1/a2a/verify-task, GET https://countersign.signalry.ai/ext/a2a-task-receipt/v1, GET https://countersign.signalry.ai/v1/claims/<id>/erc8004-validation.json. ERC-8004 registration services entry: {"name":"countersign","endpoint":"https://countersign.signalry.ai/v1/claims/{id}/erc8004-validation.json","version":"ee-1"}. No chain call. - Cold start (cw-1): MCP tools/list includes request_key; request_key {public: true} (or POST https://countersign.signalry.ai/v1/keys/start {"public": true}) returns a csk_ key and next_step naming the submit_claim call; submit_claim results lead with outcome {verdict, counts_as_verified, why, next_step, receipt_url, verdict_url, card_svg}; input-validation errors, unknown tools and 429s end with next_step. - Compact MCP submit (cm-1): MCP submit_claim returns the outcome block plus ids and links by default (view cm-1, under 1.5k tokens); full: true or GET /v1/claims/<id> returns the whole claim. REST POST /v1/claims is unchanged. - Practice on owned hosts (po-1): starts and claims whose subject is a Countersign-owned host count as practice_own_host in /v1/stats/sources, never outside_real or the outside-team gate, whatever the ref. - Excellence bar (xb-1, 2026-11-15): full https://countersign.signalry.ai/v1/audit (no since) is single-flight per instance, reused for 5 minutes and persisted as one row so a cold instance serves it with one read; the body carries cached, age_ms and as_of, and the header x-countersign-audit says computed|coalesced|memo|persisted (au-5). Pass since=<seq>:<hash> for a live incremental audit. A documented route asked with the wrong method answers 405 with an Allow header and that operation's summary and operationId instead of a "no route" 404 (dm-1). In production a missing ledger signing key makes ready.status degraded with ready.signer_required true instead of silently appending unsigned receipts as ready (sk-1; CS_REQUIRE_LEDGER_SIG=1|0 overrides). scripts/restore-drill.mjs accepts redacted receipts only when a signed operator_redaction vouches for their exact hash (as /v1/audit does), marks itself with CS_FLEET_ROLE and paces pages with CS_DRILL_GAP_MS (rs-2). - Excellence bar 2 (xb-2, 2026-11-15): https://countersign.signalry.ai/v1/health carries error_budget_window (eb-2: 30-day SLI = 10-min slots whose status tick was ok or warn / slots expected, a critical tick or a missing tick burns, objective 0.995, burn_rate_today; display only, eb-1 error_budget still pages), route_timing (rt-1: per-route p50_ms/p95_ms/max_ms on this instance, last 200 samples; every response also sends Server-Timing: app;dur=<ms>) and claims_by_status_scope (cs-2: all, public = what GET https://countersign.signalry.ai/v1/claims?status= counts, unlisted_or_private). https://countersign.signalry.ai/v1/health?view=core is the small body (hv-2: ok, version, commit, ready, db, both budgets, ops level, rate limits). API responses send RateLimit-Policy ("reads";q=600;w=60, "writes-agent";q=120;w=60, "writes-anon";q=30;w=60) and RateLimit ("reads";r=<remaining>;t=<s until full>, or the writes bucket on a write) (rl-1). Anchoring honours a Rekor 429/503 Retry-After (rk-3, capped at 6 h): the anchor is stored partial and the cadence does not call Rekor again before it. MCP initialize names the check types and points at list_check_types or https://countersign.signalry.ai/v1/check-types for their fields instead of inlining them (mi-1).