Server definition

Hash: sha256:65347699a32907fcfdfe1a25148bb750195290813cde494997da902f8feee0d6
What it is: What a remote MCP server returned when asked what it offers: 9 tools

The blob, as servednamed by its sha256

{
  "instructions": "JIDEC / NENRIN is a Bitcoin-anchored public verification ledger. Every tool here is read-only and requires no trust in HORIZON SHIELD: you fetch the bytes, you recompute the hash, you check the timestamp. For what an agent or MCP endpoint has done over time, call nenrin_resume (or nenrin_trust_signal for the compact form); for one submitted walk, nenrin_witness; for the chain itself, nenrin_ledger_head and nenrin_ledger_entry. To cite and recompute a record, jidec_cite then jidec_how_to_verify. A NENRIN history is not a score: a signature proves who asserted, not that it is true, and absence is not a negative finding. Offline verifier for NENRIN bundles: npx nenrin-verify.",
  "tools": [
    {
      "description": "Resolve and INDEPENDENTLY verify any JIDEC citation. Accepts 'jidec:path:<sha>', 'jidec:entry:<n>', a bare 64-hex id, or a ledger URL. Fetches the record's exact bytes, recomputes SHA-256 locally, and confirms it equals the cited id. Returns integrity, Bitcoin anchoring status, the parsed record (verification path, claim, or v0 spec entry), and an explicit statement of what the proof does and does not cover. No trust in HORIZON SHIELD is required to accept the result.",
      "inputSchema": {
        "properties": {
          "citation": {
            "description": "jidec:path:<sha> | jidec:entry:<n> | 64-hex | ledger URL",
            "type": "string"
          }
        },
        "required": [
          "citation"
        ],
        "type": "object"
      },
      "name": "jidec_cite",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "bitcoin": {
            "properties": {
              "status": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "citation": {
            "type": "string"
          },
          "integrity": {
            "description": "The whole point: claimed vs recomputed. match:false is an integrity FAILURE, which is a finding, not an error.",
            "properties": {
              "claimed_sha256": {
                "type": "string"
              },
              "match": {
                "type": "boolean"
              },
              "recomputed_sha256": {
                "type": "string"
              }
            },
            "required": [
              "match"
            ],
            "type": "object"
          },
          "limits": {
            "type": "string"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "record_kind": {
            "type": "string"
          },
          "resolved_entry": {
            "type": [
              "number",
              "string",
              "null"
            ]
          },
          "trust_note": {
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "integrity"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return the step-by-step recipe for verifying a JIDEC record WITHOUT trusting HORIZON SHIELD: which bytes to fetch, which hashes to recompute, which OpenTimestamps proof to check, which algorithm commit to check out, and what must match. Use this when you want to confirm the result yourself rather than repeat an assertion.",
      "inputSchema": {
        "properties": {
          "citation": {
            "description": "jidec:path:<sha> | jidec:entry:<n> | 64-hex | ledger URL",
            "type": "string"
          }
        },
        "required": [
          "citation"
        ],
        "type": "object"
      },
      "name": "jidec_how_to_verify",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "citation": {
            "type": "string"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "path_id": {
            "type": "string"
          },
          "recipe": {
            "type": [
              "object",
              "string"
            ]
          },
          "resolved_entry": {
            "type": [
              "number",
              "string",
              "null"
            ]
          }
        },
        "required": [
          "lookup"
        ],
        "type": "object"
      }
    },
    {
      "description": "List the anchored JIDEC verification paths (most recent first), with purpose, verdict and Bitcoin anchoring status.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "jidec_list_paths",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "count": {
            "description": "How many anchored paths the ledger returned. 0 means the ledger answered and holds none. It never means the ledger could not be read, that is an error.",
            "type": "number"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "paths": {
            "items": {
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "lookup",
          "count"
        ],
        "type": "object"
      }
    },
    {
      "description": "Re-observe an anchored JIDEC verification path against the live system right now and report drift. Returns MATCH (the live system still matches what was anchored) or DRIFT (it changed), node by node. Nodes that cannot be re-observed server-side are reported as deferred, never counted as drift.",
      "inputSchema": {
        "properties": {
          "citation": {
            "description": "jidec:path:<sha> | jidec:entry:<n> | ledger URL",
            "type": "string"
          }
        },
        "required": [
          "citation"
        ],
        "type": "object"
      },
      "name": "jidec_replay",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "verdict": {
            "description": "MATCH or DRIFT. Nodes that could not be re-observed are deferred, never counted as drift.",
            "type": "string"
          }
        },
        "required": [
          "lookup"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return ledger entry n as the ledger serves it: claim_sha256, the canonical record bytes, work description, OpenTimestamps status and Bitcoin block when anchored. Pair with jidec_how_to_verify to recompute it.",
      "inputSchema": {
        "properties": {
          "n": {
            "description": "entry number",
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "n"
        ],
        "type": "object"
      },
      "name": "nenrin_ledger_entry",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "does_not_establish": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "source_url": {
            "description": "The public ledger URL that returned this body. Fetch it yourself to compare.",
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "source_url"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return the current head of the JIDEC/NENRIN ledger: entry count n, the head hash, and the end marker bound into the chain (jidec-head-v1) with the recipe to recompute it. Compare it with a head you saw earlier to detect truncation or rewrite.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "nenrin_ledger_head",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "does_not_establish": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "source_url": {
            "description": "The public ledger URL that returned this body. Fetch it yourself to compare.",
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "source_url"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return the NENRIN résumé of an agent or MCP endpoint: every recorded measurement that touches its origin (by the gate and by outside witnesses, signed or not), which are Bitcoin-anchored, discrepancies, rings, agreements, and the records not counted with the reason. Includes resume_sha256 and a recompute recipe. A history, not a score. Absent means no record, not a negative finding.",
      "inputSchema": {
        "properties": {
          "endpoint": {
            "description": "https URL of the agent or MCP endpoint, e.g. https://mcp.horizonshield.dev/mcp",
            "type": "string"
          }
        },
        "required": [
          "endpoint"
        ],
        "type": "object"
      },
      "name": "nenrin_resume",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "does_not_establish": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "source_url": {
            "description": "The public ledger URL that returned this body. Fetch it yourself to compare.",
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "source_url"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return the compact NENRIN signal for an endpoint: counts of anchored measurements, witness diversity and freshness, in a shape a trust engine or orderer can read. No score, no allow or deny.",
      "inputSchema": {
        "properties": {
          "endpoint": {
            "description": "https URL of the agent or MCP endpoint",
            "type": "string"
          }
        },
        "required": [
          "endpoint"
        ],
        "type": "object"
      },
      "name": "nenrin_trust_signal",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "does_not_establish": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "source_url": {
            "description": "The public ledger URL that returned this body. Fetch it yourself to compare.",
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "source_url"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return one NENRIN witness record by its record SHA-256: pending or anchored, and when anchored, the ledger entry and batch that carry it. Use it to check a walk someone says they submitted.",
      "inputSchema": {
        "properties": {
          "sha256": {
            "description": "64-hex record SHA-256",
            "type": "string"
          }
        },
        "required": [
          "sha256"
        ],
        "type": "object"
      },
      "name": "nenrin_witness",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "does_not_establish": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "lookup": {
            "description": "ok = the ledger was read and the record exists. absent = the ledger was read and there is no such record. A read that FAILED never appears here: it comes back as a tool error (isError: true), so a consumer can never mistake this server's own failure for a statement about the ledger's contents.",
            "enum": [
              "ok",
              "absent"
            ],
            "type": "string"
          },
          "source_url": {
            "description": "The public ledger URL that returned this body. Fetch it yourself to compare.",
            "type": "string"
          }
        },
        "required": [
          "lookup",
          "source_url"
        ],
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:65347699a32907fcfdfe1a25148bb750195290813cde494997da902f8feee0d6 | sha256sum