@adjudicate/adapter-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Rodolpho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @adjudicate/adapter-core
+
+Provider-neutral orchestration for `adjudicate`-backed LLM agents.
+
+The loop, bridge, decision translator, persistence shims, and error taxonomy live here. Provider adapters (`@adjudicate/anthropic`, `@adjudicate/openai`, …) each implement a `ProviderBridge<H>` against their SDK and re-export a thin `createAdjudicatedAgent` that wires it into this loop.
+
+## Layout
+
+```
+src/
+  loop.ts          ← runAdjudicatedLoop — send/resume/confirm orchestrator
+  bridge.ts        ← classifyIncomingToolUse + buildEnvelopeFromToolUse
+  decisions.ts     ← Decision → ToolResultBlock + LoopAction translator
+  persistence.ts   ← DeferRedis, ParkRedis, ConfirmationStore (+ in-mem shims)
+  errors.ts        ← AdapterError + AdapterErrorCode
+  types.ts         ← ProviderBridge<H>, AssistantTurn, ToolResultBlock, …
+  index.ts         ← barrel
+```
+
+## Invariants the loop preserves
+
+These are the same load-bearing properties the kernel demands. Any provider adapter built on this loop inherits them:
+
+1. **Every intent envelope crosses `adjudicateAndAudit()`.** No bypass, no taint elevation, no guard-ordering short-circuit.
+2. **First non-continue Decision wins** per assistant turn. Subsequent `tool_use` blocks in the same turn are surfaced as `not_processed_due_to_pause`.
+3. **REWRITE executes the rewritten envelope**, never the original.
+4. **DEFER persists full envelope fields** (version/nonce/taint/actorPrincipal). The resume side re-derives `intentHash` and detects tampering.
+5. **REQUEST_CONFIRMATION blobs are hash-verified** at `confirm()`. Tampered blobs refuse to resume.
+6. **History `H` is opaque to the loop.** The bridge is the only thing that knows the SDK-specific conversation shape; the loop threads it.
+
+## Provider adapters
+
+Implement the `ProviderBridge<H>` contract:
+
+```ts
+interface ProviderBridge<H> {
+  emptyHistory(): H;
+  appendUserMessage(history: H, text: string): H;
+  send(
+    history: H,
+    request: { systemPrompt: string; maxTokens: number; toolSchemas: ReadonlyArray<ToolSchema> },
+  ): Promise<{ history: H; turn: AssistantTurn }>;
+  appendToolResults(history: H, results: ReadonlyArray<ToolResultBlock>): H;
+}
+```
+
+Reference implementations:
+- `@adjudicate/anthropic` — `H = ReadonlyArray<MessageParam>`
+- `@adjudicate/openai` — `H = ReadonlyArray<OpenAIMessage>`
+
+Adding a new provider is a < 200-line PR: a bridge module plus a renderer.
+
+## Status
+
+Shipped at adapter-core v0.6. Contracts stable. `ProviderBridge<H>` may gain optional methods for streaming / cancellation in future minor versions; existing implementations continue to compile.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@adjudicate/adapter-core",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@adjudicate/core": "1.0.0",
+    "@adjudicate/audit": "1.0.0",
+    "@adjudicate/runtime": "0.1.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.0.0",
+    "@vitest/coverage-v8": "^3.2.0",
+    "eslint": "^9.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0",
+    "@adjudicate/pack-payments-pix": "0.1.0",
+    "@adjudicate/eslint-config": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsc --outDir dist",
+    "lint": "tsc --noEmit && eslint \"src/**/*.ts\"",
+    "test": "vitest run"
+  }
+}

package/src/bridge.ts

@@ -0,0 +1,111 @@
+/**
+ * Bridge module — the boundary between provider tool-use blocks and
+ * adjudicate's `IntentEnvelope`s.
+ *
+ * Convention: intent-kind tool name (e.g. `pix.charge.create`) is
+ * translated to a wire-friendly form by replacing `.` with `_` (most
+ * provider APIs forbid dots in tool names). The renderer applies the
+ * translation outbound; `classifyIncomingToolUse` accepts either the
+ * translated form (live API path) or the raw dotted form (mocked-test
+ * path) so test harnesses that bypass the renderer continue to work.
+ *
+ * Taint is ALWAYS `"UNTRUSTED"` for envelopes derived from LLM tool_use
+ * blocks. There is no path from this module that raises taint upward;
+ * TRUSTED intents (e.g. webhook confirmations) come from elsewhere.
+ */
+
+import { buildEnvelope, type IntentEnvelope, type Taint } from "@adjudicate/core";
+import type { Plan } from "@adjudicate/core/llm";
+
+/**
+ * Translate an intent-kind / READ-tool name to its wire-API form.
+ * Replaces `.` with `_` so names like `pix.charge.create` become
+ * `pix_charge_create`, matching the lowest-common-denominator tool-name
+ * pattern (`^[a-zA-Z0-9_-]+$`) that both Anthropic and OpenAI accept.
+ * No-op for names that already contain only API-allowed characters.
+ *
+ * Reversibility caveat: an intent kind `a.b` and a READ tool `a_b` both
+ * translate to `a_b` and become indistinguishable on the wire. Adopters
+ * who hit this collision should rename one of them; the Pack-conformance
+ * check (P2) surfaces the collision at install time.
+ */
+export function intentKindToApiName(name: string): string {
+  return name.replaceAll(".", "_");
+}
+
+export type ToolUseClassification =
+  | { readonly kind: "read"; readonly name: string; readonly input: unknown }
+  | {
+      readonly kind: "intent";
+      readonly intentKind: string;
+      readonly payload: unknown;
+    }
+  | { readonly kind: "out_of_plan"; readonly name: string };
+
+/**
+ * Decide whether an incoming `tool_use` is a READ tool execution, an
+ * intent proposal, or a hallucinated tool the planner did not advertise.
+ *
+ * Out-of-plan tool_uses translate to `isError: true` tool-results so the
+ * loop never silently fails — the model gets a recoverable signal.
+ *
+ * The match is forgiving: the planner exposes the raw (dotted) intent
+ * kind, the renderer ships the translated (underscored) form to the
+ * provider API, and the model echoes back the translated form on
+ * `tool_use`. We compare both raw and translated against each candidate
+ * so mocked-test paths (which skip the renderer translation) and
+ * live-API paths (which round-trip through translation) both work.
+ */
+export function classifyIncomingToolUse(
+  toolUse: { readonly name: string; readonly input: unknown },
+  plan: Plan,
+): ToolUseClassification {
+  const matchesName = (candidate: string): boolean =>
+    candidate === toolUse.name ||
+    intentKindToApiName(candidate) === toolUse.name;
+
+  const readMatch = plan.visibleReadTools.find(matchesName);
+  if (readMatch !== undefined) {
+    return { kind: "read", name: readMatch, input: toolUse.input };
+  }
+  const intentMatch = plan.allowedIntents.find(matchesName);
+  if (intentMatch !== undefined) {
+    return {
+      kind: "intent",
+      intentKind: intentMatch,
+      payload: toolUse.input,
+    };
+  }
+  return { kind: "out_of_plan", name: toolUse.name };
+}
+
+export interface BuildEnvelopeFromToolUseArgs {
+  readonly intentKind: string;
+  readonly payload: unknown;
+  readonly sessionId: string;
+  /**
+   * Taint of the proposing context. The loop pins this to `"UNTRUSTED"`
+   * for LLM-derived envelopes; this argument exists for symmetry with
+   * `buildEnvelope` and to keep the boundary explicit.
+   */
+  readonly taint: Taint;
+  readonly nonce: string;
+}
+
+/**
+ * Construct an IntentEnvelope from a provider-neutral tool_use. Wraps
+ * `buildEnvelope` from @adjudicate/core with adapter-specific defaults:
+ * principal = `"llm"`, taint as supplied (always `"UNTRUSTED"` from the
+ * loop).
+ */
+export function buildEnvelopeFromToolUse(
+  args: BuildEnvelopeFromToolUseArgs,
+): IntentEnvelope<string, unknown> {
+  return buildEnvelope({
+    kind: args.intentKind,
+    payload: args.payload,
+    actor: { principal: "llm", sessionId: args.sessionId },
+    taint: args.taint,
+    nonce: args.nonce,
+  });
+}

package/src/decisions.ts

@@ -0,0 +1,294 @@
+/**
+ * Decision → provider-neutral tool-result + loop-action translator.
+ *
+ * One branch per `Decision.kind`. Returns:
+ * - `toolResult` — the provider-neutral `ToolResultBlock` that goes back
+ *   to the model in the next user-role message (or `null` if no tool-
+ *   result is sent).
+ * - `loopAction` — what the loop should do next: `continue` (next
+ *   iteration), `pause_for_user_confirmation` / `pause_for_defer`
+ *   (return outcome to adopter), or `complete_for_escalation`
+ *   (terminate the turn).
+ * - `events` — `AgentEvent`s to push for audit / transcript display.
+ *
+ * **REWRITE** runs the executor against the *rewritten* envelope (NOT
+ * the original) and surfaces a human-readable note in the tool-result
+ * by default.
+ *
+ * **First non-continue Decision wins**: if multiple tool_use blocks fire
+ * in the same assistant turn, the loop processes them in order but
+ * stops translating the moment a non-continue Decision arrives. The
+ * remaining blocks are surfaced as `not_processed_due_to_pause`.
+ */
+
+import type { Decision, IntentEnvelope } from "@adjudicate/core";
+import { parkDeferredIntent } from "@adjudicate/runtime";
+import { AdapterError, AdapterErrorCode } from "./errors.js";
+import type {
+  ConfirmationStore,
+  DeferRedis,
+  ParkRedis,
+} from "./persistence.js";
+import type {
+  AdopterExecutor,
+  AgentEvent,
+  AgentLogger,
+  ToolResultBlock,
+} from "./types.js";
+
+export interface DecisionTranslationContext<K extends string, P, S, H> {
+  readonly decision: Decision;
+  readonly envelope: IntentEnvelope<K, P>;
+  readonly toolUseId: string;
+  readonly sessionId: string;
+  readonly state: S;
+  readonly executor: AdopterExecutor<K, P, S>;
+  readonly deferStore: DeferRedis & ParkRedis;
+  readonly confirmationStore: ConfirmationStore<H>;
+  readonly historySnapshot: H;
+  readonly rk: (raw: string) => string;
+  readonly log?: AgentLogger;
+  /**
+   * Per-turn token generator. Adapter passes `crypto.randomUUID()` by
+   * default; tests can inject a deterministic generator.
+   */
+  readonly generateToken: () => string;
+}
+
+export type LoopAction =
+  | { readonly kind: "continue" }
+  | {
+      readonly kind: "pause_for_user_confirmation";
+      readonly prompt: string;
+      readonly token: string;
+    }
+  | {
+      readonly kind: "pause_for_defer";
+      readonly signal: string;
+      readonly intentHash: string;
+    }
+  | {
+      readonly kind: "complete_for_escalation";
+      readonly to: "human" | "supervisor";
+      readonly reason: string;
+    };
+
+export interface DecisionTranslation {
+  readonly toolResult: ToolResultBlock | null;
+  readonly loopAction: LoopAction;
+  readonly extraEvents: ReadonlyArray<AgentEvent>;
+}
+
+/**
+ * Translate a `Decision` into a provider-neutral `ToolResultBlock` plus
+ * the next loop action. The caller (the send loop) appends the tool-
+ * result to the next user-role message and either continues or pauses
+ * based on `loopAction.kind`.
+ */
+export async function translateDecision<K extends string, P, S, H>(
+  ctx: DecisionTranslationContext<K, P, S, H>,
+): Promise<DecisionTranslation> {
+  switch (ctx.decision.kind) {
+    case "EXECUTE":
+      return runExecute(ctx, ctx.envelope, null);
+    case "REWRITE":
+      return runExecute(
+        ctx,
+        ctx.decision.rewritten as IntentEnvelope<K, P>,
+        ctx.decision.reason,
+      );
+    case "REFUSE": {
+      const text = ctx.decision.refusal.userFacing;
+      const result: ToolResultBlock = {
+        toolUseId: ctx.toolUseId,
+        content: text,
+        isError: true,
+      };
+      return {
+        toolResult: result,
+        loopAction: { kind: "continue" },
+        extraEvents: [
+          { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+        ],
+      };
+    }
+    case "REQUEST_CONFIRMATION": {
+      const token = ctx.generateToken();
+      await ctx.confirmationStore.put(
+        token,
+        {
+          envelope: ctx.envelope,
+          sessionId: ctx.sessionId,
+          assistantHistorySnapshot: ctx.historySnapshot,
+          toolUseId: ctx.toolUseId,
+          prompt: ctx.decision.prompt,
+        },
+        24 * 60 * 60,
+      );
+      const result: ToolResultBlock = {
+        toolUseId: ctx.toolUseId,
+        content: `Confirmation required: ${ctx.decision.prompt}`,
+      };
+      return {
+        toolResult: result,
+        loopAction: {
+          kind: "pause_for_user_confirmation",
+          prompt: ctx.decision.prompt,
+          token,
+        },
+        extraEvents: [
+          { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+        ],
+      };
+    }
+    case "ESCALATE": {
+      const result: ToolResultBlock = {
+        toolUseId: ctx.toolUseId,
+        content: `Escalated to ${ctx.decision.to}: ${ctx.decision.reason}`,
+      };
+      return {
+        toolResult: result,
+        loopAction: {
+          kind: "complete_for_escalation",
+          to: ctx.decision.to,
+          reason: ctx.decision.reason,
+        },
+        extraEvents: [
+          { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+        ],
+      };
+    }
+    case "DEFER": {
+      const ttlSeconds = Math.max(ctx.decision.timeoutMs, 1000) / 1000 + 60;
+      const parkResult = await parkDeferredIntent({
+        envelope: {
+          intentHash: ctx.envelope.intentHash,
+          kind: ctx.envelope.kind,
+          actor: { sessionId: ctx.envelope.actor.sessionId },
+          payload: ctx.envelope.payload,
+          // Hash-verification fields. The resume path re-derives intentHash
+          // via sha256Canonical and asserts byte-equality with the stored
+          // value — detects blob tampering between park and resume.
+          version: ctx.envelope.version,
+          nonce: ctx.envelope.nonce,
+          taint: ctx.envelope.taint,
+          actorPrincipal: ctx.envelope.actor.principal,
+        },
+        signal: ctx.decision.signal,
+        ttlSeconds,
+        redis: ctx.deferStore,
+        rk: ctx.rk,
+        log: ctx.log,
+      });
+      if (!parkResult.parked) {
+        const result: ToolResultBlock = {
+          toolUseId: ctx.toolUseId,
+          content: `This action could not be queued (per-session quota exceeded; ${parkResult.observed}/${parkResult.limit}).`,
+          isError: true,
+        };
+        return {
+          toolResult: result,
+          loopAction: { kind: "continue" },
+          extraEvents: [
+            { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+          ],
+        };
+      }
+      const result: ToolResultBlock = {
+        toolUseId: ctx.toolUseId,
+        content: `Action queued. Waiting for signal "${ctx.decision.signal}" (timeout ${ctx.decision.timeoutMs}ms).`,
+      };
+      return {
+        toolResult: result,
+        loopAction: {
+          kind: "pause_for_defer",
+          signal: ctx.decision.signal,
+          intentHash: ctx.envelope.intentHash,
+        },
+        extraEvents: [
+          { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+        ],
+      };
+    }
+  }
+}
+
+/**
+ * Shared EXECUTE / REWRITE path. Runs the adopter's executor against the
+ * envelope passed in (the original for EXECUTE, the rewritten one for
+ * REWRITE), serializes the result, and returns a continue-loop translation.
+ */
+async function runExecute<K extends string, P, S, H>(
+  ctx: DecisionTranslationContext<K, P, S, H>,
+  effectiveEnvelope: IntentEnvelope<K, P>,
+  rewriteReason: string | null,
+): Promise<DecisionTranslation> {
+  let executorResult: unknown;
+  try {
+    executorResult = await ctx.executor.invokeIntent(
+      effectiveEnvelope,
+      ctx.state,
+    );
+  } catch (err) {
+    const message =
+      err instanceof Error ? err.message : "executor threw a non-Error value";
+    const errResult: ToolResultBlock = {
+      toolUseId: ctx.toolUseId,
+      content: `Executor failed: ${message}`,
+      isError: true,
+    };
+    return {
+      toolResult: errResult,
+      loopAction: { kind: "continue" },
+      extraEvents: [
+        { kind: "tool_result", toolUseId: ctx.toolUseId, payload: errResult },
+      ],
+    };
+  }
+
+  const handlerEvent: AgentEvent = {
+    kind: "handler_result",
+    toolUseId: ctx.toolUseId,
+    result: executorResult,
+  };
+
+  const body =
+    rewriteReason === null
+      ? { ok: true, result: executorResult }
+      : {
+          ok: true,
+          result: executorResult,
+          note: `Note: kernel rewrote your proposal — ${rewriteReason}`,
+        };
+
+  const result: ToolResultBlock = {
+    toolUseId: ctx.toolUseId,
+    content: JSON.stringify(body),
+  };
+  return {
+    toolResult: result,
+    loopAction: { kind: "continue" },
+    extraEvents: [
+      handlerEvent,
+      { kind: "tool_result", toolUseId: ctx.toolUseId, payload: result },
+    ],
+  };
+}
+
+/**
+ * Build the provider-neutral `ToolResultBlock` for an out-of-plan tool
+ * call. Re-exported so tests + adopters can construct one from outside
+ * the loop.
+ */
+export function makeOutOfPlanToolResult(
+  toolUseId: string,
+  toolName: string,
+): ToolResultBlock {
+  return {
+    toolUseId,
+    content: `Tool "${toolName}" is not available in the current plan.`,
+    isError: true,
+  };
+}
+
+export { AdapterError, AdapterErrorCode };

package/src/errors.ts

@@ -0,0 +1,36 @@
+/**
+ * Error taxonomy for the provider-neutral adapter loop.
+ *
+ * Most failures inside the loop become `isError: true` tool-results
+ * surfaced back to the model (so it can recover gracefully). Errors
+ * thrown out of the adapter are reserved for adopter-visible
+ * misconfiguration or contract violations.
+ */
+
+export const AdapterErrorCode = {
+  OUT_OF_PLAN_TOOL_USE: "OUT_OF_PLAN_TOOL_USE",
+  EXECUTOR_FAILED: "EXECUTOR_FAILED",
+  INVALID_PAYLOAD: "INVALID_PAYLOAD",
+  MAX_ITERATIONS_EXCEEDED: "MAX_ITERATIONS_EXCEEDED",
+  CONFIRMATION_TOKEN_INVALID: "CONFIRMATION_TOKEN_INVALID",
+  RESUME_NO_PARKED: "RESUME_NO_PARKED",
+} as const;
+
+export type AdapterErrorCode =
+  (typeof AdapterErrorCode)[keyof typeof AdapterErrorCode];
+
+export class AdapterError extends Error {
+  readonly code: AdapterErrorCode;
+  readonly details?: Record<string, unknown>;
+
+  constructor(
+    code: AdapterErrorCode,
+    message: string,
+    details?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = "AdapterError";
+    this.code = code;
+    this.details = details;
+  }
+}

package/src/index.ts

@@ -0,0 +1,98 @@
+/**
+ * `@adjudicate/adapter-core` — provider-neutral orchestration for
+ * adjudicate-backed LLM agents.
+ *
+ * The loop, bridge, decision translator, persistence shims, and error
+ * taxonomy live here. Provider adapters (`@adjudicate/anthropic`,
+ * `@adjudicate/openai`, …) implement a `ProviderBridge<H>` against
+ * their SDK and re-export a thin `createAdjudicatedAgent` that wires
+ * it into this loop.
+ *
+ * Invariants the loop preserves:
+ *   - Every intent envelope crosses `adjudicateAndAudit()`. No bypass,
+ *     no taint elevation, no guard-ordering short-circuit.
+ *   - First non-continue Decision wins per assistant turn.
+ *   - History `H` is opaque to the loop; the bridge owns its shape.
+ *   - REWRITE executes the rewritten envelope, never the original.
+ *   - DEFER persists full envelope fields so resume can re-derive the
+ *     intentHash and detect tampering.
+ *
+ * Provider adapters MUST NOT bypass this loop. The kernel-side audit
+ * + ledger guarantees only hold when every adjudication flows here.
+ */
+
+export { createAdjudicatedAgent } from "./loop.js";
+export type {
+  AdjudicatedAgent,
+  AdjudicatedAgentOptions,
+  AdopterExecutor,
+  AgentEvent,
+  AgentLogger,
+  AgentOutcome,
+  AgentTurnResult,
+  AssistantTurn,
+  ConfirmArgs,
+  ProviderBridge,
+  ProviderRequest,
+  ResumeArgs,
+  SendInput,
+  ToolResultBlock,
+  ToolUseRequest,
+} from "./types.js";
+
+export {
+  buildEnvelopeFromToolUse,
+  classifyIncomingToolUse,
+  intentKindToApiName,
+} from "./bridge.js";
+export type {
+  BuildEnvelopeFromToolUseArgs,
+  ToolUseClassification,
+} from "./bridge.js";
+
+export {
+  makeOutOfPlanToolResult,
+  translateDecision,
+} from "./decisions.js";
+export type {
+  DecisionTranslation,
+  DecisionTranslationContext,
+  LoopAction,
+} from "./decisions.js";
+
+export {
+  createInMemoryConfirmationStore,
+  createInMemoryDeferStore,
+} from "./persistence.js";
+export type {
+  ConfirmationStore,
+  DeferRedis,
+  ParkRedis,
+  PendingConfirmation,
+} from "./persistence.js";
+export {
+  createRedisConfirmationStore,
+  type ConfirmationRedisClient,
+  type CreateRedisConfirmationStoreOptions,
+} from "./persistence-redis.js";
+
+export {
+  noopTraceSink,
+  createInMemoryTraceSink,
+  type AdapterPauseReason,
+  type AdapterTraceEvent,
+  type AdapterTracePhase,
+  type TraceSink,
+} from "./trace.js";
+
+export { AdapterError, AdapterErrorCode } from "./errors.js";
+
+/**
+ * In-memory Execution Ledger — re-export from `@adjudicate/audit` for
+ * zero-import-friction in tests, quickstarts, and local development.
+ *
+ * NOT for distributed or persistent production deployments. Production
+ * adopters wire `createRedisLedger` (or any backing store with SET-NX,
+ * EX, INCR, DECR) from `@adjudicate/audit`.
+ */
+export { createMemoryLedger } from "@adjudicate/audit";