agentledger-runtime 1.0.3 → 1.0.5

package/README.md

@@ -1,6 +1,6 @@
 # AgentLedger Node / TypeScript Runtime
 
-This directory contains the dependency-free Node/TypeScript-compatible runtime-core baseline for AgentLedger 1.0.2.
+This directory contains the dependency-free Node/TypeScript-compatible runtime-core baseline for AgentLedger 1.0.5.
 
 It runs a native local runtime loop, participates in the shared Python/Go/TypeScript/Rust conformance gate, and should be treated as runtime-core aligned; concrete production adapters are shipped separately as they mature.
 

package/examples/README.md

@@ -20,3 +20,20 @@ node src/cli.js conformance
 ```
 
 Package surface: `agentledger-runtime`. See `../README.md` for package metadata and API examples.
+
+
+## Travel Assistant
+
+`travel_assistant/travel_assistant.js` is a larger interactive demo. Treat it as an example app, not part of the npm package release gate.
+
+Run from the repository root:
+
+```bash
+node typescript/examples/travel_assistant/travel_assistant.js
+```
+
+Or pass a custom local state root:
+
+```bash
+node typescript/examples/travel_assistant/travel_assistant.js .agentledger-ts
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentledger-runtime",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "private": false,
   "description": "Dependency-free Node/TypeScript-compatible runtime for AgentLedger.",
   "type": "module",
@@ -17,5 +17,11 @@
   },
   "bin": {
     "agentledger-ts": "src/cli.js"
-  }
+  },
+  "files": [
+    "src/",
+    "examples/README.md",
+    "examples/quickstart/",
+    "README.md"
+  ]
 }

package/src/cli.js

@@ -194,7 +194,7 @@ export function validateFixtures() {
 }
 
 function usage() {
-  return `AgentLedger TypeScript Runtime 1.0.3\n\nUsage:\n  agentledger-ts doctor\n  agentledger-ts version\n  agentledger-ts quickstart\n  agentledger-ts conformance\n  agentledger-ts contract validate\n  agentledger-ts contract export\n\nProject: https://github.com/yaogdu/AgentLedger`;
+  return `AgentLedger TypeScript Runtime 1.0.5\n\nUsage:\n  agentledger-ts doctor\n  agentledger-ts version\n  agentledger-ts quickstart\n  agentledger-ts conformance\n  agentledger-ts contract validate\n  agentledger-ts contract export\n\nProject: https://github.com/yaogdu/AgentLedger`;
 }
 
 export async function runRuntimeSmoke() {
@@ -577,11 +577,11 @@ export async function main(args = process.argv.slice(2)) {
     return 0;
   }
   if (args.length === 1 && args[0] === 'version') {
-    console.log('agentledger-ts 1.0.3');
+    console.log('agentledger-ts 1.0.5');
     return 0;
   }
   if (args.length === 1 && args[0] === 'doctor') {
-    console.log(JSON.stringify({ language: 'typescript', version: '1.0.3', status: 'ok', runtime_core_parity: true }, null, 2));
+    console.log(JSON.stringify({ language: 'typescript', version: '1.0.5', status: 'ok', runtime_core_parity: true }, null, 2));
     return 0;
   }
   if (args.length === 1 && args[0] === 'quickstart') {

package/examples/travel_assistant/travel_assistant.js

@@ -1,395 +0,0 @@
-#!/usr/bin/env node
-/**
- * Travel Assistant Demo — AgentLedger TypeScript Interactive Demo
- * ================================================================
- * 旅游助手交互式演示 — 每一步展示数据库里的实际变化
- *
- * Usage:
- *   node typescript/examples/travel_assistant/travel_assistant.js
- *   node typescript/examples/travel_assistant/travel_assistant.js .agentledger-ts
- */
-
-import { createInterface } from 'node:readline';
-import {
-  Runtime, JSONStore, LocalBlobStore, RetryableAgentError,
-  exportEvidence, replay, costAttribution,
-} from '../../src/index.js';
-
-// ════════════════════════════════════════════════════════════
-// ANSI Colors
-// ════════════════════════════════════════════════════════════
-const C = {
-  R: '\x1b[91m', G: '\x1b[92m', Y: '\x1b[93m', B: '\x1b[94m',
-  M: '\x1b[95m', C: '\x1b[96m', BOLD: '\x1b[1m', DIM: '\x1b[2m', RST: '\x1b[0m',
-};
-
-// ════════════════════════════════════════════════════════════
-// Mock data
-// ════════════════════════════════════════════════════════════
-const MOCK_FLIGHTS = [
-  { id: 'FL-002', from_city: 'Beijing', from_code: 'PEK', to_city: 'Tokyo', to_code: 'NRT', date: '2025-06-15', airline: 'JAL', price_usd: 580 },
-];
-const MOCK_HOTELS = [
-  { id: 'HT-002', city: 'Tokyo', name: 'APA Hotel Shinjuku', nightly_usd: 85, stars: 3 },
-];
-const MOCK_WEATHER = { Tokyo: { temp_c: 24, condition: 'Partly Cloudy', humidity: 65 } };
-const bookingDB = {};
-
-// ════════════════════════════════════════════════════════════
-// Tool implementations
-// ════════════════════════════════════════════════════════════
-
-function searchFlights(args) {
-  const origin = (args.from || '').trim().toLowerCase();
-  const dest = (args.to || '').trim().toLowerCase();
-  const results = MOCK_FLIGHTS.filter(f =>
-    (f.from_city.toLowerCase().includes(origin) || f.from_code.toLowerCase().includes(origin)) &&
-    (f.to_city.toLowerCase().includes(dest) || f.to_code.toLowerCase().includes(dest))
-  );
-  return { results, count: results.length };
-}
-
-function searchHotels(args) {
-  const city = (args.city || '').trim().toLowerCase();
-  const results = MOCK_HOTELS.filter(h => h.city.toLowerCase() === city);
-  return { results, count: results.length };
-}
-
-function checkWeather(args) {
-  const city = (args.city || '').trim();
-  return { city, ...(MOCK_WEATHER[city] || { temp_c: 20, condition: 'Unknown' }) };
-}
-
-function bookFlight(args) {
-  const ref = `BK-F-${args.flight_id}-${(args.passenger || '').slice(0, 3).toUpperCase()}`;
-  if (bookingDB[ref]) return bookingDB[ref];
-  const f = MOCK_FLIGHTS.find(f => f.id === args.flight_id);
-  if (!f) throw new Error(`Flight not found: ${args.flight_id}`);
-  const booking = { booking_ref: ref, type: 'flight', airline: f.airline, price_usd: f.price_usd, status: 'confirmed', external_id: ref };
-  bookingDB[ref] = booking;
-  return booking;
-}
-
-function bookHotel(args) {
-  const ref = `BK-H-${args.hotel_id}-${(args.guest || '').slice(0, 3).toUpperCase()}`;
-  if (bookingDB[ref]) return bookingDB[ref];
-  const h = MOCK_HOTELS.find(h => h.id === args.hotel_id);
-  if (!h) throw new Error(`Hotel not found: ${args.hotel_id}`);
-  const booking = { booking_ref: ref, type: 'hotel', name: h.name, price_total_usd: h.nightly_usd * 5, status: 'confirmed', external_id: ref };
-  bookingDB[ref] = booking;
-  return booking;
-}
-
-// ════════════════════════════════════════════════════════════
-// Agent function
-// ════════════════════════════════════════════════════════════
-
-async function travelPlanner(ctx, state) {
-  // Phase 1: Research
-  const flights = await ctx.callTool('travel.search_flights', { from: 'Beijing', to: 'Tokyo' });
-  const hotels = await ctx.callTool('travel.search_hotels', { city: 'Tokyo' });
-  const weather = await ctx.callTool('travel.check_weather', { city: 'Tokyo' });
-  await ctx.writeState('research', { flights: flights.count, hotels: hotels.count, weather: weather.temp_c });
-
-  // Phase 2: Book flight (approval required)
-  const flight = await ctx.callTool('travel.book_flight', {
-    flight_id: 'FL-002', passenger: 'Demo User',
-    _logical_operation: 'book-demo-flight',
-  });
-
-  // Phase 3: Simulated crash on attempt 2
-  if (ctx.attempt === 2) {
-    throw new RetryableAgentError('after flight booking');
-  }
-
-  // Phase 4: Book hotel (approval required)
-  const hotel = await ctx.callTool('travel.book_hotel', {
-    hotel_id: 'HT-002', check_in: '2025-06-15', check_out: '2025-06-20',
-    guest: 'Demo User', _logical_operation: 'book-demo-hotel',
-  });
-
-  await ctx.writeState('bookings', { flight: flight.booking_ref, hotel: hotel.booking_ref });
-  await ctx.writeState('trip_status', 'confirmed');
-}
-
-// ════════════════════════════════════════════════════════════
-// Display helpers
-// ════════════════════════════════════════════════════════════
-
-function wait(msg = 'Press Enter to continue') {
-  return new Promise((resolve) => {
-    process.stdout.write(`\n${C.DIM}  ⏎ ${msg}...${C.RST}`);
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    rl.once('line', () => { rl.close(); resolve(); });
-  });
-}
-
-function showRows(label, headers, rows, color = C.C) {
-  if (!rows || rows.length === 0) {
-    console.log(`\n  ${color}${label}:${C.RST} ${C.DIM}(empty)${C.RST}`);
-    return;
-  }
-  console.log(`\n  ${color}${label} (${rows.length} rows):${C.RST}`);
-  for (const row of rows) {
-    const items = headers.map((h, i) => `${h}=${C.BOLD}${row[i]}${C.RST}`);
-    console.log(`    ${C.DIM}${items.join(' | ')}${C.RST}`);
-  }
-}
-
-function showDB(store, runID) {
-  // Runs
-  const runData = store.run(runID);
-  const runRows = [];
-  if (runData) {
-    const shortID = runData.run_id.length > 24 ? runData.run_id.slice(0, 24) + '...' : runData.run_id;
-    runRows.push([shortID, runData.status, String(runData.state_version)]);
-  }
-  showRows('Runs', ['run_id', 'status', 'state_version'], runRows, C.B);
-
-  // Steps
-  const steps = store.steps(runID);
-  const stepRows = steps.map(s => {
-    const shortID = s.step_id.length > 24 ? s.step_id.slice(0, 24) + '...' : s.step_id;
-    return [shortID, s.status, String(s.attempt)];
-  });
-  showRows('Steps', ['step_id', 'status', 'attempt'], stepRows, C.B);
-
-  // Tool Ledger
-  const ledger = store.ledger(runID);
-  const ledgerRows = ledger.map(tl => {
-    const key = tl.idempotency_key;
-    const parts = key.split(':');
-    const shortKey = parts.length >= 2 ? parts[parts.length - 2] + ':' + parts[parts.length - 1].slice(0, 10) : key.slice(0, 25);
-    return [tl.tool_name, tl.status, shortKey];
-  });
-  showRows('Tool Ledger', ['tool', 'status', 'idemp_key'], ledgerRows, C.Y);
-
-  // Approval requests
-  const approvals = store.approvalRequests(runID);
-  const approvalRows = approvals.map(a => [a.tool_name, a.status, a.approved_by || '-']);
-  showRows('Approval Requests', ['tool', 'status', 'approved_by'], approvalRows, C.R);
-
-  console.log();
-}
-
-// ════════════════════════════════════════════════════════════
-// Main
-// ════════════════════════════════════════════════════════════
-
-async function main() {
-  const root = process.argv[2] || '.agentledger-ts';
-
-  // Intro
-  console.log(`\n${C.BOLD}${C.C}  ╔════════════════════════════════════════════════════╗${C.RST}`);
-  console.log(`${C.BOLD}${C.C}  ║   AgentLedger Travel Assistant (TS) — Interactive Demo  ║${C.RST}`);
-  console.log(`${C.BOLD}${C.C}  ║   See real database state at every step                 ║${C.RST}`);
-  console.log(`${C.BOLD}${C.C}  ╚════════════════════════════════════════════════════╝${C.RST}`);
-
-  console.log(`\n  ${C.DIM}AgentLedger — Durable Execution Runtime for AI Agents${C.RST}`);
-  console.log(`  ┌────────────────────────────────────────────────────┐`);
-  console.log(`  │  ${C.G}✓${C.RST} Durable execution — crash recovery              │`);
-  console.log(`  │  ${C.G}✓${C.RST} Tool Ledger — idempotent replay                │`);
-  console.log(`  │  ${C.G}✓${C.RST} Approval gates — human-in-the-loop              │`);
-  console.log(`  │  ${C.G}✓${C.RST} Policy engine — role-based access               │`);
-  console.log(`  │  ${C.G}✓${C.RST} Budget control — tool call limits               │`);
-  console.log(`  │  ${C.G}✓${C.RST} Evidence export — full audit trail              │`);
-  console.log(`  └────────────────────────────────────────────────────┘`);
-
-  await wait('Press Enter to start / 按 Enter 开始');
-
-  // ════════════════════════════════════════════════════════
-  // Step 1: Setup
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.B}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.B}  Step 1: Initialize — Register tools, configure policy${C.RST}`);
-  console.log(`${C.BOLD}${C.B}${'═'.repeat(60)}${C.RST}`);
-
-  const store = await JSONStore.open(`${root}/state.json`);
-  const rt = new Runtime(store);
-  rt.setBudget({ maxToolCalls: 25 });
-
-  for (const t of ['travel.search_flights', 'travel.search_hotels', 'travel.check_weather',
-    'travel.book_flight', 'travel.book_hotel']) {
-    rt.policy.allowTool('TravelPlanner', t);
-  }
-
-  rt.registerTool({
-    name: 'travel.search_flights', version: 'v1', sideEffect: 'none', riskLevel: 'low',
-    inputSchema: { type: 'object', required: ['from', 'to'] },
-    outputSchema: { type: 'object' },
-    func: searchFlights,
-  });
-  rt.registerTool({
-    name: 'travel.search_hotels', version: 'v1', sideEffect: 'none', riskLevel: 'low',
-    inputSchema: { type: 'object', required: ['city'] },
-    outputSchema: { type: 'object' },
-    func: searchHotels,
-  });
-  rt.registerTool({
-    name: 'travel.check_weather', version: 'v1', sideEffect: 'none', riskLevel: 'low',
-    inputSchema: { type: 'object', required: ['city'] },
-    outputSchema: { type: 'object' },
-    func: checkWeather,
-  });
-  rt.registerTool({
-    name: 'travel.book_flight', version: 'v1', sideEffect: 'external_write', riskLevel: 'high',
-    idempotencyRequired: true, approvalRequired: true,
-    inputSchema: { type: 'object', required: ['flight_id', 'passenger'] },
-    outputSchema: { type: 'object' },
-    func: bookFlight,
-  });
-  rt.registerTool({
-    name: 'travel.book_hotel', version: 'v1', sideEffect: 'external_write', riskLevel: 'high',
-    idempotencyRequired: true, approvalRequired: true,
-    inputSchema: { type: 'object', required: ['hotel_id', 'guest'] },
-    outputSchema: { type: 'object' },
-    func: bookHotel,
-  });
-
-  const { runId } = await rt.createRun({ trip: 'Tokyo', budget_usd: 3000 });
-  console.log(`\n  ${C.B}Run created: ${C.BOLD}${runId}${C.RST}`);
-  showDB(store, runId);
-  await wait('Press Enter to continue');
-
-  // ════════════════════════════════════════════════════════
-  // Step 2: Attempt 1 — Approval interception
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.R}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.R}  Step 2: Attempt 1 — Agent runs → Approval triggered${C.RST}`);
-  console.log(`${C.BOLD}${C.R}${'═'.repeat(60)}${C.RST}`);
-  console.log(`\n  ${C.DIM}Agent executing: search flights → search hotels → check weather → book flight...${C.RST}`);
-
-  await rt.runOnce({ runId, workerId: 'worker-node', agentRole: 'TravelPlanner', agent: travelPlanner });
-
-  console.log(`\n  ${C.R}book_flight triggered approval! Runtime paused, waiting for human.${C.RST}`);
-  showDB(store, runId);
-  console.log(`  ${C.R}Note: Tool Ledger has RESERVED entry, approval status is PENDING${C.RST}`);
-  await wait('Press Enter to approve / 按 Enter 审批');
-
-  for (const req of store.approvalRequests(runId)) {
-    if (req.status === 'PENDING') {
-      await store.approveRequest(req.approval_id, { approver: 'traveler', reason: 'Within budget, approved' });
-      console.log(`\n  ${C.G}✅ Approved: ${req.tool_name} — by traveler${C.RST}`);
-    }
-  }
-  showDB(store, runId);
-  await wait('Press Enter to continue');
-
-  // ════════════════════════════════════════════════════════
-  // Step 3: Attempt 2 — Execute + Crash
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.Y}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.Y}  Step 3: Attempt 2 — Approved → Execute booking → Simulated crash${C.RST}`);
-  console.log(`${C.BOLD}${C.Y}${'═'.repeat(60)}${C.RST}`);
-  console.log(`\n  ${C.DIM}Re-running agent (approval passed, book_flight will execute)...${C.RST}`);
-
-  await rt.runOnce({ runId, workerId: 'worker-node', agentRole: 'TravelPlanner', agent: travelPlanner });
-
-  console.log(`\n  ${C.Y}Agent booked flight, then crashed before committing state!${C.RST}`);
-  console.log(`  ${C.Y}Flight is booked in external system, but agent state was NOT persisted.${C.RST}`);
-  showDB(store, runId);
-  console.log(`  ${C.Y}Key: Tool Ledger book_flight status = ${C.G}SUCCEEDED${C.Y} (external side effect executed)${C.RST}`);
-  console.log(`  ${C.Y}      Step status = retry_scheduled (state not committed, waiting for retry)${C.RST}`);
-  await wait('Press Enter to continue');
-
-  // ════════════════════════════════════════════════════════
-  // Step 4: Attempt 3 — Recovery + Hotel approval
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.G}  Step 4: Attempt 3 — Crash recovery → Tool Ledger idempotent replay${C.RST}`);
-  console.log(`${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-  console.log(`\n  ${C.DIM}Agent re-executes. book_flight: Tool Ledger sees SUCCEEDED record...${C.RST}`);
-  console.log(`  ${C.DIM}${C.G}→ Returns cached result, no duplicate API call, no double charge!${C.RST}`);
-
-  await rt.runOnce({ runId, workerId: 'worker-node', agentRole: 'TravelPlanner', agent: travelPlanner });
-
-  console.log(`\n  ${C.G}✅ Flight idempotent replay successful! (no duplicate _book_flight call)${C.RST}`);
-  console.log(`  ${C.R}Hotel booking → triggers approval again${C.RST}`);
-
-  for (const req of store.approvalRequests(runId)) {
-    if (req.status === 'PENDING') {
-      await store.approveRequest(req.approval_id, { approver: 'traveler', reason: 'Hotel within budget, approved' });
-      console.log(`\n  ${C.G}✅ Approved: ${req.tool_name} — by traveler${C.RST}`);
-    }
-  }
-  showDB(store, runId);
-  await wait('Press Enter to continue');
-
-  // ════════════════════════════════════════════════════════
-  // Step 5: Attempt 4 — Complete
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.G}  Step 5: Attempt 4 — Hotel approved → Full execution → State committed${C.RST}`);
-  console.log(`${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-
-  const ok = await rt.runOnce({ runId, workerId: 'worker-node', agentRole: 'TravelPlanner', agent: travelPlanner });
-  if (!ok) {
-    console.error('Recovery failed');
-    process.exit(1);
-  }
-  if (Object.keys(bookingDB).length !== 2) {
-    console.error(`Expected 2 bookings, got ${Object.keys(bookingDB).length}`);
-    process.exit(1);
-  }
-
-  console.log(`\n  ${C.G}✅ Travel planning complete! State persisted to database.${C.RST}`);
-  showDB(store, runId);
-  console.log(`  ${C.G}Step status = completed, State has bookings + trip_status${C.RST}`);
-  console.log(`  ${C.G}External bookings: [${Object.keys(bookingDB).join(', ')}] (2 total, no duplicates)${C.RST}`);
-  await wait('Press Enter to continue');
-
-  // ════════════════════════════════════════════════════════
-  // Step 6: Evidence + Cost + Replay
-  // ════════════════════════════════════════════════════════
-  console.log(`\n${C.BOLD}${C.M}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.M}  Step 6: Evidence export + Cost attribution + Replay verification${C.RST}`);
-  console.log(`${C.BOLD}${C.M}${'═'.repeat(60)}${C.RST}`);
-
-  const bundle = exportEvidence(store, runId);
-  const replayResult = replay(store, runId);
-  const cost = costAttribution(store, runId);
-
-  console.log(`\n  ${C.M}Cost attribution: ${cost.total?.tool_calls ?? 0} tool calls${C.RST}`);
-  console.log(`  ${C.M}Replay: ${replayResult.event_count} events, safe=${C.G}${replayResult.replay_safe}${C.RST}`);
-  console.log(`  ${C.M}Evidence bundle: ${bundle.events.length} events total${C.RST}`);
-
-  // Final summary
-  console.log(`\n${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-  console.log(`${C.BOLD}${C.G}  Summary: What AgentLedger (TypeScript) did in this demo${C.RST}`);
-  console.log(`${C.BOLD}${C.G}${'═'.repeat(60)}${C.RST}`);
-  console.log(`
-  ┌──────────────────────────────────────────────────────────┐
-  │                                                          │
-  │  ${C.G}✓ Durable execution${C.RST}  Crash → auto retry, state preserved         │
-  │                   Step: retry_scheduled → completed           │
-  │                                                          │
-  │  ${C.G}✓ Tool Ledger${C.RST}      Idempotent replay, flight booked ${C.BOLD}1x${C.RST} only       │
-  │                   SUCCEEDED → cached result on retry        │
-  │                                                          │
-  │  ${C.G}✓ Approval gates${C.RST}    Flight + hotel each trigger approval          │
-  │                   approval_requests records in store        │
-  │                                                          │
-  │  ${C.G}✓ Policy engine${C.RST}     Each tool call checked by policy             │
-  │                   TravelPlanner role allowed              │
-  │                                                          │
-  │  ${C.G}✓ Budget control${C.RST}    Tracked ${cost.total?.tool_calls ?? 0} tool calls                       │
-  │                   BudgetController.beforeToolCall()       │
-  │                                                          │
-  │  ${C.G}✓ Evidence export${C.RST}   ${bundle.events.length} events recorded                         │
-  │                   events stored in JSON store              │
-  │                                                          │
-  │  ${C.G}✓ Cost attribution${C.RST}  Auto-recorded per run                        │
-  │                   CostAttribution by agent                │
-  │                                                          │
-  │  ${C.G}✓ Replay engine${C.RST}     Event hash verification passed                │
-  │                   Verify history without re-running       │
-  │                                                          │
-  └──────────────────────────────────────────────────────────┘
-`);
-
-  console.log(`  ${C.DIM}Storage file: ${root}/state.json${C.RST}`);
-  console.log(`  ${C.DIM}Run: node typescript/examples/travel_assistant/travel_assistant.js${C.RST}`);
-  console.log();
-}
-
-main().catch(err => { console.error(err); process.exit(1); });

package/test/runtime.test.js

@@ -1,272 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import test from 'node:test';
-import { JSONStore, LocalBlobStore, LocalWorker, RetryableAgentError, Runtime, WorkerService, exportEvidence, replay, costAttribution, failureAttribution } from '../src/index.js';
-
-test('runtime creates durable run, evidence, and replay summary', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'agentledger-ts-'));
-  const path = join(dir, 'state.json');
-  const rt = await Runtime.local(path);
-  rt.registerTool({ name: 'docs.echo', func: async (args) => ({ echo: args.text }) });
-  const { runId } = await rt.createRun({ input: 'hello' });
-  const ok = await rt.runOnce({
-    runId,
-    workerId: 'worker-a',
-    agentRole: 'Researcher',
-    agent: async (ctx, state) => {
-      const result = await ctx.callTool('docs.echo', { text: state.input });
-      await ctx.writeState('tool_result', result);
-    },
-  });
-  assert.equal(ok, true);
-  await readFile(path, 'utf8');
-  const reopened = await JSONStore.open(path);
-  assert.deepEqual(reopened.finalState(runId).tool_result, { echo: 'hello' });
-  const bundle = exportEvidence(reopened, runId);
-  assert.equal(bundle.schema_version, 'agentledger.evidence.v1');
-  assert.ok(bundle.bundle_hash);
-  const summary = replay(reopened, runId);
-  assert.equal(summary.replay_safe, true);
-  assert.equal(summary.event_count, bundle.events.length);
-  assert.equal(summary.tool_call_count, 2);
-});
-
-test('local blob store roundtrips JSON-compatible values', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'agentledger-ts-blobs-'));
-  const blobs = await LocalBlobStore.open(dir);
-  const value = { hello: 'world', nested: { n: 1 } };
-  const first = await blobs.putJSON(value);
-  const second = await blobs.putJSON(value);
-  assert.ok(first.digest.startsWith('sha256:'));
-  assert.ok(first.ref.startsWith('blob://sha256/'));
-  assert.deepEqual(first, second);
-  assert.deepEqual(await blobs.getJSON(first.ref), value);
-  await assert.rejects(() => blobs.getJSON('unsupported://blob'), /unsupported blob ref/);
-});
-
-test('tool schema validation rejects invalid input before execution', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  let calls = 0;
-  rt.registerTool({
-    name: 'docs.echo',
-    inputSchema: { type: 'object', required: ['text'], additionalProperties: false, properties: { text: { type: 'string', minLength: 1 } } },
-    outputSchema: { type: 'object', required: ['echo'], additionalProperties: false, properties: { echo: { type: 'string' } } },
-    func: async (args) => { calls += 1; return { echo: args.text }; },
-  });
-  const { runId } = await rt.createRun({});
-  await assert.rejects(() => rt.runOnce({ runId, agentRole: 'SchemaAgent', agent: (ctx) => ctx.callTool('docs.echo', {}) }), /required/);
-  assert.equal(calls, 0);
-  assert.equal(rt.store.events(runId).some((event) => event.type === 'tool_call_failed' && event.payload.phase === 'input_validation'), true);
-});
-
-test('tool ledger idempotency reuses side effect response across retry', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  let calls = 0;
-  rt.registerTool({
-    name: 'github.create_pr',
-    sideEffect: 'external',
-    idempotencyRequired: true,
-    func: async (args) => {
-      calls += 1;
-      return { external_id: 'pr-123', title: args.title };
-    },
-  });
-  const { runId } = await rt.createRun({ title: 'runtime parity' });
-  const agent = async (ctx, state) => {
-    const result = await ctx.callTool('github.create_pr', { title: state.title });
-    if (ctx.attempt === 1) throw new RetryableAgentError('crash after side effect');
-    await ctx.writeState('pr', result);
-  };
-  assert.equal(await rt.runOnce({ runId, agent }), false);
-  assert.equal(await rt.runOnce({ runId, workerId: 'worker-b', agent }), true);
-  assert.equal(calls, 1);
-  assert.equal(rt.store.ledger(runId).length, 1);
-  assert.equal(rt.store.ledger(runId)[0].status, 'SUCCEEDED');
-});
-
-test('policy denies unapproved high-risk tool before execution', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  let calls = 0;
-  rt.registerTool({ name: 'repo.write', riskLevel: 'high', func: async () => { calls += 1; return { ok: true }; } });
-  const { runId } = await rt.createRun({});
-  await assert.rejects(() => rt.runOnce({ runId, agentRole: 'Reviewer', agent: (ctx) => ctx.callTool('repo.write', { path: 'README.md' }) }), /high-risk tool denied/);
-  assert.equal(calls, 0);
-  assert.equal(rt.store.events(runId).some((event) => event.type === 'tool_permission_decided' && event.payload.allowed === false), true);
-  assert.equal(rt.store.steps(runId)[0].status, 'failed');
-});
-
-test('approval pauses and resumes step', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  let calls = 0;
-  rt.registerTool({
-    name: 'github.create_pr',
-    riskLevel: 'high',
-    approvalRequired: true,
-    sideEffect: 'external',
-    idempotencyRequired: true,
-    func: async () => { calls += 1; return { external_id: 'pr-42' }; },
-  });
-  const { runId } = await rt.createRun({});
-  const agent = async (ctx) => {
-    const result = await ctx.callTool('github.create_pr', { title: 'safe' });
-    await ctx.writeState('pr', result);
-  };
-  assert.equal(await rt.runOnce({ runId, workerId: 'worker-a', agentRole: 'Coder', agent }), false);
-  assert.equal(calls, 0);
-  const approvals = rt.store.approvalRequests(runId);
-  assert.equal(approvals.length, 1);
-  assert.equal(approvals[0].status, 'PENDING');
-  assert.equal(rt.store.steps(runId)[0].status, 'waiting_human');
-  await rt.store.approveRequest(approvals[0].approval_id, { approver: 'alice', reason: 'reviewed' });
-  assert.equal(await rt.runOnce({ runId, workerId: 'worker-b', agentRole: 'Coder', agent }), true);
-  assert.equal(calls, 1);
-
-  const { runId: deniedRun } = await rt.createRun({});
-  assert.equal(await rt.runOnce({ runId: deniedRun, workerId: 'worker-c', agentRole: 'Coder', agent }), false);
-  await rt.store.denyRequest(rt.store.approvalRequests(deniedRun)[0].approval_id, { approver: 'bob', reason: 'not allowed' });
-  assert.equal(rt.store.steps(deniedRun)[0].status, 'failed');
-});
-
-test('sandbox-required tool fails closed without executor', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  let calls = 0;
-  rt.registerTool({ name: 'shell.exec', sandboxRequired: true, func: async () => { calls += 1; return { ok: true }; } });
-  const { runId } = await rt.createRun({});
-  await assert.rejects(() => rt.runOnce({ runId, agentRole: 'Executor', agent: (ctx) => ctx.callTool('shell.exec', { argv: ['echo', 'hi'] }) }), /sandbox executor/);
-  assert.equal(calls, 0);
-  assert.equal(rt.store.events(runId).some((event) => event.type === 'sandbox_started'), true);
-  assert.equal(rt.store.events(runId).some((event) => event.type === 'tool_call_failed'), true);
-});
-
-test('cost budget and failure attribution are recorded', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  rt.setBudget({ maxToolCalls: 1 });
-  let calls = 0;
-  rt.registerTool({ name: 'docs.echo', func: async (args) => { calls += 1; return { echo: args.text }; } });
-  const { runId } = await rt.createRun({});
-  await assert.rejects(() => rt.runOnce({
-    runId,
-    agentRole: 'Researcher',
-    agent: async (ctx) => {
-      await ctx.recordModelCall({ model: 'gpt-test', inputTokens: 10, outputTokens: 5, totalUsd: 0.01 });
-      await ctx.callTool('docs.echo', { text: 'first' });
-      await ctx.callTool('docs.echo', { text: 'second' });
-    },
-  }), /tool call budget exceeded/);
-  assert.equal(calls, 1);
-  const summary = rt.store.costSummary(runId);
-  assert.equal(summary.tool_calls, 1);
-  assert.equal(summary.model_tokens, 15);
-  assert.equal(summary.total_usd, 0.01);
-  const cost = costAttribution(rt.store, runId);
-  assert.equal(cost.by_agent.Researcher.tool_calls, 1);
-  assert.equal(cost.by_agent.Researcher.model_tokens, 15);
-  const failure = failureAttribution(rt.store, runId);
-  assert.equal(failure.summary.failed_step_count, 1);
-  assert.equal(failure.failure_events.some((event) => event.type === 'budget_check_failed'), true);
-  assert.equal(failure.failure_events.some((event) => event.type === 'failure_classified'), true);
-});
-
-test('media and stream artifacts are indexed in evidence and replay', async () => {
-  const rt = new Runtime(JSONStore.memory());
-  const { runId } = await rt.createRun({});
-  const ok = await rt.runOnce({
-    runId,
-    workerId: 'worker-media',
-    agentRole: 'MediaAgent',
-    agent: async (ctx) => {
-      const frame = await ctx.createMediaArtifact('frame-0001', 'frame', {
-        uri: 's3://media/demo/frame-0001.jpg',
-        mediaMetadata: { mime_type: 'image/jpeg', frame_index: 1 },
-        lineage: { source_blob_refs: ['s3://media/demo/input.mp4'], tool_call_ids: ['video.extract_frames'] },
-      });
-      const checkpoint = await ctx.createStreamCheckpoint('camera-checkpoint', {
-        streamId: 'camera-1',
-        consumerId: 'vision-agent',
-        offset: 7,
-        watermark: 1.5,
-        chunk: { streamId: 'camera-1', chunkId: 'chunk-7', offset: 7, contentRef: 'blob://sha256/chunk-7.json', sequence: 7 },
-        backpressure: { recommended_pause_ms: 100 },
-      });
-      await ctx.writeState('artifacts', { frame, checkpoint });
-    },
-  });
-  assert.equal(ok, true);
-  const bundle = exportEvidence(rt.store, runId);
-  assert.equal(bundle.summary.artifact_count, 2);
-  assert.equal(bundle.summary.media_artifact_count, 1);
-  assert.equal(bundle.summary.stream_checkpoint_count, 1);
-  assert.equal(bundle.media_artifacts[0].kind, 'frame');
-  assert.equal(bundle.stream_checkpoints[0].stream_id, 'camera-1');
-  const summary = replay(rt.store, runId);
-  assert.equal(summary.artifact_count, 2);
-  assert.equal(summary.media_artifact_count, 1);
-  assert.equal(summary.stream_checkpoint_count, 1);
-});
-
-test('lease recovery fences previous owner', async () => {
-  const store = JSONStore.memory();
-  const { runId, stepId } = await store.createRun({});
-  const claim = await store.claimStep({ workerId: 'stale-worker', runId, leaseSeconds: 0 });
-  assert.equal(await store.recoverExpiredLeases(), 1);
-  await assert.rejects(() => store.commitStatePatch({ runId, stepId, leaseToken: claim.lease_token, baseVersion: 0, patch: { late: true } }), /invalid or stale lease token/);
-  const next = await store.claimStep({ workerId: 'new-worker', runId, leaseSeconds: 60 });
-  assert.equal(next.step_id, stepId);
-});
-
-test('cancellation fences worker', async () => {
-  const store = JSONStore.memory();
-  const { runId, stepId } = await store.createRun({});
-  const claim = await store.claimStep({ workerId: 'worker', runId, leaseSeconds: 60 });
-  assert.equal(await store.cancelRun(runId, 'operator requested'), 1);
-  await assert.rejects(() => store.commitStatePatch({ runId, stepId, leaseToken: claim.lease_token, baseVersion: 0, patch: { late: true } }), /invalid or stale lease token/);
-});
-
-test('contract fixture is readable and includes TypeScript target', async () => {
-  const contract = JSON.parse(await readFile(new URL('../../contracts/agentledger.runtime.v1.json', import.meta.url), 'utf8'));
-  assert.equal(contract.contract_version, '1.0');
-  assert.ok(contract.language_targets.some((target) => target.language === 'typescript'));
-});
-
-test('shared runtime baseline fixture covers preview scenarios', async () => {
-  const fixture = JSON.parse(await readFile(new URL('../../contracts/conformance/runtime_baseline.v1.json', import.meta.url), 'utf8'));
-  assert.equal(fixture.schema_version, 'agentledger.conformance.runtime_baseline.v1');
-  assert.equal(fixture.contract_version, '1.0');
-  const names = new Set(fixture.required_scenarios.map((scenario) => scenario.name));
-  for (const name of ['durable_run_evidence_replay', 'tool_ledger_idempotent_retry', 'lease_recovery_fences_stale_worker', 'cancellation_fences_worker']) assert.equal(names.has(name), true, `missing shared fixture scenario ${name}`);
-  for (const scenario of fixture.required_scenarios) assert.ok(scenario.required_assertions.length > 0, `scenario ${scenario.name} should define assertions`);
-});
-
-test('shared parity fixtures cover implemented scenarios', async () => {
-  const fixtures = {
-    'policy_approval_sandbox.v1.json': ['agentledger.conformance.policy_approval_sandbox.v1', 'policy_denies_unapproved_high_risk_tool', 'approval_pauses_and_resumes_step', 'sandbox_required_tool_fails_closed'],
-    'cost_failure_attribution.v1.json': ['agentledger.conformance.cost_failure_attribution.v1', 'tool_and_model_cost_attributed_to_run_step_role', 'budget_exhaustion_blocks_execution', 'failure_attribution_classifies_agent_tool_model_runtime'],
-    'local_persistence.v1.json': ['agentledger.conformance.local_persistence.v1', 'local_store_round_trips_completed_run', 'local_store_preserves_evidence_replay_chain', 'local_store_uses_atomic_snapshot_write'],
-    'local_blob_store.v1.json': ['agentledger.conformance.local_blob_store.v1', 'blob_roundtrip_json_value', 'blob_content_address_is_stable', 'blob_bad_ref_is_rejected'],
-    'tool_schema_validation.v1.json': ['agentledger.conformance.tool_schema_validation.v1', 'invalid_tool_input_rejected_before_execution', 'valid_tool_input_and_output_pass', 'invalid_tool_output_rejected'],
-    'worker_service.v1.json': ['agentledger.conformance.worker_service.v1', 'local_worker_runs_until_terminal', 'worker_service_stops_after_idle_poll', 'worker_loop_recovers_expired_leases'],
-    'media_stream_artifacts.v1.json': ['agentledger.conformance.media_stream_artifacts.v1', 'media_artifact_ref_is_indexed_in_evidence', 'stream_checkpoint_ref_is_indexed_in_evidence'],
-    'evidence_consumers.v1.json': ['agentledger.conformance.evidence_consumers.v1', 'trace_spans_from_evidence', 'evidence_diff_detects_state_and_event_changes', 'divergence_report_lists_changed_dimensions', 'static_debug_summary_is_exportable'],
-    'static_debug_html.v1.json': ['agentledger.conformance.static_debug_html.v1', 'static_debug_html_contains_run_events_and_state'],
-    'ops_readiness.v1.json': ['agentledger.conformance.ops_readiness.v1', 'retention_plan_is_non_destructive_and_counts_evidence', 'backup_readiness_reports_required_checks'],
-    'storage_schema.v1.json': ['agentledger.conformance.storage_schema.v1', 'latest_schema_version_and_ddl_are_available'],
-    'mcp_adapters.v1.json': ['agentledger.conformance.mcp_adapters.v1', 'in_memory_mcp_tool_server_lists_and_calls_tools', 'mcp_tool_descriptor_maps_to_tool_spec', 'in_memory_mcp_context_server_reads_resources'],
-    'framework_adapters.v1.json': ['agentledger.conformance.framework_adapters.v1', 'function_adapter_maps_run_spec_and_invokes_agent', 'method_framework_adapter_uses_first_available_method_and_writes_output'],
-    'otlp_trace_export.v1.json': ['agentledger.conformance.otlp_trace_export.v1', 'otlp_json_contains_resource_scope_and_spans'],
-    'simple_api.v1.json': ['agentledger.conformance.simple_api.v1', 'simple_run_returns_output_and_state'],
-    'boundary_lint.v1.json': ['agentledger.conformance.boundary_lint.v1', 'direct_shell_and_http_calls_are_reported', 'ignored_lines_are_not_reported'],
-    'scheduler.v1.json': ['agentledger.conformance.scheduler.v1', 'scheduler_status_reports_run_steps_and_cost', 'scheduler_recover_and_cancel_delegate_to_store'],
-    'adversarial_review.v1.json': ['agentledger.conformance.adversarial_review.v1', 'clean_evidence_passes_blocker_review', 'pending_high_risk_approval_blocks_review', 'max_total_usd_limit_blocks_review'],
-    'evidence_regression.v1.json': ['agentledger.conformance.evidence_regression.v1', 'evidence_health_checks_pass_for_clean_bundle', 'regression_detects_final_state_and_event_type_changes', 'regression_cost_delta_limit_blocks'],
-    'failure_injection.v1.json': ['agentledger.conformance.failure_injection.v1', 'retry_exhaustion_marks_run_failed', 'lease_fencing_rejects_stale_commit', 'cancellation_fencing_rejects_late_commit', 'side_effect_idempotency_executes_once_across_retry'],
-    'shadow.v1.json': ['agentledger.conformance.shadow.v1', 'shadow_state_diff_reports_changed_keys', 'shadow_report_carries_source_shadow_and_ok'],
-    'repro.v1.json': ['agentledger.conformance.repro.v1', 'builtin_golden_names_are_available', 'minimal_success_golden_is_valid_evidence', 'golden_regression_detects_changed_final_state'],
-    'time_travel.v1.json': ['agentledger.conformance.time_travel.v1', 'timeline_reconstructs_state_at_selected_seq', 'timeline_marks_state_changed_frames', 'time_travel_report_exports_static_html'],
-  };
-  for (const [file, required] of Object.entries(fixtures)) {
-    const body = await readFile(new URL(`../../contracts/conformance/${file}`, import.meta.url), 'utf8');
-    for (const token of required) assert.ok(body.includes(token), `fixture ${file} missing ${token}`);
-  }
-});