Replayable AI Execution: Every Agent Decision as an Independently Verifiable Artifact

import { H33Agent, Session, ToolEnvelope } from '@h33/agent';

// Step 1: Register agent with canonical name
const agent = await H33Agent.register({
  name: 'h33.agent.acme.finance.analyst.prod.001',
  apiKey: process.env.H33_API_KEY,
  endpoint: 'https://api.h33.ai/v1',
  policy: {
    scopes: ['organization', 'team', 'project', 'session', 'action'],
  },
});

// Step 2: Start session
const session: Session = await agent.startSession({
  purpose: 'quarterly-revenue-analysis',
  parentSession: null,          // no continuation
  memoryCheckpointInterval: 10, // checkpoint every 10 actions
});

console.log(`Session ${session.id} started`);
console.log(`  Root hash: ${session.rootHash}`);

// Step 3: Execute actions with tool calls
const dataResult = await session.action({
  type: 'tool_call',
  tool: 'database.query',
  input: { sql: 'SELECT revenue FROM q1_2026 WHERE region = $1', params: ['EMEA'] },
});

// Every tool call is wrapped in a ToolEnvelope
console.log(`  Tool envelope: ${dataResult.toolEnvelope.hash}`);
console.log(`  Policy authorized: ${dataResult.policyResult.authorized}`);
console.log(`  DAG node: ${dataResult.nodeHash}`);

// Step 4: Agent performs analysis (attested action)
const analysis = await session.action({
  type: 'computation',
  description: 'Calculate YoY growth rate for EMEA revenue',
  input: { currentRevenue: dataResult.output.encrypted, priorRevenue: '...' },
});

// Step 5: Memory checkpoint (automatic at interval, or manual)
const checkpoint = await session.checkpoint();
console.log(`  Checkpoint hash: ${checkpoint.hash}`);
console.log(`  Actions since last checkpoint: ${checkpoint.actionCount}`);

// Step 6: Close session with H33-74 commitment
const receipt = await session.close();

console.log(`Session closed`);
console.log(`  Total actions: ${receipt.actionCount}`);
console.log(`  Total tool calls: ${receipt.toolCallCount}`);
console.log(`  Final DAG hash: ${receipt.dagHash}`);
console.log(`  H33-74 bundle: ${receipt.attestation.bundleSize} bytes`);
console.log(`  Replay-deterministic: ${receipt.replayDeterministic}`);

// Step 7: Replay the session programmatically
const replayResult = await agent.replay({
  sessionReceipt: receipt,
  iterations: 100,
});

console.log(`Replay: ${replayResult.allMatch ? 'PASS' : 'FAIL'}`);
console.log(`  Iterations: ${replayResult.iterations}`);
console.log(`  Divergence point: ${replayResult.divergenceNode ?? 'none'}`);

// Step 8: Diff two sessions
const diff = await agent.diff({
  before: previousReceipt,
  after: receipt,
});

console.log(`Diff: ${diff.identical ? 'identical' : diff.changes.length + ' changes'}`);
for (const change of diff.changes) {
  console.log(`  Node ${change.index}: ${change.type} -- ${change.description}`);
}

# Verify a session receipt via the public API
curl -X POST https://api.h33.ai/v1/verify/session \
  -H "Content-Type: application/json" \
  -d @session-receipt.json

# Replay a session via the public API
curl -X POST https://api.h33.ai/v1/replay/session \
  -H "Content-Type: application/json" \
  -d '{"receipt": "session-receipt.json", "iterations": 100}'