saeeol 1.2.0 → 1.2.1

package/src/session/core/revert.ts

@@ -0,0 +1,173 @@
+import { Effect, Layer, Context, Schema } from "effect"
+import { Bus } from "../../bus"
+import { Snapshot } from "../../snapshot"
+import { Storage } from "@/storage/storage"
+import { SyncEvent } from "../../sync"
+import * as Log from "@saeeol/core/util/log"
+import { zod } from "@/util/effect-zod"
+import { withStatics } from "@/util/schema"
+import * as Session from "./session"
+import { MessageV2 } from "../message/message-v2"
+import { SessionID, MessageID, PartID } from "./schema"
+import { SessionRunState } from "./run-state"
+import { SessionSummary } from "./summary"
+
+const log = Log.create({ service: "session.revert" })
+
+export const RevertInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: MessageID,
+  partID: Schema.optional(PartID),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type RevertInput = Schema.Schema.Type<typeof RevertInput>
+
+export interface Interface {
+  readonly revert: (input: RevertInput) => Effect.Effect<Session.Info>
+  readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info>
+  readonly cleanup: (session: Session.Info) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionRevert") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const sessions = yield* Session.Service
+    const snap = yield* Snapshot.Service
+    const storage = yield* Storage.Service
+    const bus = yield* Bus.Service
+    const summary = yield* SessionSummary.Service
+    const state = yield* SessionRunState.Service
+    const sync = yield* SyncEvent.Service
+
+    const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
+      yield* state.assertNotBusy(input.sessionID)
+      const all = yield* sessions.messages({ sessionID: input.sessionID })
+      let lastUser: MessageV2.User | undefined
+      const session = yield* sessions.get(input.sessionID)
+
+      let rev: Session.Info["revert"]
+      const patches: Snapshot.Patch[] = []
+      for (const msg of all) {
+        if (msg.info.role === "user") lastUser = msg.info
+        const remaining = []
+        for (const part of msg.parts) {
+          if (rev) {
+            if (part.type === "patch") patches.push(part)
+            continue
+          }
+
+          if (!rev) {
+            if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+              const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+              rev = {
+                messageID: !partID && lastUser ? lastUser.id : msg.info.id,
+                partID,
+              }
+            }
+            remaining.push(part)
+          }
+        }
+      }
+
+      if (!rev) return session
+
+      rev.snapshot = session.revert?.snapshot ?? (yield* snap.track())
+      if (session.revert?.snapshot) yield* snap.restore(session.revert.snapshot)
+      // reflects changes being undone (files on disk still have AI modifications)
+      const range = all.filter((msg) => msg.info.id >= rev!.messageID)
+      const diffs = yield* summary.computeDiff({ messages: range })
+
+      yield* snap.revert(patches)
+      if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot as string)
+      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
+      yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
+      const summaryDiffs: Snapshot.SummaryFileDiff[] = diffs.map((d) => ({
+        file: d.file,
+        additions: d.additions,
+        deletions: d.deletions,
+        status: d.status,
+      }))
+      yield* sessions.setRevert({
+        sessionID: input.sessionID,
+        revert: rev,
+        summary: {
+          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+          files: diffs.length,
+          diffs: summaryDiffs, 
+        },
+      })
+      return yield* sessions.get(input.sessionID)
+    })
+
+    const unrevert = Effect.fn("SessionRevert.unrevert")(function* (input: { sessionID: SessionID }) {
+      log.info("unreverting", input)
+      yield* state.assertNotBusy(input.sessionID)
+      const session = yield* sessions.get(input.sessionID)
+      if (!session.revert) return session
+      if (session.revert.snapshot) yield* snap.restore(session.revert!.snapshot!)
+      yield* sessions.clearRevert(input.sessionID)
+      return yield* sessions.get(input.sessionID)
+    })
+
+    const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
+      if (!session.revert) return
+      const sessionID = session.id
+      const msgs = yield* sessions.messages({ sessionID })
+      const messageID = session.revert.messageID
+      const remove = [] as MessageV2.WithParts[]
+      let target: MessageV2.WithParts | undefined
+      for (const msg of msgs) {
+        if (msg.info.id < messageID) continue
+        if (msg.info.id > messageID) {
+          remove.push(msg)
+          continue
+        }
+        if (session.revert.partID) {
+          target = msg
+          continue
+        }
+        remove.push(msg)
+      }
+      for (const msg of remove) {
+        yield* sync.run(MessageV2.Event.Removed, {
+          sessionID,
+          messageID: msg.info.id,
+        })
+      }
+      if (session.revert.partID && target) {
+        const partID = session.revert.partID
+        const idx = target.parts.findIndex((part) => part.id === partID)
+        if (idx >= 0) {
+          const removeParts = target.parts.slice(idx)
+          target.parts = target.parts.slice(0, idx)
+          for (const part of removeParts) {
+            yield* sync.run(MessageV2.Event.PartRemoved, {
+              sessionID,
+              messageID: target.info.id,
+              partID: part.id,
+            })
+          }
+        }
+      }
+      yield* sessions.clearRevert(sessionID)
+    })
+
+    return Service.of({ revert, unrevert, cleanup })
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(SessionRunState.defaultLayer),
+    Layer.provide(Session.defaultLayer),
+    Layer.provide(Snapshot.defaultLayer),
+    Layer.provide(Storage.defaultLayer),
+    Layer.provide(Bus.layer),
+    Layer.provide(SessionSummary.defaultLayer),
+    Layer.provide(SyncEvent.defaultLayer),
+  ),
+)
+
+export * as SessionRevert from "./revert"

package/src/session/core/run-state.ts

@@ -0,0 +1,110 @@
+import { InstanceState } from "@/effect/instance-state"
+import { Runner } from "@/effect/runner"
+import { Effect, Latch, Layer, Scope, Context } from "effect"
+import * as Session from "./session"
+import { MessageV2 } from "../message/message-v2"
+import { SessionID } from "./schema"
+import { SessionStatus } from "./status"
+
+export interface Interface {
+  readonly assertNotBusy: (sessionID: SessionID) => Effect.Effect<void>
+  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
+  readonly ensureRunning: (
+    sessionID: SessionID,
+    onInterrupt: Effect.Effect<MessageV2.WithParts>,
+    work: Effect.Effect<MessageV2.WithParts>,
+  ) => Effect.Effect<MessageV2.WithParts>
+  readonly startShell: (
+    sessionID: SessionID,
+    onInterrupt: Effect.Effect<MessageV2.WithParts>,
+    work: Effect.Effect<MessageV2.WithParts>,
+    ready?: Latch.Latch,
+  ) => Effect.Effect<MessageV2.WithParts>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionRunState") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const status = yield* SessionStatus.Service
+
+    const state = yield* InstanceState.make(
+      Effect.fn("SessionRunState.state")(function* () {
+        const scope = yield* Scope.Scope
+        const runners = new Map<SessionID, Runner.Runner<MessageV2.WithParts>>()
+        yield* Effect.addFinalizer(
+          Effect.fnUntraced(function* () {
+            yield* Effect.forEach(runners.values(), (runner) => runner.cancel, {
+              concurrency: "unbounded",
+              discard: true,
+            })
+            runners.clear()
+          }),
+        )
+        return { runners, scope }
+      }),
+    )
+
+    const runner = Effect.fn("SessionRunState.runner")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<MessageV2.WithParts>,
+    ) {
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (existing) return existing
+      const next = Runner.make<MessageV2.WithParts>(data.scope, {
+        onIdle: Effect.gen(function* () {
+          data.runners.delete(sessionID)
+          yield* status.set(sessionID, { type: "idle" })
+        }),
+        onBusy: status.set(sessionID, { type: "busy" }),
+        onInterrupt,
+        busy: () => {
+          throw new Session.BusyError(sessionID)
+        },
+      })
+      data.runners.set(sessionID, next)
+      return next
+    })
+
+    const assertNotBusy = Effect.fn("SessionRunState.assertNotBusy")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (existing?.busy) throw new Session.BusyError(sessionID)
+    })
+
+    const cancel = Effect.fn("SessionRunState.cancel")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (!existing || !existing.busy) {
+        yield* status.set(sessionID, { type: "idle" })
+        return
+      }
+      yield* existing.cancel
+    })
+
+    const ensureRunning = Effect.fn("SessionRunState.ensureRunning")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<MessageV2.WithParts>,
+      work: Effect.Effect<MessageV2.WithParts>,
+    ) {
+      return yield* (yield* runner(sessionID, onInterrupt)).ensureRunning(work)
+    })
+
+    const startShell = Effect.fn("SessionRunState.startShell")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<MessageV2.WithParts>,
+      work: Effect.Effect<MessageV2.WithParts>,
+      ready?: Latch.Latch,
+    ) {
+      return yield* (yield* runner(sessionID, onInterrupt)).startShell(work, ready)
+    })
+
+    return Service.of({ assertNotBusy, cancel, ensureRunning, startShell })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(SessionStatus.defaultLayer))
+
+export * as SessionRunState from "./run-state"

package/src/session/core/schema.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect"
+
+import { Identifier } from "@/id/id"
+import { zod, ZodOverride } from "@/util/effect-zod"
+import { withStatics } from "@/util/schema"
+
+export const SessionID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("session") }).pipe(
+  Schema.brand("SessionID"),
+  withStatics((s) => ({
+    descending: (id?: string) => s.make(Identifier.descending("session", id)),
+    zod: zod(s),
+  })),
+)
+
+export type SessionID = Schema.Schema.Type<typeof SessionID>
+
+export const MessageID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("message") }).pipe(
+  Schema.brand("MessageID"),
+  withStatics((s) => ({
+    ascending: (id?: string) => s.make(Identifier.ascending("message", id)),
+    zod: zod(s),
+  })),
+)
+
+export type MessageID = Schema.Schema.Type<typeof MessageID>
+
+export const PartID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("part") }).pipe(
+  Schema.brand("PartID"),
+  withStatics((s) => ({
+    ascending: (id?: string) => s.make(Identifier.ascending("part", id)),
+    zod: zod(s),
+  })),
+)
+
+export type PartID = Schema.Schema.Type<typeof PartID>

package/src/session/core/session-types.ts

@@ -0,0 +1,160 @@
+import path from "path"
+import { Decimal } from "decimal.js"
+import z from "zod"
+import { type ProviderMetadata, type LanguageModelUsage } from "ai"
+import { InstallationVersion } from "@saeeol/core/installation/version"
+import { BusEvent } from "@/bus/bus-event"
+import { SyncEvent } from "../../sync"
+import { PartTable, SessionTable } from "./session.sql"
+import * as Log from "@saeeol/core/util/log"
+import { MessageV2 } from "../message/message-v2"
+import { Snapshot } from "@/snapshot"
+import { ProjectID } from "../../project/schema"
+import { WorkspaceID } from "../../control-plane/schema"
+import { SessionID, MessageID, PartID } from "./schema"
+import type { Provider } from "@/provider/provider"
+import { Permission } from "@/permission"
+import { Global } from "@saeeol/core/global"
+import { SaeeolSession } from "@/saeeol/session"
+import { Effect, Schema, Types } from "effect"
+import { zod } from "@/util/effect-zod"
+import { NonNegativeInt, optionalOmitUndefined, withStatics } from "@/util/schema"
+
+const log = Log.create({ service: "session" })
+
+const parentTitlePrefix = "New session - "
+const childTitlePrefix = "Child session - "
+
+export function createDefaultTitle(isChild = false) {
+  return (isChild ? childTitlePrefix : parentTitlePrefix) + new Date().toISOString()
+}
+
+export function isDefaultTitle(title: string) {
+  return new RegExp(`^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`).test(title)
+}
+
+type SessionRow = typeof SessionTable.$inferSelect
+
+export function fromRow(row: SessionRow): Info {
+  const summary = row.summary_additions !== null || row.summary_deletions !== null || row.summary_files !== null
+    ? { additions: row.summary_additions ?? 0, deletions: row.summary_deletions ?? 0, files: row.summary_files ?? 0, diffs: row.summary_diffs ?? undefined }
+    : undefined
+  const share = row.share_url ? { url: row.share_url } : undefined
+  return {
+    id: row.id, slug: row.slug, projectID: row.project_id, workspaceID: row.workspace_id ?? undefined,
+    directory: row.directory, path: row.path ?? undefined, parentID: row.parent_id ?? undefined,
+    title: row.title, version: row.version, summary, share, revert: row.revert ?? undefined,
+    permission: row.permission ?? undefined,
+    time: { created: row.time_created, updated: row.time_updated, compacting: row.time_compacting ?? undefined, archived: row.time_archived ?? undefined },
+  }
+}
+
+export function toRow(info: Info) {
+  return {
+    id: info.id, project_id: info.projectID, workspace_id: info.workspaceID, parent_id: info.parentID,
+    slug: info.slug, directory: info.directory, path: info.path, title: info.title, version: info.version,
+    share_url: info.share?.url, summary_additions: info.summary?.additions, summary_deletions: info.summary?.deletions,
+    summary_files: info.summary?.files, summary_diffs: info.summary?.diffs, revert: info.revert ?? null,
+    permission: info.permission, time_created: info.time.created, time_updated: info.time.updated,
+    time_compacting: info.time.compacting, time_archived: info.time.archived,
+  }
+}
+
+export function getForkedTitle(title: string): string {
+  const match = title.match(/^(.+) \(fork #(\d+)\)$/)
+  if (match) return `${match[1]} (fork #${parseInt(match[2], 10) + 1})`
+  return `${title} (fork #1)`
+}
+
+export function sessionPath(worktree: string, cwd: string) {
+  return path.relative(path.resolve(worktree), cwd).replaceAll("\\", "/")
+}
+
+const Summary = Schema.Struct({ additions: NonNegativeInt, deletions: NonNegativeInt, files: NonNegativeInt, diffs: optionalOmitUndefined(Schema.Array(Snapshot.SummaryFileDiff)) })
+const Share = Schema.Struct({ url: Schema.String })
+export const ArchivedTimestamp = Schema.Finite
+const Time = Schema.Struct({ created: NonNegativeInt, updated: NonNegativeInt, compacting: optionalOmitUndefined(NonNegativeInt), archived: optionalOmitUndefined(ArchivedTimestamp) })
+const Revert = Schema.Struct({ messageID: MessageID, partID: optionalOmitUndefined(PartID), snapshot: optionalOmitUndefined(Schema.String), diff: optionalOmitUndefined(Schema.String) })
+
+export const Info = Schema.Struct({
+  id: SessionID, slug: Schema.String, projectID: ProjectID, workspaceID: optionalOmitUndefined(WorkspaceID),
+  directory: Schema.String, path: optionalOmitUndefined(Schema.String), parentID: optionalOmitUndefined(SessionID),
+  summary: optionalOmitUndefined(Summary), share: optionalOmitUndefined(Share), title: Schema.String,
+  version: Schema.String, time: Time, permission: optionalOmitUndefined(Permission.Ruleset), revert: optionalOmitUndefined(Revert),
+}).annotate({ identifier: "Session" }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Info = Types.DeepMutable<Schema.Schema.Type<typeof Info>>
+
+export const ProjectInfo = Schema.Struct({ id: ProjectID, name: optionalOmitUndefined(Schema.String), worktree: Schema.String })
+  .annotate({ identifier: "ProjectSummary" }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ProjectInfo = Types.DeepMutable<Schema.Schema.Type<typeof ProjectInfo>>
+
+export const GlobalInfo = Schema.Struct({ ...Info.fields, project: Schema.NullOr(ProjectInfo), worktreeName: Schema.optional(Schema.String) })
+  .annotate({ identifier: "GlobalSession" }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type GlobalInfo = Types.DeepMutable<Schema.Schema.Type<typeof GlobalInfo>>
+
+export const CreateInput = Schema.optional(Schema.Struct({
+  parentID: Schema.optional(SessionID), title: Schema.optional(Schema.String), permission: Schema.optional(Permission.Ruleset),
+  platform: Schema.optional(Schema.String), workspaceID: Schema.optional(WorkspaceID),
+})).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type CreateInput = Types.DeepMutable<Schema.Schema.Type<typeof CreateInput>>
+
+export const ForkInput = Schema.Struct({ sessionID: SessionID, messageID: Schema.optional(MessageID) }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const GetInput = SessionID
+export const ChildrenInput = SessionID
+export const RemoveInput = SessionID
+export const SetTitleInput = Schema.Struct({ sessionID: SessionID, title: Schema.String }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const SetArchivedInput = Schema.Struct({ sessionID: SessionID, time: Schema.optional(ArchivedTimestamp) }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const SetPermissionInput = Schema.Struct({ sessionID: SessionID, permission: Permission.Ruleset }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const SetRevertInput = Schema.Struct({ sessionID: SessionID, revert: Schema.optional(Revert), summary: Schema.optional(Summary) }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const MessagesInput = Schema.Struct({ sessionID: SessionID, limit: Schema.optional(NonNegativeInt) }).pipe(withStatics((s) => ({ zod: zod(s) })))
+
+export type ListInput = { directory?: string; scope?: "project"; path?: string; workspaceID?: WorkspaceID; roots?: boolean; start?: number; search?: string; limit?: number }
+
+const CreatedEventSchema = Schema.Struct({ sessionID: SessionID, info: Info })
+const UpdatedShare = Schema.Struct({ url: Schema.optional(Schema.NullOr(Schema.String)) })
+const UpdatedTime = Schema.Struct({ created: Schema.optional(Schema.NullOr(NonNegativeInt)), updated: Schema.optional(Schema.NullOr(NonNegativeInt)), compacting: Schema.optional(Schema.NullOr(NonNegativeInt)), archived: Schema.optional(Schema.NullOr(ArchivedTimestamp)) })
+const UpdatedInfo = Schema.Struct({
+  id: Schema.optional(Schema.NullOr(SessionID)), slug: Schema.optional(Schema.NullOr(Schema.String)),
+  projectID: Schema.optional(Schema.NullOr(ProjectID)), workspaceID: Schema.optional(Schema.NullOr(WorkspaceID)),
+  directory: Schema.optional(Schema.NullOr(Schema.String)), path: Schema.optional(Schema.NullOr(Schema.String)),
+  parentID: Schema.optional(Schema.NullOr(SessionID)), summary: Schema.optional(Schema.NullOr(Summary)),
+  share: Schema.optional(UpdatedShare), title: Schema.optional(Schema.NullOr(Schema.String)),
+  version: Schema.optional(Schema.NullOr(Schema.String)), time: Schema.optional(UpdatedTime),
+  permission: Schema.optional(Schema.NullOr(Permission.Ruleset)), revert: Schema.optional(Schema.NullOr(Revert)),
+})
+const UpdatedEventSchema = Schema.Struct({ sessionID: SessionID, info: UpdatedInfo })
+
+export const Event = {
+  Created: SyncEvent.define({ type: "session.created", version: 1, aggregate: "sessionID", schema: CreatedEventSchema }),
+  Updated: SyncEvent.define({ type: "session.updated", version: 1, aggregate: "sessionID", schema: UpdatedEventSchema, busSchema: CreatedEventSchema }),
+  Deleted: SyncEvent.define({ type: "session.deleted", version: 1, aggregate: "sessionID", schema: CreatedEventSchema }),
+  Diff: BusEvent.define("session.diff", Schema.Struct({ sessionID: SessionID, diff: Schema.Array(Snapshot.FileDiff) })),
+  Error: BusEvent.define("session.error", Schema.Struct({ sessionID: Schema.optional(SessionID), error: MessageV2.Assistant.fields.error })),
+  TurnOpen: SaeeolSession.Event.TurnOpen,
+  TurnClose: SaeeolSession.Event.TurnClose,
+}
+
+export function plan(input: { slug: string; time: { created: number } }, instance: any) {
+  const base = instance.project.vcs ? path.join(instance.worktree, ".saeeol", "plans") : path.join(Global.Path.data, "plans")
+  return path.join(base, [input.time.created, input.slug].join("-") + ".md")
+}
+
+export const getUsage = (input: { model: Provider.Model; usage: LanguageModelUsage; metadata?: ProviderMetadata; provider?: Provider.Info }) => {
+  const safe = (v: number) => (Number.isFinite(v) ? v : 0)
+  const inputTokens = safe(input.usage.inputTokens ?? 0)
+  const outputTokens = safe(input.usage.outputTokens ?? 0)
+  const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
+  const cacheRead = safe(input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0)
+  const cacheWrite = safe(Number(input.usage.inputTokenDetails?.cacheWriteTokens ?? input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ?? input.metadata?.["vertex"]?.["cacheCreationInputTokens"] ?? (input.metadata as any)?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ?? (input.metadata as any)?.["venice"]?.["usage"]?.["cacheCreationInputTokens"] ?? 0))
+  const adjustedInput = safe(inputTokens - cacheRead - cacheWrite)
+  const tokens = { total: input.usage.totalTokens, input: adjustedInput, output: safe(outputTokens - reasoningTokens), reasoning: reasoningTokens, cache: { write: cacheWrite, read: cacheRead } }
+  const reported = SaeeolSession.providerCost({ metadata: input.metadata, usage: input.usage, provider: input.provider, providerID: input.model.providerID })
+  if (reported !== undefined) return { cost: safe(reported), tokens }
+  const costInfo = input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 200_000 ? input.model.cost.experimentalOver200K : input.model.cost
+  return {
+    cost: safe(new Decimal(0).add(new Decimal(tokens.input).mul(costInfo?.input ?? 0).div(1_000_000)).add(new Decimal(tokens.output).mul(costInfo?.output ?? 0).div(1_000_000)).add(new Decimal(tokens.cache.read).mul(costInfo?.cache?.read ?? 0).div(1_000_000)).add(new Decimal(tokens.cache.write).mul(costInfo?.cache?.write ?? 0).div(1_000_000)).add(new Decimal(tokens.reasoning).mul(costInfo?.output ?? 0).div(1_000_000)).toNumber()),
+    tokens,
+  }
+}
+
+export class BusyError extends Error { constructor(public readonly sessionID: string) { super(`Session ${sessionID} is busy`) } }

package/src/session/core/session.sql.ts

@@ -0,0 +1,124 @@
+import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
+import { ProjectTable } from "../../project/project.sql"
+import type { MessageV2 } from "../message/message-v2"
+import type { SessionEntry } from "../../v2/session-entry"
+import type { Snapshot } from "../../snapshot"
+import type { Permission } from "../../permission"
+import type { ProjectID } from "../../project/schema"
+import type { SessionID, MessageID, PartID } from "./schema"
+import type { WorkspaceID } from "../../control-plane/schema"
+import { Timestamps } from "../../storage/schema.sql"
+
+type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
+type InfoData = Omit<MessageV2.Info, "id" | "sessionID">
+
+export const SessionTable = sqliteTable(
+  "session",
+  {
+    id: text().$type<SessionID>().primaryKey(),
+    project_id: text()
+      .$type<ProjectID>()
+      .notNull()
+      .references(() => ProjectTable.id, { onDelete: "cascade" }),
+    workspace_id: text().$type<WorkspaceID>(),
+    parent_id: text().$type<SessionID>(),
+    slug: text().notNull(),
+    directory: text().notNull(),
+    path: text(),
+    title: text().notNull(),
+    version: text().notNull(),
+    share_url: text(),
+    summary_additions: integer(),
+    summary_deletions: integer(),
+    summary_files: integer(),
+    summary_diffs: text({ mode: "json" }).$type<Snapshot.SummaryFileDiff[]>(), 
+    revert: text({ mode: "json" }).$type<{ messageID: MessageID; partID?: PartID; snapshot?: string; diff?: string }>(),
+    permission: text({ mode: "json" }).$type<Permission.Ruleset>(),
+    ...Timestamps,
+    time_compacting: integer(),
+    time_archived: integer(),
+  },
+  (table) => [
+    index("session_project_idx").on(table.project_id),
+    index("session_workspace_idx").on(table.workspace_id),
+    index("session_parent_idx").on(table.parent_id),
+  ],
+)
+
+export const MessageTable = sqliteTable(
+  "message",
+  {
+    id: text().$type<MessageID>().primaryKey(),
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    ...Timestamps,
+    data: text({ mode: "json" }).notNull().$type<InfoData>(),
+  },
+  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)],
+)
+
+export const PartTable = sqliteTable(
+  "part",
+  {
+    id: text().$type<PartID>().primaryKey(),
+    message_id: text()
+      .$type<MessageID>()
+      .notNull()
+      .references(() => MessageTable.id, { onDelete: "cascade" }),
+    session_id: text().$type<SessionID>().notNull(),
+    ...Timestamps,
+    data: text({ mode: "json" }).notNull().$type<PartData>(),
+  },
+  (table) => [
+    index("part_message_id_id_idx").on(table.message_id, table.id),
+    index("part_session_idx").on(table.session_id),
+  ],
+)
+
+export const TodoTable = sqliteTable(
+  "todo",
+  {
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    content: text().notNull(),
+    status: text().notNull(),
+    priority: text().notNull(),
+    position: integer().notNull(),
+    ...Timestamps,
+  },
+  (table) => [
+    primaryKey({ columns: [table.session_id, table.position] }),
+    index("todo_session_idx").on(table.session_id),
+  ],
+)
+
+export const SessionEntryTable = sqliteTable(
+  "session_entry",
+  {
+    id: text().$type<SessionEntry.ID>().primaryKey(),
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    type: text().$type<SessionEntry.Type>().notNull(),
+    ...Timestamps,
+    data: text({ mode: "json" }).notNull().$type<Omit<SessionEntry.Entry, "type" | "id">>(),
+  },
+  (table) => [
+    index("session_entry_session_idx").on(table.session_id),
+    index("session_entry_session_type_idx").on(table.session_id, table.type),
+    index("session_entry_time_created_idx").on(table.time_created),
+  ],
+)
+
+export const PermissionTable = sqliteTable("permission", {
+  project_id: text()
+    .primaryKey()
+    .references(() => ProjectTable.id, { onDelete: "cascade" }),
+  ...Timestamps,
+  data: text({ mode: "json" }).notNull().$type<Permission.Ruleset>(),
+})