@xandreed/plugin-session-sqlite 0.12.0 → 0.13.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/plugin-session-sqlite
 
-Efferent composable agent framework, 0.12.0. Bun only (bun:sqlite).
+Efferent composable agent framework, 0.13.0. Bun only.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/index.d.ts

@@ -1,19 +1,9 @@
-import { Layer } from "effect";
-import { SessionEnvironment, SessionLog, SessionStore, TurnAdmission } from "@xandreed/core";
-/** @deprecated The historical store API is a projection over the unified log. */
-export declare const SessionStoreLive: (path: string, options?: {
-    readonly legacyPaths?: ReadonlyArray<string>;
-    readonly legacyOwner?: string;
-}) => Layer.Layer<SessionLog | TurnAdmission | SessionStore, import("@xandreed/core").SessionLogError, never>;
+import { SessionLog, TurnAdmission } from "@xandreed/core";
 /** Storage and the open admission policy; compose sessionsPlugin explicitly in the host graph. */
 export declare const sessionSqlitePlugin: import("@xandreed/core").TypedPlugin<{
     readonly path: string;
-    readonly legacyPaths: readonly string[];
 }, {
     readonly path: string;
-    readonly legacyPaths: readonly string[];
-}, SessionLog | TurnAdmission | SessionStore, import("@xandreed/core").SessionLogError, SessionEnvironment>;
+}, SessionLog | TurnAdmission, import("@xandreed/core").SessionLogError, never>;
 export default sessionSqlitePlugin;
-export { ConversationStoreProjectionLive, SqliteConversationStoreLive } from "./store/sqliteStore.js";
-export { SessionStoreProjectionLive } from "./compatibility.adapter.js";
 export { SessionLogSqliteLive, sessionLogSqlitePlugin } from "./session-log.adapter.js";

package/dist/index.js

@@ -1,19 +1,15 @@
-import { Effect, Layer, Schema } from "effect";
-import { definePlugin, SessionEnvironment, SessionLog, SessionStore, TurnAdmission, TurnAdmissionOpen } from "@xandreed/core";
-import { SessionStoreProjectionLive } from "./compatibility.adapter.js";
+import { Layer, Schema } from "effect";
+import { definePlugin, SessionLog, TurnAdmission, TurnAdmissionOpen } from "@xandreed/core";
 import { SessionLogSqliteLive } from "./session-log.adapter.js";
-const Config = Schema.Struct({ path: Schema.String, legacyPaths: Schema.Array(Schema.String) });
-export const SessionStoreLive = (path, options = {}) => Layer.mergeAll(SessionStoreProjectionLive.pipe(Layer.provideMerge(SessionLogSqliteLive(path, options))), TurnAdmissionOpen), sessionSqlitePlugin = definePlugin({
+const Config = Schema.Struct({ path: Schema.String });
+export const sessionSqlitePlugin = definePlugin({
   id: "@xandreed/plugin-session-sqlite",
-  version: "0.12.0",
+  version: "0.13.0",
   scope: "runtime",
   config: Config,
-  defaults: { path: ".efferent/runtime/sessions.db", legacyPaths: [] },
-  requires: [SessionEnvironment],
-  provides: [SessionLog, SessionStore, TurnAdmission],
-  layer: ({ path, legacyPaths }) => Layer.unwrap(SessionEnvironment.pipe(Effect.map(({ workspace }) => SessionStoreLive(path, { legacyPaths, legacyOwner: workspace }))))
+  defaults: { path: ".efferent/runtime/sessions.db" },
+  provides: [SessionLog, TurnAdmission],
+  layer: ({ path }) => Layer.merge(SessionLogSqliteLive(path), TurnAdmissionOpen)
 });
 export default sessionSqlitePlugin;
-export { ConversationStoreProjectionLive, SqliteConversationStoreLive } from "./store/sqliteStore.js";
-export { SessionStoreProjectionLive } from "./compatibility.adapter.js";
 export { SessionLogSqliteLive, sessionLogSqlitePlugin } from "./session-log.adapter.js";

package/dist/session-log.adapter.d.ts

@@ -1,47 +1,15 @@
-import { Effect, Layer, Option } from "effect";
+import { Effect, Layer } from "effect";
 import type { Scope } from "effect";
-import { ConversationId, SessionLog, SessionLogError } from "@xandreed/core";
-import type { JsonObject } from "@xandreed/core";
-/** One conversation as the positional listing shows it: its first message and its latest title and outcome, as stored. */
-export interface ConversationOverview {
-    readonly id: ConversationId;
-    readonly createdAt: number;
-    readonly first: Option.Option<JsonObject>;
-    readonly title: Option.Option<JsonObject>;
-    readonly outcome: Option.Option<JsonObject>;
-}
-/**
- * What this package's compatibility projections use of a SQLite log beyond
- * the SessionLog contract: set-based reads, retention in one transaction,
- * and importing a host's own older file.
- */
-export interface SqliteLogInternals {
-    /** The owner's conversation sessions (origin `conversation`), newest first, in one query. */
-    readonly conversations: (owner: string) => Effect.Effect<ReadonlyArray<ConversationOverview>, SessionLogError>;
-    /** Remove the conversation sessions created before `before` in one transaction, then reclaim the space; returns how many. */
-    readonly prune: (before: number) => Effect.Effect<number, SessionLogError>;
-    /** Import older files through read-only connections (absent ones are skipped); orphan rows without a session default to `owner`. */
-    readonly importLegacy: (paths: ReadonlyArray<string>, owner: Option.Option<string>) => Effect.Effect<void, SessionLogError>;
-}
-/** The SQLite internals of a log `SessionLogSqliteLive` built; none for any other SessionLog. */
-export declare const sqliteLogInternals: (log: SessionLog["Service"]) => Option.Option<SqliteLogInternals>;
+import { SessionLog, SessionLogError } from "@xandreed/core";
 /**
  * The authoritative session journal in one SQLite file: `session_heads`
- * and `session_log_events`. Legacy tables remain preserved, read only after
- * their import. Removal cascades to events and children and leaves a
- * tombstone, so no import brings a removed session back. A commit is one
+ * and `session_log_events`. Removal cascades to events and children. A commit is one
  * IMMEDIATE transaction that checks the revision and the clock before it
  * writes; the clock is the process's.
  */
-export declare const makeSessionLogSqlite: (path: string, options?: {
-    readonly legacyPaths?: ReadonlyArray<string>;
-    readonly legacyOwner?: string;
-}) => Effect.Effect<SessionLog["Service"], SessionLogError, Scope.Scope>;
+export declare const makeSessionLogSqlite: (path: string) => Effect.Effect<SessionLog["Service"], SessionLogError, Scope.Scope>;
 /** The session log over one SQLite file (see `makeSessionLogSqlite`). */
-export declare const SessionLogSqliteLive: (path: string, options?: {
-    readonly legacyPaths?: ReadonlyArray<string>;
-    readonly legacyOwner?: string;
-}) => Layer.Layer<SessionLog, SessionLogError>;
+export declare const SessionLogSqliteLive: (path: string) => Layer.Layer<SessionLog, SessionLogError>;
 /** The session log in a SQLite file, as a plugin: provides SessionLog. */
 export declare const sessionLogSqlitePlugin: import("@xandreed/core").TypedPlugin<{
     readonly path: string;

package/dist/session-log.adapter.js

@@ -1,6 +1,6 @@
 import { Database } from "bun:sqlite";
 import { mkdir } from "node:fs/promises";
-import { chmodSync, existsSync, realpathSync } from "node:fs";
+import { chmodSync } from "node:fs";
 import { dirname } from "node:path";
 import { Clock, Effect, Layer, Option, Schema } from "effect";
 import {
@@ -13,7 +13,6 @@ import {
   SessionLogError,
   SessionMissing
 } from "@xandreed/core";
-import { importLegacySessions, LEGACY_BOOKKEEPING } from "./legacy-session.adapter.js";
 const failure = (code) => (error) => new SessionLogError({ code, message: String(error) }), json = (text) => JSON.parse(text), headOf = (row, now) => ({
   header: {
     id: ConversationId.make(row.id),
@@ -39,8 +38,8 @@ const failure = (code) => (error) => new SessionLogError({ code, message: String
   kind: row.kind,
   at: row.at,
   data: json(row.data)
-}), internals = new WeakMap;
-export const sqliteLogInternals = (log) => Option.fromNullishOr(internals.get(log)), makeSessionLogSqlite = (path, options = {}) => Effect.gen(function* () {
+});
+export const makeSessionLogSqlite = (path) => Effect.gen(function* () {
   yield* Effect.tryPromise({ try: () => mkdir(dirname(path), { recursive: !0 }), catch: failure("store.open") });
   const db = yield* Effect.acquireRelease(Effect.try({ try: () => new Database(path, { create: !0, strict: !0 }), catch: failure("store.open") }), (database) => Effect.sync(() => database.close())), operation = (work) => Effect.try({ try: work, catch: failure("store.io") });
   yield* operation(() => chmodSync(path, 384));
@@ -58,26 +57,9 @@ export const sqliteLogInternals = (log) => Option.fromNullishOr(internals.get(lo
       session_id TEXT NOT NULL REFERENCES session_heads(id) ON DELETE CASCADE, seq INTEGER NOT NULL, turn INTEGER,
       kind TEXT NOT NULL, at INTEGER NOT NULL, data TEXT NOT NULL, PRIMARY KEY(session_id, seq));
     CREATE INDEX IF NOT EXISTS session_log_events_kind ON session_log_events(session_id, kind, seq);
-    ${LEGACY_BOOKKEEPING}
   `));
-  const imported = (source, sourceId, owner) => operation(() => importLegacySessions(db, source, sourceId, owner)).pipe(Effect.tap((result) => Effect.forEach(result.skipped, (row) => Effect.logWarning(`legacy import of ${sourceId}: skipped an undecodable row: ${row}`), { discard: !0 })), Effect.flatMap((result) => Option.match(result.refused, {
-    onNone: () => Effect.void,
-    onSome: (message) => Effect.fail(new SessionLogError({ code: "store.legacy-conflict", message }))
-  }))), importLegacy = (paths, owner) => Effect.gen(function* () {
-    const destination = yield* operation(() => realpathSync(path)), sources = yield* operation(() => [...new Set(paths.filter(existsSync).map((source) => realpathSync(source)))].filter((source) => source !== destination));
-    yield* Effect.forEach(sources, (source) => Effect.acquireUseRelease(operation(() => {
-      const legacy = new Database(source, { readonly: !0, strict: !0 });
-      legacy.exec("PRAGMA busy_timeout = 5000");
-      return legacy;
-    }), (legacy) => imported(legacy, source, owner), (legacy) => Effect.sync(() => legacy.close())), { discard: !0 });
-  }), owner = Option.fromNullishOr(options.legacyOwner);
-  yield* imported(db, "local", owner);
-  yield* importLegacy(options.legacyPaths ?? [], owner);
-  const headRow = (id) => db.query("SELECT * FROM session_heads WHERE id = ?").get(id), removeTrees = (ids, now) => ids.forEach((id) => {
-    db.query(`WITH RECURSIVE tree(id) AS (SELECT id FROM session_heads WHERE id = ? UNION SELECT child.id FROM session_heads child JOIN tree ON child.parent_id = tree.id)
-      INSERT OR IGNORE INTO session_log_tombstones (session_id, removed_at) SELECT id, ? FROM tree`).run(id, now);
-    db.query("DELETE FROM session_heads WHERE id = ?").run(id);
-  }), log = SessionLog.of({
+  const headRow = (id) => db.query("SELECT * FROM session_heads WHERE id = ?").get(id), removeTree = (id) => db.query("DELETE FROM session_heads WHERE id = ?").run(id);
+  return SessionLog.of({
     create: (header) => Effect.gen(function* () {
       const now = yield* Clock.currentTimeMillis, outcome = yield* operation(() => db.transaction(() => {
         if (headRow(header.id) !== null)
@@ -141,38 +123,15 @@ export const sqliteLogInternals = (log) => Option.fromNullishOr(internals.get(lo
         return Effect.fail(new RevisionConflict({ session: id, expected: commit.expect, actual: outcome.actual }));
       return Effect.fail(new LeaseExpired({ session: id, notAfter: Option.getOrElse(commit.notAfter, () => at), now: at }));
     })))),
-    remove: (id) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => operation(() => db.transaction(() => removeTrees([id], now)).immediate())))
-  });
-  internals.set(log, {
-    conversations: (owner) => operation(() => db.query(`
-      SELECT head.id AS id, head.created_at AS created_at,
-        (SELECT event.data FROM session_log_events event WHERE event.session_id = head.id AND event.kind = 'conversation.message' ORDER BY event.seq LIMIT 1) AS first,
-        (SELECT event.data FROM session_log_events event WHERE event.session_id = head.id AND event.kind = 'conversation.title' ORDER BY event.seq DESC LIMIT 1) AS title,
-        (SELECT event.data FROM session_log_events event WHERE event.session_id = head.id AND event.kind = 'conversation.outcome' ORDER BY event.seq DESC LIMIT 1) AS outcome
-      FROM session_heads head WHERE head.owner = ? AND head.origin = 'conversation' ORDER BY head.created_at DESC, head.id DESC`).all(owner).map((row) => ({
-      id: ConversationId.make(row.id),
-      createdAt: row.created_at,
-      first: Option.map(Option.fromNullishOr(row.first), json),
-      title: Option.map(Option.fromNullishOr(row.title), json),
-      outcome: Option.map(Option.fromNullishOr(row.outcome), json)
-    }))),
-    prune: (before) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => operation(() => {
-      const removed = db.transaction(() => {
-        const ids = db.query("SELECT id FROM session_heads WHERE origin = 'conversation' AND created_at < ?").all(before).map((row) => row.id);
-        removeTrees(ids, now);
-        return ids.length;
-      }).immediate();
-      db.exec("PRAGMA wal_checkpoint(TRUNCATE);");
-      return removed;
-    }))),
-    importLegacy
+    remove: (id) => operation(() => db.transaction(() => {
+      removeTree(id);
+    }).immediate())
   });
-  return log;
-}), SessionLogSqliteLive = (path, options = {}) => Layer.effect(SessionLog, makeSessionLogSqlite(path, options));
+}), SessionLogSqliteLive = (path) => Layer.effect(SessionLog, makeSessionLogSqlite(path));
 const LogConfig = Schema.Struct({ path: Schema.String });
 export const sessionLogSqlitePlugin = definePlugin({
   id: "@xandreed/plugin-session-sqlite/log",
-  version: "0.12.0",
+  version: "0.13.0",
   scope: "runtime",
   config: LogConfig,
   defaults: { path: ".efferent/runtime/sessions.db" },

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@xandreed/plugin-session-sqlite",
-  "version": "0.12.0",
+  "version": "0.13.0",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,8 +13,8 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.12.0",
-    "effect": "4.0.0-rc.118",
+    "@xandreed/core": "0.13.0",
+    "effect": "4.0.7",
     "ws": "^8.21.0"
   },
   "private": false,
@@ -23,8 +26,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }

package/dist/compatibility.adapter.d.ts

@@ -1,35 +0,0 @@
-import { Effect, Layer, Option } from "effect";
-import { ConversationId, HarnessError, SessionEvent, SessionLog, SessionStore } from "@xandreed/core";
-import type { EventBody, SessionCommitted, SessionDraft, SessionHead, SessionLogEvent } from "@xandreed/core";
-type Log = SessionLog["Service"];
-/** Read inherited records at their immutable fork boundary, then the child's own records. A fork at `through <= 0` inherits nothing. */
-export declare const compatibilityHistory: (log: Log, id: ConversationId, kinds: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<SessionLogEvent>, HarnessError>;
-/**
- * The last event of `kinds` at or before `upTo` (the head when omitted), or
- * the inherited history's when the session has none of its own: a binary
- * search over the cursor, so an append never reads the whole history.
- */
-export declare const compatibilityLast: (log: Log, id: ConversationId, kinds: ReadonlyArray<string>, upTo?: number) => Effect.Effect<Option.Option<SessionLogEvent>, HarnessError>;
-/**
- * Plan against the head's revision; a conflict re-reads and re-plans. The
- * first retries are immediate, later ones wait a little (jittered), so an
- * append outside a turn outlasts a busy turn writer instead of failing.
- */
-export declare const compatibilityCommit: <A>(log: Log, id: ConversationId, plan: (head: SessionHead) => Effect.Effect<{
-    readonly drafts: ReadonlyArray<SessionDraft>;
-    readonly result: A;
-}, HarnessError>) => Effect.Effect<{
-    readonly committed: SessionCommitted;
-    readonly result: A;
-}, HarnessError>;
-/** Includes branches, preserving the historical list contract. */
-export declare const compatibilityListing: (log: Log, owner: string, parent?: Option.Option<string & import("effect/Brand").Brand<"ConversationId">>) => Effect.Effect<ReadonlyArray<SessionHead>, HarnessError>;
-export declare const harnessHistory: (log: Log, id: ConversationId, after?: number) => Effect.Effect<ReadonlyArray<SessionEvent>, HarnessError>;
-export declare const harnessEvent: (id: ConversationId, body: EventBody, seq: number, at: number) => SessionEvent;
-/**
- * @deprecated Historical harness vocabulary projected over SessionLog.
- * It owns no tables and can be removed once custom AgentLoop hosts use the
- * composable Agent/Turn API. Harness itself admits and ends through Sessions.
- */
-export declare const SessionStoreProjectionLive: Layer.Layer<SessionStore, never, SessionLog>;
-export {};

package/dist/compatibility.adapter.js

@@ -1,91 +0,0 @@
-import { Clock, Effect, Layer, Option, Random, Schema } from "effect";
-import { ConversationId, HarnessError, SessionEvent, SessionLog, SessionRecord, SessionStore } from "@xandreed/core";
-const storageFailure = (error) => new HarnessError({ code: error._tag === "SessionMissing" ? "session.missing" : "session.log", message: error.message ?? error._tag }), eventOf = Schema.decodeUnknownEffect(SessionEvent), decodeFailure = (error) => new HarnessError({ code: "session.decode", message: String(error) }), HARNESS = "harness.event", SETTLED = ["run.completed", "run.failed", "run.cancelled"], harnessSeqOf = (event) => {
-  const inner = event.data.event;
-  return typeof inner === "object" && inner !== null && "seq" in inner && typeof inner.seq === "number" ? inner.seq : Number.POSITIVE_INFINITY;
-};
-export const compatibilityHistory = (log, id, kinds) => Effect.gen(function* () {
-  const head = yield* log.head(id).pipe(Effect.mapError(storageFailure)), inherited = yield* Option.match(head.header.parent, {
-    onNone: () => Effect.succeed([]),
-    onSome: (parent) => parent.through <= 0 ? Effect.succeed([]) : compatibilityHistory(log, parent.id, kinds).pipe(Effect.map((events) => events.filter((event) => event.session !== parent.id || event.seq <= parent.through)))
-  }), own = yield* log.read(id, { after: 0, limit: Option.none(), kinds }).pipe(Effect.mapError(storageFailure));
-  return [...inherited, ...own];
-});
-const nextOf = (log, id, kinds, after, upTo) => log.read(id, { after, limit: Option.some(1), kinds }).pipe(Effect.map((events) => Option.filter(Option.fromNullishOr(events[0]), (event) => event.seq <= upTo)), Effect.mapError(storageFailure)), firstHolding = (low, high, holds) => low >= high ? Effect.succeed(high) : Effect.gen(function* () {
-  const middle = Math.floor((low + high) / 2);
-  return (yield* holds(middle)) ? yield* firstHolding(low, middle, holds) : yield* firstHolding(middle + 1, high, holds);
-});
-export const compatibilityLast = (log, id, kinds, upTo = Number.MAX_SAFE_INTEGER) => Effect.gen(function* () {
-  const head = yield* log.head(id).pipe(Effect.mapError(storageFailure)), bound = Math.min(head.seq, upTo), cursor = yield* firstHolding(0, bound, (at) => nextOf(log, id, kinds, at, bound).pipe(Effect.map(Option.isNone)));
-  if (cursor > 0)
-    return yield* nextOf(log, id, kinds, cursor - 1, bound);
-  return yield* Option.match(head.header.parent, {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (parent) => parent.through <= 0 ? Effect.succeed(Option.none()) : compatibilityLast(log, parent.id, kinds, parent.through)
-  });
-});
-const harnessAfter = (log, id, after, upTo = Number.MAX_SAFE_INTEGER) => Effect.gen(function* () {
-  const head = yield* log.head(id).pipe(Effect.mapError(storageFailure)), bound = Math.min(head.seq, upTo), beyond = (cursor) => nextOf(log, id, [HARNESS], cursor, bound).pipe(Effect.map(Option.match({ onNone: () => !0, onSome: (event) => harnessSeqOf(event) > after }))), cursor = after < 0 || (yield* beyond(0)) ? 0 : yield* firstHolding(1, bound, beyond), own = (yield* log.read(id, { after: cursor, limit: Option.none(), kinds: [HARNESS] }).pipe(Effect.mapError(storageFailure))).filter((event) => event.seq <= bound && harnessSeqOf(event) > after);
-  return [...cursor > 0 ? [] : yield* Option.match(head.header.parent, {
-    onNone: () => Effect.succeed([]),
-    onSome: (parent) => parent.through <= 0 ? Effect.succeed([]) : harnessAfter(log, parent.id, after, parent.through)
-  }), ...own];
-});
-export const compatibilityCommit = (log, id, plan) => {
-  const attempt = (tries) => Effect.gen(function* () {
-    const head = yield* log.head(id).pipe(Effect.mapError(storageFailure)), planned = yield* plan(head);
-    return yield* log.commit(id, { expect: head.revision, notAfter: Option.none(), state: Option.none(), events: planned.drafts }).pipe(Effect.map((committed) => ({ committed, result: planned.result })), Effect.catchTag("RevisionConflict", (conflict) => tries >= 32 ? Effect.fail(storageFailure(conflict)) : tries < 4 ? attempt(tries + 1) : Random.nextIntBetween(1, Math.min(2 ** (tries - 3), 50)).pipe(Effect.flatMap((wait) => Effect.sleep(`${wait} millis`)), Effect.andThen(attempt(tries + 1)))), Effect.mapError((error) => error instanceof HarnessError ? error : storageFailure(error)));
-  });
-  return attempt(0);
-}, compatibilityListing = (log, owner, parent = Option.none()) => Effect.gen(function* () {
-  const heads = yield* log.list({ owner, limit: Number.MAX_SAFE_INTEGER, before: Option.none(), parent }).pipe(Effect.mapError(storageFailure)), children = yield* Effect.forEach(heads, (head) => compatibilityListing(log, owner, Option.some(head.header.id)));
-  return [...heads, ...children.flat()].sort((a, b) => b.header.createdAt - a.header.createdAt);
-});
-const recordOf = (head) => Schema.decodeUnknownEffect(SessionRecord)({
-  id: head.header.id,
-  workspace: head.header.owner,
-  profile: head.header.meta.profile ?? "smith",
-  createdAt: head.header.createdAt,
-  ...Option.match(head.header.parent, { onNone: () => typeof head.header.meta.legacyParent === "string" ? { parent: head.header.meta.legacyParent } : {}, onSome: (parent) => ({ parent: parent.id }) })
-}).pipe(Effect.mapError((error) => new HarnessError({ code: "session.decode", message: String(error) }))), decodedHarness = (id, events) => Effect.forEach(events, (event) => eventOf(event.data.event).pipe(Effect.map((decoded) => ({ ...decoded, sessionId: id })), Effect.mapError(decodeFailure)));
-export const harnessHistory = (log, id, after = -1) => harnessAfter(log, id, after).pipe(Effect.flatMap((events) => decodedHarness(id, events))), harnessEvent = (id, body, seq, at) => ({ ...body, version: 1, id: crypto.randomUUID(), sessionId: id, seq, at });
-const isHarness = (event) => event.kind === HARNESS;
-export const SessionStoreProjectionLive = Layer.effect(SessionStore, Effect.gen(function* () {
-  const log = yield* SessionLog;
-  return SessionStore.of({
-    create: (workspace, profile) => Clock.currentTimeMillis.pipe(Effect.flatMap((createdAt) => log.create({
-      id: ConversationId.make(crypto.randomUUID()),
-      owner: workspace,
-      origin: "harness",
-      createdAt,
-      meta: { workspace, profile, projection: "harness" },
-      parent: Option.none()
-    })), Effect.flatMap(recordOf), Effect.mapError((error) => error instanceof HarnessError ? error : storageFailure(error))),
-    get: (id) => log.head(id).pipe(Effect.mapError(storageFailure), Effect.flatMap(recordOf)),
-    list: (workspace) => compatibilityListing(log, workspace).pipe(Effect.flatMap((heads) => Effect.forEach(heads.filter((head) => head.header.origin !== "task"), recordOf))),
-    read: (id, after) => harnessHistory(log, id, after),
-    append: (id, body) => compatibilityCommit(log, id, (head) => Effect.gen(function* () {
-      const last = yield* compatibilityLast(log, id, [HARNESS], head.seq), previous = yield* Option.match(last, {
-        onNone: () => Effect.succeed(-1),
-        onSome: (event) => eventOf(event.data.event).pipe(Effect.map((decoded) => decoded.seq), Effect.mapError(decodeFailure))
-      }), event = harnessEvent(id, body, previous + 1, yield* Clock.currentTimeMillis);
-      return { drafts: [{ kind: HARNESS, turn: Option.none(), data: { event } }], result: event };
-    })).pipe(Effect.map((done) => done.result)),
-    fork: (id, through) => Effect.gen(function* () {
-      const parent = yield* log.head(id).pipe(Effect.mapError(storageFailure));
-      if ((yield* harnessHistory(log, id)).filter((event) => event.seq <= through).reduce((runs, event) => event.runId === void 0 ? runs : event.name === "run.started" ? [...runs, event.runId] : SETTLED.includes(event.name) ? runs.filter((run) => run !== event.runId) : runs, []).length > 0)
-        return yield* Effect.fail(new HarnessError({ code: "session.fork-boundary", message: "Fork at a settled turn boundary" }));
-      const journal = yield* compatibilityHistory(log, id, []), lastIndex = journal.findLastIndex((event) => isHarness(event) && harnessSeqOf(event) <= through), endIndex = Option.flatMap(Option.fromNullishOr(journal[lastIndex]), (last) => Option.flatMap(Option.fromNullishOr(journal.slice(lastIndex + 1).find((event) => isHarness(event) || event.kind === "turn.ended" && event.session === last.session && Option.isSome(last.turn) && Option.contains(event.turn, last.turn.value))), (next) => isHarness(next) ? Option.none() : Option.some(journal.indexOf(next)))), boundaryIndex = Option.getOrElse(endIndex, () => lastIndex), inherited = journal.slice(0, boundaryIndex + 1), boundary = Option.fromNullishOr(journal[boundaryIndex]), inheritedCut = Option.exists(boundary, (event) => event.session !== id), copied = inheritedCut ? inherited.filter((event) => isHarness(event) || event.kind.startsWith("conversation.")) : [], turnAtFork = inherited.reduce((turns, event) => Option.match(event.turn, { onNone: () => turns, onSome: (turn) => Math.max(turns, turn) }), 0), created = yield* log.create({
-        id: ConversationId.make(crypto.randomUUID()),
-        owner: parent.header.owner,
-        origin: parent.header.origin,
-        createdAt: yield* Clock.currentTimeMillis,
-        meta: { ...parent.header.meta, legacyParent: id },
-        parent: Option.some({ id, through: inheritedCut ? 0 : Option.match(boundary, { onNone: () => 0, onSome: (event) => event.seq }), turnAtFork })
-      }).pipe(Effect.mapError(storageFailure));
-      if (copied.length > 0)
-        yield* compatibilityCommit(log, created.header.id, () => Effect.succeed({ drafts: copied.map((event) => ({ kind: event.kind, turn: Option.none(), data: event.data })), result: void 0 })).pipe(Effect.onError(() => log.remove(created.header.id).pipe(Effect.ignore)));
-      return yield* recordOf(created);
-    }).pipe(Effect.uninterruptible)
-  });
-}));

package/dist/compatibility.adapter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/legacy-session.adapter.d.ts

@@ -1,24 +0,0 @@
-import { Database } from "bun:sqlite";
-import { Option } from "effect";
-/** What importing one source did: refused (nothing written), or imported, with the rows it could not decode and skipped. */
-export interface LegacyImport {
-    readonly refused: Option.Option<string>;
-    readonly skipped: ReadonlyArray<string>;
-}
-/**
- * The import bookkeeping: the sources already imported, and the sessions
- * removed since (a removed session is never imported again, whatever path
- * its source is found at).
- */
-export declare const LEGACY_BOOKKEEPING = "\n  CREATE TABLE IF NOT EXISTS session_log_imports (source TEXT PRIMARY KEY, imported_at INTEGER NOT NULL);\n  CREATE TABLE IF NOT EXISTS session_log_tombstones (session_id TEXT PRIMARY KEY, removed_at INTEGER NOT NULL);\n";
-/**
- * Import frozen pre-log tables once, in the destination's IMMEDIATE
- * transaction. Sources stay read only. A session is matched by id whatever
- * path its source is found at: events it already holds are not imported
- * again, a removed session is not imported again, and an orphan message row
- * (written under a harness id with no conversation row) joins the session
- * stored under its id, with that session's owner. A conflicting identity or
- * position refuses the entire source before any row is changed; a row that
- * does not decode is skipped and reported.
- */
-export declare const importLegacySessions: (database: Database, source: Database, sourceId: string, owner?: Option.Option<string>) => LegacyImport;

package/dist/legacy-session.adapter.js

@@ -1,80 +0,0 @@
-import { Database } from "bun:sqlite";
-import { Option, Result, Schema } from "effect";
-import { canonicalJson, SessionEvent, SessionRecord } from "@xandreed/core";
-const decodeRecord = Schema.decodeUnknownResult(Schema.fromJsonString(SessionRecord)), decodeEvent = Schema.decodeUnknownResult(Schema.fromJsonString(SessionEvent)), hasTable = (database, name) => database.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) !== null;
-export const LEGACY_BOOKKEEPING = `
-  CREATE TABLE IF NOT EXISTS session_log_imports (source TEXT PRIMARY KEY, imported_at INTEGER NOT NULL);
-  CREATE TABLE IF NOT EXISTS session_log_tombstones (session_id TEXT PRIMARY KEY, removed_at INTEGER NOT NULL);
-`;
-const HARNESS_KINDS = ["harness.event"], CONVERSATION_KINDS = ["conversation.message", "conversation.checkpoint", "conversation.title", "conversation.outcome"], placeOf = (event) => {
-  const inner = event.data.event;
-  if (event.kind === "conversation.message" && typeof event.data.position === "number")
-    return Option.some(`${event.kind}:${event.data.position}`);
-  return event.kind === "harness.event" && typeof inner === "object" && inner !== null && "seq" in inner && typeof inner.seq === "number" ? Option.some(`${event.kind}:${inner.seq}`) : Option.none();
-};
-export const importLegacySessions = (database, source, sourceId, owner = Option.none()) => database.transaction(() => {
-  database.exec(LEGACY_BOOKKEEPING);
-  if (database.query("SELECT source FROM session_log_imports WHERE source = ?").get(sourceId) !== null)
-    return { refused: Option.none(), skipped: [] };
-  const removed = (id) => database.query("SELECT session_id FROM session_log_tombstones WHERE session_id = ?").get(id) !== null, stored = (id) => Option.fromNullishOr(database.query("SELECT owner, origin, created_at FROM session_heads WHERE id = ?").get(id)), records = hasTable(source, "harness_sessions") ? source.query("SELECT id, body FROM harness_sessions ORDER BY rowid").all().map((row) => ({ row, decoded: decodeRecord(row.body) })) : [], harness = records.flatMap(({ decoded }) => Result.match(decoded, { onFailure: () => [], onSuccess: (record) => [record] })).map((record) => {
-    const rows = source.query("SELECT seq, body FROM harness_events WHERE session_id = ? ORDER BY seq").all(record.id).map((row) => ({ row, decoded: decodeEvent(row.body) }));
-    return { plan: {
-      id: record.id,
-      owner: record.workspace,
-      origin: "harness",
-      createdAt: record.createdAt,
-      kinds: HARNESS_KINDS,
-      meta: { workspace: record.workspace, profile: record.profile, projection: "harness", ...Option.match(Option.fromNullishOr(record.parent), { onNone: () => ({}), onSome: (parent) => ({ legacyParent: parent }) }) },
-      events: rows.flatMap(({ decoded }) => Result.match(decoded, { onFailure: () => [], onSuccess: (event) => [{ kind: "harness.event", at: event.at, data: { event } }] }))
-    }, skipped: rows.flatMap(({ row, decoded }) => Result.match(decoded, { onFailure: (issue) => [`harness event ${record.id}#${row.seq}: ${String(issue)}`], onSuccess: () => [] })) };
-  }), messages = hasTable(source, "messages"), conversations = hasTable(source, "conversations"), conversationRows = conversations ? source.query("SELECT id, workspace_dir, title, created_at FROM conversations ORDER BY rowid").all() : [], orphanRows = messages ? source.query(`SELECT conversation_id AS id, MIN(created_at) AS created_at FROM messages ${conversations ? "WHERE conversation_id NOT IN (SELECT id FROM conversations)" : ""} GROUP BY conversation_id`).all().map((row) => {
-    const target = stored(row.id), planned = Option.fromNullishOr(harness.find((entry) => entry.plan.id === row.id)?.plan);
-    return {
-      id: row.id,
-      title: null,
-      workspace_dir: Option.getOrElse(Option.orElse(Option.map(target, (head) => head.owner), () => Option.map(planned, (plan) => plan.owner)), () => Option.getOrElse(owner, () => "conversation-store")),
-      created_at: Option.getOrElse(Option.orElse(Option.map(target, (head) => head.created_at), () => Option.map(planned, (plan) => plan.createdAt)), () => row.created_at)
-    };
-  }) : [], checkpoints = hasTable(source, "checkpoints"), outcomes = hasTable(source, "run_outcomes"), conversationPlans = [...conversationRows, ...orphanRows].map((row) => ({
-    id: row.id,
-    owner: row.workspace_dir ?? "conversation-store",
-    origin: "conversation",
-    createdAt: row.created_at,
-    kinds: CONVERSATION_KINDS,
-    meta: { workspace: row.workspace_dir ?? "conversation-store", projection: "conversation" },
-    events: [
-      ...messages ? source.query("SELECT position, content, created_at FROM messages WHERE conversation_id = ? ORDER BY position").all(row.id).map((message) => ({ kind: "conversation.message", at: message.created_at, data: { position: message.position, content: message.content } })) : [],
-      ...checkpoints ? source.query("SELECT message_position, summary, created_at FROM checkpoints WHERE conversation_id = ? ORDER BY rowid").all(row.id).map((checkpoint) => ({ kind: "conversation.checkpoint", at: checkpoint.created_at, data: { messagePosition: checkpoint.message_position, summary: checkpoint.summary, createdAt: checkpoint.created_at } })) : [],
-      ...row.title === null ? [] : [{ kind: "conversation.title", at: row.created_at, data: { title: row.title } }],
-      ...outcomes ? source.query("SELECT at, outcome, reason FROM run_outcomes WHERE conversation_id = ? ORDER BY at, rowid").all(row.id).map((outcome) => ({ kind: "conversation.outcome", at: outcome.at, data: { outcome: outcome.outcome, reason: outcome.reason, at: outcome.at } })) : []
-    ]
-  })), skipped = [
-    ...records.flatMap(({ row, decoded }) => Result.match(decoded, { onFailure: (issue) => [`harness session ${row.id}: ${String(issue)}`], onSuccess: () => [] })),
-    ...harness.flatMap((entry) => entry.skipped)
-  ], plans = [...harness.map((entry) => entry.plan), ...conversationPlans].filter((plan) => !removed(plan.id)), identityConflict = plans.find((plan) => plans.some((other) => other.id === plan.id && other.owner !== plan.owner) || Option.exists(stored(plan.id), (head) => head.owner !== plan.owner || head.origin === plan.origin && head.created_at !== plan.createdAt));
-  if (identityConflict !== void 0)
-    return { refused: Option.some(`session ${identityConflict.id} has a conflicting legacy identity`), skipped };
-  const indexed = plans.map((plan) => {
-    const previous = database.query(`SELECT kind, data FROM session_log_events WHERE session_id = ? AND kind IN (${plan.kinds.map(() => "?").join(", ")}) ORDER BY seq`).all(plan.id, ...plan.kinds).map((row) => ({ kind: row.kind, data: JSON.parse(row.data) })).map((event) => ({ place: placeOf(event), content: `${event.kind}
-${canonicalJson(event.data)}` })), places = new Map(previous.flatMap((event) => Option.toArray(Option.map(event.place, (place) => [place, event.content])))), present = new Set(previous.map((event) => event.content)), incoming = plan.events.map((event) => ({ event, place: placeOf(event), content: `${event.kind}
-${canonicalJson(event.data)}` }));
-    return {
-      plan,
-      conflict: incoming.some((entry) => Option.exists(entry.place, (place) => Option.exists(Option.fromNullishOr(places.get(place)), (content) => content !== entry.content))),
-      fresh: incoming.filter((entry) => !present.has(entry.content)).map((entry) => entry.event)
-    };
-  }), positionConflict = indexed.find((entry) => entry.conflict);
-  if (positionConflict !== void 0)
-    return { refused: Option.some(`session ${positionConflict.plan.id} has a conflicting legacy position`), skipped };
-  const header = database.query("INSERT OR IGNORE INTO session_heads (id, owner, origin, created_at, meta, updated_at) VALUES (?, ?, ?, ?, ?, ?)"), insert = database.query("INSERT INTO session_log_events (session_id, seq, turn, kind, at, data) VALUES (?, ?, NULL, ?, ?, ?)");
-  indexed.forEach(({ plan, fresh }) => {
-    header.run(plan.id, plan.owner, plan.origin, plan.createdAt, JSON.stringify(plan.meta), plan.createdAt);
-    if (fresh.length === 0)
-      return;
-    const base = database.query("SELECT seq FROM session_heads WHERE id = ?").get(plan.id)?.seq ?? 0;
-    fresh.forEach((event, index) => insert.run(plan.id, base + index + 1, event.kind, event.at, JSON.stringify(event.data)));
-    database.query("UPDATE session_heads SET seq = ?, revision = revision + 1, updated_at = MAX(updated_at, ?) WHERE id = ?").run(base + fresh.length, fresh.reduce((latest, event) => Math.max(latest, event.at), 0), plan.id);
-  });
-  database.query("INSERT INTO session_log_imports VALUES (?, ?)").run(sourceId, Date.now());
-  return { refused: Option.none(), skipped };
-}).immediate();

package/dist/legacy-session.adapter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/store/sqliteStore.d.ts

@@ -1,20 +0,0 @@
-import { Effect, Layer } from "effect";
-import { ConversationStore, SessionLog, StoreError } from "@xandreed/core";
-/**
- * @deprecated Positional conversation API projected over the host's unified SessionLog.
- *
- * Over this package's SQLite log it lists a workspace in one query and prunes
- * in one transaction, and `legacy` imports the host's own older message file
- * into it first (orphan rows without a session default to `owner`). Over any
- * other log the listing reads each conversation's first message and latest
- * title and outcome, pruning needs the host's `prune`, and `legacy` fails.
- */
-export declare const ConversationStoreProjectionLive: (options?: {
-    readonly prune?: (beforeEpochMs: number) => Effect.Effect<number, StoreError>;
-    readonly legacy?: {
-        readonly paths: ReadonlyArray<string>;
-        readonly owner: string;
-    };
-}) => Layer.Layer<ConversationStore, StoreError, SessionLog>;
-/** @deprecated Convenience host composition: the projection over one SQLite session log, opened once. */
-export declare const SqliteConversationStoreLive: (dbPath: string) => Layer.Layer<ConversationStore, StoreError>;

package/dist/store/sqliteStore.js

@@ -1,100 +0,0 @@
-import { Clock, Effect, Layer, Option, Result, Schema } from "effect";
-import { AgentMessage, Checkpoint, ConversationId, ConversationStore, ConversationSummary, HarnessError, RunOutcomeRecord, SessionLog, StoredMessage, StoreError } from "@xandreed/core";
-import { compatibilityCommit, compatibilityHistory, compatibilityLast } from "../compatibility.adapter.js";
-import { makeSessionLogSqlite, sqliteLogInternals } from "../session-log.adapter.js";
-const MESSAGE = "conversation.message", CHECKPOINT = "conversation.checkpoint", TITLE = "conversation.title", OUTCOME = "conversation.outcome", failed = (error) => new StoreError({ message: error instanceof Error ? error.message : String(error) }), decodeMessage = Schema.decodeUnknownResult(Schema.fromJsonString(AgentMessage)), decodeListedOutcome = Schema.decodeUnknownResult(Schema.Struct({
-  outcome: Schema.Literals(["ok", "partial"]),
-  reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
-})), draft = (kind, data) => ({ kind, data, turn: Option.none() }), positioned = (events) => Effect.forEach(events.filter((event) => event.kind === MESSAGE), (event) => {
-  const decoded = decodeMessage(typeof event.data.content === "string" ? event.data.content : "");
-  return Result.match(decoded, {
-    onFailure: (issue) => Effect.logWarning(`conversation ${event.session}: skipping undecodable message at ${event.data.position}: ${String(issue)}`).pipe(Effect.as(Option.none())),
-    onSuccess: (message) => typeof event.data.position === "number" ? Effect.succeed(Option.some(new StoredMessage({ position: event.data.position, message }))) : Effect.succeed(Option.none())
-  });
-}).pipe(Effect.map((rows) => rows.flatMap(Option.toArray))), latestFold = (events, upTo = Number.MAX_SAFE_INTEGER) => events.filter((event) => event.kind === CHECKPOINT && Number(event.data.messagePosition) <= upTo).reduce((best, event) => Option.match(best, {
-  onNone: () => Option.some(event),
-  onSome: (current) => Number(event.data.messagePosition) >= Number(current.data.messagePosition) ? Option.some(event) : best
-}), Option.none()), summaryOf = (row) => {
-  const first = Option.flatMap(row.first, (data) => typeof data.content === "string" ? Result.getSuccess(decodeMessage(data.content)) : Option.none());
-  return new ConversationSummary({
-    id: row.id,
-    createdAt: row.createdAt,
-    title: Option.flatMap(row.title, (data) => typeof data.title === "string" ? Option.some(data.title) : Option.none()),
-    firstPrompt: Option.flatMap(first, (message) => message.role === "user" ? Option.some(message.content.slice(0, 120)) : Option.none()),
-    lastOutcome: Option.flatMap(row.outcome, (data) => Result.getSuccess(decodeListedOutcome({ outcome: data.outcome, reason: data.reason })))
-  });
-};
-export const ConversationStoreProjectionLive = (options = {}) => Layer.effect(ConversationStore, Effect.gen(function* () {
-  const log = yield* SessionLog, sqlite = sqliteLogInternals(log), legacy = Option.fromNullishOr(options.legacy);
-  if (Option.isSome(legacy))
-    yield* Option.match(sqlite, {
-      onNone: () => Effect.fail(new StoreError({ message: "importing an older conversation file requires the SQLite session log" })),
-      onSome: (internals) => internals.importLegacy(legacy.value.paths, Option.some(legacy.value.owner)).pipe(Effect.mapError(failed))
-    });
-  const orEmpty = (read, empty) => read.pipe(Effect.catchTag("HarnessError", (error) => error.code === "session.missing" ? Effect.succeed(empty) : Effect.fail(error)), Effect.mapError(failed)), read = (id) => orEmpty(compatibilityHistory(log, id, [MESSAGE, CHECKPOINT, TITLE, OUTCOME]), []), last = (id, kind, upTo) => orEmpty(compatibilityLast(log, id, [kind], upTo), Option.none()), checkpointOf = (id, events) => Option.match(latestFold(events), {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (latest) => Schema.decodeUnknownEffect(Checkpoint)({ conversationId: id, ...latest.data }).pipe(Effect.map(Option.some), Effect.mapError(failed))
-  }), ensure = (id) => log.head(id).pipe(Effect.catchTag("SessionMissing", () => Clock.currentTimeMillis.pipe(Effect.flatMap((createdAt) => log.create({
-    id,
-    owner: "conversation-store",
-    origin: "conversation",
-    createdAt,
-    meta: { projection: "conversation", workspace: "conversation-store" },
-    parent: Option.none()
-  }).pipe(Effect.catchTag("SessionExists", () => log.head(id)))))), Effect.mapError(failed), Effect.asVoid), commit = (id, plan) => ensure(id).pipe(Effect.andThen(compatibilityCommit(log, id, (head) => plan(head).pipe(Effect.mapError((error) => new HarnessError({ code: "conversation.store", message: error.message }))))), Effect.map((done) => done.result), Effect.mapError(failed)), lastPosition = (id, head) => last(id, MESSAGE, head.seq).pipe(Effect.map(Option.match({ onNone: () => -1, onSome: (event) => Number(event.data.position) }))), appendAll = (id, messages) => messages.length === 0 ? Effect.succeed([]) : commit(id, (head) => lastPosition(id, head).pipe(Effect.map((previous) => {
-    const positions = messages.map((_, index) => previous + index + 1);
-    return { drafts: messages.map((message, index) => draft(MESSAGE, { position: positions[index], content: JSON.stringify(message) })), result: positions };
-  }))), checkpointAt = (id, summary, messagePosition) => commit(id, () => Clock.currentTimeMillis.pipe(Effect.map((createdAt) => ({
-    drafts: [draft(CHECKPOINT, { summary, messagePosition, createdAt })],
-    result: void 0
-  })))), latestOutcome = (id) => last(id, OUTCOME).pipe(Effect.flatMap(Option.match({
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (latest) => Schema.decodeUnknownEffect(RunOutcomeRecord)({ conversationId: id, ...latest.data }).pipe(Effect.map(Option.some), Effect.mapError(failed))
-  }))), overviews = (owner) => log.list({ owner, limit: Number.MAX_SAFE_INTEGER, before: Option.none(), parent: Option.none() }).pipe(Effect.mapError(failed), Effect.map((heads) => heads.filter((head) => head.header.origin === "conversation").sort((a, b) => b.header.createdAt - a.header.createdAt || (a.header.id < b.header.id ? 1 : -1))), Effect.flatMap((heads) => Effect.forEach(heads, (head) => Effect.gen(function* () {
-    const first = yield* log.read(head.header.id, { after: 0, limit: Option.some(1), kinds: [MESSAGE] }).pipe(Effect.mapError(failed)), title = yield* last(head.header.id, TITLE), outcome = yield* last(head.header.id, OUTCOME);
-    return { id: head.header.id, createdAt: head.header.createdAt, first: Option.map(Option.fromNullishOr(first[0]), (event) => event.data), title: Option.map(title, (event) => event.data), outcome: Option.map(outcome, (event) => event.data) };
-  }))));
-  return ConversationStore.of({
-    create: (workspace = "conversation-store") => Clock.currentTimeMillis.pipe(Effect.flatMap((createdAt) => log.create({
-      id: ConversationId.make(crypto.randomUUID()),
-      owner: workspace,
-      origin: "conversation",
-      createdAt,
-      meta: { workspace, projection: "conversation" },
-      parent: Option.none()
-    })), Effect.map((head) => head.header.id), Effect.mapError(failed)),
-    append: (id, message) => appendAll(id, [message]).pipe(Effect.map((positions) => positions[0] ?? 0)),
-    appendAll,
-    list: (id) => read(id).pipe(Effect.flatMap(positioned), Effect.map((rows) => rows.map((row) => row.message))),
-    listActive: (id) => read(id).pipe(Effect.flatMap((events) => Effect.all([positioned(events), checkpointOf(id, events)])), Effect.map(([rows, checkpoint]) => rows.filter((row) => row.position > Option.match(checkpoint, { onNone: () => -1, onSome: (fold) => fold.messagePosition })))),
-    checkpoint: (id, summary) => commit(id, (head) => Effect.gen(function* () {
-      const messagePosition = yield* lastPosition(id, head);
-      return { drafts: [draft(CHECKPOINT, { summary, messagePosition, createdAt: yield* Clock.currentTimeMillis })], result: void 0 };
-    })),
-    checkpointAt,
-    latestCheckpoint: (id) => read(id).pipe(Effect.flatMap((events) => checkpointOf(id, events))),
-    setTitle: (id, title) => commit(id, () => Effect.succeed({ drafts: [draft(TITLE, { title })], result: void 0 })),
-    recordOutcome: (id, outcome, reason) => commit(id, () => Clock.currentTimeMillis.pipe(Effect.map((at) => ({ drafts: [draft(OUTCOME, { at, outcome, reason })], result: void 0 })))),
-    latestOutcome,
-    listByWorkspace: (workspace) => Option.match(sqlite, {
-      onNone: () => overviews(workspace),
-      onSome: (internals) => internals.conversations(workspace).pipe(Effect.mapError(failed))
-    }).pipe(Effect.map((rows) => rows.map(summaryOf))),
-    fork: (id, upToPosition = Number.MAX_SAFE_INTEGER) => Effect.gen(function* () {
-      const source = yield* log.head(id).pipe(Effect.mapError((error) => new StoreError({ message: `conversation ${id} not found: ${String(error)}` }))), records = yield* read(id), messages = records.filter((event) => event.kind === MESSAGE && Number(event.data.position) <= upToPosition), checkpoint = latestFold(records, upToPosition), title = records.filter((event) => event.kind === TITLE).at(-1)?.data.title, created = yield* log.create({
-        id: ConversationId.make(crypto.randomUUID()),
-        owner: source.header.owner,
-        origin: "conversation",
-        createdAt: yield* Clock.currentTimeMillis,
-        meta: { ...source.header.meta, forkedFrom: id, projection: "conversation" },
-        parent: Option.none()
-      }).pipe(Effect.mapError(failed));
-      yield* commit(created.header.id, () => Effect.succeed({ drafts: [...messages.map((event) => draft(event.kind, event.data)), ...Option.toArray(Option.map(checkpoint, (fold) => draft(fold.kind, fold.data))), ...typeof title === "string" ? [draft(TITLE, { title: `fork: ${title}` })] : []], result: void 0 })).pipe(Effect.onError(() => log.remove(created.header.id).pipe(Effect.ignore)));
-      return created.header.id;
-    }).pipe(Effect.uninterruptible),
-    prune: options.prune ?? ((before) => Option.match(sqlite, {
-      onNone: () => Effect.fail(new StoreError({ message: "pruning requires the storage host's explicit retention adapter" })),
-      onSome: (internals) => internals.prune(before).pipe(Effect.mapError(failed))
-    }))
-  });
-})), SqliteConversationStoreLive = (dbPath) => Layer.unwrap(makeSessionLogSqlite(dbPath).pipe(Effect.mapError(failed), Effect.map((log) => ConversationStoreProjectionLive().pipe(Layer.provide(Layer.succeed(SessionLog, log))))));

package/dist/store/sqliteStore.test.d.ts

@@ -1 +0,0 @@
-export {};