@helm-protocol/ttt-mcp 0.2.2 → 0.3.0

package/README.md

@@ -4,291 +4,298 @@
 
 **MCP Server for OpenTTT — Proof of Time tools for AI agents**
 
-> AI Agent A and Agent B both trigger a payment at the same time.
-> Who was first?
->
-> OpenTTT answers this with cryptographic Proof of Time — synthesized from
-> multiple independent time sources, verified through GRG integrity shards,
-> and signed with Ed25519 for non-repudiation.
+---
 
-## Quick Start
+## The Problem: Workflow Amnesia
 
-```bash
-npm install @helm-protocol/ttt-mcp
+Large Claude Code workflows — 20-agent Dynamic Workflows, multi-day multi-session projects, 100K+ token contexts — all face the same failure mode: **context compression erases action history.**
+
+Agent B has no memory of what Agent A decided. Agent A resumes after compression with no record of its own prior steps. Duplicate work. Lost decisions. State corruption.
+
+**ttt-mcp is the external nervous system that survives context compression.**
+
+Every workflow step is anchored to a cryptographic timestamp on an **external server** — physically separate from Claude's context window. When compression happens, agents query their exact action history through the MCP tools and resume with full causal context.
+
+```
+Claude workflow → [context compressed] → agents call pot_query(eventId)
+                                         → external server returns full timeline
+                                         → workflow resumes, zero lost state
 ```
 
+---
+
+## Mathematical Guarantee
+
+| Layer | Mechanism | Guarantee |
+|-------|-----------|-----------|
+| **Identity** | SHA-3 eventId (256-bit) | Collision probability 2⁻²⁵⁶ ≈ 0 — practically 100% exact step recall |
+| **Ordering** | TTTPS causal timestamps | Total order on events — tamper-proof sequence proof |
+| **Causal chain** | prevEventId DAG | O(depth) traversal — depth ~100 for 1B-token workflows |
+| **Fingerprint** | Multi-layer cryptographic pipeline | Formally bounded tamper-evident step identity |
+| **Non-repudiation** | Ed25519 signature | Cryptographic proof of who acted when |
+
+---
+
+## Quick Start
+
+```bash
+# Claude Desktop
 ```json
-// claude_desktop_config.json
 {
   "mcpServers": {
     "ttt": {
       "command": "npx",
-      "args": ["@helm-protocol/ttt-mcp"]
+      "args": ["-y", "@helm-protocol/ttt-mcp"]
     }
   }
 }
 ```
 
-That's it. Your AI agent now has access to 5 Proof of Time tools.
+Add `TTT_API_KEY` for unlimited calls (free tier: 100 calls/day per IP).
+
+---
 
 ## Tools
 
 | Tool | Description |
 |------|-------------|
-| `pot_generate` | Generate a Proof of Time for a transaction |
-| `pot_verify` | Verify a Proof of Time using its hash and GRG shards |
-| `pot_query` | Query PoT history from local log and on-chain subgraph |
+| `pot_generate` | Stamp a workflow step with eventId + prevEventId (builds causal chain) |
+| `pot_verify` | Verify a Proof of Time using its hash and integrity shards |
+| `pot_query` | O(1) exact lookup by eventId — call this after context compression |
+| `pot_graph` | Traverse full causal DAG — backward + forward chain from any step |
 | `pot_stats` | Get turbo/full mode statistics for a time period |
-| `pot_health` | Check system health: time sources, subgraph sync, uptime |
+| `pot_health` | Check system health: time sources, uptime, current mode |
+| `pot_checkpoint` | Create a compressed rollup checkpoint of workflow history |
+
+---
 
 ## Tool Parameters
 
 ### pot_generate
 
-Generate a Proof of Time for a transaction. Returns potHash, timestamp, stratum, and GRG integrity shards.
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| txHash | string | Yes | Transaction hash (hex with 0x prefix) |
-| chainId | number | Yes | Chain ID (e.g. 8453 for Base, 84532 for Base Sepolia) |
-| poolAddress | string | Yes | DEX pool contract address |
-
-### pot_verify
-
-Verify a Proof of Time using its hash and GRG shards. Returns validity, mode (turbo/full), and timestamp.
+Stamp a workflow step with a cryptographic timestamp. For Claude Code: use `eventId` + `prevEventId`. For DeFi: use `txHash` + `chainId` + `poolAddress`. One of `eventId` or `txHash` is required.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| potHash | string | Yes | PoT hash to verify (hex with 0x prefix) |
-| grgShards | string[] | Yes | Array of hex-encoded GRG integrity shards |
-| chainId | number | Yes | EVM chain ID (e.g. 84532 for Base Sepolia) |
-| poolAddress | string | Yes | Uniswap V4 pool address (0x-prefixed) |
+| eventId | string | Either/or | Workflow step identifier. E.g. `"refactor_auth_step1"` |
+| prevEventId | string | No | Previous step's eventId — links steps into a causal chain |
+| txHash | string | Either/or | Transaction hash (DeFi, hex with 0x prefix) |
+| chainId | number | No | EVM chain ID (DeFi) |
+| poolAddress | string | No | DEX pool contract address (DeFi) |
 
 ### pot_query
 
-Query Proof of Time history from local log and on-chain subgraph.
+Query Proof of Time records. Use `eventId` for O(1) exact lookup after context compression.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
+| eventId | string | No | Exact step lookup — collision probability 2⁻²⁵⁶ |
 | startTime | number | No | Start time (unix ms). Default: 24h ago |
 | endTime | number | No | End time (unix ms). Default: now |
 | limit | number | No | Max entries to return. Default: 100, max: 1000 |
 
-### pot_stats
+### pot_graph
 
-Get PoT statistics: total swaps, turbo/full counts, and turbo ratio for a given period.
+Traverse the causal chain from any step. Returns backward chain (ancestors) and forward chain (descendants).
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| period | `"day"` \| `"week"` \| `"month"` | Yes | Time period for statistics |
-
-### pot_health
+| eventId | string | Yes | Step to traverse from |
+| depth | number | No | Max backward depth. Default: 10, max: 100 |
 
-Check PoT system health: time source status, subgraph sync, server uptime, and current mode.
+### pot_verify
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| *(none)* | — | — | This tool takes no parameters |
-
-## Example: Generate and Verify a PoT
-
-```typescript
-// In your AI agent's tool call:
-const pot = await pot_generate({
-  txHash: "0xabc123...",
-  chainId: 84532,
-  poolAddress: "0xdef456..."
-});
-
-// pot.potHash — unique Proof of Time hash
-// pot.grgShards — GRG integrity shards for verification
-// pot.timestamp — synthesized nanosecond timestamp
-// pot.mode — "turbo" (honest) or "full" (requires full verification)
-
-const verification = await pot_verify({
-  potHash: pot.potHash,
-  grgShards: pot.grgShards
-});
-// verification.valid — true if integrity shards reconstruct correctly
-```
+| potHash | string | Yes | PoT hash to verify (hex with 0x prefix) |
+| grgShards | string[] | Yes | Array of hex-encoded cryptographic integrity shards |
+| chainId | number | Yes | EVM chain ID |
+| poolAddress | string | Yes | Uniswap V4 pool address |
 
-## How It Works
+### pot_stats
 
-1. **Time Synthesis** — Queries multiple independent time sources (NIST, Google, Cloudflare) via HTTPS/NTP and synthesizes a median timestamp with uncertainty bounds
-2. **GRG Pipeline** — Encodes transaction data through a multi-layer integrity pipeline, producing verifiable shards
-3. **Ed25519 Signing** — Signs the PoT hash for non-repudiation
-4. **Adaptive Mode** — Honest builders get `turbo` mode (fast, profitable); tampered sequences get `full` mode (slow, costly) — natural economic selection
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| period | `"day"` \| `"week"` \| `"month"` | Yes | Time period for statistics |
 
-## Claude Desktop Configuration
+### pot_health
 
-Add to your `claude_desktop_config.json`:
+No parameters.
 
-```json
-{
-  "mcpServers": {
-    "ttt": {
-      "command": "npx",
-      "args": ["@helm-protocol/ttt-mcp"]
-    }
-  }
-}
-```
+### pot_checkpoint
 
-Config file locations:
-- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
-- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+Creates a compressed rollup checkpoint of workflow history.
 
-## Requirements
+**Use when:** Approaching context limit, before long tasks, or every ~100 events.
 
-- Node.js >= 18
-- Network access for time synthesis (HTTPS to time.nist.gov, time.google.com, time.cloudflare.com)
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| fromEventId | string | No | Start of range — first eventId in the causal chain to include |
+| toEventId | string | No | End of range — last eventId in the causal chain to include |
+| startTime | number | No | Unix ms. Default: 1 hour ago |
+| endTime | number | No | Unix ms. Default: now |
+| maxTokens | number | No | Approximate max tokens for rollup output. Default: 2000 |
+
+**Returns:**
+- `checkpointId` — unique checkpoint identifier
+- `rollupSummary` — compressed event history (depth-adaptive: full/compact/minimal/rollup)
+- `chainIntact` — whether the causal chain is unbroken
+- `nextCheckpointHint` — recommended events before next checkpoint
+
+**Depth-adaptive compression:**
+
+| Depth | Format | ~Tokens |
+|-------|--------|---------|
+| 1–5 | Full entry | ~200/event |
+| 6–20 | Compact (id+hash+ts) | ~80/event |
+| 21–50 | Minimal (id+ts) | ~30/event |
+| 51+ | Rollup string | ~10/event |
 
 ---
 
 ## Use Cases
 
-### 1. MEV Bot — Transaction Ordering Proof
+### 1. Claude Code Workflow — Amnesia Prevention
 
-**Problem**: You got front-run. You know it happened. You can't prove it — mempool timestamps are per-node, unsigned, and non-authoritative. No evidence, no recourse.
+**Problem**: A 20-agent Dynamic Workflow refactors a 500K-line codebase over hours. After each context compression, agents have no memory of what they already processed. Duplicate work. State corruption.
 
-**Solution**: Call `pot_generate` before submitting every transaction. The PoT receipt is cryptographically signed by three independent time sources (NIST, Google, Cloudflare), hashed on-chain to Base Sepolia TTT ERC-1155. If front-running occurs, you have a timestamped, on-chain-anchored record of your original submission that predates the attacker's block inclusion.
+**Solution**: Each agent stamps its steps with `pot_generate(eventId, prevEventId)`. After compression, it calls `pot_query(eventId)` to recover its exact action history — what ran, when, in what order — from the external server. The server is outside Claude's context window; compression never touches it.
 
 ```typescript
-// Before tx submission
-const pot = await client.callTool({ name: "pot_generate", arguments: { txHash: pendingTxHash, chainId: 8453 } });
-// Store pot.potHash alongside your trade log
-// If front-run: pot.potHash is your evidence, timestamped by NIST+Google+Cloudflare
-```
-
-**V2 path**: When builder staking goes live, `S(V) ≥ V − c₀` makes reordering economically irrational for any V. Not just evidence — prevention.
-
----
+// Agent starts a workflow step
+const pot = await client.callTool({
+  name: "pot_generate",
+  arguments: {
+    eventId: "refactor_auth_module_step3",
+    prevEventId: "refactor_auth_module_step2"
+  }
+});
+// pot.potHash — cryptographic proof this step happened at this time
 
-### 2. DEX Protocol — AdaptiveSwitch Sandwich Deterrence
+// After context compression, agent recovers its history:
+const history = await client.callTool({
+  name: "pot_query",
+  arguments: { eventId: "refactor_auth_module_step3" }
+});
+// history.local[0] — exact record: timestamp, prevEventId, potHash
+// history.found: true — O(1) lookup, collision probability 2⁻²⁵⁶
 
-**Problem**: Small-to-mid value sandwich attacks (V < ~$87) are constant background noise on any AMM. Each one is individually too small to litigate, collectively significant. No governance mechanism moves fast enough to respond.
+// Traverse full causal chain:
+const chain = await client.callTool({
+  name: "pot_graph",
+  arguments: { eventId: "refactor_auth_module_step3", depth: 20 }
+});
+// chain.backwardChain — all ancestor steps in chronological order
+// chain.forwardChain — steps that follow this one
+```
 
-**Solution**: Integrate `TTTHookSimple` (Uniswap V4 hook, Base Sepolia: `0x8C633b05b833a476925F7d9818da6E215760F2c7`). Honest builders who preserve PoT-verified ordering get `turbo` mode (~50ms path). Builders who tamper are flagged to `full` mode (~127ms + exponential backoff up to 320 blocks). The 77ms throughput differential makes reordering cost exceed opportunity value for the V* range. No vote. No committee. Economics.
+**Before a long task or every ~100 events — create a checkpoint:**
 
 ```typescript
-// Query current switch state for a pool
-const status = await client.callTool({ name: "pot_stats", arguments: { poolAddress: "0x..." } });
-// status.adaptiveMode: "turbo" | "full"
-// status.currentV_star: estimated MEV threshold being deterred
+// Compress workflow history before context fills up — by causal range:
+const checkpoint = await client.callTool({
+  name: "pot_checkpoint",
+  arguments: {
+    fromEventId: "refactor_auth_module_step1",
+    toEventId: "refactor_auth_module_step3"
+  }
+});
+// checkpoint.checkpointId — store this; resume from it after compression
+// checkpoint.rollupSummary — depth-adaptive compressed history (10–200 tokens/event)
+// checkpoint.chainIntact: true — causal chain verified unbroken
+// checkpoint.nextCheckpointHint: 87 — suggested events before next checkpoint
+
+// Or compress by time window with a token budget:
+const checkpoint = await client.callTool({
+  name: "pot_checkpoint",
+  arguments: {
+    startTime: Date.now() - 3_600_000,  // last 1 hour
+    maxTokens: 1500
+  }
+});
+
+// After context compression, restore from checkpoint instead of re-querying all events:
+const history = await client.callTool({
+  name: "pot_query",
+  arguments: { eventId: checkpoint.checkpointId }
+});
+// Full causal context restored in a single call
 ```
 
-**Outcome**: ~80% reduction in sub-threshold sandwich attacks. Provable per-block audit trail.
+**Outcome**: Zero duplicate work. Full workflow timeline recoverable even after complete context resets.
 
 ---
 
-### 3. Hedge Fund / Prop Desk — MiFIR Art.22c Compliance
+### 2. MEV Bot — Transaction Ordering Proof
 
-**Problem**: MiFIR Article 22c / RTS 25 requires microsecond-precision UTC-synchronized timestamps for every trade on regulated venues. The standard hardware solution (PTP/IEEE 1588 appliances) costs $50K–$500K and requires dedicated ops. Most DeFi-adjacent funds run manual reconciliation between two separate timestamp systems.
+**Problem**: You got front-run. You can't prove it — mempool timestamps are per-node, unsigned, non-authoritative.
 
-**Solution**: `pot_generate` produces an Ed25519-signed timestamp with uncertainty bound, confidence score, and multi-source attestation. The output is structurally compatible with RTS 25 audit record requirements. No hardware appliance. No dedicated ops. One API call per trade.
+**Solution**: Call `pot_generate` before every submission. The PoT receipt is cryptographically signed by three independent time sources (NIST, Google, Cloudflare), anchored on Base Sepolia TTT ERC-1155. If front-running occurs, you have a timestamped, on-chain record predating the attacker's block inclusion.
 
 ```typescript
-const audit = await client.callTool({
+const pot = await client.callTool({
   name: "pot_generate",
-  arguments: { txHash: tradeHash, chainId: 8453, metadata: { desk: "MACRO-1", trader: "algo-07" } }
+  arguments: { txHash: pendingTxHash, chainId: 8453, poolAddress: "0x..." }
 });
-// audit.timestamp: nanosecond precision
-// audit.uncertainty: +/- ms bound (required field in RTS 25 record)
-// audit.confidence: fraction of sources that agreed
-// audit.ed25519_sig: non-repudiation signature
-// Export to your compliance system — same format, every trade
+// pot.potHash — your evidence, timestamped by NIST+Google+Cloudflare
 ```
 
-**Outcome**: MiFIR-grade audit trail at ~$0.04/1K calls (DEX tier). Replaces $50K+ hardware setup. IETF standardized via `draft-helmprotocol-tttps-00`.
-
 ---
 
-### 4. Liquidity Provider — Position Timeline for Dispute Resolution
+### 3. DEX Protocol — Sandwich Deterrence
 
-**Problem**: LP enters and exits positions based on market conditions. When impermanent loss occurs due to a suspected protocol exploit or ordering manipulation, proving the sequence of events (position entry → exploit event → position exit) requires timestamped evidence that the current stack doesn't provide.
-
-**Solution**: Stamp every LP action (add liquidity, remove liquidity, fee harvest) with a PoT receipt. The receipt chain creates an unforgeable causal timeline: each action's potHash references the previous, anchored on Base Sepolia. Legally defensible for tax documentation, insurance claims, and protocol dispute resolution.
-
-```typescript
-// On liquidity add
-const entryPot = await client.callTool({ name: "pot_generate", arguments: { txHash: addLiqTx, chainId: 8453 } });
-
-// On liquidity remove
-const exitPot = await client.callTool({ name: "pot_generate", arguments: { txHash: removeLiqTx, chainId: 8453 } });
-
-// Verify the causal chain
-const chain = await client.callTool({ name: "pot_verify", arguments: { potHash: exitPot.potHash, precedingHash: entryPot.potHash } });
-// chain.valid: true means exit cryptographically followed entry
-```
+**Solution**: Integrate `TTTHookSimple` (Uniswap V4 hook, Base Sepolia: `0x8C633b05b833a476925F7d9818da6E215760F2c7`). Honest builders get `turbo` mode. Tampered sequences get `full` mode (exponential backoff). Economics, not governance.
 
 ---
 
-### 5. AI Agent Coordination — Multi-Agent Causal Ordering
+### 4. Hedge Fund / Prop Desk — MiFIR Art.22c Compliance
 
-**Problem**: When multiple AI agents interact in a pipeline (Agent A signals → Agent B acts → Agent C settles), the causal order matters for debugging, auditing, and liability. Agent logs are unverifiable—any agent can claim any timestamp.
+**Problem**: MiFIR Article 22c / RTS 25 requires microsecond-precision UTC-synchronized timestamps. Hardware PTP appliances cost $50K–$500K.
 
-**Solution**: Each agent calls `pot_generate` before acting. The resulting potHash chain is independently verifiable: "Agent A's signal at T₁ preceded Agent B's action at T₂" can be proven without trusting either agent's self-reported logs. The on-chain anchor makes the ordering dispute-proof.
+**Solution**: `pot_generate` produces an Ed25519-signed timestamp with uncertainty bound and multi-source attestation. Structurally compatible with RTS 25 audit record requirements. One API call per trade.
 
 ```typescript
-// Agent A (signal generator)
-const signalPot = await client.callTool({ name: "pot_generate", arguments: { txHash: signalId } });
-
-// Agent B (executor) — references Agent A's pot
-const execPot = await client.callTool({
+const audit = await client.callTool({
   name: "pot_generate",
-  arguments: { txHash: execId, precedingPotHash: signalPot.potHash }
+  arguments: { txHash: tradeHash, chainId: 8453 }
 });
-
-// Any third party can verify the causal chain
-const verified = await client.callTool({ name: "pot_verify", arguments: { potHash: execPot.potHash, precedingHash: signalPot.potHash } });
+// audit.timestamp: nanosecond precision
+// audit.uncertainty: ±ms bound (RTS 25 required field)
+// audit.confidence: fraction of sources that agreed
 ```
 
-**Outcome**: Unforgeable causal chain across autonomous agents. Useful for multi-agent DeFi strategies, audit compliance, and cross-agent dispute resolution.
+**Outcome**: MiFIR-grade audit trail. IETF standardized via `draft-helmprotocol-tttps-00`.
 
 ---
 
-## TypeScript: MEV Bot Integration
-
-```typescript
-import { McpClient } from "@modelcontextprotocol/sdk/client/mcp.js";
-
-// Generate a Proof of Time for a transaction
-const result = await client.callTool({
-  name: "pot_generate",
-  arguments: {
-    txHash: "0xabc123...",
-    chainId: 8453,
-    poolAddress: "0xdef456..."
-  }
-});
-// Returns: { potHash, timestamp, stratum, grg_shards }
-```
+### 5. Multi-Agent Coordination — Causal Order Proof
 
-## Python: Hedge Fund Audit
+**Problem**: When multiple AI agents interact in a pipeline, the causal order matters for debugging and audit. Agent logs are unverifiable.
 
-```python
-import subprocess, json
+**Solution**: Each agent stamps its action with `pot_generate`. The potHash chain is independently verifiable. `pot_graph` reconstructs who did what and in what order.
 
-result = subprocess.run(
-    ["npx", "-y", "@helm-protocol/ttt-mcp"],
-    input=json.dumps({
-        "tool": "pot_verify",
-        "potHash": "0x...",
-        "expectedChainId": 8453
-    }),
-    capture_output=True, text=True
-)
-```
+---
 
 ## Rate Limits & Pricing
 
 ```
 Free Tier:   100 calls/day per IP — no API key needed
-Paid Tier:   Set TTT_API_KEY env var — unlimited
-Commercial:  peter@kenosian.com (hedge funds, DEX protocols, OTC desks)
+BOT Tier:    $199/mo — unlimited, SLA
+DEX Tier:    $499/mo — unlimited, priority support
+FUND Tier:   $2K+/mo — enterprise, dedicated infra
 ```
 
+Contact: heime.jorgen@proton.me
+
+---
+
+## Requirements
+
+- Node.js >= 18
+- Network access for time synthesis (HTTPS to time.nist.gov, time.google.com, time.cloudflare.com)
+
+---
+
 ## Learn More
 
 - [OpenTTT SDK](https://www.npmjs.com/package/openttt) — The underlying SDK
@@ -299,7 +306,6 @@ Commercial:  peter@kenosian.com (hedge funds, DEX protocols, OTC desks)
 
 BSL-1.1 — free for non-commercial use.
 
-**Commercial use** (production bots, hedge funds, prop desks) requires a license.  
-→ [kenosian.com/pricing](https://kenosian.com/pricing)
+**Commercial use** (production bots, hedge funds, prop desks) requires a license.
 
 Change Date: 2029-05-28 → Apache 2.0

package/dist/index.js

@@ -7,188 +7,183 @@ var import_http = require("http");
 var import_zod = require("zod");
 var import_tools = require("./tools");
 var import_auth = require("./auth");
-const IS_STDIO = !process.env.PORT;
-const server = new import_mcp.McpServer({
-  name: "ttt-mcp",
-  version: "0.1.0"
-});
-server.tool(
-  "pot_generate",
-  "Generate a Proof of Time for a transaction. Returns potHash, timestamp, stratum, and GRG integrity shards.",
-  {
-    txHash: import_zod.z.string().describe("Transaction hash (hex with 0x prefix)"),
-    chainId: import_zod.z.number().describe("Chain ID (e.g. 8453 for Base, 84532 for Base Sepolia)"),
-    poolAddress: import_zod.z.string().describe("DEX pool contract address")
-  },
-  async (args) => {
-    if (IS_STDIO) {
-      const apiKey = (0, import_auth.resolveApiKey)();
-      const rl = (0, import_auth.checkRateLimit)(apiKey, "stdio");
-      if (!rl.allowed) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({
-            error: "rate_limit_exceeded",
-            message: `Free tier: ${import_auth.FREE_TIER_LIMIT} calls/day. Set TTT_API_KEY env var for unlimited access. \u2192 kenosian.com/pricing`,
-            remaining: 0,
-            tier: "free"
-          }) }],
-          isError: true
-        };
+async function restoreDAGFromRedis() {
+  try {
+    await Promise.race([
+      import_tools.redis.connect(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 3e3))
+    ]);
+  } catch {
+    return 0;
+  }
+  let cursor = "0";
+  let restored = 0;
+  const entries = [];
+  try {
+    do {
+      const [next, keys] = await import_tools.redis.scan(cursor, "MATCH", "dag:*", "COUNT", "200");
+      cursor = next;
+      if (keys.length === 0) continue;
+      const values = await import_tools.redis.mget(...keys);
+      for (const v of values) {
+        if (!v) continue;
+        try {
+          const entry = JSON.parse(v);
+          if (entry.eventId) entries.push(entry);
+        } catch {
+        }
       }
-    }
+    } while (cursor !== "0");
+  } catch {
+    return 0;
+  }
+  entries.sort((a, b) => a.createdAt - b.createdAt);
+  for (const e of entries) {
     try {
-      const result = await (0, import_tools.potGenerate)(args);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true
-      };
+      (0, import_tools.restoreDagEntry)({
+        eventId: e.eventId,
+        prevEventId: e.prevEventId,
+        potHash: e.potHash,
+        timestamp: e.timestamp,
+        stratum: e.stratum,
+        mode: e.mode,
+        createdAt: e.createdAt,
+        chainId: e.chainId,
+        poolAddress: e.poolAddress
+      });
+      restored++;
+    } catch {
     }
   }
-);
-server.tool(
-  "pot_verify",
-  "Verify a Proof of Time using its hash and GRG shards. Returns validity, mode (turbo/full), and timestamp.",
-  {
-    potHash: import_zod.z.string().describe("PoT hash to verify (hex with 0x prefix)"),
-    grgShards: import_zod.z.array(import_zod.z.string()).describe("Array of hex-encoded GRG integrity shards"),
-    chainId: import_zod.z.number().describe("EVM chain ID (e.g. 84532 for Base Sepolia)"),
-    poolAddress: import_zod.z.string().describe("Uniswap V4 pool address (0x-prefixed)")
-  },
-  async (args) => {
-    if (IS_STDIO) {
-      const apiKey = (0, import_auth.resolveApiKey)();
-      const rl = (0, import_auth.checkRateLimit)(apiKey, "stdio");
-      if (!rl.allowed) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({
-            error: "rate_limit_exceeded",
-            message: `Free tier: ${import_auth.FREE_TIER_LIMIT} calls/day. Set TTT_API_KEY env var for unlimited access. \u2192 kenosian.com/pricing`,
-            remaining: 0,
-            tier: "free"
-          }) }],
-          isError: true
-        };
+  if (restored > 0) {
+    console.error(`[ttt-mcp] DAG restored from Redis: ${restored} entries`);
+  }
+  return restored;
+}
+function buildMcpServer() {
+  const s = new import_mcp.McpServer({ name: "ttt-mcp", version: "0.1.0" });
+  s.tool(
+    "pot_generate",
+    "Generate a cryptographic Proof of Time timestamp. For Claude Code workflows: use eventId + prevEventId to build a causal chain. For DeFi: use txHash + chainId + poolAddress. Either eventId or txHash is required.",
+    {
+      eventId: import_zod.z.string().optional().describe("Workflow step identifier (Claude Code). E.g. 'refactor_auth_step1'"),
+      prevEventId: import_zod.z.string().optional().describe("Previous step's eventId \u2014 links steps into a causal chain"),
+      txHash: import_zod.z.string().optional().describe("Transaction hash (DeFi, hex with 0x prefix)"),
+      chainId: import_zod.z.number().optional().describe("EVM chain ID (DeFi, e.g. 8453 for Base)"),
+      poolAddress: import_zod.z.string().optional().describe("DEX pool contract address (DeFi)")
+    },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potGenerate)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
       }
     }
-    try {
-      const result = await (0, import_tools.potVerify)(args);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true
-      };
+  );
+  s.tool(
+    "pot_verify",
+    "Verify a Proof of Time using its hash and integrity shards. Returns validity, mode (turbo/full), and timestamp.",
+    {
+      potHash: import_zod.z.string().describe("PoT hash to verify (hex with 0x prefix)"),
+      grgShards: import_zod.z.array(import_zod.z.string()).describe("Array of hex-encoded cryptographic integrity shards"),
+      chainId: import_zod.z.number().describe("EVM chain ID (e.g. 84532 for Base Sepolia)"),
+      poolAddress: import_zod.z.string().describe("Uniswap V4 pool address (0x-prefixed)")
+    },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potVerify)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+      }
     }
-  }
-);
-server.tool(
-  "pot_query",
-  "Query Proof of Time history from local log and on-chain subgraph.",
-  {
-    startTime: import_zod.z.number().optional().describe("Start time (unix ms). Default: 24h ago"),
-    endTime: import_zod.z.number().optional().describe("End time (unix ms). Default: now"),
-    limit: import_zod.z.number().optional().describe("Max entries to return. Default: 100, max: 1000")
-  },
-  async (args) => {
-    if (IS_STDIO) {
-      const apiKey = (0, import_auth.resolveApiKey)();
-      const rl = (0, import_auth.checkRateLimit)(apiKey, "stdio");
-      if (!rl.allowed) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({
-            error: "rate_limit_exceeded",
-            message: `Free tier: ${import_auth.FREE_TIER_LIMIT} calls/day. Set TTT_API_KEY env var for unlimited access. \u2192 kenosian.com/pricing`,
-            remaining: 0,
-            tier: "free"
-          }) }],
-          isError: true
-        };
+  );
+  s.tool(
+    "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.",
+    {
+      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"),
+      endTime: import_zod.z.number().optional().describe("End time (unix ms). Default: now"),
+      limit: import_zod.z.number().optional().describe("Max entries to return. Default: 100, max: 1000")
+    },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potQuery)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
       }
     }
-    try {
-      const result = await (0, import_tools.potQuery)(args);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true
-      };
+  );
+  s.tool(
+    "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.",
+    {
+      eventId: import_zod.z.string().describe("The workflow step to start traversal from"),
+      depth: import_zod.z.number().optional().describe("Max backward traversal depth. Default: 10, max: 100")
+    },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potGraph)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+      }
     }
-  }
-);
-server.tool(
-  "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")
-  },
-  async (args) => {
-    if (IS_STDIO) {
-      const apiKey = (0, import_auth.resolveApiKey)();
-      const rl = (0, import_auth.checkRateLimit)(apiKey, "stdio");
-      if (!rl.allowed) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({
-            error: "rate_limit_exceeded",
-            message: `Free tier: ${import_auth.FREE_TIER_LIMIT} calls/day. Set TTT_API_KEY env var for unlimited access. \u2192 kenosian.com/pricing`,
-            remaining: 0,
-            tier: "free"
-          }) }],
-          isError: true
-        };
+  );
+  s.tool(
+    "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") },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potStats)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
       }
     }
-    try {
-      const result = await (0, import_tools.potStats)(args);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true
-      };
+  );
+  s.tool(
+    "pot_health",
+    "Check PoT system health: time source status, subgraph sync, server uptime, and current mode.",
+    {},
+    async () => {
+      try {
+        const result = await (0, import_tools.potHealth)();
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+      }
     }
-  }
-);
-server.tool(
-  "pot_health",
-  "Check PoT system health: time source status, subgraph sync, server uptime, and current mode.",
-  {},
-  async () => {
-    try {
-      const result = await (0, import_tools.potHealth)();
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true
-      };
+  );
+  s.tool(
+    "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).",
+    {
+      fromEventId: import_zod.z.string().optional().describe("Start of range by eventId (optional, use with toEventId)"),
+      toEventId: import_zod.z.string().optional().describe("End of range by eventId (optional, use with fromEventId)"),
+      startTime: import_zod.z.number().optional().describe("Unix ms start time (optional, default: 1h ago)"),
+      endTime: import_zod.z.number().optional().describe("Unix ms end time (optional, default: now)"),
+      maxTokens: import_zod.z.number().optional().describe("Approximate max tokens for rollup (default: 2000)")
+    },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potCheckpoint)(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+      }
     }
-  }
-);
+  );
+  return s;
+}
 async function main() {
+  await restoreDAGFromRedis();
   const port = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
   if (port) {
-    const transport = new import_streamableHttp.StreamableHTTPServerTransport({
-      sessionIdGenerator: void 0
-    });
-    await server.connect(transport);
     const httpServer = (0, import_http.createServer)(async (req, res) => {
       if (req.method === "GET" && (req.url === "/health" || req.url === "/ping")) {
         res.writeHead(200, { "Content-Type": "application/json" });
@@ -209,7 +204,7 @@ async function main() {
           res.end(
             JSON.stringify({
               error: "rate_limit_exceeded",
-              message: "Free tier limit reached (100 calls/day). Add X-API-Key header for unlimited access.",
+              message: "Free tier: 100 calls/day reached. Contact heime.jorgen@proton.me for commercial access.",
               tier: "free"
             })
           );
@@ -233,6 +228,9 @@ async function main() {
         }
       }
       try {
+        const reqServer = buildMcpServer();
+        const transport = new import_streamableHttp.StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+        await reqServer.connect(transport);
         await transport.handleRequest(req, res);
       } catch (err) {
         if (!res.headersSent) {
@@ -245,8 +243,9 @@ async function main() {
       console.error(`[ttt-mcp] OpenTTT MCP Server (HTTP) on port ${port}`);
     });
   } else {
+    const stdioServer = buildMcpServer();
     const transport = new import_stdio.StdioServerTransport();
-    await server.connect(transport);
+    await stdioServer.connect(transport);
     console.error("[ttt-mcp] OpenTTT MCP Server running on stdio");
   }
 }

package/dist/tools.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,24 +17,52 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tools_exports = {};
 __export(tools_exports, {
+  potCheckpoint: () => potCheckpoint,
   potGenerate: () => potGenerate,
+  potGraph: () => potGraph,
   potHealth: () => potHealth,
   potQuery: () => potQuery,
   potStats: () => potStats,
-  potVerify: () => potVerify
+  potVerify: () => potVerify,
+  redis: () => redis,
+  restoreDagEntry: () => restoreDagEntry
 });
 module.exports = __toCommonJS(tools_exports);
 var import_openttt = require("openttt");
 var import_telemetry = require("./telemetry");
+var import_ioredis = __toESM(require("ioredis"));
+const GrgPipeline = (
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require("openttt").GrgPipeline ?? null
+);
+const redis = new import_ioredis.default(process.env.REDIS_URL ?? "redis://127.0.0.1:6379", {
+  lazyConnect: true,
+  enableOfflineQueue: false,
+  maxRetriesPerRequest: 1
+});
+redis.on("error", () => {
+});
 const timeSynth = new import_openttt.TimeSynthesis();
 const adaptiveSwitch = new import_openttt.AdaptiveSwitch();
 const potSigner = new import_openttt.PotSigner();
 const startedAt = Date.now();
 const POT_LOG_MAX = 1e4;
 const potLog = [];
+const potByEventId = /* @__PURE__ */ new Map();
+const potByPrevEventId = /* @__PURE__ */ new Map();
+const evictedEventIds = /* @__PURE__ */ new Set();
+const EVICTED_MAX = 1e3;
 function bigintReplacer(_key, value) {
   return typeof value === "bigint" ? value.toString() : value;
 }
@@ -40,26 +70,181 @@ function serialize(obj) {
   return JSON.parse(JSON.stringify(obj, bigintReplacer));
 }
 const SUBGRAPH_URL = "https://api.studio.thegraph.com/query/1744392/openttt-base-sepolia/v0.1.0";
+function compressEntry(entry, depth, depthThreshold) {
+  const t = depthThreshold ?? { compact: 5, minimal: 20, rollup: 50 };
+  if (depth <= t.compact) return entry;
+  if (depth <= t.minimal) return {
+    // compact
+    eventId: entry.eventId,
+    potHash: entry.potHash,
+    timestamp: entry.timestamp,
+    prevEventId: entry.prevEventId
+  };
+  if (depth <= t.rollup) return {
+    // minimal
+    eventId: entry.eventId,
+    timestamp: entry.timestamp
+  };
+  return `${entry.eventId ?? "?"}@${entry.timestamp}`;
+}
+function depthThresholdFromTokens(maxTokens, entryCount) {
+  const charBudget = maxTokens * 4;
+  const fullBudget = charBudget * 0.6;
+  const compactBudget = charBudget * 0.25;
+  const minimalBudget = charBudget * 0.1;
+  const fullDepth = Math.max(1, Math.floor(fullBudget / 300));
+  const compactDepth = fullDepth + Math.max(0, Math.floor(compactBudget / 120));
+  const minimalDepth = compactDepth + Math.max(0, Math.floor(minimalBudget / 60));
+  return {
+    compact: Math.min(fullDepth, entryCount),
+    minimal: Math.min(compactDepth, entryCount),
+    rollup: Math.min(minimalDepth, entryCount)
+  };
+}
+function restoreDagEntry(entry) {
+  if (potByEventId.has(entry.eventId)) return;
+  const e = {
+    potHash: entry.potHash,
+    timestamp: entry.timestamp,
+    stratum: entry.stratum,
+    mode: entry.mode,
+    chainId: entry.chainId ?? void 0,
+    poolAddress: entry.poolAddress ?? void 0,
+    eventId: entry.eventId,
+    prevEventId: entry.prevEventId ?? void 0,
+    createdAt: entry.createdAt
+  };
+  if (potLog.length >= POT_LOG_MAX) {
+    const evicted = potLog.shift();
+    if (evicted.eventId) {
+      potByEventId.delete(evicted.eventId);
+      evictedEventIds.add(evicted.eventId);
+      if (evictedEventIds.size > EVICTED_MAX) {
+        const first = evictedEventIds.values().next().value;
+        if (first !== void 0) evictedEventIds.delete(first);
+      }
+    }
+    if (evicted.prevEventId) {
+      const siblings = potByPrevEventId.get(evicted.prevEventId);
+      if (siblings) {
+        const filtered = siblings.filter((s) => s !== evicted);
+        if (filtered.length === 0) potByPrevEventId.delete(evicted.prevEventId);
+        else potByPrevEventId.set(evicted.prevEventId, filtered);
+      }
+    }
+  }
+  potLog.push(e);
+  potByEventId.set(entry.eventId, e);
+  if (entry.prevEventId) {
+    const bucket = potByPrevEventId.get(entry.prevEventId) ?? [];
+    bucket.push(e);
+    potByPrevEventId.set(entry.prevEventId, bucket);
+  }
+}
 async function potGenerate(args) {
+  if (!args.eventId && !args.txHash) {
+    throw new Error("Either eventId (Claude Code) or txHash (DeFi) is required");
+  }
   (0, import_telemetry.telemetryIncrement)("pot_generate");
-  const pot = await timeSynth.generateProofOfTime();
+  let pot;
+  let isOfflineFallback = false;
+  try {
+    pot = await timeSynth.generateProofOfTime();
+  } catch {
+    isOfflineFallback = true;
+    const nowMs = BigInt(Date.now());
+    pot = {
+      timestamp: nowMs * 1000000n,
+      stratum: 16,
+      uncertainty: 999999999,
+      confidence: 0,
+      sources: 0,
+      nonce: Buffer.from(crypto.getRandomValues(new Uint8Array(16))).toString("hex"),
+      expiresAt: (nowMs + 300000n) * 1000000n,
+      sourceReadings: []
+    };
+  }
   const potHash = import_openttt.TimeSynthesis.getOnChainHash(pot);
-  const txData = new TextEncoder().encode(args.txHash);
-  const grgShards = import_openttt.GrgPipeline.processForward(txData, args.chainId, args.poolAddress);
+  let grgShards = [];
+  let currentMode;
+  if (args.txHash && args.chainId != null && args.poolAddress) {
+    const txData = new TextEncoder().encode(args.txHash);
+    grgShards = GrgPipeline.processForward(txData, args.chainId, args.poolAddress).map((s) => Buffer.from(s).toString("hex"));
+    const syntheticBlock = {
+      timestamp: Number(pot.timestamp / 1000000n),
+      // ns → ms
+      txs: [args.txHash],
+      data: new TextEncoder().encode(args.txHash)
+    };
+    const syntheticTTTRecord = {
+      time: Number(pot.timestamp / 1000000n),
+      txOrder: [args.txHash],
+      grgPayload: []
+    };
+    currentMode = adaptiveSwitch.verifyBlock(syntheticBlock, syntheticTTTRecord, args.chainId, args.poolAddress);
+  } else {
+    currentMode = adaptiveSwitch.getCurrentMode();
+  }
   const signature = potSigner.signPot(potHash);
   const entry = {
     potHash,
     timestamp: pot.timestamp.toString(),
     stratum: pot.stratum,
-    mode: adaptiveSwitch.getCurrentMode(),
+    mode: currentMode,
     chainId: args.chainId,
     poolAddress: args.poolAddress,
+    eventId: args.eventId,
+    prevEventId: args.prevEventId,
     createdAt: Date.now()
   };
+  if (potLog.length >= POT_LOG_MAX) {
+    const evicted = potLog.shift();
+    if (evicted.eventId) {
+      potByEventId.delete(evicted.eventId);
+      evictedEventIds.add(evicted.eventId);
+      if (evictedEventIds.size > EVICTED_MAX) {
+        const first = evictedEventIds.values().next().value;
+        if (first !== void 0) evictedEventIds.delete(first);
+      }
+    }
+    if (evicted.prevEventId) {
+      const siblings = potByPrevEventId.get(evicted.prevEventId);
+      if (siblings) {
+        const filtered = siblings.filter((e) => e !== evicted);
+        if (filtered.length === 0) potByPrevEventId.delete(evicted.prevEventId);
+        else potByPrevEventId.set(evicted.prevEventId, filtered);
+      }
+    }
+  }
   potLog.push(entry);
-  if (potLog.length > POT_LOG_MAX) potLog.shift();
+  if (args.eventId) potByEventId.set(args.eventId, entry);
+  if (args.prevEventId) {
+    const bucket = potByPrevEventId.get(args.prevEventId) ?? [];
+    bucket.push(entry);
+    potByPrevEventId.set(args.prevEventId, bucket);
+  }
+  if (args.eventId) {
+    redis.setex(
+      `dag:${args.eventId}`,
+      90 * 86400,
+      JSON.stringify({
+        eventId: args.eventId,
+        prevEventId: args.prevEventId ?? null,
+        potHash,
+        timestamp: pot.timestamp.toString(),
+        stratum: pot.stratum,
+        mode: currentMode,
+        createdAt: entry.createdAt,
+        chainId: args.chainId ?? null,
+        poolAddress: args.poolAddress ?? null
+      })
+    ).catch(() => {
+    });
+  }
   return serialize({
     potHash,
+    eventId: args.eventId ?? null,
+    prevEventId: args.prevEventId ?? null,
     timestamp: pot.timestamp.toString(),
     stratum: pot.stratum,
     uncertainty: pot.uncertainty,
@@ -67,7 +252,8 @@ async function potGenerate(args) {
     sources: pot.sources,
     nonce: pot.nonce,
     expiresAt: pot.expiresAt.toString(),
-    grgShards: grgShards.map((s) => Buffer.from(s).toString("hex")),
+    ...isOfflineFallback && { mode: "local" },
+    ...grgShards.length > 0 && { grgShards },
     signature: {
       issuerPubKey: signature.issuerPubKey,
       signature: signature.signature,
@@ -81,7 +267,7 @@ async function potVerify(args) {
   let valid = false;
   let reconstructedSize = 0;
   try {
-    const recovered = import_openttt.GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
+    const recovered = GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
     valid = recovered.length > 0;
     reconstructedSize = recovered.length;
   } catch {
@@ -98,6 +284,16 @@ async function potVerify(args) {
 }
 async function potQuery(args) {
   (0, import_telemetry.telemetryIncrement)("pot_query");
+  if (args.eventId) {
+    const entry = potByEventId.get(args.eventId);
+    return serialize({
+      local: entry ? [entry] : [],
+      subgraph: [],
+      found: !!entry,
+      totalLocal: potLog.length,
+      query: { eventId: args.eventId }
+    });
+  }
   const limit = Math.min(args.limit ?? 100, 1e3);
   const now = Date.now();
   const startTime = args.startTime ?? now - 864e5;
@@ -140,6 +336,35 @@ async function potQuery(args) {
     query: { startTime, endTime, limit }
   });
 }
+async function potGraph(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_graph");
+  const maxDepth = Math.min(args.depth ?? 10, 100);
+  const backwardChain = [];
+  let cursor = potByEventId.get(args.eventId);
+  let d = 0;
+  while (cursor && d < maxDepth) {
+    backwardChain.unshift(cursor);
+    cursor = cursor.prevEventId ? potByEventId.get(cursor.prevEventId) : void 0;
+    d++;
+  }
+  const forwardChain = potByPrevEventId.get(args.eventId) ?? [];
+  const found = potByEventId.has(args.eventId);
+  const chainBroken = backwardChain.some((e) => e.eventId && evictedEventIds.has(e.eventId)) || cursor?.prevEventId != null && potByEventId.get(cursor.prevEventId) == null;
+  const chainRoot = backwardChain.length > 0 ? backwardChain[0] : null;
+  const isServerRestart = chainBroken && chainRoot !== null && chainRoot.prevEventId != null && !potByEventId.has(chainRoot.prevEventId) && !evictedEventIds.has(chainRoot.prevEventId);
+  const brokenAt = chainBroken ? isServerRestart ? "server_restart" : backwardChain[0]?.eventId ?? null : null;
+  const compressedBackward = backwardChain.map((e, i) => compressEntry(e, i + 1));
+  return serialize({
+    eventId: args.eventId,
+    found,
+    backwardChain: compressedBackward,
+    forwardChain,
+    chainLength: backwardChain.length + forwardChain.length,
+    reachableDepth: backwardChain.length,
+    chainBroken,
+    brokenAt
+  });
+}
 async function potStats(args) {
   (0, import_telemetry.telemetryIncrement)("pot_stats");
   const now = Date.now();
@@ -220,11 +445,54 @@ async function potHealth() {
     }
   });
 }
+async function potCheckpoint(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_checkpoint");
+  const now = Date.now();
+  const startTime = args.startTime ?? now - 36e5;
+  const endTime = args.endTime ?? now;
+  let entries;
+  if (args.fromEventId && args.toEventId) {
+    entries = [];
+    let cursor = potByEventId.get(args.fromEventId);
+    const maxDepth = 1e3;
+    let d = 0;
+    while (cursor && d < maxDepth) {
+      entries.push(cursor);
+      if (cursor.eventId === args.toEventId) break;
+      const nexts = potByPrevEventId.get(cursor.eventId ?? "") ?? [];
+      cursor = nexts[0];
+      d++;
+    }
+  } else {
+    entries = potLog.filter((e) => e.createdAt >= startTime && e.createdAt <= endTime);
+  }
+  const eventCount = entries.length;
+  const depthThreshold = args.maxTokens ? depthThresholdFromTokens(args.maxTokens, entries.length) : void 0;
+  const compressed = entries.map((e, i) => compressEntry(e, i + 1, depthThreshold));
+  const chainIntact = !entries.some((e) => e.eventId && evictedEventIds.has(e.eventId));
+  const nextCheckpointHint = Math.max(10, 100 - eventCount % 100);
+  const checkpointId = `ckpt_${now}_${eventCount}`;
+  const firstTs = entries[0]?.timestamp ?? null;
+  const lastTs = entries[entries.length - 1]?.timestamp ?? null;
+  return serialize({
+    checkpointId,
+    eventCount,
+    chainIntact,
+    nextCheckpointHint,
+    rollup: compressed,
+    summary: `${eventCount} events from ${firstTs ?? "?"} to ${lastTs ?? "?"}`,
+    generatedAt: now
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  potCheckpoint,
   potGenerate,
+  potGraph,
   potHealth,
   potQuery,
   potStats,
-  potVerify
+  potVerify,
+  redis,
+  restoreDagEntry
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helm-protocol/ttt-mcp",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "MCP Server for OpenTTT — Proof of Time tools for AI agents",
   "main": "dist/index.js",
   "bin": {
@@ -13,7 +13,23 @@
   "scripts": {
     "build": "esbuild index.ts tools.ts telemetry.ts auth.ts --platform=node --target=node18 --format=cjs --outdir=dist",
     "start": "node dist/index.js",
-    "dev": "npx ts-node index.ts"
+    "dev": "npx ts-node index.ts",
+    "test": "jest --forceExit"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": ["**/__tests__/**/*.test.ts"],
+    "moduleNameMapper": {
+      "^openttt$": "<rootDir>/node_modules/openttt/dist/index.js"
+    },
+    "transform": {
+      "^.+\\.tsx?$": ["ts-jest", {
+        "tsconfig": {
+          "module": "CommonJS"
+        }
+      }]
+    }
   },
   "keywords": [
     "mcp",
@@ -36,12 +52,16 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "openttt": "^0.2.6",
+    "ioredis": "^5.11.0",
+    "openttt": "^0.2.13",
     "zod": "^3.25.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.11.19",
     "esbuild": "^0.27.4",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.11",
     "typescript": "^5.3.3"
   },
   "mcpName": "io.github.Helm-Protocol/openttt-pot"