@cursor/july 0.1.107 → 0.1.109

package/src/internal/storage-coordinator.ts

@@ -11,19 +11,17 @@
  * must never stall or fail a turn.
  *
  * Scaling shape: sessions reduce to keyed puts on the KV sink; eval runs
- * and A/B metrics go to their dedicated tables (`evals` / `abs`).
- * Reminder documents live on the control plane. Everything shares one
- * bounded, serialized queue.
+ * go to their dedicated `evals` table. Reminder documents live on the
+ * control plane. Everything shares one bounded, serialized queue.
  *
  * It does three unrelated jobs, declared separately as
  * {@link FrameworkSessionStore}, {@link AuthorKvStore}, and
- * {@link EvalAbStore} — see `storage-roles.ts` for why they differ and where
+ * {@link EvalStore} — see `storage-roles.ts` for why they differ and where
  * each is headed. The queue stays shared: it is one bounded, serialized chain
  * per agent, and splitting it would change backpressure behavior, which this
  * seam deliberately does not touch.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import {
   type ResolvedStoragePolicy,
@@ -36,12 +34,11 @@ import {
 } from "../storage.js";
 import { isCursorHostedStorage } from "../storage-backends/cursor-hosted.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import { describeError } from "./describe-error.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 import type {
   AuthorKvStore,
-  EvalAbStore,
+  EvalStore,
   FrameworkSessionStore,
 } from "./storage-roles.js";
 
@@ -71,13 +68,6 @@ const CLOSE_DRAIN_TIMEOUT_MS = 10_000;
 /** Debounced event batching flushes early past this many buffered events. */
 const DEBOUNCE_MAX_BATCH = 200;
 
-/**
- * Aggregate A/B snapshots are refreshed at most this often — the
- * playground polls `GET /v1/abs` every few seconds, and the snapshot is a
- * convenience backfill, not a source of truth.
- */
-const AB_SNAPSHOT_MIN_INTERVAL_MS = 60_000;
-
 /** One queued sink call (KV put/delete or a dedicated-table write). */
 interface StorageOp {
   /** Human-readable op label for failure logs, e.g. `put({root}/...)`. */
@@ -114,7 +104,7 @@ function sessionRecordsOf(entries: readonly StorageEntry[]): SessionRecord[] {
 }
 
 export class StorageCoordinator
-  implements FrameworkSessionStore, AuthorKvStore, EvalAbStore
+  implements FrameworkSessionStore, AuthorKvStore, EvalStore
 {
   readonly policy: ResolvedStoragePolicy;
 
@@ -136,7 +126,6 @@ export class StorageCoordinator
   private pending = 0;
   /** Ops dropped because the queue was full. */
   private dropped = 0;
-  private lastAbSnapshotAt = 0;
   private closed = false;
 
   constructor(options: StorageCoordinatorOptions) {
@@ -559,66 +548,6 @@ export class StorageCoordinator
     };
   }
 
-  // ==========================================================================
-  // A/Bs (dedicated `abs` table)
-  // ==========================================================================
-
-  /** Append one metric sample to the `abs` table (no-op without it). */
-  abSample(sample: ABMetricSample): void {
-    const table = this.definition.abs;
-    if (this.closed || table === undefined) {
-      return;
-    }
-    this.enqueue(
-      [
-        {
-          label: `abs.putSample(${sample.sessionId})`,
-          run: (ctx) => table.putSample(sample, ctx),
-        },
-      ],
-      "policy"
-    );
-  }
-
-  /**
-   * Refresh the persisted aggregate A/B snapshot, throttled to once per
-   * {@link AB_SNAPSHOT_MIN_INTERVAL_MS} (the playground recomputes the
-   * fold on every `GET /v1/abs` poll). No-op without `abs.putSnapshot`.
-   */
-  abSnapshot(snapshot: ABSnapshot): void {
-    const putSnapshot = this.definition.abs?.putSnapshot;
-    const now = Date.now();
-    if (
-      this.closed ||
-      putSnapshot === undefined ||
-      now - this.lastAbSnapshotAt < AB_SNAPSHOT_MIN_INTERVAL_MS
-    ) {
-      return;
-    }
-    this.lastAbSnapshotAt = now;
-    this.enqueue(
-      [{ label: "abs.putSnapshot", run: (ctx) => putSnapshot(snapshot, ctx) }],
-      "policy"
-    );
-  }
-
-  /** Latest persisted aggregate A/B snapshot; errors read as absent. */
-  async getLatestAbSnapshot(): Promise<ABSnapshot | undefined> {
-    const getSnapshot = this.definition.abs?.getSnapshot;
-    if (getSnapshot === undefined) {
-      return undefined;
-    }
-    try {
-      const value = await getSnapshot(this.context("restore"));
-      return value ?? undefined;
-    } catch (error) {
-      this.logger(
-        `[agent-sdk] storage abs.getSnapshot() failed: ${describeError(error)}`
-      );
-      return undefined;
-    }
-  }
-
   // ==========================================================================
   // Delivery
   // ==========================================================================

package/src/internal/storage-roles.ts

@@ -14,18 +14,16 @@
  * - {@link AuthorKvStore} is author state: whatever `ctx.host.kv` was handed.
  *   It converges onto the author file plane, which is a different destination
  *   from the one above.
- * - {@link EvalAbStore} is playground/experiment bookkeeping with its own
- *   dedicated tables, and follows neither.
+ * - {@link EvalStore} is playground eval bookkeeping with its own dedicated
+ *   table, and follows neither.
  *
  * Consumers should depend on the narrowest role they use. That is what keeps a
  * later change to framework persistence from silently reaching author KV, and
  * it is why these are interfaces rather than a comment on one class.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { StorageContext } from "../storage.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 
 /**
@@ -84,10 +82,7 @@ export interface AuthorKvStore {
   kvDelete(authorKey: string): Promise<void>;
 }
 
-/** Playground eval batches and live A/B metrics, on their own tables. */
-export interface EvalAbStore {
+/** Playground eval batches, on their own table. */
+export interface EvalStore {
   evalRuns(): EvalRunStorage | undefined;
-  abSample(sample: ABMetricSample): void;
-  abSnapshot(snapshot: ABSnapshot): void;
-  getLatestAbSnapshot(): Promise<ABSnapshot | undefined>;
 }

package/src/storage-backends/cursor-hosted-v2.ts

@@ -25,9 +25,9 @@
  *   pagination. `list` / `listKeys` below drain every page, so the v1
  *   truncated-scan failure mode does not exist here.
  *
- * Eval runs and A/B samples still ride the v1 storage proxy's dedicated
- * tables (`evals` / `abs` below); moving them to factorydb is a separate
- * follow-up from the KV cutover.
+ * Eval runs still ride the v1 storage proxy's dedicated table (`evals`
+ * below); moving them to factorydb is a separate follow-up from the KV
+ * cutover.
  *
  * This backend is platform-selected for architecture v2
  * (framework-storage-selection.ts) — authors never import it; `agent/storage.ts`
@@ -35,7 +35,6 @@
  */
 
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageEntry,
@@ -85,7 +84,6 @@ type CursorHostedStorageV2Methods = Required<
   readonly [CURSOR_HOSTED_STORAGE]: true;
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 function toCasResult(response: KvV2PutResponse): KvCasResult {
@@ -149,7 +147,7 @@ async function listAllPages(
 export function cursorHostedStorageV2(
   options: CursorHostedStorageOptions = {}
 ): CursorHostedStorageV2Methods {
-  // Eval runs and A/B samples stay on the v1 proxy's dedicated tables.
+  // Eval runs stay on the v1 proxy's dedicated table.
   const v1 = cursorHostedStorage(options);
   return {
     [CURSOR_HOSTED_STORAGE]: true,
@@ -214,6 +212,5 @@ export function cursorHostedStorageV2(
       },
     },
     evals: v1.evals,
-    abs: v1.abs,
   };
 }

package/src/storage-backends/cursor-hosted.ts

@@ -22,11 +22,9 @@
  * ```
  */
 
-import type { ABSnapshot } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import { injectActiveTraceContext } from "../otel.js";
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageEntry,
@@ -114,7 +112,6 @@ type CursorHostedStorageMethods = Required<
   readonly [CURSOR_HOSTED_STORAGE]: true;
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 // ============================================================================
@@ -169,6 +166,30 @@ export interface KvListKeysResponse {
   truncated?: boolean;
 }
 
+const STORAGE_RPC_ERROR_CODES = new Set([
+  "agentsdk_kv_credential_missing",
+  "agentsdk_kv_cursor_invalid",
+  "agentsdk_kv_deployment_unbound",
+  "agentsdk_kv_key_invalid",
+  "agentsdk_kv_request_invalid",
+  "agentsdk_kv_storage_not_allowed",
+  "agentsdk_kv_value_invalid",
+  "agentsdk_kv_version_invalid",
+]);
+
+export class StorageRpcError extends Error {
+  readonly code = "agent_dependency_failed";
+  readonly reasonCode: string;
+  readonly status: number;
+
+  constructor(message: string, reasonCode: string, status: number) {
+    super(message);
+    this.name = "StorageRpcError";
+    this.reasonCode = reasonCode;
+    this.status = status;
+  }
+}
+
 function toCasResult(response: KvCasResponse): KvCasResult {
   if (response.ok) {
     if (response.version === null) {
@@ -251,7 +272,22 @@ export async function storageRpc<T>(
       typeof (parsed as { error: unknown }).error === "string"
         ? (parsed as { error: string }).error
         : `HTTP ${response.status}`;
-    throw new Error(`cursorHostedStorage ${path}: ${error}`);
+    const candidate =
+      parsed !== null &&
+      typeof parsed === "object" &&
+      "code" in parsed &&
+      typeof (parsed as { code: unknown }).code === "string"
+        ? (parsed as { code: string }).code
+        : undefined;
+    const code =
+      candidate !== undefined && STORAGE_RPC_ERROR_CODES.has(candidate)
+        ? candidate
+        : "agentsdk_storage_http_error";
+    throw new StorageRpcError(
+      `cursorHostedStorage ${path}: ${error}`,
+      code,
+      response.status
+    );
   }
   return parsed as T;
 }
@@ -378,39 +414,5 @@ export function cursorHostedStorage(
         return result.runs;
       },
     },
-    abs: {
-      async putSample(sample, ctx): Promise<void> {
-        await storageRpc(
-          options,
-          "/internal/agent-serve/storage/abs/put-sample",
-          {
-            agentName: ctx.agentName,
-            sample,
-          }
-        );
-      },
-      async putSnapshot(snapshot, ctx): Promise<void> {
-        await storageRpc(
-          options,
-          "/internal/agent-serve/storage/abs/put-snapshot",
-          {
-            agentName: ctx.agentName,
-            snapshot,
-          }
-        );
-      },
-      async getSnapshot(ctx): Promise<ABSnapshot | undefined> {
-        const result = await storageRpc<{
-          found: boolean;
-          snapshot: ABSnapshot | null;
-        }>(options, "/internal/agent-serve/storage/abs/get-snapshot", {
-          agentName: ctx.agentName,
-        });
-        if (!result.found) {
-          return undefined;
-        }
-        return result.snapshot ?? undefined;
-      },
-    },
   };
 }

package/src/storage-backends/file-kv.ts

@@ -1,19 +1,17 @@
 /**
- * File-backed `defineStorage` helper: a file-per-key KV store plus
- * file-backed `evals` / `abs` tables.
+ * File-backed `defineStorage` helper: a file-per-key KV store plus a
+ * file-backed `evals` table.
  *
  * Implements the whole `defineStorage` surface with zero external
  * dependencies: the four KV methods against a flat directory of JSON files
  * (one file per key, filename = URI-encoded key), the `cas`
  * group (single-process conditional writes — see the `cas` member below),
- * eval runs as
- * `eval-runs/<agent>/<runId>.json`, and A/B metrics as
- * `ab/<agent>/samples.ndjson` (append-only) plus `ab/<agent>/snapshot.json`
- * (latest aggregate). KV keys carry the agent name inside the framework
- * key scheme, but the evals/abs tables have no such scheme — the agent
- * subdirectory keeps agents sharing one storage `dir` from mixing or
- * overwriting each other's history. Swap this for a real backend
- * (Postgres, S3, …) in production; the contracts are identical.
+ * and eval runs as `eval-runs/<agent>/<runId>.json`. KV keys carry the
+ * agent name inside the framework key scheme, but the evals table has no
+ * such scheme — the agent subdirectory keeps agents sharing one storage
+ * `dir` from mixing or overwriting each other's history. Swap this for a
+ * real backend (Postgres, S3, …) in production; the contracts are
+ * identical.
  *
  * Layout notes:
  * - KV filenames encode the full key (`encodeURIComponent(key) + ".json"`),
@@ -29,7 +27,6 @@
 
 import { createHash, randomUUID } from "node:crypto";
 import {
-  appendFile,
   mkdir,
   readdir,
   readFile,
@@ -38,10 +35,8 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import type { ABSnapshot } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageContext,
@@ -63,7 +58,6 @@ type FileKvMethods = Required<
 > & {
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 /** File-backed `defineStorage` methods, ready to spread into `defineStorage({...})`. */
@@ -72,12 +66,10 @@ export function fileKv(options?: FileKvOptions): FileKvMethods {
     const dir = options?.dir ?? ".agent-serve/kv";
     return isAbsolute(dir) ? dir : join(ctx.projectRoot, dir);
   };
-  // The evals/abs tables are scoped per agent (KV keys already carry the
-  // agent name via the framework key scheme).
+  // The evals table is scoped per agent (KV keys already carry the agent
+  // name via the framework key scheme).
   const evalRunsDir = (ctx: StorageContext): string =>
     join(resolveDir(ctx), "eval-runs", encodeURIComponent(ctx.agentName));
-  const abDir = (ctx: StorageContext): string =>
-    join(resolveDir(ctx), "ab", encodeURIComponent(ctx.agentName));
   const filePath = (ctx: StorageContext, key: string): string =>
     join(resolveDir(ctx), `${encodeURIComponent(key)}.json`);
   const readRaw = async (
@@ -270,39 +262,6 @@ export function fileKv(options?: FileKvOptions): FileKvMethods {
         return runs;
       },
     },
-
-    // A/B metrics: append-only sample log + latest aggregate snapshot,
-    // both under ab/<agent>/.
-    abs: {
-      async putSample(sample, ctx): Promise<void> {
-        const dir = abDir(ctx);
-        await mkdir(dir, { recursive: true });
-        await appendFile(
-          join(dir, "samples.ndjson"),
-          `${JSON.stringify(sample)}\n`,
-          "utf8"
-        );
-      },
-      async putSnapshot(snapshot, ctx): Promise<void> {
-        await writeJsonAtomic({
-          dir: abDir(ctx),
-          fileName: "snapshot.json",
-          value: snapshot,
-        });
-      },
-      async getSnapshot(ctx): Promise<ABSnapshot | undefined> {
-        try {
-          return JSON.parse(
-            await readFile(join(abDir(ctx), "snapshot.json"), "utf8")
-          ) as ABSnapshot;
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return undefined;
-          }
-          throw error;
-        }
-      },
-    },
   };
 }
 

package/src/storage-protocol.ts

@@ -39,10 +39,9 @@ const DURABLE_SESSION_RECORD_KEY_RE =
  * | `{root}/{agent}/continuation/{channelId}/{token}` | `{ sessionId }` |
  * | `{root}/{agent}/kv/{key}` | Author JSON via `HostContext.kv` |
  *
- * The `eval-runs` / `ab-samples` / `ab-snapshot` families are minted only
- * by the tables `defineStorage` derives over the KV core; a backend that
- * authors dedicated `StorageConfig.evals` / `StorageConfig.abs` groups never
- * sees them.
+ * The `eval-runs` family is minted only by the table `defineStorage`
+ * derives over the KV core; a backend that authors a dedicated
+ * `StorageConfig.evals` group never sees it.
  */
 function createStorageKeys(root: string) {
   return {
@@ -94,19 +93,6 @@ function createStorageKeys(root: string) {
     evalRun: (agent: string, runId: string): string =>
       `${root}/${agent}/eval-runs/${keySegment(runId)}`,
     evalRunsPrefix: (agent: string): string => `${root}/${agent}/eval-runs/`,
-    /**
-     * One A/B metric sample (derived `abs` table); the segments mirror the
-     * dedicated table's row identity (experiment + sessionId + at).
-     */
-    abSample: (
-      agent: string,
-      experiment: string,
-      sessionId: string,
-      at: string
-    ): string =>
-      `${root}/${agent}/ab-samples/${keySegment(experiment)}/${keySegment(sessionId)}/${keySegment(at)}`,
-    /** Latest aggregate A/B snapshot (derived `abs` table, LWW). */
-    abSnapshot: (agent: string): string => `${root}/${agent}/ab-snapshot`,
   } as const;
 }
 

package/src/storage.ts

@@ -4,16 +4,15 @@
  * Author `agent/storage.ts` with {@link defineStorage} to mirror the
  * framework's durable state into storage you own (a database, S3, a data
  * pipeline, …). Without it, state lives under `--state-root` on local disk
- * only, and eval/A/B history stays in process memory.
+ * only, and eval history stays in process memory.
  *
  * The sink is a plain key-value store — put/get/delete/list, no schema —
  * plus a conditional-write group ({@link StorageConfig.cas}; optional).
  * Implementing that small KV core is enough for
- * FULL functionality: eval-run and A/B history are derived over the core
- * when the optional dedicated tables ({@link StorageConfig.evals} and
- * {@link StorageConfig.abs}) are not authored — those groups exist as
- * backend-native optimizations (a real table, an analytics pipeline),
- * not as required-or-lose-history hooks:
+ * FULL functionality: eval-run history is derived over the core when the
+ * optional dedicated table ({@link StorageConfig.evals}) is not authored —
+ * that group exists as a backend-native optimization (a real table, an
+ * analytics pipeline), not as a required-or-lose-history hook:
  *
  * ```ts
  * import { defineStorage } from "@cursor/july/storage";
@@ -25,7 +24,6 @@
  *   list: (prefix) => db.listByPrefix(prefix), // [{ key, value }] in key order
  *   cas: { getWithVersion: ..., putIfAbsent: ..., putIfVersion: ..., listKeys: ... },
  *   evals: { put: ..., delete: ..., list: ... }, // eval-runs table
- *   abs: { putSample: ... },                     // A/B table
  * });
  * ```
  *
@@ -51,9 +49,7 @@
  * interface is the durable mirror.
  */
 
-import type { ABMetricSample } from "./ab.js";
 import type { EvalRunSnapshot } from "./evals.js";
-import type { ABSnapshot } from "./internal/ab-snapshot.js";
 import { brandDefinition } from "./internal/brand.js";
 import { storageKeys } from "./storage-protocol.js";
 import type { JsonValue, KvCasResult, KvVersionedEntry } from "./types.js";
@@ -161,24 +157,6 @@ export interface StorageEvalsTable {
   list(ctx: StorageContext): EvalRunSnapshot[] | Promise<EvalRunSnapshot[]>;
 }
 
-/**
- * Dedicated table for live A/B metrics: one row per cumulative metric
- * sample (unique per `experiment` + `sessionId` + `at` — one boundary
- * event emits a sample per enrolled experiment), plus — optionally — the latest
- * aggregate snapshot so a replacement host with no local sessions can
- * still serve the A/Bs surface.
- */
-export interface StorageABTable {
-  /** Append one cumulative metric sample (turn complete/fail). */
-  putSample(sample: ABMetricSample, ctx: StorageContext): void | Promise<void>;
-  /** Upsert the latest aggregate snapshot (framework-throttled). Optional. */
-  putSnapshot?(snapshot: ABSnapshot, ctx: StorageContext): void | Promise<void>;
-  /** Latest saved aggregate snapshot (replacement-host backfill). Optional. */
-  getSnapshot?(
-    ctx: StorageContext
-  ): ABSnapshot | undefined | null | Promise<ABSnapshot | undefined | null>;
-}
-
 /**
  * Conditional writes (CAS) — the coordination tier of the storage backend
  * contract. Plain storage works without it, so existing backends keep
@@ -186,9 +164,8 @@ export interface StorageABTable {
  * it, so implementing this group yourself only comes up for BYO storage.
  *
  * Grouped under {@link StorageConfig.cas} rather than as loose methods —
- * matching the `evals` / `abs` table groups — so `defineStorage`
- * validates the whole group at once: there is no meaningful
- * half-implementation.
+ * matching the `evals` table group — so `defineStorage` validates the
+ * whole group at once: there is no meaningful half-implementation.
  *
  * Version tokens are opaque per-key strings that change on every
  * successful write (counter, UUID, content hash — whatever is cheap for
@@ -234,14 +211,6 @@ export interface StorageConfig {
    * memory (lost on restart).
    */
   evals?: StorageEvalsTable;
-  /**
-   * Dedicated A/B table — a backend-native optimization, not a
-   * requirement. When omitted, `defineStorage` derives it over the KV
-   * core: `putSample` and `putSnapshot` need only core `put` (always
-   * present), `getSnapshot` additionally needs core `get`. Session event
-   * logs remain the assignment/fold source of truth either way.
-   */
-  abs?: StorageABTable;
   /**
    * Conditional writes (CAS). Optional for plain storage — existing
    * backends keep working without it. The built-in backends (`fileKv`,
@@ -260,7 +229,7 @@ export interface StorageConfig {
   delete?(key: string, ctx: StorageContext): void | Promise<void>;
   /**
    * Point lookup. Optional — required for **lazy restore** (resolving a
-   * continuation token on a replacement host) and the A/B backfill.
+   * continuation token on a replacement host).
    * Return `undefined`/`null` only for a **definitive** miss: on the lazy
    * restore path a throw propagates and fails the follow-up (retryable) —
    * a store outage must not read as "unknown token", which would fork the
@@ -346,34 +315,16 @@ export function defineStorage(config: StorageConfig): StorageDefinition {
       );
     }
   }
-  if (config.abs !== undefined) {
-    if (typeof config.abs.putSample !== "function") {
-      throw new Error(
-        "defineStorage: abs.putSample must be a function when the abs table is set"
-      );
-    }
-    for (const hook of ["putSnapshot", "getSnapshot"] as const) {
-      const value = config.abs[hook];
-      if (value !== undefined && typeof value !== "function") {
-        throw new Error(
-          `defineStorage: abs.${hook} must be a function when set`
-        );
-      }
-    }
-  }
   // Validate eagerly so a bad policy fails at discovery, not first flush.
   resolveStoragePolicy(config.policy);
   // A backend that implements only the KV core gets full functionality:
-  // the dedicated tables are backend-native optimizations, derived over
-  // the core when absent. Authored groups always win.
+  // the dedicated table is a backend-native optimization, derived over
+  // the core when absent. An authored group always wins.
   const derivedEvals =
     config.evals === undefined ? deriveEvalsTable(config) : undefined;
-  const derivedAbs =
-    config.abs === undefined ? deriveAbsTable(config) : undefined;
   return brandDefinition("storage", {
     ...config,
     ...(derivedEvals === undefined ? {} : { evals: derivedEvals }),
-    ...(derivedAbs === undefined ? {} : { abs: derivedAbs }),
   });
 }
 
@@ -408,48 +359,6 @@ function deriveEvalsTable(
   };
 }
 
-/**
- * A/B table over the KV core. Each sample lands as its own key (identity
- * = experiment + sessionId + at, matching the dedicated table's row
- * uniqueness): appending to one array value would need read-modify-write
- * — lost updates under concurrent writers without CAS, and unbounded
- * value growth — while a key per sample keeps `putSample` a blind put
- * with real append-only semantics. The aggregate snapshot lives at one
- * fixed key via plain `put` (last-write-wins is correct for "latest").
- * Requires only core `put`; `getSnapshot` is included when core `get`
- * exists.
- */
-function deriveAbsTable(config: StorageConfig): StorageABTable {
-  const get = config.get;
-  return {
-    putSample: (sample, ctx) =>
-      config.put(
-        storageKeys.abSample(
-          ctx.agentName,
-          sample.experiment,
-          sample.sessionId,
-          sample.at
-        ),
-        sample as unknown as JsonValue,
-        ctx
-      ),
-    putSnapshot: (snapshot, ctx) =>
-      config.put(
-        storageKeys.abSnapshot(ctx.agentName),
-        snapshot as unknown as JsonValue,
-        ctx
-      ),
-    ...(get === undefined
-      ? {}
-      : {
-          getSnapshot: async (ctx: StorageContext) => {
-            const value = await get(storageKeys.abSnapshot(ctx.agentName), ctx);
-            return (value ?? undefined) as ABSnapshot | undefined;
-          },
-        }),
-  };
-}
-
 // ============================================================================
 // Policy resolution
 // ============================================================================