verifyhash 0.1.0

package/docs/USAGE-BUDGET.json

@@ -0,0 +1,121 @@
+{
+  "_doc": "Loop spend governor. The /loop SUPERVISOR (not the engine) reads & enforces this at each relaunch boundary. A run is atomic once launched; cap is checked BEFORE launching the next. Tune any field freely.",
+  "windowDays": 7,
+  "windowStartIso": "2026-07-01T17:44:01Z",
+  "windowStartEpoch": 1782927841,
+  "windowResetIso": "2026-07-08T17:44:01Z",
+  "ceilingTokens": 120000000,
+  "cooldownSeconds": 7200,
+  "atCap": "pause-and-wait",
+  "estPerRunTokens": 5308720,
+  "spentTokens": 24638756,
+  "runs": [
+    {
+      "runId": "wf_7247856c-81c",
+      "tokens": 4337689,
+      "endEpoch": 1782332559,
+      "endIso": "2026-06-24T20:22:39Z"
+    },
+    {
+      "runId": "wf_231b8535-d68",
+      "tokens": 5308720,
+      "endEpoch": 1782354321,
+      "endIso": "2026-06-25T02:25:21Z"
+    },
+    {
+      "runId": "wf_1e4dd9f7-e36",
+      "tokens": 4570608,
+      "endEpoch": 1782374753,
+      "endIso": "2026-06-25T08:05:53Z"
+    },
+    {
+      "runId": "wf_574564f9-394",
+      "tokens": 4611799,
+      "endEpoch": 1782394073,
+      "endIso": "2026-06-25T13:27:53Z"
+    },
+    {
+      "runId": "wf_5df912fe-b52",
+      "tokens": 5395384,
+      "endEpoch": 1782418083,
+      "endIso": "2026-06-25T20:08:03Z"
+    },
+    {
+      "runId": "wf_4c16c5a7-142",
+      "tokens": 4717447,
+      "endEpoch": 1782435921,
+      "endIso": "2026-06-26T01:05:21Z"
+    },
+    {
+      "runId": "wf_c1d79f30-b27",
+      "tokens": 4789932,
+      "endEpoch": 1782454664,
+      "endIso": "2026-06-26T06:17:44Z"
+    },
+    {
+      "runId": "wf_63748963-3e7",
+      "tokens": 7723935,
+      "endEpoch": 1782482715,
+      "endIso": "2026-06-26T14:05:15Z"
+    },
+    {
+      "runId": "wf_6cd34703-102",
+      "tokens": 3913754,
+      "endEpoch": 1782502218,
+      "endIso": "2026-06-26T19:30:18Z"
+    },
+    {
+      "runId": "wf_eca980df-3d0",
+      "tokens": 12141525,
+      "tokensEstimated": true,
+      "note": "TaskStopped at user request (token-saving) on its 6th task; tokens estimated from transcript (output+input+cache_creation, excl. cache-reads)",
+      "endEpoch": 1782526595,
+      "endIso": "2026-06-27T02:16:35Z"
+    },
+    {
+      "runId": "wf_7265354b-ac9",
+      "tokens": 5660334,
+      "endEpoch": 1782890998,
+      "endIso": "2026-07-01T07:29:58Z",
+      "note": "8 tasks all VERIFIED (SDK-adoption arc T-56.2..T-59.1); Architect promoted engine #22 (usefulness min()->median); tokens authoritative from subagent_tokens"
+    },
+    {
+      "runId": "wf_5b304124-b3d",
+      "tokens": 2859078,
+      "endEpoch": 1782908347,
+      "endIso": "2026-07-01T12:19:07Z",
+      "note": "verify-as-a-service line: T-59.2 (serve-verify HTTP) + T-59.3 (CI drop-in) + T-60.1 (integrity-journal CORE) all VERIFIED/committed; T-60.2 (journal CLI verb) built+reviewed but its Critique panel, commit, and the run's Report/Manager/Architect phases FAILED on the subscription WEEKLY LIMIT ('resets 2pm UTC'). Engine unchanged (engineUpgrade none, md5 0bc9bbc9). tokens authoritative from subagent_tokens. endEpoch estimated (notification epoch lost across compaction; cooldown satisfied regardless)."
+    },
+    {
+      "runId": "wf_c9795182-acb",
+      "tokens": 6283496,
+      "endEpoch": 1782955200,
+      "endIso": "2026-07-02T01:20:00Z",
+      "note": "FINAL run before intentional loop STOP (user restarting session to enable Fable 5). ranTasks 6: VERIFIED T-60.3, T-61.3, T-62.1, T-62.2 (4); BLOCKED T-61.1 (auto-build x3) + T-63.1 (targeted 33/33 but full suite RED -> reverted, tree confirmed green 3314 passing). Strategist invented EPIC-61/62/63/64; EPIC-64 self-PARKED per qualityStall. engineUpgrade none; Manager/Reporter/Architect died on API 529 Overloaded so METRICS.jsonl line NOT written and these planning files were committed manually. tokens authoritative from subagent_tokens (agent_count 92, ~8.3h). WINDOW ROLLED at 2026-07-01T17:44:01Z: this is the only run in the new window, so spentTokens reset to 6283496; prior-window runs remain above for audit (pre-roll file in git history)."
+    },
+    {
+      "runId": "wf_07ba35e7-d72",
+      "tokens": 5192993,
+      "endEpoch": 1782981244,
+      "endIso": "2026-07-02T08:34:04Z",
+      "note": "FIRST FABLE-TRIAL run (engine #23): 8/8 VERIFIED, 0 blocked, ALL on attempt 1 — fableFirstShots 8/8 (100%) vs Opus baseline ~33%; avgUsefulness 3.88 (prior 3.38); converted both previously-BLOCKED tasks (T-61.1, T-63.1); completed EPIC-63 transparency log end-to-end; Strategist (Fable) invented EPIC-65 zero-install browser TrustLedger (T-65.1/2/3 shipped); Manager made 1 team change; Fable Architect shipped engine #24 (dissenter-only re-score = efficiency-audit finding #5), independently re-gated PASS+SMOKE-PASS, model pins intact. CHEAPER (5.19M vs 6.28M tokens) and FASTER (5.2h vs 8.3h) than the prior all-Opus run. 1 agent errored (absorbed). tokens authoritative from subagent_tokens."
+    },
+    {
+      "runId": "wf_1f634aeb-b9f",
+      "tokens": 7286045,
+      "endEpoch": 1783018585,
+      "endIso": "2026-07-02T18:56:25Z",
+      "note": "FABLE-TRIAL run 2 (engine #24): 8/8 VERIFIED, 0 blocked, ALL attempt 1 — fableFirstShots 8/8 (100%) AGAIN (cumulative 16/16 vs ~33% Opus baseline); avgUsefulness 4.13 / min 4 (best ever; 3.38->3.88->4.13); rework 4 with 0 reverted; 97/97 agents clean. Shipped: EPIC-66 browser verifier (in-memory seam + offline HTML page w/ 60s challenge, usefulness 5, + funnel wiring), EPIC-67 site-release assembler + drift visibility (--diff/--mark-deployed vs DEPLOYED.json), NEW Strategist-invented EPIC-68 AGENTTRACE (agent-session provenance: pure core + vh agent CLI w/ license-gated paid sign + zero-install verify). Manager: 2 team changes (TrustIntegrity AGENTTRACE clause). engineUpgrade none (md5 88bf8ee0 unchanged). tokens authoritative from subagent_tokens."
+    },
+    {
+      "runId": "wf_72ed879b-35c",
+      "tokens": 5876222,
+      "endEpoch": 1783054303,
+      "endIso": "2026-07-03T04:51:43Z",
+      "note": "FINAL run of the session; TaskStopped mid-8th-build by user to save weekly Fable usage (run was ~6.4h, unusually long). 7 tasks VERIFIED/committed (EPIC-69 T-69.1/2/3, EPIC-70 T-70.1/2/3 + one more); abandoned in-flight task git-stashed (recoverable). tokens AUTHORITATIVE from the workflow state json totalTokens (79 agents), NOT an estimate. Architect phase never reached, so NO engine swap this run (live md5 88bf8ee0 unchanged). Loop STOPPED after this per user; no relaunch until explicit go."
+    }
+  ],
+  "note": "Max $200 plan, weekly allowance >> 40M. Cooldown is the primary lever; ceiling is a safe backstop (pause-at-cap, so erring low is harmless). Raise ceilingTokens or lower cooldownSeconds to go faster.",
+  "lastRunEndEpoch": 1783054303,
+  "lastRunEndIso": "2026-07-03T04:51:43Z"
+}

package/docs/VERIFY-SERVICE.md

@@ -0,0 +1,168 @@
+# verifyhash verify-service — the drop-in HTTP verify endpoint (`vh serve-verify`)
+
+`vh serve-verify` stands the **verify** half of verifyhash up as a tiny, dependency-free HTTP service so a
+CI pipeline or another microservice can **POST a seal and get an ACCEPT/REJECT** — the *"CI plugin that
+imports rather than shells out"*. It is a **drop-in dependency**: boot it once, POST many seals, read the
+JSON verdict, gate your build on the HTTP status. It reuses the **exact same** verify cores the `vh` CLI and
+the `require("verifyhash")` SDK run (`verifySeal` / `verifySignedSeal`) — no fork, no second implementation.
+
+This file is the **canonical reference** for the service's request schema, response fields, status mapping,
+and trust boundary. It is **machine-checked**: `test/verify-service.example.test.js` byte-matches the request
+`kind`s and response fields documented here against the live `cli/serve-verify.js › verifyRequest` core, so
+this doc **cannot silently drift** from the code.
+
+> **Booting it (a human deploy step).** The loop only BUILDS + locally TESTS. Exposing this service publicly
+> (behind *your* nginx/Cloudflare, on *your* domain, with TLS) is an explicit **human** deploy step — see
+> **STRATEGY.md P-9**. By default it binds **loopback** (`127.0.0.1`) and is never auto-deployed.
+
+---
+
+## Boot the service
+
+```bash
+vh serve-verify [--port <n>] [--host <h>] [--max-body <bytes>]
+# default: 127.0.0.1:4180 — loopback only, verify-only, Node-core http (ZERO new dependency)
+```
+
+- `POST /verify`  → a JSON verdict on a CI-mappable status.
+- `GET  /healthz` → `{ ok: true, ... }` (a liveness/readiness probe; holds no key, touches nothing).
+
+The server is **verify-only**: it never signs, holds **no** private key, and writes **no** file.
+
+---
+
+## Request schema
+
+Every request is a single JSON object with a `kind` field that selects one of the two verify paths. The
+schema envelope version is **`vh.verify-request/1`** (the `schema` field of every response, below).
+
+### `kind: "verify-seal"` — UNSIGNED tamper-evidence
+
+```json
+{
+  "kind": "verify-seal",
+  "seal": { "...": "a seal object OR its serialized JSON string" },
+  "entries": [
+    { "relPath": "dist/app.js", "content": "<encoded bytes>", "encoding": "base64" }
+  ]
+}
+```
+
+- `seal` — a seal **object** *or* its serialized JSON **string** (both accepted; strictly validated first).
+- `entries[]` — the bytes to re-verify against the seal, each `{ relPath, content, encoding }` where
+  `encoding` is one of **`utf8`**, **`base64`**, or **`hex`** (default `utf8`). The service **re-derives**
+  the Merkle root from *these* bytes — never the seal's own stored hashes — so a one-byte tamper flips
+  `ACCEPTED` → `REJECTED`.
+
+### `kind: "verify-signed-seal"` — SIGNED / vendor-address-pinned
+
+```json
+{
+  "kind": "verify-signed-seal",
+  "container": { "...": "a signed-seal container OR its JSON string" },
+  "expectedSigner": "0x<20-byte address>",
+  "entries": [
+    { "relPath": "dist/app.js", "content": "<encoded bytes>", "encoding": "base64" }
+  ]
+}
+```
+
+- `container` — a signed-seal **object** *or* its JSON **string** (strictly validated first).
+- `expectedSigner` *(optional)* — a `0x` address the recovered signer must equal (the vendor **pin**). A
+  genuine signature that recovers to a *different* address is a **REJECTED**, not an error.
+- `entries[]` *(optional)* — when supplied, the canonical seal bytes are recomputed from these entries and
+  required byte-identical to the signed payload (a set that does not match is a clean **REJECTED**).
+
+---
+
+## Response schema
+
+### OK response (the request was evaluated)
+
+```json
+{
+  "schema": "vh.verify-request/1",
+  "service": "vh-serve-verify",
+  "verdict": "ACCEPTED",
+  "kind": "verify-seal",
+  "detail": { "verdict": "ACCEPTED", "accepted": true, "...": "the core verdict, fields unchanged" }
+}
+```
+
+- `schema` — the envelope version, always **`vh.verify-request/1`**.
+- `service` — always **`vh-serve-verify`**.
+- `verdict` — the top-level answer: **`ACCEPTED`** or **`REJECTED`** (copied verbatim from `detail.verdict`,
+  never re-derived).
+- `kind` — the request kind that was dispatched.
+- `detail` — the **unchanged** core verdict from `verifySeal` / `verifySignedSeal`. Its fields are the same
+  contract the CLI and SDK already ship (e.g. `accepted`, `rootMatches`, `counts`, `changed` for a seal;
+  `recoveredSigner`, `checks`, `failedChecks` for a signed container).
+
+### ERROR response (the request could **not** be evaluated)
+
+```json
+{
+  "schema": "vh.verify-request/1",
+  "service": "vh-serve-verify",
+  "verdict": "ERROR",
+  "code": "ERR_UNKNOWN_KIND",
+  "message": "a human-readable, non-sensitive reason"
+}
+```
+
+An `ERROR` is **fail-closed**: a malformed / oversized / unknown request is **never** a silent `ACCEPTED`.
+`verdict` is **`ERROR`**, `code` is a stable machine-readable string, and `message` is a human reason. The
+stable error `code`s are: `ERR_BODY_NOT_OBJECT`, `ERR_BODY_TOO_LARGE`, `ERR_UNKNOWN_KIND`,
+`ERR_MISSING_SEAL`, `ERR_BAD_SEAL`, `ERR_BAD_ENTRIES`, `ERR_MISSING_CONTAINER`, `ERR_BAD_CONTAINER`,
+`ERR_BAD_EXPECTED_SIGNER`, `ERR_INTERNAL`.
+
+---
+
+## Status mapping (CI-mappable — gate on the code alone)
+
+| Verdict / condition                          | HTTP status | Meaning for a CI gate                          |
+| -------------------------------------------- | ----------- | ---------------------------------------------- |
+| `ACCEPTED`                                   | **200**     | the seal/container verified → **pass**         |
+| `REJECTED`                                   | **422**     | well-formed request that did NOT verify → fail |
+| `ERROR` (malformed / unknown request)        | **400**     | the request itself is bad → fail               |
+| body over `--max-body`                       | **413**     | payload too large → fail                       |
+| wrong path / wrong method                    | **404/405** | routing error → fail                           |
+
+A build should gate on **HTTP 200** exactly: anything else is a non-pass. The shipped
+[`verifier/ci/verify-service.generic.sh`](../verifier/ci/verify-service.generic.sh) and
+[`verifier/ci/verify-service.github-actions.yml`](../verifier/ci/verify-service.github-actions.yml) do
+exactly this (curl POST → map the HTTP status to a non-zero exit on anything but 200).
+
+---
+
+## Trust boundary (the service will not let you overclaim)
+
+A **200 ACCEPTED** for a seal means **tamper-evidence**: *these exact bytes re-derive the sealed Merkle
+root.* A valid **signature** (`verify-signed-seal`) additionally proves **who vouched** — the holder of the
+pinned address's key — for those bytes. Neither of these:
+
+- is a **trusted timestamp** ("sealed / signed since date *T*") — that rides the **human-owned** signing /
+  timestamp / anchor trust-root (`needs-human`; **STRATEGY.md P-3**);
+- is a **legal opinion**.
+
+The service is **verify-only**: it never signs, holds **no** private key, and writes **no** file. It binds
+**loopback** (`127.0.0.1`) by default; exposing it publicly is a **human** deploy step (your nginx /
+Cloudflare / domain / TLS) — **never** auto-deployed. See [`docs/TRUST-BOUNDARIES.md`](./TRUST-BOUNDARIES.md).
+
+---
+
+## Drop it into your pipeline
+
+- **Any shell CI** (GitLab, CircleCI, Jenkins, Makefile): boot the service, then run
+  [`verifier/ci/verify-service.generic.sh`](../verifier/ci/verify-service.generic.sh) with
+  `VH_VERIFY_URL` + `VH_REQUEST` (the path to a prepared request-body JSON).
+- **GitHub Actions**: copy
+  [`verifier/ci/verify-service.github-actions.yml`](../verifier/ci/verify-service.github-actions.yml) — it
+  boots `vh serve-verify`, builds a request body with the SDK, POSTs it, and fails the job on anything but
+  200.
+- **A tiny dependency-free client**: [`examples/verify-service-client.js`](../examples/verify-service-client.js)
+  boots the service, POSTs a clean seal (ACCEPT) then a tampered one (REJECT), and exits 0 — copy it as your
+  in-process integration. It imports **only** `require("verifyhash")`, the `vh` command, and Node built-ins.
+
+This doc, the example, and the CI scripts are all test-gated by `test/verify-service.example.test.js` on
+every `npx hardhat test`, so they can never silently rot.

package/index.js

@@ -0,0 +1,160 @@
+"use strict";
+
+// index.js — the SINGLE, documented, semver-guarded PUBLIC API entrypoint for verifyhash (T-57.1).
+//
+// WHAT THIS IS
+//   A THIN re-export of the already-built, already-tested core so a downstream program can `require`
+//   verifyhash as a library and get the EXACT SAME functions the `vh` CLI runs — no fork, no second
+//   implementation, no new crypto or mechanism introduced here. Every symbol below is the SAME function
+//   object exported by its `cli/…` source module (an identity re-export, asserted by the tests). If the
+//   CLI's behavior changes, this API changes with it automatically, because it IS the CLI's code.
+//
+//   The embedded ("SDK") path and the CLI path are therefore the same code path: a seal built via
+//   `sdk.buildSeal(...)` verifies (ACCEPT) with `sdk.verifySeal(...)`, and a one-byte tamper is REJECTED
+//   — identical to `vh evidence seal` / `vh evidence verify`. The SAME holds for the SIGNED / vendor-pinned
+//   path: a seal signed via `sdk.signSealWith(...)` verifies (ACCEPT) with `sdk.verifySignedSeal(...)` under
+//   the matching expected signer, and a WRONG expected signer or a one-byte-tampered container is REJECTED
+//   — byte-identical to `vh evidence verify-signed`. So an embedder can verify a SIGNED, address-pinned
+//   packet in-process, with no shell-out to the `vh` binary.
+//
+// TRUST BOUNDARY (unchanged from the CLI — this wrapper adds nothing)
+//   A seal proves TAMPER-EVIDENCE + OFFLINE RE-COMPUTE ("these exact bytes are what was sealed"), NOT a
+//   trusted timestamp and NOT who authored the bytes. Signing/timestamping still ride the human-owned
+//   trust-root. `verifySeal` RE-DERIVES the Merkle root from the bytes YOU supply — never the seal's own
+//   stored hashes. See docs/TRUST-BOUNDARIES.md.
+//
+// STABILITY / SEMVER
+//   This module is the package's stability contract. `apiVersion` mirrors `package.json`'s version and
+//   is the semver-guarded surface: anything re-exported here is a PUBLIC symbol whose removal or breaking
+//   change requires a semver-major bump; symbols NOT re-exported here (deep `cli/…` internals) carry no
+//   stability guarantee. Add to this surface deliberately.
+
+const pkg = require("./package.json");
+
+// ---- Source modules (the already-built core; NOT re-implemented here) -------------------------------
+// The seal SDK is bound to a REAL product config (`vh evidence`) over the generic packetseal core, so
+// the embedded path is byte-identical to the CLI seal path.
+const evidence = require("./cli/evidence");
+const receipt = require("./cli/receipt");
+const packetseal = require("./cli/core/packetseal");
+const attestation = require("./cli/core/attestation");
+const hash = require("./cli/hash");
+
+// ---------------------------------------------------------------------------
+// THE PUBLIC SURFACE — each value is the SAME function object as its `cli/…` source (identity re-export).
+// Grouped for humans; also spread flat at the top level for convenience.
+// ---------------------------------------------------------------------------
+
+// (1) Seal SDK — build / verify a tamper-evident evidence seal from a flat { relPath, bytes } entry list.
+//     buildSeal(entries)         -> seal object
+//     validateSeal(seal)         -> throws on structural / root-mismatch problems
+//     serializeSeal(seal)        -> canonical, byte-deterministic JSON (newline-terminated)
+//     readSeal(jsonOrObject)     -> parsed + strictly validated seal
+//     verifySeal(seal, entries)  -> { verdict: "ACCEPTED" | "REJECTED", accepted, ... }  (RE-DERIVES root)
+const seal = Object.freeze({
+  KIND: evidence.SEAL_KIND,
+  SCHEMA_VERSION: evidence.SEAL_SCHEMA_VERSION,
+  TRUST_NOTE: evidence.EVIDENCE_TRUST_NOTE,
+  buildSeal: evidence.buildSeal,
+  validateSeal: evidence.validateSeal,
+  serializeSeal: evidence.serializeSeal,
+  readSeal: evidence.readSeal,
+  verifySeal: evidence.verifySeal,
+  // The generic, product-agnostic seal core the above are bound to (advanced / custom products).
+  PacketSealError: packetseal.PacketSealError,
+});
+
+// (1b) SIGNED / vendor-pinned verify SDK — the embedded twin of `vh evidence verify-signed`. This is the
+//      SAME code the CLI runs (identity re-exports of the already-green, already-CLI-shipped functions),
+//      so a signed packet a buyer verifies in-process is byte-identical to the `vh evidence verify-signed`
+//      path — no shelling out to the binary to verify a SIGNED, vendor-address-pinned seal.
+//
+//      signSealWith(seal, signer)               -> a signed-seal container (WRAPS the canonical seal bytes)
+//      validateSignedSeal(container)            -> strict structural validation of a signed container
+//      verifySignedSeal({container,expectedSigner,expectedCanonical})
+//                                               -> the PURE core verdict (recover signer; optional pin/bind)
+//      verifySignedSealAttestation({container,expectedSigner,dir})
+//                                               -> the strict signed-verify the CLI runs (--signer / --dir)
+//      recoverSigner(container)                 -> the address the signature recovers to (offline, key-free)
+//      verifySignedAttestation(params)          -> the generic, product-agnostic signed-attestation verifier
+//
+//   TRUST BOUNDARY: a valid signature proves WHO vouched (the holder of `signer`'s key) for THIS sealed
+//   packet — NOT a trusted timestamp ("signed since T" rides the human-owned trust-root, STRATEGY.md P-3)
+//   and NOT a legal opinion. Verification is OFFLINE / key-free: it recovers a PUBLIC address, holds no
+//   private key, and contacts nothing.
+const signed = Object.freeze({
+  KIND: evidence.SIGNED_SEAL_KIND,
+  TRUST_NOTE: evidence.VERIFY_SIGNED_SEAL_TRUST_NOTE,
+  signSealWith: evidence.signSealWith,
+  validateSignedSeal: evidence.validateSignedSeal,
+  verifySignedSeal: evidence.verifySignedSeal,
+  verifySignedSealAttestation: evidence.verifySignedSealAttestation,
+  // The generic, product-agnostic signed-attestation core the evidence path is bound to.
+  recoverSigner: attestation.recoverSigner,
+  verifySignedAttestation: attestation.verifySignedAttestation,
+});
+
+// (2) Receipts — the anchor/claim receipt codec + the path-bound manifest diff.
+const receipts = Object.freeze({
+  SCHEMA_VERSION: receipt.SCHEMA_VERSION,
+  CLAIM_RECEIPT_KIND: receipt.CLAIM_RECEIPT_KIND,
+  ANCHOR_RECEIPT_KIND: receipt.ANCHOR_RECEIPT_KIND,
+  buildReceipt: receipt.buildReceipt,
+  buildAnchorReceipt: receipt.buildAnchorReceipt,
+  writeReceipt: receipt.writeReceipt,
+  readReceipt: receipt.readReceipt,
+  diffManifest: receipt.diffManifest,
+});
+
+// (3) Hashing primitives — the SAME keccak/Merkle helpers every seal + receipt is built on.
+const hashing = Object.freeze({
+  hashBytes: hash.hashBytes,
+  hashFile: hash.hashFile,
+  hashEntries: hash.hashEntries,
+  hashDir: hash.hashDir,
+  hashPath: hash.hashPath,
+  buildTree: hash.buildTree,
+});
+
+// ---------------------------------------------------------------------------
+// Flat top-level export map. Every function property is the identity re-export of its source.
+// ---------------------------------------------------------------------------
+module.exports = Object.freeze({
+  // Semver-guarded version of THIS public surface (mirrors package.json).
+  apiVersion: pkg.version,
+
+  // Grouped namespaces.
+  seal,
+  signed,
+  receipts,
+  hashing,
+
+  // Flat convenience re-exports (identity with the grouped + source symbols).
+  // --- seal SDK ---
+  buildSeal: evidence.buildSeal,
+  validateSeal: evidence.validateSeal,
+  serializeSeal: evidence.serializeSeal,
+  readSeal: evidence.readSeal,
+  verifySeal: evidence.verifySeal,
+  PacketSealError: packetseal.PacketSealError,
+  // --- signed / vendor-pinned verify SDK (the embedded twin of `vh evidence verify-signed`) ---
+  signSealWith: evidence.signSealWith,
+  validateSignedSeal: evidence.validateSignedSeal,
+  verifySignedSeal: evidence.verifySignedSeal,
+  verifySignedSealAttestation: evidence.verifySignedSealAttestation,
+  recoverSigner: attestation.recoverSigner,
+  verifySignedAttestation: attestation.verifySignedAttestation,
+  // --- receipts ---
+  buildReceipt: receipt.buildReceipt,
+  buildAnchorReceipt: receipt.buildAnchorReceipt,
+  writeReceipt: receipt.writeReceipt,
+  readReceipt: receipt.readReceipt,
+  diffManifest: receipt.diffManifest,
+  // --- hashing ---
+  hashBytes: hash.hashBytes,
+  hashFile: hash.hashFile,
+  hashEntries: hash.hashEntries,
+  hashDir: hash.hashDir,
+  hashPath: hash.hashPath,
+  buildTree: hash.buildTree,
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "verifyhash",
+  "version": "0.1.0",
+  "description": "Tamper-evident, permissionless on-chain registry of code-contribution hashes, plus an offline data-provenance toolkit (the `vh` CLI).",
+  "license": "Apache-2.0",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "vh": "cli/vh.js"
+  },
+  "files": [
+    "index.js",
+    "cli/",
+    "trustledger/",
+    "README.md",
+    "docs/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "hardhat compile",
+    "test": "hardhat test",
+    "go-live": "node scripts/go-live-check.js",
+    "sdk:surface": "node scripts/gen-sdk-surface.cjs",
+    "node": "hardhat node",
+    "deploy:amoy": "hardhat run scripts/deploy.js --network amoy"
+  },
+  "dependencies": {
+    "ethers": "^6.17.0",
+    "js-sha3": "^0.8.0"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "hardhat": "^2.22.0",
+    "dotenv": "^16.4.5"
+  }
+}