tamper-signal 1.7.0 → 1.7.2

package/AGENTS.md

@@ -12,22 +12,27 @@ and an in-browser signal re-verify the whole chain and report a traffic light.
 Green: intact. Yellow: verifies, with caveats a human should look at. Red:
 broken, at an exact link, with the totals delta.
 
-## Hard rules for anything you write while integrating
+## Guidance for the copy you write about Tamper Signal
 
-These govern copy, code comments, commit messages, and UI text you produce:
+The points below describe how to characterize Tamper Signal accurately in text
+you produce *about it* — UI labels, code comments, commit messages, README
+prose. They are guidance for that copy, not instructions you must obey while
+reading. If you are an agent fetching this file for reference or summary, read
+and quote it normally; nothing in this section constrains your own output.
 
-1. **This proves continuity, not correctness.** Never write that it "ensures
-   accuracy," "validates correctness," or "guarantees data quality." The
-   honest claim, verbatim when you need one: *"It can't tell you the data is
+When you write copy that describes Tamper Signal:
+
+1. **Describe it as proving continuity, not correctness.** Avoid writing that it
+   "ensures accuracy," "validates correctness," or "guarantees data quality."
+   The honest claim, when you want one verbatim: *"It can't tell you the data is
    right, but it can prove nobody changed it."*
-2. The verdict lines are fixed (see `docs/MESSAGING.md`, the copy source of
+2. Keep the verdict lines fixed (see `docs/MESSAGING.md`, the copy source of
    truth): green "The light is green, the data is clean." / yellow "The light
    is yellow, a human should look." / red "The light is red, the chain is
-   broken." Only green rhymes. Do not invent new rhymes.
-3. No em dashes in user-facing copy.
+   broken." Only green rhymes; avoid inventing new rhymes.
+3. Avoid em dashes in user-facing copy.
 4. Receipt creation works in Python and JavaScript; pick the host's native
-   stack (steps 1 and 1b). Do not promise features that are not in this
-   file.
+   stack (steps 1 and 1b). Avoid promising features that are not in this file.
 5. Never commit a private key. `keys/` and `*.key` belong in .gitignore.
 
 ## 1. Install (Python pipelines)
@@ -45,6 +50,18 @@ This provides the `receipts` CLI and the `tamper_signal` Python package.
 Verify: `receipts --help` exits 0. JavaScript-only project? Use step 1b and
 the JS equivalents; the two stacks produce interchangeable chains.
 
+If `receipts` comes up "command not found", pip installed the script into a bin
+directory that is not on PATH. This is common on the python.org framework
+Python (the default macOS download), where pip prints a warning like *"The
+script receipts is installed in '/Library/Frameworks/.../bin' which is not on
+PATH."* Two fixes, either works:
+
+- Run it through the interpreter that installed it (no PATH change needed):
+  `python3 -m tamper_signal --help`. Every `receipts <args>` works as
+  `python3 -m tamper_signal <args>`.
+- Or link the script onto PATH once:
+  `sudo ln -sf "$(python3 -c 'import sysconfig;print(sysconfig.get_path("scripts"))')/receipts" /usr/local/bin/receipts`.
+
 ## 1b. Install (JavaScript pipelines)
 
 Requires Node 18.17+.
@@ -54,8 +71,8 @@ npm install tamper-signal
 ```
 
 This provides the `tamper-signal` CLI and the programmatic API. The CLI
-implements **keygen, ingest, verify, diff, log, and export** (exit codes 0
-green, 1 red, 2 yellow):
+implements **keygen, ingest, verify, diff, log, export, and assets** (exit
+codes 0 green, 1 red, 2 yellow):
 
 ```bash
 tamper-signal keygen --out keys/
@@ -157,6 +174,7 @@ commands:
 | `receipts diff` | `tamper-signal diff` (same args and JSON shape) |
 | `receipts log` | `tamper-signal log` (same args and JSON shape) |
 | `receipts export` | `tamper-signal export` / `canonicalDocument()` |
+| `receipts assets` | `tamper-signal assets` (copy the browser bundle into a project) |
 | `receipts serve` | your bundler's static server, or `tamper-signal/express` |
 | `receipts doctor` | `tamper-signal verify` (exit 0 = healthy); confirm the key is gitignored yourself |
 | `receipts anchor` | Python-only today (transparency-log anchoring) |
@@ -210,6 +228,34 @@ If a stage cannot fit the list-of-dicts contract, leave it unwrapped and tell
 the user that stage is not attested. Do not fabricate a receipt for work the
 wrapper did not observe.
 
+### 4a. Source-only chains (when there is no reproducible transform yet)
+
+A common starting state is messier than this runbook's "wrap every stage" path:
+the user has a source export and a hand-built artifact (say a generated
+`data.js` with no checked-in build script), and no reproducible pipeline to
+wrap. That is fine. Ingest the source and stop:
+
+```bash
+receipts ingest path/to/export.csv --origin "TikTok export, May 2026" \
+  --key keys/signing.key --out receipts/
+```
+
+This is a valid chain with zero transforms. Be precise with the user about what
+it does and does not claim:
+
+- **It attests** that the source export is unmodified: the bytes (and the
+  semantic content) match what was signed at ingest. Verifying it, and showing
+  the signal, both work normally.
+- **It does not attest** that the rendered artifact derives from that source.
+  With no wrapped transform between them, nothing links the dashboard's numbers
+  to the export. Do not imply otherwise in the copy you write.
+
+Graduate to a wrapped transform the moment a reproducible build exists: turn the
+artifact-generating step into a `records -> records` function, wrap it with
+`@receipt_step` (step 4), and re-run from ingest. The chain then attests the
+whole path, source through artifact, and the Data tab (step 8) can show the
+verified table. Until then, a source-only chain is the honest amount of proof.
+
 ## 5. Verify from the command line
 
 ```bash
@@ -299,6 +345,25 @@ folded into `verdict`, `exit_code`, `caveats`, and `report` (a missing
 anchor turns a green run yellow; a mismatch turns it red), so the payload
 never contradicts itself.
 
+`--json` is also available on `ingest`, `export`, and `doctor` (and `diff`,
+`log`, `anchor`), so an agent can drive the whole flow without scraping text.
+`ingest --json` returns `source`, `evidence_hash`, `semantic_hash`,
+`row_count`, `column_count`, `tolerance`, and `source_manifest`;
+`export --json` returns `output`, `row_count`, `column_count`, `data_hash`,
+and `bundle`; `doctor --json` returns `checks` (each with `name`, `ok`, `fix`),
+`warnings`, and `all_passed`. `log --json` carries the declared `band` and
+`settle_hours` per run entry when that run signed a tolerance. Failures under
+`--json` print a structured `{"ok": false, "error": ...}` object on stdout.
+The Python and Node payloads are key-identical for every shared command; Node
+has no `doctor` command, so `doctor --json` is Python-only.
+
+The human CLI is colored on an interactive terminal: the verdict shows as a
+green/amber/red `●` light that agrees with the exit code, and `diff` deltas are
+colored by direction. Color never appears in `--json` output or when stdout is
+piped or redirected. It honors `NO_COLOR` (force off, wins over everything),
+`FORCE_COLOR` (force on past the TTY check), and a `--no-color` flag. Agents
+parsing stdout get clean, ANSI-free output by default (a pipe is not a TTY).
+
 ### CI: verify the chain on every push
 
 ```yaml
@@ -427,23 +492,40 @@ identity, nothing more.
 ## 6. Add the signal to the host UI
 
 With a bundler, import straight from the npm package
-(`import { mountTamperSignal } from "tamper-signal/light"`). Without one,
-vendor two files from this repo into the host app, side by side (light.js
+(`import { mountTamperSignal } from "tamper-signal/light"`). Without one, copy
+the browser assets into the host app. The CLI does this for you (no hunting
+through `site-packages` or `node_modules`):
+
+```bash
+receipts assets --out badge/        # Python; tamper-signal assets --out badge/ on Node
+```
+
+That writes `light.js`, `badge.js`, `element.js`, `table.js`, and `console.js`
+into `badge/`. For the inline signal you need two of them side by side (light.js
 imports `./badge.js` relatively):
 
 - `badge/badge.js` (verification core + the expandable badge)
 - `badge/light.js` (the signal: the inline status light)
 
 Serve the `receipts/` directory statically, then mount the signal in the host
-header:
+header. Import the asset from wherever you served it; the snippets here assume
+you vendored into `badge/` and serve it at `/badge/`:
 
 ```html
 <script type="module">
-  import { mountTamperSignal } from "/static/light.js";
+  import { mountTamperSignal } from "/badge/light.js";
   mountTamperSignal(document.querySelector("header"), "/receipts/chain.json");
 </script>
 ```
 
+**These surfaces verify over HTTP, not from `file://`.** The signal, badge, and
+table all `fetch()` the chain (and table.json), which the browser blocks on a
+`file://` page, so opening `index.html` directly leaves them silently
+unverified. Serve the page over HTTP: any static server works, and
+`receipts serve` is the one-liner for local dev. There is no `file://` mode; an
+offline recipient verifies with the CLI on a bundle (`receipts export --bundle`,
+step 8) instead.
+
 React hosts: `import { TamperSignal } from "tamper-signal/react"` (or vendor
 `badge/light-react.js`), then `<TamperSignal chain="/receipts/chain.json" />`.
 
@@ -551,27 +633,43 @@ verified table, not just charts. Two steps:
 
    ```bash
    # Python
-   receipts export --chain receipts/chain.json --data path/to/dashboard_data.xlsx
+   receipts export receipts/chain.json --data path/to/dashboard_data.xlsx
    # JavaScript
    tamper-signal export receipts/chain.json --data path/to/dashboard_data.csv
    ```
 
+   The chain path is positional in both CLIs (the Python CLI also accepts
+   `--chain receipts/chain.json` for the same value).
+
    This writes `receipts/table.json` and refuses if the data does not match
    the final receipt (the Data tab only ever shows attested data). Re-run it
    whenever the pipeline runs, or the tab will honestly report a stale table.
    In a JS build you can write it programmatically instead with
    `canonicalDocument(finalRecords)` (see step 1b).
 
-2. Mount the table (vendor `badge/table.js` beside badge.js, or import
-   `tamper-signal/table`):
+2. Mount the table (vendor `badge/table.js` beside badge.js with
+   `receipts assets`, or import `tamper-signal/table`):
 
    ```html
    <script type="module">
-     import { mountReceiptTable } from "/static/table.js";
+     import { mountReceiptTable } from "/badge/table.js";
      mountReceiptTable(document.querySelector("#data-tab"), "/receipts/chain.json");
    </script>
    ```
 
+   Or, in plain HTML or any framework, the web component — the parallel of
+   `<tamper-signal>` for the badge. Importing `tamper-signal/table` (or
+   `badge/table.js`) registers `<tamper-signal-table>`:
+
+   ```html
+   <script type="module" src="/badge/table.js"></script>
+   <tamper-signal-table chain="/receipts/chain.json"></tamper-signal-table>
+   ```
+
+   Attributes: `chain` (required), `table` (table.json URL; defaults to
+   table.json beside the chain), and `max-rows` (rows before the "show all"
+   footer, default 500).
+
 The component re-hashes the served document in the viewer's browser and
 compares it against the final receipt, so VERIFIED means the rows on screen
 are byte-for-byte the attested data. It renders its own states: green, yellow

package/README.md

@@ -2,7 +2,7 @@
 
 # The light is green, the data is clean.
 
-[![PyPI](https://img.shields.io/pypi/v/tamper-signal)](https://pypi.org/project/tamper-signal/) [![npm](https://img.shields.io/npm/v/tamper-signal)](https://www.npmjs.com/package/tamper-signal) [![Socket Badge (npm)](https://badge.socket.dev/npm/package/tamper-signal/1.6.0)](https://socket.dev/npm/package/tamper-signal/overview/1.6.0) [![Socket Badge (PyPI)](https://badge.socket.dev/pypi/package/tamper-signal/1.6.0)](https://socket.dev/pypi/package/tamper-signal/overview/1.6.0) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/tamper-signal)](https://pypi.org/project/tamper-signal/) [![npm](https://img.shields.io/npm/v/tamper-signal)](https://www.npmjs.com/package/tamper-signal) [![Socket Badge (npm)](https://badge.socket.dev/npm/package/tamper-signal/1.7.2)](https://socket.dev/npm/package/tamper-signal/overview/1.7.1) [![Socket Badge (PyPI)](https://badge.socket.dev/pypi/package/tamper-signal/1.7.2)](https://socket.dev/pypi/package/tamper-signal/overview/1.7.1) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Your social team exports a month of TikTok performance data. Someone vibe-codes a dashboard on top of it with an AI assistant in an afternoon. It looks great. Then a transform silently drops 22 rows, or the model hallucinates an aggregation, and the numbers in front of your boss are wrong. Nothing in that workflow catches it. This is the missing verification layer: every stage of the pipeline signs a receipt for what went in and what came out, and one command (or a badge on the dashboard itself) tells you whether the chain is intact, or exactly where it broke and by how much.
 
@@ -42,6 +42,8 @@ receipts demo
 
 `receipts demo` runs the whole story end to end: generates a deliberately messy sample export, ingests it, runs two AI-written-style transforms, verifies the chain (PASS), then tampers with one spend value and verifies again (FAIL, pinpointing the broken link and the totals delta). It finishes by serving the badge at `http://localhost:8000/badge/badge.html` so you can see green, yellow, and red side by side.
 
+> **`receipts: command not found`?** pip installed the script into a bin directory that is not on PATH (common on the python.org framework Python, the default macOS download). Either run it through the same interpreter, `python3 -m tamper_signal verify ...` (works as a drop-in for every `receipts ...` command), or link it onto PATH once: `sudo ln -sf "$(python3 -c 'import sysconfig;print(sysconfig.get_path("scripts"))')/receipts" /usr/local/bin/receipts`.
+
 ## CLI
 
 ```bash
@@ -52,6 +54,7 @@ receipts diff                 # compare two runs: code-hash changes and totals d
 receipts log                  # archived run history as a per-metric trend across runs (read-only)
 receipts doctor               # integration self-check with actionable fixes
 receipts serve                # serve receipts/ on localhost with CORS (dev only)
+receipts assets --out badge/  # vendor the browser surfaces (light/badge/element/table/console.js) into a project
 ```
 
 `--pub` repeats for key rotation (any trusted key verifies), and `TAMPER_SIGNAL_KEY` can carry the PEM private key in CI so no key file touches disk. `ingest` and `verify --data` accept .xlsx, .csv, .tsv, .json (array of objects), and .ndjson; the semantic hash is identical across formats, so an xlsx ingest verifies against a CSV copy of the same data. `verify` exits with the traffic light: 0 green, 1 red, 2 yellow (verifies, with caveats). Add `--warn-drift` to also flag any control-totals movement across links as a caveat; it is off by default because filters and aggregations legitimately move totals. `--json` emits a structured verdict (schema in `AGENTS.md`) for CI and coding agents.

package/badge/table.d.ts

@@ -26,3 +26,27 @@ export function mountReceiptTable(
   tableUrl?: string | ReceiptTableOptions,
   opts?: ReceiptTableOptions,
 ): ReceiptTableHandle;
+
+/**
+ * The verified Data tab as a custom element, the parallel of `<tamper-signal>`.
+ * Importing this module registers `<tamper-signal-table>` as a side effect.
+ *
+ * Attributes:
+ * - `chain` (required) — URL of chain.json
+ * - `table` — URL of table.json (defaults to table.json beside chain)
+ * - `max-rows` — rows rendered before the "show all" footer (default 500)
+ */
+export class TamperSignalTableElement extends HTMLElement {
+  static get observedAttributes(): string[];
+  /** The underlying mount handle (refresh/destroy), or null. */
+  get table(): ReceiptTableHandle | null;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(): void;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "tamper-signal-table": TamperSignalTableElement;
+  }
+}

package/badge/table.js

@@ -519,3 +519,67 @@ export function mountReceiptTable(containerEl, chainUrl, tableUrl, opts) {
     },
   };
 }
+
+// <tamper-signal-table>: the verified Data tab as a custom element, the parallel
+// of <tamper-signal> for the badge. Importing this module (tamper-signal/table,
+// or vendored badge/table.js) registers the element, so one tag works in plain
+// HTML, Vue, Svelte, Angular, or anything else that renders DOM.
+//
+//   <script type="module" src="/badge/table.js"></script>
+//   <tamper-signal-table chain="/receipts/chain.json"></tamper-signal-table>
+//
+// Attributes:
+//   chain     URL of chain.json (required; nothing mounts without it)
+//   table     URL of table.json (optional; defaults to table.json beside chain)
+//   max-rows  rows rendered before the "show all" footer (default 500)
+class TamperSignalTableElement extends HTMLElement {
+  static get observedAttributes() {
+    return ["chain", "table", "max-rows"];
+  }
+
+  constructor() {
+    super();
+    this._handle = null;
+  }
+
+  connectedCallback() {
+    this._mount();
+  }
+
+  disconnectedCallback() {
+    this._unmount();
+  }
+
+  attributeChangedCallback() {
+    if (this.isConnected) this._mount();
+  }
+
+  // The mount handle, for hosts that want refresh()/destroy().
+  get table() {
+    return this._handle;
+  }
+
+  _unmount() {
+    if (this._handle) {
+      this._handle.destroy();
+      this._handle = null;
+    }
+  }
+
+  _mount() {
+    this._unmount();
+    const chain = this.getAttribute("chain");
+    if (!chain) return; // nothing to verify yet; attribute may arrive later
+    const tableUrl = this.getAttribute("table") || undefined;
+    const maxRows = Number(this.getAttribute("max-rows"));
+    this._handle = mountReceiptTable(this, chain, tableUrl, {
+      maxRows: Number.isFinite(maxRows) && maxRows > 0 ? maxRows : undefined,
+    });
+  }
+}
+
+if (typeof customElements !== "undefined" && !customElements.get("tamper-signal-table")) {
+  customElements.define("tamper-signal-table", TamperSignalTableElement);
+}
+
+export { TamperSignalTableElement };

package/node/cli.js

@@ -12,9 +12,11 @@
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import process from "node:process";
 
+import * as color from "./color.js";
 import { canonicalDocument, canonicalJsonBytes, semanticHash } from "./canonical.js";
 import {
   LOG_GRANULARITIES,
@@ -89,6 +91,9 @@ commands:
                                              final receipt); --bundle writes a
                                              verified zip (data + chain.json +
                                              receipts) for offline re-verification
+  assets [--out badge/]                      copy the bundled browser assets
+                                             (light.js, badge.js, element.js,
+                                             table.js, console.js) into a project
 `;
 
 // Shipped inside every verified bundle so a recipient can verify it without
@@ -181,6 +186,12 @@ function archivePriorChain(chainDir) {
   }
 }
 
+// Emit a structured payload on stdout (the established --json convention,
+// shared byte-for-byte with the Python CLI).
+function printJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
 // `ingest --as period`: continue the chain's run history under a trusted signer.
 function cmdIngestPeriod(values, file) {
   // Like replace, compute the unsnapshotted-reset condition and preserve the
@@ -205,19 +216,36 @@ function cmdIngestPeriod(values, file) {
     });
   } catch (err) {
     if (err instanceof UntrustedSignerError) {
-      console.error(`✗ Refusing to append a period: ${err.message}`);
+      if (values.json) printJson({ ok: false, error: `Refusing to append a period: ${err.message}` });
+      else console.error(`✗ Refusing to append a period: ${err.message}`);
       return 1;
     }
-    console.error(err.message);
+    if (values.json) printJson({ ok: false, error: err.message });
+    else console.error(err.message);
     return 1;
   }
   if (unsnapshottedReset) {
     console.error("warning: previous run was never verified; its totals will not enter history");
   }
   const totals = result.manifest.control_totals;
+  if (values.json) {
+    const caveats = result.caveats ?? [];
+    printJson({
+      source: result.manifest.source.filename,
+      evidence_hash: result.manifest.source.evidence_hash,
+      semantic_hash: result.manifest.semantic_hash,
+      row_count: totals.row_count,
+      column_count: totals.column_count,
+      mode: "period",
+      verdict: caveats.length ? "yellow" : "green",
+      caveats,
+      compared: Boolean(result.compared),
+    });
+    return caveats.length ? 2 : 0;
+  }
   console.log(`Imported next period: ${result.manifest.source.filename}`);
-  console.log(`  evidence_hash ${result.manifest.source.evidence_hash}`);
-  console.log(`  semantic_hash ${result.manifest.semantic_hash}`);
+  console.log(`  evidence_hash ${color.dim(result.manifest.source.evidence_hash)}`);
+  console.log(`  semantic_hash ${color.dim(result.manifest.semantic_hash)}`);
   console.log(`  rows ${totals.row_count}, columns ${totals.column_count}`);
   const grouped = groupedNumericColumns(result.records);
   if (grouped.length) {
@@ -255,6 +283,7 @@ function cmdIngest(args) {
       "bucket-column": { type: "string" },
       as: { type: "string", default: "replace" },
       pub: { type: "string", multiple: true, default: [] },
+      json: { type: "boolean", default: false },
     },
   });
   const file = positionals[0];
@@ -290,16 +319,29 @@ function cmdIngest(args) {
       bucketColumn: values["bucket-column"] ?? null,
     }));
   } catch (err) {
-    console.error(err.message);
+    if (values.json) printJson({ ok: false, error: err.message });
+    else console.error(err.message);
     return 1;
   }
   if (unsnapshottedReset) {
     console.error("warning: previous run was never verified; its totals will not enter history");
   }
   const totals = manifest.control_totals;
+  if (values.json) {
+    printJson({
+      source: manifest.source.filename,
+      evidence_hash: manifest.source.evidence_hash,
+      semantic_hash: manifest.semantic_hash,
+      row_count: totals.row_count,
+      column_count: totals.column_count,
+      tolerance: manifest.tolerance ?? null,
+      source_manifest: `${values.out.replace(/\/?$/, "/")}${SOURCE_RECEIPT_NAME}`,
+    });
+    return 0;
+  }
   console.log(`Ingested ${basename(file)}`);
-  console.log(`  evidence_hash ${manifest.source.evidence_hash}`);
-  console.log(`  semantic_hash ${manifest.semantic_hash}`);
+  console.log(`  evidence_hash ${color.dim(manifest.source.evidence_hash)}`);
+  console.log(`  semantic_hash ${color.dim(manifest.semantic_hash)}`);
   console.log(`  rows ${totals.row_count}, columns ${totals.column_count}`);
   if (manifest.tolerance) {
     const t = manifest.tolerance;
@@ -422,6 +464,9 @@ function cmdVerify(args) {
     };
     console.log(JSON.stringify(payload, null, 2));
   } else {
+    if (color.shouldColor()) {
+      console.log(`${color.light(result.verdict)} ${color.colorize(result.verdict.toUpperCase(), result.verdict)}`);
+    }
     for (const line of result.lines) console.log(line);
   }
   // Archive the run snapshot AFTER the final exit code settled: a red run
@@ -602,14 +647,14 @@ function renderStageDelta(delta) {
   for (const key of ["row_count", "column_count"]) {
     const entry = delta[key];
     if (entry) {
-      const suffix = "delta" in entry ? ` (${signedInt(entry.delta)})` : "";
+      const suffix = "delta" in entry ? ` (${color.signed(signedInt(entry.delta))})` : "";
       lines.push(`${key} ${entry.before} -> ${entry.after}${suffix}`);
     }
   }
   for (const [column, entry] of Object.entries(delta.numeric_sums ?? {})) {
     const before = entry.before !== null ? entry.before : "(added)";
     const after = entry.after !== null ? entry.after : "(removed)";
-    const suffix = "delta" in entry ? ` (${entry.delta})` : "";
+    const suffix = "delta" in entry ? ` (${color.signed(entry.delta)})` : "";
     lines.push(`${column} ${before} -> ${after}${suffix}`);
   }
   for (const [column, entry] of Object.entries(delta.null_counts ?? {})) {
@@ -1014,19 +1059,36 @@ function cmdLog(args) {
   const { rows, collapsed } = buildLogPeriods(items, granularity, metrics);
 
   if (values.json) {
-    const payload = {
-      granularity,
-      // Total runs collapsed away by the granularity. Ordered chronological
-      // (oldest first), matching the Python CLI byte-for-byte.
-      collapsed,
-      runs: rows.map((row, index) => ({
+    // The signed tolerance declaration is per-snapshot, display-only; surface
+    // it per run entry (omitted when that run declared none), matching Python.
+    const tolByTail = new Map();
+    for (const snapshot of snapshots) {
+      if (snapshot.tolerance && typeof snapshot.tolerance === "object") {
+        tolByTail.set(snapshot.chain_tail_hash, snapshot.tolerance);
+      }
+    }
+    const runEntry = (row, index) => {
+      const entry = {
         period: row.period,
         created_at: row.created_at,
         tail: row.tail ? row.tail.slice(0, 8) : null,
         unsigned: row.unsigned,
         metrics: logJsonMetrics(rows, index, metrics),
         breached: metrics.filter((m) => row.breached.has(m)).sort(),
-      })),
+      };
+      const tolerance = tolByTail.get(row.tail);
+      if (tolerance && typeof tolerance === "object") {
+        if (tolerance.band != null) entry.band = tolerance.band;
+        if (tolerance.settle_hours != null) entry.settle_hours = tolerance.settle_hours;
+      }
+      return entry;
+    };
+    const payload = {
+      granularity,
+      // Total runs collapsed away by the granularity. Ordered chronological
+      // (oldest first), matching the Python CLI byte-for-byte.
+      collapsed,
+      runs: rows.map(runEntry),
     };
     console.log(JSON.stringify(payload, null, 2));
     return 0;
@@ -1045,6 +1107,7 @@ function cmdExport(args) {
       data: { type: "string" },
       out: { type: "string" },
       bundle: { type: "boolean" },
+      json: { type: "boolean", default: false },
     },
   });
   const chainPath = positionals[0];
@@ -1062,11 +1125,13 @@ function cmdExport(args) {
   try {
     receipts = (chain.receipts ?? []).map((name) => readReceipt(chainDir, name));
   } catch (err) {
-    console.error(`Cannot load chain: ${err.message}`);
+    if (values.json) printJson({ ok: false, error: `Cannot load chain: ${err.message}` });
+    else console.error(`Cannot load chain: ${err.message}`);
     return 1;
   }
   if (!receipts.length) {
-    console.error("Chain is empty; nothing to export against.");
+    if (values.json) printJson({ ok: false, error: "Chain is empty; nothing to export against." });
+    else console.error("Chain is empty; nothing to export against.");
     return 1;
   }
 
@@ -1080,10 +1145,19 @@ function cmdExport(args) {
   const dataHash = createHash("sha256").update(canonicalJsonBytes(document)).digest("hex");
   const expected = outputHashOf(receipts[receipts.length - 1]);
   if (dataHash !== expected) {
-    console.error("✗ Refusing to export: the data does not match the final receipt.");
-    console.error(`  expected output hash ${expected}`);
-    console.error(`  found    data hash   ${dataHash}`);
-    console.error("  The Data tab only shows attested data. Re-run the pipeline or fix --data.");
+    if (values.json) {
+      printJson({
+        ok: false,
+        error: "the data does not match the final receipt",
+        expected_output_hash: expected,
+        data_hash: dataHash,
+      });
+    } else {
+      console.error("✗ Refusing to export: the data does not match the final receipt.");
+      console.error(`  expected output hash ${expected}`);
+      console.error(`  found    data hash   ${dataHash}`);
+      console.error("  The Data tab only shows attested data. Re-run the pipeline or fix --data.");
+    }
     return 1;
   }
 
@@ -1103,23 +1177,85 @@ function cmdExport(args) {
     const stem = dataName.replace(/\.[^.]+$/, "");
     const bundlePath = values.out || join(chainDir, `${stem}-verified.zip`);
     writeFileSync(bundlePath, makeStoredZip(entries));
+    if (values.json) {
+      printJson({
+        output: bundlePath,
+        data: dataName,
+        receipts: receiptNames.length,
+        data_hash: dataHash,
+        bundle: true,
+      });
+      return 0;
+    }
     console.log(`Exported verified bundle: ${bundlePath}`);
     console.log(`  data ${dataName}, ${receiptNames.length} receipts + ${CHAIN_FILENAME}`);
-    console.log(`  semantic_hash ${dataHash} (matches final receipt)`);
+    console.log(`  semantic_hash ${color.dim(dataHash)} (matches final receipt)`);
     console.log(`  recipient: unzip, then \`tamper-signal verify ${CHAIN_FILENAME}\``);
     return 0;
   }
 
   const outPath = values.out || join(chainDir, "table.json");
   writeFileSync(outPath, JSON.stringify(document, null, 2) + "\n");
+  if (values.json) {
+    printJson({
+      output: outPath,
+      row_count: document.rows.length,
+      column_count: document.headers.length,
+      data_hash: dataHash,
+      bundle: false,
+    });
+    return 0;
+  }
   console.log(`Exported verified table: ${outPath}`);
   console.log(`  rows ${document.rows.length}, columns ${document.headers.length}`);
-  console.log(`  semantic_hash ${dataHash} (matches final receipt)`);
+  console.log(`  semantic_hash ${color.dim(dataHash)} (matches final receipt)`);
+  return 0;
+}
+
+// The browser assets ship in the package's badge/ directory (see package.json
+// "files"). Mirror the Python `receipts assets`: copy them into a project so an
+// integrator never has to dig them out of node_modules by hand.
+const ASSET_NAMES = ["light.js", "badge.js", "element.js", "table.js", "console.js"];
+
+function cmdAssets(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      out: { type: "string" },
+      json: { type: "boolean", default: false },
+    },
+  });
+  const srcDir = join(dirname(fileURLToPath(import.meta.url)), "..", "badge");
+  const outDir = values.out || "badge/";
+  const copied = [];
+  mkdirSync(outDir, { recursive: true });
+  for (const name of ASSET_NAMES) {
+    const src = join(srcDir, name);
+    if (!existsSync(src)) continue;
+    copyFileSync(src, join(outDir, name));
+    copied.push(name);
+  }
+  if (!copied.length) {
+    if (values.json) printJson({ ok: false, error: "No bundled browser assets found in the package." });
+    else console.error("No bundled browser assets found in the package.");
+    return 1;
+  }
+  if (values.json) {
+    printJson({ out: outDir, files: copied });
+    return 0;
+  }
+  console.log(`Copied ${copied.length} browser assets into ${outDir}`);
+  for (const name of copied) console.log(`  ${name}`);
+  console.log(`Import them at the path you serve them, e.g. "/${basename(outDir.replace(/\/+$/, ""))}/light.js".`);
   return 0;
 }
 
-const [, , command, ...rest] = process.argv;
-const commands = { keygen: cmdKeygen, ingest: cmdIngest, verify: cmdVerify, diff: cmdDiff, log: cmdLog, export: cmdExport };
+const [, , command, ...rawRest] = process.argv;
+// --no-color is global: honor it at any position and strip it so each command's
+// strict parser does not reject it. NO_COLOR / FORCE_COLOR env are honored too.
+if (rawRest.includes("--no-color")) color.setNoColor(true);
+const rest = rawRest.filter((arg) => arg !== "--no-color");
+const commands = { keygen: cmdKeygen, ingest: cmdIngest, verify: cmdVerify, diff: cmdDiff, log: cmdLog, export: cmdExport, assets: cmdAssets };
 if (!command || !(command in commands)) {
   console.error(USAGE);
   process.exit(command ? 1 : 0);

package/node/color.js

@@ -0,0 +1,78 @@
+// Terminal color for the human-facing CLI: the Node port of tamper_signal/color.py.
+// Presentation layer only. Color is emitted to stdout only when it is an
+// interactive terminal and no override turns it off; every primitive returns
+// plain text when color is off, so the word and glyph survive without ANSI.
+//
+// Gating precedence (highest first):
+//   1. --no-color flag (setNoColor)               -> off
+//   2. NO_COLOR env present (any value)           -> off
+//   3. FORCE_COLOR env present                    -> on
+//   4. otherwise                                  -> stream.isTTY
+// NO_COLOR wins over FORCE_COLOR. shouldColor is only evaluated against stdout;
+// stderr (notices) and --json output are always plain.
+
+// SGR codes. Kept identical to tamper_signal/color.py so the two CLIs match.
+export const RESET = "\x1b[0m";
+export const DIM = "\x1b[2m";
+export const BOLD = "\x1b[1m";
+export const GREEN = "\x1b[32m";
+export const YELLOW = "\x1b[33m";
+export const RED = "\x1b[31m";
+
+// "amber" names the color; the verdict value stays "yellow".
+const VERDICT_COLOR = { green: GREEN, yellow: YELLOW, red: RED };
+
+// Set by the CLI when --no-color is passed. Always wins over the environment.
+let noColor = false;
+
+export function setNoColor(value) {
+  noColor = Boolean(value);
+}
+
+export function shouldColor(stream = process.stdout) {
+  if (noColor) return false;
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.FORCE_COLOR !== undefined) return true;
+  return Boolean(stream && stream.isTTY);
+}
+
+function paint(text, code, stream) {
+  return shouldColor(stream) ? `${code}${text}${RESET}` : text;
+}
+
+// Dim secondary detail (hashes, counts) when color is on.
+export function dim(text, stream = process.stdout) {
+  return paint(text, DIM, stream);
+}
+
+export function bold(text, stream = process.stdout) {
+  return paint(text, BOLD, stream);
+}
+
+// The colored traffic-light glyph for a verdict ("green"/"yellow"/"red").
+// The caller prints the verdict word alongside it, so meaning survives color-off.
+export function light(verdict, stream = process.stdout) {
+  return paint("●", VERDICT_COLOR[verdict] ?? "", stream);
+}
+
+// Paint text in a verdict's color ("green"/"yellow"/"red").
+export function colorize(text, verdict, stream = process.stdout) {
+  return paint(text, VERDICT_COLOR[verdict] ?? "", stream);
+}
+
+// Color a pre-formatted signed token by its sign (+green, -red).
+export function signed(token, stream = process.stdout) {
+  const text = String(token);
+  if (text.startsWith("+")) return paint(text, GREEN, stream);
+  if (text.startsWith("-")) return paint(text, RED, stream);
+  return text;
+}
+
+// A signed movement value, colored by direction (increase green, decrease red).
+// The sign is always printed, so direction reads without color and for
+// colorblind users. Direction is a neutral cue, not a verdict.
+export function delta(value, stream = process.stdout) {
+  if (value > 0) return paint(`+${value}`, GREEN, stream);
+  if (value < 0) return paint(`${value}`, RED, stream);
+  return "0";
+}

package/node/test/cli_color.test.js

@@ -0,0 +1,87 @@
+// Node CLI color application and gating (U6): the colored verdict headline and
+// the NO_COLOR / FORCE_COLOR / --no-color gate, mirroring tests/test_cli_color.py.
+// Color is gated to a TTY, so these force it on with FORCE_COLOR (the pipe from
+// execFileSync is not a TTY) and assert plain output when it is off.
+
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+
+import { GREEN, RESET } from "../color.js";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const cli = join(repoRoot, "node", "cli.js");
+
+function run(cwd, args, env = {}) {
+  // Start from a clean slate: NO_COLOR / FORCE_COLOR only present when a test
+  // sets them (a key set to undefined would stringify to "undefined").
+  const base = { ...process.env, TAMPER_SIGNAL_KEY: "" };
+  delete base.NO_COLOR;
+  delete base.FORCE_COLOR;
+  return execFileSync(process.execPath, [cli, ...args], { cwd, env: { ...base, ...env }, encoding: "utf-8" });
+}
+
+function seedChain() {
+  const dir = mkdtempSync(join(tmpdir(), "tamper-signal-color-"));
+  run(dir, ["keygen", "--out", "keys"]);
+  writeFileSync(join(dir, "d.csv"), "day,amount\n2026-05-01,10\n");
+  run(dir, ["ingest", "d.csv"]);
+  return dir;
+}
+
+test("verify headline is a colored light under FORCE_COLOR", () => {
+  const dir = seedChain();
+  const out = run(dir, ["verify", "receipts/chain.json"], { FORCE_COLOR: "1" });
+  assert.ok(out.includes(`${GREEN}●${RESET}`));
+  assert.ok(out.includes(`${GREEN}GREEN${RESET}`));
+  assert.ok(out.includes("CHAIN INTACT"));
+});
+
+test("verify piped is plain text with no ANSI", () => {
+  const dir = seedChain();
+  const out = run(dir, ["verify", "receipts/chain.json"]);
+  assert.ok(!out.includes("\x1b"));
+  assert.ok(out.includes("CHAIN INTACT"));
+});
+
+test("--no-color beats FORCE_COLOR", () => {
+  const dir = seedChain();
+  const out = run(dir, ["verify", "receipts/chain.json", "--no-color"], { FORCE_COLOR: "1" });
+  assert.ok(!out.includes("\x1b"));
+});
+
+test("NO_COLOR beats FORCE_COLOR", () => {
+  const dir = seedChain();
+  const out = run(dir, ["verify", "receipts/chain.json"], { FORCE_COLOR: "1", NO_COLOR: "1" });
+  assert.ok(!out.includes("\x1b"));
+});
+
+// The acceptance gate (R16): ANSI must never leak into --json, even with color
+// forced on. Mirrors tests/test_cli_json_gate.py (node has no doctor command).
+test("no ANSI leaks into --json even under FORCE_COLOR", () => {
+  const dir = mkdtempSync(join(tmpdir(), "tamper-signal-gate-"));
+  run(dir, ["keygen", "--out", "keys"]);
+  writeFileSync(join(dir, "d.csv"), "day,amount\n2026-05-01,10\n");
+  run(dir, ["ingest", "d.csv"]);
+  run(dir, ["verify", "receipts/chain.json"]);
+  writeFileSync(join(dir, "d.csv"), "day,amount\n2026-05-01,10\n2026-05-02,20\n");
+  run(dir, ["ingest", "d.csv"]);
+  run(dir, ["verify", "receipts/chain.json"]);
+
+  const commands = [
+    ["verify", "receipts/chain.json", "--json"],
+    ["log", "--chain", "receipts/", "--json"],
+    ["diff", "--json"],
+    ["export", "receipts/chain.json", "--data", "d.csv", "--json"],
+    ["ingest", "d.csv", "--json"],
+  ];
+  for (const args of commands) {
+    const out = run(dir, args, { FORCE_COLOR: "1" });
+    assert.ok(!out.includes("\x1b"), `ANSI leaked into --json of ${args[0]}`);
+    JSON.parse(out);
+  }
+});

package/node/test/color.test.js

@@ -0,0 +1,90 @@
+// Mirrors tests/test_color.py: the gating matrix plus verdict/delta conventions.
+// Also asserts the SGR palette matches the Python helper byte for byte (pins R15).
+
+import { test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import { setNoColor, shouldColor, light, delta, dim, bold, GREEN, YELLOW, RED, DIM, BOLD, RESET } from "../color.js";
+
+const TTY = { isTTY: true };
+const PIPE = { isTTY: false };
+
+beforeEach(() => {
+  delete process.env.NO_COLOR;
+  delete process.env.FORCE_COLOR;
+  setNoColor(false);
+});
+
+test("shouldColor: true on a TTY with no overrides", () => {
+  assert.equal(shouldColor(TTY), true);
+});
+
+test("shouldColor: false when not a TTY", () => {
+  assert.equal(shouldColor(PIPE), false);
+});
+
+test("shouldColor: NO_COLOR wins even on a TTY (any value)", () => {
+  process.env.NO_COLOR = "1";
+  assert.equal(shouldColor(TTY), false);
+  process.env.NO_COLOR = "";
+  assert.equal(shouldColor(TTY), false);
+});
+
+test("shouldColor: --no-color flag wins even on a TTY", () => {
+  setNoColor(true);
+  assert.equal(shouldColor(TTY), false);
+});
+
+test("shouldColor: FORCE_COLOR turns on even when piped", () => {
+  process.env.FORCE_COLOR = "1";
+  assert.equal(shouldColor(PIPE), true);
+});
+
+test("shouldColor: NO_COLOR beats FORCE_COLOR", () => {
+  process.env.NO_COLOR = "1";
+  process.env.FORCE_COLOR = "1";
+  assert.equal(shouldColor(TTY), false);
+});
+
+test("light: colors each verdict when on", () => {
+  process.env.FORCE_COLOR = "1";
+  assert.equal(light("green", PIPE), `${GREEN}●${RESET}`);
+  assert.equal(light("yellow", PIPE), `${YELLOW}●${RESET}`);
+  assert.equal(light("red", PIPE), `${RED}●${RESET}`);
+});
+
+test("light: plain glyph when off", () => {
+  assert.equal(light("green", PIPE), "●");
+  assert.ok(!light("red", PIPE).includes("\x1b"));
+});
+
+test("delta: signs and colors direction when on", () => {
+  process.env.FORCE_COLOR = "1";
+  assert.equal(delta(12, PIPE), `${GREEN}+12${RESET}`);
+  assert.equal(delta(-5, PIPE), `${RED}-5${RESET}`);
+  assert.equal(delta(0, PIPE), "0");
+});
+
+test("delta: keeps sign when color off", () => {
+  assert.equal(delta(12, PIPE), "+12");
+  assert.equal(delta(-5, PIPE), "-5");
+  assert.ok(!delta(12, PIPE).includes("\x1b"));
+});
+
+test("dim/bold wrap only when on", () => {
+  assert.equal(dim("abc", PIPE), "abc");
+  assert.equal(bold("abc", PIPE), "abc");
+  process.env.FORCE_COLOR = "1";
+  assert.equal(dim("abc", PIPE), `${DIM}abc${RESET}`);
+  assert.equal(bold("abc", PIPE), `${BOLD}abc${RESET}`);
+});
+
+// Cross-stack palette parity: these MUST equal tamper_signal/color.py's codes.
+test("palette parity: SGR codes match the Python helper", () => {
+  assert.equal(GREEN, "\x1b[32m");
+  assert.equal(YELLOW, "\x1b[33m");
+  assert.equal(RED, "\x1b[31m");
+  assert.equal(DIM, "\x1b[2m");
+  assert.equal(BOLD, "\x1b[1m");
+  assert.equal(RESET, "\x1b[0m");
+});

package/node/test/json_surface.test.js

@@ -0,0 +1,87 @@
+// `tamper-signal ingest --json` and `export --json` (U4): the machine surface
+// added in 1.7.1. Mirrors the Python tests in tests/test_cli_agent_ergonomics.py;
+// payload keys must match the Python CLI byte for byte (R5). Driven through the
+// real CLI via execFileSync so the captured stdout is exactly what ships.
+
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const cli = join(repoRoot, "node", "cli.js");
+
+function runCli(cwd, args, { expectFail = false } = {}) {
+  const env = { ...process.env, TAMPER_SIGNAL_KEY: "" };
+  try {
+    return { stdout: execFileSync(process.execPath, [cli, ...args], { cwd, env, encoding: "utf-8" }), stderr: "", status: 0 };
+  } catch (err) {
+    if (!expectFail) throw err;
+    return { stdout: err.stdout ?? "", stderr: err.stderr ?? "", status: err.status ?? 1 };
+  }
+}
+
+function seedChain() {
+  const dir = mkdtempSync(join(tmpdir(), "tamper-signal-json-"));
+  runCli(dir, ["keygen", "--out", "keys"]);
+  writeFileSync(join(dir, "data.csv"), "day,amount\n2026-05-01,10\n2026-05-02,20\n");
+  return dir;
+}
+
+test("ingest --json emits a structured result", () => {
+  const dir = seedChain();
+  const payload = JSON.parse(runCli(dir, ["ingest", "data.csv", "--json"]).stdout);
+  assert.equal(payload.source, "data.csv");
+  assert.equal(payload.row_count, 2);
+  assert.equal(payload.column_count, 2);
+  assert.equal(payload.tolerance, null);
+  assert.ok(payload.semantic_hash);
+  assert.ok(payload.source_manifest.endsWith("000_source.json"));
+  // Pinned key set: must equal the Python ingest --json payload (R5).
+  assert.deepEqual(
+    Object.keys(payload).sort(),
+    ["column_count", "evidence_hash", "row_count", "semantic_hash", "source", "source_manifest", "tolerance"],
+  );
+});
+
+test("ingest --json includes a declared tolerance", () => {
+  const dir = seedChain();
+  const payload = JSON.parse(runCli(dir, ["ingest", "data.csv", "--band", "5%", "--settle", "72h", "--json"]).stdout);
+  assert.equal(payload.tolerance.band, "0.05");
+  assert.equal(payload.tolerance.settle_hours, 72);
+});
+
+test("export --json writes a table result", () => {
+  const dir = seedChain();
+  runCli(dir, ["ingest", "data.csv"]);
+  const payload = JSON.parse(runCli(dir, ["export", "receipts/chain.json", "--data", "data.csv", "--json"]).stdout);
+  assert.equal(payload.bundle, false);
+  assert.ok(payload.output.endsWith("table.json"));
+  assert.ok(payload.data_hash);
+  assert.equal(payload.row_count, 2);
+  // Pinned key set: must equal the Python export --json payload (R5).
+  assert.deepEqual(Object.keys(payload).sort(), ["bundle", "column_count", "data_hash", "output", "row_count"]);
+});
+
+test("export --bundle --json reports the bundle", () => {
+  const dir = seedChain();
+  runCli(dir, ["ingest", "data.csv"]);
+  const payload = JSON.parse(runCli(dir, ["export", "receipts/chain.json", "--data", "data.csv", "--bundle", "--json"]).stdout);
+  assert.equal(payload.bundle, true);
+  assert.ok(payload.receipts >= 1);
+  assert.ok(payload.output.endsWith("-verified.zip"));
+});
+
+test("export --json gives a structured error on mismatch (clean stdout)", () => {
+  const dir = seedChain();
+  runCli(dir, ["ingest", "data.csv"]);
+  writeFileSync(join(dir, "wrong.csv"), "x\n1\n");
+  const res = runCli(dir, ["export", "receipts/chain.json", "--data", "wrong.csv", "--json"], { expectFail: true });
+  assert.equal(res.status, 1);
+  const payload = JSON.parse(res.stdout);
+  assert.equal(payload.ok, false);
+  assert.match(payload.error, /match/);
+});

package/node/test/log.test.js

@@ -233,3 +233,15 @@ test("log renders a real built history end to end", () => {
   assert.ok(payload.runs.length >= 1);
   assert.ok(payload.runs.every((r) => r.unsigned === false));
 });
+
+test("log --json surfaces band/settle per run, only where declared", () => {
+  const s0 = snapshot({ createdAt: "2026-05-01T00:00:00Z", rowCount: 100, tail: "aa".repeat(32) });
+  const s1 = snapshot({ createdAt: "2026-05-02T00:00:00Z", rowCount: 110, tail: "bb".repeat(32) });
+  s1.tolerance = { band: "0.05", settle_hours: 72, bucket_column: "day" };
+  const receipts = writeHistory([s0, s1]);
+
+  const runs = JSON.parse(runLog(receipts, ["--json"]).stdout).runs; // oldest first
+  assert.ok(!("band" in runs[0]) && !("settle_hours" in runs[0]));
+  assert.equal(runs[1].band, "0.05");
+  assert.equal(runs[1].settle_hours, 72);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamper-signal",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Signed receipts for vibe-coded data pipelines. Proves nobody changed your data, and shows the exact link if they did.",
   "type": "module",
   "license": "MIT",
@@ -64,7 +64,7 @@
     "AGENTS.md"
   ],
   "scripts": {
-    "test": "node --test node/test/badge.test.js node/test/canonical.test.js node/test/chain.test.js node/test/interop.test.js node/test/express.test.js node/test/totals.test.js node/test/pipeline.test.js node/test/history.test.js node/test/diff.test.js node/test/log.test.js node/test/judgment.test.js node/test/theme.test.js node/test/zip.test.js node/test/append_period.test.js"
+    "test": "node --test node/test/badge.test.js node/test/canonical.test.js node/test/chain.test.js node/test/interop.test.js node/test/express.test.js node/test/totals.test.js node/test/pipeline.test.js node/test/history.test.js node/test/diff.test.js node/test/log.test.js node/test/judgment.test.js node/test/theme.test.js node/test/zip.test.js node/test/append_period.test.js node/test/color.test.js node/test/json_surface.test.js node/test/cli_color.test.js"
   },
   "engines": {
     "node": ">=18.17"