@helm-protocol/ttt-mcp 0.3.4 → 0.4.1

package/README.md

@@ -55,12 +55,12 @@ Claude workflow → [context compressed] → agents call pot_query(eventId)
 ### Claude Code
 
 ```bash
-claude mcp add ttt -- npx -y @helm-protocol/ttt-mcp@0.3.3
+claude mcp add ttt -- npx -y @helm-protocol/ttt-mcp@0.4.0
 ```
 
 With an API key (raises the free limit to your plan's monthly quota):
 ```bash
-claude mcp add ttt -e TTT_API_KEY=your-key -- npx -y @helm-protocol/ttt-mcp@0.3.3
+claude mcp add ttt -e TTT_API_KEY=your-key -- npx -y @helm-protocol/ttt-mcp@0.4.0
 ```
 
 ### Claude Desktop
@@ -72,7 +72,7 @@ Add to `claude_desktop_config.json`:
   "mcpServers": {
     "ttt": {
       "command": "npx",
-      "args": ["-y", "@helm-protocol/ttt-mcp@0.3.3"],
+      "args": ["-y", "@helm-protocol/ttt-mcp@0.4.0"],
       "env": { "TTT_API_KEY": "your-key" }
     }
   }
@@ -81,7 +81,7 @@ Add to `claude_desktop_config.json`:
 
 ### Cursor
 
-[![Add to Cursor](https://img.shields.io/badge/Add%20to%20Cursor-1a1a1a?style=flat&logo=cursor&logoColor=white)](https://cursor.com/install-mcp?name=ttt&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBoZWxtLXByb3RvY29sL3R0dC1tY3BAMC4zLjMiXX0=)
+[![Add to Cursor](https://img.shields.io/badge/Add%20to%20Cursor-1a1a1a?style=flat&logo=cursor&logoColor=white)](https://cursor.com/install-mcp?name=ttt&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBoZWxtLXByb3RvY29sL3R0dC1tY3BAMC40LjAiXX0=)
 
 One-click install, or add the same `mcpServers` block above to `.cursor/mcp.json`.
 
@@ -127,12 +127,14 @@ pot_graph(eventId: "step-2", depth: 5)
 
 ---
 
-## 8 Tools
+## 10 Tools
 
 | Tool | Purpose |
 |------|---------|
 | `pot_generate` | Stamp a workflow step with a cryptographic timestamp |
 | `pot_verify` | Verify a PoT signature |
+| `pot_generate_v2` | Generate the draft-11 180-octet PoT Record v2 core (canonical wire profile) |
+| `pot_verify_v2` | Verify a v2 record; optional TLS 1.3 exporter binding proof (fails closed without TLS) |
 | `pot_verify_v08` | Verify a draft-08 §3 Payload Digest record |
 | `pot_query` | O(1) exact lookup by eventId — core amnesia recovery |
 | `pot_graph` | Traverse causal DAG (backward + forward chain) |
@@ -168,6 +170,12 @@ Verify a draft-08 §3 record produced by `pot_generate`'s `potRecordV08` field:
 | ctxId | string | No | Must match what `pot_generate` used, or verification fails |
 | issuerPubKey | string | No | Hex-encoded 32-byte raw Ed25519 public key. Defaults to this server's own key. |
 | content | string | No | Payload to check against the record's Payload Digest field |
+| clientId | string | Required when `TTTPS_REQUIRE_REPLAY_LEDGER=1` | Stable caller identity for the replay key |
+| sessionId | string | Required when `TTTPS_REQUIRE_REPLAY_LEDGER=1` | Active transport/session identifier for the replay key |
+
+When `TTTPS_REQUIRE_V08_FRESHNESS=1`, `TTTPS_V08_MAX_SKEW_NS` MUST be set to a non-negative integer. The verifier rejects records outside `maxSkewNs + errorBoundUs`. When `TTTPS_REQUIRE_REPLAY_LEDGER=1`, a successful verification atomically claims `clientId/sessionId/nonce` in Redis with a 90-day TTL; Redis failure or a second claim is rejected. These flags are fail-closed controls.
+
+The current MCP canonical wire profile is draft-11 PoT Record v2 (180 octets). `pot_generate_v2` and `pot_verify_v2` implement the fixed core record, including SHA-256 integrity over octets 0-79 and Ed25519 issuer authentication over octets 0-115. Draft-08 remains available through `pot_verify_v08` for legacy interoperability only. TLS binding proof is a separate 64/32-octet value; `TTTPS_V2_REQUIRE_BINDING=1` fails closed unless the server is running over direct TLS 1.3; stdio and plain HTTP have no TLS exporter. Configure `MCP_TLS_CERT_FILE` and `MCP_TLS_KEY_FILE` for the HTTPS mode. Replay claims use `(ctx_id, nonce)` with `TTTPS_REPLAY_TTL_SECONDS` (default 86400).
 
 ### pot_query
 

package/dist/index.js

@@ -4,6 +4,10 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 var import_http = require("http");
+var import_https = require("https");
+var import_fs = require("fs");
+var import_tls_exporter = require("./tls_exporter");
+var import_transport_context = require("./transport_context");
 var import_zod = require("zod");
 var import_tools = require("./tools");
 var import_auth = require("./auth");
@@ -101,8 +105,9 @@ function toolSuccess(result) {
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 }
 function buildMcpServer() {
-  const s = new import_mcp.McpServer({ name: "ttt-mcp", version: "0.3.2" });
-  s.tool(
+  const s = new import_mcp.McpServer({ name: "ttt-mcp", version: "0.4.1" });
+  const registerTool = s.tool.bind(s);
+  registerTool(
     "pot_generate",
     "Generate a cryptographic Proof of Time timestamp (draft-helmprotocol-tttps, https://datatracker.ietf.org/doc/draft-helmprotocol-tttps/). For Claude Code workflows: use eventId + prevEventId to build a causal chain. For DeFi: use txHash + chainId + poolAddress. For a spec-conformant draft-08 \xA73 record binding this attestation to a specific piece of content, also supply contentDigest. One of eventId, txHash, or contentDigest is required.",
     {
@@ -126,7 +131,7 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_verify",
     "Verify a Proof of Time using its hash and integrity shards. Returns validity, mode (turbo/full), and timestamp.",
     {
@@ -145,16 +150,58 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
+    "pot_generate_v2",
+    "Generate the draft-11 180-octet Proof-of-Time Record v2 core. TLS binding proof is computed only after a live TLS session exists.",
+    {
+      tsTaiUs: import_zod.z.string().describe("TAI timestamp in microseconds as a decimal string"),
+      dispersionUs: import_zod.z.number().int().nonnegative().describe("Uncertainty bound in microseconds"),
+      ctxId: import_zod.z.string().length(32).describe("16-octet context identifier encoded as hex"),
+      holderAuthData: import_zod.z.string().length(64).describe("32-octet holder public key or PSK digest encoded as hex"),
+      holderAuthType: import_zod.z.number().int().optional().describe("0x01 Ed25519 holder key (default) or 0x02 shared secret")
+    },
+    { title: "Generate draft-11 180-octet PoT v2", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    async (args) => {
+      try {
+        return toolSuccess(await (0, import_tools.potGenerateV2)(args));
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  registerTool(
+    "pot_verify_v2",
+    "Verify the draft-11 180-octet PoT Record v2 core. Binding-required mode fails closed in stdio because no TLS exporter session exists.",
+    {
+      potRecordV2: import_zod.z.string().length(360).describe("Hex-encoded 180-octet draft-11 v2 record"),
+      issuerPubKey: import_zod.z.string().length(64).optional().describe("Raw 32-octet issuer Ed25519 public key in hex"),
+      nowTaiUs: import_zod.z.string().optional().describe("Current TAI timestamp in microseconds"),
+      maxSkewUs: import_zod.z.string().optional().describe("Configured freshness allowance in microseconds"),
+      clientId: import_zod.z.string().optional(),
+      sessionId: import_zod.z.string().optional(),
+      bindingProof: import_zod.z.string().regex(/^(?:[0-9a-fA-F]{128}|[0-9a-fA-F]{64})$/).optional().describe("64-octet Ed25519 or 32-octet HMAC TLS binding proof")
+    },
+    { title: "Verify draft-11 180-octet PoT v2", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    async (args) => {
+      try {
+        return toolSuccess(await (0, import_tools.potVerifyV2)(args));
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  registerTool(
     "pot_verify_v08",
-    "Verify a draft-helmprotocol-tttps-08 \xA73 Proof-of-Time record (as produced by pot_generate's potRecordV08 field): recomputes the Commitment and checks the Ed25519 signature, and \u2014 if content is supplied \u2014 recomputes SHA-256(content) and checks it against the record's Payload Digest field.",
+    "Verify and, when configured, admit a draft-helmprotocol-tttps-08 \xA73 Proof-of-Time record: recomputes the Commitment and Ed25519 signature, applies configured freshness, and atomically claims client/session/nonce in Redis before admission.",
     {
       potRecordV08: import_zod.z.string().describe("Hex-encoded 184 or 216-octet record from pot_generate's potRecordV08 field"),
       ctxId: import_zod.z.string().max(255).optional().describe("Context identifier the record was generated under. Must match what pot_generate used, or verification fails."),
       issuerPubKey: import_zod.z.string().optional().describe("Hex-encoded 32-byte raw Ed25519 issuer public key. Defaults to this server's own key."),
-      content: import_zod.z.string().optional().describe("The payload (utf8) to check against the record's Payload Digest field, if available")
+      content: import_zod.z.string().optional().describe("The payload (utf8) to check against the record's Payload Digest field, if available"),
+      clientId: import_zod.z.string().optional().describe("Stable caller identity for the durable replay ledger when TTTPS_REQUIRE_REPLAY_LEDGER=1"),
+      sessionId: import_zod.z.string().optional().describe("Active transport/session identifier for the durable replay ledger when TTTPS_REQUIRE_REPLAY_LEDGER=1")
     },
-    { title: "Verify draft-08 Proof-of-Time Record", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    { title: "Verify draft-08 Proof-of-Time Record", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     async (args) => {
       try {
         const result = await (0, import_tools.potVerifyV08)(args);
@@ -164,9 +211,9 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_query",
-    "Query Proof of Time records. Use eventId for exact O(1) lookup of a specific workflow step (collision probability 2^-256). Use startTime/endTime for time-range queries.",
+    "Query Proof of Time records. Use eventId for exact lookup of a specific workflow step. Use startTime/endTime for time-range queries.",
     {
       eventId: import_zod.z.string().optional().describe("Exact eventId lookup \u2014 call this at workflow start to restore action history after context compression"),
       startTime: import_zod.z.number().optional().describe("Start time (unix ms). Default: 24h ago"),
@@ -183,7 +230,7 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_graph",
     "Traverse the causal chain of workflow steps. Given an eventId, returns the full backward chain (ancestors via prevEventId) and forward chain (steps that follow). Use after context compression to reconstruct the complete workflow timeline.",
     {
@@ -200,7 +247,7 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_stats",
     "Get PoT statistics: total swaps, turbo/full counts, and turbo ratio for a given period.",
     { period: import_zod.z.enum(["day", "week", "month"]).describe("Time period for statistics") },
@@ -214,7 +261,7 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_health",
     "Check PoT system health: time source status, subgraph sync, server uptime, and current mode.",
     {},
@@ -228,7 +275,7 @@ function buildMcpServer() {
       }
     }
   );
-  s.tool(
+  registerTool(
     "pot_checkpoint",
     "Create a compressed rollup checkpoint of workflow history. Call this periodically to prevent token explosion when recovering from context compression. Returns checkpointId, compressed event history, chainIntact status, and nextCheckpointHint (recommended events before next checkpoint).",
     {
@@ -254,10 +301,10 @@ async function main() {
   await restoreDAGFromRedis();
   const port = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
   if (port) {
-    const httpServer = (0, import_http.createServer)(async (req, res) => {
+    const requestHandler = async (req, res) => {
       if (req.method === "GET" && (req.url === "/health" || req.url === "/ping")) {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.3.2" }));
+        res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.4.1" }));
         return;
       }
       if (req.method === "POST") {
@@ -309,9 +356,18 @@ async function main() {
           res.end(JSON.stringify({ error: "Internal server error" }));
         }
       }
-    });
+    };
+    const certFile = process.env.MCP_TLS_CERT_FILE?.trim();
+    const keyFile = process.env.MCP_TLS_KEY_FILE?.trim();
+    if (certFile && !keyFile || !certFile && keyFile) {
+      throw new Error("MCP_TLS_CERT_FILE and MCP_TLS_KEY_FILE must be configured together");
+    }
+    const httpServer = certFile && keyFile ? (0, import_https.createServer)({ minVersion: "TLSv1.3", cert: (0, import_fs.readFileSync)(certFile), key: (0, import_fs.readFileSync)(keyFile) }, (req, res) => {
+      const exporter = (0, import_tls_exporter.extractTls13Exporter)(req);
+      return (0, import_transport_context.withTransportBinding)({ exporter, remoteAddress: req.socket.remoteAddress ?? "", clientId: String(req.headers["x-ttt-client-id"] ?? ""), sessionId: String(req.headers["x-ttt-session-id"] ?? "") }, () => requestHandler(req, res));
+    }) : (0, import_http.createServer)((req, res) => (0, import_transport_context.withTransportBinding)({ remoteAddress: req.socket.remoteAddress ?? "", clientId: String(req.headers["x-ttt-client-id"] ?? ""), sessionId: String(req.headers["x-ttt-session-id"] ?? "") }, () => requestHandler(req, res)));
     httpServer.listen(port, () => {
-      console.error(`[ttt-mcp] OpenTTT MCP Server (HTTP) on port ${port}`);
+      console.error(`[ttt-mcp] OpenTTT MCP Server (${certFile ? "HTTPS/TLS1.3" : "HTTP"}) on port ${port}`);
     });
   } else {
     const stdioServer = buildMcpServer();

package/dist/pot_record_v08.js

@@ -161,7 +161,7 @@ function decodePotRecordV08(record) {
     p
   };
 }
-function verifyPotRecordV08(record, ctxId, issuerPublicKeyRaw, content) {
+function verifyPotRecordV08(record, ctxId, issuerPublicKeyRaw, content, freshness) {
   let decoded;
   try {
     decoded = decodePotRecordV08(record);
@@ -177,6 +177,15 @@ function verifyPotRecordV08(record, ctxId, issuerPublicKeyRaw, content) {
   if (decoded.errorBoundUs === RESERVED_ERROR_BOUND) {
     return { verdict: "rejected", reason: "Error Bound carries the reserved value 0xFFFFFF" };
   }
+  if (freshness !== void 0) {
+    if (freshness.maxSkewNs < 0n) {
+      return { verdict: "rejected", reason: "invalid freshness policy" };
+    }
+    const delta = decoded.timestampNs >= freshness.nowNs ? decoded.timestampNs - freshness.nowNs : freshness.nowNs - decoded.timestampNs;
+    if (delta > freshness.maxSkewNs + BigInt(decoded.errorBoundUs) * 1000n) {
+      return { verdict: "rejected", reason: "freshness window exceeded" };
+    }
+  }
   const expectedCommitment = computeCommitmentSha256(decoded.fieldsPre, ctxId);
   if (!expectedCommitment.equals(decoded.commitment)) {
     return { verdict: "rejected", reason: "commitment mismatch" };

package/dist/pot_record_v2.js

@@ -0,0 +1,174 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pot_record_v2_exports = {};
+__export(pot_record_v2_exports, {
+  HOLDER_AUTH_ED25519: () => HOLDER_AUTH_ED25519,
+  HOLDER_AUTH_SHARED_SECRET: () => HOLDER_AUTH_SHARED_SECRET,
+  POT_V2_INTEGRITY_SHA256: () => POT_V2_INTEGRITY_SHA256,
+  POT_V2_SIZE: () => POT_V2_SIZE,
+  POT_V2_VERSION: () => POT_V2_VERSION,
+  computeV2BindingInput: () => computeV2BindingInput,
+  computeV2ExporterContext: () => computeV2ExporterContext,
+  decodePotRecordV2: () => decodePotRecordV2,
+  encodePotRecordV2: () => encodePotRecordV2,
+  verifyPotRecordV2: () => verifyPotRecordV2,
+  verifyV2BindingProof: () => verifyV2BindingProof
+});
+module.exports = __toCommonJS(pot_record_v2_exports);
+var import_crypto = require("crypto");
+const POT_V2_SIZE = 180;
+const POT_V2_VERSION = 2;
+const POT_V2_INTEGRITY_SHA256 = 1;
+const HOLDER_AUTH_ED25519 = 1;
+const HOLDER_AUTH_SHARED_SECRET = 2;
+const OFF = {
+  VERSION: 0,
+  HOLDER_AUTH_TYPE: 1,
+  ALG_ID: 2,
+  TS: 4,
+  DISPERSION: 12,
+  CTX_ID: 16,
+  NONCE: 32,
+  HOLDER_AUTH_DATA: 48,
+  INTEGRITY_TAG: 80,
+  ISSUER_KEY_ID: 112,
+  ISSUER_SIG: 116
+};
+const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function requireLength(name, value, length) {
+  if (value.length !== length) throw new Error(`${name} must be ${length} bytes`);
+}
+function issuerPublicKeyFromRaw(raw) {
+  requireLength("issuer public key", raw, 32);
+  return (0, import_crypto.createPublicKey)({ key: Buffer.concat([ED25519_SPKI_PREFIX, raw]), format: "der", type: "spki" });
+}
+function integrityTag(signedPrefix) {
+  return (0, import_crypto.createHash)("sha256").update(signedPrefix).digest();
+}
+function encodePotRecordV2(fields, issuerPrivateKey) {
+  if (fields.holderAuthType !== HOLDER_AUTH_ED25519 && fields.holderAuthType !== HOLDER_AUTH_SHARED_SECRET) {
+    throw new Error("unsupported holder_auth_type");
+  }
+  if (fields.algId !== POT_V2_INTEGRITY_SHA256) throw new Error("unsupported alg_id");
+  if (fields.tsTaiUs < 0n || fields.tsTaiUs > 0xffffffffffffffffn) throw new Error("ts out of range");
+  if (fields.dispersionUs < 0 || fields.dispersionUs > 4294967295) throw new Error("dispersion out of range");
+  if (fields.issuerKeyId < 0 || fields.issuerKeyId > 4294967295) throw new Error("issuer_key_id out of range");
+  requireLength("ctx_id", fields.ctxId, 16);
+  requireLength("nonce", fields.nonce, 16);
+  requireLength("holder_auth_data", fields.holderAuthData, 32);
+  const prefix = Buffer.alloc(116);
+  prefix.writeUInt8(POT_V2_VERSION, OFF.VERSION);
+  prefix.writeUInt8(fields.holderAuthType, OFF.HOLDER_AUTH_TYPE);
+  prefix.writeUInt16BE(fields.algId, OFF.ALG_ID);
+  prefix.writeBigUInt64BE(fields.tsTaiUs, OFF.TS);
+  prefix.writeUInt32BE(fields.dispersionUs, OFF.DISPERSION);
+  fields.ctxId.copy(prefix, OFF.CTX_ID);
+  fields.nonce.copy(prefix, OFF.NONCE);
+  fields.holderAuthData.copy(prefix, OFF.HOLDER_AUTH_DATA);
+  integrityTag(prefix.subarray(0, 80)).copy(prefix, OFF.INTEGRITY_TAG);
+  prefix.writeUInt32BE(fields.issuerKeyId, OFF.ISSUER_KEY_ID);
+  const signature = (0, import_crypto.sign)(null, prefix, issuerPrivateKey);
+  return Buffer.concat([prefix, signature]);
+}
+function decodePotRecordV2(record) {
+  if (record.length !== POT_V2_SIZE) throw new Error(`expected 180 octets, got ${record.length}`);
+  const signedPrefix = record.subarray(0, 116);
+  return {
+    holderAuthType: record.readUInt8(OFF.HOLDER_AUTH_TYPE),
+    algId: record.readUInt16BE(OFF.ALG_ID),
+    tsTaiUs: record.readBigUInt64BE(OFF.TS),
+    dispersionUs: record.readUInt32BE(OFF.DISPERSION),
+    ctxId: Buffer.from(record.subarray(OFF.CTX_ID, OFF.CTX_ID + 16)),
+    nonce: Buffer.from(record.subarray(OFF.NONCE, OFF.NONCE + 16)),
+    holderAuthData: Buffer.from(record.subarray(OFF.HOLDER_AUTH_DATA, OFF.HOLDER_AUTH_DATA + 32)),
+    issuerKeyId: record.readUInt32BE(OFF.ISSUER_KEY_ID),
+    integrityTag: Buffer.from(record.subarray(OFF.INTEGRITY_TAG, OFF.INTEGRITY_TAG + 32)),
+    issuerSig: Buffer.from(record.subarray(OFF.ISSUER_SIG, POT_V2_SIZE)),
+    signedPrefix: Buffer.from(signedPrefix)
+  };
+}
+function computeV2ExporterContext(record) {
+  const decoded = decodePotRecordV2(record);
+  const bindingPrefix = Buffer.from("tttps-binding-v2\0", "ascii");
+  const recordHash = (0, import_crypto.createHash)("sha256").update(record).digest();
+  return (0, import_crypto.createHash)("sha256").update(Buffer.concat([bindingPrefix, recordHash, decoded.ctxId, decoded.nonce])).digest();
+}
+function computeV2BindingInput(record, exporterOutput) {
+  decodePotRecordV2(record);
+  if (exporterOutput.length !== 32) throw new Error("TLS exporter output must be 32 octets");
+  return Buffer.concat([Buffer.from("tttps-binding-v2\0", "ascii"), exporterOutput, record.subarray(16, 32), record.subarray(32, 48)]);
+}
+function verifyV2BindingProof(record, bindingProof, exporterOutput, sharedSecret) {
+  const decoded = decodePotRecordV2(record);
+  const bindingInput = computeV2BindingInput(record, exporterOutput);
+  if (decoded.holderAuthType === HOLDER_AUTH_ED25519) {
+    if (bindingProof.length !== 64) return { verdict: "rejected", reason: "Ed25519 binding proof must be 64 octets" };
+    const holderPublicKey = issuerPublicKeyFromRaw(decoded.holderAuthData);
+    return (0, import_crypto.verify)(null, bindingInput, holderPublicKey, bindingProof) ? { verdict: "intact" } : { verdict: "rejected", reason: "TLS exporter holder proof mismatch" };
+  }
+  if (decoded.holderAuthType === HOLDER_AUTH_SHARED_SECRET) {
+    if (!sharedSecret) return { verdict: "rejected", reason: "shared-secret holder binding is not configured" };
+    if (bindingProof.length !== 32) return { verdict: "rejected", reason: "HMAC binding proof must be 32 octets" };
+    const expectedDigest = (0, import_crypto.createHash)("sha256").update(sharedSecret).digest();
+    if (!(0, import_crypto.timingSafeEqual)(expectedDigest, decoded.holderAuthData)) return { verdict: "rejected", reason: "shared-secret digest mismatch" };
+    const expected = (0, import_crypto.createHmac)("sha256", sharedSecret).update(bindingInput).digest();
+    return (0, import_crypto.timingSafeEqual)(expected, bindingProof) ? { verdict: "intact" } : { verdict: "rejected", reason: "TLS exporter HMAC proof mismatch" };
+  }
+  return { verdict: "rejected", reason: "unsupported holder authentication type" };
+}
+function verifyPotRecordV2(record, issuerPublicKeyRaw, freshness) {
+  let decoded;
+  try {
+    decoded = decodePotRecordV2(record);
+  } catch (e) {
+    return { verdict: "rejected", reason: e instanceof Error ? e.message : String(e) };
+  }
+  if (record[OFF.VERSION] !== POT_V2_VERSION) return { verdict: "rejected", reason: "unknown version" };
+  if (decoded.holderAuthType !== HOLDER_AUTH_ED25519 && decoded.holderAuthType !== HOLDER_AUTH_SHARED_SECRET) {
+    return { verdict: "rejected", reason: "unsupported holder_auth_type" };
+  }
+  if (decoded.algId !== POT_V2_INTEGRITY_SHA256) return { verdict: "rejected", reason: "unsupported alg_id" };
+  if (!integrityTag(decoded.signedPrefix.subarray(0, 80)).equals(decoded.integrityTag)) return { verdict: "rejected", reason: "integrity mismatch" };
+  if (freshness) {
+    const delta = decoded.tsTaiUs >= freshness.nowTaiUs ? decoded.tsTaiUs - freshness.nowTaiUs : freshness.nowTaiUs - decoded.tsTaiUs;
+    if (delta > freshness.maxSkewUs + BigInt(decoded.dispersionUs)) return { verdict: "rejected", reason: "freshness window exceeded" };
+  }
+  try {
+    if (!(0, import_crypto.verify)(null, decoded.signedPrefix, issuerPublicKeyFromRaw(issuerPublicKeyRaw), decoded.issuerSig)) {
+      return { verdict: "rejected", reason: "issuer signature invalid" };
+    }
+  } catch (e) {
+    return { verdict: "rejected", reason: e instanceof Error ? e.message : String(e) };
+  }
+  return { verdict: "intact", nonce: decoded.nonce };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOLDER_AUTH_ED25519,
+  HOLDER_AUTH_SHARED_SECRET,
+  POT_V2_INTEGRITY_SHA256,
+  POT_V2_SIZE,
+  POT_V2_VERSION,
+  computeV2BindingInput,
+  computeV2ExporterContext,
+  decodePotRecordV2,
+  encodePotRecordV2,
+  verifyPotRecordV2,
+  verifyV2BindingProof
+});

package/dist/tls_exporter.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tls_exporter_exports = {};
+__export(tls_exporter_exports, {
+  TTTPS_V2_EXPORTER_LABEL: () => TTTPS_V2_EXPORTER_LABEL,
+  TTTPS_V2_EXPORTER_LENGTH: () => TTTPS_V2_EXPORTER_LENGTH,
+  exporterForTlsSocket: () => exporterForTlsSocket,
+  extractTls13Exporter: () => extractTls13Exporter
+});
+module.exports = __toCommonJS(tls_exporter_exports);
+const TTTPS_V2_EXPORTER_LABEL = "EXPORTER-TTTPS-v2-Binding";
+const TTTPS_V2_EXPORTER_LENGTH = 32;
+function exporterForTlsSocket(socket) {
+  if (!socket.encrypted || typeof socket.exportKeyingMaterial !== "function") return void 0;
+  if (typeof socket.getProtocol === "function" && socket.getProtocol() !== "TLSv1.3") return void 0;
+  return (contextValue) => socket.exportKeyingMaterial(TTTPS_V2_EXPORTER_LENGTH, TTTPS_V2_EXPORTER_LABEL, contextValue);
+}
+function extractTls13Exporter(req) {
+  return exporterForTlsSocket(req.socket);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TTTPS_V2_EXPORTER_LABEL,
+  TTTPS_V2_EXPORTER_LENGTH,
+  exporterForTlsSocket,
+  extractTls13Exporter
+});

package/dist/tools.js

@@ -30,12 +30,14 @@ var tools_exports = {};
 __export(tools_exports, {
   potCheckpoint: () => potCheckpoint,
   potGenerate: () => potGenerate,
+  potGenerateV2: () => potGenerateV2,
   potGraph: () => potGraph,
   potHealth: () => potHealth,
   potQuery: () => potQuery,
   potStats: () => potStats,
   potVerify: () => potVerify,
   potVerifyV08: () => potVerifyV08,
+  potVerifyV2: () => potVerifyV2,
   redis: () => redis,
   restoreDagEntry: () => restoreDagEntry,
   tttsFreshnessSeal: () => tttsFreshnessSeal,
@@ -46,6 +48,8 @@ var import_openttt = require("openttt");
 var import_telemetry = require("./telemetry");
 var import_server = require("./server");
 var import_crypto = require("crypto");
+var import_pot_record_v2 = require("./pot_record_v2");
+var import_transport_context = require("./transport_context");
 var import_pot_record_v08 = require("./pot_record_v08");
 var import_ioredis = __toESM(require("ioredis"));
 const GrgPipeline = (
@@ -71,6 +75,41 @@ const redis = new import_ioredis.default(process.env.REDIS_URL ?? "redis://127.0
 });
 redis.on("error", () => {
 });
+const REPLAY_TTL_SECONDS = Number.parseInt(process.env.TTTPS_REPLAY_TTL_SECONDS ?? "86400", 10);
+function requiredFlag(name) {
+  return process.env[name]?.trim() === "1";
+}
+function configuredFreshnessPolicy() {
+  const raw = process.env.TTTPS_V08_MAX_SKEW_NS?.trim();
+  if (!raw) return void 0;
+  try {
+    const maxSkewNs = BigInt(raw);
+    if (maxSkewNs < 0n) return void 0;
+    return { nowNs: BigInt(Date.now()) * 1000000n, maxSkewNs };
+  } catch {
+    return void 0;
+  }
+}
+async function claimV2Replay(ctxIdHex, nonceHex) {
+  if (!ctxIdHex || !nonceHex) return "unavailable";
+  const key = `tttps:v2:replay:${ctxIdHex}:${nonceHex}`;
+  try {
+    const result = await redis.set(key, "1", "EX", REPLAY_TTL_SECONDS, "NX");
+    return result === "OK" ? "claimed" : "replay";
+  } catch {
+    return "unavailable";
+  }
+}
+async function claimV08Replay(clientId, sessionId, nonceHex) {
+  if (!clientId || !sessionId || !nonceHex) return "unavailable";
+  const key = `tttps:v08:replay:${clientId}:${sessionId}:${nonceHex}`;
+  try {
+    const result = await redis.set(key, "1", "EX", REPLAY_TTL_SECONDS, "NX");
+    return result === "OK" ? "claimed" : "replay";
+  } catch {
+    return "unavailable";
+  }
+}
 const timeSynth = new import_openttt.TimeSynthesis();
 const adaptiveSwitch = new import_openttt.AdaptiveSwitch();
 const potSigner = new import_openttt.PotSigner();
@@ -374,17 +413,210 @@ async function potVerify(args) {
     verifiedAt: Date.now()
   });
 }
+async function potGenerateV2(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_generate_v2");
+  const ctxId = Buffer.from(args.ctxId, "hex");
+  const holderAuthData = Buffer.from(args.holderAuthData, "hex");
+  if (ctxId.length !== 16) throw new Error("ctxId must be exactly 16 bytes of hex");
+  if (holderAuthData.length !== 32) throw new Error("holderAuthData must be exactly 32 bytes of hex");
+  const tsTaiUs = BigInt(args.tsTaiUs);
+  const nonce = (0, import_crypto.randomBytes)(16);
+  const issuerKeyId = (0, import_crypto.createHash)("sha256").update(potSignerPublicKeyRawV08).digest().readUInt32BE(0);
+  const record = (0, import_pot_record_v2.encodePotRecordV2)({
+    holderAuthType: args.holderAuthType ?? 1,
+    algId: 1,
+    tsTaiUs,
+    dispersionUs: args.dispersionUs,
+    ctxId,
+    nonce,
+    holderAuthData,
+    issuerKeyId
+  }, potSignerPrivateKeyV08);
+  return serialize({
+    wireProfile: "draft-helmprotocol-tttps-11-v2",
+    potRecordV2: record.toString("hex"),
+    issuerPubKey: potSignerPublicKeyRawV08.toString("hex"),
+    issuerKeyId,
+    nonce: nonce.toString("hex"),
+    bindingProofRequired: process.env.TTTPS_V2_REQUIRE_BINDING === "1"
+  });
+}
+function trustedKeyList(envName) {
+  return (process.env[envName] ?? "").split(",").map((s) => s.trim()).filter((s) => /^[0-9a-fA-F]{64}$/.test(s)).map((h) => Buffer.from(h, "hex"));
+}
+let roughtimeAdmitCache = null;
+async function roughtimeQuorumOk() {
+  const url = process.env.TTTPS_ADMISSION_STATUS_URL ?? "https://api.kenosian.com/pot/status";
+  const ttlMs = Number.parseInt(process.env.TTTPS_ADMISSION_TTL_MS ?? "5000", 10);
+  if (roughtimeAdmitCache && Date.now() - roughtimeAdmitCache.at < ttlMs) return roughtimeAdmitCache.ok;
+  try {
+    const timeoutMs = Number.parseInt(process.env.TTTPS_ADMISSION_TIMEOUT_MS ?? "1500", 10);
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    const j = await res.json();
+    const ok = j?.roughtime_ok === true;
+    roughtimeAdmitCache = { ok, at: Date.now() };
+    return ok;
+  } catch {
+    roughtimeAdmitCache = { ok: false, at: Date.now() };
+    return false;
+  }
+}
+async function potVerifyV2Core(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_verify_v2");
+  const bindingRequired = process.env.TTTPS_V2_REQUIRE_BINDING === "1";
+  if (bindingRequired && !args.bindingProof) {
+    return serialize({ verdict: "rejected", reason: "TLS exporter binding proof is required" });
+  }
+  const record = Buffer.from(args.potRecordV2, "hex");
+  if (process.env.TTTPS_REQUIRE_ROUGHTIME_QUORUM === "1") {
+    if (!await roughtimeQuorumOk()) {
+      return serialize({ verdict: "rejected", reason: "roughtime quorum unavailable" });
+    }
+  }
+  const freshness = process.env.TTTPS_ENFORCE_FRESHNESS === "1" ? { nowTaiUs: BigInt(Date.now()) * 1000n, maxSkewUs: BigInt(process.env.TTTPS_MAX_SKEW_US ?? "60000000") } : args.nowTaiUs !== void 0 && args.maxSkewUs !== void 0 ? { nowTaiUs: BigInt(args.nowTaiUs), maxSkewUs: BigInt(args.maxSkewUs) } : void 0;
+  const trustedIssuers = trustedKeyList("TTTPS_TRUSTED_ISSUERS");
+  const pinSelfIssuer = process.env.TTTPS_PIN_SELF_ISSUER === "1";
+  const candidates = trustedIssuers.length > 0 ? trustedIssuers : pinSelfIssuer ? [potSignerPublicKeyRawV08] : [args.issuerPubKey ? Buffer.from(args.issuerPubKey, "hex") : potSignerPublicKeyRawV08];
+  let result = (0, import_pot_record_v2.verifyPotRecordV2)(record, candidates[0], freshness);
+  for (let i = 1; i < candidates.length && result.verdict === "rejected" && result.reason === "issuer signature invalid"; i++) {
+    result = (0, import_pot_record_v2.verifyPotRecordV2)(record, candidates[i], freshness);
+  }
+  if (result.verdict === "rejected") {
+    if (trustedIssuers.length > 0 && result.reason === "issuer signature invalid") {
+      return serialize({ verdict: "rejected", reason: "issuer not trusted" });
+    }
+    return serialize(result);
+  }
+  const trustedHolders = trustedKeyList("TTTPS_TRUSTED_HOLDERS");
+  if (trustedHolders.length > 0) {
+    const holder = record.subarray(48, 80);
+    if (!trustedHolders.some((h) => h.equals(holder))) {
+      return serialize({ verdict: "rejected", reason: "holder not authorized" });
+    }
+  }
+  if (args.bindingProof) {
+    const exporter = (0, import_transport_context.currentTransportBinding)()?.exporter;
+    if (!exporter) return serialize({ verdict: "rejected", reason: "live TLS exporter unavailable" });
+    let exporterOutput;
+    try {
+      exporterOutput = exporter((0, import_pot_record_v2.computeV2ExporterContext)(record));
+    } catch {
+      return serialize({ verdict: "rejected", reason: "TLS exporter derivation failed" });
+    }
+    const binding = (0, import_pot_record_v2.verifyV2BindingProof)(record, Buffer.from(args.bindingProof, "hex"), exporterOutput);
+    if (binding.verdict === "rejected") return serialize(binding);
+  }
+  if (process.env.TTTPS_REQUIRE_REPLAY_LEDGER === "1") {
+    const ctxId = record.subarray(16, 32).toString("hex");
+    const replay = await claimV2Replay(ctxId, result.nonce.toString("hex"));
+    if (replay !== "claimed") return serialize({ verdict: "rejected", reason: replay === "replay" ? "replay detected" : "replay ledger unavailable" });
+  }
+  return serialize({ verdict: "intact", wireProfile: "draft-helmprotocol-tttps-11-v2", nonce: result.nonce.toString("hex") });
+}
+const V2_AUDIT_STREAM = process.env.TTTPS_AUDIT_STREAM ?? "tttps:audit:v2";
+const V2_AUDIT_MAXLEN = Number.parseInt(process.env.TTTPS_AUDIT_MAXLEN ?? "100000", 10);
+const TTTPS_FORMAL_RECEIPT = {
+  spec: "draft-helmprotocol-tttps-11",
+  // Honest status. There is a TLA+ model (TLC model-checked) and a Lean 4 module whose
+  // theorems the kernel accepts (sorry 0, axiom propext), and this runtime. They are
+  // RELATED artifacts, not a machine-checked end-to-end 1:1 equivalence. Treat this as
+  // provenance the auditor can chase, not proof of the byte parser or the cryptography.
+  binding_status: "provenance-only; TLA+<->Lean<->runtime 1:1 equivalence is NOT machine-checked end-to-end (HOLD)",
+  lean: {
+    module: "KLean.TTTPS.Core",
+    theorems: [
+      "invalid_ingress_no_mutation",
+      "parse_is_deterministic",
+      "parsed_record_has_fixed_size",
+      "valid_ingress_commit_delta",
+      "zero_state_preservation"
+    ],
+    axioms: ["propext"],
+    content_hash: "sha256:6116b82318d540a1e4e5b694e31978739851f658356330349b9d4289aeb5bae8",
+    abstraction: "models admission at frame-size (=180) granularity; does NOT model field offsets, Ed25519, SHA-256, or the TLS exporter"
+  },
+  tla: { spec: "TTTPS_Ingress_Gate.tla", method: "TLC bounded model check (not an unbounded theorem)" },
+  anchor: {
+    receipt_id: "33108706ed730e5296ae1b06",
+    time_source: "roughtime_chain",
+    verify_url: "https://kpp.kenosian.com/v1/verify?receipt_id=33108706ed730e5296ae1b06"
+  },
+  revision: { package_commit: "677a3b9", note: "live gate runs this revision with admission flags ON; published npm 0.4.0 bytes carry the v2 core only" },
+  scope: "Kernel-checks the 180-octet parse + admission state boundary (invalid ingress => zero state mutation). Does NOT prove Ed25519/SHA-256/TLS-exporter cryptographic security, nor a byte-exact parser equivalence."
+};
+async function potVerifyV2(args) {
+  const startedNs = process.hrtime.bigint();
+  let result;
+  try {
+    result = await potVerifyV2Core(args);
+  } catch (e) {
+    result = { verdict: "rejected", reason: `verifier exception: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  const serverLatencyUs = Number((process.hrtime.bigint() - startedNs) / 1000n);
+  const binding = (0, import_transport_context.currentTransportBinding)();
+  const recordHex = typeof args.potRecordV2 === "string" ? args.potRecordV2 : "";
+  const record = Buffer.from(recordHex, "hex");
+  const fields = {
+    ts_ms: String(Date.now()),
+    verdict: String(result.verdict ?? "unknown"),
+    reason: String(result.reason ?? ""),
+    case: String(args.clientId ?? binding?.clientId ?? ""),
+    session: String(args.sessionId ?? binding?.sessionId ?? ""),
+    remote: String(binding?.remoteAddress ?? ""),
+    transport: binding?.exporter ? "tls13" : "none",
+    binding_proof: args.bindingProof ? "present" : "absent",
+    record_len: String(record.length),
+    record_sha16: record.length ? (0, import_crypto.createHash)("sha256").update(record).digest("hex").slice(0, 16) : "",
+    ctx_id: record.length >= 48 ? record.subarray(16, 32).toString("hex") : "",
+    nonce: record.length >= 48 ? record.subarray(32, 48).toString("hex") : "",
+    latency_us: String(serverLatencyUs)
+  };
+  const flat = [];
+  for (const [k, v] of Object.entries(fields)) flat.push(k, v);
+  redis.call("XADD", V2_AUDIT_STREAM, "MAXLEN", "~", String(V2_AUDIT_MAXLEN), "*", ...flat).catch(() => void 0);
+  const emitFormal = process.env.TTTPS_EMIT_FORMAL_RECEIPT !== "0";
+  return serialize({ ...result, serverLatencyUs, ...emitFormal ? { formal: TTTPS_FORMAL_RECEIPT } : {} });
+}
 async function potVerifyV08(args) {
   (0, import_telemetry.telemetryIncrement)("pot_verify_v08");
   const record = Buffer.from(args.potRecordV08, "hex");
   const ctxId = args.ctxId ?? DEFAULT_CTX_ID_V08;
   const issuerPubKey = args.issuerPubKey !== void 0 ? Buffer.from(args.issuerPubKey, "hex") : potSignerPublicKeyRawV08;
   const content = args.content !== void 0 ? Buffer.from(args.content, "utf8") : void 0;
-  const result = (0, import_pot_record_v08.verifyPotRecordV08)(record, ctxId, issuerPubKey, content);
+  const requireFreshness = requiredFlag("TTTPS_REQUIRE_V08_FRESHNESS");
+  const freshness = configuredFreshnessPolicy();
+  if (requireFreshness && freshness === void 0) {
+    return serialize({ verdict: "rejected", reason: "freshness policy is not configured", ctxId, verifiedAt: Date.now() });
+  }
+  const result = (0, import_pot_record_v08.verifyPotRecordV08)(record, ctxId, issuerPubKey, content, freshness);
+  if (result.verdict === "rejected") {
+    return serialize({
+      verdict: result.verdict,
+      reason: result.reason ?? null,
+      payloadDigestMatchesContent: result.payloadDigestMatchesContent ?? null,
+      ctxId,
+      verifiedAt: Date.now()
+    });
+  }
+  let replayClaim = "not_required";
+  if (requiredFlag("TTTPS_REQUIRE_REPLAY_LEDGER")) {
+    const decoded = (0, import_pot_record_v08.decodePotRecordV08)(record);
+    replayClaim = await claimV08Replay(args.clientId ?? "", args.sessionId ?? "", decoded.nonce.toString("hex"));
+    if (replayClaim !== "claimed") {
+      return serialize({
+        verdict: "rejected",
+        reason: replayClaim === "replay" ? "replay detected" : "replay ledger unavailable",
+        replayClaim,
+        ctxId,
+        verifiedAt: Date.now()
+      });
+    }
+  }
   return serialize({
     verdict: result.verdict,
     reason: result.reason ?? null,
     payloadDigestMatchesContent: result.payloadDigestMatchesContent ?? null,
+    replayClaim,
     ctxId,
     verifiedAt: Date.now()
   });
@@ -645,12 +877,14 @@ async function potCheckpoint(args) {
 0 && (module.exports = {
   potCheckpoint,
   potGenerate,
+  potGenerateV2,
   potGraph,
   potHealth,
   potQuery,
   potStats,
   potVerify,
   potVerifyV08,
+  potVerifyV2,
   redis,
   restoreDagEntry,
   tttsFreshnessSeal,

package/dist/transport_context.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transport_context_exports = {};
+__export(transport_context_exports, {
+  currentTransportBinding: () => currentTransportBinding,
+  withTransportBinding: () => withTransportBinding
+});
+module.exports = __toCommonJS(transport_context_exports);
+var import_node_async_hooks = require("node:async_hooks");
+const storage = new import_node_async_hooks.AsyncLocalStorage();
+function withTransportBinding(context, fn) {
+  return storage.run(context, fn);
+}
+function currentTransportBinding() {
+  return storage.getStore();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  currentTransportBinding,
+  withTransportBinding
+});

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@helm-protocol/ttt-mcp",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Proof-of-Time attestation — Ed25519-signed timestamps with multi-source corroboration and explicit error bounds. IETF draft-helmprotocol-tttps",
   "main": "dist/index.js",
   "bin": {
-    "ttt-mcp": "./dist/index.js"
+    "ttt-mcp": "dist/index.js"
   },
   "files": [
     "dist",
     "README.md"
   ],
   "scripts": {
-    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts server.ts pot_record_v08.ts --platform=node --target=node18 --format=cjs --outdir=dist",
+    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts server.ts pot_record_v08.ts pot_record_v2.ts tls_exporter.ts transport_context.ts --platform=node --target=node18 --format=cjs --outdir=dist",
     "start": "node dist/index.js",
     "dev": "npx ts-node index.ts",
     "test": "jest --forceExit",
@@ -50,7 +50,7 @@
   "license": "BSL-1.1",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Helm-Protocol/openttt-mcp"
+    "url": "git+https://github.com/Helm-Protocol/openttt-mcp.git"
   },
   "homepage": "https://github.com/Helm-Protocol/openttt-mcp#readme",
   "engines": {
@@ -70,5 +70,8 @@
     "ts-jest": "^29.4.11",
     "typescript": "^5.3.3"
   },
-  "mcpName": "io.github.Helm-Protocol/openttt-pot"
+  "mcpName": "io.github.Helm-Protocol/openttt-pot",
+  "publishConfig": {
+    "access": "public"
+  }
 }