@rel-time/mcp-server 1.2.7 → 1.2.8

package/README.md

@@ -6,7 +6,8 @@ Official Model Context Protocol (MCP) server for **[Rel-Time](https://rel-time.c
 3. **Anchor SHA-256 hashes to the Bitcoin Timechain & Rel-Time VDF** (`POST /v1/anchor`).
 4. **Generate & overlay 64-ray Sun-Stamps onto PDFs and Images** (`reltime-stamped-<name>.pdf` / `.png`).
 5. **Verify Bitcoin block settlement & Merkle proofs** (`GET /v1/proof/{hash}`).
-6. **Self-provision or Reload (+500 Hash Credits / $50) an Autonomous Agent API key via Lightning** (`POST /v1/agent/invoice` & `POST /v1/agent/claim`).
+6. **Self-provision or Reload all 4 Rel-Time Tiers via Bitcoin Lightning or Stripe Card** (`Universal Anchor $3`, `Agent Launch Pack $5 / 50`, `Autonomous Agents $50 / 500`, and `Rel-Time Superhighway $600 / 5,000`).
+7. **Run a Superhighway Cryptographic Audit Trail & Local Folder Integrity Check** (`reltime_audit_trail`), generating an interactive HTML Audit Dashboard with Corporate Hardware Passkey (`signer_public_key`) attribution and Bitcoin block verification.
 
 ---
 
@@ -25,11 +26,13 @@ Add the following to your `.mcp.json`, `claude_desktop_config.json`, or `.cursor
 }
 ```
 
-When you start a fresh chat and ask to anchor a file or provision a key, `@rel-time/mcp-server` automatically prompts your agent to ask which pack you want first:
-1. **Agent Launch Pack (`pack: "launch"`, `$5 / 50 Hashes`):** Priority 10-Minute Bitcoin Queue · Standard Mode only (Data Integrity + Biometric or Anonymous) · Includes 64-Ray Sun-Stamp, 1-Click Stamped Copy (`.PDF`/`.PNG`), and `.JSON` Doomsday Proof.
-2. **Autonomous Agents (`pack: "standard"`, `$50 / 500 Hashes`):** Dynamic 6-Hour Batch Queue · Supports both Temporal Mode (`T_index` sub-second VDF sequencing) and Standard Mode · Reloadable anytime (`+500` credits / `$50`).
+When you start a fresh chat and ask to anchor a file or provision a key, `@rel-time/mcp-server` automatically prompts your agent to ask which tier and payment method (**Bitcoin Lightning** or **Stripe Card**) you want first:
+1. **Universal Anchor (`pack: "universal"`, `$3 / anchor`):** Priority 10-Minute Bitcoin Queue · Standard Mode (Data Integrity + Biometric or Anonymous).
+2. **Agent Launch Pack (`pack: "launch"`, `$5 / 50 Hashes`):** Priority 10-Minute Bitcoin Queue · Standard Mode · Includes 64-Ray Sun-Stamp, 1-Click Stamped Copy (`.PDF`/`.PNG`), and `.JSON` Doomsday Proof.
+3. **Autonomous Agents (`pack: "standard"`, `$50 / 500 Hashes`):** Dynamic 6-Hour Batch Queue · Supports both Temporal Mode (`T_index` sub-second VDF sequencing) and Standard Mode · Reloadable anytime (`+500` credits / `$50`).
+4. **Rel-Time Superhighway (`pack: "enterprise"`, `$600 / 5,000 Hashes`):** Priority 10-Minute Bitcoin Queue · Temporal Mode (`T_index`) + Standard Mode + Bulk Folder & Superhighway Audit Dashboard.
 
-Once paid via Lightning (or if you pass an existing `rel_key_...` key), the MCP server automatically saves your API key to `~/.reltime/api_key.json` (`0600` permissions) — no app restart or `.zshrc` edits required.
+Once paid via Lightning or Stripe (or if you pass an existing `rel_key_...` key), the MCP server automatically saves your API key to `~/.reltime/api_key.json` (`0600` permissions) — no app restart or `.zshrc` edits required.
 
 ---
 
@@ -37,11 +40,12 @@ Once paid via Lightning (or if you pass an existing `rel_key_...` key), the MCP
 
 | Tool Name | Requires Key? | What It Does |
 | :--- | :---: | :--- |
-| `reltime_anchor_file` | Yes | Computes the SHA-256 hash of a local file **on your machine** (0 bytes uploaded), supports `biometric: true` for **Biometric Anchors** (TouchID/FaceID/YubiKey), anchors via `POST /v1/anchor`, saves `reltime-stamp-<filename>.svg` and `reltime-doomsday-proof-<filename>.json`, and automatically outputs a **Stamped Copy** (`reltime-stamped-<name>.pdf` or `.png`). |
+| `reltime_anchor_file` | Yes | Computes the SHA-256 hash of a local file **on your machine** (0 bytes uploaded), supports `biometric: true` for **Biometric Anchors** (TouchID/FaceID/YubiKey), anchors via `POST /v1/anchor`, saves `reltime-stamp-<filename>.svg` and `reltime-doomsday-proof-<filename>.json`, and automatically outputs a clickable **Stamped Copy** (`reltime-stamped-<name>.pdf` or `.png`). |
+| `reltime_audit_trail` | Yes | Fetches the account's chronological anchor ledger (`GET /v1/account/history`), aggregates Bitcoin block settlements, VDF `T_index` ticks, and Corporate Hardware Passkey (`signer_public_key`) signatures, optionally verifies a local file or entire folder bit-for-bit (`verify_local_path`), and spins up a self-contained interactive HTML Audit Report (`reltime-audit-report-*.html`) in your browser. |
 | `reltime_link_passkey` | **No** | Opens `https://rel-time.com/mcp-passkey` in the system browser so the user can touch TouchID / FaceID / YubiKey once, saving `{ public_key_hex, passkey_signature }` to `~/.reltime/passkey.json` for seamless Biometric Anchors. |
 | `reltime_stamp_file` | **No** | Overlays the authentic 64-ray Sun-Stamp onto the bottom-right corner of any local PDF or Image (`.png`, `.jpg`, `.jpeg`, `.webp`, `.gif`) 100% locally. |
 | `reltime_anchor_hash` | Yes | Anchors any 64-char hex SHA-256 hash in `standard` (10-min Express / Integrity) or `temporal` (VDF sequence ordering) mode. |
 | `reltime_get_sun_stamp` | **No** | Fetches the deterministic 64-ray SVG Sun-Stamp (`GET /v1/stamp/{hash}`) and returns ready-to-paste Markdown/HTML badge snippets. |
 | `reltime_check_proof` | **No** | Queries `GET /v1/proof/{hash}` for Bitcoin TXID, Block Height, UTC Timestamp, and Merkle inclusion path, and optionally saves/updates the `.json` Doomsday Proof receipt on disk. |
 | `reltime_account_status` | Yes | Checks remaining Hash Credits and tier status (`GET /v1/account`). |
-| `reltime_provision_agent_key` | **No** | Generates a Lightning invoice (`$50` for 500 Hash Credits) and claims either a brand-new Tier 4 Autonomous Agent API key or **reloads `+500` Hash Credits into an existing key** (`reload_existing: true` or `api_key`). |
+| `reltime_provision_agent_key` | **No** | Provisions or reloads any of the 4 Rel-Time Tiers (`universal` `$3`, `launch` `$5/50`, `standard` `$50/500`, `enterprise` `$600/5,000`) via **Bitcoin Lightning** or **Stripe Card**. |

package/index.js

@@ -56,7 +56,7 @@ let LAST_INVOICE_PACK = null;
 
 const SERVER_INFO = {
   name: "rel-time-mcp-server",
-  version: "1.2.7",
+  version: "1.2.8",
 };
 
 /**
@@ -477,6 +477,629 @@ async function stampLocalFileOptionA(filePath, svgContent, customOutputPath = nu
   }
 }
 
+/**
+ * Extracts an embedded Rel-Time verification hash from a Stamped Copy (.png or .pdf) if present.
+ */
+function extractStampedCopyEmbeddedHash(filePath, fileBuffer) {
+  try {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".png" || ext === ".pdf" || ext === ".svg") {
+      const latin1 = fileBuffer.toString("latin1");
+      const m = latin1.match(/rel-time\.com\/verify\?t=([0-9a-fA-F]{64})/);
+      if (m && m[1]) {
+        return m[1].toLowerCase();
+      }
+    }
+  } catch (e) {
+    // Ignore extraction errors
+  }
+  return null;
+}
+
+function escapeHtml(str) {
+  return String(str == null ? "" : str)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+/**
+ * Generates a self-contained, interactive Rel-Time Superhighway Cryptographic Audit Trail HTML report.
+ */
+function generateAuditReportHtml(audit) {
+  const generatedUtc = audit.generated_at_utc || new Date().toISOString();
+  const acct = audit.account_overview || {};
+  const sum = audit.audit_summary || {};
+  const modes = sum.mode_breakdown || {};
+  const btc = sum.bitcoin_settlement || {};
+  const signers = Array.isArray(sum.hardware_passkey_signers) ? sum.hardware_passkey_signers : [];
+  const localCheck = audit.local_path_verification || null;
+  const entries = Array.isArray(audit.audit_trail) ? audit.audit_trail : [];
+
+  const signerRowsHtml = signers.length
+    ? signers
+        .map(
+          (s, idx) => `
+        <tr>
+          <td class="mono">#${idx + 1}</td>
+          <td>
+            <span class="badge badge-passkey">FIDO2 / WebAuthn Hardware Key</span>
+            <div class="mono hash-full" style="margin-top:4px">${escapeHtml(s.signer_public_key)}</div>
+          </td>
+          <td class="mono" style="font-weight:700;color:#F5B041">${s.anchor_count}</td>
+          <td class="mono" style="color:#2ECC71">${s.settled_count}</td>
+          <td class="mono">${escapeHtml(s.latest_timestamp_utc || "—")}</td>
+        </tr>`
+        )
+        .join("")
+    : `<tr><td colspan="5" style="text-align:center;color:#8892b0;padding:18px">No hardware Passkey signatures recorded yet in this window. Link a passkey with <code>reltime_link_passkey</code> and anchor with <code>biometric: true</code>.</td></tr>`;
+
+  const localVerificationHtml = localCheck
+    ? `
+    <div class="section-card">
+      <div class="section-header">
+        <div>
+          <h2>Local File &amp; Folder Integrity Audit</h2>
+          <p class="section-sub">Target Path: <span class="mono">${escapeHtml(localCheck.target_path)}</span> · Zero-Knowledge Local SHA-256 Cross-Reference</p>
+        </div>
+        <span class="badge ${
+          localCheck.summary.unanchored_or_modified_count === 0 ? "badge-settled" : "badge-warn"
+        }">
+          ${
+            localCheck.summary.unanchored_or_modified_count === 0
+              ? `100% INTACT (${localCheck.summary.total_files_scanned} Verified)`
+              : `${localCheck.summary.unanchored_or_modified_count} UNANCHORED / MODIFIED`
+          }
+        </span>
+      </div>
+      <div class="table-wrap">
+        <table>
+          <thead>
+            <tr>
+              <th>File</th>
+              <th>Size</th>
+              <th>Local SHA-256 / Embedded Hash</th>
+              <th>Integrity Status</th>
+              <th>Mode / Signer</th>
+              <th>Bitcoin Settlement</th>
+              <th>Proof</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${localCheck.files
+              .map((f) => {
+                const statusBadge =
+                  f.integrity_status === "VERIFIED_SETTLED"
+                    ? `<span class="badge badge-settled">✓ VERIFIED (BITCOIN SETTLED)</span>`
+                    : f.integrity_status === "VERIFIED_PENDING"
+                    ? `<span class="badge badge-pending">⏳ VERIFIED (PENDING BLOCK)</span>`
+                    : `<span class="badge badge-warn">⚠ UNANCHORED OR MODIFIED</span>`;
+                const signerText = f.signer_public_key
+                  ? `<span class="badge badge-passkey" title="${escapeHtml(f.signer_public_key)}">Passkey ${escapeHtml(
+                      f.signer_public_key.slice(0, 10)
+                    )}…</span>`
+                  : `<span class="mono" style="color:#94a3b8">${escapeHtml(f.anchor_mode || "—")}</span>`;
+                const btcText = f.block_height
+                  ? `<span class="mono" style="color:#2ECC71">Block #${escapeHtml(f.block_height)}</span>`
+                  : f.integrity_status === "VERIFIED_PENDING"
+                  ? `<span class="mono" style="color:#F5B041">Awaiting Next Block</span>`
+                  : `—`;
+                const verifyLink = f.verify_url
+                  ? `<a class="btn-link" href="${escapeHtml(f.verify_url)}" target="_blank" rel="noopener">Verify ↗</a>`
+                  : `—`;
+                return `
+                <tr>
+                  <td style="font-weight:600;color:#f8fafc">${escapeHtml(f.file_name)}${
+                  f.is_stamped_copy ? ` <span class="badge badge-mode">Stamped Copy</span>` : ""
+                }</td>
+                  <td class="mono">${escapeHtml(f.size_human)}</td>
+                  <td class="mono hash-cell" title="${escapeHtml(f.local_sha256)}">${escapeHtml(
+                  f.local_sha256.slice(0, 16)
+                )}…${escapeHtml(f.local_sha256.slice(-8))}</td>
+                  <td>${statusBadge}</td>
+                  <td>${signerText}</td>
+                  <td>${btcText}</td>
+                  <td>${verifyLink}</td>
+                </tr>`;
+              })
+              .join("")}
+          </tbody>
+        </table>
+      </div>
+    </div>`
+    : "";
+
+  const ledgerRowsHtml = entries.length
+    ? entries
+        .map((e, idx) => {
+          const isSettled = e.status === "settled";
+          const isBiometric = Boolean(e.signer_public_key);
+          const modeType = e.anchor_mode || "standard";
+          const filterClasses = [
+            isSettled ? "status-settled" : "status-pending",
+            `mode-${modeType}`,
+            isBiometric ? "mode-biometric" : "",
+          ]
+            .filter(Boolean)
+            .join(" ");
+
+          const statusHtml = isSettled
+            ? `<span class="badge badge-settled">✓ SETTLED</span>`
+            : `<span class="badge badge-pending">⏳ PENDING FINALITY</span>`;
+
+          const modeHtml = `
+            <span class="badge badge-mode">${escapeHtml(modeType.toUpperCase())}</span>
+            ${
+              isBiometric
+                ? `<span class="badge badge-passkey" title="Signed by Passkey: ${escapeHtml(
+                    e.signer_public_key
+                  )}">🔐 Passkey ${escapeHtml(e.signer_public_key.slice(0, 8))}…</span>`
+                : ""
+            }
+          `;
+
+          const btcHtml = isSettled
+            ? `
+              <div class="mono" style="color:#2ECC71;font-weight:600">Block #${escapeHtml(e.block_height || "—")}</div>
+              ${
+                e.txid
+                  ? `<a class="mono tx-link" href="https://mempool.space/tx/${escapeHtml(
+                      e.txid
+                    )}" target="_blank" rel="noopener" title="${escapeHtml(e.txid)}">TX: ${escapeHtml(
+                      e.txid.slice(0, 10)
+                    )}…${escapeHtml(e.txid.slice(-6))} ↗</a>`
+                  : ""
+              }
+            `
+            : `<span class="mono" style="color:#94a3b8">Queued in VDF Batch</span>`;
+
+          return `
+          <tr class="ledger-row ${filterClasses}" data-search="${escapeHtml(
+            `${e.client_hash} ${e.t_index} ${e.original_file_hash || ""} ${e.signer_public_key || ""} ${
+              e.txid || ""
+            } ${e.block_height || ""} ${modeType}`.toLowerCase()
+          )}">
+            <td class="mono" style="color:#64748b">#${idx + 1}</td>
+            <td class="mono">${escapeHtml(e.timestamp_utc || "—")}</td>
+            <td>${statusHtml}</td>
+            <td>${modeHtml}</td>
+            <td class="mono hash-cell" title="Client Hash: ${escapeHtml(e.client_hash)}${
+            e.original_file_hash ? ` | Original File SHA-256: ${escapeHtml(e.original_file_hash)}` : ""
+          }">
+              <div>${escapeHtml(e.client_hash.slice(0, 14))}…${escapeHtml(e.client_hash.slice(-8))}</div>
+              ${
+                e.original_file_hash
+                  ? `<div style="font-size:11px;color:#94a3b8">File: ${escapeHtml(
+                      e.original_file_hash.slice(0, 10)
+                    )}…</div>`
+                  : ""
+              }
+            </td>
+            <td class="mono hash-cell" title="T_index: ${escapeHtml(e.t_index)} | Solar Ticks: ${escapeHtml(
+            e.vdf_ticks
+          )}">
+              <div>${escapeHtml(e.t_index.slice(0, 12))}…${escapeHtml(e.t_index.slice(-6))}</div>
+              <div style="font-size:11px;color:#F5B041">Ticks: ${ Number(e.vdf_ticks || 0).toLocaleString() }</div>
+            </td>
+            <td>${btcHtml}</td>
+            <td>
+              <a class="btn-link" href="${escapeHtml(e.verify_url)}" target="_blank" rel="noopener">Verify ↗</a>
+            </td>
+          </tr>`;
+        })
+        .join("")
+    : `<tr><td colspan="8" style="text-align:center;color:#8892b0;padding:24px">No ledger entries matched the current filter.</td></tr>`;
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Rel-Time Superhighway — Cryptographic Audit Trail</title>
+  <style>
+    :root {
+      --bg: #07090e;
+      --card: #0f1420;
+      --card-border: #1e293b;
+      --gold: #f5b041;
+      --gold-dim: rgba(245, 176, 65, 0.14);
+      --green: #2ecc71;
+      --green-dim: rgba(46, 204, 113, 0.14);
+      --blue: #38bdf8;
+      --blue-dim: rgba(56, 189, 248, 0.14);
+      --purple: #c084fc;
+      --purple-dim: rgba(192, 132, 252, 0.15);
+      --red: #f87171;
+      --red-dim: rgba(248, 113, 113, 0.15);
+      --text: #f8fafc;
+      --muted: #94a3b8;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      padding: 32px 24px 64px;
+      background: radial-gradient(circle at top right, #131c31 0%, var(--bg) 55%);
+      color: var(--text);
+      font-family: -apple-system, BlinkMacSystemFont, "Inter", "Segoe UI", Roboto, sans-serif;
+      line-height: 1.5;
+    }
+    .container { max-width: 1340px; margin: 0 auto; }
+    .topbar {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: space-between;
+      align-items: center;
+      gap: 16px;
+      padding: 24px 28px;
+      background: linear-gradient(135deg, rgba(15,20,32,0.96), rgba(20,28,46,0.92));
+      border: 1px solid rgba(245, 176, 65, 0.35);
+      border-radius: 16px;
+      box-shadow: 0 18px 40px rgba(0,0,0,0.45);
+      margin-bottom: 24px;
+    }
+    .brand-eyebrow {
+      font-size: 11px;
+      letter-spacing: 0.18em;
+      text-transform: uppercase;
+      color: var(--gold);
+      font-weight: 700;
+      margin-bottom: 4px;
+    }
+    h1 {
+      margin: 0;
+      font-size: 26px;
+      font-weight: 800;
+      letter-spacing: -0.02em;
+    }
+    .meta-line {
+      font-size: 13px;
+      color: var(--muted);
+      margin-top: 4px;
+    }
+    .actions-bar {
+      display: flex;
+      gap: 10px;
+      align-items: center;
+    }
+    .btn {
+      background: var(--gold);
+      color: #07090e;
+      border: none;
+      padding: 10px 16px;
+      border-radius: 8px;
+      font-weight: 700;
+      font-size: 13px;
+      cursor: pointer;
+      text-decoration: none;
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+    }
+    .btn-outline {
+      background: transparent;
+      color: var(--text);
+      border: 1px solid var(--card-border);
+      padding: 10px 16px;
+      border-radius: 8px;
+      font-weight: 600;
+      font-size: 13px;
+      cursor: pointer;
+      text-decoration: none;
+    }
+    .kpi-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 16px;
+      margin-bottom: 24px;
+    }
+    .kpi-card {
+      background: var(--card);
+      border: 1px solid var(--card-border);
+      border-radius: 14px;
+      padding: 18px 20px;
+    }
+    .kpi-label {
+      font-size: 11px;
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+      color: var(--muted);
+      margin-bottom: 6px;
+    }
+    .kpi-value {
+      font-size: 26px;
+      font-weight: 800;
+      font-family: "JetBrains Mono", "SF Mono", Menlo, monospace;
+    }
+    .kpi-sub {
+      font-size: 12px;
+      color: var(--muted);
+      margin-top: 4px;
+    }
+    .section-card {
+      background: var(--card);
+      border: 1px solid var(--card-border);
+      border-radius: 16px;
+      padding: 22px 24px;
+      margin-bottom: 24px;
+    }
+    .section-header {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: space-between;
+      align-items: center;
+      gap: 12px;
+      margin-bottom: 16px;
+    }
+    h2 {
+      margin: 0;
+      font-size: 18px;
+      font-weight: 700;
+    }
+    .section-sub {
+      margin: 3px 0 0;
+      font-size: 13px;
+      color: var(--muted);
+    }
+    .filter-bar {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      align-items: center;
+      margin-bottom: 16px;
+    }
+    .search-input {
+      background: #07090e;
+      border: 1px solid var(--card-border);
+      color: var(--text);
+      padding: 8px 12px;
+      border-radius: 8px;
+      font-size: 13px;
+      min-width: 260px;
+    }
+    .filter-pill {
+      background: #07090e;
+      border: 1px solid var(--card-border);
+      color: var(--muted);
+      padding: 6px 12px;
+      border-radius: 999px;
+      font-size: 12px;
+      font-weight: 600;
+      cursor: pointer;
+    }
+    .filter-pill.active {
+      background: var(--gold-dim);
+      border-color: var(--gold);
+      color: var(--gold);
+    }
+    .table-wrap {
+      overflow-x: auto;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 13px;
+    }
+    th {
+      text-align: left;
+      padding: 11px 12px;
+      font-size: 11px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--muted);
+      border-bottom: 1px solid var(--card-border);
+      white-space: nowrap;
+    }
+    td {
+      padding: 12px;
+      border-bottom: 1px solid rgba(30, 41, 59, 0.65);
+      vertical-align: middle;
+    }
+    tr:hover td {
+      background: rgba(255, 255, 255, 0.02);
+    }
+    .mono {
+      font-family: "JetBrains Mono", "SF Mono", Menlo, monospace;
+      font-size: 12px;
+    }
+    .hash-full {
+      word-break: break-all;
+      color: #cbd5e1;
+      font-size: 11.5px;
+    }
+    .badge {
+      display: inline-block;
+      padding: 3px 9px;
+      border-radius: 999px;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.03em;
+      white-space: nowrap;
+    }
+    .badge-settled { background: var(--green-dim); color: var(--green); border: 1px solid rgba(46,204,113,0.35); }
+    .badge-pending { background: var(--gold-dim); color: var(--gold); border: 1px solid rgba(245,176,65,0.35); }
+    .badge-mode { background: var(--blue-dim); color: var(--blue); border: 1px solid rgba(56,189,248,0.3); }
+    .badge-passkey { background: var(--purple-dim); color: var(--purple); border: 1px solid rgba(192,132,252,0.35); }
+    .badge-warn { background: var(--red-dim); color: var(--red); border: 1px solid rgba(248,113,113,0.35); }
+    .btn-link {
+      color: var(--gold);
+      text-decoration: none;
+      font-weight: 700;
+      font-size: 12px;
+      padding: 5px 10px;
+      border: 1px solid rgba(245,176,65,0.35);
+      border-radius: 6px;
+      background: var(--gold-dim);
+      white-space: nowrap;
+    }
+    .tx-link {
+      color: #94a3b8;
+      text-decoration: none;
+      font-size: 11px;
+      display: inline-block;
+      margin-top: 2px;
+    }
+    .tx-link:hover { color: var(--gold); }
+    @media print {
+      body { background: #07090e !important; -webkit-print-color-adjust: exact; print-color-adjust: exact; padding: 12px; }
+      .no-print { display: none !important; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="topbar">
+      <div>
+        <div class="brand-eyebrow">Rel-Time Sovereign Provenance Protocol · Audit Trail</div>
+        <h1>Cryptographic Data Integrity &amp; Timechain Audit Report</h1>
+        <div class="meta-line">
+          Generated: <span class="mono">${escapeHtml(generatedUtc)}</span> ·
+          Account Tier: <strong style="color:#F5B041">${escapeHtml(acct.tier || "Active")}</strong> ·
+          Key: <span class="mono">${escapeHtml(acct.masked_api_key || "rel_key_***")}</span>
+        </div>
+      </div>
+      <div class="actions-bar no-print">
+        <a class="btn-outline" href="https://rel-time.com/verify" target="_blank" rel="noopener">Open Verifier ↗</a>
+        <button class="btn" onclick="window.print()">Print / Save PDF Audit Certificate</button>
+      </div>
+    </div>
+
+    <div class="kpi-grid">
+      <div class="kpi-card">
+        <div class="kpi-label">Audited Anchors</div>
+        <div class="kpi-value" style="color:#f8fafc">${Number(sum.matched_entries_count || 0).toLocaleString()}</div>
+        <div class="kpi-sub">Lifetime Account Total: ${Number(acct.lifetime_anchors || 0).toLocaleString()}</div>
+      </div>
+      <div class="kpi-card">
+        <div class="kpi-label">Bitcoin Finality</div>
+        <div class="kpi-value" style="color:#2ECC71">${Number(sum.settled_on_bitcoin_count || 0).toLocaleString()}</div>
+        <div class="kpi-sub">${escapeHtml(sum.settlement_rate_pct || "0%")} Settled · ${Number(
+    sum.pending_finality_count || 0
+  )} Pending</div>
+      </div>
+      <div class="kpi-card">
+        <div class="kpi-label">Bitcoin Blocks &amp; TXs</div>
+        <div class="kpi-value" style="color:#F5B041">${Number(btc.unique_blocks_count || 0)}</div>
+        <div class="kpi-sub">${Number(btc.unique_txids_count || 0)} Unique OP_RETURN TXIDs${
+    btc.latest_settled_block ? ` · Latest #${escapeHtml(btc.latest_settled_block)}` : ""
+  }</div>
+      </div>
+      <div class="kpi-card">
+        <div class="kpi-label">Hashing Modes</div>
+        <div class="kpi-value" style="color:#38bdf8">${Number(modes.standard_count || 0)} / ${Number(
+    modes.temporal_vdf_count || 0
+  )}</div>
+        <div class="kpi-sub">Standard Integrity / Temporal VDF</div>
+      </div>
+      <div class="kpi-card">
+        <div class="kpi-label">Hardware Passkey Signers</div>
+        <div class="kpi-value" style="color:#c084fc">${signers.length}</div>
+        <div class="kpi-sub">${Number(modes.biometric_passkey_count || 0)} Biometric-Attested Anchors</div>
+      </div>
+      <div class="kpi-card">
+        <div class="kpi-label">Available Fuel</div>
+        <div class="kpi-value" style="color:#F5B041">${Number(acct.hash_credits_remaining || 0).toLocaleString()}</div>
+        <div class="kpi-sub">Remaining Hash Credits</div>
+      </div>
+    </div>
+
+    ${localVerificationHtml}
+
+    <div class="section-card">
+      <div class="section-header">
+        <div>
+          <h2>Corporate Hardware Passkey Signers (WebAuthn / FIDO2 COSE Keys)</h2>
+          <p class="section-sub">Hardware Secure Enclave &amp; YubiKey public keys that have attested files under this corporate account</p>
+        </div>
+      </div>
+      <div class="table-wrap">
+        <table>
+          <thead>
+            <tr>
+              <th>#</th>
+              <th>Hardware Signer Public Key (COSE Hex)</th>
+              <th>Signed Anchors</th>
+              <th>Bitcoin Settled</th>
+              <th>Latest Signature (UTC)</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${signerRowsHtml}
+          </tbody>
+        </table>
+      </div>
+    </div>
+
+    <div class="section-card">
+      <div class="section-header">
+        <div>
+          <h2>Chronological Timechain Audit Ledger</h2>
+          <p class="section-sub">Complete record of SHA-256 data integrity hashes, VDF thermodynamic proofs (T_index), and Bitcoin Merkle settlements</p>
+        </div>
+      </div>
+      <div class="filter-bar no-print">
+        <input id="searchInput" class="search-input" type="text" placeholder="Filter by SHA-256 hash, T_index, Passkey, TXID, or Block #..." oninput="filterLedger()" />
+        <button class="filter-pill active" onclick="setPill(this, 'all')">All (${entries.length})</button>
+        <button class="filter-pill" onclick="setPill(this, 'status-settled')">Settled (${Number(
+          sum.settled_on_bitcoin_count || 0
+        )})</button>
+        <button class="filter-pill" onclick="setPill(this, 'status-pending')">Pending (${Number(
+          sum.pending_finality_count || 0
+        )})</button>
+        <button class="filter-pill" onclick="setPill(this, 'mode-biometric')">Biometric Passkey (${Number(
+          modes.biometric_passkey_count || 0
+        )})</button>
+        <button class="filter-pill" onclick="setPill(this, 'mode-temporal')">Temporal VDF (${Number(
+          modes.temporal_vdf_count || 0
+        )})</button>
+        <button class="filter-pill" onclick="setPill(this, 'mode-standard')">Standard (${Number(
+          modes.standard_count || 0
+        )})</button>
+      </div>
+      <div class="table-wrap">
+        <table>
+          <thead>
+            <tr>
+              <th>#</th>
+              <th>Timestamp (UTC)</th>
+              <th>Status</th>
+              <th>Mode &amp; Signer</th>
+              <th>Client / File SHA-256</th>
+              <th>Thermodynamic Proof (T_index)</th>
+              <th>Bitcoin Settlement</th>
+              <th>Verify</th>
+            </tr>
+          </thead>
+          <tbody id="ledgerBody">
+            ${ledgerRowsHtml}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    let currentFilter = 'all';
+    function setPill(btn, filter) {
+      currentFilter = filter;
+      document.querySelectorAll('.filter-pill').forEach(el => el.classList.remove('active'));
+      btn.classList.add('active');
+      filterLedger();
+    }
+    function filterLedger() {
+      const q = (document.getElementById('searchInput').value || '').trim().toLowerCase();
+      document.querySelectorAll('.ledger-row').forEach(row => {
+        const matchesFilter = currentFilter === 'all' || row.classList.contains(currentFilter);
+        const matchesQuery = !q || (row.getAttribute('data-search') || '').includes(q);
+        row.style.display = (matchesFilter && matchesQuery) ? '' : 'none';
+      });
+    }
+  </script>
+</body>
+</html>`;
+}
+
 const TOOLS = [
   {
     name: "reltime_anchor_file",
@@ -685,6 +1308,64 @@ const TOOLS = [
       required: ["action"],
     },
   },
+  {
+    name: "reltime_audit_trail",
+    description:
+      "Superhighway Cryptographic Audit Trail & Local Folder Integrity Verifier (`GET /api/v1/account` + `GET /api/v1/account/history` + local SHA-256 cross-reference). Fetches the account's chronological anchor ledger, aggregates Bitcoin block settlements, VDF `T_index` ticks, and Corporate Hardware Passkey (`signer_public_key`) signatures, optionally verifies a local file or entire folder bit-for-bit against the ledger (`verify_local_path`), and spins up a self-contained interactive HTML Audit Report (`reltime-audit-report-*.html`) in the user's browser.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        verify_local_path: {
+          type: "string",
+          description:
+            "Optional local file path or folder/directory path to audit bit-for-bit (Zero-Knowledge local SHA-256 + Passkey attestation check + Stamped Copy check) against the Rel-Time Bitcoin ledger.",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of audit ledger entries to retrieve (default 100, max 500).",
+        },
+        status_filter: {
+          type: "string",
+          enum: ["all", "settled", "pending"],
+          description: "Filter ledger entries by settlement status: 'all' (default), 'settled', or 'pending'.",
+        },
+        mode_filter: {
+          type: "string",
+          enum: ["all", "standard", "temporal", "biometric"],
+          description:
+            "Filter ledger entries by mode: 'all' (default), 'standard', 'temporal' (VDF T_index), or 'biometric' (Hardware Passkey attested).",
+        },
+        signer_filter: {
+          type: "string",
+          description:
+            "Optional full or partial Hardware Passkey `public_key_hex` to filter anchors signed by a specific employee or corporate YubiKey.",
+        },
+        save_html_report: {
+          type: "boolean",
+          description:
+            "If true (default), saves an interactive dark-mode HTML Superhighway Audit Trail dashboard (`reltime-audit-report-<date>.html`).",
+        },
+        open_in_browser: {
+          type: "boolean",
+          description:
+            "If true (default), automatically opens the generated HTML Audit Trail dashboard in the user's browser.",
+        },
+        export_csv: {
+          type: "boolean",
+          description: "If true, also exports the audit ledger to a `.csv` spreadsheet file.",
+        },
+        output_dir: {
+          type: "string",
+          description:
+            "Optional directory where the generated `.html` / `.csv` audit reports should be saved (defaults to `verify_local_path` folder or `~/.reltime/audits`).",
+        },
+        api_key: {
+          type: "string",
+          description: "Optional override for RELTIME_API_KEY.",
+        },
+      },
+    },
+  },
 ];
 
 async function executeTool(name, args = {}) {
@@ -984,6 +1665,405 @@ async function executeTool(name, args = {}) {
     return data;
   }
 
+  if (name === "reltime_audit_trail") {
+    if (!key) {
+      return buildPackSelectionPrompt(
+        "To run a Superhighway Audit Trail, a Rel-Time API key is required. Ask the user which tier and payment method they would like to provision:"
+      );
+    }
+
+    const acctRes = await fetch(`${API_BASE}/account`, {
+      headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!acctRes.ok) {
+      if (acctRes.status === 401 || acctRes.status === 403) {
+        return buildPackSelectionPrompt(
+          "The configured API key was not recognized. Ask the user which tier and payment method they would like to provision:"
+        );
+      }
+      throw new Error(`Rel-Time Account error (${acctRes.status}): ${await acctRes.text()}`);
+    }
+    const acctData = await acctRes.json();
+
+    const maxEntries = Math.min(500, Math.max(1, Number(args.limit) || 100));
+    const pageSize = Math.min(100, maxEntries);
+    const pagesToFetch = Math.ceil(maxEntries / pageSize);
+    let rawHistory = [];
+    let totalInLedger = 0;
+
+    for (let p = 1; p <= pagesToFetch; p++) {
+      const histRes = await fetch(`${API_BASE}/account/history?page=${p}&limit=${pageSize}`, {
+        headers: { Authorization: `Bearer ${key}` },
+      });
+      if (!histRes.ok) break;
+      const histJson = await histRes.json();
+      totalInLedger = Number(histJson.total || 0);
+      const batch = Array.isArray(histJson.history) ? histJson.history : [];
+      rawHistory.push(...batch);
+      if (batch.length < pageSize || rawHistory.length >= maxEntries || rawHistory.length >= totalInLedger) {
+        break;
+      }
+    }
+    rawHistory = rawHistory.slice(0, maxEntries);
+
+    const statusFilter = (args.status_filter || "all").toLowerCase();
+    const modeFilter = (args.mode_filter || "all").toLowerCase();
+    const signerFilter = (args.signer_filter || "").trim().toLowerCase();
+
+    const normalizedEntries = rawHistory.map((item) => {
+      const clientHash = (item.client_hash || "").toLowerCase();
+      const tIndex = (item.t_index || "").toLowerCase();
+      const origHash = item.original_file_hash ? item.original_file_hash.toLowerCase() : null;
+      const mode = (item.anchor_mode || "standard").toLowerCase();
+      const lookupHash = mode === "temporal" ? tIndex || clientHash : clientHash;
+      const tsSec = Number(item.timestamp || 0);
+      const tsUtc = tsSec > 0 ? new Date(tsSec * 1000).toISOString() : null;
+      return {
+        timestamp: tsSec,
+        timestamp_utc: tsUtc,
+        status: item.status || "pending_finality",
+        anchor_mode: mode,
+        identity_mode: item.signer_public_key ? "biometric_passkey" : "anonymous",
+        client_hash: clientHash,
+        original_file_hash: origHash,
+        t_index: tIndex,
+        vdf_ticks: Number(item.vdf_ticks || 0),
+        signer_public_key: item.signer_public_key || null,
+        block_height: item.block_height || null,
+        block_time: item.block_time || null,
+        block_time_utc: item.block_time ? new Date(Number(item.block_time) * 1000).toISOString() : null,
+        txid: item.txid || null,
+        merkle_root: item.merkle_root || null,
+        verify_url: `https://rel-time.com/verify?t=${lookupHash}`,
+        sun_stamp_svg_url: `${API_BASE}/stamp/${lookupHash}`,
+      };
+    });
+
+    const filteredEntries = normalizedEntries.filter((e) => {
+      if (statusFilter === "settled" && e.status !== "settled") return false;
+      if (statusFilter === "pending" && e.status === "settled") return false;
+      if (modeFilter === "standard" && e.anchor_mode !== "standard") return false;
+      if (modeFilter === "temporal" && e.anchor_mode !== "temporal") return false;
+      if (modeFilter === "biometric" && !e.signer_public_key) return false;
+      if (signerFilter && !(e.signer_public_key || "").toLowerCase().includes(signerFilter)) return false;
+      return true;
+    });
+
+    // Aggregate KPI & Hardware Passkey Signer statistics
+    let settledCount = 0;
+    let pendingCount = 0;
+    let standardCount = 0;
+    let temporalCount = 0;
+    let biometricCount = 0;
+    const uniqueBlocks = new Set();
+    const uniqueTxids = new Set();
+    let latestBlock = null;
+    let latestTxid = null;
+    const signerMap = new Map();
+
+    for (const e of filteredEntries) {
+      if (e.status === "settled") {
+        settledCount++;
+        if (e.block_height) {
+          uniqueBlocks.add(e.block_height);
+          if (!latestBlock || Number(e.block_height) > Number(latestBlock)) {
+            latestBlock = e.block_height;
+            latestTxid = e.txid || latestTxid;
+          }
+        }
+        if (e.txid) uniqueTxids.add(e.txid);
+      } else {
+        pendingCount++;
+      }
+
+      if (e.anchor_mode === "temporal") temporalCount++;
+      else standardCount++;
+
+      if (e.signer_public_key) {
+        biometricCount++;
+        const pk = e.signer_public_key;
+        const cur = signerMap.get(pk) || {
+          signer_public_key: pk,
+          short_key: `${pk.slice(0, 12)}...${pk.slice(-8)}`,
+          anchor_count: 0,
+          settled_count: 0,
+          latest_timestamp_utc: e.timestamp_utc,
+        };
+        cur.anchor_count++;
+        if (e.status === "settled") cur.settled_count++;
+        if (e.timestamp_utc && (!cur.latest_timestamp_utc || e.timestamp_utc > cur.latest_timestamp_utc)) {
+          cur.latest_timestamp_utc = e.timestamp_utc;
+        }
+        signerMap.set(pk, cur);
+      }
+    }
+
+    // Build fast lookup index of all known hashes in account history + known passkeys
+    const ledgerByHash = new Map();
+    const knownPasskeys = new Set();
+    const localPasskey = loadSavedPasskey();
+    if (localPasskey && localPasskey.public_key_hex) {
+      knownPasskeys.add(localPasskey.public_key_hex);
+    }
+    for (const e of normalizedEntries) {
+      if (e.client_hash) ledgerByHash.set(e.client_hash, e);
+      if (e.t_index) ledgerByHash.set(e.t_index, e);
+      if (e.original_file_hash) ledgerByHash.set(e.original_file_hash, e);
+      if (e.signer_public_key) knownPasskeys.add(e.signer_public_key);
+    }
+
+    // Optional Zero-Knowledge Local File / Folder Integrity Verification
+    let localPathVerification = null;
+    if (args.verify_local_path) {
+      const targetPath = resolveLocalFilePath(args.verify_local_path);
+      if (!fs.existsSync(targetPath)) {
+        throw new Error(`verify_local_path not found: ${targetPath}`);
+      }
+      const stat = fs.statSync(targetPath);
+      let candidateFiles = [];
+      if (stat.isFile()) {
+        candidateFiles.push(targetPath);
+      } else if (stat.isDirectory()) {
+        const dirItems = fs.readdirSync(targetPath);
+        for (const item of dirItems) {
+          if (item.startsWith(".")) continue;
+          if (
+            item.startsWith("reltime-stamp-") ||
+            item.startsWith("reltime-doomsday-proof-") ||
+            item.startsWith("reltime-proof-") ||
+            item.startsWith("reltime-audit-report-")
+          ) {
+            continue;
+          }
+          const fullItemPath = path.join(targetPath, item);
+          try {
+            if (fs.statSync(fullItemPath).isFile()) {
+              candidateFiles.push(fullItemPath);
+            }
+          } catch (e) {
+            // Skip unreadable entry
+          }
+        }
+      }
+
+      const fileAuditResults = [];
+      let vSettled = 0;
+      let vPending = 0;
+      let vUnanchored = 0;
+
+      for (const fPath of candidateFiles) {
+        const buf = fs.readFileSync(fPath);
+        const fName = path.basename(fPath);
+        const rawSha256 = crypto.createHash("sha256").update(buf).digest("hex");
+        const embeddedHash = extractStampedCopyEmbeddedHash(fPath, buf);
+        const isStampedCopy = Boolean(embeddedHash) || fName.startsWith("reltime-stamped-");
+
+        let matchedEntry =
+          ledgerByHash.get(rawSha256) || (embeddedHash ? ledgerByHash.get(embeddedHash) : null) || null;
+
+        // Also check biometric attested hashes SHA-256(rawSha256 + passkey_hex)
+        if (!matchedEntry) {
+          for (const pkHex of knownPasskeys) {
+            const attestedCandidate = crypto
+              .createHash("sha256")
+              .update(`${rawSha256}${pkHex}`, "utf8")
+              .digest("hex");
+            if (ledgerByHash.has(attestedCandidate)) {
+              matchedEntry = ledgerByHash.get(attestedCandidate);
+              break;
+            }
+          }
+        }
+
+        // Fallback: query live GET /v1/proof/{hash} in case it was anchored outside the recent history window
+        const probeHash = embeddedHash || rawSha256;
+        if (!matchedEntry) {
+          try {
+            const proofRes = await fetch(`${API_BASE}/proof/${probeHash}`);
+            if (proofRes.ok) {
+              const proofData = await proofRes.json();
+              const s = proofData.settlement || {};
+              matchedEntry = {
+                status: proofData.status || "settled",
+                anchor_mode: proofData.anchor_mode || "standard",
+                client_hash: proofData.client_hash || probeHash,
+                t_index: proofData.t_index || probeHash,
+                signer_public_key: proofData.signer_public_key || null,
+                block_height: s.bitcoin_block_height || s.block_height || null,
+                txid: s.bitcoin_txid || null,
+                merkle_root: s.merkle_root || null,
+                verify_url: `https://rel-time.com/verify?t=${probeHash}`,
+              };
+            }
+          } catch (e) {
+            // Ignore network error during fallback lookup
+          }
+        }
+
+        let integrityStatus = "UNANCHORED_OR_MODIFIED";
+        if (matchedEntry) {
+          if (matchedEntry.status === "settled") {
+            integrityStatus = "VERIFIED_SETTLED";
+            vSettled++;
+          } else {
+            integrityStatus = "VERIFIED_PENDING";
+            vPending++;
+          }
+        } else {
+          vUnanchored++;
+        }
+
+        const bytes = buf.length;
+        const sizeHuman =
+          bytes >= 1048576
+            ? `${(bytes / 1048576).toFixed(2)} MB`
+            : bytes >= 1024
+            ? `${(bytes / 1024).toFixed(1)} KB`
+            : `${bytes} B`;
+
+        fileAuditResults.push({
+          file_name: fName,
+          file_path: fPath,
+          size_bytes: bytes,
+          size_human: sizeHuman,
+          local_sha256: embeddedHash || rawSha256,
+          raw_file_sha256: rawSha256,
+          embedded_stamp_hash: embeddedHash,
+          is_stamped_copy: isStampedCopy,
+          integrity_status: integrityStatus,
+          anchor_mode: matchedEntry ? matchedEntry.anchor_mode : null,
+          signer_public_key: matchedEntry ? matchedEntry.signer_public_key : null,
+          t_index: matchedEntry ? matchedEntry.t_index : null,
+          block_height: matchedEntry ? matchedEntry.block_height : null,
+          txid: matchedEntry ? matchedEntry.txid : null,
+          verify_url: matchedEntry ? matchedEntry.verify_url : null,
+        });
+      }
+
+      localPathVerification = {
+        target_path: targetPath,
+        summary: {
+          total_files_scanned: fileAuditResults.length,
+          verified_settled_count: vSettled,
+          verified_pending_count: vPending,
+          unanchored_or_modified_count: vUnanchored,
+          overall_integrity: vUnanchored === 0 ? "ALL_FILES_VERIFIED" : "ATTENTION_UNANCHORED_OR_MODIFIED_FILES",
+        },
+        files: fileAuditResults,
+      };
+    }
+
+    const maskedKey = key.length > 16 ? `${key.slice(0, 14)}…${key.slice(-4)}` : "rel_key_***";
+    const settlementRatePct =
+      filteredEntries.length > 0 ? `${Math.round((settledCount / filteredEntries.length) * 100)}%` : "0%";
+
+    const auditPayload = {
+      status: "audit_complete",
+      generated_at_utc: new Date().toISOString(),
+      account_overview: {
+        tier: acctData.tier || "Active",
+        hash_credits_remaining: Number(acctData.hash_credits || 0),
+        lifetime_anchors: Number(acctData.total_usage || totalInLedger || 0),
+        masked_api_key: maskedKey,
+      },
+      audit_summary: {
+        total_ledger_entries: totalInLedger,
+        matched_entries_count: filteredEntries.length,
+        settled_on_bitcoin_count: settledCount,
+        pending_finality_count: pendingCount,
+        settlement_rate_pct: settlementRatePct,
+        mode_breakdown: {
+          standard_count: standardCount,
+          temporal_vdf_count: temporalCount,
+          biometric_passkey_count: biometricCount,
+        },
+        bitcoin_settlement: {
+          unique_blocks_count: uniqueBlocks.size,
+          unique_txids_count: uniqueTxids.size,
+          latest_settled_block: latestBlock,
+          latest_txid: latestTxid,
+        },
+        hardware_passkey_signers: Array.from(signerMap.values()),
+      },
+      local_path_verification: localPathVerification,
+      audit_trail: filteredEntries,
+    };
+
+    // Determine output directory for reports
+    let reportDir = path.join(PASSKEY_CONFIG_DIR, "audits");
+    if (args.output_dir) {
+      reportDir = resolveLocalFilePath(args.output_dir);
+    } else if (localPathVerification) {
+      const tp = localPathVerification.target_path;
+      reportDir = fs.statSync(tp).isDirectory() ? tp : path.dirname(tp);
+    }
+    if (!fs.existsSync(reportDir)) {
+      fs.mkdirSync(reportDir, { recursive: true });
+    }
+
+    const dateStamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const savedReports = {};
+
+    if (args.save_html_report !== false) {
+      const htmlPath = path.join(reportDir, `reltime-audit-report-${dateStamp}.html`);
+      const htmlContent = generateAuditReportHtml(auditPayload);
+      fs.writeFileSync(htmlPath, htmlContent, "utf8");
+      savedReports.html_report_path = htmlPath;
+
+      if (args.open_in_browser !== false) {
+        try {
+          openSystemBrowser(htmlPath);
+          savedReports.opened_in_browser = true;
+        } catch (e) {
+          savedReports.opened_in_browser = false;
+        }
+      }
+    }
+
+    if (args.export_csv) {
+      const csvPath = path.join(reportDir, `reltime-audit-trail-${dateStamp}.csv`);
+      const csvHeader = [
+        "timestamp_utc",
+        "status",
+        "anchor_mode",
+        "identity_mode",
+        "client_hash",
+        "original_file_hash",
+        "t_index",
+        "vdf_ticks",
+        "signer_public_key",
+        "bitcoin_block_height",
+        "bitcoin_txid",
+        "merkle_root",
+        "verify_url",
+      ].join(",");
+      const csvRows = filteredEntries.map((e) =>
+        [
+          e.timestamp_utc || "",
+          e.status || "",
+          e.anchor_mode || "",
+          e.identity_mode || "",
+          e.client_hash || "",
+          e.original_file_hash || "",
+          e.t_index || "",
+          e.vdf_ticks || 0,
+          e.signer_public_key || "",
+          e.block_height || "",
+          e.txid || "",
+          e.merkle_root || "",
+          e.verify_url || "",
+        ]
+          .map((v) => `"${String(v).replace(/"/g, '""')}"`)
+          .join(",")
+      );
+      fs.writeFileSync(csvPath, [csvHeader, ...csvRows].join("\n"), "utf8");
+      savedReports.csv_report_path = csvPath;
+    }
+
+    auditPayload.saved_reports = savedReports;
+    return auditPayload;
+  }
+
   if (name === "reltime_provision_agent_key") {
     if (args.action === "create_invoice") {
       const validPacks = ["universal", "launch", "standard", "enterprise", "superhighway"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rel-time/mcp-server",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Official Model Context Protocol (MCP) server for Rel-Time (rel-time.com) — Zero-Knowledge Bitcoin & VDF Provenance, Local File Hashing, and Sun-Stamp Generation for Claude, Cursor, Windsurf, and Antigravity.",
   "main": "index.js",
   "bin": {