@effect-agent/storage-cloudflare 0.1.0-beta.38 → 0.1.0-beta.40

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { CanonicalSequence, ProducerEpoch } from "@effect-agent/session";
+import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread";
 import { Schema } from "effect";
 
 /** The Durable Object's SQLite storage uses a private-development format this adapter cannot read. */
@@ -75,7 +75,7 @@ export class DoAppendConflict extends Schema.TaggedError<DoAppendConflict>()("Do
 }) {}
 
 /**
- * A producer epoch does not match the Conversation's current writer registration. Appends
+ * A producer epoch does not match the Thread's current writer registration. Appends
  * require the exact registered epoch, so both older and newer unregistered epochs are fenced;
  * a newer epoch takes over by materializing first.
  */
@@ -109,7 +109,7 @@ export const DoStorageFailpointLocation = Schema.Literals([
   "append:after-record-insert",
   "append:after-tail-update",
   "append:after",
-  "export:after-conversation-read",
+  "export:after-thread-read",
   "save-checkpoint:before",
   "save-checkpoint:after",
   "ledger:admit:before",

package/src/index.ts

@@ -1,8 +1,8 @@
 /**
- * `@effect-agent/storage-cloudflare` — Durable Object SQLite adapters for the session ports
- * (`ConversationStore`, `SubmissionLedger`).
+ * `@effect-agent/storage-cloudflare` — Durable Object SQLite adapters for the thread ports
+ * (`ThreadStore`, `SubmissionLedger`).
  *
- * WP1 lands the LOCAL facets: the full port implementations against one Conversation Durable
+ * WP1 lands the LOCAL facets: the full port implementations against one Thread Durable
  * Object's private SQLite database, structurally mirroring the Node/SQLite adapters (same
  * tables, same failpoint-location names, same conformance suites) with the DC-specific
  * differences documented in each module — Durable Object storage-backed transactions instead
@@ -13,20 +13,21 @@
  *
  * WP2 adds the cross-Object distribution seam: `port-protocol.ts` (the Schema
  * request/response/failure envelopes for the CLOSED route-capable port subset) and
- * `routing.ts` (the `ConversationPortTransport` service, the routed decorator Layers over
- * the local facets — this-conversation → local, route-capable foreign → transport, anything
+ * `routing.ts` (the `ThreadPortTransport` service, the routed decorator Layers over
+ * the local facets — this-thread → local, route-capable foreign → transport, anything
  * else foreign → fail fast typed — and the owner-side `handleEncodedPortRequest` endpoint
- * body for the Conversation Object's `portCall`).
+ * body for the Thread Object's `portCall`).
  *
  * This package never imports the `cloudflare:workers` runtime module — Durable Object handles
  * (`ctx.storage`) are injected as Layer construction values, and `@cloudflare/workers-types`
  * stays a types-only devDependency.
  */
 export * from "./errors.ts";
-export * from "./migrations.ts";
-export * from "./do-conversation-store.ts";
+export { CurrentDoStorageVersion } from "./migrations.ts";
+export * from "./do-thread-store.ts";
 export * from "./do-ledger.ts";
 export * from "./do-schedule-store.ts";
+export * from "./do-subscription-store.ts";
 export * from "./do-storage-config.ts";
 export * from "./do-storage-failpoint.ts";
 export * from "./port-protocol.ts";

package/src/migrations.ts

@@ -2,35 +2,28 @@ import { SqliteMigrator } from "@effect/sql-sqlite-do";
 import { Effect } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
-/**
- * The exact-or-fresh storage version recorded in `effect_agent_meta`. Cloudflare is a fresh
- * platform, so there is exactly ONE migration carrying the complete current schema — no
- * v1→v4 history to replay (deployment spec §9: no rolling data-version promise during
- * private development).
- */
-export const CurrentDoStorageVersion = 1;
+/** The current storage version recorded in `effect_agent_meta`. */
+export const CurrentDoStorageVersion = 2;
 
 /**
- * The Conversation Durable Object schema. Table names and columns mirror the Node/SQLite v4
- * schema byte-for-byte (`packages/storage-sqlite/src/migrations.ts`, migrations 1–4 collapsed
- * into their final shape) so the shared conformance suites and crash-matrix rows address
- * identical durable state. Two DC-specific additions:
+ * The Thread Durable Object schema shares its thread and ledger tables with Node/SQLite.
+ * Schedules and subscriptions use separate Durable Objects. Two DC-specific additions:
  *
  * 1. `effect_agent_meta` replaces `PRAGMA user_version` as the exact-or-fresh version gate —
  *    a meta table is portable regardless of which PRAGMAs Durable Object SQL storage allows.
  * 2. `effect_agent_child_settlements` is the durable cross-store notification marker the
  *    SubmissionLedger port contract mandates for cross-store adapters (`suspend`'s covering
- *    check and `recordChildSettled`'s wake both consult it): parent and child Conversations
+ *    check and `recordChildSettled`'s wake both consult it): parent and child Threads
  *    live in different Durable Objects, so a child settlement reported before the parent's
  *    suspend commits must be observable from the PARENT's own storage.
  */
 export const doMigrations = SqliteMigrator.fromRecord({
-  "1_current_cloudflare_conversation_object": Effect.gen(function* () {
+  "1_current_cloudflare_thread_object": Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
 
     yield* sql`
-      CREATE TABLE effect_agent_conversations (
-        conversation_id TEXT PRIMARY KEY NOT NULL,
+      CREATE TABLE effect_agent_threads (
+        thread_id TEXT PRIMARY KEY NOT NULL,
         created_at TEXT NOT NULL,
         tail_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
@@ -40,59 +33,59 @@ export const doMigrations = SqliteMigrator.fromRecord({
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_batches (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         first_sequence INTEGER NOT NULL,
         last_sequence INTEGER NOT NULL,
         batch_digest TEXT NOT NULL,
         tail_digest TEXT NOT NULL,
         batch_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, batch_id),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, batch_id),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_records (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         sequence INTEGER NOT NULL,
         record_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         record_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, sequence),
-        UNIQUE (conversation_id, record_id),
-        FOREIGN KEY (conversation_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(conversation_id, batch_id)
+        PRIMARY KEY (thread_id, sequence),
+        UNIQUE (thread_id, record_id),
+        FOREIGN KEY (thread_id, batch_id)
+          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (conversation_id, batch_id, sequence)
+        ON effect_agent_canonical_records (thread_id, batch_id, sequence)
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_checkpoints (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         through_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
         checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, through_sequence),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, through_sequence),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
-    // Admission rows exist before Conversation materialization (durability §4), so
-    // conversation_id intentionally carries no foreign key into effect_agent_conversations.
+    // Admission rows exist before Thread materialization (durability §4), so
+    // thread_id intentionally carries no foreign key into effect_agent_threads.
     yield* sql`
       CREATE TABLE effect_agent_submissions (
         submission_id TEXT PRIMARY KEY NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         queue_sequence INTEGER NOT NULL,
         principal TEXT NOT NULL,
         idempotency_key TEXT NOT NULL,
@@ -115,8 +108,8 @@ export const doMigrations = SqliteMigrator.fromRecord({
         unknown_tool_call_ids_json TEXT,
         parent_submission_id TEXT,
         parent_tool_call_id TEXT,
-        UNIQUE (conversation_id, principal, idempotency_key),
-        UNIQUE (conversation_id, queue_sequence)
+        UNIQUE (thread_id, principal, idempotency_key),
+        UNIQUE (thread_id, queue_sequence)
       )
     `.withoutTransform;
 
@@ -148,7 +141,7 @@ export const doMigrations = SqliteMigrator.fromRecord({
       CREATE TABLE effect_agent_attempts (
         attempt_id TEXT PRIMARY KEY NOT NULL,
         submission_id TEXT NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         owner_producer_id TEXT NOT NULL,
         producer_epoch INTEGER NOT NULL,
         claimed_at TEXT NOT NULL,

package/src/port-protocol.ts

@@ -10,14 +10,14 @@ import {
   CanonicalRecordEnvelope,
   ChildSettledNotification,
   ChildSettledOutcome,
-  ConversationExport,
-  ConversationExportRequest,
-  ConversationMaterialization,
-  ConversationNotMaterialized,
-  ConversationRead,
-  ConversationStoreError,
-  ConversationTail,
-  ConversationTailRequest,
+  ThreadExport,
+  ThreadExportRequest,
+  ThreadMaterialization,
+  ThreadNotMaterialized,
+  ThreadRead,
+  ThreadStoreError,
+  ThreadTail,
+  ThreadTailRequest,
   FenceRejected,
   FencedAppendRequest,
   JoinedToHost,
@@ -27,20 +27,20 @@ import {
   SubmissionLookup,
   SubmissionLookupByKey,
   SubmissionSnapshot,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { Schema } from "effect";
 
 /**
  * The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error
- * envelopes for the CLOSED route-capable subset of the session ports. One Conversation's
- * Durable Object executes another Conversation's request against its OWN local facets; the
+ * envelopes for the CLOSED route-capable subset of the thread ports. One Thread's
+ * Durable Object executes another Thread's request against its OWN local facets; the
  * envelopes here are the only values that cross the Object boundary, and they are
  * transport-agnostic — native Durable Object JS RPC is the shipped carrier, fetch-with-JSON
  * the documented fallback, and both move the same Schema-encoded JSON.
  *
  * The closed subset is exactly the set of operations the durable coordinator performs against
- * a FOREIGN Conversation (parent/child establishment, status checks, abort propagation,
- * child-settlement notification, and the child-conversation store operations used by
+ * a FOREIGN Thread (parent/child establishment, status checks, abort propagation,
+ * child-settlement notification, and the child-thread store operations used by
  * establishment, `verifySettledChild`, and result projection):
  *
  * - ledger: `admit`, `markReady`, `lookup`, `resolveAdmission`, `requestAbort`,
@@ -53,7 +53,7 @@ import { Schema } from "effect";
  *
  * Failures cross the boundary as the `PortFailure` union and re-decode on the caller side to
  * the SAME tagged error types the local facet would have produced, so routed calls keep
- * error-tag fidelity. `cause` chains inside `LedgerError`/`ConversationStoreError` travel as
+ * error-tag fidelity. `cause` chains inside `LedgerError`/`ThreadStoreError` travel as
  * Schema defects and do not claim instance fidelity across Objects (plan §2.8).
  */
 
@@ -71,7 +71,7 @@ export const boundPortDiagnostic = (value: string): string =>
 /**
  * The envelope itself could not be honored: the receiving Object could not decode the
  * request, or a response could not be encoded/decoded. It never carries port semantics —
- * callers fold it into the operation's base error (`LedgerError`/`ConversationStoreError`),
+ * callers fold it into the operation's base error (`LedgerError`/`ThreadStoreError`),
  * except `resolveAdmission`, which folds it into `AdmissionIndeterminate` because a
  * non-answer is never proof of absence (SUB-031).
  */
@@ -128,39 +128,39 @@ export class LedgerRecordChildSettledCall extends Schema.TaggedClass<LedgerRecor
   request: ChildSettledNotification,
 }) {}
 
-/** Routed `ConversationStore.materialize` against the owning Object. */
+/** Routed `ThreadStore.materialize` against the owning Object. */
 export class StoreMaterializeCall extends Schema.TaggedClass<StoreMaterializeCall>(
   "@effect-agent/storage-cloudflare/StoreMaterializeCall",
 )("StoreMaterialize", {
-  request: ConversationMaterialization,
+  request: ThreadMaterialization,
 }) {}
 
-/** Routed `ConversationStore.append` against the owning Object. */
+/** Routed `ThreadStore.append` against the owning Object. */
 export class StoreAppendCall extends Schema.TaggedClass<StoreAppendCall>(
   "@effect-agent/storage-cloudflare/StoreAppendCall",
 )("StoreAppend", {
   request: FencedAppendRequest,
 }) {}
 
-/** Routed one-page `ConversationStore.read`; the page bound is the request's own `limit`. */
+/** Routed one-page `ThreadStore.read`; the page bound is the request's own `limit`. */
 export class StoreReadPageCall extends Schema.TaggedClass<StoreReadPageCall>(
   "@effect-agent/storage-cloudflare/StoreReadPageCall",
 )("StoreReadPage", {
-  request: ConversationRead,
+  request: ThreadRead,
 }) {}
 
-/** Routed `ConversationStore.inspectTail` against the owning Object. */
+/** Routed `ThreadStore.inspectTail` against the owning Object. */
 export class StoreInspectTailCall extends Schema.TaggedClass<StoreInspectTailCall>(
   "@effect-agent/storage-cloudflare/StoreInspectTailCall",
 )("StoreInspectTail", {
-  request: ConversationTailRequest,
+  request: ThreadTailRequest,
 }) {}
 
-/** Routed `ConversationStore.export` against the owning Object. */
+/** Routed `ThreadStore.export` against the owning Object. */
 export class StoreExportCall extends Schema.TaggedClass<StoreExportCall>(
   "@effect-agent/storage-cloudflare/StoreExportCall",
 )("StoreExport", {
-  request: ConversationExportRequest,
+  request: ThreadExportRequest,
 }) {}
 
 /** Every request that may cross a Durable Object boundary — the CLOSED route-capable subset. */
@@ -241,13 +241,13 @@ export class StoreReadPageResult extends Schema.TaggedClass<StoreReadPageResult>
 export class StoreInspectTailResult extends Schema.TaggedClass<StoreInspectTailResult>(
   "@effect-agent/storage-cloudflare/StoreInspectTailResult",
 )("StoreInspectTailResult", {
-  tail: ConversationTail,
+  tail: ThreadTail,
 }) {}
 
 export class StoreExportResult extends Schema.TaggedClass<StoreExportResult>(
   "@effect-agent/storage-cloudflare/StoreExportResult",
 )("StoreExportResult", {
-  export: ConversationExport,
+  export: ThreadExport,
 }) {}
 
 /** Every successful routed result. Callers narrow by the tag their request implies. */
@@ -273,15 +273,15 @@ export type PortResult = typeof PortResult.Type;
 /**
  * Every typed failure a route-capable operation can produce on its owning Object, plus the
  * protocol's own `PortProtocolError`. Members re-decode to the SAME tagged classes the
- * session ports declare, so a routed caller observes identical error tags and fields.
+ * thread ports declare, so a routed caller observes identical error tags and fields.
  */
 export const PortFailure = Schema.Union([
   AdmissionConflict,
   SettlementConflict,
   JoinedToHost,
   LedgerError,
-  ConversationStoreError,
-  ConversationNotMaterialized,
+  ThreadStoreError,
+  ThreadNotMaterialized,
   AppendConflict,
   FenceRejected,
   PortProtocolError,