@xandreed/plugin-session-sqlite 0.3.0 → 0.8.0-next.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/plugin-session-sqlite
 
-Efferent composable agent framework, 0.3.0. Bun on Linux.
+Efferent composable agent framework, 0.8.0-next.0. Bun on Linux.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/compatibility.adapter.d.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,91 @@
+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

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

package/dist/index.d.ts

@@ -1,6 +1,19 @@
 import { Layer } from "effect";
-import { HarnessError, SessionStore } from "@xandreed/core";
-export declare const SessionStoreLive: (path: string) => Layer.Layer<SessionStore, HarnessError, never>;
-export declare const sessionSqlitePlugin: import("@xandreed/core").Plugin;
+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>;
+/** 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>;
 export default sessionSqlitePlugin;
-export { SqliteConversationStoreLive } from "./store/sqliteStore.js";
+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,60 +1,19 @@
-import { Database } from "bun:sqlite";
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
 import { Effect, Layer, Schema } from "effect";
-import { ConversationId, definePlugin, HarnessError, SessionEvent, SessionRecord, SessionStore } from "@xandreed/core";
-const Config = Schema.Struct({ path: Schema.String }), decodeRecord = Schema.decodeUnknownSync(Schema.parseJson(SessionRecord)), decodeEvent = Schema.decodeUnknownSync(Schema.parseJson(SessionEvent));
-export const SessionStoreLive = (path) => Layer.scoped(SessionStore, Effect.gen(function* () {
-  yield* Effect.tryPromise({ try: () => mkdir(dirname(path), { recursive: !0 }), catch: (error) => new HarnessError({ code: "store.open", message: String(error) }) });
-  const db = yield* Effect.acquireRelease(Effect.try({ try: () => new Database(path, { create: !0, strict: !0 }), catch: (error) => new HarnessError({ code: "store.open", message: String(error) }) }), (database) => Effect.sync(() => database.close())), operation = (work) => Effect.try({ try: work, catch: (error) => new HarnessError({ code: "store.io", message: String(error) }) });
-  yield* operation(() => db.exec(`
-    PRAGMA journal_mode = WAL;
-    PRAGMA busy_timeout = 5000;
-    PRAGMA foreign_keys = ON;
-    CREATE TABLE IF NOT EXISTS harness_sessions (id TEXT PRIMARY KEY, workspace TEXT NOT NULL, body TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS harness_events (session_id TEXT NOT NULL REFERENCES harness_sessions(id), seq INTEGER NOT NULL, body TEXT NOT NULL, PRIMARY KEY(session_id, seq));
-  `));
-  const insert = (record) => {
-    db.query("INSERT INTO harness_sessions VALUES (?, ?, ?)").run(record.id, record.workspace, JSON.stringify(record));
-    return record;
-  }, get = (id) => operation(() => db.query("SELECT body FROM harness_sessions WHERE id = ?").get(id)).pipe(Effect.flatMap((row) => row === null ? Effect.fail(new HarnessError({ code: "session.missing", message: `Session ${id} does not exist` })) : operation(() => decodeRecord(row.body)))), read = (id, after) => get(id).pipe(Effect.zipRight(operation(() => db.query("SELECT body FROM harness_events WHERE session_id = ? AND seq > ? ORDER BY seq").all(id, after).map((row) => decodeEvent(row.body)))));
-  return SessionStore.of({
-    create: (workspace, profile) => operation(() => insert({ id: ConversationId.make(crypto.randomUUID()), workspace, profile, createdAt: Date.now() })),
-    get,
-    list: (workspace) => operation(() => db.query("SELECT body FROM harness_sessions WHERE workspace = ? ORDER BY rowid DESC").all(workspace).map((row) => decodeRecord(row.body))),
-    read,
-    append: (id, body) => get(id).pipe(Effect.zipRight(operation(() => db.transaction(() => {
-      const row = db.query("SELECT COALESCE(MAX(seq), -1) + 1 AS seq FROM harness_events WHERE session_id = ?").get(id), event = { ...body, version: 1, id: crypto.randomUUID(), sessionId: id, seq: row?.seq ?? 0, at: Date.now() };
-      db.query("INSERT INTO harness_events VALUES (?, ?, ?)").run(id, event.seq, JSON.stringify(event));
-      return event;
-    })()))),
-    fork: (id, through) => Effect.gen(function* () {
-      const parent = yield* get(id), trail = (yield* read(id, -1)).filter((event) => event.seq <= through);
-      if (trail.reduce((runs, event) => {
-        if (event.runId === void 0)
-          return runs;
-        if (event.name === "run.started")
-          return [...runs, event.runId];
-        if (["run.completed", "run.failed", "run.cancelled"].includes(event.name))
-          return runs.filter((run) => run !== event.runId);
-        return runs;
-      }, []).length > 0)
-        return yield* Effect.fail(new HarnessError({ code: "session.fork-boundary", message: "Fork at a settled turn boundary" }));
-      return yield* operation(() => db.transaction(() => {
-        const record = insert({ ...parent, id: ConversationId.make(crypto.randomUUID()), parent: id, createdAt: Date.now() });
-        trail.forEach((event, seq) => db.query("INSERT INTO harness_events VALUES (?, ?, ?)").run(record.id, seq, JSON.stringify({ ...event, sessionId: record.id, id: crypto.randomUUID(), seq })));
-        return record;
-      })());
-    })
-  });
-})), sessionSqlitePlugin = definePlugin({
+import { definePlugin, SessionEnvironment, SessionLog, SessionStore, TurnAdmission, TurnAdmissionOpen } from "@xandreed/core";
+import { SessionStoreProjectionLive } from "./compatibility.adapter.js";
+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({
   id: "@xandreed/plugin-session-sqlite",
-  version: "0.3.0",
+  version: "0.8.0-next.0",
   scope: "runtime",
   config: Config,
-  defaults: { path: ".efferent/runtime/sessions.db" },
-  provides: [SessionStore],
-  layer: ({ path }) => SessionStoreLive(path)
+  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 }))))
 });
 export default sessionSqlitePlugin;
-export { SqliteConversationStoreLive } from "./store/sqliteStore.js";
+export { ConversationStoreProjectionLive, SqliteConversationStoreLive } from "./store/sqliteStore.js";
+export { SessionStoreProjectionLive } from "./compatibility.adapter.js";
+export { SessionLogSqliteLive, sessionLogSqlitePlugin } from "./session-log.adapter.js";

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,80 @@
+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

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

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

@@ -0,0 +1,50 @@
+import { Effect, Layer, Option } 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>;
+/**
+ * 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
+ * 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>;
+/** 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>;
+/** The session log in a SQLite file, as a plugin: provides SessionLog. */
+export declare const sessionLogSqlitePlugin: import("@xandreed/core").TypedPlugin<{
+    readonly path: string;
+}, {
+    readonly path: string;
+}, SessionLog, SessionLogError, never>;

package/dist/session-log.adapter.js

@@ -0,0 +1,181 @@
+import { Database } from "bun:sqlite";
+import { mkdir } from "node:fs/promises";
+import { chmodSync, existsSync, realpathSync } from "node:fs";
+import { dirname } from "node:path";
+import { Clock, Effect, Layer, Option, Schema } from "effect";
+import {
+  ConversationId,
+  definePlugin,
+  LeaseExpired,
+  RevisionConflict,
+  SessionExists,
+  SessionLog,
+  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),
+    owner: row.owner,
+    origin: row.origin,
+    createdAt: row.created_at,
+    meta: json(row.meta),
+    parent: row.parent_id === null ? Option.none() : Option.some({
+      id: ConversationId.make(row.parent_id),
+      through: row.parent_through ?? 0,
+      turnAtFork: row.turn_at_fork ?? 0
+    })
+  },
+  seq: row.seq,
+  revision: row.revision,
+  state: json(row.state),
+  updatedAt: row.updated_at,
+  now
+}), eventOf = (session) => (row) => ({
+  session,
+  seq: row.seq,
+  turn: Option.fromNullishOr(row.turn),
+  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* () {
+  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));
+  yield* operation(() => db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA busy_timeout = 5000;
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS session_heads (
+      id TEXT PRIMARY KEY, owner TEXT NOT NULL, origin TEXT NOT NULL, created_at INTEGER NOT NULL, meta TEXT NOT NULL,
+      parent_id TEXT REFERENCES session_heads(id) ON DELETE CASCADE, parent_through INTEGER, turn_at_fork INTEGER,
+      seq INTEGER NOT NULL DEFAULT 0, revision INTEGER NOT NULL DEFAULT 0, state TEXT NOT NULL DEFAULT '{}', updated_at INTEGER NOT NULL);
+    CREATE INDEX IF NOT EXISTS session_heads_owner ON session_heads(owner, updated_at DESC, id DESC);
+    CREATE INDEX IF NOT EXISTS session_heads_parent ON session_heads(parent_id);
+    CREATE TABLE IF NOT EXISTS session_log_events (
+      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({
+    create: (header) => Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis, outcome = yield* operation(() => db.transaction(() => {
+        if (headRow(header.id) !== null)
+          return "exists";
+        if (Option.isSome(header.parent) && headRow(header.parent.value.id) === null)
+          return "orphan";
+        const parent = Option.getOrNull(header.parent);
+        db.query("INSERT INTO session_heads (id, owner, origin, created_at, meta, parent_id, parent_through, turn_at_fork, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(header.id, header.owner, header.origin, header.createdAt, JSON.stringify(header.meta), parent?.id ?? null, parent?.through ?? null, parent?.turnAtFork ?? null, now);
+        return "created";
+      }).immediate());
+      if (outcome === "exists")
+        return yield* Effect.fail(new SessionExists({ session: header.id }));
+      if (outcome === "orphan")
+        return yield* Effect.fail(new SessionMissing({ session: Option.match(header.parent, { onNone: () => header.id, onSome: (parent) => parent.id }) }));
+      const row = yield* operation(() => headRow(header.id));
+      return row === null ? yield* Effect.fail(new SessionLogError({ code: "store.io", message: "the new session was not stored" })) : headOf(row, now);
+    }),
+    head: (id) => Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis, row = yield* operation(() => headRow(id));
+      return row === null ? yield* Effect.fail(new SessionMissing({ session: id })) : headOf(row, now);
+    }),
+    list: (query) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => operation(() => {
+      const before = Option.getOrNull(query.before), parent = Option.getOrNull(query.parent);
+      return db.query(`
+        SELECT * FROM session_heads
+        WHERE owner = ? AND ((? IS NULL AND parent_id IS NULL) OR parent_id = ?)
+          AND (? IS NULL OR updated_at < ? OR (updated_at = ? AND id < ?))
+        ORDER BY updated_at DESC, id DESC LIMIT ?`).all(query.owner, parent, parent, before?.updatedAt ?? null, before?.updatedAt ?? null, before?.updatedAt ?? null, before?.id ?? null, Math.max(0, query.limit)).map((row) => headOf(row, now));
+    }))),
+    read: (id, query) => Effect.gen(function* () {
+      if ((yield* operation(() => headRow(id))) === null)
+        return yield* Effect.fail(new SessionMissing({ session: id }));
+      const kinds = query.kinds.length === 0 ? "" : ` AND kind IN (${query.kinds.map(() => "?").join(", ")})`, limit = Option.match(query.limit, { onNone: () => -1, onSome: (value) => Math.max(0, value) });
+      return yield* operation(() => db.query(`SELECT seq, turn, kind, at, data FROM session_log_events WHERE session_id = ? AND seq > ?${kinds} ORDER BY seq LIMIT ?`).all(id, query.after, ...query.kinds, limit).map(eventOf(id)));
+    }),
+    commit: (id, commit) => Clock.currentTimeMillis.pipe(Effect.flatMap((at) => operation(() => db.transaction(() => {
+      const head = db.query("SELECT seq, revision FROM session_heads WHERE id = ?").get(id);
+      if (head === null)
+        return { _tag: "Missing" };
+      if (head.revision !== commit.expect)
+        return { _tag: "Conflict", actual: head.revision };
+      if (Option.isSome(commit.notAfter) && at > commit.notAfter.value)
+        return { _tag: "Expired" };
+      const events = commit.events.map((draft, index) => ({
+        session: id,
+        seq: head.seq + index + 1,
+        turn: draft.turn,
+        kind: draft.kind,
+        at,
+        data: json(JSON.stringify(draft.data))
+      })), insert = db.query("INSERT INTO session_log_events (session_id, seq, turn, kind, at, data) VALUES (?, ?, ?, ?, ?, ?)");
+      events.forEach((event) => insert.run(id, event.seq, Option.getOrNull(event.turn), event.kind, at, JSON.stringify(event.data)));
+      db.query("UPDATE session_heads SET revision = revision + 1, seq = ?, state = COALESCE(?, state), updated_at = ? WHERE id = ?").run(head.seq + events.length, Option.match(commit.state, { onNone: () => null, onSome: (state) => JSON.stringify(state) }), at, id);
+      return { _tag: "Done", committed: { revision: head.revision + 1, seq: head.seq + events.length, events, at } };
+    }).immediate()).pipe(Effect.flatMap((outcome) => {
+      if (outcome._tag === "Done")
+        return Effect.succeed(outcome.committed);
+      if (outcome._tag === "Missing")
+        return Effect.fail(new SessionMissing({ session: id }));
+      if (outcome._tag === "Conflict")
+        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
+  });
+  return log;
+}), SessionLogSqliteLive = (path, options = {}) => Layer.effect(SessionLog, makeSessionLogSqlite(path, options));
+const LogConfig = Schema.Struct({ path: Schema.String });
+export const sessionLogSqlitePlugin = definePlugin({
+  id: "@xandreed/plugin-session-sqlite/log",
+  version: "0.8.0-next.0",
+  scope: "runtime",
+  config: LogConfig,
+  defaults: { path: ".efferent/runtime/sessions.db" },
+  provides: [SessionLog],
+  layer: ({ path }) => SessionLogSqliteLive(path)
+});

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

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

package/dist/store/sqliteStore.d.ts

@@ -1,3 +1,20 @@
-import { Layer } from "effect";
-import { ConversationStore, StoreError } from "@xandreed/core";
-export declare const SqliteConversationStoreLive: (dbPath: string) => Layer.Layer<ConversationStore, StoreError, never>;
+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,175 +1,100 @@
-import { Database } from "bun:sqlite";
-import { chmodSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { Effect, Either, Layer, Option, Schema } from "effect";
-import { AgentMessage, Checkpoint, ConversationId, ConversationStore, ConversationSummary, RunOutcomeRecord, StoredMessage, StoreError } from "@xandreed/core";
-const MIGRATIONS = [
-  `
-  CREATE TABLE IF NOT EXISTS conversations (
-    id TEXT PRIMARY KEY,
-    workspace_dir TEXT,
-    title TEXT,
-    created_at INTEGER NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS messages (
-    conversation_id TEXT NOT NULL,
-    position INTEGER NOT NULL,
-    content TEXT NOT NULL,
-    created_at INTEGER NOT NULL,
-    PRIMARY KEY (conversation_id, position)
-  );
-  CREATE TABLE IF NOT EXISTS checkpoints (
-    conversation_id TEXT NOT NULL,
-    message_position INTEGER NOT NULL,
-    summary TEXT NOT NULL,
-    created_at INTEGER NOT NULL
-  );
-  `,
-  `
-  CREATE INDEX IF NOT EXISTS checkpoints_by_conversation
-    ON checkpoints (conversation_id, message_position);
-  CREATE INDEX IF NOT EXISTS conversations_by_workspace
-    ON conversations (workspace_dir);
-  `,
-  `
-  CREATE TABLE IF NOT EXISTS run_outcomes (
-    conversation_id TEXT NOT NULL,
-    at INTEGER NOT NULL,
-    outcome TEXT NOT NULL,
-    reason TEXT NOT NULL
-  );
-  CREATE INDEX IF NOT EXISTS run_outcomes_by_conversation
-    ON run_outcomes (conversation_id, at);
-  `
-], migrate = (db) => {
-  const version = db.query("PRAGMA user_version").get().user_version;
-  MIGRATIONS.slice(version).forEach((step) => db.transaction(() => db.exec(step))());
-  db.exec(`PRAGMA user_version = ${MIGRATIONS.length}`);
-}, decodeMessage = Schema.decodeUnknownEither(Schema.parseJson(AgentMessage)), tryDb = (run) => Effect.try({
-  try: run,
-  catch: (e) => new StoreError({ message: String(e) })
-}), salvageRows = (rows, where) => Effect.forEach(rows, (row) => Either.match(decodeMessage(row.content), {
-  onLeft: (issue) => Effect.logWarning(`${where}: skipping undecodable message row: ${String(issue)}`).pipe(Effect.as(Option.none())),
-  onRight: (message) => Effect.succeed(Option.some(message))
-})).pipe(Effect.map((decoded) => decoded.filter(Option.isSome).map((some) => some.value))), salvagePositioned = (rows, where) => Effect.forEach(rows, (row) => Either.match(decodeMessage(row.content), {
-  onLeft: (issue) => Effect.logWarning(`${where}: skipping undecodable message row at ${row.position}: ${String(issue)}`).pipe(Effect.as(Option.none())),
-  onRight: (message) => Effect.succeed(Option.some(new StoredMessage({ position: row.position, message })))
-})).pipe(Effect.map((decoded) => decoded.filter(Option.isSome).map((some) => some.value)));
-export const SqliteConversationStoreLive = (dbPath) => Layer.scoped(ConversationStore, Effect.gen(function* () {
-  const db = yield* tryDb(() => {
-    mkdirSync(dirname(dbPath), { recursive: !0 });
-    const database = new Database(dbPath, { create: !0 });
-    chmodSync(dbPath, 384);
-    database.exec("PRAGMA busy_timeout = 5000;");
-    database.exec("PRAGMA journal_mode = WAL;");
-    migrate(database);
-    return database;
+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())
   });
-  yield* Effect.addFinalizer(() => tryDb(() => db.close()).pipe(Effect.catchAll((error) => Effect.logWarning(`conversation database cleanup failed: ${error.message}`))));
-  const latestCheckpointRow = (id) => Option.fromNullable(db.query(`SELECT message_position, summary, created_at FROM checkpoints
-               WHERE conversation_id = ? ORDER BY message_position DESC LIMIT 1`).get(id));
-  return {
-    create: (workspaceDir) => tryDb(() => {
-      const id = ConversationId.make(crypto.randomUUID());
-      db.query("INSERT INTO conversations (id, workspace_dir, title, created_at) VALUES (?, ?, NULL, ?)").run(id, workspaceDir ?? null, Date.now());
-      return id;
-    }),
-    append: (id, message) => tryDb(() => db.query(`INSERT INTO messages (conversation_id, position, content, created_at)
-                     SELECT ?1, COALESCE(MAX(position) + 1, 0), ?2, ?3
-                     FROM messages WHERE conversation_id = ?1
-                     RETURNING position`).get(id, JSON.stringify(message), Date.now()).position),
-    appendAll: (id, messages) => tryDb(() => db.transaction(() => messages.map((message) => db.query(`INSERT INTO messages (conversation_id, position, content, created_at)
-                         SELECT ?1, COALESCE(MAX(position) + 1, 0), ?2, ?3
-                         FROM messages WHERE conversation_id = ?1
-                         RETURNING position`).get(id, JSON.stringify(message), Date.now()).position))()),
-    list: (id) => tryDb(() => db.query("SELECT content FROM messages WHERE conversation_id = ? ORDER BY position ASC").all(id)).pipe(Effect.flatMap((rows) => salvageRows(rows, `list ${id}`))),
-    listActive: (id) => tryDb(() => {
-      const fold = latestCheckpointRow(id), after = Option.match(fold, {
-        onNone: () => -1,
-        onSome: (c) => c.message_position
-      });
-      return db.query(`SELECT position, content FROM messages
-                 WHERE conversation_id = ? AND position > ? ORDER BY position ASC`).all(id, after);
-    }).pipe(Effect.flatMap((rows) => salvagePositioned(rows, `listActive ${id}`))),
-    checkpoint: (id, summary) => tryDb(() => {
-      db.query(`INSERT INTO checkpoints (conversation_id, message_position, summary, created_at)
-               SELECT ?1, COALESCE(MAX(position), -1), ?2, ?3
-               FROM messages WHERE conversation_id = ?1`).run(id, summary, Date.now());
-    }),
-    checkpointAt: (id, summary, messagePosition) => tryDb(() => {
-      db.query(`INSERT INTO checkpoints (conversation_id, message_position, summary, created_at)
-               VALUES (?1, ?2, ?3, ?4)`).run(id, messagePosition, summary, Date.now());
-    }),
-    latestCheckpoint: (id) => tryDb(() => Option.map(latestCheckpointRow(id), (row) => new Checkpoint({
-      conversationId: id,
-      messagePosition: row.message_position,
-      summary: row.summary,
-      createdAt: row.created_at
-    }))),
-    setTitle: (id, title) => tryDb(() => {
-      db.query("UPDATE conversations SET title = ? WHERE id = ?").run(title, id);
-    }),
-    recordOutcome: (id, outcome, reason) => tryDb(() => {
-      db.query("INSERT INTO run_outcomes (conversation_id, at, outcome, reason) VALUES (?, ?, ?, ?)").run(id, Date.now(), outcome, reason);
-    }),
-    latestOutcome: (id) => tryDb(() => Option.fromNullable(db.query(`SELECT at, outcome, reason FROM run_outcomes
-                   WHERE conversation_id = ? ORDER BY at DESC, rowid DESC LIMIT 1`).get(id))).pipe(Effect.flatMap((row) => Option.match(row, {
-      onNone: () => Effect.succeed(Option.none()),
-      onSome: (r) => Schema.decodeUnknown(RunOutcomeRecord)({ conversationId: id, ...r }).pipe(Effect.map(Option.some), Effect.mapError((issue) => new StoreError({ message: String(issue) })))
-    }))),
-    prune: (beforeEpochMs) => tryDb(() => {
-      const removed = db.transaction(() => {
-        const ids = db.query("SELECT id FROM conversations WHERE created_at < ?").all(beforeEpochMs).map((row) => row.id);
-        ids.forEach((id) => {
-          db.query("DELETE FROM messages WHERE conversation_id = ?").run(id);
-          db.query("DELETE FROM checkpoints WHERE conversation_id = ?").run(id);
-          db.query("DELETE FROM conversations WHERE id = ?").run(id);
-        });
-        return ids.length;
-      })();
-      db.exec("PRAGMA wal_checkpoint(TRUNCATE);");
-      return removed;
-    }),
-    fork: (id, upToPosition) => tryDb(() => Option.fromNullable(db.query("SELECT workspace_dir, title FROM conversations WHERE id = ?").get(id))).pipe(Effect.flatMap(Option.match({
-      onNone: () => Effect.fail(new StoreError({ message: `conversation ${id} not found` })),
-      onSome: (source) => tryDb(() => {
-        const forkId = ConversationId.make(crypto.randomUUID()), cap = upToPosition ?? Number.MAX_SAFE_INTEGER;
-        db.transaction(() => {
-          db.query("INSERT INTO conversations (id, workspace_dir, title, created_at) VALUES (?, ?, ?, ?)").run(forkId, source.workspace_dir, source.title === null ? null : `fork: ${source.title}`, Date.now());
-          db.query(`INSERT INTO messages (conversation_id, position, content, created_at)
-                         SELECT ?2, position, content, created_at FROM messages
-                         WHERE conversation_id = ?1 AND position <= ?3`).run(id, forkId, cap);
-          db.query(`INSERT INTO checkpoints (conversation_id, message_position, summary, created_at)
-                         SELECT ?2, message_position, summary, created_at FROM checkpoints
-                         WHERE conversation_id = ?1 AND message_position <= ?3
-                         ORDER BY message_position DESC LIMIT 1`).run(id, forkId, cap);
-        })();
-        return forkId;
-      })
-    }))),
-    listByWorkspace: (workspaceDir) => tryDb(() => db.query(`SELECT c.id, c.created_at, c.title,
-                          (SELECT m.content FROM messages m
-                           WHERE m.conversation_id = c.id ORDER BY m.position ASC LIMIT 1)
-                            AS first_content,
-                          (SELECT o.outcome FROM run_outcomes o
-                           WHERE o.conversation_id = c.id ORDER BY o.at DESC, o.rowid DESC LIMIT 1)
-                            AS last_outcome,
-                          (SELECT o.reason FROM run_outcomes o
-                           WHERE o.conversation_id = c.id ORDER BY o.at DESC, o.rowid DESC LIMIT 1)
-                            AS last_reason
-                   FROM conversations c WHERE c.workspace_dir = ?
-                   ORDER BY c.created_at DESC`).all(workspaceDir).map((row) => {
-      const first = Option.fromNullable(row.first_content).pipe(Option.flatMap((content) => Either.getRight(decodeMessage(content))), Option.flatMap((parsed) => parsed.role === "user" ? Option.some(parsed.content.slice(0, 120)) : Option.none())), lastOutcome = Option.flatMap(Option.all([Option.fromNullable(row.last_outcome), Option.fromNullable(row.last_reason)]), ([outcome, reason]) => Either.getRight(Schema.decodeUnknownEither(Schema.Struct({
-        outcome: Schema.Literal("ok", "partial"),
-        reason: Schema.Literal("completed", "step-cap", "degenerate-loop")
-      }))({ outcome, reason })));
-      return new ConversationSummary({
-        id: ConversationId.make(row.id),
-        createdAt: row.created_at,
-        firstPrompt: first,
-        title: Option.fromNullable(row.title),
-        lastOutcome
-      });
+}).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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/plugin-session-sqlite",
-  "version": "0.3.0",
+  "version": "0.8.0-next.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,8 +10,8 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.3.0",
-    "effect": "3.21.4",
+    "@xandreed/core": "0.8.0-next.0",
+    "effect": "4.0.0-rc.118",
     "ws": "^8.21.0"
   },
   "private": false,