@fiscalmindset/blindfold 0.4.0

package/dist/cli.mjs

@@ -0,0 +1,4317 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/keychain.ts
+import { spawnSync } from "node:child_process";
+function has(cmd) {
+  const finder = isWin ? "where" : "which";
+  const r = spawnSync(finder, [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function winPS(op, target, secret) {
+  let body;
+  if (op === "set") {
+    body = `$b=[System.Text.Encoding]::UTF8.GetBytes($env:BF_SECRET);$p=[Runtime.InteropServices.Marshal]::AllocHGlobal($b.Length);[Runtime.InteropServices.Marshal]::Copy($b,0,$p,$b.Length);$c=New-Object BFCred+CREDENTIAL;$c.Type=1;$c.TargetName=$env:BF_TARGET;$c.UserName=$env:BF_TARGET;$c.CredentialBlobSize=$b.Length;$c.CredentialBlob=$p;$c.Persist=2;$ok=[BFCred]::CredWriteW([ref]$c,0);[Runtime.InteropServices.Marshal]::FreeHGlobal($p);if($ok){[Console]::Out.Write('BFOK')}`;
+  } else if (op === "get") {
+    body = `$ptr=[IntPtr]::Zero;if([BFCred]::CredReadW($env:BF_TARGET,1,0,[ref]$ptr)){$c=[Runtime.InteropServices.Marshal]::PtrToStructure($ptr,[BFCred+CREDENTIAL]);$n=[int]$c.CredentialBlobSize;$b=New-Object byte[] $n;[Runtime.InteropServices.Marshal]::Copy([IntPtr]$c.CredentialBlob,$b,0,$n);[BFCred]::CredFree($ptr);[Console]::Out.Write([System.Text.Encoding]::UTF8.GetString($b))}else{exit 1}`;
+  } else {
+    body = `if([BFCred]::CredDeleteW($env:BF_TARGET,1,0)){[Console]::Out.Write('BFOK')}`;
+  }
+  const env = { ...process.env, BF_TARGET: target };
+  if (secret !== void 0) env.BF_SECRET = secret;
+  const r = spawnSync(
+    "powershell",
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "-"],
+    { input: PS_HEADER + body, env, encoding: "utf8" }
+  );
+  return { status: r.status, stdout: typeof r.stdout === "string" ? r.stdout : "" };
+}
+function winTarget(account) {
+  return `${SERVICE}:${account}`;
+}
+function keychainAvailable() {
+  if (process.platform === "darwin") return has("security");
+  if (process.platform === "linux") return has("secret-tool");
+  if (isWin) return has("powershell");
+  return false;
+}
+function keychainBackend() {
+  if (process.platform === "darwin") return "macOS Keychain";
+  if (process.platform === "linux") return "libsecret (secret-tool)";
+  if (isWin) return "Windows Credential Manager";
+  return "none";
+}
+function keychainSet(account, secret) {
+  if (process.platform === "darwin") {
+    const r = spawnSync("security", ["add-generic-password", "-a", account, "-s", SERVICE, "-w", secret, "-U"], { stdio: "ignore" });
+    return r.status === 0;
+  }
+  if (process.platform === "linux") {
+    const r = spawnSync("secret-tool", ["store", "--label=blindfold", "service", SERVICE, "account", account], { input: secret, stdio: ["pipe", "ignore", "ignore"] });
+    return r.status === 0;
+  }
+  if (isWin) return winPS("set", winTarget(account), secret).stdout.includes("BFOK");
+  return false;
+}
+function keychainGet(account) {
+  if (process.platform === "darwin") {
+    const r = spawnSync("security", ["find-generic-password", "-a", account, "-s", SERVICE, "-w"], { encoding: "utf8" });
+    if (r.status === 0 && typeof r.stdout === "string") return r.stdout.replace(/\n$/, "");
+    return null;
+  }
+  if (process.platform === "linux") {
+    const r = spawnSync("secret-tool", ["lookup", "service", SERVICE, "account", account], { encoding: "utf8" });
+    if (r.status === 0 && r.stdout) return r.stdout.replace(/\n$/, "");
+    return null;
+  }
+  if (isWin) {
+    const r = winPS("get", winTarget(account));
+    if (r.status === 0 && r.stdout) return r.stdout.replace(/\r?\n$/, "");
+    return null;
+  }
+  return null;
+}
+function keychainDelete(account) {
+  if (process.platform === "darwin") {
+    const r = spawnSync("security", ["delete-generic-password", "-a", account, "-s", SERVICE], { stdio: "ignore" });
+    return r.status === 0;
+  }
+  if (process.platform === "linux") {
+    const r = spawnSync("secret-tool", ["clear", "service", SERVICE, "account", account], { stdio: "ignore" });
+    return r.status === 0;
+  }
+  if (isWin) return winPS("delete", winTarget(account)).stdout.includes("BFOK");
+  return false;
+}
+var SERVICE, isWin, WIN_CS, PS_HEADER;
+var init_keychain = __esm({
+  "src/keychain.ts"() {
+    "use strict";
+    SERVICE = "blindfold";
+    isWin = process.platform === "win32";
+    WIN_CS = `
+using System;
+using System.Runtime.InteropServices;
+public static class BFCred {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct CREDENTIAL {
+    public UInt32 Flags; public UInt32 Type;
+    [MarshalAs(UnmanagedType.LPWStr)] public string TargetName;
+    [MarshalAs(UnmanagedType.LPWStr)] public string Comment;
+    public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
+    public UInt32 CredentialBlobSize; public IntPtr CredentialBlob; public UInt32 Persist;
+    public UInt32 AttributeCount; public IntPtr Attributes;
+    [MarshalAs(UnmanagedType.LPWStr)] public string TargetAlias;
+    [MarshalAs(UnmanagedType.LPWStr)] public string UserName;
+  }
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredWriteW(ref CREDENTIAL c, UInt32 f);
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredReadW(string t, UInt32 ty, UInt32 f, out IntPtr c);
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredDeleteW(string t, UInt32 ty, UInt32 f);
+  [DllImport("advapi32.dll")] public static extern void CredFree(IntPtr c);
+}
+`;
+    PS_HEADER = `$ErrorActionPreference='Stop'
+Add-Type -TypeDefinition @"
+${WIN_CS}
+"@
+`;
+  }
+});
+
+// src/env.ts
+import fs2 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function repoRoot() {
+  if (_repoRoot) return _repoRoot;
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs2.existsSync(path2.join(dir, ".env")) || fs2.existsSync(path2.join(dir, ".blindfold")) || fs2.existsSync(path2.join(dir, ".git"))) {
+      _repoRoot = dir;
+      return dir;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  _repoRoot = SRC_RELATIVE_ROOT;
+  return _repoRoot;
+}
+function homeDir() {
+  return path2.join(os.homedir(), ".blindfold");
+}
+function configPath() {
+  return path2.join(homeDir(), "config.json");
+}
+function stateDir() {
+  const override = process.env.BLINDFOLD_STATE_DIR;
+  if (override && override.trim()) return path2.resolve(override.trim());
+  const home = homeDir();
+  if (!fs2.existsSync(home)) {
+    try {
+      const legacy = path2.join(repoRoot(), ".blindfold");
+      if (fs2.existsSync(legacy) && fs2.statSync(legacy).isDirectory()) {
+        fs2.cpSync(legacy, home, { recursive: true });
+      } else {
+        fs2.mkdirSync(home, { recursive: true });
+      }
+    } catch {
+      try {
+        fs2.mkdirSync(home, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  return home;
+}
+function assertSafeOverrideUrl(raw, label) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error(`${label} is not a valid URL: ${raw}`);
+  }
+  const isLocal = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(u.hostname);
+  if (u.protocol !== "https:" && !isLocal) {
+    throw new Error(`${label} must be https (got ${u.protocol}//${u.hostname}); refusing to trust an insecure endpoint`);
+  }
+}
+function withFileLockSync(target, fn) {
+  const lockPath = `${target}.lock`;
+  const deadline = Date.now() + 1e4;
+  fs2.mkdirSync(path2.dirname(lockPath), { recursive: true });
+  const sleep = (ms) => {
+    try {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    } catch {
+    }
+  };
+  for (; ; ) {
+    try {
+      const fd = fs2.openSync(lockPath, "wx");
+      fs2.writeSync(fd, String(process.pid));
+      fs2.closeSync(fd);
+      break;
+    } catch (e) {
+      if (e?.code !== "EEXIST") throw e;
+      try {
+        const st = fs2.statSync(lockPath);
+        if (Date.now() - st.mtimeMs > 1e4) {
+          fs2.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) throw new Error(`timed out acquiring lock ${lockPath}`);
+      sleep(25);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    fs2.rmSync(lockPath, { force: true });
+  }
+}
+function defaultEnvPath() {
+  return path2.join(repoRoot(), ".env");
+}
+function loadEnvFromFile(envPath = path2.join(repoRoot(), ".env")) {
+  if (!fs2.existsSync(envPath)) return;
+  const text = fs2.readFileSync(envPath, "utf8");
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let val = line.slice(eq + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    if (process.env[key] === void 0) process.env[key] = val;
+  }
+}
+function loadHomeConfig() {
+  try {
+    const cfg = configPath();
+    if (fs2.existsSync(cfg)) {
+      const obj = JSON.parse(fs2.readFileSync(cfg, "utf8"));
+      for (const [k, v] of Object.entries(obj)) {
+        if (k === "T3N_API_KEY_STORE") continue;
+        if (typeof v === "string" && process.env[k] === void 0) process.env[k] = v;
+      }
+    }
+  } catch {
+  }
+  loadEnvFromFile(path2.join(homeDir(), ".env"));
+  if (process.env.T3N_API_KEY === void 0 && process.env.DID && keychainAvailable()) {
+    const k = keychainGet(process.env.DID);
+    if (k) process.env.T3N_API_KEY = k;
+  }
+}
+function loadBlindfoldEnv() {
+  loadEnvFromFile();
+  loadHomeConfig();
+  const t3nApiKey = process.env.T3N_API_KEY ?? "";
+  const did = process.env.DID ?? "";
+  const port = Number.parseInt(process.env.BLINDFOLD_PORT ?? "8787", 10);
+  const t3EnvRaw = (process.env.BLINDFOLD_T3_ENV ?? "testnet").toLowerCase();
+  const t3Env = t3EnvRaw === "production" ? "production" : "testnet";
+  const t3BaseUrl = (process.env.T3_BASE_URL ?? process.env.BLINDFOLD_BASE_URL ?? "").trim();
+  if (t3BaseUrl) {
+    assertSafeOverrideUrl(t3BaseUrl, process.env.T3_BASE_URL ? "T3_BASE_URL" : "BLINDFOLD_BASE_URL");
+  }
+  const mock = process.env.BLINDFOLD_MOCK === "1";
+  return { t3nApiKey, did, port, t3Env, t3BaseUrl, mock };
+}
+function assertRealReady(env) {
+  if (env.mock) return;
+  const missing = [];
+  if (!env.t3nApiKey) missing.push("T3N_API_KEY");
+  if (!env.did) missing.push("DID");
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required env: ${missing.join(", ")}. Claim them at https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens, then put them in .env. Or set BLINDFOLD_MOCK=1 to use mock mode for the demo only.`
+    );
+  }
+}
+function pluckSecret(envName) {
+  const v = process.env[envName];
+  if (!v) {
+    throw new Error(`environment variable ${envName} is unset or empty`);
+  }
+  return v;
+}
+var HERE2, SRC_RELATIVE_ROOT, _repoRoot;
+var init_env = __esm({
+  "src/env.ts"() {
+    "use strict";
+    init_keychain();
+    HERE2 = path2.dirname(fileURLToPath2(import.meta.url));
+    SRC_RELATIVE_ROOT = path2.resolve(HERE2, "..", "..", "..");
+    _repoRoot = null;
+  }
+});
+
+// src/prompt.ts
+async function readSecretLine(prompt) {
+  process.stderr.write(prompt);
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    return await readOneLine(stdin);
+  }
+  return await new Promise((resolve, reject) => {
+    let buf = "";
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+    };
+    const onData = (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      for (const ch of s) {
+        if (ch === "\n" || ch === "\r") {
+          cleanup();
+          process.stderr.write("\n");
+          resolve(buf);
+          return;
+        }
+        if (ch === "") {
+          cleanup();
+          process.stderr.write("\n");
+          reject(new Error("aborted by user"));
+          return;
+        }
+        if (ch === "\x7F" || ch === "\b") {
+          if (buf.length > 0) buf = buf.slice(0, -1);
+          continue;
+        }
+        if (ch >= " " || ch === "	") buf += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function readLine(prompt) {
+  process.stderr.write(prompt);
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return await readOneLine(stdin);
+  return await new Promise((resolve, reject) => {
+    let buf = "";
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.pause();
+    };
+    const onData = (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      for (const ch of s) {
+        if (ch === "\r" || ch === "\n") {
+          process.stderr.write("\n");
+          cleanup();
+          resolve(buf);
+          return;
+        }
+        if (ch === "") {
+          cleanup();
+          reject(new Error("aborted"));
+          return;
+        }
+        buf += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function readOneLine(stdin) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (d) => {
+      buf += d;
+    });
+    stdin.on("end", () => resolve(buf.replace(/\r?\n$/, "")));
+    stdin.on("error", reject);
+  });
+}
+var init_prompt = __esm({
+  "src/prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+var SENTINEL, CONTRACT_TAIL, CONTRACT_VERSION, DEFAULT_DASHBOARD_PORT;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    SENTINEL = "__BLINDFOLD__";
+    CONTRACT_TAIL = "blindfold-proxy";
+    CONTRACT_VERSION = "0.5.6";
+    DEFAULT_DASHBOARD_PORT = 8799;
+  }
+});
+
+// src/log.ts
+function safeLog(level, obj) {
+  const safe = typeof obj === "string" ? { msg: obj } : redact(obj);
+  const line = JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), level, ...safe });
+  process.stderr.write(line + "\n");
+}
+function redact(input) {
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (k === "headers" && v && typeof v === "object") {
+      out[k] = redactHeaders(v);
+    } else if (HEADER_BLOCKLIST.has(k.toLowerCase())) {
+      out[k] = "[redacted]";
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function redactHeaders(h) {
+  if (Array.isArray(h)) {
+    return h.map(([k, v]) => [k, HEADER_BLOCKLIST.has(k.toLowerCase()) ? "[redacted]" : v]);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(h)) {
+    out[k] = HEADER_BLOCKLIST.has(k.toLowerCase()) ? "[redacted]" : String(v);
+  }
+  return out;
+}
+var HEADER_BLOCKLIST;
+var init_log = __esm({
+  "src/log.ts"() {
+    "use strict";
+    HEADER_BLOCKLIST = /* @__PURE__ */ new Set([
+      "authorization",
+      "proxy-authorization",
+      "x-api-key",
+      "cookie",
+      "set-cookie"
+    ]);
+  }
+});
+
+// src/t3-client.ts
+var t3_client_exports = {};
+__export(t3_client_exports, {
+  SignupEmailTakenError: () => SignupEmailTakenError,
+  T3TimeoutError: () => T3TimeoutError,
+  loadEgressHosts: () => loadEgressHosts,
+  openT3Client: () => openT3Client,
+  signupTenant: () => signupTenant
+});
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import fs3 from "node:fs";
+import path3 from "node:path";
+function withDeadline(promise, label, ms = T3_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new T3TimeoutError(`T3 ${label} timed out after ${ms}ms`)), ms);
+    if (typeof timer.unref === "function") timer.unref();
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+function egressCachePath() {
+  return process.env.BLINDFOLD_EGRESS_CACHE ?? path3.join(stateDir(), "egress-hosts.json");
+}
+function loadEgressHosts(did) {
+  try {
+    const all = JSON.parse(fs3.readFileSync(egressCachePath(), "utf8"));
+    return Array.isArray(all[did]) ? all[did] : [];
+  } catch {
+    return [];
+  }
+}
+function saveEgressHosts(did, hosts) {
+  const p = egressCachePath();
+  withFileLockSync(p, () => {
+    let all = {};
+    try {
+      all = JSON.parse(fs3.readFileSync(p, "utf8"));
+    } catch {
+    }
+    const existing = Array.isArray(all[did]) ? all[did] : [];
+    all[did] = Array.from(/* @__PURE__ */ new Set([...existing, ...hosts])).sort();
+    fs3.mkdirSync(path3.dirname(p), { recursive: true });
+    fs3.writeFileSync(p, JSON.stringify(all, null, 2));
+  });
+}
+async function loadSdk() {
+  if (sdkCache) return sdkCache;
+  try {
+    const mod = await import("@terminal3/t3n-sdk");
+    sdkCache = mod;
+    return mod;
+  } catch {
+    throw new Error(
+      "@terminal3/t3n-sdk not installed. Run `npm install @terminal3/t3n-sdk` for REAL T3 mode, or set BLINDFOLD_MOCK=1 to keep using mock mode."
+    );
+  }
+}
+async function signupTenant(opts) {
+  const sdk = await loadSdk();
+  sdk.setEnvironment(opts.env);
+  const baseUrl = opts.baseUrl || sdk.NODE_URLS[opts.env];
+  const wasmComponent = await sdk.loadWasmComponent();
+  const key = "0x" + randomBytes(32).toString("hex");
+  const address = sdk.eth_get_address(key);
+  const t3n = new sdk.T3nClient({
+    baseUrl,
+    wasmComponent,
+    handlers: { EthSign: sdk.metamask_sign(address, void 0, key) }
+  });
+  await t3n.handshake();
+  const did = String(await t3n.authenticate(sdk.createEthAuthInput(address)));
+  const channel = { emailChannel: { emailAddress: opts.email } };
+  await t3n.otpRequest(channel);
+  const code = String(await opts.getOtpCode(opts.email, "email")).trim();
+  const verify = await t3n.otpVerify({ otpCode: code, request: channel });
+  if (verify.mergeSuggestion) {
+    throw new SignupEmailTakenError(opts.email, verify.mergeSuggestion.existingDid);
+  }
+  if (verify.status === "otp_failed" || verify.status === "otp_expired") {
+    throw new Error(
+      verify.status === "otp_expired" ? "the code expired \u2014 run `blindfold signup` again to get a fresh one" : "that code was incorrect \u2014 re-run `blindfold signup` and enter the emailed code"
+    );
+  }
+  if (opts.onKeyReady) await opts.onKeyReady(key, did);
+  const result = await t3n.submitUserInput({
+    profile: { email_address: opts.email, ...opts.profile ?? {} },
+    becomeDevTenant: true
+  });
+  const admit = result.tenantAdmit;
+  return {
+    key,
+    did,
+    address,
+    env: opts.env,
+    admitStatus: admit?.status ?? "unknown",
+    grantedCredits: admit?.grantedCredits,
+    refusedReason: admit?.reason,
+    refusedDetail: admit?.detail
+  };
+}
+async function openT3Client(env) {
+  if (env.mock) return openMockClient();
+  assertRealReady(env);
+  return openRealClient(env);
+}
+async function openRealClient(env) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(env.t3nApiKey)) {
+    throw new Error("T3N_API_KEY must be a 0x-prefixed 32-byte hex (secp256k1 private key).");
+  }
+  if (!/^did:t3n:[0-9a-fA-F]+$/.test(env.did)) {
+    throw new Error('DID must look like "did:t3n:<hex>".');
+  }
+  const sdk = await loadSdk();
+  sdk.setEnvironment(env.t3Env);
+  const baseUrl = env.t3BaseUrl || sdk.NODE_URLS[env.t3Env];
+  const wasmComponent = await sdk.loadWasmComponent();
+  const address = sdk.eth_get_address(env.t3nApiKey);
+  const t3n = new sdk.T3nClient({
+    baseUrl,
+    wasmComponent,
+    handlers: { EthSign: sdk.metamask_sign(address, void 0, env.t3nApiKey) }
+  });
+  await t3n.handshake();
+  await t3n.authenticate(sdk.createEthAuthInput(address));
+  const tenant = new sdk.TenantClient({
+    environment: env.t3Env,
+    baseUrl,
+    tenantDid: env.did,
+    t3n
+  });
+  const seedSecret = async (name, value) => {
+    await tenant.executeControl("map-entry-set", {
+      map_name: tenant.canonicalName("secrets"),
+      key: name,
+      value
+    });
+    safeLog("info", { msg: "seeded", name });
+  };
+  const registerContract4 = async (wasm) => {
+    const r = await tenant.contracts.register({
+      tail: CONTRACT_TAIL,
+      version: CONTRACT_VERSION,
+      wasm
+    });
+    return {
+      contractId: r.contract_id ?? r.contractId ?? "(unknown)"
+    };
+  };
+  const invokeForward = async (req) => {
+    const raw = await withDeadline(tenant.contracts.execute(CONTRACT_TAIL, {
+      version: CONTRACT_VERSION,
+      functionName: "forward",
+      input: req
+    }), "forward");
+    if (typeof raw.status === "number" && Array.isArray(raw.headers)) {
+      return { status: raw.status, headers: raw.headers, body: raw.body ?? "" };
+    }
+    return {
+      status: raw.code ?? 502,
+      headers: [["content-type", "application/json"]],
+      body: raw.body ?? ""
+    };
+  };
+  const decodeSecret = (v) => {
+    if (typeof v === "string") return v;
+    if (Array.isArray(v)) return Buffer.from(v).toString("utf8");
+    if (v && typeof v === "object") {
+      const o = v;
+      if (typeof o.value === "string") return o.value;
+      if (Array.isArray(o.value)) return Buffer.from(o.value).toString("utf8");
+      const entry = o.entry;
+      if (entry && typeof entry.value === "string") return entry.value;
+    }
+    return "";
+  };
+  const releaseSecret = async (name) => {
+    try {
+      const r = await withDeadline(tenant.contracts.execute(CONTRACT_TAIL, {
+        version: CONTRACT_VERSION,
+        functionName: "release-to-tenant",
+        input: { secret_key: name }
+      }), "release-to-tenant");
+      if (r && r.ok && r.value) return r.value;
+    } catch (e) {
+      if (e instanceof T3TimeoutError) throw e;
+    }
+    const direct = decodeSecret(
+      await withDeadline(tenant.executeControl("map-entry-get", {
+        map_name: tenant.canonicalName("secrets"),
+        key: name
+      }), "map-entry-get")
+    );
+    if (!direct) throw new Error(`secret "${name}" not found in the secrets map`);
+    return direct;
+  };
+  const me = async () => {
+    const info2 = await tenant.tenant.me();
+    return { tenant: String(info2.tenant ?? ""), status: info2.status };
+  };
+  const agentAuthUpdate = async (agentDid, hosts, functions) => {
+    let ucv = "0.1.0";
+    if (typeof sdk.getScriptVersion === "function") {
+      try {
+        const v = await sdk.getScriptVersion(baseUrl, "tee:user/contracts");
+        if (typeof v === "string" && /^\d/.test(v)) ucv = v;
+      } catch {
+      }
+    }
+    const didHex = env.did.replace(/^did:t3n:/, "");
+    const revoking = functions.length === 0 && hosts.length === 0;
+    const scripts = [{
+      scriptName: `z:${didHex}:${CONTRACT_TAIL}`,
+      versionReq: `>=${CONTRACT_VERSION}`,
+      functions: revoking ? ["forward"] : functions,
+      allowedHosts: revoking ? [] : hosts
+    }];
+    await t3n.execute({
+      script_name: "tee:user/contracts",
+      script_version: ucv,
+      function_name: "agent-auth-update",
+      input: { agents: [{ agentDid, scripts }] }
+    });
+  };
+  const grantEgress = async (hosts, opts) => {
+    const prev = opts?.replace ? [] : loadEgressHosts(env.did);
+    const merged = Array.from(/* @__PURE__ */ new Set([...prev, ...hosts])).sort();
+    await agentAuthUpdate(env.did, merged, ["forward", "release-to-tenant"]);
+    saveEgressHosts(env.did, merged);
+    return merged;
+  };
+  const setAgentGrant = (agentDid, hosts, functions) => agentAuthUpdate(agentDid, hosts, functions);
+  const verifySecret = async (name) => {
+    try {
+      const value = await releaseSecret(name);
+      return { present: true, length: value.length, fingerprint: createHash2("sha256").update(value).digest("hex").slice(0, 8) };
+    } catch {
+      return { present: false, length: 0, fingerprint: "" };
+    }
+  };
+  const getBalance = async () => {
+    const page = await withDeadline(tenant.token.getUsage(), "token.getUsage");
+    const b = page.balance ?? {};
+    return {
+      available: Number(b.available ?? 0),
+      reserved: Number(b.reserved ?? 0),
+      creditExhausted: Boolean(b.credit_exhausted),
+      storageDeposit: b.storage_deposit != null ? Number(b.storage_deposit) : void 0
+    };
+  };
+  return {
+    close: async () => {
+    },
+    seedSecret,
+    invokeForward,
+    registerContract: registerContract4,
+    releaseSecret,
+    me,
+    grantEgress,
+    setAgentGrant,
+    verifySecret,
+    getBalance,
+    isReal: true
+  };
+}
+function openMockClient() {
+  return {
+    close: async () => {
+    },
+    async seedSecret(name, value) {
+      if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
+      safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
+    },
+    async registerContract(wasm) {
+      safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
+      return { contractId: "mock-contract-1" };
+    },
+    async invokeForward(req) {
+      safeLog("info", {
+        msg: "mock-forward",
+        method: req.method,
+        url: schemeAndHost(req.url),
+        secret_key: req.secret_key
+      });
+      const body = `{"mock":true,"note":"Blindfold mock mode \u2014 no real call made.","echo":{"url":${JSON.stringify(req.url)}}}`;
+      return { status: 200, headers: [["content-type", "application/json"]], body };
+    },
+    async releaseSecret(name) {
+      safeLog("info", { msg: "mock-release", name });
+      return `mock-released:${name}`;
+    },
+    async me() {
+      return { tenant: "did:t3n:mock", status: "active" };
+    },
+    async grantEgress(hosts) {
+      safeLog("info", { msg: "mock-grant-egress", hosts });
+      return hosts;
+    },
+    async setAgentGrant(agentDid, hosts, functions) {
+      safeLog("info", { msg: "mock-set-agent-grant", agentDid, hosts, functions });
+    },
+    async verifySecret(name) {
+      return { present: true, length: 0, fingerprint: `mock-${name}`.slice(0, 8) };
+    },
+    async getBalance() {
+      return { available: 1e9, reserved: 0, creditExhausted: false, mock: true };
+    },
+    isReal: false
+  };
+}
+function schemeAndHost(url) {
+  try {
+    const u = new URL(url);
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return "<bad-url>";
+  }
+}
+var T3_TIMEOUT_MS, T3TimeoutError, sdkCache, SignupEmailTakenError;
+var init_t3_client = __esm({
+  "src/t3-client.ts"() {
+    "use strict";
+    init_constants();
+    init_env();
+    init_log();
+    T3_TIMEOUT_MS = Number(process.env.BLINDFOLD_T3_TIMEOUT_MS) || 3e4;
+    T3TimeoutError = class extends Error {
+    };
+    sdkCache = null;
+    SignupEmailTakenError = class extends Error {
+      constructor(email, existingDid) {
+        super(`"${email}" is already registered to Terminal 3 tenant ${existingDid}.`);
+        this.email = email;
+        this.existingDid = existingDid;
+        this.name = "SignupEmailTakenError";
+      }
+    };
+  }
+});
+
+// src/sealed-ledger.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+import { createHash as createHash3, createHmac, randomBytes as randomBytes2 } from "node:crypto";
+function defaultSealedLogPath() {
+  return process.env.BLINDFOLD_SEALED_LOG ?? path4.join(stateDir(), "sealed.jsonl");
+}
+function ledgerKey() {
+  try {
+    const keyPath = path4.join(stateDir(), "ledger.key");
+    if (fs5.existsSync(keyPath)) return Buffer.from(fs5.readFileSync(keyPath, "utf8").trim(), "hex");
+    fs5.mkdirSync(path4.dirname(keyPath), { recursive: true });
+    const key = randomBytes2(32);
+    fs5.writeFileSync(keyPath, key.toString("hex"), { mode: 384 });
+    try {
+      fs5.chmodSync(keyPath, 384);
+    } catch {
+    }
+    return key;
+  } catch {
+    return null;
+  }
+}
+function coreString(e) {
+  return JSON.stringify({
+    t: e.t,
+    name: e.name,
+    source: e.source,
+    length: e.length,
+    mode: e.mode,
+    tenant_did: e.tenant_did,
+    map_name: e.map_name
+  });
+}
+function sha(s) {
+  return createHash3("sha256").update(s).digest("hex");
+}
+function chainHash(key, prev, core) {
+  if (key) return { hash: createHmac("sha256", key).update(`${prev}
+${core}`).digest("hex"), alg: "hmac-sha256" };
+  return { hash: sha(`${prev}
+${core}`) };
+}
+function readLastLine(p) {
+  if (!fs5.existsSync(p)) return null;
+  const fd = fs5.openSync(p, "r");
+  try {
+    const size = fs5.fstatSync(fd).size;
+    if (size === 0) return null;
+    const readLen = Math.min(size, 64 * 1024);
+    const buf = Buffer.alloc(readLen);
+    fs5.readSync(fd, buf, 0, readLen, size - readLen);
+    const lines = buf.toString("utf8").split("\n").filter((l) => l.trim().length > 0);
+    return lines.length ? lines[lines.length - 1] : null;
+  } finally {
+    fs5.closeSync(fd);
+  }
+}
+function recordSealed(entry) {
+  const p = defaultSealedLogPath();
+  try {
+    withFileLockSync(p, () => {
+      let prevHash = "";
+      const last = readLastLine(p);
+      if (last) {
+        try {
+          prevHash = JSON.parse(last).hash ?? "";
+        } catch {
+          prevHash = "";
+        }
+      }
+      const { hash, alg } = chainHash(ledgerKey(), prevHash, coreString(entry));
+      const chained = { ...entry, prev: prevHash, hash, ...alg ? { alg } : {} };
+      fs5.mkdirSync(path4.dirname(p), { recursive: true });
+      fs5.appendFileSync(p, JSON.stringify(chained) + "\n");
+    });
+  } catch {
+  }
+}
+function readSealed() {
+  const p = defaultSealedLogPath();
+  if (!fs5.existsSync(p)) return [];
+  return fs5.readFileSync(p, "utf8").split("\n").filter(Boolean).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+}
+function verifyLedgerChain() {
+  const entries = readSealed();
+  const key = ledgerKey();
+  let runningPrev = "";
+  let legacy = 0;
+  let firstBrokenIndex = -1;
+  entries.forEach((e, i) => {
+    if (!e.hash) {
+      legacy++;
+      return;
+    }
+    if (e.alg === "hmac-sha256") {
+      const expected = key ? createHmac("sha256", key).update(`${runningPrev}
+${coreString(e)}`).digest("hex") : null;
+      if (firstBrokenIndex < 0 && (e.prev !== runningPrev || expected !== null && e.hash !== expected)) {
+        firstBrokenIndex = i;
+      }
+      if (expected === null) legacy++;
+    } else {
+      legacy++;
+    }
+    runningPrev = e.hash;
+  });
+  return { ok: firstBrokenIndex < 0, total: entries.length, legacy, firstBrokenIndex };
+}
+var init_sealed_ledger = __esm({
+  "src/sealed-ledger.ts"() {
+    "use strict";
+    init_env();
+  }
+});
+
+// src/register.ts
+async function registerSecret(opts) {
+  const env = loadBlindfoldEnv();
+  const t3 = await openT3Client(env);
+  try {
+    let source = "stdin";
+    let value;
+    if (opts.value !== void 0) {
+      value = opts.value;
+      source = "explicit";
+    } else if (opts.fromEnv) {
+      value = pluckSecret(opts.fromEnv);
+      source = `env:${opts.fromEnv}`;
+    } else {
+      value = await readSecretLine(`  Value for "${opts.name}" (input is hidden): `);
+      if (!value) throw new Error("empty value");
+    }
+    if (value.includes(SENTINEL)) {
+      throw new Error(`Secret value contains the Blindfold sentinel string "${SENTINEL}" \u2014 this would cause infinite substitution. Use a different value.`);
+    }
+    await t3.seedSecret(opts.name, value);
+    const length = value.length;
+    const mode = env.mock ? "mock" : "real";
+    recordSealed({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      name: opts.name,
+      source,
+      length,
+      mode,
+      tenant_did: env.did,
+      map_name: env.did ? `z:${env.did.replace(/^did:t3n:/, "")}:secrets` : "(mock)"
+    });
+    safeLog("info", { msg: "registered", name: opts.name, source, length, mode });
+  } finally {
+    await t3.close();
+  }
+}
+async function registerContract(wasm) {
+  const env = loadBlindfoldEnv();
+  const t3 = await openT3Client(env);
+  try {
+    return await t3.registerContract(wasm);
+  } finally {
+    await t3.close();
+  }
+}
+var init_register = __esm({
+  "src/register.ts"() {
+    "use strict";
+    init_env();
+    init_log();
+    init_prompt();
+    init_sealed_ledger();
+    init_t3_client();
+    init_constants();
+  }
+});
+
+// src/usage-log.ts
+import fs7 from "node:fs";
+import path6 from "node:path";
+function defaultLogPath() {
+  return process.env.BLINDFOLD_USAGE_LOG ?? path6.join(stateDir(), "usage.jsonl");
+}
+function rotateIfNeeded(p) {
+  try {
+    const size = fs7.statSync(p).size;
+    if (size < USAGE_MAX_BYTES) return;
+    if (fs7.existsSync(`${p}.1`)) fs7.renameSync(`${p}.1`, `${p}.2`);
+    fs7.renameSync(p, `${p}.1`);
+  } catch {
+  }
+}
+function logUsage(event) {
+  const p = defaultLogPath();
+  try {
+    const dir = path6.dirname(p);
+    if (!ensuredDirs.has(dir)) {
+      fs7.mkdirSync(dir, { recursive: true });
+      ensuredDirs.add(dir);
+    }
+    if (++writesSinceRotateCheck >= ROTATE_CHECK_EVERY) {
+      writesSinceRotateCheck = 0;
+      rotateIfNeeded(p);
+    }
+    fs7.appendFile(p, JSON.stringify(event) + "\n", () => {
+    });
+  } catch {
+  }
+}
+function readUsage() {
+  const p = defaultLogPath();
+  if (!fs7.existsSync(p)) return [];
+  return fs7.readFileSync(p, "utf8").split("\n").filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+}
+function readUsageTail(n = 500) {
+  const p = defaultLogPath();
+  if (!fs7.existsSync(p)) return [];
+  const fd = fs7.openSync(p, "r");
+  try {
+    const size = fs7.fstatSync(fd).size;
+    const readLen = Math.min(size, Math.max(64 * 1024, n * 2048));
+    const buf = Buffer.alloc(readLen);
+    fs7.readSync(fd, buf, 0, readLen, size - readLen);
+    let text = buf.toString("utf8");
+    if (readLen < size) {
+      const nl = text.indexOf("\n");
+      if (nl >= 0) text = text.slice(nl + 1);
+    }
+    const events = text.split("\n").filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+    return events.slice(-n);
+  } finally {
+    fs7.closeSync(fd);
+  }
+}
+function clearUsage() {
+  const p = defaultLogPath();
+  if (fs7.existsSync(p)) fs7.unlinkSync(p);
+}
+function providerForUpstream(upstream) {
+  try {
+    const u = new URL(upstream);
+    const h = u.hostname;
+    if (h.endsWith("openai.com")) return "openai";
+    if (h.endsWith("anthropic.com")) return "anthropic";
+    if (h.endsWith("googleapis.com")) return "google";
+    if (h.endsWith("x.ai")) return "xai";
+    if (h.endsWith("groq.com")) return "groq";
+    return h;
+  } catch {
+    return "unknown";
+  }
+}
+var USAGE_MAX_BYTES, ensuredDirs, ROTATE_CHECK_EVERY, writesSinceRotateCheck;
+var init_usage_log = __esm({
+  "src/usage-log.ts"() {
+    "use strict";
+    init_env();
+    USAGE_MAX_BYTES = Number(process.env.BLINDFOLD_USAGE_MAX_BYTES) || 10 * 1024 * 1024;
+    ensuredDirs = /* @__PURE__ */ new Set();
+    ROTATE_CHECK_EVERY = 500;
+    writesSinceRotateCheck = ROTATE_CHECK_EVERY;
+  }
+});
+
+// src/release.ts
+var release_exports = {};
+__export(release_exports, {
+  release: () => release
+});
+function sharedClient(env) {
+  const key = `${env.did}|${env.t3Env}|${env.t3BaseUrl}|${env.mock ? 1 : 0}`;
+  let c2 = clientCache.get(key);
+  if (!c2) {
+    c2 = openT3Client(env).catch((e) => {
+      clientCache.delete(key);
+      throw e;
+    });
+    clientCache.set(key, c2);
+  }
+  return c2;
+}
+async function release(name, opts) {
+  const env = opts?.env ?? loadBlindfoldEnv();
+  const useShared = !opts?.env;
+  const t3 = useShared ? await sharedClient(env) : await openT3Client(env);
+  const startedAt = Date.now();
+  try {
+    const value = await t3.releaseSecret(name);
+    logUsage({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: env.mock ? "mock" : "real",
+      provider: "(enclave)",
+      method: "RELEASE",
+      path: name,
+      upstream: "t3-enclave",
+      status: 200,
+      latency_ms: Date.now() - startedAt,
+      agent_supplied_auth: false,
+      sentinel_in_outbound: false,
+      via: opts?.via ?? "release",
+      secret_key: name
+    });
+    return value;
+  } finally {
+    if (!useShared) await t3.close();
+  }
+}
+var clientCache;
+var init_release = __esm({
+  "src/release.ts"() {
+    "use strict";
+    init_env();
+    init_t3_client();
+    init_usage_log();
+    clientCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/versions.ts
+var versions_exports = {};
+__export(versions_exports, {
+  defaultVersionsPath: () => defaultVersionsPath,
+  isValidVersionKey: () => isValidVersionKey,
+  readVersions: () => readVersions,
+  recordVersion: () => recordVersion,
+  versionKeyFor: () => versionKeyFor
+});
+import fs9 from "node:fs";
+import path7 from "node:path";
+function defaultVersionsPath() {
+  return process.env.BLINDFOLD_VERSIONS_LOG ?? path7.join(stateDir(), "versions.jsonl");
+}
+function versionKeyFor(name, stampMs) {
+  return `__bfver__${name}__${stampMs}`;
+}
+function isValidVersionKey(name, versionKey) {
+  return new RegExp(`^__bfver__${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}__\\d+$`).test(versionKey);
+}
+function recordVersion(entry) {
+  const p = defaultVersionsPath();
+  try {
+    fs9.mkdirSync(path7.dirname(p), { recursive: true });
+    fs9.appendFileSync(p, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+function readVersions(name) {
+  const p = defaultVersionsPath();
+  if (!fs9.existsSync(p)) return [];
+  const all = fs9.readFileSync(p, "utf8").split("\n").filter(Boolean).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+  return name ? all.filter((e) => e.name === name) : all;
+}
+var init_versions = __esm({
+  "src/versions.ts"() {
+    "use strict";
+    init_env();
+  }
+});
+
+// src/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  planMigration: () => planMigration,
+  runMigrate: () => runMigrate
+});
+import fs10 from "node:fs";
+function isConfigName(k) {
+  return /(_HOST|_URL|_PORT|_EMAIL|_ENV|_REGION|_BASE_URL|_USER|_USERNAME)$/i.test(k) || /^(NODE_ENV|PORT|HOST|PATH|HOME|USER|SHELL|LANG|PWD)$/i.test(k);
+}
+function isAltT3(k) {
+  return /^t\d+_/i.test(k) || /_DID$/i.test(k);
+}
+function looksSecret(k) {
+  return /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|_API|API_|_PAT|CREDENTIAL|ACCESS|PRIVATE)/i.test(k);
+}
+function readEnvVars(envPath) {
+  const lines = fs10.existsSync(envPath) ? fs10.readFileSync(envPath, "utf8").split(/\r?\n/) : [];
+  const keys = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    keys.push(line.slice(0, eq).trim());
+  }
+  return { keys, lines };
+}
+function planMigration(envPath = defaultEnvPath()) {
+  loadEnvFromFile(envPath);
+  const { keys } = readEnvVars(envPath);
+  const seen = /* @__PURE__ */ new Set();
+  const plan = [];
+  for (const k of keys) {
+    if (seen.has(k)) continue;
+    seen.add(k);
+    const val = process.env[k] ?? "";
+    const base = { envVar: k, sealName: k.toLowerCase(), bytes: val.length, action: "skip" };
+    if (NEVER_SEAL.has(k)) plan.push({ ...base, reason: "root cred / config \u2014 must stay in .env" });
+    else if (isAltT3(k)) plan.push({ ...base, reason: "T3 team key/DID \u2014 root cred" });
+    else if (isConfigName(k)) plan.push({ ...base, reason: "config, not a secret" });
+    else if (!val) plan.push({ ...base, reason: "empty" });
+    else if (!looksSecret(k)) plan.push({ ...base, reason: "name doesn't look like a secret (seal manually if it is)" });
+    else plan.push({ ...base, action: "seal" });
+  }
+  return plan;
+}
+async function runMigrate(opts = {}) {
+  const envPath = opts.envPath ?? defaultEnvPath();
+  const plan = planMigration(envPath);
+  const results = [];
+  const sealedVars = /* @__PURE__ */ new Set();
+  for (const item of plan) {
+    if (item.action !== "seal") {
+      results.push(item);
+      continue;
+    }
+    try {
+      await registerSecret({ name: item.sealName, fromEnv: item.envVar });
+      sealedVars.add(item.envVar);
+      results.push({ ...item, sealed: true });
+    } catch (e) {
+      results.push({ ...item, sealed: false, error: e.message });
+    }
+  }
+  if (sealedVars.size > 0) {
+    const original = fs10.readFileSync(envPath, "utf8");
+    const backupPath = `${envPath}.bak.${Math.floor(Date.now() / 1e3)}`;
+    fs10.writeFileSync(backupPath, original, { mode: 384 });
+    try {
+      fs10.chmodSync(backupPath, 384);
+    } catch {
+    }
+    console.warn(
+      `\u26A0\uFE0F  Wrote a PLAINTEXT backup of your secrets to ${backupPath} (mode 0600). Delete it once you've verified the migration: rm "${backupPath}"`
+    );
+    const out = [];
+    for (const raw of original.split(/\r?\n/)) {
+      const eq = raw.indexOf("=");
+      const key = eq > 0 ? raw.slice(0, eq).trim() : "";
+      if (key && sealedVars.has(key) && !raw.trim().startsWith("#")) {
+        if (opts.keep) out.push(`# sealed\u2192enclave: ${key}  (value lives in T3, use \`blindfold use --name ${key.toLowerCase()}\`)`);
+      } else {
+        out.push(raw);
+      }
+    }
+    fs10.writeFileSync(envPath, out.join("\n"));
+  }
+  return results;
+}
+var NEVER_SEAL;
+var init_migrate = __esm({
+  "src/migrate.ts"() {
+    "use strict";
+    init_env();
+    init_register();
+    NEVER_SEAL = /* @__PURE__ */ new Set([
+      "T3N_API_KEY",
+      "DID",
+      "BLINDFOLD_MOCK",
+      "BLINDFOLD_PORT",
+      "BLINDFOLD_T3_ENV",
+      "BLINDFOLD_DASHBOARD_PORT",
+      "BLINDFOLD_BASE_URL"
+    ]);
+  }
+});
+
+// bin/cli-shared.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+
+// src/color.ts
+var on = process.env.FORCE_COLOR === "1" || !process.env.NO_COLOR && process.env.TERM !== "dumb" && Boolean(process.stdout.isTTY);
+var wrap = (code) => (s) => on ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = {
+  bold: wrap("1"),
+  dim: wrap("2"),
+  red: wrap("31"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  blue: wrap("34"),
+  magenta: wrap("35"),
+  cyan: wrap("36"),
+  gray: wrap("90")
+};
+var ok = (s) => c.green(s);
+var bad = (s) => c.red(s);
+var warn = (s) => c.yellow(s);
+var head = (s) => c.bold(c.cyan(s));
+
+// bin/cli-shared.ts
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+var REPO_ROOT = path.resolve(HERE, "..", "..", "..");
+var PKG_ROOT = path.resolve(HERE, "..");
+function assetPath(repoRelative, assetName) {
+  const repoPath = path.join(REPO_ROOT, ...repoRelative.split("/"));
+  if (fs.existsSync(repoPath)) return repoPath;
+  return path.join(PKG_ROOT, "assets", assetName);
+}
+function parseArgv(argv) {
+  const out = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i] ?? "";
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        out.flags[key] = next;
+        i += 1;
+      } else {
+        out.flags[key] = true;
+      }
+    } else {
+      out._.push(a);
+    }
+  }
+  return out;
+}
+function fingerprint(s) {
+  return createHash("sha256").update(s).digest("hex").slice(0, 8);
+}
+var TOOL_ENV = {
+  gh: "GH_TOKEN",
+  git: "GH_TOKEN",
+  glab: "GITLAB_TOKEN",
+  psql: "PGPASSWORD",
+  pg_dump: "PGPASSWORD",
+  mysql: "MYSQL_PWD",
+  aws: "AWS_SECRET_ACCESS_KEY",
+  stripe: "STRIPE_API_KEY",
+  vercel: "VERCEL_TOKEN",
+  npm: "NPM_TOKEN",
+  docker: "DOCKER_PASSWORD",
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  doctl: "DIGITALOCEAN_ACCESS_TOKEN",
+  heroku: "HEROKU_API_KEY",
+  cloudflared: "CLOUDFLARE_API_TOKEN",
+  wrangler: "CLOUDFLARE_API_TOKEN"
+};
+function resolveEnvVar(asFlag, command, name) {
+  if (asFlag) return asFlag;
+  if (command && TOOL_ENV[command]) return TOOL_ENV[command];
+  return name.toUpperCase();
+}
+function die(msg) {
+  console.error(c.red(`\u2716 ${msg}`));
+  process.exit(2);
+}
+
+// bin/cmd-auth.ts
+init_env();
+init_keychain();
+init_prompt();
+import fs4 from "node:fs";
+function saveTenantCredentials(did, key, env, forceFile) {
+  const cfg = configPath();
+  let existing = {};
+  try {
+    if (fs4.existsSync(cfg)) existing = JSON.parse(fs4.readFileSync(cfg, "utf8"));
+  } catch {
+  }
+  const merged = { ...existing, DID: did, BLINDFOLD_T3_ENV: env };
+  const triedKeychain = !forceFile && keychainAvailable();
+  const inKeychain = triedKeychain && keychainSet(did, key);
+  if (inKeychain) {
+    merged.T3N_API_KEY_STORE = "keychain";
+    delete merged.T3N_API_KEY;
+  } else {
+    merged.T3N_API_KEY = key;
+    merged.T3N_API_KEY_STORE = "file";
+  }
+  fs4.mkdirSync(homeDir(), { recursive: true });
+  fs4.writeFileSync(cfg, JSON.stringify(merged, null, 2), { mode: 384 });
+  try {
+    fs4.chmodSync(cfg, 384);
+  } catch {
+  }
+  return { inKeychain, triedKeychain, cfg };
+}
+async function handleAuth(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "signup": {
+      const env = String(argv.flags.env ?? "").toLowerCase() === "production" ? "production" : "testnet";
+      if (env === "production") {
+        die("signup (self-admit) is testnet-only. Production tenants are provisioned by Terminal 3 directly.");
+      }
+      const email = argv.flags.email ? String(argv.flags.email) : (await readLine("Email for your tenant (a verification code will be sent): ")).trim();
+      if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) die("Enter a valid email address (e.g. you@example.com).");
+      console.log(`${head("blindfold signup")} \u2014 creating a Terminal 3 ${c.cyan("testnet")} tenant for ${c.cyan(email)}`);
+      console.log(c.dim("  A fresh tenant key (secp256k1) is generated locally and stored in your keychain \u2014 never printed.\n"));
+      const localPart = (email.split("@")[0] ?? "user").split("+")[0] ?? "user";
+      const firstName = argv.flags.first ? String(argv.flags.first) : localPart || "Blindfold";
+      const lastName = argv.flags.last ? String(argv.flags.last) : "Tenant";
+      const { signupTenant: signupTenant2, SignupEmailTakenError: SignupEmailTakenError2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const presetOtp = argv.flags.otp ? String(argv.flags.otp).trim() : "";
+      let saved = null;
+      let res;
+      try {
+        res = await signupTenant2({
+          env,
+          email,
+          profile: { first_name: firstName, last_name: lastName },
+          onKeyReady: (key, did) => {
+            saved = saveTenantCredentials(did, key, env, Boolean(argv.flags.file));
+          },
+          getOtpCode: async () => {
+            if (presetOtp) return presetOtp;
+            process.stderr.write(c.yellow(`  A verification code was emailed to ${email}.
+`));
+            return (await readLine("  Enter the code: ")).trim();
+          }
+        });
+      } catch (e) {
+        if (e instanceof SignupEmailTakenError2) {
+          console.error(c.red(`\u2716 ${e.message}`));
+          console.error(c.dim("  This email already has a tenant. Either:"));
+          console.error(c.dim(`    \u2022 log in with that tenant's key:  blindfold login --did ${e.existingDid}`));
+          console.error(c.dim("    \u2022 or sign up with a different email (Gmail '+' aliases work: you+blindfold@gmail.com)."));
+          process.exit(1);
+        }
+        if (saved) {
+          const s = saved;
+          console.error(c.red(`\u2716 Email verified and tenant key saved, but self-admit failed: ${e.message}`));
+          console.error(c.dim(`  Your key + DID are stored in ${s.inKeychain ? `the ${keychainBackend()}` : `${s.cfg} (0600)`} \u2014 not lost.`));
+          console.error(c.dim("  The tenant just wasn't funded. Check `blindfold credit`, or re-run `blindfold signup` with a fresh email for a new funded tenant."));
+          process.exit(1);
+        }
+        die(`signup failed: ${e.message}`);
+        return;
+      }
+      if (res.admitStatus === "refused") {
+        die(`Terminal 3 refused self-admit (${res.refusedReason ?? "unknown"})${res.refusedDetail ? `: ${res.refusedDetail}` : ""}.`);
+        return;
+      }
+      const { inKeychain, cfg } = saved ?? saveTenantCredentials(res.did, res.key, env, Boolean(argv.flags.file));
+      const verb = res.admitStatus === "already-admitted" ? "confirmed (already registered)" : "created";
+      console.log(ok(`
+\u2713 Tenant ${verb}: ${c.bold(res.did)}`));
+      console.log(`  Tenant key stored in ${inKeychain ? `the ${keychainBackend()}` : `${cfg} (0600)`} \u2014 never printed.`);
+      if (res.grantedCredits) {
+        console.log(ok(`  Welcome credits minted: ${res.grantedCredits} base units.`));
+      } else {
+        console.log(c.yellow("  No welcome credits were minted (the testnet dial may be 0). Check `blindfold credit`."));
+      }
+      console.log(`
+  Next:`);
+      console.log(`    ${c.bold("blindfold doctor")}    ${c.dim("# confirm T3 reachability")}`);
+      console.log(`    ${c.bold("blindfold credit")}    ${c.dim("# see your token balance")}`);
+      console.log(`    ${c.bold("blindfold register --name openai_key")}   ${c.dim("# seal your first secret")}`);
+      return;
+    }
+    case "login": {
+      const did = argv.flags.did ? String(argv.flags.did) : (await readSecretLine("Tenant DID (did:t3n:\u2026): ")).trim();
+      if (!/^did:t3n:[0-9a-fA-F]+$/.test(did)) die('DID must look like "did:t3n:<hex>".');
+      const key = argv.flags.key ? String(argv.flags.key) : (await readSecretLine("T3N_API_KEY (0x\u2026, hidden): ")).trim();
+      if (!/^0x[0-9a-fA-F]{64}$/.test(key)) die("T3N_API_KEY must be a 0x-prefixed 32-byte hex.");
+      const env = String(argv.flags.env ?? "").toLowerCase() === "production" ? "production" : "testnet";
+      const { inKeychain, triedKeychain, cfg } = saveTenantCredentials(did, key, env, Boolean(argv.flags.file));
+      console.log(`\u2713 Saved tenant key to ${inKeychain ? `the ${keychainBackend()}` : `${cfg} (mode 0600)`}. Blindfold now works from any directory.`);
+      console.log(`  Tenant: ${did}  \xB7  env: ${env}  \xB7  key: stored (never printed)`);
+      if (!inKeychain && !argv.flags.file) {
+        console.log(triedKeychain ? `  (Keychain write unavailable here \u2014 stored in a 0600 file. Run \`blindfold login\` in an interactive desktop session to use ${keychainBackend()}.)` : `  (No OS keychain found \u2014 stored in a 0600 file. On macOS/Linux/Windows an interactive session uses the OS credential store automatically.)`);
+      }
+      console.log(`  Verify: blindfold doctor`);
+      return;
+    }
+    case "logout": {
+      const cfg = configPath();
+      let did = "";
+      let store = "";
+      try {
+        if (fs4.existsSync(cfg)) {
+          const o = JSON.parse(fs4.readFileSync(cfg, "utf8"));
+          did = o.DID ?? "";
+          store = o.T3N_API_KEY_STORE ?? "";
+        }
+      } catch {
+      }
+      let removed = false;
+      if (store === "keychain" && did && keychainAvailable()) {
+        if (keychainDelete(did)) {
+          console.log("\u2713 Removed tenant key from the OS keychain.");
+          removed = true;
+        }
+      }
+      if (fs4.existsSync(cfg)) {
+        fs4.rmSync(cfg, { force: true });
+        console.log(`\u2713 Removed ${cfg}.`);
+        removed = true;
+      }
+      if (!removed) console.log("Nothing to remove \u2014 no saved credentials at " + cfg);
+      else console.log("Tenant credentials cleared from this machine.");
+      return;
+    }
+    case "whoami": {
+      const cfg = configPath();
+      let store = "";
+      try {
+        if (fs4.existsSync(cfg)) store = JSON.parse(fs4.readFileSync(cfg, "utf8")).T3N_API_KEY_STORE ?? "";
+      } catch {
+      }
+      const env = loadBlindfoldEnv();
+      const keySource = !env.t3nApiKey ? "MISSING" : process.env.T3N_API_KEY && store === "keychain" ? `set (${keychainBackend()})` : store === "file" ? "set (config file, 0600)" : "set (env / repo .env)";
+      console.log(`${c.bold("config:")}  ${c.gray(cfg)}${fs4.existsSync(cfg) ? "" : "  (not present)"}`);
+      console.log(`${c.bold("tenant:")}  ${c.cyan(env.did || "(none \u2014 run `blindfold login`)")}`);
+      console.log(`${c.bold("env:")}     ${env.t3Env}   \xB7   key: ${c.green(keySource)}`);
+      return;
+    }
+  }
+}
+
+// bin/cmd-secrets.ts
+init_env();
+init_register();
+import fs8 from "node:fs";
+import { spawn } from "node:child_process";
+
+// src/attest.ts
+init_env();
+import fs6 from "node:fs";
+import path5 from "node:path";
+var PIN_FIELD = "expectedRtmr3";
+function readPinnedRtmr3() {
+  try {
+    const obj = JSON.parse(fs6.readFileSync(configPath(), "utf8"));
+    const v = obj[PIN_FIELD];
+    return typeof v === "string" && v ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writePinnedRtmr3(value) {
+  const cfg = configPath();
+  fs6.mkdirSync(path5.dirname(cfg), { recursive: true });
+  withFileLockSync(cfg, () => {
+    let obj = {};
+    try {
+      obj = JSON.parse(fs6.readFileSync(cfg, "utf8"));
+    } catch {
+    }
+    obj[PIN_FIELD] = value;
+    fs6.writeFileSync(cfg, JSON.stringify(obj, null, 2), { mode: 384 });
+    try {
+      fs6.chmodSync(cfg, 384);
+    } catch {
+    }
+  });
+}
+var ATTEST_TTL_MS = Number(process.env.BLINDFOLD_ATTEST_TTL_MS) || 3e5;
+var attestCache = /* @__PURE__ */ new Map();
+async function loadAttestSdk() {
+  try {
+    return await import("@terminal3/t3n-sdk");
+  } catch {
+    throw new Error(
+      "@terminal3/t3n-sdk not installed \u2014 attestation needs the real SDK. Run `npm install @terminal3/t3n-sdk`."
+    );
+  }
+}
+async function attest(opts = {}) {
+  const env = opts.env ?? loadBlindfoldEnv();
+  if (env.mock) {
+    throw new Error("attestation is unavailable in mock mode (BLINDFOLD_MOCK=1) \u2014 it needs a real T3 node.");
+  }
+  const cacheKey = `${env.t3Env}|${env.t3BaseUrl}|${opts.expectRtmr3 ?? ""}`;
+  if (!opts.noCache) {
+    const hit = attestCache.get(cacheKey);
+    if (hit && Date.now() - hit.at < ATTEST_TTL_MS) return hit.result;
+  }
+  const sdk = await loadAttestSdk();
+  sdk.setEnvironment(env.t3Env);
+  if (env.t3BaseUrl) sdk.setNodeUrl(env.t3BaseUrl);
+  const nodeUrl = sdk.getNodeUrl(env.t3BaseUrl || void 0);
+  const bundle = await sdk.fetchDkgAttestation(nodeUrl);
+  if (!bundle) {
+    const unavailable = { available: false, nodeUrl, valid: false, validCount: 0, expectedCount: 0, rtmr3s: [], pinned: false };
+    attestCache.set(cacheKey, { at: Date.now(), result: unavailable });
+    return unavailable;
+  }
+  const encapsKey = await sdk.fetchMlKemPublicKey(nodeUrl);
+  const r = await sdk.verifyDkgAttestation(
+    encapsKey,
+    bundle.attestation_msg,
+    bundle.peer_ids,
+    bundle.quotes,
+    opts.expectRtmr3
+  );
+  const rtmr3s = [...new Set(r.results.map((p) => p.rtmr3).filter((x) => Boolean(x)))];
+  const result = {
+    available: true,
+    nodeUrl,
+    valid: r.valid,
+    validCount: r.valid_count,
+    expectedCount: r.expected_count,
+    rtmr3s,
+    pinned: Boolean(opts.expectRtmr3) && r.valid,
+    error: r.error
+  };
+  attestCache.set(cacheKey, { at: Date.now(), result });
+  return result;
+}
+async function attestationGate(opts = {}) {
+  const env = opts.env ?? loadBlindfoldEnv();
+  const pinned = readPinnedRtmr3();
+  const required = Boolean(pinned) || process.env.BLINDFOLD_REQUIRE_ATTEST === "1";
+  if (opts.skip) {
+    return {
+      enforced: false,
+      ok: true,
+      warning: required ? "attestation gate BYPASSED via --no-attest \u2014 the enclave was NOT verified" : void 0
+    };
+  }
+  if (env.mock) {
+    if (required) {
+      return { enforced: true, ok: false, message: "refusing to run in mock mode while attestation is required (a pin or BLINDFOLD_REQUIRE_ATTEST is set) \u2014 mock mode never touches a real enclave" };
+    }
+    return { enforced: false, ok: true };
+  }
+  if (!required) return { enforced: false, ok: true };
+  let r;
+  try {
+    r = await attest({ env, expectRtmr3: pinned });
+  } catch (e) {
+    return { enforced: true, ok: false, message: e.message };
+  }
+  if (!r.available) return { enforced: true, ok: false, message: `node published no attestation (${r.nodeUrl})` };
+  if (opts.requirePin && !pinned) {
+    return {
+      enforced: true,
+      ok: false,
+      message: "refusing: this operation requires a pinned RTMR3 (run `blindfold attest --pin`). Unpinned attestation only proves it's a TDX enclave, not that it runs your expected code."
+    };
+  }
+  const ok3 = r.valid && (!pinned || r.pinned);
+  const warning = ok3 && !pinned ? "attestation valid but NO RTMR3 pinned \u2014 proves genuine TDX silicon, not that the enclave runs your expected code. Pin it: `blindfold attest --pin`." : void 0;
+  return {
+    enforced: true,
+    ok: ok3,
+    warning,
+    message: ok3 ? void 0 : `enclave attestation failed${pinned ? " (RTMR3 pin mismatch)" : ""} at ${r.nodeUrl}`
+  };
+}
+
+// bin/cmd-secrets.ts
+async function handleSecrets(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "register": {
+      const name = String(argv.flags.name ?? "");
+      const fromEnv = argv.flags["from-env"] ? String(argv.flags["from-env"]) : void 0;
+      if (!name) {
+        die("usage: blindfold register --name <KV_KEY> [--from-env <ENV_VAR>]");
+      }
+      const sealGate = await attestationGate({ skip: !!argv.flags["no-attest"], requirePin: true });
+      if (sealGate.warning) console.error(`\u26A0\uFE0F  ${sealGate.warning}`);
+      if (sealGate.enforced && !sealGate.ok) {
+        die(`attestation gate: ${sealGate.message}. Refusing to seal into an unverified enclave. (bypass: --no-attest, or clear the pin)`);
+      }
+      if (sealGate.enforced) console.log("\u2713 enclave attestation verified");
+      await registerSecret({ name, fromEnv });
+      if (fromEnv) {
+        console.log(`\u2713 Registered "${name}" (value read from ${fromEnv} once, then dropped).`);
+        console.log(`  You can now DELETE ${fromEnv} from your .env.`);
+      } else {
+        console.log(`\u2713 Registered "${name}" \u2014 value lives only in the enclave.`);
+      }
+      const asVar = name.toUpperCase();
+      console.log("");
+      console.log("  Use it (the plaintext never returns to your env):");
+      console.log(`    blindfold use --name ${name} -- <your command>       # injects ${asVar} into that command only`);
+      console.log(`    blindfold use --name ${name} --as ${asVar} -- <cmd>  # custom env-var name`);
+      console.log(`    blindfold use --name ${name} --url <https url>       # quick "does it auth?" check`);
+      console.log(`    proxy/SDK:  set the key to "__BLINDFOLD__" + route via \`blindfold proxy\`, or \`release("${name}")\` in code`);
+      return;
+    }
+    case "use": {
+      const name = String(argv.flags.name ?? "");
+      if (!name) {
+        die("usage: blindfold use --name <secret> [--as <ENV_VAR>] -- <command...>\n       blindfold use --name <secret> --url <https url>   (quick auth test)");
+      }
+      const { release: release2 } = await Promise.resolve().then(() => (init_release(), release_exports));
+      const value = await release2(name, { via: "use" });
+      if (argv.flags.check) {
+        console.log(`\u2713 "${name}" is sealed and usable \u2014 ${value.length} bytes (value never shown)`);
+        return;
+      }
+      if (argv.flags.url) {
+        const url = String(argv.flags.url);
+        if (!argv.flags["allow-insecure"]) {
+          let u;
+          try {
+            u = new URL(url);
+          } catch (e) {
+            die(`invalid --url: ${e.message}`);
+            return;
+          }
+          const isLocal = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(u.hostname);
+          if (u.protocol !== "https:" && !isLocal) {
+            die(`refusing to send the released key to a non-https URL (${u.protocol}//${u.hostname}). Use https, target localhost, or pass --allow-insecure to override.`);
+            return;
+          }
+          if (!isLocal) {
+            const { loadEgressHosts: loadEgressHosts2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+            const env = loadBlindfoldEnv();
+            const granted = loadEgressHosts2(env.did);
+            const allowed = granted.some((h) => h === u.hostname || u.hostname.endsWith(`.${h}`));
+            if (!allowed) {
+              die(`refusing to send the released key to ${u.hostname}: host is not in the egress allowlist. Run \`blindfold grant --host ${u.hostname}\` first, or pass --allow-insecure to override.`);
+              return;
+            }
+          }
+        }
+        const res = await fetch(url, {
+          headers: { Authorization: `Bearer ${value}`, "User-Agent": "blindfold", Accept: "*/*" }
+        });
+        console.log(`\u2713 released "${name}" (${value.length} B, value not shown) \u2192 ${url}`);
+        console.log(`  HTTP ${res.status} ${res.statusText}  ${res.ok ? "\u2705 accepted" : "\u2716 rejected"}`);
+        return;
+      }
+      if (cmdArgs.length === 0) {
+        die("provide a command after `--` (e.g. `-- gh api user`), or pass --url <url> to test auth");
+      }
+      const asVar = resolveEnvVar(argv.flags.as ? String(argv.flags.as) : void 0, cmdArgs[0], name);
+      console.error(`\u2713 released "${name}" (${value.length} B) \u2192 injecting $${asVar} into: ${cmdArgs.join(" ")}`);
+      const child = spawn(cmdArgs[0], cmdArgs.slice(1), {
+        stdio: "inherit",
+        env: { ...process.env, [asVar]: value }
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+      child.on("error", (e) => die(`failed to run "${cmdArgs[0]}": ${e.message}`));
+      return;
+    }
+    case "export": {
+      const name = String(argv.flags.name ?? "");
+      if (!name) die("usage: blindfold export --name <secret> [--as <ENV_VAR>]   (for GitHub Actions / CI)");
+      const ghEnv = process.env.GITHUB_ENV;
+      if (!ghEnv) die("`export` writes to $GITHUB_ENV (GitHub Actions only). Use `blindfold use` locally.");
+      const asVar = resolveEnvVar(argv.flags.as ? String(argv.flags.as) : void 0, void 0, name);
+      const { release: release2 } = await Promise.resolve().then(() => (init_release(), release_exports));
+      const value = await release2(name, { via: "export" });
+      console.log(`::add-mask::${value}`);
+      fs8.appendFileSync(ghEnv, `${asVar}=${value}
+`);
+      console.error(`\u2713 exported $${asVar} from sealed "${name}" (${value.length} B, masked in logs)`);
+      return;
+    }
+  }
+}
+
+// bin/cmd-lifecycle.ts
+init_env();
+init_register();
+async function handleLifecycle(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "rotate": {
+      const name = String(argv.flags.name ?? "");
+      const fromEnv = argv.flags["from-env"] ? String(argv.flags["from-env"]) : void 0;
+      if (!name) {
+        die("usage: blindfold rotate --name <secret> [--from-env <ENV_VAR>]");
+      }
+      const env = loadBlindfoldEnv();
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const { recordVersion: recordVersion2, versionKeyFor: versionKeyFor2 } = await Promise.resolve().then(() => (init_versions(), versions_exports));
+      const client = await openT3Client2(env);
+      try {
+        try {
+          const old = await client.releaseSecret(name);
+          const vKey = versionKeyFor2(name, Date.now());
+          await client.seedSecret(vKey, old);
+          recordVersion2({ t: (/* @__PURE__ */ new Date()).toISOString(), name, versionKey: vKey, length: old.length, fingerprint: fingerprint(old) });
+          console.log(`  before:  "${name}"  ${old.length} B  fp=${fingerprint(old)}  (snapshot saved \u2014 rollback available)`);
+        } catch {
+          console.log(`  before:  (no existing value for "${name}" \u2014 sealing fresh)`);
+        }
+        await registerSecret({ name, fromEnv });
+        const now = await client.releaseSecret(name);
+        console.log(`\u2713 Rotated "${name}"  \u2192  ${now.length} B  fp=${fingerprint(now)}  (mode=real)`);
+        console.log(`  Every place that uses "${name}" now gets the new value \u2014 no code/config change.`);
+        console.log(`  Made a mistake? \`blindfold rollback --name ${name}\``);
+        if (fromEnv) console.log(`  You can now DELETE ${fromEnv} from your .env.`);
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+    case "rollback": {
+      const name = String(argv.flags.name ?? "");
+      if (!name) die("usage: blindfold rollback --name <secret> [--to <iso-ts | fingerprint>]");
+      const { readVersions: readVersions2, isValidVersionKey: isValidVersionKey2 } = await Promise.resolve().then(() => (init_versions(), versions_exports));
+      const versions = readVersions2(name);
+      if (versions.length === 0) {
+        die(`no saved versions for "${name}". \`blindfold rotate\` creates them; \`blindfold versions --name ${name}\` lists them.`);
+      }
+      const want = argv.flags.to ? String(argv.flags.to) : "";
+      let target = versions[versions.length - 1];
+      if (want) {
+        const sel = versions.find((v) => v.t === want || v.fingerprint === want || v.fingerprint.startsWith(want));
+        if (!sel) die(`no version of "${name}" matches --to ${want} (see \`blindfold versions --name ${name}\`)`);
+        target = sel;
+      }
+      if (!isValidVersionKey2(name, target.versionKey)) {
+        die(`refusing rollback: version key "${target.versionKey}" is not a valid snapshot key for "${name}" (tampered versions.jsonl?)`);
+      }
+      const env = loadBlindfoldEnv();
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      try {
+        const before = await client.verifySecret(name);
+        const restored = await client.releaseSecret(target.versionKey);
+        if (fingerprint(restored) !== target.fingerprint) {
+          die(`refusing rollback: released snapshot fingerprint ${fingerprint(restored)} \u2260 recorded ${target.fingerprint} (tampered versions.jsonl?)`);
+        }
+        await client.seedSecret(name, restored);
+        console.log(`\u2713 Rolled back "${name}"`);
+        console.log(`  ${before.present ? `fp ${before.fingerprint} (${before.length} B)` : "(no current value)"}  \u2192  fp ${fingerprint(restored)} (${restored.length} B)`);
+        console.log(`  restored the snapshot from ${target.t}.`);
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+    case "versions": {
+      const name = argv.flags.name ? String(argv.flags.name) : void 0;
+      const { readVersions: readVersions2 } = await Promise.resolve().then(() => (init_versions(), versions_exports));
+      const list = readVersions2(name);
+      if (list.length === 0) {
+        console.log(name ? `No saved versions for "${name}".` : "No saved versions yet. `blindfold rotate` creates them.");
+        return;
+      }
+      console.log(`Saved versions${name ? ` for "${name}"` : ""} (newest last):
+`);
+      console.log("  WHEN                  NAME                   BYTES  FINGERPRINT");
+      console.log("  \u2500\u2500\u2500\u2500                  \u2500\u2500\u2500\u2500                   \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      for (const v of list) {
+        const when = v.t.replace("T", " ").slice(0, 19);
+        console.log(`  ${when}   ${v.name.padEnd(22)} ${String(v.length).padStart(5)}  ${v.fingerprint}`);
+      }
+      console.log(`
+  Restore the newest:  blindfold rollback --name <name>`);
+      console.log(`  Restore a specific:  blindfold rollback --name <name> --to <fingerprint>`);
+      return;
+    }
+    case "migrate": {
+      const { planMigration: planMigration2, runMigrate: runMigrate2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      const dryRun = !!argv.flags["dry-run"];
+      const keep = !!argv.flags.keep;
+      const plan = planMigration2();
+      const toSeal = plan.filter((p) => p.action === "seal");
+      console.log(dryRun ? "\u{1F50D} blindfold migrate --dry-run (no changes will be made)\n" : "\u{1F69A} blindfold migrate\n");
+      console.log("  Plan:");
+      for (const p of plan) {
+        if (p.action === "seal") console.log(`    SEAL  ${p.envVar.padEnd(26)} \u2192 ${p.sealName}  (${p.bytes} B)`);
+        else console.log(`    skip  ${p.envVar.padEnd(26)} \u2014 ${p.reason}`);
+      }
+      if (toSeal.length === 0) {
+        console.log("\n  Nothing to seal (no secret-looking vars found).");
+        return;
+      }
+      if (dryRun) {
+        console.log(`
+  Would seal ${toSeal.length} secret(s), then ${keep ? "comment out" : "remove"} their .env lines (a .env backup is kept either way).`);
+        console.log("  Re-run without --dry-run to do it.");
+        return;
+      }
+      console.log(`
+  Sealing ${toSeal.length} secret(s) \u2026`);
+      const results = await runMigrate2({ keep });
+      console.log("");
+      let ok3 = 0, fail2 = 0;
+      for (const r of results) {
+        if (r.action !== "seal") continue;
+        if (r.sealed) {
+          ok3++;
+          console.log(`    \u2713 ${r.sealName} sealed (${r.bytes} B) \u2014 .env line ${keep ? "commented" : "removed"}`);
+        } else {
+          fail2++;
+          console.log(`    \u2716 ${r.sealName}: ${(r.error ?? "").slice(0, 100)}`);
+        }
+      }
+      console.log(`
+  Done: ${ok3} sealed, ${fail2} failed.  (.env backup saved alongside .env)`);
+      if (ok3 > 0) console.log(`  Use any of them with no code:  blindfold use --name <name> -- <command>`);
+      if (fail2 > 0) {
+        console.log(`  Failed seals kept their .env line. Check \`blindfold doctor\`.`);
+        process.exitCode = 1;
+      }
+      return;
+    }
+  }
+}
+
+// bin/cmd-tenant.ts
+init_env();
+async function handleTenant(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "grant": {
+      const hosts = [];
+      if (argv.flags.host) hosts.push(...String(argv.flags.host).split(",").map((h) => h.trim()).filter(Boolean));
+      if (argv.flags.hosts) hosts.push(...String(argv.flags.hosts).split(",").map((h) => h.trim()).filter(Boolean));
+      if (hosts.length === 0) {
+        die("usage: blindfold grant --host <host>[,<host2>...]   (e.g. --host api.openai.com)");
+      }
+      const replace = !!argv.flags.replace;
+      const env = loadBlindfoldEnv();
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      try {
+        const authorized = await client.grantEgress(hosts, { replace });
+        console.log(`\u2713 Egress granted for: ${hosts.join(", ")}${replace ? "  (replaced allowlist)" : ""}`);
+        console.log(`  Contract is now authorized to call ALL of: ${authorized.join(", ")}`);
+        console.log(`  Run \`blindfold publish\` first if you haven't \u2014 the grant targets the published contract.`);
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+    case "share": {
+      const to = String(argv.flags.to ?? "");
+      const hosts = [];
+      if (argv.flags.host) hosts.push(...String(argv.flags.host).split(",").map((h) => h.trim()).filter(Boolean));
+      if (argv.flags.hosts) hosts.push(...String(argv.flags.hosts).split(",").map((h) => h.trim()).filter(Boolean));
+      if (!to || hosts.length === 0) {
+        die("usage: blindfold share --to <agent-did> --host <host>[,host2]   (e.g. --to did:t3n:\u2026 --host api.openai.com)");
+      }
+      const env = loadBlindfoldEnv();
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      try {
+        await client.setAgentGrant(to, hosts, ["forward"]);
+        console.log(`\u2713 Shared access with ${to}`);
+        console.log(`  authorized: forward \u2192 ${hosts.join(", ")}  (they can USE the key via the enclave; they never receive the plaintext)`);
+        console.log(`  Revoke any time:  blindfold revoke --to ${to}`);
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+    case "revoke": {
+      const to = String(argv.flags.to ?? "");
+      if (!to) die("usage: blindfold revoke --to <agent-did>");
+      const env = loadBlindfoldEnv();
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      try {
+        await client.setAgentGrant(to, [], []);
+        console.log(`\u2713 Revoked all contract access for ${to}`);
+        console.log(`  Nobody holds the raw key, so revocation is immediate and complete \u2014 there's no leaked copy to chase.`);
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+  }
+}
+
+// bin/cmd-serve.ts
+init_env();
+import path9 from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+
+// src/proxy.ts
+init_constants();
+init_env();
+init_log();
+init_t3_client();
+init_usage_log();
+import http from "node:http";
+import crypto from "node:crypto";
+import fs11 from "node:fs";
+import net from "node:net";
+
+// src/providers.ts
+init_constants();
+function amzDate(now = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${now.getUTCFullYear()}${p(now.getUTCMonth() + 1)}${p(now.getUTCDate())}T${p(now.getUTCHours())}${p(now.getUTCMinutes())}${p(now.getUTCSeconds())}Z`;
+}
+var awsRegion = () => process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+var awsAccessKeyId = () => process.env.AWS_ACCESS_KEY_ID || "";
+function stripPrefix(path13, prefix) {
+  const rest = path13.slice(prefix.length - 1);
+  return rest.startsWith("/") ? rest : `/${rest}`;
+}
+var PROVIDERS = [
+  // ---- LLM providers (OpenAI-shaped, bearer). Back-compatible. --------------
+  { id: "openai", prefix: "/v1/", upstream: (p) => `https://api.openai.com${p}`, auth: () => ({ scheme: "bearer" }) },
+  { id: "openai", prefix: "/openai/", upstream: (p) => `https://api.openai.com${stripPrefix(p, "/openai/")}`, auth: () => ({ scheme: "bearer" }) },
+  // Anthropic REQUIRES the anthropic-version header on the raw REST API.
+  { id: "anthropic", prefix: "/anthropic/", upstream: (p) => `https://api.anthropic.com${stripPrefix(p, "/anthropic/")}`, auth: () => ({ scheme: "bearer" }), defaultHeaders: { "anthropic-version": "2023-06-01" } },
+  { id: "xai", prefix: "/x/", upstream: (p) => `https://api.x.ai${stripPrefix(p, "/x/")}`, auth: () => ({ scheme: "bearer" }) },
+  { id: "groq", prefix: "/groq/", upstream: (p) => `https://api.groq.com/openai${stripPrefix(p, "/groq/")}`, auth: () => ({ scheme: "bearer" }) },
+  // ---- LLM: Google Gemini (native API — key rides in `x-goog-api-key`). ------
+  // Not OpenAI-shaped and NOT `Authorization: Bearer`. The sentinel is planted
+  // in Google's provider-specific header and swapped for the sealed key inside
+  // the enclave — proving Blindfold handles a provider's real auth convention,
+  // not just the one bearer shape.
+  {
+    id: "gemini",
+    prefix: "/gemini/",
+    upstream: (p) => `https://generativelanguage.googleapis.com${stripPrefix(p, "/gemini/")}`,
+    secretKey: "gemini_api_key",
+    auth: () => ({ scheme: "bearer" }),
+    sentinelHeader: { name: "x-goog-api-key", prefix: "" }
+  },
+  // ---- Payments: Stripe (bearer; pins the API version so behaviour is stable). -----
+  {
+    id: "stripe",
+    prefix: "/stripe/",
+    upstream: (p) => `https://api.stripe.com${stripPrefix(p, "/stripe/")}`,
+    secretKey: "stripe_secret_key",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "stripe-version": "2024-06-20", "content-type": "application/x-www-form-urlencoded" }
+  },
+  // ---- Dev infra: GitHub. GitHub REJECTS requests with no User-Agent (403),
+  //      and best practice is to pin the REST API version + set the Accept type.
+  {
+    id: "github",
+    prefix: "/github/",
+    upstream: (p) => `https://api.github.com${stripPrefix(p, "/github/")}`,
+    secretKey: "github_token",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: {
+      accept: "application/vnd.github+json",
+      "x-github-api-version": "2022-11-28",
+      "user-agent": "blindfold"
+    }
+  },
+  // ---- Email: SendGrid (bearer; JSON v3 API). -------------------------------
+  {
+    id: "sendgrid",
+    prefix: "/sendgrid/",
+    upstream: (p) => `https://api.sendgrid.com${stripPrefix(p, "/sendgrid/")}`,
+    secretKey: "sendgrid_api_key",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "content-type": "application/json" }
+  },
+  // ---- Comms: Slack (bearer bot token; Web API wants JSON+charset on POST). --
+  {
+    id: "slack",
+    prefix: "/slack/",
+    upstream: (p) => `https://slack.com/api${stripPrefix(p, "/slack/")}`,
+    secretKey: "slack_bot_token",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "content-type": "application/json; charset=utf-8" }
+  },
+  // ---- Telephony: Twilio (HTTP Basic — base64 computed IN the enclave). -----
+  // Username = Account SID (not secret; also appears in the URL path). The
+  // sealed secret is the Auth Token. A generic proxy CANNOT do this: the
+  // base64 must be computed after the secret is joined, inside TDX.
+  {
+    id: "twilio",
+    prefix: "/twilio/",
+    upstream: (p) => `https://api.twilio.com${stripPrefix(p, "/twilio/")}`,
+    secretKey: "twilio_auth_token",
+    auth: () => ({ scheme: "basic", username: process.env.TWILIO_ACCOUNT_SID || "" }),
+    defaultHeaders: { "content-type": "application/x-www-form-urlencoded" }
+  },
+  // ---- Cloud: AWS SES (SigV4 — secret SIGNS, never transmitted). ------------
+  {
+    id: "aws-ses",
+    prefix: "/aws/ses/",
+    upstream: (p) => `https://email.${awsRegion()}.amazonaws.com${stripPrefix(p, "/aws/ses/")}`,
+    secretKey: "aws_secret_access_key",
+    auth: () => ({ scheme: "sigv4", access_key_id: awsAccessKeyId(), region: awsRegion(), service: "ses", amz_date: amzDate() })
+  },
+  // ---- Cloud: AWS S3 (SigV4). -----------------------------------------------
+  {
+    id: "aws-s3",
+    prefix: "/aws/s3/",
+    upstream: (p) => `https://s3.${awsRegion()}.amazonaws.com${stripPrefix(p, "/aws/s3/")}`,
+    secretKey: "aws_secret_access_key",
+    auth: () => ({ scheme: "sigv4", access_key_id: awsAccessKeyId(), region: awsRegion(), service: "s3", amz_date: amzDate() })
+  },
+  // ---- Webhook: Discord. The SECRET IS THE URL — the enclave substitutes the
+  //      sealed webhook URL for the sentinel, so the agent POSTs to /discord
+  //      with only a JSON body and never holds the URL. Needs egress for
+  //      discord.com (`blindfold grant --host discord.com`).
+  {
+    id: "discord",
+    prefix: "/discord",
+    upstream: () => SENTINEL,
+    // enclave replaces this with the sealed webhook URL
+    secretKey: "webhook_discord_url",
+    auth: () => ({ scheme: "webhook" })
+  }
+];
+function resolveProvider(path13) {
+  const def = PROVIDERS.filter((d) => path13.startsWith(d.prefix)).sort((a, b) => b.prefix.length - a.prefix.length)[0];
+  if (!def) return null;
+  return {
+    id: def.id,
+    upstream: def.upstream(path13),
+    secretKey: def.secretKey,
+    auth: def.auth(),
+    sentinelHeader: def.sentinelHeader,
+    defaultHeaders: def.defaultHeaders
+  };
+}
+
+// src/proxy.ts
+var MAX_BODY_BYTES = Number(process.env.BLINDFOLD_MAX_BODY_BYTES) || 5 * 1024 * 1024;
+var BODY_IDLE_MS = Number(process.env.BLINDFOLD_BODY_IDLE_MS) || 3e4;
+var MAX_INFLIGHT = Number(process.env.BLINDFOLD_MAX_INFLIGHT) || 64;
+var inflight = 0;
+var PayloadTooLargeError = class extends Error {
+};
+function tokenMatches(provided, expected) {
+  const a = Buffer.from(provided);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return crypto.timingSafeEqual(a, b);
+}
+var PROXY_TOKEN_HEADER = "x-blindfold-token";
+function isSocketLive(socketPath) {
+  return new Promise((resolve) => {
+    if (!fs11.existsSync(socketPath)) {
+      resolve(false);
+      return;
+    }
+    const c2 = net.connect(socketPath);
+    const done = (live) => {
+      try {
+        c2.destroy();
+      } catch {
+      }
+      resolve(live);
+    };
+    c2.once("connect", () => done(true));
+    c2.once("error", () => done(false));
+    c2.setTimeout(500, () => done(false));
+  });
+}
+async function startProxy(opts = {}) {
+  const env = loadBlindfoldEnv();
+  const port = opts.port ?? env.port ?? 8787;
+  const secretKey = opts.secretKey ?? "openai_api_key";
+  const token = (opts.token ?? process.env.BLINDFOLD_PROXY_TOKEN ?? "").trim() || void 0;
+  const socketPath = opts.socket?.trim() || void 0;
+  if (socketPath && await isSocketLive(socketPath)) {
+    throw new Error(`a Blindfold proxy is already listening on ${socketPath} \u2014 stop it first, or use a different --socket path`);
+  }
+  const t3 = await openT3Client(env);
+  const server = http.createServer((req, res) => {
+    handle(req, res, t3, secretKey, env, token).catch((e) => {
+      if (e instanceof PayloadTooLargeError) {
+        if (!res.headersSent) res.writeHead(413, { "content-type": "text/plain", "connection": "close" });
+        res.end("request body too large");
+        req.destroy();
+        return;
+      }
+      safeLog("error", { msg: "proxy_unhandled", error: e.message });
+      if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
+      res.end("internal proxy error");
+    });
+  });
+  return await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    let prevUmask;
+    const onListening = () => {
+      let url;
+      let bound = 0;
+      if (socketPath) {
+        try {
+          fs11.chmodSync(socketPath, 384);
+        } catch {
+        }
+        if (prevUmask !== void 0) {
+          try {
+            process.umask(prevUmask);
+          } catch {
+          }
+        }
+        url = `unix:${socketPath}`;
+      } else {
+        bound = server.address().port;
+        url = `http://127.0.0.1:${bound}`;
+      }
+      safeLog("info", { msg: "proxy_listening", url, mock: env.mock });
+      resolve({
+        url,
+        port: bound,
+        token,
+        socket: socketPath,
+        close: async () => {
+          await new Promise((r) => server.close(() => r()));
+          if (socketPath) {
+            try {
+              fs11.rmSync(socketPath, { force: true });
+            } catch {
+            }
+          }
+          await t3.close();
+        }
+      });
+    };
+    if (socketPath) {
+      try {
+        fs11.rmSync(socketPath, { force: true });
+      } catch {
+      }
+      prevUmask = process.umask(127);
+      server.listen(socketPath, onListening);
+    } else {
+      server.listen(port, "127.0.0.1", onListening);
+    }
+  });
+}
+async function handle(req, res, t3, secretKey, env, token) {
+  if (req.url === "/health") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ ok: true, mock: env.mock, auth: Boolean(token) }));
+    return;
+  }
+  if (token) {
+    const provided = String(req.headers[PROXY_TOKEN_HEADER] ?? "");
+    if (!provided || !tokenMatches(provided, token)) {
+      safeLog("warn", { msg: "proxy_unauthorized", path: req.url });
+      res.writeHead(401, { "content-type": "text/plain" });
+      res.end(`unauthorized: missing or invalid ${PROXY_TOKEN_HEADER} header`);
+      return;
+    }
+  }
+  const provider = resolveProvider(req.url ?? "/");
+  if (!provider) {
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end(`no upstream mapping for ${req.url}`);
+    return;
+  }
+  const upstream = provider.upstream;
+  const providerSecretKey = provider.secretKey ?? secretKey;
+  const body = await readBody(req, MAX_BODY_BYTES);
+  const agentSuppliedAuth = Object.keys(req.headers).some((k) => k.toLowerCase() === "authorization");
+  const headers = forwardableHeaders(req.headers);
+  if (provider.auth.scheme === "bearer") {
+    const sh = provider.sentinelHeader ?? { name: "authorization", prefix: "Bearer " };
+    removeHeader(headers, "authorization");
+    ensureHeader(headers, sh.name, `${sh.prefix}${SENTINEL}`);
+  } else {
+    removeHeader(headers, "authorization");
+  }
+  for (const [name, value] of Object.entries(provider.defaultHeaders ?? {})) {
+    if (!headers.some(([k]) => k.toLowerCase() === name.toLowerCase())) {
+      headers.push([name, value]);
+    }
+  }
+  let outboundUrl = upstream;
+  let outboundBody = body.length ? body.toString("utf8") : void 0;
+  const contentType = (headers.find(([k]) => k.toLowerCase() === "content-type")?.[1] ?? "").toLowerCase();
+  if (provider.auth.scheme !== "webhook" && outboundBody && contentType.includes("application/x-www-form-urlencoded")) {
+    const u = new URL(outboundUrl);
+    for (const [k, v] of new URLSearchParams(outboundBody)) u.searchParams.append(k, v);
+    outboundUrl = u.toString();
+    outboundBody = void 0;
+    safeLog("info", { msg: "form_body_to_query", provider: provider.id });
+  }
+  const forwardReq = {
+    method: req.method ?? "GET",
+    url: outboundUrl,
+    headers,
+    body: outboundBody,
+    secret_key: providerSecretKey,
+    auth: provider.auth
+  };
+  safeLog("info", {
+    msg: "proxy_forward",
+    method: forwardReq.method,
+    upstream: upstream.replace(/\?.*$/, "")
+  });
+  if (inflight >= MAX_INFLIGHT) {
+    safeLog("warn", { msg: "proxy_saturated", inflight, max: MAX_INFLIGHT });
+    if (!res.headersSent) res.writeHead(503, { "content-type": "text/plain", "retry-after": "1" });
+    res.end("proxy saturated: too many concurrent enclave calls \u2014 retry shortly");
+    return;
+  }
+  const startedAt = Date.now();
+  let result;
+  inflight++;
+  try {
+    result = await t3.invokeForward(forwardReq);
+  } catch (e) {
+    const { status, body: body2 } = explainForwardError(e);
+    safeLog("error", { msg: "proxy_forward_failed", status, provider: provider.id, error: e.message });
+    if (!res.headersSent) res.writeHead(status, { "content-type": "application/json" });
+    res.end(body2);
+    return;
+  } finally {
+    inflight--;
+  }
+  const latency = Date.now() - startedAt;
+  logUsage({
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: env.mock ? "mock" : "real",
+    provider: provider.id || providerForUpstream(upstream),
+    method: forwardReq.method,
+    path: req.url ?? "/",
+    upstream: upstream.replace(/\?.*$/, ""),
+    status: result.status,
+    latency_ms: latency,
+    agent_supplied_auth: agentSuppliedAuth,
+    auth_scheme: provider.auth.scheme,
+    sentinel_in_outbound: forwardReq.headers.some(([k, v]) => k.toLowerCase() === "authorization" && v.includes(SENTINEL)),
+    via: "proxy",
+    secret_key: providerSecretKey
+  });
+  res.writeHead(result.status, headersFromTuple(result.headers));
+  const bodyBytes = typeof result.body === "string" ? Buffer.from(result.body, "utf8") : Buffer.from(result.body);
+  res.end(bodyBytes);
+}
+function readBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let aborted = false;
+    let timer;
+    const fail2 = (e) => {
+      aborted = true;
+      clearTimeout(timer);
+      reject(e);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        if (!aborted) fail2(new Error(`request body read timed out after ${BODY_IDLE_MS}ms`));
+      }, BODY_IDLE_MS);
+    };
+    arm();
+    req.on("data", (c2) => {
+      if (aborted) return;
+      arm();
+      size += c2.length;
+      if (size > maxBytes) {
+        fail2(new PayloadTooLargeError(`request body exceeds ${maxBytes} bytes`));
+        return;
+      }
+      chunks.push(c2);
+    });
+    req.on("end", () => {
+      clearTimeout(timer);
+      if (!aborted) resolve(Buffer.concat(chunks));
+    });
+    req.on("error", (e) => {
+      if (!aborted) fail2(e);
+    });
+  });
+}
+var STRIPPED = /* @__PURE__ */ new Set(["host", "content-length", "connection", "transfer-encoding"]);
+function forwardableHeaders(h) {
+  const out = [];
+  for (const [k, v] of Object.entries(h)) {
+    if (v === void 0) continue;
+    if (STRIPPED.has(k.toLowerCase())) continue;
+    out.push([k, Array.isArray(v) ? v.join(", ") : v]);
+  }
+  return out;
+}
+function ensureHeader(h, name, value) {
+  const lower = name.toLowerCase();
+  const idx = h.findIndex(([k]) => k.toLowerCase() === lower);
+  if (idx >= 0) h[idx] = [name, value];
+  else h.push([name, value]);
+}
+function removeHeader(h, name) {
+  const lower = name.toLowerCase();
+  for (let i = h.length - 1; i >= 0; i--) {
+    if (h[i][0].toLowerCase() === lower) h.splice(i, 1);
+  }
+}
+function headersFromTuple(t) {
+  const out = {};
+  for (const [k, v] of t) out[k] = v;
+  return out;
+}
+function explainForwardError(err) {
+  const msg = err?.message ?? String(err);
+  if (err instanceof T3TimeoutError) {
+    return {
+      status: 504,
+      body: JSON.stringify({
+        error: "blindfold_forward_failed",
+        status: 504,
+        code: "t3_timeout",
+        detail: msg,
+        hint: "The T3 node did not respond within the deadline (BLINDFOLD_T3_TIMEOUT_MS). It may be slow or unreachable; retry, or point T3_BASE_URL at a healthy node."
+      }, null, 2)
+    };
+  }
+  let status = Number(msg.match(/HTTP (\d{3})/)?.[1]) || 502;
+  let code = "";
+  let detail = msg;
+  let requestId = "";
+  const jsonM = msg.match(/\((\{.*\})\)\s*$/);
+  if (jsonM && jsonM[1]) {
+    try {
+      const o = JSON.parse(jsonM[1]);
+      code = o.code ?? "";
+      detail = o.detail ?? detail;
+      requestId = o.request_id ?? "";
+    } catch {
+    }
+  }
+  let hint = "";
+  if (/egress_denied|authorised_hosts|allowlist/i.test(detail)) {
+    const host = detail.match(/host '([^']+)'/)?.[1];
+    hint = `Egress is not authorized${host ? ` for '${host}'` : ""}. Run: blindfold grant --host ${host ?? "<host>"} \u2014 list every host you use in ONE command (grant replaces the allowlist unless merged).`;
+    if (status < 400) status = 403;
+  } else if (/fuel_per_minute|too_many_requests|rate limit/i.test(detail)) {
+    hint = "Rate limited by the testnet per-minute compute quota (fuel_per_minute). Retry in ~60s and space calls out \u2014 this is not an outage.";
+    status = 429;
+  } else if (/cannot read map|:secrets/i.test(detail)) {
+    hint = "The contract isn't authorized to read your secrets map (common right after publishing a new contract id). Run: blindfold init (re-grants the secrets read ACL).";
+  } else if (/parse_payload|expected value at line/i.test(detail)) {
+    hint = "The T3 host egress parses request bodies as JSON. For form-encoded APIs (Stripe/Twilio), send params in the query string with an empty body.";
+    if (status < 400) status = 400;
+  } else if (/secret .* not found|not found in the secrets map/i.test(detail)) {
+    hint = "That sealed secret name doesn't exist. Seal it: blindfold register --name <name> --from-env <ENV_VAR>.";
+  }
+  const payload = {
+    error: "blindfold_forward_failed",
+    status,
+    code: code || void 0,
+    detail,
+    request_id: requestId || void 0,
+    hint: hint || void 0
+  };
+  return { status, body: JSON.stringify(payload, null, 2) };
+}
+
+// src/dashboard.ts
+init_constants();
+init_env();
+init_usage_log();
+init_sealed_ledger();
+import fs12 from "node:fs";
+import http2 from "node:http";
+import path8 from "node:path";
+import { timingSafeEqual } from "node:crypto";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+async function startDashboard(opts = {}) {
+  const port = opts.port ?? DEFAULT_DASHBOARD_PORT;
+  const TOKEN = process.env.BLINDFOLD_DASHBOARD_TOKEN || "";
+  const tokenEq = (candidate) => {
+    const a = Buffer.from(candidate);
+    const b = Buffer.from(TOKEN);
+    return a.length === b.length && timingSafeEqual(a, b);
+  };
+  const authed = (req, url) => {
+    if (!TOKEN) return true;
+    const auth = req.headers.authorization || "";
+    if (auth.startsWith("Bearer ") && tokenEq(auth.slice(7))) return true;
+    try {
+      const t = new URL(url, "http://x").searchParams.get("token");
+      if (t && tokenEq(t)) return true;
+    } catch {
+    }
+    return false;
+  };
+  const server = http2.createServer(async (req, res) => {
+    const url = req.url ?? "/";
+    const pathname = url.split("?")[0];
+    if (!authed(req, url)) {
+      res.writeHead(401, { "content-type": "text/plain" });
+      res.end("unauthorized \u2014 append ?token=<BLINDFOLD_DASHBOARD_TOKEN>");
+      return;
+    }
+    if (req.method === "GET" && pathname === "/logo.png") {
+      try {
+        const HERE5 = path8.dirname(fileURLToPath3(import.meta.url));
+        const candidates = [
+          path8.resolve(HERE5, "..", "..", "..", "assets", "logo.png"),
+          path8.resolve(HERE5, "..", "assets", "logo.png")
+        ];
+        const logo = candidates.find((p) => fs12.existsSync(p));
+        if (logo) {
+          res.writeHead(200, { "content-type": "image/png", "cache-control": "max-age=3600" });
+          res.end(fs12.readFileSync(logo));
+        } else {
+          const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#8b5cf6"/><stop offset="1" stop-color="#ff8c2b"/></linearGradient></defs><rect width="100" height="100" rx="22" fill="#161b22"/><path d="M50 14l28 10v22c0 20-13 33-28 40-15-7-28-20-28-40V24z" fill="url(#g)" opacity="0.92"/><rect x="34" y="46" width="32" height="24" rx="5" fill="#0b0e14"/><rect x="42" y="36" width="16" height="16" rx="8" fill="none" stroke="#0b0e14" stroke-width="5"/></svg>`;
+          res.writeHead(200, { "content-type": "image/svg+xml", "cache-control": "max-age=3600" });
+          res.end(svg);
+        }
+      } catch {
+        res.writeHead(404, { "content-type": "text/plain" }).end("logo not found");
+      }
+      return;
+    }
+    if (req.method === "GET" && (pathname === "/" || pathname === "/index.html")) {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(HTML);
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/events") {
+      const limit = Math.min(Number(new URL(url, "http://x").searchParams.get("limit")) || 500, 5e3);
+      const events = readUsageTail(limit);
+      const counters = {};
+      for (const e of events) counters[e.provider] = (counters[e.provider] ?? 0) + 1;
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ events, counters, returned: events.length, source: defaultLogPath() }));
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/sealed") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ entries: readSealed(), source: defaultSealedLogPath() }));
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/stream") {
+      res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+      res.write(": connected\n\n");
+      const send = () => {
+        try {
+          res.write("event: change\ndata: {}\n\n");
+        } catch {
+        }
+      };
+      const watchers = [];
+      for (const p of [defaultLogPath(), defaultSealedLogPath()]) {
+        try {
+          watchers.push(fs12.watch(path8.dirname(p), () => send()));
+        } catch {
+        }
+      }
+      const hb = setInterval(() => {
+        try {
+          res.write(": ping\n\n");
+        } catch {
+        }
+      }, 15e3);
+      req.on("close", () => {
+        clearInterval(hb);
+        for (const w of watchers) {
+          try {
+            w.close();
+          } catch {
+          }
+        }
+      });
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/audit/full") {
+      const env = loadBlindfoldEnv();
+      const sealed = readSealed();
+      const latest = /* @__PURE__ */ new Map();
+      for (const s of sealed) latest.set(s.name, s);
+      const results = [];
+      if (!env.mock) {
+        try {
+          const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+          const client = await openT3Client2(env);
+          try {
+            for (const e of latest.values()) {
+              const v = await client.verifySecret(e.name);
+              results.push({ name: e.name, present: v.present, enclave_len: v.length, ledger_len: e.length, fingerprint: v.fingerprint, ok: v.present && v.length === e.length });
+            }
+          } finally {
+            await client.close();
+          }
+        } catch (err) {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ mock: env.mock, error: err.message, results: [] }));
+          return;
+        }
+      }
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ mock: env.mock, results }));
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/status") {
+      const env = loadBlindfoldEnv();
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        mode: env.mock ? "mock" : "real",
+        tenant_did: env.did || null,
+        tenant_did_short: env.did ? shortenDid(env.did) : null,
+        t3_env: env.t3Env,
+        contract_version: CONTRACT_VERSION,
+        proxy_port: env.port,
+        sdk_installed: isSdkInstalled()
+      }));
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/audit") {
+      const sealed = readSealed();
+      const envKeys = new Set(readEnvKeyNames());
+      const latestByName = /* @__PURE__ */ new Map();
+      for (const s of sealed) latestByName.set(s.name, s);
+      const exposed = Array.from(latestByName.values()).filter((latest) => envKeys.has(latest.name)).map((latest) => ({ name: latest.name, length: latest.length, sealed_at: latest.t }));
+      const uniqueSealed = latestByName.size;
+      const chain = verifyLedgerChain();
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        exposed_in_env: exposed,
+        env_keys: Array.from(envKeys),
+        sealed_count: uniqueSealed,
+        ledger_chain: chain
+        // { ok, total, legacy, firstBrokenIndex }
+      }));
+      return;
+    }
+    if ((req.method === "POST" || req.method === "DELETE") && pathname === "/api/clear") {
+      clearUsage();
+      res.writeHead(204).end();
+      return;
+    }
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end("not found");
+  });
+  return await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      const { port: bound } = server.address();
+      resolve({
+        url: `http://127.0.0.1:${bound}`,
+        port: bound,
+        close: () => new Promise((r) => server.close(() => r()))
+      });
+    });
+  });
+}
+function shortenDid(did) {
+  const prefix = "did:t3n:";
+  if (!did.startsWith(prefix)) return did;
+  const tail = did.slice(prefix.length);
+  return tail.length <= 14 ? did : `${prefix}${tail.slice(0, 6)}\u2026${tail.slice(-4)}`;
+}
+function readEnvKeyNames() {
+  const ENV_PATH2 = defaultEnvPath();
+  if (!fs12.existsSync(ENV_PATH2)) return [];
+  return fs12.readFileSync(ENV_PATH2, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => line.split("=", 1)[0]?.trim() ?? "").filter(Boolean);
+}
+function isSdkInstalled() {
+  try {
+    __require.resolve?.("@terminal3/t3n-sdk");
+    return true;
+  } catch {
+    try {
+      const HERE5 = path8.dirname(fileURLToPath3(import.meta.url));
+      return fs12.existsSync(path8.resolve(HERE5, "..", "..", "..", "node_modules", "@terminal3", "t3n-sdk"));
+    } catch {
+      return false;
+    }
+  }
+}
+var HTML = `<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+<meta charset="utf-8" />
+<title>Blindfold \u2014 Dashboard</title>
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<link rel="icon" type="image/png" href="/logo.png" />
+<style>
+  :root {
+    --bg:#0b0e14; --bg2:#0e1117; --card:#161b22; --card2:#1c2230; --line:#2a313c;
+    --fg:#e6edf3; --dim:#8b949e; --dim2:#6b7280;
+    --ok:#3fb950; --warn:#d29922; --bad:#f85149; --info:#58a6ff;
+    --accent:#8b5cf6; --accent2:#58a6ff;
+    --orange:#ff8c2b; --orange2:#ff6a3d; --brand:#ff8c2b;
+    --c1:#8b5cf6; --c2:#58a6ff; --c3:#3fb950; --c4:#ff8c2b; --c5:#f85149; --c6:#ff7b72; --c7:#39c5cf; --c8:#f778ba;
+    --line:#333b47; --line-strong:#465061;
+    --shadow:0 1px 3px rgba(0,0,0,.4), 0 8px 24px rgba(0,0,0,.18);
+  }
+  [data-theme="light"] {
+    --bg:#f6f8fa; --bg2:#fff; --card:#fff; --card2:#f3f4f6; --line:#d8dee4; --line-strong:#c2cad3;
+    --fg:#1f2328; --dim:#57606a; --dim2:#8b949e;
+    --shadow:0 1px 2px rgba(0,0,0,.06), 0 8px 24px rgba(0,0,0,.06);
+  }
+  * { box-sizing:border-box; }
+  html,body { max-width:100vw; overflow-x:hidden; }
+  body {
+    margin:0; padding:20px clamp(12px,4vw,40px);
+    font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","Inter",system-ui,sans-serif;
+    background:radial-gradient(1200px 600px at 20% -10%, rgba(139,92,246,.10), transparent 60%), var(--bg);
+    color:var(--fg); line-height:1.5; transition:background .2s,color .2s;
+  }
+  a { color:var(--accent2); }
+  .topbar { display:flex; justify-content:space-between; align-items:center; gap:14px; flex-wrap:wrap; margin-bottom:18px;
+    border:1px solid var(--line-strong); border-radius:16px; padding:16px 20px;
+    background:linear-gradient(180deg,var(--card),var(--card2)); box-shadow:var(--shadow); }
+  .brandwrap { display:flex; align-items:center; gap:16px; min-width:0; }
+  .logo-img { width:clamp(76px,11vw,104px); height:clamp(76px,11vw,104px); border-radius:18px; object-fit:cover; background:var(--card); border:1px solid var(--line-strong); padding:0; box-shadow:var(--shadow); flex:none; animation:logoIn .6s cubic-bezier(.2,.8,.2,1) both; }
+  @keyframes logoIn { from{transform:scale(.7) rotate(-8deg);opacity:0;} to{transform:scale(1) rotate(0);opacity:1;} }
+  h1 { margin:0; font-size:clamp(24px,4.5vw,34px); font-weight:800; letter-spacing:-.5px; display:flex; align-items:baseline; gap:10px; flex-wrap:wrap; }
+  /* wordmark: ribbon-wrap animation \u2014 pure CSS, no runtime deps */
+  .brand { position:relative; display:inline-block; padding-bottom:6px; overflow:hidden; }
+  .brand::after { content:""; position:absolute; left:0; bottom:0; height:3px; width:100%; background:linear-gradient(90deg,var(--orange),var(--orange2)); border-radius:3px; transform-origin:left; transform:scaleX(0); opacity:0; animation:underlineIn .5s 2.2s cubic-bezier(.2,.8,.2,1) both; }
+  @keyframes underlineIn { from{transform:scaleX(0);opacity:.3;} to{transform:scaleX(1);opacity:1;} }
+  .letter { display:inline-block; position:relative; z-index:1; color:var(--fg); text-shadow:none; animation:protectLetter .35s cubic-bezier(.2,.8,.2,1) both; }
+  @keyframes protectLetter { to{ color:#bdc7d4; text-shadow:0 1px 4px rgba(139,92,246,.12); transform:translateY(-0.5px); } }
+  [data-theme="light"] .letter { animation:protectLetterLight .35s cubic-bezier(.2,.8,.2,1) both; }
+  @keyframes protectLetterLight { to{ color:#5a6478; text-shadow:0 1px 4px rgba(139,92,246,.10); transform:translateY(-0.5px); } }
+  .brand > .letter:nth-of-type(5) { animation-delay:0.90s; } .brand > .letter:nth-of-type(4) { animation-delay:0.94s; }
+  .brand > .letter:nth-of-type(6) { animation-delay:0.98s; } .brand > .letter:nth-of-type(3) { animation-delay:1.02s; }
+  .brand > .letter:nth-of-type(7) { animation-delay:1.06s; } .brand > .letter:nth-of-type(2) { animation-delay:1.10s; }
+  .brand > .letter:nth-of-type(8) { animation-delay:1.14s; } .brand > .letter:nth-of-type(1) { animation-delay:1.18s; }
+  .brand > .letter:nth-of-type(9) { animation-delay:1.22s; }
+  .ribbon { position:absolute; top:-25%; height:150%; width:55%; background:linear-gradient(180deg, rgba(50,54,62,0) 0%, rgba(38,42,50,.6) 12%, rgba(28,30,38,.92) 32%, rgba(22,24,30,1) 48%, rgba(28,30,38,.92) 64%, rgba(38,42,50,.6) 84%, rgba(50,54,62,0) 100%); border-radius:4px; z-index:2; pointer-events:none; will-change:transform; transform-origin:left center; animation:ribbonSweep 1.0s .5s cubic-bezier(.65,0,.35,1) both, ribbonSettle .7s 1.5s cubic-bezier(.34,1.56,.64,1) both, ribbonBreeze 3s 2.2s ease-in-out infinite; }
+  @keyframes ribbonSweep { 0%{ transform:translateX(100%) scaleX(.01); } 100%{ transform:translateX(22%) scaleX(1); } }
+  @keyframes ribbonSettle { 0%{ transform:translateX(22%) scaleX(1); } 100%{ transform:translateX(-6%) scaleX(.65) rotate(-1.5deg); } }
+  @keyframes ribbonBreeze { 0%,100%{ transform:translateX(-6%) scaleX(.65) rotate(-1.5deg); } 50%{ transform:translateX(-4%) scaleX(.68) rotate(.8deg); } }
+  @keyframes logoSeal { 0%{ filter:brightness(1) saturate(1); } 25%{ filter:brightness(1.06) saturate(1.1); box-shadow:0 0 0 1px rgba(139,92,246,.15); } 60%{ filter:brightness(1.03) saturate(1.05); } 100%{ filter:brightness(1) saturate(1); } }
+  .logo-img { animation:logoIn .6s cubic-bezier(.2,.8,.2,1) both, logoSeal 2.2s .6s ease both; }
+  .eyebrow { font-size:.42em; font-weight:600; color:var(--dim); text-transform:uppercase; letter-spacing:1.5px; }
+  .tagline { font-size:12px; color:var(--dim); margin-top:7px; display:flex; align-items:center; gap:6px; }
+  .tagline .lock { color:var(--orange); display:inline-block; animation:clack .5s .45s cubic-bezier(.3,1.4,.5,1) both; }
+  @keyframes clack { from{transform:rotate(-35deg) translateY(-2px);opacity:0;} to{transform:rotate(0) translateY(0);opacity:1;} }
+  /* --- Distinctive "decrypt \u2192 seal" wordmark animation (JS-driven) --- */
+  .letter.scrambling { color:var(--accent); font-family:ui-monospace,SFMono-Regular,Menlo,monospace; opacity:.92; }
+  .letter.sealed { animation:sealSnap .55s cubic-bezier(.2,1.4,.4,1) both; }
+  @keyframes sealSnap {
+    0%   { color:var(--accent); text-shadow:0 0 14px rgba(139,92,246,.95),0 0 4px rgba(139,92,246,.8); transform:translateY(-3px) scale(1.18); }
+    55%  { color:var(--fg);     text-shadow:0 0 8px rgba(139,92,246,.5);  transform:translateY(1px)  scale(.97);  }
+    100% { color:var(--fg);     text-shadow:none; transform:none; }
+  }
+  /* seal sweep: a vertical light bar that passes across the word once as it seals */
+  .sealbar { position:absolute; top:-22%; height:144%; width:16px; left:-8%; z-index:3; pointer-events:none; border-radius:9px; opacity:0;
+    background:linear-gradient(90deg,transparent, rgba(139,92,246,.55) 45%, rgba(88,166,255,.35) 60%, transparent); filter:blur(2px); }
+  .sealbar.run { animation:sealSweep 1.15s cubic-bezier(.5,0,.3,1) both; }
+  @keyframes sealSweep { 0%{ left:-8%; opacity:0;} 12%{opacity:1;} 86%{opacity:1;} 100%{ left:104%; opacity:0;} }
+  @media (prefers-reduced-motion:reduce){ .logo-img,.letter,.ribbon,.brand::after,.tagline .lock,.sealbar{ animation:none!important; } .ribbon,.sealbar{ display:none; } .letter{ color:var(--fg)!important; transform:none!important; text-shadow:none!important; } .brand::after{ transform:scaleX(1)!important; opacity:1!important; } }
+  .tagline b { color:var(--fg); font-weight:600; }
+  .tags { display:flex; gap:6px; margin-top:8px; flex-wrap:wrap; align-items:center; }
+  .tag { display:inline-flex; align-items:center; gap:5px; font-size:11px; color:var(--dim); background:var(--card); border:1px solid var(--line); border-radius:20px; padding:3px 10px; max-width:100%; }
+  .tag.live { color:var(--ok); border-color:rgba(63,185,80,.45); background:rgba(63,185,80,.08); font-weight:600; }
+  .tag.orange { color:var(--orange); border-color:rgba(255,140,43,.45); background:rgba(255,140,43,.08); }
+  .tag.path { color:var(--dim); }
+  .tag.path code { background:none; padding:0; max-width:min(52vw,420px); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; display:inline-block; vertical-align:bottom; }
+  .live-dot { width:7px; height:7px; border-radius:50%; background:var(--ok); box-shadow:0 0 0 0 rgba(63,185,80,.6); animation:pulse 2s infinite; }
+  @keyframes pulse { 0%{box-shadow:0 0 0 0 rgba(63,185,80,.5);} 70%{box-shadow:0 0 0 6px rgba(63,185,80,0);} 100%{box-shadow:0 0 0 0 rgba(63,185,80,0);} }
+  .controls { display:flex; gap:8px; align-items:center; flex-wrap:wrap; }
+  .controls label { font-size:12px; color:var(--dim); display:flex; align-items:center; gap:4px; }
+  select,button { background:var(--card); color:var(--fg); border:1px solid var(--line-strong); border-radius:8px; padding:6px 10px; font-size:12px; cursor:pointer; transition:border-color .15s,background .15s,transform .05s; }
+  button:hover,select:hover { border-color:var(--orange); color:var(--orange); }
+  button:active { transform:translateY(1px); }
+  .copybtn { background:transparent; border:1px solid var(--line); border-radius:6px; padding:2px 9px; font-size:11px; cursor:pointer; color:var(--dim); transition:border-color .15s,color .15s; }
+  .copybtn:hover { border-color:var(--orange); color:var(--orange); }
+  .copybtn.done { color:var(--ok); border-color:var(--ok); }
+  .copybtn.err { color:var(--bad); border-color:var(--bad); }
+  .copybtn.ref { color:var(--orange); border-color:rgba(255,140,43,.4); }
+  .copybtn.ref:hover { background:rgba(255,140,43,.08); }
+  code.sentinel { color:var(--orange); background:rgba(255,140,43,.10); border:1px solid rgba(255,140,43,.22); font-weight:600; }
+  .cmdname { color:var(--accent2); font-weight:600; }
+  @media (max-width:620px){
+    .topbar { flex-direction:column; align-items:stretch; }
+    .controls { display:grid; grid-template-columns:1fr 1fr; gap:8px; }
+    .controls label { width:100%; }
+    .controls label select { flex:1; width:100%; }
+    .controls > button { width:100%; }
+  }
+  .grid { display:grid; gap:12px; grid-template-columns:repeat(auto-fit,minmax(170px,1fr)); margin-bottom:14px; }
+  .two-col { display:grid; gap:12px; grid-template-columns:1fr 1fr; margin-bottom:4px; }
+  @media (max-width:860px){ .two-col{ grid-template-columns:1fr; } }
+  .card {
+    background:linear-gradient(180deg,var(--card),var(--card2)); border:1px solid var(--line);
+    border-radius:12px; padding:14px 16px; min-width:0; box-shadow:var(--shadow); position:relative; overflow:hidden;
+    transition:transform .18s cubic-bezier(.2,.8,.2,1), border-color .18s, box-shadow .18s;
+  }
+  .card:hover { transform:translateY(-3px); border-color:var(--line-strong); box-shadow:0 6px 22px rgba(0,0,0,.28), 0 0 0 1px rgba(139,92,246,.08); }
+  /* KPI cards get a soft accent glow that brightens on hover */
+  .card.kpi::before { content:""; position:absolute; left:0; top:0; bottom:0; width:3px; background:var(--kpi,var(--accent)); box-shadow:0 0 12px var(--kpi,var(--accent)); opacity:.55; transition:opacity .18s; }
+  .card.kpi:hover::before { opacity:1; }
+  .card .label { font-size:10.5px; color:var(--dim); text-transform:uppercase; letter-spacing:.6px; display:flex; align-items:center; gap:5px; }
+  .card .value { font-size:clamp(20px,3.5vw,26px); font-weight:700; margin-top:5px; overflow-wrap:anywhere; }
+  .card .sub2 { font-size:11.5px; color:var(--dim); margin-top:3px; overflow-wrap:anywhere; }
+  .trend { font-size:11px; font-weight:600; padding:1px 6px; border-radius:20px; margin-left:6px; }
+  .trend.up { color:var(--ok); background:rgba(63,185,80,.12); }
+  .trend.down { color:var(--bad); background:rgba(248,81,73,.12); }
+  .trend.flat { color:var(--dim); background:rgba(139,148,158,.12); }
+  .section-title { font-size:11px; color:var(--dim); text-transform:uppercase; letter-spacing:.6px; margin:22px 0 8px; display:flex; align-items:center; gap:8px; cursor:pointer; user-select:none; }
+  .section-title .chev { transition:transform .15s; font-size:9px; color:var(--dim2); }
+  .section-title.collapsed .chev { transform:rotate(-90deg); }
+  .collapsed + * , .collapsed + * + * { display:none !important; }
+  .scroll { background:var(--card); border:1px solid var(--line); border-radius:12px; overflow-x:auto; -webkit-overflow-scrolling:touch; box-shadow:var(--shadow); }
+  table { width:100%; border-collapse:collapse; min-width:520px; }
+  th,td { text-align:left; padding:9px 12px; border-bottom:1px solid var(--line); font-size:13px; vertical-align:top; }
+  th { color:var(--dim); font-weight:600; text-transform:uppercase; font-size:10.5px; letter-spacing:.5px; white-space:nowrap; cursor:pointer; }
+  th:hover { color:var(--fg); }
+  tr:last-child td { border-bottom:none; }
+  tbody tr:hover { background:rgba(139,92,246,.05); }
+  code { background:rgba(127,127,127,.12); padding:2px 5px; border-radius:4px; font-size:12px; overflow-wrap:anywhere; }
+  .pill { display:inline-block; padding:2px 8px; border-radius:20px; font-size:11px; font-weight:600; }
+  .pill-ok{background:rgba(63,185,80,.15);color:var(--ok);} .pill-bad{background:rgba(248,81,73,.15);color:var(--bad);}
+  .pill-warn{background:rgba(210,153,34,.15);color:var(--warn);} .pill-info{background:rgba(88,166,255,.15);color:var(--info);}
+  .pill-mock{background:rgba(139,92,246,.15);color:var(--accent);} .pill-real{background:rgba(63,185,80,.15);color:var(--ok);}
+  .pill-dim{background:rgba(127,127,127,.12);color:var(--dim);}
+  .empty { background:var(--card); border:1px dashed var(--line); border-radius:12px; padding:22px; text-align:center; color:var(--dim); }
+  .alert { border-radius:12px; padding:12px 16px; margin-bottom:14px; border:1px solid; box-shadow:var(--shadow); }
+  .alert .head { font-weight:700; margin-bottom:4px; }
+  .alert.ok { background:rgba(63,185,80,.07); border-color:rgba(63,185,80,.3); color:var(--ok); }
+  .footer { margin-top:24px; padding:14px 16px; background:var(--card); border:1px solid var(--line); border-radius:12px; font-size:12px; color:var(--dim); }
+  .footer b { color:var(--fg); }
+  /* donut + legend */
+  .donut-wrap { display:flex; align-items:center; gap:18px; flex-wrap:wrap; }
+  .legend { display:flex; flex-direction:column; gap:5px; font-size:12px; flex:1; min-width:120px; }
+  .legend .li { display:flex; align-items:center; gap:7px; cursor:default; }
+  .legend .dot { width:10px; height:10px; border-radius:3px; flex:none; }
+  .legend .li .n { margin-left:auto; color:var(--dim); }
+  /* segmented bar */
+  .segbar { display:flex; height:22px; border-radius:7px; overflow:hidden; background:rgba(127,127,127,.1); }
+  .segbar > div { transition:width .3s; }
+  /* horizontal bars */
+  .bar-row { display:flex; align-items:center; gap:8px; margin:7px 0; font-size:12px; }
+  .bar-row .name { width:120px; color:var(--dim); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+  .bar-row .track { flex:1; background:rgba(127,127,127,.1); border-radius:5px; height:16px; overflow:hidden; }
+  .bar-row .fill { height:100%; border-radius:5px; transition:width .3s; }
+  .bar-row .n { width:58px; text-align:right; }
+  /* sparkline */
+  .spark { display:flex; align-items:flex-end; gap:1px; height:60px; background:var(--card); border:1px solid var(--line); border-radius:12px; padding:8px; box-shadow:var(--shadow); }
+  .spark > .b { background:linear-gradient(180deg,var(--c2),var(--c1)); flex:1 1 0; min-width:1px; border-radius:2px 2px 0 0; transition:height .2s; }
+  .spark > .b.zero { background:var(--line); min-height:1px; }
+  .stat-row { display:flex; gap:14px; flex-wrap:wrap; font-size:12px; color:var(--dim); margin-top:7px; }
+  .stat-row span { color:var(--fg); font-weight:600; }
+  .filter { background:var(--card); color:var(--fg); border:1px solid var(--line); border-radius:8px; padding:5px 9px; font-size:12px; margin-left:auto; min-width:180px; }
+  #tooltip { position:fixed; pointer-events:none; background:var(--bg2); border:1px solid var(--line); border-radius:8px; padding:6px 9px; font-size:12px; box-shadow:var(--shadow); opacity:0; transition:opacity .1s; z-index:50; white-space:nowrap; }
+  @media (max-width:560px){ body{padding:12px;} .grid{grid-template-columns:1fr 1fr;gap:8px;} th,td{padding:7px 9px;font-size:12px;} .filter{min-width:120px;} }
+</style>
+</head>
+<body>
+  <div class="topbar">
+    <div class="brandwrap">
+      <img id="logo" class="logo-img" alt="Blindfold" />
+      <div>
+        <h1><span class="brand"><span class="letter">B</span><span class="letter">l</span><span class="letter">i</span><span class="letter">n</span><span class="letter">d</span><span class="letter">f</span><span class="letter">o</span><span class="letter">l</span><span class="letter">d</span><div class="ribbon" id="brand-ribbon"></div><div class="sealbar" id="brand-sealbar"></div></span><span class="eyebrow">Dashboard</span></h1>
+        <div class="tagline"><span class="lock">\u{1F512}</span> Secrets sealed in a <b>TEE</b> \u2014 keys you can't leak</div>
+        <div class="tags" id="tags"></div>
+      </div>
+    </div>
+    <div class="controls">
+      <label>range
+        <select id="range" onchange="setRange()">
+          <option value="15">15m</option><option value="60" selected>1h</option>
+          <option value="1440">24h</option><option value="0">all</option>
+        </select>
+      </label>
+      <label>refresh
+        <select id="refresh" onchange="setRefresh()">
+          <option value="2000">2s</option><option value="5000">5s</option>
+          <option value="10000">10s</option><option value="0">paused</option>
+        </select>
+      </label>
+      <button onclick="toggleTheme()" id="themeBtn" title="Toggle theme">\u{1F319}</button>
+      <button onclick="exportJson()">\u2B07 Export</button>
+      <button onclick="clearLog()">Clear</button>
+    </div>
+  </div>
+
+  <div id="alert-banner"></div>
+
+  <div class="grid" id="kpis"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Security posture
+    <button style="margin-left:auto" onclick="event.stopPropagation();runFullAudit()">\u{1F50E} Run full audit (live)</button>
+  </div>
+  <div class="grid" id="posture-cards"></div>
+  <div id="full-audit"></div>
+
+  <div class="two-col">
+    <div>
+      <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Providers</div>
+      <div class="card" id="provider-chart"></div>
+    </div>
+    <div>
+      <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Status codes</div>
+      <div class="card" id="status-chart"></div>
+    </div>
+  </div>
+
+  <div class="two-col">
+    <div>
+      <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>p95 latency trend</div>
+      <div class="card" id="trend-latency"></div>
+    </div>
+    <div>
+      <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Success rate trend</div>
+      <div class="card" id="trend-success"></div>
+    </div>
+  </div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Requests per minute</div>
+  <div class="spark" id="spark"></div>
+  <div class="stat-row" id="spark-stats"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>System</div>
+  <div class="grid" id="status-cards"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Sealed keys (metadata only)</div>
+  <div id="sealed-table-wrap"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Per-secret usage</div>
+  <div id="per-secret-wrap"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Blindfold commands</div>
+  <div id="commands-wrap"></div>
+
+  <div class="section-title" onclick="toggleSection(this)"><span class="chev">\u25BC</span>Recent activity
+    <input id="filter" class="filter" placeholder="filter\u2026" oninput="renderTable(rangeFiltered())" onclick="event.stopPropagation()" />
+  </div>
+  <div id="table-wrap"></div>
+
+  <div class="footer"><b>Privacy by design.</b> Metadata only \u2014 no request/response bodies, no header values, no secret values. See <code>usage-log.ts</code> + <code>sealed-ledger.ts</code>.</div>
+  <div id="tooltip"></div>
+
+<script>
+/* Distinctive wordmark: each letter scrambles through cipher glyphs, then
+   snap-seals into place \u2014 mirroring how a real key becomes __BLINDFOLD__.
+   Purely decorative; respects prefers-reduced-motion. */
+(function sealWordmark(){
+  try {
+    if (window.matchMedia && window.matchMedia('(prefers-reduced-motion:reduce)').matches) return;
+    var letters = Array.prototype.slice.call(document.querySelectorAll('.brand > .letter'));
+    if (!letters.length) return;
+    var GLYPHS = '\u2593\u2588\u2592\u2591#@$%&*/\\<>=+\xB7:';
+    var finals = letters.map(function(el){ return el.textContent; });
+    letters.forEach(function(el){ el.classList.add('scrambling'); });
+    var bar = document.getElementById('brand-sealbar');
+    if (bar) { bar.classList.add('run'); }
+    var start = performance.now();
+    var settleAt = letters.map(function(_, i){ return 260 + i * 95; }); // staggered lock, left\u2192right
+    function frame(now){
+      var t = now - start, done = 0;
+      letters.forEach(function(el, i){
+        if (el.dataset.sealed) { done++; return; }
+        if (t >= settleAt[i]) {
+          el.textContent = finals[i];
+          el.classList.remove('scrambling');
+          el.classList.add('sealed');
+          el.dataset.sealed = '1';
+          done++;
+        } else if (t % 60 < 20) {
+          el.textContent = GLYPHS[(Math.random() * GLYPHS.length) | 0];
+        }
+      });
+      if (done < letters.length) requestAnimationFrame(frame);
+    }
+    requestAnimationFrame(frame);
+  } catch (e) { /* animation must never break the dashboard */ }
+})();
+var PALETTE=['#8b5cf6','#58a6ff','#3fb950','#d29922','#f85149','#ff7b72','#39c5cf','#f778ba'];
+function hashIdx(s){var h=0;for(var i=0;i<s.length;i++)h=(h*31+s.charCodeAt(i))>>>0;return h%PALETTE.length;}
+function colorFor(name){return PALETTE[hashIdx(String(name||'?'))];}
+var TOK=new URLSearchParams(location.search).get('token');
+function api(p){return TOK?p+(p.indexOf('?')>=0?'&':'?')+'token='+encodeURIComponent(TOK):p;}
+function esc(s){return String(s).replace(/[&<>"']/g,function(c){return({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[c];});}
+function timeAgo(iso){var ms=Date.now()-new Date(iso).getTime();if(ms<1000)return'just now';var s=(ms/1000)|0;if(s<60)return s+'s ago';var m=(s/60)|0;if(m<60)return m+'m ago';var h=(m/60)|0;if(h<24)return h+'h ago';return((h/24)|0)+'d ago';}
+function pillStatus(s){if(s>=200&&s<300)return'<span class="pill pill-ok">'+s+'</span>';if(s>=400)return'<span class="pill pill-bad">'+s+'</span>';return'<span class="pill pill-warn">'+s+'</span>';}
+function pillMode(m){return'<span class="pill pill-'+m+'">'+m+'</span>';}
+function pct(arr,p){if(!arr.length)return 0;var s=arr.slice().sort(function(a,b){return a-b;});return s[Math.min(s.length-1,Math.floor(p/100*s.length))];}
+
+// shared tooltip
+var TIP=null;
+function tip(ev,html){if(!TIP)TIP=document.getElementById('tooltip');TIP.innerHTML=html;TIP.style.opacity='1';TIP.style.left=(ev.clientX+12)+'px';TIP.style.top=(ev.clientY+12)+'px';}
+function tipHide(){if(TIP)TIP.style.opacity='0';}
+
+// state
+window._events=[]; window._sort={key:'t',dir:-1};
+function rangeMin(){return Number(document.getElementById('range').value);}
+function rangeFiltered(){var m=rangeMin();if(!m)return window._events;var cut=Date.now()-m*60000;return window._events.filter(function(e){return new Date(e.t).getTime()>=cut;});}
+
+function toggleTheme(){var h=document.documentElement;var d=h.getAttribute('data-theme')==='dark';h.setAttribute('data-theme',d?'light':'dark');document.getElementById('themeBtn').textContent=d?'\u2600':'\u{1F319}';try{localStorage.setItem('bf-theme',d?'light':'dark');}catch(e){}}
+(function(){try{var t=localStorage.getItem('bf-theme');if(t){document.documentElement.setAttribute('data-theme',t);document.getElementById('themeBtn').textContent=t==='light'?'\u2600':'\u{1F319}';}}catch(e){}})();
+function toggleSection(el){el.classList.toggle('collapsed');}
+function setRange(){poll();}
+function setRefresh(){var v=Number(document.getElementById('refresh').value);if(window._timer)clearInterval(window._timer);if(v>0)window._timer=setInterval(poll,v);}
+function exportJson(){var b=new Blob([JSON.stringify(window._events||[],null,2)],{type:'application/json'});var a=document.createElement('a');a.href=URL.createObjectURL(b);a.download='blindfold-usage-'+new Date().toISOString().slice(0,19).replace(/[:T]/g,'-')+'.json';a.click();}
+async function clearLog(){await fetch(api('/api/clear'),{method:'POST'});poll();}
+
+async function poll(){
+  try{
+    var r=await Promise.all([fetch(api('/api/status')).then(function(x){return x.json();}),fetch(api('/api/sealed')).then(function(x){return x.json();}),fetch(api('/api/events')).then(function(x){return x.json();}),fetch(api('/api/audit')).then(function(x){return x.json();})]);
+    var statusR=r[0],sealedR=r[1],eventsR=r[2],auditR=r[3];
+    window._events=eventsR.events||[];
+    var ev=rangeFiltered();
+    document.getElementById('tags').innerHTML=
+      '<span class="tag live"><span class="live-dot"></span>live</span>'
+      +'<span class="tag orange">'+new Date().toLocaleTimeString()+'</span>'
+      +'<span class="tag">'+(statusR.mode==='real'?'REAL \xB7 '+esc(statusR.t3_env||''):'MOCK')+'</span>'
+      +'<span class="tag path">usage <code title="'+esc(eventsR.source)+'">'+esc(eventsR.source)+'</code></span>';
+    renderAlert(auditR,ev);
+    renderKpis(ev,auditR,statusR);
+    renderPosture(auditR,statusR);
+    renderStatus(statusR);
+    renderDonut(ev);
+    renderStatusBar(ev);
+    renderTrends(ev);
+    renderSpark(ev);
+    renderSealed(sealedR.entries||[]);
+    renderPerSecret(ev);
+    renderTable(ev);
+  }catch(e){}
+}
+
+function trendBadge(cur,prev){if(prev===0&&cur===0)return'<span class="trend flat">\u2014</span>';if(prev===0)return'<span class="trend up">new</span>';var d=Math.round((cur-prev)/prev*100);if(Math.abs(d)<2)return'<span class="trend flat">0%</span>';return'<span class="trend '+(d>0?'up':'down')+'">'+(d>0?'\u25B2':'\u25BC')+Math.abs(d)+'%</span>';}
+
+function renderKpis(ev,a,s){
+  var half=ev.slice().sort(function(x,y){return new Date(x.t)-new Date(y.t);});
+  var mid=Math.floor(half.length/2);var prevHalf=half.slice(0,mid),curHalf=half.slice(mid);
+  function ok(arr){return arr.filter(function(e){return e.status>=200&&e.status<300;}).length;}
+  var total=ev.length;
+  var succ=total?Math.round(ok(ev)/total*100):0;
+  var prevSucc=prevHalf.length?Math.round(ok(prevHalf)/prevHalf.length*100):0;
+  var curSucc=curHalf.length?Math.round(ok(curHalf)/curHalf.length*100):0;
+  var p95=pct(ev.map(function(e){return e.latency_ms||0;}),95);
+  var p95p=pct(prevHalf.map(function(e){return e.latency_ms||0;}),95);
+  var p95c=pct(curHalf.map(function(e){return e.latency_ms||0;}),95);
+  var sealed=(a&&a.sealed_count)||0;
+  var posture=postureScore(a,s).score;
+  var cards=[
+    ['Requests',total,'',trendBadge(curHalf.length,prevHalf.length),'var(--c1)'],
+    ['Success rate',succ+'%',ok(ev)+'/'+total+' 2xx',trendBadge(curSucc,prevSucc),succ>=95?'var(--ok)':succ>=80?'var(--warn)':'var(--bad)'],
+    ['p95 latency',p95+' ms',ev.length+' samples',trendBadge(p95c,p95p),'var(--c2)'],
+    ['Sealed secrets',sealed,'in the enclave','','var(--c7)'],
+    ['Posture',posture+'<span style="font-size:13px;color:var(--dim)">/100</span>','security score','',posture>=90?'var(--ok)':posture>=60?'var(--warn)':'var(--bad)']
+  ];
+  document.getElementById('kpis').innerHTML=cards.map(function(c){return '<div class="card kpi" style="--kpi:'+c[4]+'"><div class="label">'+c[0]+'</div><div class="value">'+c[1]+c[3]+'</div><div class="sub2">'+c[2]+'</div></div>';}).join('');
+}
+
+function postureScore(a,s){var exposed=((a&&a.exposed_in_env)||[]).length;var chain=(a&&a.ledger_chain)||{ok:true,total:0};var sealed=(a&&a.sealed_count)||0;var score=100;var notes=[];if(exposed>0){score-=30;notes.push(exposed+' key(s) in .env');}if(chain.total>0&&!chain.ok){score-=40;notes.push('ledger TAMPERED');}if(s&&s.mode!=='real'){score-=10;notes.push('MOCK mode');}if(s&&!s.sdk_installed){score-=10;notes.push('SDK missing');}if(sealed===0){score-=10;notes.push('nothing sealed');}return{score:Math.max(0,score),notes:notes};}
+
+function renderAlert(a,ev){
+  var msgs=[];var chain=(a&&a.ledger_chain)||{};
+  if(chain.total>0&&!chain.ok)msgs.push(['bad','\u{1F534} Ledger TAMPERED \u2014 a sealed-keys line was edited or removed']);
+  if(((a&&a.exposed_in_env)||[]).length>0)msgs.push(['warn','\u{1F7E0} '+a.exposed_in_env.length+' sealed key(s) still in .env \u2014 delete them']);
+  var recent=(ev||[]).filter(function(e){return Date.now()-new Date(e.t).getTime()<300000;});
+  var errs=recent.filter(function(e){return(e.status||0)>=400;}).length;
+  if(recent.length>=5&&errs/recent.length>0.3)msgs.push(['warn','\u{1F7E0} '+Math.round(errs/recent.length*100)+'% errors in the last 5 min ('+errs+'/'+recent.length+')']);
+  var el=document.getElementById('alert-banner');
+  if(!msgs.length){el.innerHTML='';return;}
+  var bad=msgs.some(function(m){return m[0]==='bad';});
+  el.innerHTML='<div class="alert" style="background:'+(bad?'rgba(248,81,73,.08)':'rgba(210,153,34,.08)')+';border-color:'+(bad?'rgba(248,81,73,.4)':'rgba(210,153,34,.4)')+';color:'+(bad?'var(--bad)':'var(--warn)')+'"><div class="head">\u26A0 Attention</div>'+msgs.map(function(m){return esc(m[1]);}).join('<br/>')+'</div>';
+}
+
+function renderPosture(a,s){
+  var p=postureScore(a,s);var exposed=((a&&a.exposed_in_env)||[]).length;var chain=(a&&a.ledger_chain)||{ok:true,total:0,legacy:0};
+  var chainTxt=chain.total===0?'empty':(chain.ok?'intact':'TAMPERED');
+  var cards=[
+    ['.env leak surface',exposed===0?'0 \u2705':exposed+' \u26A0','sealed keys still in .env',exposed===0?'var(--ok)':'var(--warn)'],
+    ['Ledger integrity',(chainTxt==='TAMPERED'?'\u2716 ':chainTxt==='intact'?'\u2705 ':'')+chainTxt,(chain.legacy||0)+' legacy entries',chainTxt==='TAMPERED'?'var(--bad)':'var(--ok)'],
+    ['Mode',s&&s.mode==='real'?'REAL':'MOCK',s&&s.mode==='real'?'connected to '+esc(s.t3_env||''):'BLINDFOLD_MOCK=1','var(--c1)'],
+    ['Issues',p.notes.length,p.notes.length?esc(p.notes.join(' \xB7 ')):'all clear',p.notes.length?'var(--warn)':'var(--ok)']
+  ];
+  document.getElementById('posture-cards').innerHTML=cards.map(function(c){return '<div class="card kpi" style="--kpi:'+c[3]+'"><div class="label">'+c[0]+'</div><div class="value">'+c[1]+'</div><div class="sub2">'+c[2]+'</div></div>';}).join('');
+}
+
+function renderStatus(s){
+  var cards=[
+    [s.mode==='real'?'REAL':'MOCK','Mode',s.mode==='real'?'T3 '+esc(s.t3_env):'mock'],
+    [esc(s.contract_version||'\u2014'),'Contract','blindfold-proxy'],
+    [esc(s.tenant_did_short||'(none)'),'Tenant',s.tenant_did?'full in title':'set creds'],
+    [s.proxy_port,'Proxy port','127.0.0.1:'+s.proxy_port],
+    [s.sdk_installed?'\u2713':'\u2717','SDK',s.sdk_installed?'installed':'missing']
+  ];
+  document.getElementById('status-cards').innerHTML=cards.map(function(c){return '<div class="card"><div class="label">'+esc(c[1])+'</div><div class="value">'+esc(c[0])+'</div><div class="sub2">'+esc(c[2])+'</div></div>';}).join('');
+}
+
+function donutSvg(rows,total){
+  var r=42,c=2*Math.PI*r,off=0,seg='';
+  rows.forEach(function(row){var frac=total?row[1]/total:0;var len=frac*c;var col=colorFor(row[0]);seg+='<circle cx="60" cy="60" r="'+r+'" fill="none" stroke="'+col+'" stroke-width="16" stroke-dasharray="'+len.toFixed(2)+' '+(c-len).toFixed(2)+'" stroke-dashoffset="'+(-off).toFixed(2)+'" transform="rotate(-90 60 60)"><title>'+esc(row[0])+': '+row[1]+'</title></circle>';off+=len;});
+  return '<svg viewBox="0 0 120 120" style="width:120px;height:120px;flex:none">'+seg+'<text x="60" y="56" text-anchor="middle" fill="var(--fg)" font-size="22" font-weight="700">'+total+'</text><text x="60" y="74" text-anchor="middle" fill="var(--dim)" font-size="9">requests</text></svg>';
+}
+function renderDonut(ev){
+  var by={};ev.forEach(function(e){var k=e.provider||'(unknown)';by[k]=(by[k]||0)+1;});
+  var rows=Object.keys(by).map(function(k){return[k,by[k]];}).sort(function(a,b){return b[1]-a[1];});
+  var el=document.getElementById('provider-chart');
+  if(!rows.length){el.innerHTML='<div style="color:var(--dim);font-size:13px">No traffic yet.</div>';return;}
+  var legend=rows.map(function(row){return '<div class="li"><span class="dot" style="background:'+colorFor(row[0])+'"></span>'+esc(row[0])+'<span class="n">'+row[1]+'</span></div>';}).join('');
+  el.innerHTML='<div class="donut-wrap">'+donutSvg(rows,ev.length)+'<div class="legend">'+legend+'</div></div>';
+}
+
+function renderStatusBar(ev){
+  var b={'2xx':0,'3xx':0,'4xx':0,'5xx':0};ev.forEach(function(e){var k=Math.floor((e.status||0)/100)+'xx';if(b[k]!==undefined)b[k]++;});
+  var col={'2xx':'var(--ok)','3xx':'var(--info)','4xx':'var(--warn)','5xx':'var(--bad)'};
+  var total=ev.length;var el=document.getElementById('status-chart');
+  if(!total){el.innerHTML='<div style="color:var(--dim);font-size:13px">No traffic yet.</div>';return;}
+  var segs=Object.keys(b).filter(function(k){return b[k]>0;}).map(function(k){return '<div style="width:'+(b[k]/total*100)+'%;background:'+col[k]+'" title="'+k+': '+b[k]+'"></div>';}).join('');
+  var legend=Object.keys(b).map(function(k){return '<div class="li"><span class="dot" style="background:'+col[k]+'"></span>'+k+'<span class="n">'+b[k]+'</span></div>';}).join('');
+  el.innerHTML='<div class="segbar">'+segs+'</div><div class="legend" style="flex-direction:row;flex-wrap:wrap;gap:14px;margin-top:12px">'+legend+'</div>';
+}
+
+function areaSvg(values,color,maxOpt){
+  var w=300,h=70,n=values.length;if(n<2)values=values.concat(values);n=values.length;
+  var max=Math.max(maxOpt||0,Math.max.apply(null,values),1);
+  var pts=values.map(function(v,i){return (i/(n-1)*w).toFixed(1)+','+(h-(v/max)*h).toFixed(1);});
+  var gid='g'+Math.floor(Math.random()*1e6);
+  var poly=pts.join(' ');var area='0,'+h+' '+poly+' '+w+','+h;
+  return '<svg viewBox="0 0 '+w+' '+h+'" preserveAspectRatio="none" style="width:100%;height:72px;display:block"><defs><linearGradient id="'+gid+'" x1="0" y1="0" x2="0" y2="1"><stop offset="0%" stop-color="'+color+'" stop-opacity="0.35"/><stop offset="100%" stop-color="'+color+'" stop-opacity="0"/></linearGradient></defs><polygon points="'+area+'" fill="url(#'+gid+')"/><polyline points="'+poly+'" fill="none" stroke="'+color+'" stroke-width="2" vector-effect="non-scaling-stroke"/></svg>';
+}
+function renderTrends(ev){
+  var now=Date.now();var lat=[],ok=[],tot=[];for(var i=0;i<60;i++){lat.push([]);ok.push(0);tot.push(0);}
+  ev.forEach(function(e){var ageMin=Math.floor((now-new Date(e.t).getTime())/60000);if(ageMin>=0&&ageMin<60){var idx=59-ageMin;lat[idx].push(e.latency_ms||0);tot[idx]++;if((e.status||0)>=200&&(e.status||0)<300)ok[idx]++;}});
+  var p95=lat.map(function(a){return a.length?pct(a,95):0;});
+  var succ=tot.map(function(t,i){return t?Math.round(ok[i]/t*100):0;});
+  document.getElementById('trend-latency').innerHTML=areaSvg(p95,'var(--c1)')+'<div class="stat-row">peak p95 <span>'+Math.max.apply(null,p95.concat(0))+' ms</span></div>';
+  document.getElementById('trend-success').innerHTML=areaSvg(succ,'var(--ok)',100)+'<div class="stat-row">latest <span>'+(succ[59]||0)+'%</span></div>';
+}
+
+function renderSpark(ev){
+  var now=Date.now();var b=[];for(var i=0;i<60;i++)b.push(0);
+  ev.forEach(function(e){var ageMin=Math.floor((now-new Date(e.t).getTime())/60000);if(ageMin>=0&&ageMin<60)b[59-ageMin]++;});
+  var max=Math.max.apply(null,b.concat(1));
+  document.getElementById('spark').innerHTML=b.map(function(v,i){var hh=Math.max(1,Math.round(v/max*44));return '<div class="b '+(v===0?'zero':'')+'" style="height:'+hh+'px" title="'+v+' req \xB7 '+(59-i)+'m ago"></div>';}).join('');
+  var sum=b.reduce(function(a,c){return a+c;},0);
+  document.getElementById('spark-stats').innerHTML='last 60 min <span>'+sum+'</span> \xB7 peak minute <span>'+max+'</span>';
+}
+
+function renderSealed(entries){
+  if(!entries.length){document.getElementById('sealed-table-wrap').innerHTML='<div class="empty">No keys sealed yet. <code>blindfold register --name &lt;K&gt;</code></div>';return;}
+  var latest={};entries.forEach(function(e){latest[e.name]=e;});
+  var rows=Object.keys(latest).map(function(k){return latest[k];}).sort(function(a,b){return a.t<b.t?1:-1;}).map(function(e){return '<tr><td><span class="dot" style="display:inline-block;width:8px;height:8px;border-radius:2px;margin-right:6px;background:'+colorFor(e.name)+'"></span><code>'+esc(e.name)+'</code></td><td>'+e.length+' B</td><td>'+pillMode(e.mode)+'</td><td title="'+esc(e.t)+'">'+timeAgo(e.t)+'</td><td><code class="sentinel">__BLINDFOLD__</code></td><td style="white-space:nowrap"><button class="copybtn cmd" data-name="'+esc(e.name)+'" title="Copy a ready-to-run verify command">\u29C9 cmd</button> <button class="copybtn ref" data-name="'+esc(e.name)+'" title="Copy the Blindfold sentinel \u2014 put this where the real key would go; the enclave substitutes the sealed value at call time">\u29C9 sealed token</button></td></tr>';}).join('');
+  document.getElementById('sealed-table-wrap').innerHTML='<div class="scroll"><table><thead><tr><th>Name</th><th>Bytes</th><th>Mode</th><th>Sealed</th><th>Sealed token</th><th>Copy</th></tr></thead><tbody>'+rows+'</tbody></table></div>';
+  function flash(b,txt,cls){var o=b.textContent;b.textContent=txt;b.classList.add(cls||'done');setTimeout(function(){b.textContent=o;b.classList.remove('done','err');},1400);}
+  var cmds=document.querySelectorAll('#sealed-table-wrap .copybtn.cmd');
+  for(var i=0;i<cmds.length;i++){(function(b){b.onclick=function(){var cmd='npm run blindfold -- use --name '+b.getAttribute('data-name')+' --check';try{navigator.clipboard.writeText(cmd);}catch(e){}flash(b,'\u2713 copied');};})(cmds[i]);}
+  var refs=document.querySelectorAll('#sealed-table-wrap .copybtn.ref');
+  for(var j=0;j<refs.length;j++){(function(b){b.onclick=function(){try{navigator.clipboard.writeText('__BLINDFOLD__');}catch(e){}flash(b,'\u2713 sentinel copied');};})(refs[j]);}
+}
+
+function renderPerSecret(ev){
+  var by={};ev.forEach(function(e){var k=e.secret_key||'(unknown)';by[k]=(by[k]||0)+1;});
+  var rows=Object.keys(by).map(function(k){return[k,by[k]];}).sort(function(a,b){return b[1]-a[1];});
+  var el=document.getElementById('per-secret-wrap');
+  if(!rows.length){el.innerHTML='<div class="empty">No secret usage yet. Try <code>blindfold use --name &lt;X&gt; -- &lt;cmd&gt;</code> or the proxy.</div>';return;}
+  var max=Math.max.apply(null,rows.map(function(r){return r[1];}).concat(1));
+  el.innerHTML='<div class="card">'+rows.map(function(r){return '<div class="bar-row"><div class="name" title="'+esc(r[0])+'">'+esc(r[0])+'</div><div class="track"><div class="fill" style="width:'+(r[1]/max*100)+'%;background:'+colorFor(r[0])+'"></div></div><div class="n">'+r[1]+'</div></div>';}).join('')+'</div>';
+}
+
+function sortBy(k){if(window._sort.key===k)window._sort.dir*=-1;else window._sort={key:k,dir:-1};renderTable(rangeFiltered());}
+function renderTable(ev){
+  var q=(document.getElementById('filter').value||'').toLowerCase().trim();
+  var list=ev;
+  if(q)list=ev.filter(function(e){return(e.provider||'').toLowerCase().indexOf(q)>=0||(e.path||'').toLowerCase().indexOf(q)>=0||(e.via||'').toLowerCase().indexOf(q)>=0||String(e.status||'').indexOf(q)>=0||(e.mode||'').toLowerCase().indexOf(q)>=0;});
+  var k=window._sort.key,dir=window._sort.dir;
+  list=list.slice().sort(function(a,b){var x=a[k],y=b[k];if(k==='t'){x=new Date(a.t).getTime();y=new Date(b.t).getTime();}return x<y?-dir:x>y?dir:0;}).slice(0,80);
+  if(!list.length){document.getElementById('table-wrap').innerHTML='<div class="empty">'+(q?'No requests match "'+esc(q)+'".':'No traffic in range. Use a secret or the proxy.')+'</div>';return;}
+  var rows=list.map(function(e){return '<tr><td>'+timeAgo(e.t)+'</td><td><span class="dot" style="display:inline-block;width:8px;height:8px;border-radius:2px;margin-right:6px;background:'+colorFor(e.provider)+'"></span>'+esc(e.provider)+'</td><td><span class="pill pill-info">'+esc(e.via||'proxy')+'</span></td><td><code>'+esc(e.method)+' '+esc(e.path)+'</code></td><td>'+pillStatus(e.status)+'</td><td>'+e.latency_ms+' ms</td><td>'+pillMode(e.mode)+'</td></tr>';}).join('');
+  document.getElementById('table-wrap').innerHTML='<div class="scroll"><table><thead><tr><th data-k="t">When</th><th data-k="provider">Provider</th><th data-k="via">Via</th><th>Request</th><th data-k="status">Status</th><th data-k="latency_ms">Latency</th><th data-k="mode">Mode</th></tr></thead><tbody>'+rows+'</tbody></table></div>';
+  var ths=document.querySelectorAll('#table-wrap th[data-k]');for(var ti=0;ti<ths.length;ti++){(function(th){th.onclick=function(){sortBy(th.getAttribute('data-k'));};})(ths[ti]);}
+}
+
+async function runFullAudit(){
+  var el=document.getElementById('full-audit');el.innerHTML='<div class="empty">Running live enclave reconciliation\u2026</div>';
+  try{
+    var r=await fetch(api('/api/audit/full')).then(function(x){return x.json();});
+    if(r.mock){el.innerHTML='<div class="alert ok"><div class="head">MOCK mode</div>Reconciliation only runs in REAL mode.</div>';return;}
+    if(r.error){el.innerHTML='<div class="alert" style="border-color:rgba(248,81,73,.4);color:var(--bad)"><div class="head">Audit error</div>'+esc(r.error)+'</div>';return;}
+    var rows=(r.results||[]).map(function(x){return '<tr><td><code>'+esc(x.name)+'</code></td><td>'+(x.present?'<span class="pill pill-ok">present</span>':'<span class="pill pill-bad">MISSING</span>')+'</td><td>'+x.enclave_len+' B</td><td>'+x.ledger_len+' B</td><td>'+(x.ok?'<span class="pill pill-ok">ok</span>':'<span class="pill pill-warn">drift</span>')+'</td><td><code>'+esc(x.fingerprint||'')+'</code></td></tr>';}).join('');
+    var okN=(r.results||[]).filter(function(x){return x.ok;}).length;
+    el.innerHTML='<div class="scroll" style="margin-bottom:6px"><table><thead><tr><th>Secret</th><th>Enclave</th><th>Enc bytes</th><th>Ledger bytes</th><th>Match</th><th>Fingerprint</th></tr></thead><tbody>'+rows+'</tbody></table></div><div class="stat-row">'+okN+'/'+(r.results||[]).length+' verified against the enclave</div>';
+  }catch(e){el.innerHTML='<div class="alert" style="border-color:rgba(248,81,73,.4);color:var(--bad)"><div class="head">Audit failed</div>'+esc(String(e))+'</div>';}
+}
+
+function startStream(){try{var es=new EventSource(api('/api/stream'));es.addEventListener('change',function(){poll();});es.onerror=function(){};}catch(e){}}
+
+function renderCommands(){
+  var C=[
+    ['doctor','doctor','Check your key + tenant are healthy'],
+    ['status','status','Mode, tenant, and every sealed secret'],
+    ['audit','audit','Verify the ledger + reconcile against the enclave'],
+    ['migrate','migrate','Seal every secret in .env in one shot'],
+    ['register','register --name NAME --from-env NAME','Seal a secret into the enclave'],
+    ['use','use --name NAME -- COMMAND','Run any tool with a sealed secret injected'],
+    ['use --check','use --name NAME --check','Confirm a sealed secret is usable'],
+    ['rotate','rotate --name NAME --from-env NAME','Replace a secret value (rollback-safe)'],
+    ['rollback','rollback --name NAME','Restore the previous value'],
+    ['versions','versions --name NAME','List rollback snapshots'],
+    ['grant','grant --host api.openai.com','Authorize the contract to call a host'],
+    ['share','share --to DID --host HOST','Let a teammate agent use your keys'],
+    ['revoke','revoke --to DID','Remove a teammate access'],
+    ['proxy','proxy','Run the local OpenAI/Anthropic proxy'],
+    ['publish','publish','Publish the contract to T3'],
+    ['sealed','sealed','List sealed keys (metadata only)'],
+    ['dashboard','dashboard','Launch this dashboard'],
+    ['export','export --name NAME','CI: inject a sealed secret into the job env']
+  ];
+  var rows=C.map(function(c){return '<tr><td><span class="cmdname">'+esc(c[0])+'</span></td><td><code>npm run blindfold -- '+esc(c[1])+'</code></td><td>'+esc(c[2])+'</td><td><button class="copybtn" data-cmd="npm run blindfold -- '+esc(c[1])+'">\u29C9 copy</button></td></tr>';}).join('');
+  document.getElementById('commands-wrap').innerHTML='<div class="scroll"><table><thead><tr><th>Command</th><th>Run</th><th>What it does</th><th>Copy</th></tr></thead><tbody>'+rows+'</tbody></table></div>';
+  var btns=document.querySelectorAll('#commands-wrap .copybtn');
+  for(var i=0;i<btns.length;i++){(function(b){b.onclick=function(){try{navigator.clipboard.writeText(b.getAttribute('data-cmd'));}catch(e){}var o=b.textContent;b.textContent='\u2713 copied';b.classList.add('done');setTimeout(function(){b.textContent=o;b.classList.remove('done');},1300);};})(btns[i]);}
+}
+
+document.getElementById('logo').src=api('/logo.png');
+renderCommands();
+poll();setRefresh();startStream();
+</script>
+</body>
+</html>
+`;
+
+// bin/cmd-serve.ts
+init_usage_log();
+async function handleServe(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "proxy": {
+      const port = argv.flags.port ? Number(argv.flags.port) : void 0;
+      const secret = argv.flags.secret ? String(argv.flags.secret) : void 0;
+      let token = argv.flags.token ? String(argv.flags.token) : void 0;
+      if (!token && argv.flags.auth) token = randomBytes3(24).toString("hex");
+      let socket;
+      if (argv.flags.socket !== void 0) {
+        socket = typeof argv.flags.socket === "string" && argv.flags.socket.length > 0 ? String(argv.flags.socket) : path9.join(stateDir(), "proxy.sock");
+      }
+      const proxyGate = await attestationGate({ skip: !!argv.flags["no-attest"] });
+      if (proxyGate.warning) console.error(`\u26A0\uFE0F  ${proxyGate.warning}`);
+      if (proxyGate.enforced && !proxyGate.ok) {
+        die(`attestation gate: ${proxyGate.message}. Refusing to start the proxy against an unverified enclave. (bypass: --no-attest, or clear the pin)`);
+      }
+      if (proxyGate.enforced) console.log("\u2713 enclave attestation verified");
+      if (socket && !token) {
+        console.error("\u26A0\uFE0F  --socket without --auth: access is gated only by the socket's 0600 owner permission. Add --auth for a per-process token too.");
+      }
+      const handle2 = await startProxy({ port, secretKey: secret, token, socket });
+      console.log(`\u2713 Blindfold proxy listening at ${handle2.url}`);
+      if (handle2.socket) {
+        console.log(`  Unix socket (0600) \u2014 only your user's processes can connect.`);
+        console.log(`  Call it with:          curl --unix-socket ${handle2.socket} http://localhost/v1/...`);
+      } else {
+        console.log(`  Point your agent at:   OPENAI_BASE_URL=${handle2.url}/v1`);
+      }
+      if (handle2.token) {
+        console.error(`  Auth ON \u2014 every request must send header:`);
+        console.error(`    x-blindfold-token: ${handle2.token}`);
+        console.error(`  Give it to your agent via BLINDFOLD_PROXY_TOKEN or wrap({ token }).`);
+        console.error(`  NOTE: env vars and argv are readable by same-user processes \u2014 on a shared`);
+        console.error(`        machine prefer --socket (OS-enforced) over the token alone.`);
+        if (argv.flags.token) {
+          console.error(`  \u26A0\uFE0F  --token on the command line is visible in \`ps\`/proc; prefer --auth (mints one) or BLINDFOLD_PROXY_TOKEN.`);
+        }
+      } else {
+        console.log(`  Auth OFF \u2014 add --auth to require a per-session token (recommended on shared machines).`);
+      }
+      console.log(`  Health check:          ${handle2.url}/health`);
+      process.on("SIGINT", async () => {
+        await handle2.close();
+        process.exit(0);
+      });
+      return;
+    }
+    case "attest": {
+      const expectRtmr3 = argv.flags["expect-rtmr3"] ? String(argv.flags["expect-rtmr3"]) : void 0;
+      const r = await attest({ expectRtmr3, noCache: true });
+      if (argv.flags.json) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+      }
+      if (!r.available) {
+        console.log(`\u2139\uFE0F  ${r.nodeUrl} publishes no attestation (mock signer or still bootstrapping).`);
+        return;
+      }
+      console.log(`Attestation for ${r.nodeUrl}`);
+      console.log(`  chain to Intel root:  ${r.valid ? "\u2705 valid" : "\u2716 INVALID"}${r.error ? ` (${r.error})` : ""}`);
+      console.log(`  quotes verified:      ${r.validCount}/${r.expectedCount}`);
+      for (const m of r.rtmr3s) console.log(`  RTMR3 (code measure): ${m}`);
+      if (expectRtmr3) {
+        console.log(`  RTMR3 pin:            ${r.pinned ? "\u2705 matches expected" : "\u2716 DID NOT MATCH"}`);
+      } else if (r.rtmr3s.length) {
+        console.log(`  Tip: pin it next time \u2192 blindfold attest --expect-rtmr3 ${r.rtmr3s[0]}`);
+      }
+      if (argv.flags.pin) {
+        const toPin = expectRtmr3 ?? r.rtmr3s[0];
+        if (r.valid && toPin) {
+          if (!expectRtmr3) {
+            console.error(`  \u26A0\uFE0F  Pinning the measurement the node just reported (trust-on-first-use).`);
+            console.error(`      Cross-check ${toPin} against your enclave's published/reproducible build hash;`);
+            console.error(`      if this first contact was with a malicious node, you'd be pinning its measurement.`);
+          }
+          writePinnedRtmr3(toPin);
+          console.log(`  \u2713 pinned \u2014 \`seal\` and \`proxy\` will now verify this measurement first.`);
+        } else {
+          console.log(`  \u2717 not pinning: attestation must pass first.`);
+        }
+      }
+      if (!r.valid || expectRtmr3 && !r.pinned) process.exitCode = 1;
+      return;
+    }
+    case "dashboard": {
+      const port = argv.flags.port ? Number(argv.flags.port) : void 0;
+      const handle2 = await startDashboard({ port });
+      console.log(`\u2713 Blindfold dashboard at ${handle2.url}`);
+      console.log(`  Reading: ${defaultLogPath()}`);
+      console.log(`  (open in your browser; auto-refreshes every 2s)`);
+      process.on("SIGINT", async () => {
+        await handle2.close();
+        process.exit(0);
+      });
+      return;
+    }
+    case "stats": {
+      const events = readUsage();
+      if (events.length === 0) {
+        console.log("No usage recorded yet. Reads from " + defaultLogPath());
+        return;
+      }
+      const byProvider = {};
+      let ok3 = 0, bad2 = 0, totalLat = 0, sentinel = 0;
+      for (const e of events) {
+        byProvider[e.provider] = (byProvider[e.provider] ?? 0) + 1;
+        if (e.status >= 200 && e.status < 300) ok3++;
+        else if (e.status >= 400) bad2++;
+        totalLat += e.latency_ms;
+        if (e.sentinel_in_outbound) sentinel++;
+      }
+      const total = events.length;
+      console.log("Blindfold usage stats (source: " + defaultLogPath() + ")");
+      console.log(`  Total requests:     ${total}`);
+      console.log(`  2xx / 4xx+:         ${ok3} / ${bad2}`);
+      console.log(`  Sentinel substituted: ${sentinel}/${total}  (should equal total)`);
+      console.log(`  Avg latency:        ${total ? Math.round(totalLat / total) : 0} ms`);
+      console.log(`  By provider:        ${Object.entries(byProvider).map(([k, v]) => `${k}\xD7${v}`).join("  ")}`);
+      console.log(`  Recent (last 5):`);
+      for (const e of events.slice(-5)) {
+        console.log(`    ${e.t}  ${e.method.padEnd(6)} ${e.path}  \u2192 ${e.status} (${e.latency_ms}ms, ${e.provider}, ${e.mode})`);
+      }
+      return;
+    }
+    case "stats:clear": {
+      clearUsage();
+      console.log("\u2713 Cleared " + defaultLogPath());
+      return;
+    }
+  }
+}
+
+// bin/cmd-enclave.ts
+init_env();
+init_register();
+import fs14 from "node:fs";
+import path12 from "node:path";
+
+// src/init.ts
+init_env();
+init_sealed_ledger();
+init_t3_client();
+import { spawn as spawn2 } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path10 from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+var HERE3 = path10.dirname(fileURLToPath4(import.meta.url));
+var REPO_ROOT2 = path10.resolve(HERE3, "..", "..", "..");
+var ENV_PATH = path10.join(REPO_ROOT2, ".env");
+var ENV_EXAMPLE_PATH = path10.join(REPO_ROOT2, ".env.example");
+var WASM_PATH = path10.join(REPO_ROOT2, "contract", "target", "wasm32-wasip2", "release", "blindfold_proxy.wasm");
+var T3_CLAIM_URL = "https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens";
+var colour = process.stdout.isTTY ? (c2, s) => `\x1B[${c2}m${s}\x1B[0m` : (_, s) => s;
+var bold = (s) => colour("1", s);
+var green = (s) => colour("32", s);
+var yellow = (s) => colour("33", s);
+var red = (s) => colour("31", s);
+var dim = (s) => colour("2", s);
+var cyan = (s) => colour("36", s);
+function header(n, total, title) {
+  process.stdout.write(`
+${dim(`[${n}/${total}]`)} ${bold(title)}
+`);
+}
+function ok2(line) {
+  process.stdout.write(`  ${green("\u2713")} ${line}
+`);
+}
+function info(line) {
+  process.stdout.write(`  ${dim("\xB7")} ${line}
+`);
+}
+function warn2(line) {
+  process.stdout.write(`  ${yellow("!")} ${line}
+`);
+}
+function fail(line, fixHint) {
+  process.stdout.write(`  ${red("\u2716")} ${line}
+`);
+  if (fixHint) {
+    for (const ln of fixHint.split("\n")) process.stdout.write(`    ${dim("\u2192")} ${cyan(ln)}
+`);
+  }
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn2(cmd, args, {
+      cwd: opts.cwd ?? REPO_ROOT2,
+      env: { ...process.env, ...opts.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const o = [];
+    const e = [];
+    child.stdout.on("data", (c2) => o.push(c2));
+    child.stderr.on("data", (c2) => e.push(c2));
+    child.on("close", (code) => resolve({ code: code ?? -1, out: Buffer.concat(o).toString("utf8"), err: Buffer.concat(e).toString("utf8") }));
+    child.on("error", (err) => resolve({ code: -1, out: "", err: err.message }));
+  });
+}
+async function ask(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(prompt)).trim();
+  } finally {
+    rl.close();
+  }
+}
+async function runInit(opts = {}) {
+  const total = 5;
+  process.stdout.write(`
+${bold("\u{1F6E1}\uFE0F  Blindfold \u2014 first-time setup")}
+${dim("This wizard sets up REAL T3 mode end-to-end. Secrets are read from your .env, never typed onto the command line.")}
+`);
+  header(1, total, "Preflight");
+  await ensureEnvOrPrompt(opts);
+  loadEnvFromFile(ENV_PATH);
+  const env = loadBlindfoldEnv();
+  if (!env.t3nApiKey || !env.did) {
+    fail("Still missing T3N_API_KEY and/or DID after .env walkthrough.", "Open .env, paste the two values, and re-run `npm run setup`.");
+    throw new Error("preflight failed");
+  }
+  ok2(`T3 ${env.t3Env} \xB7 tenant ${dim(env.did)}`);
+  const haveSdk = await isSdkInstalled2();
+  if (!haveSdk) {
+    fail("@terminal3/t3n-sdk is not installed.", "Run: npm install @terminal3/t3n-sdk");
+    throw new Error("sdk missing");
+  }
+  ok2("@terminal3/t3n-sdk present");
+  let canBuild = !opts.skipBuild;
+  if (canBuild) {
+    const cargo = await run("which", ["cargo"]);
+    if (cargo.code !== 0) {
+      warn2("cargo (Rust toolchain) not found \u2014 auto-skipping contract build.");
+      info(`Install rust at https://rustup.rs and re-run \`blindfold init\` to build the contract locally.`);
+      canBuild = false;
+    } else {
+      const targets = await run("rustup", ["target", "list", "--installed"]);
+      if (!targets.out.includes("wasm32-wasip2")) {
+        info("Installing wasm32-wasip2 target \u2026");
+        const add = await run("rustup", ["target", "add", "wasm32-wasip2"]);
+        if (add.code !== 0) {
+          warn2("Could not install wasm32-wasip2 automatically; skipping contract build.");
+          info("Run manually: rustup target add wasm32-wasip2");
+          canBuild = false;
+        }
+      }
+      if (canBuild) ok2("Rust toolchain + wasm32-wasip2 target ready");
+    }
+  }
+  if (canBuild) {
+    header(2, total, "Build contract  (Rust \u2192 WASM)");
+    info("cargo build --target wasm32-wasip2 --release");
+    const build = await run("cargo", ["build", "--target", "wasm32-wasip2", "--release"], {
+      cwd: path10.join(REPO_ROOT2, "contract")
+    });
+    if (build.code !== 0) {
+      fail("Contract build failed.", `Inspect with: cd contract && cargo build --target wasm32-wasip2 --release
+stderr tail:
+${build.err.slice(-800)}`);
+      throw new Error("contract build failed");
+    }
+    if (!existsSync(WASM_PATH)) {
+      fail(`Build succeeded but artifact missing at ${WASM_PATH}.`, "Did the package name change?");
+      throw new Error("artifact missing");
+    }
+    const wasmBytes = readFileSync(WASM_PATH);
+    ok2(`Built ${WASM_PATH} (${wasmBytes.byteLength.toLocaleString()} bytes)`);
+  } else {
+    header(2, total, "Build contract  (skipped)");
+  }
+  header(3, total, "Authenticate to T3");
+  let t3;
+  try {
+    t3 = await openT3Client(env);
+    if (!t3.isReal) throw new Error("Mock client returned \u2014 env misconfigured.");
+    ok2("Handshake + authenticate succeeded \u2728");
+  } catch (e) {
+    fail("Could not connect to T3.", `Error: ${e.message}
+Check T3N_API_KEY + DID match a real T3 account (and BLINDFOLD_T3_ENV matches their environment).`);
+    throw e;
+  }
+  await ensureTenantScaffolding(env);
+  if (!opts.skipPublish && canBuild) {
+    header(4, total, "Publish the wrapper contract + grant ACLs");
+    try {
+      const wasm = readFileSync(WASM_PATH);
+      const r = await t3.registerContract(new Uint8Array(wasm.buffer, wasm.byteOffset, wasm.byteLength));
+      const contractId = Number(r.contractId);
+      ok2(`Published "blindfold-proxy"  \xB7  contract_id=${contractId}`);
+      await grantContractReads(env, contractId);
+      ok2(`Granted read access on z:tid:secrets to contract ${contractId}`);
+    } catch (e) {
+      const msg = e.message;
+      if (/version.*not higher|already.*registered/i.test(msg)) {
+        warn2(`Already published at this version \u2014 skipping. (${msg.slice(0, 100)})`);
+      } else {
+        fail("Publish failed.", `Error: ${msg.slice(0, 300)}`);
+        throw e;
+      }
+    }
+  } else {
+    header(4, total, opts.skipPublish ? "Publish (skipped: --skip-publish)" : "Publish (skipped: no contract built)");
+  }
+  header(5, total, "Seal a secret into the enclave");
+  const toSeed = collectSeedPlan(opts);
+  if (toSeed.length === 0) {
+    info("No --seed flag given.");
+    info(`Later, after dropping an OPENAI_API_KEY into .env:  ${cyan("blindfold register --name openai_api_key --from-env OPENAI_API_KEY")}`);
+  }
+  for (const { name, fromEnv } of toSeed) {
+    try {
+      const value = pluckSecret(fromEnv);
+      await t3.seedSecret(name, value);
+      recordSealed({
+        t: (/* @__PURE__ */ new Date()).toISOString(),
+        name,
+        source: `env:${fromEnv}`,
+        length: value.length,
+        mode: env.mock ? "mock" : "real",
+        tenant_did: env.did,
+        map_name: `z:${env.did.replace(/^did:t3n:/, "")}:secrets`
+      });
+      ok2(`Sealed ${bold(name)} (read from ${fromEnv}, ${value.length} bytes, then dropped). You can DELETE ${fromEnv} from .env now.`);
+    } catch (e) {
+      fail(`Could not seal "${name}".`, `Error: ${e.message}
+Make sure ${fromEnv} is set in .env (you can delete it after sealing).`);
+    }
+  }
+  await t3.close();
+  process.stdout.write(`
+${green(bold("\u2713 All done."))}
+`);
+  if (opts.start) {
+    process.stdout.write(`${dim("Starting the proxy now (Ctrl+C to stop) \u2026")}
+`);
+    const proxy = spawn2(process.execPath, [process.argv[1] ?? "", "proxy"], {
+      cwd: REPO_ROOT2,
+      stdio: "inherit"
+    });
+    proxy.on("exit", (code) => process.exit(code ?? 0));
+    return;
+  }
+  process.stdout.write(`${dim("Next:")}
+`);
+  process.stdout.write(`  ${cyan("npm run blindfold -- proxy")}        ${dim("# leave this running")}
+`);
+  process.stdout.write(`  ${cyan("npm run dashboard")}                 ${dim("# open http://127.0.0.1:8799")}
+`);
+  process.stdout.write(`  ${dim("Then point your agent at:")} ${cyan("OPENAI_BASE_URL=http://127.0.0.1:8787/v1  OPENAI_API_KEY=__BLINDFOLD__")}
+`);
+  process.stdout.write(`${dim("Or re-run with")} ${cyan("--start")} ${dim("to launch the proxy automatically.")}
+`);
+}
+async function ensureEnvOrPrompt(opts) {
+  loadEnvFromFile(ENV_PATH);
+  const haveBoth = !!process.env.T3N_API_KEY && !!process.env.DID;
+  if (haveBoth) return;
+  if (opts.yes) {
+    fail(".env is missing T3N_API_KEY and/or DID.", `Claim them here: ${T3_CLAIM_URL}
+Then put them in .env and re-run.`);
+    throw new Error("env missing");
+  }
+  if (!existsSync(ENV_PATH) && existsSync(ENV_EXAMPLE_PATH)) {
+    const template = readFileSync(ENV_EXAMPLE_PATH, "utf8");
+    writeFileSync(ENV_PATH, template);
+    info("Created .env from .env.example.");
+  }
+  warn2(".env is missing your T3 credentials.");
+  info(`Claim them (free, takes 30 seconds): ${cyan(T3_CLAIM_URL)}`);
+  const proceed = await ask(`  Paste them now? [Y/n] `);
+  if (proceed.toLowerCase().startsWith("n")) {
+    info("OK \u2014 open .env, paste both values, and re-run `npm run setup`.");
+    process.exit(0);
+  }
+  const apiKey = await promptUntilMatches("  T3N_API_KEY  (0x\u2026 32-byte hex): ", /^0x[0-9a-fA-F]{64}$/, "expected 0x followed by 64 hex chars");
+  const did = await promptUntilMatches("  DID          (did:t3n:\u2026):       ", /^did:t3n:[0-9a-fA-F]+$/, "expected did:t3n:<hex>");
+  upsertEnvLines(ENV_PATH, { T3N_API_KEY: apiKey, DID: did });
+  ok2("Wrote .env (T3N_API_KEY + DID).");
+  loadEnvFromFile(ENV_PATH);
+  process.env.T3N_API_KEY = apiKey;
+  process.env.DID = did;
+}
+async function promptUntilMatches(prompt, re, hint) {
+  for (let i = 0; i < 5; i++) {
+    const v = await ask(prompt);
+    if (re.test(v)) return v;
+    warn2(`That doesn't look right \u2014 ${hint}. Try again.`);
+  }
+  fail("Too many invalid attempts.", "Run the wizard again when you have the right values.");
+  process.exit(1);
+}
+function upsertEnvLines(envPath, kv) {
+  let body = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+  for (const [k, v] of Object.entries(kv)) {
+    const re = new RegExp(`^${k}=.*$`, "m");
+    if (re.test(body)) body = body.replace(re, `${k}=${v}`);
+    else body += (body.endsWith("\n") || body === "" ? "" : "\n") + `${k}=${v}
+`;
+  }
+  writeFileSync(envPath, body);
+}
+function collectSeedPlan(opts) {
+  const seeds = opts.seed ?? [];
+  return seeds.map((s) => {
+    const [name, fromEnv] = s.split(":");
+    if (!name || !fromEnv) {
+      warn2(`Ignoring --seed "${s}" (expected KV_KEY:ENV_VAR, e.g. openai_api_key:OPENAI_API_KEY)`);
+      return null;
+    }
+    return { name, fromEnv };
+  }).filter((x) => x !== null);
+}
+async function ensureTenantScaffolding(env) {
+  const sdk = await import("@terminal3/t3n-sdk");
+  sdk.setEnvironment(env.t3Env);
+  const baseUrl = sdk.NODE_URLS[env.t3Env];
+  const addr = sdk.eth_get_address(env.t3nApiKey);
+  const t3n = new sdk.T3nClient({ baseUrl, wasmComponent: await sdk.loadWasmComponent(), handlers: { EthSign: sdk.metamask_sign(addr, void 0, env.t3nApiKey) } });
+  await t3n.handshake();
+  await t3n.authenticate(sdk.createEthAuthInput(addr));
+  const tenant = new sdk.TenantClient({ environment: env.t3Env, baseUrl, tenantDid: env.did, t3n });
+  for (const tail of ["secrets", "authorised-hosts"]) {
+    try {
+      await tenant.maps.create({ tail, visibility: "private", writers: "all" });
+      info(`Created tenant map "${tail}"`);
+    } catch {
+    }
+  }
+}
+async function grantContractReads(env, contractId) {
+  const sdk = await import("@terminal3/t3n-sdk");
+  sdk.setEnvironment(env.t3Env);
+  const baseUrl = sdk.NODE_URLS[env.t3Env];
+  const addr = sdk.eth_get_address(env.t3nApiKey);
+  const t3n = new sdk.T3nClient({ baseUrl, wasmComponent: await sdk.loadWasmComponent(), handlers: { EthSign: sdk.metamask_sign(addr, void 0, env.t3nApiKey) } });
+  await t3n.handshake();
+  await t3n.authenticate(sdk.createEthAuthInput(addr));
+  const tenant = new sdk.TenantClient({ environment: env.t3Env, baseUrl, tenantDid: env.did, t3n });
+  await tenant.maps.update("secrets", { readers: { only: [contractId] } });
+  try {
+    await tenant.maps.update("authorised-hosts", { readers: { only: [contractId] } });
+  } catch {
+  }
+}
+async function isSdkInstalled2() {
+  try {
+    await import("@terminal3/t3n-sdk");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runVerify() {
+  process.stdout.write(`
+${bold("\u{1F6E1}\uFE0F  Blindfold \u2014 verify")}
+`);
+  const env = loadBlindfoldEnv();
+  info(`mode: ${env.mock ? red("MOCK") : green("REAL")}  \xB7  T3 env: ${env.t3Env}`);
+  if (env.mock) {
+    warn2("MOCK mode \u2014 there's nothing to verify on the T3 side. Set T3N_API_KEY + DID.");
+    return;
+  }
+  process.stdout.write(`  ${dim("\xB7")} attempting handshake + authenticate against T3 \u2026
+`);
+  try {
+    const t3 = await openT3Client(env);
+    if (t3.isReal) ok2("REAL T3 round-trip succeeded.");
+    await t3.close();
+  } catch (e) {
+    fail("REAL T3 connection failed.", `Error: ${e.message}`);
+    process.exitCode = 1;
+  }
+  try {
+    const p = path10.join(REPO_ROOT2, ".blindfold", "verify.jsonl");
+    mkdirSync(path10.dirname(p), { recursive: true });
+    const line = JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), mode: env.mock ? "mock" : "real", t3Env: env.t3Env, ok: !process.exitCode });
+    appendFileSync(p, line + "\n");
+  } catch {
+  }
+}
+
+// src/compat.ts
+import { spawn as spawn3 } from "node:child_process";
+import fs13 from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+var HERE4 = path11.dirname(fileURLToPath5(import.meta.url));
+var REPO_ROOT3 = path11.resolve(HERE4, "..", "..", "..");
+var colour2 = process.stdout.isTTY ? (c2, s) => `\x1B[${c2}m${s}\x1B[0m` : (_, s) => s;
+var bold2 = (s) => colour2("1", s);
+var dim2 = (s) => colour2("2", s);
+var green2 = (s) => colour2("32", s);
+var yellow2 = (s) => colour2("33", s);
+var red2 = (s) => colour2("31", s);
+var cyan2 = (s) => colour2("36", s);
+async function detectBinary(name) {
+  return new Promise((resolve) => {
+    const child = spawn3("which", [name], { stdio: ["ignore", "pipe", "ignore"] });
+    const chunks = [];
+    child.stdout.on("data", (c2) => chunks.push(c2));
+    child.on("close", (code) => {
+      const out = Buffer.concat(chunks).toString("utf8").trim();
+      resolve({ detected: code === 0 && !!out, via: "PATH", detail: out || void 0 });
+    });
+    child.on("error", () => resolve({ detected: false, via: "PATH" }));
+  });
+}
+async function detectPackage(pkg) {
+  const candidates = [
+    path11.join(REPO_ROOT3, "node_modules", pkg),
+    path11.join(REPO_ROOT3, "node_modules", pkg, "package.json")
+  ];
+  for (const c2 of candidates) {
+    if (fs13.existsSync(c2)) return { detected: true, via: "node_modules", detail: c2 };
+  }
+  return { detected: false, via: "node_modules" };
+}
+var TOOLS = [
+  {
+    name: "Claude Code (claude)",
+    detect: () => detectBinary("claude"),
+    applies: "depends",
+    recipe: {
+      env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:8787/anthropic", ANTHROPIC_API_KEY: "__BLINDFOLD__" },
+      note: "Only applies if you authenticate Claude Code with an Anthropic API key (enterprise/proxy mode). Default Claude Code uses claude.ai OAuth \u2014 there is no exposed key to protect."
+    },
+    explanation: "Claude Code respects ANTHROPIC_BASE_URL when ANTHROPIC_API_KEY is set; in the default subscription/OAuth flow it does not, and Blindfold has nothing to protect."
+  },
+  {
+    name: "OpenCode (sst.dev/opencode)",
+    detect: () => detectBinary("opencode"),
+    applies: "applies",
+    recipe: {
+      env: { OPENAI_BASE_URL: "http://127.0.0.1:8787/v1", OPENAI_API_KEY: "__BLINDFOLD__" },
+      note: "Configure your provider in ~/.config/opencode/config.json to use the proxy URL."
+    }
+  },
+  {
+    name: "Aider",
+    detect: () => detectBinary("aider"),
+    applies: "applies",
+    recipe: {
+      env: { OPENAI_API_BASE: "http://127.0.0.1:8787/v1", OPENAI_API_KEY: "__BLINDFOLD__" },
+      note: "Aider reads OPENAI_API_BASE (the older name). Same idea."
+    }
+  },
+  {
+    name: "Continue.dev (continue)",
+    detect: () => detectBinary("continue"),
+    applies: "applies",
+    recipe: {
+      note: "Edit ~/.continue/config.json \u2014 set apiBase to http://127.0.0.1:8787/v1 and apiKey to __BLINDFOLD__ on each OpenAI-flavoured model."
+    }
+  },
+  {
+    name: "Cline (VS Code extension)",
+    detect: () => detectBinary("code"),
+    applies: "applies",
+    recipe: {
+      note: "In Cline settings \u2192 API Provider \u2192 set baseURL to http://127.0.0.1:8787/v1 and api key to __BLINDFOLD__. (Detection here just checks for VS Code; Cline itself is a VS Code extension.)"
+    }
+  },
+  {
+    name: "OpenAI Codex CLI (codex)",
+    detect: () => detectBinary("codex"),
+    applies: "applies",
+    recipe: { env: { OPENAI_BASE_URL: "http://127.0.0.1:8787/v1", OPENAI_API_KEY: "__BLINDFOLD__" } }
+  },
+  {
+    name: "Cursor (desktop app)",
+    detect: () => detectBinary("cursor"),
+    applies: "needs-base-url",
+    recipe: {
+      note: "Cursor does not expose a per-request base-URL setting in current builds. If you self-host an Anthropic/OpenAI-compatible gateway, point Cursor at that, then at Blindfold from there."
+    }
+  },
+  {
+    name: "openai (Node SDK)",
+    detect: () => detectPackage("openai"),
+    applies: "applies",
+    recipe: { env: { OPENAI_BASE_URL: "http://127.0.0.1:8787/v1", OPENAI_API_KEY: "__BLINDFOLD__" } }
+  },
+  {
+    name: "@anthropic-ai/sdk (Node SDK)",
+    detect: () => detectPackage("@anthropic-ai/sdk"),
+    applies: "applies",
+    recipe: { env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:8787/anthropic", ANTHROPIC_API_KEY: "__BLINDFOLD__" } }
+  },
+  {
+    name: "@langchain/openai (LangChain JS)",
+    detect: () => detectPackage("@langchain/openai"),
+    applies: "applies",
+    recipe: { note: "Use `new ChatOpenAI({ apiKey: '__BLINDFOLD__', configuration: { baseURL: 'http://127.0.0.1:8787/v1' } })`." }
+  },
+  {
+    name: "ollama (local model runner)",
+    detect: () => detectBinary("ollama"),
+    applies: "oauth-only",
+    recipe: { note: "Ollama runs models locally with no external API key \u2014 there's no secret for Blindfold to protect. Skip." }
+  }
+];
+async function runCompat(opts = {}) {
+  const results = await Promise.all(
+    TOOLS.map(async (t) => ({ tool: t, detection: await t.detect() }))
+  );
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(results.map((r) => ({
+      tool: r.tool.name,
+      detected: r.detection.detected,
+      detected_at: r.detection.detail,
+      applies: r.tool.applies,
+      env: r.tool.recipe.env,
+      note: r.tool.recipe.note,
+      explanation: r.tool.explanation
+    })), null, 2));
+    return;
+  }
+  process.stdout.write(`
+${bold2("\u{1F6E1}\uFE0F  Blindfold \u2014 compatibility scan")}
+${dim2("Probing local box for agent tools and SDKs Blindfold can protect.")}
+
+`);
+  const detected = results.filter((r) => r.detection.detected);
+  const notFound = results.filter((r) => !r.detection.detected);
+  process.stdout.write(`${bold2(`Detected (${detected.length}):`)}
+`);
+  if (detected.length === 0) process.stdout.write(`  ${dim2("(none \u2014 install one of the tools below, or just use the OpenAI/Anthropic SDK in your own code)")}
+`);
+  for (const r of detected) {
+    renderTool(r.tool, r.detection, true);
+  }
+  process.stdout.write(`
+${bold2(`Not found on this machine (${notFound.length}):`)}
+`);
+  for (const r of notFound) {
+    renderTool(r.tool, r.detection, false);
+  }
+  process.stdout.write(`
+${dim2("For a longer-form compatibility writeup see docs/05-compatibility.md.")}
+`);
+}
+function renderTool(tool, detection, detected) {
+  const mark = !detected ? dim2("\xB7") : tool.applies === "applies" ? green2("\u2713") : tool.applies === "depends" ? yellow2("?") : tool.applies === "needs-base-url" ? yellow2("!") : red2("\u2716");
+  const status = !detected ? dim2("(not installed)") : tool.applies === "applies" ? green2("Blindfold protects this") : tool.applies === "depends" ? yellow2("Depends on how you authenticate") : tool.applies === "needs-base-url" ? yellow2("No base-URL hook \u2014 needs upstream support") : red2("Doesn't apply (no user-supplied key)");
+  process.stdout.write(`  ${mark} ${bold2(tool.name)}  ${dim2("\xB7")}  ${status}
+`);
+  if (detected && detection.detail) process.stdout.write(`    ${dim2("at " + detection.detail)}
+`);
+  if (detected && tool.recipe.env) {
+    const envLine = Object.entries(tool.recipe.env).map(([k, v]) => `${k}=${v}`).join("  ");
+    process.stdout.write(`    ${cyan2(envLine)}
+`);
+  }
+  if (detected && tool.recipe.note) process.stdout.write(`    ${dim2(tool.recipe.note)}
+`);
+  if (detected && tool.explanation) process.stdout.write(`    ${dim2(tool.explanation)}
+`);
+}
+
+// bin/cmd-enclave.ts
+init_sealed_ledger();
+async function handleEnclave(cmd, argv, cmdArgs) {
+  switch (cmd) {
+    case "credit":
+    case "balance": {
+      const env = loadBlindfoldEnv();
+      const BASE = 1e6;
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      try {
+        const b = await client.getBalance();
+        const tok = (n) => (n / BASE).toLocaleString(void 0, { maximumFractionDigits: 6 });
+        if (argv.flags.json) {
+          console.log(JSON.stringify(b, null, 2));
+          return;
+        }
+        console.log(head(`\u{1F4B3} Terminal 3 credit`) + c.gray(` \u2014 ${env.did || "(no tenant)"}  (${env.mock ? "MOCK" : env.t3Env})`));
+        console.log(`  available:  ${c.bold(tok(b.available) + " tokens")}  ${c.gray("(" + b.available.toLocaleString() + " base units)")}`);
+        console.log(`  reserved:   ${b.reserved.toLocaleString()} base units`);
+        console.log(`  status:     ${b.creditExhausted ? warn("\u26A0 EXHAUSTED") : ok("\u2705 ok")}`);
+        if (b.creditExhausted) {
+          console.log(`  Top up testnet credits, then re-check with \`blindfold credit\`:`);
+          console.log(`    https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens`);
+          process.exitCode = 1;
+        }
+      } finally {
+        await client.close();
+      }
+      return;
+    }
+    case "update":
+    case "upgrade": {
+      const PKG = "@fiscalmindset/blindfold";
+      const { spawnSync: spawnSync2 } = await import("node:child_process");
+      const run2 = (cmd2, args, cwd) => spawnSync2(cmd2, args, { stdio: "inherit", cwd });
+      let from = argv.flags.from ? String(argv.flags.from) : process.env.BLINDFOLD_SRC || "";
+      if (!from) {
+        for (const cand of [path12.resolve(process.cwd(), "packages", "blindfold"), process.cwd()]) {
+          try {
+            const pkg = JSON.parse(fs14.readFileSync(path12.join(cand, "package.json"), "utf8"));
+            if ((pkg.name === PKG || pkg.name === "blindfold") && pkg.bin?.blindfold) {
+              from = cand;
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      if (!from) {
+        console.log(head("\u21BB Updating global blindfold from npm") + c.gray(` (${PKG}@latest)\u2026`));
+        const r = run2("npm", ["install", "-g", `${PKG}@latest`]);
+        if (r.status !== 0) {
+          console.log("");
+          console.log(bad("npm update failed") + c.gray(" \u2014 not published yet, or offline."));
+          console.log("  Update from your repo checkout instead \u2014 one of:");
+          console.log(c.cyan("    blindfold update --from /path/to/packages/blindfold"));
+          console.log(c.cyan("    cd <repo> && blindfold update"));
+          console.log(c.gray("    (or export BLINDFOLD_SRC=/path/to/packages/blindfold)"));
+          process.exitCode = 1;
+          return;
+        }
+        console.log(ok("\u2713 blindfold updated to the latest published version."));
+        return;
+      }
+      console.log(head(`\u21BB Updating global blindfold`) + c.gray(` from ${from}`));
+      if (run2("npm", ["run", "build"], from).status !== 0) die("build failed");
+      const pack = spawnSync2("npm", ["pack"], { cwd: from, encoding: "utf8" });
+      const tgz = (pack.stdout || "").trim().split("\n").pop() || "";
+      if (!tgz) die("npm pack produced no tarball");
+      const tgzPath = path12.join(from, tgz);
+      const inst = run2("npm", ["install", "-g", tgzPath]);
+      try {
+        fs14.rmSync(tgzPath, { force: true });
+      } catch {
+      }
+      if (inst.status !== 0) die("global install failed");
+      console.log(ok(`\u2713 blindfold updated.`) + c.gray(" Open a NEW shell if the command still looks stale."));
+      return;
+    }
+    case "publish": {
+      const wasmPath = argv.flags.wasm ?? assetPath("contract/target/wasm32-wasip2/release/blindfold_proxy.wasm", "blindfold_proxy.wasm");
+      if (!fs14.existsSync(wasmPath)) {
+        die(`no wasm found at ${wasmPath} \u2014 run scripts/build-contract.sh first`);
+      }
+      const wasm = fs14.readFileSync(wasmPath);
+      const r = await registerContract(new Uint8Array(wasm.buffer, wasm.byteOffset, wasm.byteLength));
+      console.log(`\u2713 Published contract. contract_id=${r.contractId}`);
+      return;
+    }
+    case "init": {
+      const seedFlag = argv.flags.seed;
+      const seedArr = Array.isArray(seedFlag) ? seedFlag : seedFlag ? [String(seedFlag)] : [];
+      await runInit({
+        skipBuild: !!argv.flags["skip-build"],
+        skipPublish: !!argv.flags["skip-publish"],
+        seed: seedArr,
+        yes: !!argv.flags.yes,
+        start: !!argv.flags.start
+      });
+      return;
+    }
+    case "verify": {
+      await runVerify();
+      return;
+    }
+    case "compat": {
+      await runCompat({ json: !!argv.flags.json });
+      return;
+    }
+    case "sealed": {
+      const entries = readSealed();
+      if (entries.length === 0) {
+        console.log(`No sealed-keys ledger yet at ${defaultSealedLogPath()}.`);
+        console.log(`Seal one with:  blindfold register --name <KV_KEY>`);
+        return;
+      }
+      console.log(head("\u{1F510} Sealed keys") + c.gray(`  (source: ${defaultSealedLogPath()})`) + "\n");
+      console.log("  WHEN                  NAME                       BYTES  MODE   WHERE");
+      console.log("  \u2500\u2500\u2500\u2500                  \u2500\u2500\u2500\u2500                       \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500");
+      for (const e of entries) {
+        const when = e.t.replace("T", " ").slice(0, 19);
+        const where = e.map_name.length > 60 ? e.map_name.slice(0, 57) + "\u2026" : e.map_name;
+        console.log(`  ${when}   ${e.name.padEnd(26)}  ${String(e.length).padStart(5)}  ${e.mode.padEnd(5)}  ${where}/${e.name}`);
+      }
+      console.log("\n  (values are NOT stored in this ledger \u2014 only metadata. The canonical copy lives in the enclave.)");
+      return;
+    }
+    case "audit": {
+      console.log("\u{1F50D} Blindfold audit\n");
+      const chain = verifyLedgerChain();
+      console.log("  1. Ledger integrity (tamper-evidence)");
+      if (chain.total === 0) {
+        console.log("     (ledger is empty)");
+      } else if (chain.ok) {
+        const chained = chain.total - chain.legacy;
+        console.log(`     \u2705 hash-chain intact \u2014 ${chained} chained entr${chained === 1 ? "y" : "ies"}${chain.legacy ? `, ${chain.legacy} legacy (pre-chain, unverifiable)` : ""}`);
+      } else {
+        console.log(`     \u2716 TAMPERED \u2014 the chain breaks at entry #${chain.firstBrokenIndex} (a line was edited or removed after it was written)`);
+        process.exitCode = 1;
+      }
+      const env = loadBlindfoldEnv();
+      if (env.mock) {
+        console.log("\n  2. Enclave reconciliation: skipped (MOCK mode)");
+        return;
+      }
+      const realEntries = readSealed().filter((e) => e.mode === "real");
+      const latest = /* @__PURE__ */ new Map();
+      for (const e of realEntries) latest.set(e.name, e);
+      console.log(`
+  2. Enclave reconciliation \u2014 the enclave is the source of truth (${latest.size} secret${latest.size === 1 ? "" : "s"})`);
+      if (latest.size === 0) {
+        console.log("     (nothing sealed)");
+        return;
+      }
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      const client = await openT3Client2(env);
+      let okCount = 0, drift = 0, missing = 0;
+      try {
+        for (const e of latest.values()) {
+          const v = await client.verifySecret(e.name);
+          if (!v.present) {
+            missing++;
+            console.log(`     \u2716 ${e.name.padEnd(22)} MISSING in enclave  (ledger claims ${e.length} B)`);
+          } else if (v.length !== e.length) {
+            drift++;
+            console.log(`     \u26A0 ${e.name.padEnd(22)} length drift: enclave ${v.length} B vs ledger ${e.length} B  fp=${v.fingerprint}`);
+          } else {
+            okCount++;
+            console.log(`     \u2705 ${e.name.padEnd(22)} present (${v.length} B, fp=${v.fingerprint})`);
+          }
+        }
+      } finally {
+        await client.close();
+      }
+      console.log(`
+  Summary: ${okCount} verified \xB7 ${drift} drift \xB7 ${missing} missing \xB7 ledger ${chain.ok ? "intact" : "TAMPERED"}`);
+      if (drift > 0 || missing > 0 || !chain.ok) process.exitCode = 1;
+      return;
+    }
+    case "status": {
+      const env = loadBlindfoldEnv();
+      console.log(head("\u{1F6E1}\uFE0F  Blindfold status") + "\n");
+      console.log(`  mode:    ${env.mock ? "MOCK (BLINDFOLD_MOCK=1)" : "REAL"}   \xB7   T3 env: ${env.t3Env}`);
+      if (env.t3BaseUrl) console.log(`  node:    ${env.t3BaseUrl}  (override)`);
+      if (!env.mock) {
+        try {
+          const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+          const client = await openT3Client2(env);
+          const info2 = await client.me();
+          console.log(`  tenant:  ${ok("\u2705 " + info2.tenant)}  (status=${info2.status ?? "?"})`);
+        } catch (e) {
+          console.log(`  tenant:  ${bad("\u2716 " + e.message.slice(0, 90))}`);
+          console.log(`           \u2192 run \`blindfold doctor\` for a full diagnosis.`);
+          process.exitCode = 1;
+        }
+      }
+      const entries = readSealed();
+      const latest = /* @__PURE__ */ new Map();
+      for (const e of entries) latest.set(e.name, e);
+      console.log(`
+  Sealed secrets (${latest.size}):`);
+      if (latest.size === 0) {
+        console.log(`    (none yet)   seal one:  blindfold register --name <X> --from-env <X>`);
+      } else {
+        for (const e of latest.values()) {
+          console.log(`    \u2022 ${e.name.padEnd(22)} ${String(e.length).padStart(4)} B   ${e.mode}`);
+        }
+      }
+      console.log(`
+  Next:  blindfold use --name <secret> -- <command>     (use it, no code)`);
+      return;
+    }
+    case "doctor": {
+      const env = loadBlindfoldEnv();
+      console.log(head("\u{1FA7A} Blindfold doctor"));
+      console.log(`  mode:               ${env.mock ? "MOCK (BLINDFOLD_MOCK=1)" : "REAL (T3)"}`);
+      console.log(`  T3N_API_KEY set:    ${env.t3nApiKey ? "yes" : "NO \u2716"}`);
+      console.log(`  DID set:            ${env.did ? "yes" : "NO \u2716"}`);
+      console.log(`  T3 environment:     ${env.t3Env}`);
+      console.log(`  node URL:           ${env.t3BaseUrl || `(SDK default for ${env.t3Env})`}`);
+      console.log(`  default proxy port: ${env.port}`);
+      if (!env.mock && (!env.t3nApiKey || !env.did)) {
+        console.log("");
+        console.log(`  \u26A0  REAL mode is selected but credentials are missing.`);
+        console.log(`     Claim them: https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens`);
+        console.log(`     Or run \`npm run setup\` and the wizard will walk you through it.`);
+        process.exitCode = 1;
+        return;
+      }
+      if (env.mock) return;
+      console.log("");
+      console.log("  Live check (handshake + authenticate + me) \u2026");
+      const { openT3Client: openT3Client2 } = await Promise.resolve().then(() => (init_t3_client(), t3_client_exports));
+      let client;
+      try {
+        client = await openT3Client2(env);
+        console.log(`  auth:               ${ok("\u2705 handshake + authenticate OK")}`);
+      } catch (e) {
+        console.log(`  auth:               ${bad("\u2716 " + e.message)}`);
+        console.log(`     \u2192 Check T3N_API_KEY is a 0x 32-byte hex private key and DID looks like did:t3n:<hex>.`);
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        const info2 = await client.me();
+        console.log(`  tenant:             \u2705 ${info2.tenant}  (status=${info2.status ?? "?"})`);
+        const didHex = env.did.replace(/^did:t3n:/, "").toLowerCase();
+        const meHex = info2.tenant.replace(/^did:t3n:/, "").toLowerCase();
+        if (meHex && didHex && meHex !== didHex) {
+          console.log("");
+          console.log(`  \u26A0  DID MISMATCH: your .env DID (${env.did}) is not this key's tenant.`);
+          console.log(`     The tenant DID is server-assigned, not derived from the key address.`);
+          console.log(`     Fix: set  DID=${info2.tenant}  in .env  (writes/seals target this tenant).`);
+          process.exitCode = 1;
+        } else if (info2.status && info2.status !== "active") {
+          console.log(`  \u26A0  tenant status is "${info2.status}" (not active) \u2014 seals/writes may fail.`);
+          process.exitCode = 1;
+        } else {
+          console.log(`  ${ok("\u2705 Ready to seal & use secrets on this tenant.")}`);
+        }
+      } catch (e) {
+        const msg = e.message;
+        console.log(`  tenant:             \u2716 ${msg}`);
+        console.log("");
+        if (/InsufficientCredit|forbidden|403/i.test(msg)) {
+          console.log(`  \u26A0  This key has a tenant but NO CREDITS. Seals/writes need credit.`);
+          console.log(`     Fix: request testnet credits / claim tokens, then re-run \`blindfold doctor\`:`);
+          console.log(`       https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens`);
+        } else if (/500|internal_error/i.test(msg)) {
+          console.log(`  \u26A0  This key AUTHENTICATES but its tenant is unusable: a read-only me()`);
+          console.log(`     returns a server error. Every seal/write with it will also 500.`);
+          console.log(`     Fix one of:`);
+          console.log(`       \u2022 switch .env to a key whose tenant is active (check with this doctor),`);
+          console.log(`       \u2022 point at a healthy node:  T3_BASE_URL=<leader-node-url>  (if the node itself is unhealthy), or`);
+          console.log(`       \u2022 ask Terminal 3 to provision/claim a tenant for this key.`);
+        } else {
+          console.log(`  \u26A0  Could not read the tenant behind this key \u2014 seals/writes will likely fail.`);
+          console.log(`     Verify the key is provisioned, or switch to a key that passes this doctor.`);
+        }
+        process.exitCode = 1;
+      }
+      return;
+    }
+    case "skill": {
+      const sub = argv._[1] ?? "help";
+      const skillSource = assetPath(".claude/skills/blindfold/SKILL.md", "SKILL.md");
+      if (!fs14.existsSync(skillSource)) {
+        die(`skill source not found at ${skillSource} \u2014 reinstall Blindfold or run from the repo.`);
+      }
+      const skillContent = fs14.readFileSync(skillSource, "utf-8");
+      if (sub === "install") {
+        const targets = [];
+        const global = !!argv.flags.global;
+        const cursor = !!argv.flags.cursor;
+        const opencode = !!argv.flags.opencode;
+        const cline = !!argv.flags.cline;
+        const all = !!argv.flags.all;
+        if (global || all) targets.push({ label: "global (all Claude Code sessions)", dir: path12.join(process.env.HOME ?? "~", ".claude", "skills", "blindfold") });
+        if (cursor || all) targets.push({ label: "Cursor", dir: path12.resolve(".cursor", "rules") });
+        if (opencode || all) targets.push({ label: "OpenCode", dir: path12.resolve(".opencode", "skills", "blindfold") });
+        if (cline || all) targets.push({ label: "Cline", dir: path12.resolve(".cline", "rules") });
+        if (!global && !cursor && !opencode && !cline && !all) {
+          targets.push({ label: "this project (Claude Code)", dir: path12.resolve(".claude", "skills", "blindfold") });
+        }
+        for (const t of targets) {
+          fs14.mkdirSync(t.dir, { recursive: true });
+          const dest = path12.join(t.dir, t.dir.includes("rules") ? "blindfold.md" : "SKILL.md");
+          fs14.writeFileSync(dest, skillContent);
+          console.log(`  \u2713 ${t.label} \u2192 ${dest}`);
+        }
+        console.log(`
+\u2713 Blindfold skill installed (${targets.length} target${targets.length > 1 ? "s" : ""})`);
+        console.log(`  Your coding agent will now handle secrets safely \u2014 try asking it to "seal my API key".`);
+      } else if (sub === "uninstall") {
+        const locations = [
+          path12.resolve(".claude", "skills", "blindfold", "SKILL.md"),
+          path12.join(process.env.HOME ?? "~", ".claude", "skills", "blindfold", "SKILL.md"),
+          path12.resolve(".cursor", "rules", "blindfold.md"),
+          path12.resolve(".opencode", "skills", "blindfold", "SKILL.md"),
+          path12.resolve(".cline", "rules", "blindfold.md")
+        ];
+        let removed = 0;
+        for (const loc of locations) {
+          if (fs14.existsSync(loc)) {
+            fs14.unlinkSync(loc);
+            console.log(`  \u2713 removed ${loc}`);
+            removed++;
+          }
+        }
+        console.log(removed ? `
+\u2713 Removed ${removed} skill file(s).` : "  No skill files found to remove.");
+      } else {
+        console.log(`blindfold skill \u2014 install the Blindfold agent skill for your coding agent.
+
+  blindfold skill install                   Install for this project (Claude Code auto-discovers it)
+  blindfold skill install --global          Install globally (~/.claude/skills/, all sessions)
+  blindfold skill install --cursor          Install for Cursor (.cursor/rules/)
+  blindfold skill install --opencode        Install for OpenCode (.opencode/skills/)
+  blindfold skill install --cline           Install for Cline (.cline/rules/)
+  blindfold skill install --all             Install for all of the above at once
+
+  blindfold skill uninstall                 Remove all installed skill files
+
+What it does: teaches your coding agent to seal keys safely \u2014 no pasting secrets
+into chat, release-broker pattern in generated code, fingerprint-only verification.`);
+      }
+      return;
+    }
+  }
+}
+
+// bin/blindfold.ts
+var ROUTES = {
+  signup: handleAuth,
+  login: handleAuth,
+  logout: handleAuth,
+  whoami: handleAuth,
+  register: handleSecrets,
+  use: handleSecrets,
+  export: handleSecrets,
+  rotate: handleLifecycle,
+  rollback: handleLifecycle,
+  versions: handleLifecycle,
+  migrate: handleLifecycle,
+  grant: handleTenant,
+  share: handleTenant,
+  revoke: handleTenant,
+  proxy: handleServe,
+  attest: handleServe,
+  dashboard: handleServe,
+  stats: handleServe,
+  "stats:clear": handleServe,
+  publish: handleEnclave,
+  init: handleEnclave,
+  verify: handleEnclave,
+  compat: handleEnclave,
+  sealed: handleEnclave,
+  audit: handleEnclave,
+  status: handleEnclave,
+  doctor: handleEnclave,
+  skill: handleEnclave,
+  credit: handleEnclave,
+  balance: handleEnclave,
+  update: handleEnclave,
+  upgrade: handleEnclave
+};
+async function main() {
+  const raw = process.argv.slice(2);
+  const ddIdx = raw.indexOf("--");
+  const cmdArgs = ddIdx >= 0 ? raw.slice(ddIdx + 1) : [];
+  const argv = parseArgv(ddIdx >= 0 ? raw.slice(0, ddIdx) : raw);
+  const cmd = argv._[0] ?? "help";
+  const handler = ROUTES[cmd];
+  if (handler) await handler(cmd, argv, cmdArgs);
+  else printHelp();
+}
+function printHelp() {
+  console.log(`${head("\u{1F6E1}\uFE0F  Blindfold")} ${c.gray("\u2014 protect your AI agent's API keys with Terminal 3 enclaves.")}
+
+${c.bold("Commands:")}
+  signup   [--email <you@x.com>]                    Self-serve: create a Terminal 3 testnet tenant from scratch. Generates a key locally, verifies your email by code, and mints welcome credits \u2014 no manual provisioning. Then run doctor + register.
+  init     [--seed KV:ENV]... [--start]             One-command zero-knowledge setup. Walks through .env, build, auth, publish, seed; can auto-launch the proxy.
+  verify                                            Handshake + auth against T3 (smoke test).
+  compat   [--json]                                 Scan this machine for AI agent tools/SDKs and print the exact env-var swap for each.
+  register --name <KV_KEY> [--from-env <ENV_VAR>]  Seal a secret into the enclave (one-time). With --from-env: reads process.env. Without: prompts the terminal with no echo (preferred \u2014 never touches disk/history). Also accepts piped stdin.
+  use      --name <secret> [--as <ENV>] -- <cmd>   USE a sealed secret: release it and run <cmd> with it injected as $ENV for that command only \u2014 never back in your env. --as is auto-detected for known tools (gh\u2192GH_TOKEN, psql\u2192PGPASSWORD, \u2026). Or  --url <https>  for a quick auth check.
+  rotate   --name <secret> [--from-env <ENV_VAR>]  Replace a sealed secret's value (snapshots the old value for rollback; shows before/after fingerprints, never the value).
+  export   --name <secret> [--as <ENV_VAR>]         CI-only: release a sealed secret into $GITHUB_ENV for later steps (masked in logs). Used by the Blindfold GitHub Action.
+  rollback --name <secret> [--to <fp|iso-ts>]      Restore a previous value snapshotted by rotate (most recent by default).
+  versions [--name <secret>]                        List the snapshots available to roll back to (metadata only).
+  migrate  [--dry-run] [--keep]                     Seal EVERY secret in your .env in one shot, then remove the plaintext lines (backup kept). --dry-run previews; --keep comments lines instead of deleting. Skips T3 creds + config.
+  status                                             One-glance overview: mode, tenant health, and the list of sealed secrets.
+  sealed                                             List sealed keys \u2014 metadata only (name, byte-length, when, where). Never the value.
+  audit                                              Verify the ledger's tamper-evident hash-chain AND reconcile it against the enclave (the source of truth) \u2014 flags drift/missing/tampering.
+  proxy    [--port 8787] [--auth] [--socket [path]] Run the local OpenAI-shaped proxy. --auth mints a per-session token; --socket binds a 0600 unix socket (only your OS user can connect).
+  attest   [--expect-rtmr3 <b64>] [--pin] [--json]  Verify the enclave's TDX attestation (chains to Intel's root CA). --pin records the RTMR3 so seal/proxy auto-verify it first.
+  publish  [--wasm path/to/blindfold_proxy.wasm]   Publish the Rust\u2192WASM contract (one-time).
+  grant    --host <host>[,<host2>...]              Authorize the contract to call these hosts (required before the proxy / in-enclave path can reach them). E.g. --host api.openai.com
+  share    --to <agent-did> --host <host>[,...]    Let a teammate's agent USE your sealed keys for those hosts via the enclave \u2014 they never receive the plaintext (forward only, least privilege).
+  revoke   --to <agent-did>                         Remove a teammate's access. Immediate and complete \u2014 nobody holds a raw key copy.
+
+  skill    install [--global|--cursor|--opencode|--cline|--all]   Install the Blindfold agent skill so your coding agent handles secrets safely. Default: this project.
+  skill    uninstall                                Remove all installed skill files.
+
+  dashboard [--port 8799]                           Live HTML dashboard of proxy usage.
+  stats                                             CLI summary of proxy usage.
+  stats:clear                                       Wipe the usage log.
+  doctor                                            Show current mode + config.
+  credit   [--json]                                 Show the tenant's Terminal 3 token/credit balance (no credit cost).
+  update   [--from <path>]                           Update the global blindfold (from npm, or a local repo with --from).
+
+The friendliest path is just:  blindfold init
+
+Quick start:
+  1) ./scripts/build-contract.sh             # build the Rust contract (REAL mode only)
+  2) blindfold publish                        # register the contract on T3
+  3) blindfold register --name openai_api_key --from-env OPENAI_API_KEY
+  4) blindfold proxy                          # then point your agent at it
+`);
+}
+main().catch((e) => {
+  console.error("\u2716", e.message);
+  process.exit(1);
+});