chore(tui): merge v2 into form branch

2026-07-03 15:01:22 -05:00 · 2026-07-03 15:01:22 -05:00 · be0cd93c8f
commit be0cd93c8f
parent d1163cb5ec 438654768c
235 changed files with 5364 additions and 3885 deletions
--- a/packages/core/src/account.ts
+++ b/packages/core/src/account.ts
@ -1,7 +1,7 @@
 export * as AccountV2 from "./account"

 import { Schema } from "effect"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+import type { HttpClientError } from "effect/unstable/http"

 export const ID = Schema.String.pipe(Schema.brand("AccountID"))
 export type ID = Schema.Schema.Type<typeof ID>
--- a/packages/core/src/config/experimental.ts
+++ b/packages/core/src/config/experimental.ts
@ -2,17 +2,19 @@ export * as ConfigExperimental from "./experimental"

 import { Schema } from "effect"
 import { Catalog } from "../catalog"
-import { Policy as PolicyV2 } from "../policy"
+import { Policy } from "../policy"

 // Each core domain exports the policy actions it supports. Adding an action to
 // this union makes it valid in authored config while keeping Policy generic.
 export const PolicyAction = Schema.Union([Catalog.PolicyActions])

-export class Policy extends Schema.Class<Policy>("ConfigV2.Experimental.Policy")({
-  ...PolicyV2.Info.fields,
+class PolicyConfig extends Schema.Class<PolicyConfig>("ConfigV2.Experimental.Policy")({
+  ...Policy.Info.fields,
  action: PolicyAction,
 }) {}

+export { PolicyConfig as Policy }
+
 export class Experimental extends Schema.Class<Experimental>("ConfigV2.Experimental")({
-  policies: Policy.pipe(Schema.Array, Schema.optional),
+  policies: PolicyConfig.pipe(Schema.Array, Schema.optional),
 }) {}
--- a/packages/core/src/control-plane/move-session.ts
+++ b/packages/core/src/control-plane/move-session.ts
@ -106,8 +106,7 @@ const layer = Layer.effect(
      yield* events.publish(SessionEvent.Moved, {
        sessionID: input.sessionID,
        location: Location.Ref.make({ directory }),
-        subdirectory: RelativePath.make(path.relative(destination.directory, directory).replaceAll("\\", "/")),
-        timestamp: yield* DateTime.now,
+        subpath: RelativePath.make(path.relative(destination.directory, directory).replaceAll("\\", "/")),
      })

      if (patch) {
--- a/packages/core/src/cross-spawn-spawner.ts
+++ b/packages/core/src/cross-spawn-spawner.ts
@ -1,26 +1,17 @@
-import type * as Arr from "effect/Array"
-import { NodeFileSystem, NodeSink, NodeStream } from "@effect/platform-node"
-import * as NodePath from "@effect/platform-node/NodePath"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FileSystem from "effect/FileSystem"
-import * as Layer from "effect/Layer"
-import * as Path from "effect/Path"
-import * as PlatformError from "effect/PlatformError"
-import * as Predicate from "effect/Predicate"
-import type * as Scope from "effect/Scope"
-import * as Sink from "effect/Sink"
-import * as Stream from "effect/Stream"
-import * as ChildProcess from "effect/unstable/process/ChildProcess"
-import type { ChildProcessHandle } from "effect/unstable/process/ChildProcessSpawner"
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import { NodeFileSystem, NodePath, NodeSink, NodeStream } from "@effect/platform-node"
+import { Deferred, Effect, Exit, FileSystem, Layer, Path, PlatformError, Predicate, Sink, Stream } from "effect"
+import type { Scope } from "effect"
+import { ChildProcess } from "effect/unstable/process"
 import {
  ChildProcessSpawner,
  ExitCode,
-  make as makeSpawner,
+  make,
  makeHandle,
  ProcessId,
+  type ChildProcessHandle,
 } from "effect/unstable/process/ChildProcessSpawner"
+// ast-grep-ignore: no-star-import
 import * as NodeChildProcess from "node:child_process"
 import { PassThrough } from "node:stream"
 import launch from "cross-spawn"
@ -71,7 +62,7 @@ const flatten = (command: ChildProcess.Command) => {
  if (commands.length === 0) throw new Error("flatten produced empty commands array")
  const [head, ...tail] = commands
  return {
-    commands: [head, ...tail] as Arr.NonEmptyReadonlyArray<ChildProcess.StandardCommand>,
+    commands: [head, ...tail] as NonEmptyReadonlyArray<ChildProcess.StandardCommand>,
    opts,
  }
 }
@ -96,7 +87,7 @@ const toPlatformError = (

 type ExitSignal = Deferred.Deferred<readonly [code: number | null, signal: NodeJS.Signals | null]>

-export const make = Effect.gen(function* () {
+const makeCrossSpawnSpawner = Effect.gen(function* () {
  const fs = yield* FileSystem.FileSystem
  const path = yield* Path.Path

@ -494,12 +485,12 @@ export const make = Effect.gen(function* () {
    },
  )

-  return makeSpawner(spawnCommand)
+  return make(spawnCommand)
 })

 const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.FileSystem | Path.Path> = Layer.effect(
  ChildProcessSpawner,
-  make,
+  makeCrossSpawnSpawner,
 )

 export const node = makeGlobalNode({ service: ChildProcessSpawner, layer, deps: [filesystem, path] })
--- a/packages/core/src/database/database.ts
+++ b/packages/core/src/database/database.ts
@ -1,7 +1,7 @@
 export * as Database from "./database"

 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { layer as sqliteLayer } from "#sqlite"
+import { layer } from "#sqlite"
 import { Context, Effect, Layer } from "effect"
 import { Global } from "../global"
 import { Flag } from "../flag/flag"
@ -19,7 +19,7 @@ export interface Interface {

 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/storage/Database") {}

-const layer = Layer.effect(
+const databaseLayer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const db = yield* makeDatabase
@ -37,7 +37,7 @@ const layer = Layer.effect(
 )

 export function layerFromPath(filename: string) {
-  return layer.pipe(Layer.provide(sqliteLayer({ filename })))
+  return databaseLayer.pipe(Layer.provide(layer({ filename })))
 }

 export function path() {
--- a/packages/core/src/database/migration.gen.ts
+++ b/packages/core/src/database/migration.gen.ts
@ -41,5 +41,7 @@ export const migrations = (
    import("./migration/20260622170816_reset_v2_session_state"),
    import("./migration/20260622202450_simplify_session_input"),
    import("./migration/20260702134641_add_session_context_entry"),
+    import("./migration/20260703090000_reset_v2_event_rename_sweep"),
+    import("./migration/20260703181610_event_created_column"),
  ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]
--- a/packages/core/src/database/migration.ts
+++ b/packages/core/src/database/migration.ts
@ -22,7 +22,7 @@ export function apply(db: Database) {
        sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`,
      )
      if (tables.some((table) => table.name === "session")) return yield* applyOnly(db, migrations)
-      if (tables.length > 0) return yield* Effect.die("Database is not empty and has no session table")
+      if (tables.length > 0) return yield* Effect.die(new Error("Database is not empty and has no session table"))
      yield* db.transaction((tx) =>
        Effect.gen(function* () {
          yield* schema.up(tx)
--- a/packages/core/src/database/migration/20260703090000_reset_v2_event_rename_sweep.ts
+++ b/packages/core/src/database/migration/20260703090000_reset_v2_event_rename_sweep.ts
@ -0,0 +1,17 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: "20260703090000_reset_v2_event_rename_sweep",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_input\`;`)
+      yield* tx.run(`DELETE FROM \`session_message\`;`)
+      yield* tx.run(`DELETE FROM \`event\`;`)
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`)
+      // `created` column is added by the generated 20260703181610_event_created_column
+      // migration, which runs after this wipe (NOT NULL without default is safe on the
+      // emptied table).
+    })
+  },
+} satisfies DatabaseMigration.Migration
--- a/packages/core/src/database/migration/20260703181610_event_created_column.ts
+++ b/packages/core/src/database/migration/20260703181610_event_created_column.ts
@ -0,0 +1,11 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: "20260703181610_event_created_column",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`event\` ADD \`created\` integer NOT NULL;`)
+    })
+  },
+} satisfies DatabaseMigration.Migration
--- a/packages/core/src/database/path.ts
+++ b/packages/core/src/database/path.ts
@ -1,5 +1,6 @@
 import nodePath from "path"
 import { customType } from "drizzle-orm/sqlite-core"
+import { Schema } from "effect"
 import { AbsolutePath } from "../schema"

 function storagePath(input: string) {
@ -74,6 +75,8 @@ export const pathColumn = customType<{
  },
 })

+const decodeAbsoluteArray = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(Schema.String)))
+
 export const absoluteArrayColumn = customType<{
  data: AbsolutePath[]
  driverData: string
@ -86,6 +89,6 @@ export const absoluteArrayColumn = customType<{
    return JSON.stringify(input.map(absolute))
  },
  fromDriver(input) {
-    return (JSON.parse(input) as string[]).map((item) => AbsolutePath.make(toPlatform(absolute(item))))
+    return decodeAbsoluteArray(input).map((item) => AbsolutePath.make(toPlatform(absolute(item))))
  },
 })
--- a/packages/core/src/database/schema.gen.ts
+++ b/packages/core/src/database/schema.gen.ts
@ -81,6 +81,7 @@ export default {
          \`id\` text PRIMARY KEY,
          \`aggregate_id\` text NOT NULL,
          \`seq\` integer NOT NULL,
+          \`created\` integer NOT NULL,
          \`type\` text NOT NULL,
          \`data\` text NOT NULL,
          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
--- a/packages/core/src/database/sqlite.bun.ts
+++ b/packages/core/src/database/sqlite.bun.ts
@ -1,18 +1,11 @@
 import { Database } from "bun:sqlite"
 import { drizzle } from "drizzle-orm/bun-sqlite"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
 import { identity } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
-import * as Semaphore from "effect/Semaphore"
-import * as Stream from "effect/Stream"
-import * as Reactivity from "effect/unstable/reactivity/Reactivity"
-import * as Client from "effect/unstable/sql/SqlClient"
+import { Reactivity } from "effect/unstable/reactivity"
+import { SqlClient, Statement } from "effect/unstable/sql"
 import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
-import * as Statement from "effect/unstable/sql/Statement"
 import { Sqlite } from "./sqlite"

 const ATTR_DB_SYSTEM_NAME = "db.system.name"
@ -20,7 +13,7 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
 type TypeId = typeof TypeId

-interface SqliteClient extends Client.SqlClient {
+interface SqliteClient extends SqlClient.SqlClient {
  readonly [TypeId]: TypeId
  readonly config: Config
  readonly export: Effect.Effect<Uint8Array, SqlError>
@ -57,7 +50,7 @@ const make = (options: Config) =>
      Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
        const statement = native.query(query)
        // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
-        statement.safeIntegers(Context.get(fiber.context, Client.SafeIntegers))
+        statement.safeIntegers(Context.get(fiber.context, SqlClient.SafeIntegers))
        try {
          return Effect.succeed((statement.all(...(params as any)) ?? []) as Array<Record<string, unknown>>)
        } catch (cause) {
@ -73,7 +66,7 @@ const make = (options: Config) =>
      Effect.withFiber<Array<unknown[]>, SqlError>((fiber) => {
        const statement = native.query(query)
        // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
-        statement.safeIntegers(Context.get(fiber.context, Client.SafeIntegers))
+        statement.safeIntegers(Context.get(fiber.context, SqlClient.SafeIntegers))
        try {
          return Effect.succeed((statement.values(...(params as any)) ?? []) as Array<unknown[]>)
        } catch (cause) {
@ -130,7 +123,7 @@ const make = (options: Config) =>
    })

    const client = Object.assign(
-      (yield* Client.make({
+      (yield* SqlClient.make({
        acquirer,
        compiler,
        transactionAcquirer,
@ -166,7 +159,7 @@ const nativeLayer = (config: Config) =>
    }),
  )

-const sqliteLayer = (config: Config) => Layer.effect(Client.SqlClient, make(config))
+const sqliteLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))

 const drizzleLayer = Layer.effect(
  Sqlite.Drizzle,
--- a/packages/core/src/database/sqlite.node.ts
+++ b/packages/core/src/database/sqlite.node.ts
@ -1,18 +1,11 @@
 import { DatabaseSync, type SQLInputValue } from "node:sqlite"
 import { drizzle } from "drizzle-orm/node-sqlite"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
 import { identity } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
-import * as Semaphore from "effect/Semaphore"
-import * as Stream from "effect/Stream"
-import * as Reactivity from "effect/unstable/reactivity/Reactivity"
-import * as Client from "effect/unstable/sql/SqlClient"
+import { Reactivity } from "effect/unstable/reactivity"
+import { SqlClient, Statement } from "effect/unstable/sql"
 import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
-import * as Statement from "effect/unstable/sql/Statement"
 import { Sqlite } from "./sqlite"

 const ATTR_DB_SYSTEM_NAME = "db.system.name"
@ -20,7 +13,7 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
 type TypeId = typeof TypeId

-interface SqliteClient extends Client.SqlClient {
+interface SqliteClient extends SqlClient.SqlClient {
  readonly [TypeId]: TypeId
  readonly config: Config
  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
@ -56,7 +49,7 @@ const make = (options: Config) =>
    const run = (query: string, params: ReadonlyArray<unknown> = []) =>
      Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
        const statement = native.prepare(query)
-        statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
+        statement.setReadBigInts(Context.get(fiber.context, SqlClient.SafeIntegers))
        try {
          return Effect.succeed(statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>)
        } catch (cause) {
@ -71,7 +64,7 @@ const make = (options: Config) =>
    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
      Effect.withFiber<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>((fiber) => {
        const statement = native.prepare(query)
-        statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
+        statement.setReadBigInts(Context.get(fiber.context, SqlClient.SafeIntegers))
        statement.setReturnArrays(true)
        try {
          return Effect.succeed(
@ -124,7 +117,7 @@ const make = (options: Config) =>
    })

    const client = Object.assign(
-      (yield* Client.make({
+      (yield* SqlClient.make({
        acquirer,
        compiler,
        transactionAcquirer,
@ -161,7 +154,7 @@ const nativeLayer = (config: Config) =>
    }),
  )

-const sqliteLayer = (config: Config) => Layer.effect(Client.SqlClient, make(config))
+const sqliteLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))

 const drizzleLayer = Layer.effect(
  Sqlite.Drizzle,
--- a/packages/core/src/effect/layer-node.ts
+++ b/packages/core/src/effect/layer-node.ts
@ -227,7 +227,7 @@ export function hoist<A, E, T extends Tag, const Items extends Replacements = re
      }
      if (node.tag === tag) {
        const existing = hoisted.get(node.name)
-        if (existing && existing !== node) {
+        if (existing && existing.implementation !== node.implementation) {
          throw new Error(`Tag ${tag} has conflicting implementations for ${node.name}`)
        }
        hoisted.set(node.name, rewriteReplacementDependencies(node, replacementMap))
--- a/packages/core/src/event.ts
+++ b/packages/core/src/event.ts
@ -1,6 +1,6 @@
 export * as EventV2 from "./event"

-import { Cause, Context, Effect, Layer, Option, PubSub, Queue, Schema, Stream } from "effect"
+import { Cause, Context, DateTime, Effect, Layer, Option, PubSub, Queue, Schema, Stream } from "effect"
 import { Event } from "@opencode-ai/schema/event"
 import type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 import type { EventLog } from "@opencode-ai/schema/event-log"
@ -55,6 +55,7 @@ export const reserveSequence = Effect.fn("EventV2.reserveSequence")(function* (
 export type SerializedEvent = {
  readonly id: ID
  readonly type: string
+  readonly created?: DateTime.Utc
  readonly seq: number
  readonly aggregateID: string
  readonly data: Record<string, unknown>
@ -81,6 +82,7 @@ const decodeSerializedEvent = (event: SerializedEvent): Payload => {
  }
  return {
    id: event.id,
+    created: event.created ?? DateTime.makeUnsafe(0),
    type: definition.type,
    durable: envelope(event.aggregateID, event.seq, definition.durable.version),
    data: Schema.decodeUnknownSync(definition.data)(event.data),
@ -92,8 +94,9 @@ export class SubscriberOverflowError extends Schema.TaggedErrorClass<SubscriberO
  { capacity: Schema.Int },
 ) {}

-export const define = Event.define
 export const versionedType = Event.versionedType
+export const durable = Event.durable
+export const ephemeral = Event.ephemeral

 export interface PublishOptions {
  readonly id?: ID
@ -294,6 +297,7 @@ export const layerWith = (options?: LayerOptions) =>
                            if (
                              stored?.id === event.id &&
                              stored.type === versionedType(definition.type, durable.version) &&
+                              stored.created === DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)) &&
                              isDeepStrictEqual(stored.data, encoded)
                            ) {
                              if (input.ownerID && row?.ownerID == null) {
@ -365,6 +369,7 @@ export const layerWith = (options?: LayerOptions) =>
                                id: event.id,
                                aggregate_id: aggregateID,
                                seq,
+                                created: DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)),
                                type: versionedType(definition.type, durable.version),
                                data: encoded,
                              },
@ -470,6 +475,7 @@ export const layerWith = (options?: LayerOptions) =>
            definition,
            {
              id: options?.id ?? ID.create(),
+              created: yield* DateTime.now,
              ...(options?.metadata ? { metadata: options.metadata } : {}),
              type: definition.type,
              ...(location ? { location } : {}),
@ -493,6 +499,7 @@ export const layerWith = (options?: LayerOptions) =>
          } else {
            const payload = {
              id: event.id,
+              created: event.created ?? DateTime.makeUnsafe(0),
              type: definition.type,
              data: Schema.decodeUnknownSync(definition.data)(event.data),
            } as Payload
@ -609,6 +616,7 @@ export const layerWith = (options?: LayerOptions) =>
              return [
                decodeSerializedEvent({
                  id: event.id,
+                  created: DateTime.makeUnsafe(event.created),
                  aggregateID: event.aggregate_id,
                  seq: event.seq,
                  type: event.type,
--- a/packages/core/src/event/sql.ts
+++ b/packages/core/src/event/sql.ts
@ -15,6 +15,7 @@ export const EventTable = sqliteTable(
      .notNull()
      .references(() => EventSequenceTable.aggregate_id, { onDelete: "cascade" }),
    seq: integer().notNull(),
+    created: integer().notNull(),
    type: text().notNull(),
    data: text({ mode: "json" }).$type<Record<string, unknown>>().notNull(),
  },
--- a/packages/core/src/filesystem/watcher.ts
+++ b/packages/core/src/filesystem/watcher.ts
@ -113,7 +113,8 @@ const layer = Layer.effect(
      )
    }

-    const config = (yield* (yield* Config.Service).entries())
+    const configService = yield* Config.Service
+    const config = (yield* configService.entries())
      .filter((entry): entry is Config.Document => entry.type === "document")
      .flatMap((item) => item.info.watcher?.ignore ?? [])
    yield* Effect.forkScoped(
--- a/packages/core/src/form.ts
+++ b/packages/core/src/form.ts
@ -98,10 +98,14 @@ export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const events = yield* EventV2.Service
-    const forms = yield* Cache.makeWith<ID, Entry>(() => Effect.die("Form cache must be used via set/getSuccess, never get"), {
-      capacity: Number.MAX_SAFE_INTEGER,
-      timeToLive: (exit) => (Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION),
-    })
+    const forms = yield* Cache.makeWith<ID, Entry>(
+      () => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")),
+      {
+        capacity: Number.MAX_SAFE_INTEGER,
+        timeToLive: (exit) =>
+          Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION,
+      },
+    )

    const find = Effect.fn("Form.find")(function* (id: ID) {
      return yield* Cache.getSuccess(forms, id).pipe(
@ -131,7 +135,9 @@ export const layer = Layer.effect(
            ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
          }
          const form: Info =
-            input.mode === "form" ? { ...base, mode: "form", fields: input.fields } : { ...base, mode: "url", url: input.url }
+            input.mode === "form"
+              ? { ...base, mode: "form", fields: input.fields }
+              : { ...base, mode: "url", url: input.url }
          const entry: Entry = {
            form,
            state: { status: "pending" },
@ -149,7 +155,9 @@ export const layer = Layer.effect(
        Effect.gen(function* () {
          const form = yield* create(input)
          const entry = yield* find(form.id).pipe(Effect.orDie)
-          return yield* restore(Deferred.await(entry.deferred)).pipe(Effect.onInterrupt(() => Effect.ignore(cancel(form.id))))
+          return yield* restore(Deferred.await(entry.deferred)).pipe(
+            Effect.onInterrupt(() => Effect.ignore(cancel(form.id))),
+          )
        }),
      ),
    )
@ -301,7 +309,8 @@ function validateField(field: Form.Field, value: Form.Value): string | undefined
        return `Form field has invalid pattern: ${field.key}`
      }
    }
-    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return `Expected email for form field: ${field.key}`
+    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+      return `Expected email for form field: ${field.key}`
    if (field.format === "uri" && !isUri(value)) return `Expected URI for form field: ${field.key}`
    if (field.format === "date" && !isDate(value)) return `Expected date for form field: ${field.key}`
    if (field.format === "date-time" && !isDateTime(value)) return `Expected date-time for form field: ${field.key}`
@ -324,8 +333,10 @@ function validateField(field: Form.Field, value: Form.Value): string | undefined
  if (field.type === "multiselect") {
    if (!isStringArray(value)) return `Expected string array for form field: ${field.key}`
    if (field.required && value.length === 0) return `Missing required form field: ${field.key}`
-    if (field.minItems !== undefined && value.length < field.minItems) return `Too few selections for form field: ${field.key}`
-    if (field.maxItems !== undefined && value.length > field.maxItems) return `Too many selections for form field: ${field.key}`
+    if (field.minItems !== undefined && value.length < field.minItems)
+      return `Too few selections for form field: ${field.key}`
+    if (field.maxItems !== undefined && value.length > field.maxItems)
+      return `Too many selections for form field: ${field.key}`
    if (!field.custom && value.some((item) => !field.options.some((option) => option.value === item))) {
      return `Invalid option for form field: ${field.key}`
    }
--- a/packages/core/src/fs-util.ts
+++ b/packages/core/src/fs-util.ts
@ -1,7 +1,7 @@
 import { NodeFileSystem } from "@effect/platform-node"
-import { dirname, isAbsolute, join, relative, resolve as pathResolve, sep } from "path"
+import path, { dirname, isAbsolute, join, relative, sep } from "path"
 import { realpathSync } from "fs"
-import * as NFS from "fs/promises"
+import { readdir } from "fs/promises"
 import { lookup } from "mime-types"
 import { Context, Effect, FileSystem, Layer, Schema } from "effect"
 import type { PlatformError } from "effect/PlatformError"
@ -38,6 +38,7 @@ export namespace FSUtil {
    readonly ensureDir: (path: string) => Effect.Effect<void, Error>
    readonly writeWithDirs: (path: string, content: string | Uint8Array, mode?: number) => Effect.Effect<void, Error>
    readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error>
+    readonly resolve: (path: string) => Effect.Effect<string>
    readonly findUp: (target: string, start: string, stop?: string) => Effect.Effect<string[], Error>
    readonly up: (options: { targets: string[]; start: string; stop?: string }) => Effect.Effect<string[], Error>
    readonly globUp: (pattern: string, start: string, stop?: string) => Effect.Effect<string[], Error>
@ -49,7 +50,9 @@ export namespace FSUtil {

  export const use = serviceUse(Service)

-  const layer = Layer.effect(
+  // Exported so simulation can wrap this layer and override the methods that
+  // bypass the injected FileSystem (readDirectoryEntries, glob, globUp).
+  export const layer = Layer.effect(
    Service,
    Effect.gen(function* () {
      const fs = yield* FileSystem.FileSystem
@ -77,7 +80,7 @@ export namespace FSUtil {
      const readDirectoryEntries = Effect.fn("FileSystem.readDirectoryEntries")(function* (dirPath: string) {
        return yield* Effect.tryPromise({
          try: async () => {
-            const entries = await NFS.readdir(dirPath, { withFileTypes: true })
+            const entries = await readdir(dirPath, { withFileTypes: true })
            return entries.map(
              (e): DirEntry => ({
                name: e.name,
@ -89,6 +92,14 @@ export namespace FSUtil {
        })
      })

+      const resolve = Effect.fn("FileSystem.resolve")(function* (input: string) {
+        const resolved = path.resolve(windowsPath(input))
+        return yield* fs.realPath(resolved).pipe(
+          Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(resolved)),
+          Effect.orDie,
+        )
+      })
+
      const readJson = Effect.fn("FileSystem.readJson")(function* (path: string) {
        const text = yield* fs.readFileString(path)
        return yield* Effect.try({
@ -187,6 +198,7 @@ export namespace FSUtil {
        isDir,
        isFile,
        readDirectoryEntries,
+        resolve,
        readJson,
        writeJson,
        ensureDir,
@ -209,7 +221,7 @@ export namespace FSUtil {

  export function normalizePath(p: string): string {
    if (process.platform !== "win32") return p
-    const resolved = pathResolve(windowsPath(p))
+    const resolved = path.resolve(windowsPath(p))
    try {
      return realpathSync.native(resolved)
    } catch {
@ -227,7 +239,7 @@ export namespace FSUtil {
  }

  export function resolve(p: string): string {
-    const resolved = pathResolve(windowsPath(p))
+    const resolved = path.resolve(windowsPath(p))
    try {
      return normalizePath(realpathSync(resolved))
    } catch (e: any) {
--- a/packages/core/src/id/id.ts
+++ b/packages/core/src/id/id.ts
@ -1,4 +1,4 @@
-import { create as createIdentifier } from "@opencode-ai/schema/identifier"
+import { create } from "@opencode-ai/schema/identifier"

 const prefixes = {
  job: "job",
@ -23,7 +23,7 @@ export function descending(prefix: keyof typeof prefixes, given?: string) {

 function generateID(prefix: keyof typeof prefixes, direction: "descending" | "ascending", given?: string): string {
  if (!given) {
-    return create(prefixes[prefix], direction)
+    return createID(prefixes[prefix], direction)
  }

  if (!given.startsWith(prefixes[prefix])) {
@ -32,10 +32,12 @@ function generateID(prefix: keyof typeof prefixes, direction: "descending" | "as
  return given
 }

-export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
-  return prefix + "_" + createIdentifier(direction === "descending", timestamp)
+function createID(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
+  return prefix + "_" + create(direction === "descending", timestamp)
 }

+export { createID as create }
+
 /** Extract timestamp from an ascending ID. Does not work with descending IDs. */
 export function timestamp(id: string): number {
  const prefix = id.split("_")[0]
--- a/packages/core/src/instruction-context.ts
+++ b/packages/core/src/instruction-context.ts
@ -43,22 +43,24 @@ const layer = Layer.effect(
      })

    const observe = Effect.fn("InstructionContext.observe")(function* () {
-      const start = FSUtil.resolve(location.directory)
-      const stop = FSUtil.resolve(location.project.directory)
+      const start = yield* fs.resolve(location.directory)
+      const stop = yield* fs.resolve(location.project.directory)
      const fromProject = relative(stop, start)
      const insideProject =
        fromProject === "" || (fromProject !== ".." && !fromProject.startsWith(`..${sep}`) && !isAbsolute(fromProject))
      const discovered = new Set(
-        (Flag.OPENCODE_DISABLE_PROJECT_CONFIG || !insideProject
-          ? []
-          : yield* fs.up({
-              targets: ["AGENTS.md"],
-              start,
-              stop,
-            })
-        ).map(FSUtil.resolve),
+        yield* Effect.forEach(
+          Flag.OPENCODE_DISABLE_PROJECT_CONFIG || !insideProject
+            ? []
+            : yield* fs.up({
+                targets: ["AGENTS.md"],
+                start,
+                stop,
+              }),
+          fs.resolve,
+        ),
      )
-      const paths = Array.dedupe([FSUtil.resolve(join(global.config, "AGENTS.md")), ...discovered])
+      const paths = Array.dedupe([yield* fs.resolve(join(global.config, "AGENTS.md")), ...discovered])
      const files = yield* Effect.forEach(
        paths,
        (path) =>
--- a/packages/core/src/integration.ts
+++ b/packages/core/src/integration.ts
@ -406,7 +406,7 @@ const layer = Layer.effect(
            .get()
            .integrations.get(input.integrationID)
            ?.methods.some((method) => method.type === "key")
-          if (!method) return yield* Effect.die(`Key method not found: ${input.integrationID}`)
+          if (!method) return yield* Effect.die(new Error(`Key method not found: ${input.integrationID}`))
          yield* credentials.create({
            integrationID: input.integrationID,
            label: input.label,
@ -418,7 +418,7 @@ const layer = Layer.effect(
        oauth: Effect.fn("Integration.connection.oauth")(function* (input) {
          const method = state.get().integrations.get(input.integrationID)?.implementations.get(input.methodID)
          if (!method) {
-            return yield* Effect.die(`OAuth method not found: ${input.integrationID}/${input.methodID}`)
+            return yield* Effect.die(new Error(`OAuth method not found: ${input.integrationID}/${input.methodID}`))
          }
          const attemptScope = yield* Scope.fork(scope)
          const authorization = yield* authorize(method.authorize(input.inputs)).pipe(
@ -475,7 +475,7 @@ const layer = Layer.effect(
      attempt: {
        status: Effect.fn("Integration.attempt.status")(function* (attemptID) {
          const attempt = (yield* SynchronizedRef.get(attempts)).get(attemptID)
-          if (!attempt) return yield* Effect.die(`OAuth attempt not found: ${attemptID}`)
+          if (!attempt) return yield* Effect.die(new Error(`OAuth attempt not found: ${attemptID}`))
          if (attempt.status === "failed") {
            return { status: attempt.status, message: attempt.message ?? "Authorization failed", time: attempt.time }
          }
@ -488,12 +488,13 @@ const layer = Layer.effect(
            if (match.authorization.mode === "code" && input.code === undefined) return [match, current]
            return [match, new Map(current).set(input.attemptID, { ...match, completing: true })]
          })
-          if (!attempt) return yield* Effect.die(`OAuth attempt not found: ${input.attemptID}`)
+          if (!attempt) return yield* Effect.die(new Error(`OAuth attempt not found: ${input.attemptID}`))
          if (attempt.status !== "pending") return
          if (attempt.authorization.mode === "code" && input.code === undefined) {
            return yield* new CodeRequiredError({ attemptID: input.attemptID })
          }
-          if (attempt.completing) return yield* Effect.die(`OAuth attempt already completing: ${input.attemptID}`)
+          if (attempt.completing)
+            return yield* Effect.die(new Error(`OAuth attempt already completing: ${input.attemptID}`))
          const callback =
            attempt.authorization.mode === "auto"
              ? attempt.authorization.callback
--- a/packages/core/src/location-services.ts
+++ b/packages/core/src/location-services.ts
@ -22,14 +22,13 @@ import { PermissionV2 } from "./permission"
 import { PluginV2 } from "./plugin"
 import { PluginInternal } from "./plugin/internal"
 import { Policy } from "./policy"
-import { Project } from "./project"
 import { ProjectCopy } from "./project/copy"
 import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
 import { Shell } from "./shell"
 import { Reference } from "./reference"
 import { ReferenceGuidance } from "./reference/guidance"
-import * as SessionRunnerLLM from "./session/runner/llm"
+import { SessionRunnerLLM } from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
 import { SessionCompaction } from "./session/compaction"
 import { SessionTitle } from "./session/title"
@ -49,8 +48,7 @@ import { Vcs } from "./vcs"

 export { LocationServiceMap } from "./location-service-map"

-export const locationServices = LayerNode.group([
-  Project.node,
+const locationServiceNodes = [
  Location.node,
  Policy.node,
  Config.node,
@ -96,7 +94,9 @@ export const locationServices = LayerNode.group([
  Snapshot.node,
  SessionRunnerLLM.node,
  Vcs.node,
-])
+] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
+
+export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)

 export type LocationServices = LayerNode.Output<typeof locationServices>
 export type LocationError = LayerNode.Error<typeof locationServices>
--- a/packages/core/src/mcp/client.ts
+++ b/packages/core/src/mcp/client.ts
@ -46,7 +46,11 @@ const TolerantListPromptsResult = ListPromptsResultSchema.extend({

 export class NeedsAuthError extends Schema.TaggedErrorClass<NeedsAuthError>()("MCP.NeedsAuthError", {
  server: Schema.String,
-}) {}
+}) {
+  override get message() {
+    return `MCP server requires authentication: ${this.server}`
+  }
+}

 export class ConnectError extends Schema.TaggedErrorClass<ConnectError>()("MCP.ConnectError", {
  server: Schema.String,
--- a/packages/core/src/mcp/index.ts
+++ b/packages/core/src/mcp/index.ts
@ -127,7 +127,11 @@ export class ResourceContent extends Schema.Class<ResourceContent>("MCP.Resource

 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("MCP.NotFoundError", {
  server: ServerName,
-}) {}
+}) {
+  override get message() {
+    return `MCP server not found: ${this.server}`
+  }
+}

 export class ToolCallError extends Schema.TaggedErrorClass<ToolCallError>()("MCP.ToolCallError", {
  server: ServerName,
--- a/packages/core/src/models-dev.ts
+++ b/packages/core/src/models-dev.ts
@ -47,7 +47,7 @@ const Cost = Schema.Struct({
 const ReasoningOption = Schema.Union([
  Schema.Struct({
    type: Schema.Literal("effort"),
-    values: Schema.Array(Schema.String),
+    values: Schema.Array(Schema.Union([Schema.String, Schema.Null])),
  }),
  Schema.Struct({
    type: Schema.Literal("toggle"),
@ -67,7 +67,7 @@ export const Model = Schema.Struct({
  attachment: Schema.Boolean,
  reasoning: Schema.Boolean,
  reasoning_options: Schema.optional(Schema.Array(ReasoningOption)),
-  temperature: Schema.Boolean,
+  temperature: Schema.optional(Schema.Boolean),
  tool_call: Schema.Boolean,
  interleaved: Schema.optional(
    Schema.Union([
@ -125,6 +125,10 @@ export const Provider = Schema.Struct({

 export type Provider = Schema.Schema.Type<typeof Provider>

+const Providers = Schema.Record(Schema.String, Provider)
+const decodeProviders = Schema.decodeUnknownEffect(Schema.fromJsonString(Providers))
+const decodeProvidersUnknown = Schema.decodeUnknownEffect(Providers)
+
 export const Event = ModelsDev.Event

 declare const OPENCODE_MODELS_DEV: Record<string, Provider> | undefined
@ -176,6 +180,7 @@ const layer = Layer.effect(
    })

    const loadFromDisk = fs.readJson(Flag.OPENCODE_MODELS_PATH ?? filepath).pipe(
+      Effect.flatMap(decodeProvidersUnknown),
      Effect.catch((error) => {
        if (
          Flag.OPENCODE_MODELS_PATH === undefined &&
@ -186,11 +191,17 @@ const layer = Layer.effect(
        }
        return Effect.succeed(undefined)
      }),
-      Effect.map((v) => v as Record<string, Provider> | undefined),
    )

    const loadSnapshot = Effect.sync(() =>
      typeof OPENCODE_MODELS_DEV === "undefined" ? undefined : OPENCODE_MODELS_DEV,
+    ).pipe(
+      Effect.flatMap((snapshot) =>
+        snapshot === undefined ? Effect.succeed(undefined) : decodeProvidersUnknown(snapshot),
+      ),
+      Effect.catch((cause) =>
+        Effect.logWarning("bundled models snapshot failed schema decode", { cause }).pipe(Effect.as(undefined)),
+      ),
    )

    const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
@ -221,7 +232,7 @@ const layer = Layer.effect(
          return yield* fetchAndWrite()
        }),
      )
-      return JSON.parse(text) as Record<string, Provider>
+      return yield* decodeProviders(text)
    }).pipe(Effect.withSpan("ModelsDev.populate"), Effect.orDie)

    const [cachedGet, invalidate] = yield* Effect.cachedInvalidateWithTTL(populate, Duration.infinity)
--- a/packages/core/src/permission.ts
+++ b/packages/core/src/permission.ts
@ -1,7 +1,7 @@
 export * as PermissionV2 from "./permission"

 import { makeLocationNode } from "./effect/app-node"
-import { Context, Deferred, Effect as EffectRuntime, Layer, Schema } from "effect"
+import { Context, Deferred, Effect, Layer, Schema } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
 import { Location } from "./location"
@ -11,7 +11,9 @@ import { SessionStore } from "./session/store"
 import { Wildcard } from "./util/wildcard"
 import { PermissionSaved } from "./permission/saved"

-export { Effect, Rule, Ruleset } from "@opencode-ai/schema/permission"
+const PermissionEffect = Permission.Effect
+export { PermissionEffect as Effect }
+export { Rule, Ruleset } from "@opencode-ai/schema/permission"
 const missingAgentPermissions: Permission.Ruleset = [{ action: "*", resource: "*", effect: "deny" }]

 export const ID = Permission.ID
@ -90,12 +92,12 @@ export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
 }

 export interface Interface {
-  readonly ask: (input: AssertInput) => EffectRuntime.Effect<AskResult, SessionV2.NotFoundError>
-  readonly assert: (input: AssertInput) => EffectRuntime.Effect<void, Error | SessionV2.NotFoundError>
-  readonly reply: (input: ReplyInput) => EffectRuntime.Effect<void, NotFoundError>
-  readonly get: (id: ID) => EffectRuntime.Effect<Request | undefined>
-  readonly forSession: (sessionID: SessionV2.ID) => EffectRuntime.Effect<ReadonlyArray<Request>>
-  readonly list: () => EffectRuntime.Effect<ReadonlyArray<Request>>
+  readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionV2.NotFoundError>
+  readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionV2.NotFoundError>
+  readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>
+  readonly get: (id: ID) => Effect.Effect<Request | undefined>
+  readonly forSession: (sessionID: SessionV2.ID) => Effect.Effect<ReadonlyArray<Request>>
+  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Permission") {}
@ -108,7 +110,7 @@ interface Pending {

 const layer = Layer.effect(
  Service,
-  EffectRuntime.gen(function* () {
+  Effect.gen(function* () {
    const events = yield* EventV2.Service
    const location = yield* Location.Service
    const agents = yield* AgentV2.Service
@ -116,28 +118,25 @@ const layer = Layer.effect(
    const saved = yield* PermissionSaved.Service
    const pending = new Map<ID, Pending>()

-    yield* EffectRuntime.addFinalizer(() =>
-      EffectRuntime.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new RejectedError()), {
+    yield* Effect.addFinalizer(() =>
+      Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new RejectedError()), {
        discard: true,
      }).pipe(
-        EffectRuntime.ensuring(
-          EffectRuntime.sync(() => {
+        Effect.ensuring(
+          Effect.sync(() => {
            pending.clear()
          }),
        ),
      ),
    )

-    const savedRules = EffectRuntime.fnUntraced(function* () {
+    const savedRules = Effect.fnUntraced(function* () {
      return (yield* saved.list({ projectID: location.project.id })).map(
        (item): Permission.Rule => ({ action: item.action, resource: item.resource, effect: "allow" }),
      )
    })

-    const configured = EffectRuntime.fn("PermissionV2.configured")(function* (
-      sessionID: SessionV2.ID,
-      agentID?: AgentV2.ID,
-    ) {
+    const configured = Effect.fn("PermissionV2.configured")(function* (sessionID: SessionV2.ID, agentID?: AgentV2.ID) {
      const session = yield* sessions.get(sessionID)
      if (!session) return yield* new SessionV2.NotFoundError({ sessionID })
      const agent = yield* agents.resolve(agentID ?? session.agent)
@ -152,7 +151,7 @@ const layer = Layer.effect(
      return rules.filter((rule) => Wildcard.match(input.action, rule.action))
    }

-    const evaluateInput = EffectRuntime.fnUntraced(function* (input: AssertInput) {
+    const evaluateInput = Effect.fnUntraced(function* (input: AssertInput) {
      const rules = yield* configured(input.sessionID, input.agent)
      if (denied(input, rules)) return { effect: "deny" as const, rules }
      const all = [...rules, ...(yield* savedRules())]
@ -174,29 +173,30 @@ const layer = Layer.effect(
    }

    const create = (request: Request, agent?: AgentV2.ID) =>
-      EffectRuntime.uninterruptible(
-        EffectRuntime.gen(function* () {
+      Effect.uninterruptible(
+        Effect.gen(function* () {
          const deferred = yield* Deferred.make<void, RejectedError | CorrectedError>()
          const item = { request, agent, deferred }
-          if (pending.has(request.id)) return yield* EffectRuntime.die(`Duplicate pending permission ID: ${request.id}`)
+          if (pending.has(request.id))
+            return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request.id}`))
          pending.set(request.id, item)
          yield* events
            .publish(Event.Asked, request)
-            .pipe(EffectRuntime.onError(() => EffectRuntime.sync(() => pending.delete(request.id))))
+            .pipe(Effect.onError(() => Effect.sync(() => pending.delete(request.id))))
          return item
        }),
      )

-    const ask = EffectRuntime.fn("PermissionV2.ask")(function* (input: AssertInput) {
+    const ask = Effect.fn("PermissionV2.ask")(function* (input: AssertInput) {
      const result = yield* evaluateInput(input)
      const value = request(input)
      if (result.effect === "ask") yield* create(value, input.agent)
      return { id: value.id, effect: result.effect }
    })

-    const assert = EffectRuntime.fn("PermissionV2.assert")((input: AssertInput) =>
-      EffectRuntime.uninterruptibleMask((restore) =>
-        EffectRuntime.gen(function* () {
+    const assert = Effect.fn("PermissionV2.assert")((input: AssertInput) =>
+      Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
          const result = yield* evaluateInput(input)
          if (result.effect === "deny") {
            return yield* new DeniedError({
@ -206,8 +206,8 @@ const layer = Layer.effect(
          if (result.effect === "allow") return
          const item = yield* create(request(input), input.agent)
          return yield* restore(Deferred.await(item.deferred)).pipe(
-            EffectRuntime.ensuring(
-              EffectRuntime.sync(() => {
+            Effect.ensuring(
+              Effect.sync(() => {
                pending.delete(item.request.id)
              }),
            ),
@ -216,9 +216,9 @@ const layer = Layer.effect(
      ),
    )

-    const reply = EffectRuntime.fn("PermissionV2.reply")((input: ReplyInput) =>
-      EffectRuntime.uninterruptible(
-        EffectRuntime.gen(function* () {
+    const reply = Effect.fn("PermissionV2.reply")((input: ReplyInput) =>
+      Effect.uninterruptible(
+        Effect.gen(function* () {
          const existing = pending.get(input.requestID)
          if (!existing) return yield* new NotFoundError({ requestID: input.requestID })
          yield* events.publish(Event.Replied, {
@ -261,7 +261,7 @@ const layer = Layer.effect(
          for (const [id, item] of pending) {
            const input = { ...item.request }
            const rules = yield* configured(item.request.sessionID, item.agent).pipe(
-              EffectRuntime.catchTag("Session.NotFoundError", () => EffectRuntime.succeed(undefined)),
+              Effect.catchTag("Session.NotFoundError", () => Effect.succeed(undefined)),
            )
            if (!rules) continue
            if (denied(input, rules)) continue
@ -284,15 +284,15 @@ const layer = Layer.effect(
      ),
    )

-    const list = EffectRuntime.fn("PermissionV2.list")(function* () {
+    const list = Effect.fn("PermissionV2.list")(function* () {
      return Array.from(pending.values(), (item) => item.request)
    })

-    const get = EffectRuntime.fn("PermissionV2.get")(function* (id: ID) {
+    const get = Effect.fn("PermissionV2.get")(function* (id: ID) {
      return pending.get(id)?.request
    })

-    const forSession = EffectRuntime.fn("PermissionV2.forSession")(function* (sessionID: SessionV2.ID) {
+    const forSession = Effect.fn("PermissionV2.forSession")(function* (sessionID: SessionV2.ID) {
      return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID)
    })

--- a/packages/core/src/plugin.ts
+++ b/packages/core/src/plugin.ts
@ -48,7 +48,7 @@ const layer = Layer.effect(
    let host: Parameters<PluginDefinition["effect"]>[0]

    const add = Effect.fn("Plugin.add")(function* (id: ID, effect: PluginDefinition["effect"]) {
-      if (loading.has(id)) return yield* Effect.die(`Plugin load cycle detected for ${id}`)
+      if (loading.has(id)) return yield* Effect.die(new Error(`Plugin load cycle detected for ${id}`))

      yield* locks.withLock(id)(
        Effect.sync(() => {
@ -90,7 +90,7 @@ const layer = Layer.effect(
    })

    const remove = Effect.fn("Plugin.remove")(function* (id: ID) {
-      if (loading.has(id)) return yield* Effect.die(`Cannot remove plugin ${id} while it is loading`)
+      if (loading.has(id)) return yield* Effect.die(new Error(`Cannot remove plugin ${id} while it is loading`))

      yield* locks.withLock(id)(
        State.batch(
--- a/packages/core/src/plugin/host.ts
+++ b/packages/core/src/plugin/host.ts
@ -1,6 +1,6 @@
 export * as PluginHost from "./host"

-import type { PluginContext as Interface } from "@opencode-ai/plugin/v2/effect"
+import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { Effect, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { AISDK } from "../aisdk"
@ -40,7 +40,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
      workspaceID: location.workspaceID,
      project: location.project,
    })
-  const locationRef = (input?: Parameters<Interface["agent"]["list"]>[0]) =>
+  const locationRef = (input?: Parameters<PluginContext["agent"]["list"]>[0]) =>
    input?.location === undefined
      ? undefined
      : Location.Ref.make({
@ -305,5 +305,5 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
      command: runtime.session.command,
      interrupt: (input) => runtime.session.interrupt(input.sessionID),
    },
-  } satisfies Interface
+  } satisfies PluginContext
 })
--- a/packages/core/src/plugin/provider/openai.ts
+++ b/packages/core/src/plugin/provider/openai.ts
@ -1,7 +1,7 @@
 import { createServer } from "node:http"
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
 import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Deferred, Effect, Semaphore, Stream } from "effect"
+import { Deferred, Effect, Option, Schema, Semaphore, Stream } from "effect"
 import type { Scope } from "effect"
 import { Credential } from "../../credential"
 import { EventV2 } from "../../event"
@ -32,11 +32,16 @@ type TokenResponse = {
  expires_in?: number
 }

-type Claims = {
-  chatgpt_account_id?: string
-  organizations?: Array<{ id: string }>
-  "https://api.openai.com/auth"?: { chatgpt_account_id?: string }
-}
+const Claims = Schema.fromJsonString(
+  Schema.Struct({
+    chatgpt_account_id: Schema.optional(Schema.String),
+    organizations: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String }))),
+    "https://api.openai.com/auth": Schema.optional(
+      Schema.Struct({ chatgpt_account_id: Schema.optional(Schema.String) }),
+    ),
+  }),
+)
+const decodeClaims = Schema.decodeUnknownOption(Claims)

 const browser = {
  integrationID: Integration.ID.make("openai"),
@ -315,14 +320,11 @@ function extractAccountID(tokens: TokenResponse) {
 function claim(token: string) {
  const part = token.split(".")[1]
  if (!part) return
-  try {
-    const claims = JSON.parse(Buffer.from(part, "base64url").toString()) as Claims
-    return (
-      claims.chatgpt_account_id ??
-      claims["https://api.openai.com/auth"]?.chatgpt_account_id ??
-      claims.organizations?.[0]?.id
-    )
-  } catch {
-    return
-  }
+  const claims = Option.getOrUndefined(decodeClaims(Buffer.from(part, "base64url").toString()))
+  if (!claims) return
+  return (
+    claims.chatgpt_account_id ??
+    claims["https://api.openai.com/auth"]?.chatgpt_account_id ??
+    claims.organizations?.[0]?.id
+  )
 }
--- a/packages/core/src/plugin/provider/sap-ai-core.ts
+++ b/packages/core/src/plugin/provider/sap-ai-core.ts
@ -19,17 +19,18 @@ export const SapAICorePlugin = define({
        const installedPath = evt.package.startsWith("file://")
          ? evt.package
          : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint
-        if (!installedPath) throw new Error(`Package ${evt.package} has no import entrypoint`)
+        if (!installedPath) return yield* Effect.die(new Error(`Package ${evt.package} has no import entrypoint`))

-        const mod = yield* Effect.promise(async () => {
-          return (await import(
-            installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href
-          )) as Record<string, (options: any) => any>
-        }).pipe(Effect.orDie)
+        const mod: Record<string, unknown> = yield* Effect.promise(
+          () => import(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href),
+        )
        const match = Object.keys(mod).find((name) => name.startsWith("create"))
-        if (!match) throw new Error(`Package ${evt.package} has no provider factory export`)
+        if (!match) return yield* Effect.die(new Error(`Package ${evt.package} has no provider factory export`))
+        const factory = mod[match]
+        if (typeof factory !== "function")
+          return yield* Effect.die(new Error(`Package ${evt.package} provider factory export is not callable`))

-        evt.sdk = mod[match](
+        evt.sdk = factory(
          serviceKey
            ? { deploymentId: process.env.AICORE_DEPLOYMENT_ID, resourceGroup: process.env.AICORE_RESOURCE_GROUP }
            : {},
--- a/packages/core/src/plugin/runtime.ts
+++ b/packages/core/src/plugin/runtime.ts
@ -31,7 +31,7 @@ export interface Cell {

 export const makeCell = (): Cell => ({})

-const unavailable = <A, E, R>() => Effect.die("Plugin runtime is unavailable") as Effect.Effect<A, E, R>
+const unavailable = <A, E, R>() => Effect.die(new Error("Plugin runtime is unavailable")) as Effect.Effect<A, E, R>
 const require = <A, E, R>(cell: Cell, f: (runtime: Interface) => Effect.Effect<A, E, R>) =>
  Effect.suspend(() => {
    const runtime = cell.runtime
--- a/packages/core/src/policy.ts
+++ b/packages/core/src/policy.ts
@ -1,22 +1,23 @@
 export * as Policy from "./policy"

 import { makeLocationNode } from "./effect/app-node"
-import { Context, Effect as EffectRuntime, Layer, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { Wildcard } from "./util/wildcard"
 import { Location } from "./location"

-export const Effect = Schema.Literals(["allow", "deny"]).annotate({ identifier: "Policy.Effect" })
-export type Effect = typeof Effect.Type
+const PolicyEffect = Schema.Literals(["allow", "deny"]).annotate({ identifier: "Policy.Effect" })
+export { PolicyEffect as Effect }
+export type Effect = typeof PolicyEffect.Type

 export class Info extends Schema.Class<Info>("Policy.Info")({
  action: Schema.String,
-  effect: Effect,
+  effect: PolicyEffect,
  resource: Schema.String,
 }) {}

 export interface Interface {
-  readonly load: (statements: Info[]) => EffectRuntime.Effect<void>
-  readonly evaluate: (action: string, resource: string, fallback: Effect) => EffectRuntime.Effect<Effect>
+  readonly load: (statements: Info[]) => Effect.Effect<void>
+  readonly evaluate: (action: string, resource: string, fallback: Effect) => Effect.Effect<Effect>
  readonly hasStatements: () => boolean
 }

@ -24,16 +25,16 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2

 const layer = Layer.effect(
  Service,
-  EffectRuntime.gen(function* () {
+  Effect.gen(function* () {
    let statements: Info[] = []
    yield* Location.Service

    return Service.of({
-      load: EffectRuntime.fn("Policy.load")(function* (input) {
+      load: Effect.fn("Policy.load")(function* (input) {
        statements = input
      }),
      hasStatements: () => statements.length > 0,
-      evaluate: EffectRuntime.fn("Policy.evaluate")(function* (action, resource, fallback) {
+      evaluate: Effect.fn("Policy.evaluate")(function* (action, resource, fallback) {
        return (
          statements.findLast(
            (statement) => Wildcard.match(action, statement.action) && Wildcard.match(resource, statement.resource),
--- a/packages/core/src/project/copy.ts
+++ b/packages/core/src/project/copy.ts
@ -139,7 +139,7 @@ const layer = Layer.effect(
    })

    const canonical = Effect.fnUntraced(function* (input: AbsolutePath) {
-      const resolved = AbsolutePath.make(FSUtil.resolve(input))
+      const resolved = AbsolutePath.make(yield* fs.resolve(input))
      if (!(yield* fs.isDir(resolved))) return yield* new DirectoryUnavailableError({ directory: input })
      return resolved
    })
@ -202,7 +202,8 @@ const layer = Layer.effect(
      const copyDirectory = yield* canonical(input.directory)
      const stored = yield* directories.get({ projectID: input.projectID, directory: copyDirectory })
      if (!stored?.strategy) return yield* new InvalidDirectoryError({ directory: copyDirectory })
-      yield* (yield* getStrategy(StrategyID.make(stored.strategy))).remove({
+      const strategy = yield* getStrategy(StrategyID.make(stored.strategy))
+      yield* strategy.remove({
        directory: copyDirectory,
        force: input.force,
      })
--- a/packages/core/src/project/sql.ts
+++ b/packages/core/src/project/sql.ts
@ -1,11 +1,11 @@
 import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
-import * as DatabasePath from "../database/path"
+import { absoluteArrayColumn, absoluteColumn } from "../database/path"
 import { Timestamps } from "../database/schema.sql"
 import { ProjectSchema } from "./schema"

 export const ProjectTable = sqliteTable("project", {
  id: text().$type<ProjectSchema.ID>().primaryKey(),
-  worktree: DatabasePath.absoluteColumn().notNull(),
+  worktree: absoluteColumn().notNull(),
  vcs: text(),
  name: text(),
  icon_url: text(),
@ -13,7 +13,7 @@ export const ProjectTable = sqliteTable("project", {
  icon_color: text(),
  ...Timestamps,
  time_initialized: integer(),
-  sandboxes: DatabasePath.absoluteArrayColumn().notNull(),
+  sandboxes: absoluteArrayColumn().notNull(),
  commands: text({ mode: "json" }).$type<{ start?: string }>(),
 })

@ -24,7 +24,7 @@ export const ProjectDirectoryTable = sqliteTable(
      .$type<ProjectSchema.ID>()
      .notNull()
      .references(() => ProjectTable.id, { onDelete: "cascade" }),
-    directory: DatabasePath.absoluteColumn().notNull(),
+    directory: absoluteColumn().notNull(),
    type: text().$type<"main" | "root" | "git_worktree">(),
    strategy: text(),
    time_created: integer()
--- a/packages/core/src/pty/pty.bun.ts
+++ b/packages/core/src/pty/pty.bun.ts
@ -1,10 +1,10 @@
-import { spawn as create } from "bun-pty"
+import { spawn } from "bun-pty"
 import type { Opts, Proc } from "./pty"

 export type { Disp, Exit, Opts, Proc } from "./pty"

-export function spawn(file: string, args: string[], opts: Opts): Proc {
-  const pty = create(file, args, opts)
+function spawnPty(file: string, args: string[], opts: Opts): Proc {
+  const pty = spawn(file, args, opts)
  return {
    pid: pty.pid,
    onData(listener) {
@ -24,3 +24,5 @@ export function spawn(file: string, args: string[], opts: Opts): Proc {
    },
  }
 }
+
+export { spawnPty as spawn }
--- a/packages/core/src/pty/pty.node.ts
+++ b/packages/core/src/pty/pty.node.ts
@ -1,3 +1,4 @@
+// ast-grep-ignore: no-star-import
 import * as pty from "@lydell/node-pty"
 import type { Opts, Proc } from "./pty"

--- a/packages/core/src/pty/ticket.ts
+++ b/packages/core/src/pty/ticket.ts
@ -32,7 +32,7 @@ function matches(record: Scope, input: Scope) {

 // Tickets are inserted via Cache.set and removed atomically via invalidateWhen. The lookup is
 // never invoked; it dies if it ever is, which would signal a misuse of the Service interface.
-const noLookup = () => Effect.die("PtyTicket cache must be used via set/invalidateWhen, never get")
+const noLookup = () => Effect.die(new Error("PtyTicket cache must be used via set/invalidateWhen, never get"))

 // Visible for tests so the TTL can be shortened. Production uses `layer` with the default TTL.
 export const make = (ttl: Duration.Input = DEFAULT_TTL) =>
--- a/packages/core/src/ripgrep.ts
+++ b/packages/core/src/ripgrep.ts
@ -35,6 +35,7 @@ const RawMatch = Schema.Struct({
    ),
  }),
 })
+const decodeJsonRecord = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)

 type RawMatchData = (typeof RawMatch.Type)["data"]

@ -232,10 +233,7 @@ const layer = Layer.effect(
          parse: (line) =>
            (Buffer.byteLength(line, "utf8") > MAX_RECORD_BYTES
              ? Effect.fail(failure(`Ripgrep JSON record exceeded ${MAX_RECORD_BYTES} bytes`))
-              : Effect.try({
-                  try: () => JSON.parse(line) as unknown,
-                  catch: (cause) => failure("Invalid ripgrep JSON output", cause),
-                })
+              : decodeJsonRecord(line).pipe(Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)))
            ).pipe(
              Effect.flatMap((json) => {
                if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
--- a/packages/core/src/session.ts
+++ b/packages/core/src/session.ts
@ -41,6 +41,9 @@ import type { EventLog } from "@opencode-ai/schema/event-log"
 import { SkillV2 } from "./skill"
 import { Job } from "./job"
 import { CommandV2 } from "./command"
+import { Identifier } from "./util/identifier"
+import { Shell } from "./shell"
+import { KeyedMutex } from "./effect/keyed-mutex"

 export const RevertState = Revert.State
 export type RevertState = Revert.State
@ -106,7 +109,7 @@ export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Ses
 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
  "Session.OperationUnavailableError",
  {
-    operation: Schema.Literals(["move", "shell", "skill", "switchAgent", "compact"]),
+    operation: Schema.Literals(["move", "skill", "switchAgent", "compact"]),
  },
 ) {}

@ -208,8 +211,7 @@ export interface Interface {
    id?: EventV2.ID
    sessionID: SessionSchema.ID
    command: string
-    resume?: boolean
-  }) => Effect.Effect<void, OperationUnavailableError>
+  }) => Effect.Effect<void, NotFoundError>
  readonly skill: (input: {
    id?: SessionMessage.ID
    sessionID: SessionSchema.ID
@ -255,6 +257,8 @@ const layer = Layer.effect(
    const locations = yield* LocationServiceMap.Service
    const jobs = yield* Job.Service
    const scope = yield* Scope.Scope
+    const activeShells = new Set<SessionSchema.ID>()
+    const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
    const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
    const decode = (row: typeof SessionMessageTable.$inferSelect) =>
@ -268,6 +272,19 @@ const layer = Layer.effect(
        ),
      )

+    // Session shell is user-initiated and synchronous at the API boundary, while
+    // the Location shell service owns process lifecycle and file-backed output.
+    const runShellCommand = (command: string, cwd: string) =>
+      Effect.gen(function* () {
+        const shell = yield* Shell.Service
+        const info = yield* shell.create({ command, cwd })
+        yield* shell.wait(info.id)
+        const output = yield* shell.output(info.id, { limit: SHELL_MAX_CAPTURE_BYTES })
+        return output.output || "(no output)"
+      }).pipe(
+        Effect.catchTag("Shell.NotFoundError", () => Effect.succeed("Shell command output is no longer available.")),
+      )
+
    const result = Service.of({
      create: Effect.fn("V2Session.create")(function* (input) {
        const sessionID = input.id ?? SessionSchema.ID.create()
@ -346,8 +363,7 @@ const layer = Layer.effect(
        yield* events.publish(SessionEvent.Forked, {
          sessionID,
          parentID: parent.id,
-          messageID: input.messageID,
-          timestamp: yield* DateTime.now,
+          from: input.messageID,
        })
        return yield* result.get(sessionID).pipe(Effect.orDie)
      }),
@ -489,7 +505,10 @@ const layer = Layer.effect(
            )
            if (!SessionInput.equivalent(admitted, expected))
              return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
-            if (input.resume !== false) yield* execution.wake(admitted.sessionID)
+            if (input.resume !== false) {
+              if (activeShells.has(admitted.sessionID)) return admitted
+              yield* execution.wake(admitted.sessionID)
+            }
            return admitted
          }),
        ),
@ -525,8 +544,39 @@ const layer = Layer.effect(
          resume: input.resume,
        })
      }),
-      shell: Effect.fn("V2Session.shell")(function* () {
-        return yield* new OperationUnavailableError({ operation: "shell" })
+      shell: Effect.fn("V2Session.shell")(function* (input) {
+        const session = yield* result.get(input.sessionID)
+        yield* shellLocks.withLock(input.sessionID)(
+          Effect.gen(function* () {
+            activeShells.add(input.sessionID)
+            if ((yield* execution.active).has(input.sessionID)) yield* execution.awaitIdle(input.sessionID)
+            const callID = Identifier.ascending()
+            yield* events.publish(
+              SessionEvent.Shell.Started,
+              {
+                sessionID: input.sessionID,
+                callID,
+                command: input.command,
+              },
+              { id: input.id },
+            )
+            const output = yield* runShellCommand(input.command, session.location.directory).pipe(
+              Effect.provide(locations.get(session.location)),
+            )
+            yield* events.publish(SessionEvent.Shell.Ended, {
+              sessionID: input.sessionID,
+              callID,
+              output,
+            })
+          }).pipe(
+            Effect.ensuring(
+              Effect.gen(function* () {
+                activeShells.delete(input.sessionID)
+                yield* execution.wake(input.sessionID)
+              }),
+            ),
+          ),
+        )
      }),
      skill: Effect.fn("V2Session.skill")(function* (input) {
        const session = yield* result.get(input.sessionID)
@ -535,8 +585,6 @@ const layer = Layer.effect(
        if (!skill) return yield* new SkillNotFoundError({ skill: input.skill })
        yield* events.publish(SessionEvent.Skill.Activated, {
          sessionID: input.sessionID,
-          messageID: input.id ?? SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
          name: skill.name,
          text: skill.content,
        })
@ -547,10 +595,8 @@ const layer = Layer.effect(
      }),
      switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
        yield* result.get(input.sessionID)
-        yield* events.publish(SessionEvent.AgentSwitched, {
+        yield* events.publish(SessionEvent.AgentSelected, {
          sessionID: input.sessionID,
-          messageID: SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
          agent: input.agent,
        })
      }),
@ -562,10 +608,8 @@ const layer = Layer.effect(
          (session.model.variant ?? "default") === (input.model.variant ?? "default")
        )
          return
-        yield* events.publish(SessionEvent.ModelSwitched, {
+        yield* events.publish(SessionEvent.ModelSelected, {
          sessionID: input.sessionID,
-          messageID: SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
          model: input.model,
        })
      }),
@ -573,7 +617,6 @@ const layer = Layer.effect(
        yield* result.get(input.sessionID)
        yield* events.publish(SessionEvent.Renamed, {
          sessionID: input.sessionID,
-          timestamp: yield* DateTime.now,
          title: input.title,
        })
      }),
@ -621,8 +664,6 @@ const layer = Layer.effect(
        yield* result.get(input.sessionID)
        yield* events.publish(SessionEvent.Synthetic, {
          sessionID: input.sessionID,
-          messageID: SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
          text: input.text,
          description: input.description,
          metadata: input.metadata,
@ -679,6 +720,9 @@ const resolvePrompt = (input: PromptInput.Prompt) =>
    }),
  })

+// Mirrors the shell tool's in-memory preview safety limit.
+const SHELL_MAX_CAPTURE_BYTES = 1024 * 1024
+
 export const node = makeGlobalNode({
  service: Service,
  layer: layer.pipe(Layer.orDie),
--- a/packages/core/src/session/compaction.ts
+++ b/packages/core/src/session/compaction.ts
@ -2,14 +2,12 @@ export * as SessionCompaction from "./compaction"

 import { LLM, LLMClient, LLMError, LLMEvent, Message, type LLMRequest, type Model } from "@opencode-ai/llm"
 import { Context, DateTime, Effect, Layer, Stream } from "effect"
-import type { Config } from "../config"
-import { Config as ConfigV2 } from "../config"
-import type { EventV2 } from "../event"
-import { EventV2 as EventV2Service } from "../event"
+import { Config } from "../config"
+import { EventV2 } from "../event"
 import { makeLocationNode } from "../effect/app-node"
 import { llmClient } from "../effect/app-node-platform"
 import { SessionEvent } from "./event"
-import { SessionMessage } from "./message"
+import type { SessionMessage } from "./message"
 import { SessionRunnerModel } from "./runner/model"
 import { SessionSchema } from "./schema"
 import { Token } from "../util/token"
@ -208,11 +206,8 @@ const make = (dependencies: Dependencies) => {
    const summaryPrompt = buildPrompt({ previousSummary: input.previousSummary, context: input.context })
    const summaryOutput = Math.min(output || SUMMARY_OUTPUT_TOKENS, SUMMARY_OUTPUT_TOKENS)
    if (Token.estimate(summaryPrompt) > context - summaryOutput) return false
-    const messageID = SessionMessage.ID.create()
    yield* dependencies.events.publish(SessionEvent.Compaction.Started, {
      sessionID: input.sessionID,
-      messageID,
-      timestamp: yield* DateTime.now,
      reason: input.reason,
    })

@ -240,8 +235,6 @@ const make = (dependencies: Dependencies) => {
    if (!summarized || failed || !summary.trim()) return false
    yield* dependencies.events.publish(SessionEvent.Compaction.Ended, {
      sessionID: input.sessionID,
-      messageID,
-      timestamp: yield* DateTime.now,
      reason: input.reason,
      text: summary,
      recent: input.recent,
@ -311,9 +304,9 @@ const make = (dependencies: Dependencies) => {
 export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    const events = yield* EventV2Service.Service
+    const events = yield* EventV2.Service
    const llm = yield* LLMClient.Service
-    const config = yield* ConfigV2.Service
+    const config = yield* Config.Service
    const models = yield* SessionRunnerModel.Service
    const compaction = make({ events, llm, config: yield* config.entries() })

@ -336,5 +329,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
  service: Service,
  layer,
-  deps: [EventV2Service.node, llmClient, ConfigV2.node, SessionRunnerModel.node],
+  deps: [EventV2.node, llmClient, Config.node, SessionRunnerModel.node],
 })
--- a/packages/core/src/session/context-checkpoint.ts
+++ b/packages/core/src/session/context-checkpoint.ts
@ -1,13 +1,12 @@
 export * as SessionContextCheckpoint from "./context-checkpoint"

 import { eq } from "drizzle-orm"
-import { DateTime, Effect, Option, Schema } from "effect"
+import { Effect, Option, Schema } from "effect"
 import type { Database } from "../database/database"
 import { EventV2 } from "../event"
 import { SystemContext } from "../system-context/index"
 import { SessionEvent } from "./event"
 import { SessionHistory } from "./history"
-import { SessionMessage } from "./message"
 import { SessionSchema } from "./schema"
 import { SessionContextCheckpointTable } from "./sql"

@ -19,7 +18,7 @@ const decodeApplied = Schema.decodeUnknownOption(SystemContext.Applied)
 * Loads or creates the session's durable context checkpoint, narrating any
 * drift since the model was last told as a chronological update. Completed
 * compaction rebaselines; nothing else rewrites the baseline. Runs before
- * input promotion so a blocked first turn leaves pending inputs untouched.
+ * input promotion so a blocked first step leaves pending inputs untouched.
 */
 export const prepare = Effect.fn("SessionContextCheckpoint.prepare")(function* (
  db: DatabaseService,
@ -50,7 +49,7 @@ export const prepare = Effect.fn("SessionContextCheckpoint.prepare")(function* (

  yield* events.publish(
    SessionEvent.ContextUpdated,
-    { sessionID, messageID: SessionMessage.ID.create(), timestamp: yield* DateTime.now, text: result.text },
+    { sessionID, text: result.text },
    { commit: () => advance(db, sessionID, result.applied).pipe(Effect.orDie) },
  )
  return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
@ -112,7 +111,7 @@ const rewrite = Effect.fnUntraced(function* (
    .returning({ sessionID: SessionContextCheckpointTable.session_id })
    .get()
    .pipe(Effect.orDie)
-  if (!updated) return yield* Effect.die("Context checkpoint not found")
+  if (!updated) return yield* Effect.die(new Error("Context checkpoint not found"))
 })

 const advance = Effect.fnUntraced(function* (
@ -127,5 +126,5 @@ const advance = Effect.fnUntraced(function* (
    .returning({ sessionID: SessionContextCheckpointTable.session_id })
    .get()
    .pipe(Effect.orDie)
-  if (!updated) return yield* Effect.die("Context checkpoint not found")
+  if (!updated) return yield* Effect.die(new Error("Context checkpoint not found"))
 })
--- a/packages/core/src/session/execution/local.ts
+++ b/packages/core/src/session/execution/local.ts
@ -19,8 +19,8 @@ const layer = Layer.effect(
    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError>({
      drain: Effect.fnUntraced(function* (sessionID: SessionSchema.ID, force) {
        const session = yield* store.get(sessionID)
-        if (!session) return yield* Effect.die(`Session not found: ${sessionID}`)
-        return yield* SessionRunner.Service.use((runner) => runner.run({ sessionID, force })).pipe(
+        if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
+        return yield* SessionRunner.Service.use((runner) => runner.drain({ sessionID, force })).pipe(
          Effect.provide(locations.get(session.location)),
          Effect.tapCause((cause) =>
            Cause.hasInterruptsOnly(cause)
@ -36,7 +36,6 @@ const layer = Layer.effect(
            Exit.isFailure(exit) && !Cause.hasInterrupts(exit.cause) ? Cause.squash(exit.cause) : undefined
          yield* events.publish(SessionEvent.ExecutionSettled, {
            sessionID,
-            timestamp: yield* DateTime.now,
            outcome: Exit.isSuccess(exit) ? "success" : Cause.hasInterrupts(exit.cause) ? "interrupted" : "failure",
            error:
              failure !== undefined
--- a/packages/core/src/session/history.ts
+++ b/packages/core/src/session/history.ts
@ -34,7 +34,7 @@ const messageRows = Effect.fnUntraced(function* (
      and(
        eq(SessionMessageTable.session_id, sessionID),
        // Keep system updates visible in the gap between a completed compaction
-        // and the next prepared turn's rebaseline, when their content is not yet
+        // and the next prepared step's rebaseline, when their content is not yet
        // folded into a new baseline.
        compaction
          ? or(
--- a/packages/core/src/session/input.ts
+++ b/packages/core/src/session/input.ts
@ -50,19 +50,17 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
 ) {
  const existing = yield* find(db, input.id)
  if (existing !== undefined) return existing
-  const timestamp = yield* DateTime.now
  return yield* events
    .publish(SessionEvent.PromptAdmitted, {
-      messageID: input.id,
+      inputID: input.id,
      sessionID: input.sessionID,
-      timestamp,
      prompt: input.prompt,
      delivery: input.delivery,
    })
    .pipe(
      Effect.flatMap((event) =>
        event.durable === undefined
-          ? Effect.die("Prompt admission event is missing aggregate sequence")
+          ? Effect.die(new Error("Prompt admission event is missing aggregate sequence"))
          : Effect.succeed(
              Admitted.make({
                admittedSeq: event.durable.seq,
@ -70,7 +68,7 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
                sessionID: input.sessionID,
                prompt: input.prompt,
                delivery: input.delivery,
-                timeCreated: timestamp,
+                timeCreated: event.created,
              }),
            ),
      ),
@ -115,14 +113,11 @@ export const projectAdmitted = Effect.fn("SessionInput.projectAdmitted")(functio
  if (!stored) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
 })

-export const projectPrompted = Effect.fn("SessionInput.projectPrompted")(function* (
+export const projectPromptPromoted = Effect.fn("SessionInput.projectPromptPromoted")(function* (
  db: DatabaseService,
  input: {
    readonly id: SessionMessage.ID
    readonly sessionID: SessionSchema.ID
-    readonly prompt: Prompt
-    readonly delivery: Delivery
-    readonly timeCreated: DateTime.Utc
    readonly promotedSeq: number
  },
 ) {
@ -141,15 +136,16 @@ export const projectPrompted = Effect.fn("SessionInput.projectPrompted")(functio
    .pipe(Effect.orDie)
  if (updated) {
    const stored = fromRow(updated)
-    if (!matchesProjection(stored, input)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
-    return
+    if (stored.sessionID !== input.sessionID) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+    return stored
  }

-  // Every Prompted event is published from an admitted inbox row, so a missing or
+  // Every PromptPromoted event is published from an admitted inbox row, so a missing or
  // divergent row on replay is an invariant violation.
  const stored = yield* find(db, input.id)
-  if (!stored || !matchesProjection(stored, input) || stored.promotedSeq !== input.promotedSeq)
+  if (!stored || stored.sessionID !== input.sessionID || stored.promotedSeq !== input.promotedSeq)
    return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  return stored
 })

 export const hasPending = Effect.fn("SessionInput.hasPending")(function* (
@ -206,12 +202,9 @@ const publish = Effect.fn("SessionInput.publish")(function* (
  for (const row of rows) {
    const id = SessionMessage.ID.make(row.id)
    yield* events
-      .publish(SessionEvent.Prompted, {
+      .publish(SessionEvent.PromptPromoted, {
        sessionID,
-        timestamp: DateTime.makeUnsafe(row.time_created),
-        messageID: id,
-        prompt: decodePrompt(row.prompt),
-        delivery: row.delivery,
+        inputID: id,
      })
      .pipe(
        Effect.catchDefect((defect) =>
--- a/packages/core/src/session/instructions.ts
+++ b/packages/core/src/session/instructions.ts
@ -35,10 +35,10 @@ const layer = Layer.effect(
    // Resolved once for the Location layer; the synthetic text and dedup ledger keep
    // absolute paths, but the human-facing description shows paths relative to the project
    // root so opening a subdirectory still describes paths from the project root.
-    const root = FSUtil.resolve(location.project.directory)
-    // Same-turn parallel reads settle concurrently, so an in-memory claim guards each
+    const root = yield* fs.resolve(location.project.directory)
+    // Same-step parallel reads settle concurrently, so an in-memory claim guards each
    // Session/path pair before any filesystem work. The durable history check below covers
-    // paths injected in earlier turns after this Location layer was reopened.
+    // paths injected in earlier steps after this Location layer was reopened.
    const injected = yield* Ref.make<Map<SessionSchema.ID, Set<string>>>(new Map())

    const load = Effect.fn("SessionInstructions.load")(function* (input: {
@ -60,9 +60,9 @@ const layer = Layer.effect(
      const files = yield* Effect.forEach(
        toInject,
        (path) =>
-          fs.readFileStringSafe(path).pipe(
-            Effect.map((content) => (content === undefined ? undefined : { path, content })),
-          ),
+          fs
+            .readFileStringSafe(path)
+            .pipe(Effect.map((content) => (content === undefined ? undefined : { path, content }))),
        { concurrency: "unbounded" },
      )
      const readable = files.filter((file): file is { path: string; content: string } => file !== undefined)
@ -74,8 +74,6 @@ const layer = Layer.effect(
      // metadata so it survives across Location layer restarts.
      yield* events.publish(SessionEvent.Synthetic, {
        sessionID: input.sessionID,
-        messageID: SessionMessage.ID.create(),
-        timestamp: yield* DateTime.now,
        text: readable.map((file) => `Instructions from: ${file.path}\n${file.content}`).join("\n\n"),
        description: `Loaded ${readable.map((file) => describePath(root, file.path)).join(", ")}`,
        metadata: { instruction: { paths: readable.map((file) => file.path) } },
--- a/packages/core/src/session/message-updater.ts
+++ b/packages/core/src/session/message-updater.ts
@ -19,7 +19,7 @@ export interface Adapter {
 export function memory(state: MemoryState): Adapter {
  const assistantIndex = (messageID: SessionMessage.ID) =>
    state.messages.findLastIndex((message) => message.id === messageID)
-  // A newer turn supersedes stale incomplete rows; never resume an older assistant projection.
+  // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
  const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
  const activeShellIndex = (callID: string) =>
    state.messages.findLastIndex((message) => message.type === "shell" && message.callID === callID)
@ -100,112 +100,100 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {

  return Effect.gen(function* () {
    yield* SessionEvent.All.match(event, {
-      "session.next.agent.switched": (event) => {
+      "agent.selected": (event) => {
        return adapter.appendMessage(
-          SessionMessage.AgentSwitched.make({
-            id: event.data.messageID,
+          SessionMessage.AgentSelected.make({
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "agent-switched",
            metadata: event.metadata,
            agent: event.data.agent,
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.model.switched": (event) => {
+      "model.selected": (event) => {
        return adapter.appendMessage(
-          SessionMessage.ModelSwitched.make({
-            id: event.data.messageID,
+          SessionMessage.ModelSelected.make({
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "model-switched",
            metadata: event.metadata,
            model: event.data.model,
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.moved": () => Effect.void,
-      "session.next.renamed": () => Effect.void,
-      "session.next.forked": () => Effect.void,
-      "session.next.prompted": (event) => {
-        return adapter.appendMessage(
-          SessionMessage.User.make({
-            id: event.data.messageID,
-            type: "user",
-            metadata: event.metadata,
-            text: event.data.prompt.text,
-            files: event.data.prompt.files,
-            agents: event.data.prompt.agents,
-            time: { created: event.data.timestamp },
-          }),
-        )
-      },
-      "session.next.prompt.admitted": () => Effect.void,
-      "session.next.execution.settled": () => Effect.void,
-      "session.next.context.updated": (event) =>
+      "session.moved": () => Effect.void,
+      renamed: () => Effect.void,
+      forked: () => Effect.void,
+      "prompt.promoted": () => Effect.void,
+      "prompt.admitted": () => Effect.void,
+      "execution.settled": () => Effect.void,
+      "session.context.updated": (event) =>
        adapter.appendMessage(
          SessionMessage.System.make({
-            id: event.data.messageID,
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "system",
            text: event.data.text,
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        ),
-      "session.next.synthetic": (event) => {
+      synthetic: (event) => {
        return adapter.appendMessage(
          SessionMessage.Synthetic.make({
            sessionID: event.data.sessionID,
            text: event.data.text,
            description: event.data.description,
            metadata: event.data.metadata,
-            id: event.data.messageID,
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "synthetic",
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.skill.activated": (event) => {
+      "skill.activated": (event) => {
        return adapter.appendMessage(
          SessionMessage.Skill.make({
-            id: event.data.messageID,
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "skill",
            name: event.data.name,
            text: event.data.text,
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.shell.started": (event) => {
+      "shell.started": (event) => {
        return adapter.appendMessage(
          SessionMessage.Shell.make({
-            id: event.data.messageID,
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "shell",
            metadata: event.metadata,
            callID: event.data.callID,
            command: event.data.command,
            output: "",
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.shell.ended": (event) => {
+      "shell.ended": (event) => {
        return Effect.gen(function* () {
          const currentShell = yield* adapter.getCurrentShell(event.data.callID)
          if (currentShell) {
            yield* adapter.updateShell(
              produce(currentShell, (draft) => {
                draft.output = event.data.output
-                draft.time.completed = event.data.timestamp
+                draft.time.completed = event.created
              }),
            )
          }
        })
      },
-      "session.next.step.started": (event) => {
+      "step.started": (event) => {
        return Effect.gen(function* () {
          const currentAssistant = yield* adapter.getCurrentAssistant()
          if (currentAssistant) {
            yield* adapter.updateAssistant(
              produce(currentAssistant, (draft) => {
-                draft.time.completed = event.data.timestamp
+                draft.time.completed = event.created
              }),
            )
          }
@ -215,16 +203,16 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
              type: "assistant",
              agent: event.data.agent,
              model: event.data.model,
-              time: { created: event.data.timestamp },
+              time: { created: event.created },
              content: [],
              snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
            }),
          )
        })
      },
-      "session.next.step.ended": (event) => {
+      "step.ended": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.time.completed = event.data.timestamp
+          draft.time.completed = event.created
          draft.finish = event.data.finish
          draft.cost = event.data.cost
          draft.tokens = event.data.tokens
@ -236,33 +224,33 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
            }
        })
      },
-      "session.next.step.failed": (event) => {
+      "step.failed": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          draft.time.completed = event.data.timestamp
+          draft.time.completed = event.created
          draft.finish = "error"
          draft.error = event.data.error
        })
      },
-      "session.next.text.started": (event) => {
+      "text.started": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          draft.content.push(
            castDraft(SessionMessage.AssistantText.make({ type: "text", id: event.data.textID, text: "" })),
          )
        })
      },
-      "session.next.text.delta": (event) => {
+      "text.delta": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestText(draft, event.data.textID)
          if (match) match.text += event.data.delta
        })
      },
-      "session.next.text.ended": (event) => {
+      "text.ended": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestText(draft, event.data.textID)
          if (match) match.text = event.data.text
        })
      },
-      "session.next.tool.input.started": (event) => {
+      "tool.input.started": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          draft.content.push(
            castDraft(
@ -270,26 +258,26 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
                type: "tool",
                id: event.data.callID,
                name: event.data.name,
-                time: { created: event.data.timestamp },
+                time: { created: event.created },
                state: SessionMessage.ToolStatePending.make({ status: "pending", input: "" }),
              }),
            ),
          )
        })
      },
-      "session.next.tool.input.delta": () => Effect.void,
-      "session.next.tool.input.ended": (event) => {
+      "tool.input.delta": () => Effect.void,
+      "tool.input.ended": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestTool(draft, event.data.callID)
          if (match && match.state.status === "pending") match.state.input = event.data.text
        })
      },
-      "session.next.tool.called": (event) => {
+      "tool.called": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestTool(draft, event.data.callID)
          if (match) {
            match.provider = event.data.provider
-            match.time.ran = event.data.timestamp
+            match.time.ran = event.created
            match.state = castDraft(
              SessionMessage.ToolStateRunning.make({
                status: "running",
@ -301,7 +289,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
          }
        })
      },
-      "session.next.tool.progress": (event) => {
+      "tool.progress": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestTool(draft, event.data.callID)
          if (match && match.state.status === "running") {
@ -310,7 +298,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
          }
        })
      },
-      "session.next.tool.success": (event) => {
+      "tool.success": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestTool(draft, event.data.callID)
          if (match && match.state.status === "running") {
@ -319,7 +307,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
              metadata: match.provider?.metadata,
              resultMetadata: event.data.provider.metadata,
            }
-            match.time.completed = event.data.timestamp
+            match.time.completed = event.created
            match.state = castDraft(
              SessionMessage.ToolStateCompleted.make({
                status: "completed",
@ -333,7 +321,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
          }
        })
      },
-      "session.next.tool.failed": (event) => {
+      "tool.failed": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestTool(draft, event.data.callID)
          if (match && (match.state.status === "pending" || match.state.status === "running")) {
@ -342,7 +330,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
              metadata: match.provider?.metadata,
              resultMetadata: event.data.provider.metadata,
            }
-            match.time.completed = event.data.timestamp
+            match.time.completed = event.created
            match.state = castDraft(
              SessionMessage.ToolStateError.make({
                status: "error",
@ -356,7 +344,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
          }
        })
      },
-      "session.next.reasoning.started": (event) => {
+      "reasoning.started": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          draft.content.push(
            castDraft(
@ -365,47 +353,47 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
                id: event.data.reasoningID,
                text: "",
                providerMetadata: event.data.providerMetadata,
-                time: { created: event.data.timestamp },
+                time: { created: event.created },
              }),
            ),
          )
        })
      },
-      "session.next.reasoning.delta": (event) => {
+      "reasoning.delta": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestReasoning(draft, event.data.reasoningID)
          if (match) match.text += event.data.delta
        })
      },
-      "session.next.reasoning.ended": (event) => {
+      "reasoning.ended": (event) => {
        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
          const match = latestReasoning(draft, event.data.reasoningID)
          if (match) {
            match.text = event.data.text
-            match.time = { created: match.time?.created ?? event.data.timestamp, completed: event.data.timestamp }
+            match.time = { created: match.time?.created ?? event.created, completed: event.created }
            if (event.data.providerMetadata !== undefined) match.providerMetadata = event.data.providerMetadata
          }
        })
      },
-      "session.next.retried": () => Effect.void,
-      "session.next.compaction.started": () => Effect.void,
-      "session.next.compaction.delta": () => Effect.void,
-      "session.next.compaction.ended": (event) => {
+      retried: () => Effect.void,
+      "compaction.started": () => Effect.void,
+      "compaction.delta": () => Effect.void,
+      "compaction.ended": (event) => {
        return adapter.appendMessage(
          SessionMessage.Compaction.make({
-            id: event.data.messageID,
+            id: SessionMessage.ID.fromEvent(event.id),
            type: "compaction",
            metadata: event.metadata,
            reason: event.data.reason,
            summary: event.data.text,
            recent: event.data.recent,
-            time: { created: event.data.timestamp },
+            time: { created: event.created },
          }),
        )
      },
-      "session.next.revert.staged": () => Effect.void,
-      "session.next.revert.cleared": () => Effect.void,
-      "session.next.revert.committed": () => Effect.void,
+      "revert.staged": () => Effect.void,
+      "revert.cleared": () => Effect.void,
+      "revert.committed": () => Effect.void,
    })
  })
 }
--- a/packages/core/src/session/projector.ts
+++ b/packages/core/src/session/projector.ts
@ -25,7 +25,7 @@ import type { DeepMutable } from "../schema"
 import { Slug } from "../util/slug"

 type DatabaseService = Database.Interface["db"]
-type MessageEvent = Exclude<SessionEvent.Event, typeof SessionEvent.Forked.Type>
+type MessageEvent = Exclude<SessionEvent.DurableEvent, typeof SessionEvent.Forked.Type>

 const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Message)
 const encodeMessage = Schema.encodeSync(SessionMessage.Message)
@ -157,22 +157,19 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
    .where(eq(SessionTable.id, event.data.parentID))
    .get()
    .pipe(Effect.orDie)
-  if (!parent) return yield* Effect.die(`Fork parent session not found: ${event.data.parentID}`)
-  const boundary = event.data.messageID
+  if (!parent) return yield* Effect.die(new Error(`Fork parent session not found: ${event.data.parentID}`))
+  const boundary = event.data.from
    ? yield* db
        .select({ seq: SessionMessageTable.seq })
        .from(SessionMessageTable)
        .where(
-          and(
-            eq(SessionMessageTable.session_id, event.data.parentID),
-            eq(SessionMessageTable.id, event.data.messageID),
-          ),
+          and(eq(SessionMessageTable.session_id, event.data.parentID), eq(SessionMessageTable.id, event.data.from)),
        )
        .get()
        .pipe(Effect.orDie)
    : undefined
-  if (event.data.messageID && !boundary)
-    return yield* Effect.die(`Fork boundary message not found: ${event.data.messageID}`)
+  if (event.data.from && !boundary)
+    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.from}`))
  const copied = yield* db
    .select({ seq: SessionMessageTable.seq })
    .from(SessionMessageTable)
@ -208,8 +205,8 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
      tokens_reasoning: 0,
      tokens_cache_read: 0,
      tokens_cache_write: 0,
-      time_created: DateTime.toEpochMillis(event.data.timestamp),
-      time_updated: DateTime.toEpochMillis(event.data.timestamp),
+      time_created: DateTime.toEpochMillis(event.created),
+      time_updated: DateTime.toEpochMillis(event.created),
    })
    .onConflictDoNothing()
    .returning({ sessionID: SessionTable.id })
@ -341,7 +338,8 @@ function run(db: DatabaseService, event: MessageEvent) {
    const decodeRow = (row: typeof SessionMessageTable.$inferSelect) =>
      decodeMessage({ ...row.data, id: row.id, type: row.type })
    const updateMessage = (message: SessionMessage.Message) => {
-      if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
+      if (event.durable === undefined)
+        return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
      const encoded = encodeMessage(message)
      const { id, type, ...data } = encoded
      return db
@ -360,7 +358,7 @@ function run(db: DatabaseService, event: MessageEvent) {
    const adapter: SessionMessageUpdater.Adapter = {
      getCurrentAssistant() {
        return Effect.gen(function* () {
-          // A newer turn supersedes stale incomplete rows; never resume an older assistant projection.
+          // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
          const row = yield* db
            .select()
            .from(SessionMessageTable)
@ -417,8 +415,8 @@ function run(db: DatabaseService, event: MessageEvent) {
  })
 }

-function insertMessage(db: DatabaseService, event: SessionEvent.Event, message: SessionMessage.Message) {
-  if (event.durable === undefined) return Effect.die("Durable Session event is missing aggregate sequence")
+function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, message: SessionMessage.Message) {
+  if (event.durable === undefined) return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
  const encoded = encodeMessage(message)
  const { id, type, ...data } = encoded
  return db
@ -438,7 +436,7 @@ function insertMessage(db: DatabaseService, event: SessionEvent.Event, message:
 const layer = Layer.effectDiscard(
  Effect.gen(function* () {
    const events = yield* EventV2.Service
-    const { db } = yield* Database.Service
+    const db = (yield* Database.Service).db
    yield* events.project(SessionV1.Event.Created, (event) =>
      Effect.gen(function* () {
        const stored = yield* db
@ -473,9 +471,9 @@ const layer = Layer.effectDiscard(
          .update(SessionTable)
          .set({
            directory: event.data.location.directory,
-            path: event.data.subdirectory,
+            path: event.data.subpath,
            workspace_id: event.data.location.workspaceID ? WorkspaceV2.ID.make(event.data.location.workspaceID) : null,
-            time_updated: DateTime.toEpochMillis(event.data.timestamp),
+            time_updated: DateTime.toEpochMillis(event.created),
          })
          .where(eq(SessionTable.id, event.data.sessionID))
          .run()
@ -555,19 +553,19 @@ const layer = Layer.effectDiscard(
        if (next) yield* applyUsage(db, sessionID, next)
      }),
    )
-    yield* events.project(SessionEvent.AgentSwitched, (event) =>
+    yield* events.project(SessionEvent.AgentSelected, (event) =>
      db
        .update(SessionTable)
-        .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+        .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
        .where(eq(SessionTable.id, event.data.sessionID))
        .run()
        .pipe(Effect.orDie, Effect.andThen(run(db, event))),
    )
-    yield* events.project(SessionEvent.ModelSwitched, (event) =>
+    yield* events.project(SessionEvent.ModelSelected, (event) =>
      Effect.gen(function* () {
        yield* db
          .update(SessionTable)
-          .set({ model: event.data.model, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+          .set({ model: event.data.model, time_updated: DateTime.toEpochMillis(event.created) })
          .where(eq(SessionTable.id, event.data.sessionID))
          .run()
          .pipe(Effect.orDie)
@ -577,36 +575,43 @@ const layer = Layer.effectDiscard(
    yield* events.project(SessionEvent.Renamed, (event) =>
      db
        .update(SessionTable)
-        .set({ title: event.data.title, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+        .set({ title: event.data.title, time_updated: DateTime.toEpochMillis(event.created) })
        .where(eq(SessionTable.id, event.data.sessionID))
        .run()
        .pipe(Effect.orDie),
    )
    yield* events.project(SessionEvent.Forked, (event) => projectFork(db, event))
-    yield* events.project(SessionEvent.Prompted, (event) =>
+    yield* events.project(SessionEvent.PromptPromoted, (event) =>
      Effect.gen(function* () {
-        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
-        yield* SessionInput.projectPrompted(db, {
-          id: event.data.messageID,
+        if (event.durable === undefined)
+          return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
+        const input = yield* SessionInput.projectPromptPromoted(db, {
+          id: event.data.inputID,
          sessionID: event.data.sessionID,
-          prompt: event.data.prompt,
-          delivery: event.data.delivery,
-          timeCreated: event.data.timestamp,
          promotedSeq: event.durable.seq,
        })
-        yield* run(db, event)
+        yield* insertMessage(db, event, {
+          id: input.id,
+          type: "user",
+          metadata: event.metadata,
+          text: input.prompt.text,
+          files: input.prompt.files,
+          agents: input.prompt.agents,
+          time: { created: event.created },
+        })
      }),
    )
    yield* events.project(SessionEvent.PromptAdmitted, (event) =>
      Effect.gen(function* () {
-        if (event.durable === undefined) return yield* Effect.die("Durable Session event is missing aggregate sequence")
+        if (event.durable === undefined)
+          return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
        yield* SessionInput.projectAdmitted(db, {
          admittedSeq: event.durable.seq,
-          id: event.data.messageID,
+          id: event.data.inputID,
          sessionID: event.data.sessionID,
          prompt: event.data.prompt,
          delivery: event.data.delivery,
-          timeCreated: event.data.timestamp,
+          timeCreated: event.created,
        })
      }),
    )
@ -614,11 +619,11 @@ const layer = Layer.effectDiscard(
    yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
    yield* events.project(SessionEvent.Skill.Activated, (event) =>
      insertMessage(db, event, {
-        id: event.data.messageID,
+        id: SessionMessage.ID.fromEvent(event.id),
        type: "skill",
        name: event.data.name,
        text: event.data.text,
-        time: { created: event.data.timestamp },
+        time: { created: event.created },
      }),
    )
    yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
@ -643,7 +648,7 @@ const layer = Layer.effectDiscard(
        .update(SessionTable)
        .set({
          revert: { ...event.data.revert, files: event.data.revert.files ? [...event.data.revert.files] : undefined },
-          time_updated: DateTime.toEpochMillis(event.data.timestamp),
+          time_updated: DateTime.toEpochMillis(event.created),
        })
        .where(eq(SessionTable.id, event.data.sessionID))
        .run()
@ -652,7 +657,7 @@ const layer = Layer.effectDiscard(
    yield* events.project(SessionEvent.RevertEvent.Cleared, (event) =>
      db
        .update(SessionTable)
-        .set({ revert: null, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+        .set({ revert: null, time_updated: DateTime.toEpochMillis(event.created) })
        .where(eq(SessionTable.id, event.data.sessionID))
        .run()
        .pipe(Effect.orDie, Effect.asVoid),
@ -670,7 +675,7 @@ const layer = Layer.effectDiscard(
          )
          .get()
          .pipe(Effect.orDie)
-        if (!boundary) return yield* Effect.die(`Revert boundary message not found: ${event.data.messageID}`)
+        if (!boundary) return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.messageID}`))
        yield* db
          .delete(SessionMessageTable)
          .where(
@ -690,7 +695,7 @@ const layer = Layer.effectDiscard(
          .pipe(Effect.orDie)
        yield* db
          .update(SessionTable)
-          .set({ revert: null, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+          .set({ revert: null, time_updated: DateTime.toEpochMillis(event.created) })
          .where(eq(SessionTable.id, event.data.sessionID))
          .run()
          .pipe(Effect.orDie)
--- a/packages/core/src/session/revert.ts
+++ b/packages/core/src/session/revert.ts
@ -89,7 +89,6 @@ export const stage = Effect.fn("SessionRevert.stage")(function* (input: {
  } satisfies SessionSchema.Info["revert"]
  yield* events.publish(SessionEvent.RevertEvent.Staged, {
    sessionID: input.session.id,
-    timestamp: yield* DateTime.now,
    revert,
  })
  return revert
@ -106,7 +105,6 @@ export const clear = Effect.fn("SessionRevert.clear")(function* (session: Sessio
  const events = yield* EventV2.Service
  yield* events.publish(SessionEvent.RevertEvent.Cleared, {
    sessionID: session.id,
-    timestamp: yield* DateTime.now,
  })
 })

@ -116,6 +114,5 @@ export const commit = Effect.fn("SessionRevert.commit")(function* (session: Sess
  yield* events.publish(SessionEvent.RevertEvent.Committed, {
    sessionID: session.id,
    messageID: session.revert.messageID,
-    timestamp: yield* DateTime.now,
  })
 })
--- a/packages/core/src/session/runner/index.ts
+++ b/packages/core/src/session/runner/index.ts
@ -9,16 +9,12 @@ import type { SystemContext } from "../../system-context/index"
 import type { ToolOutputStore } from "../../tool-output-store"

 export type RunError =
-  | LLMError
-  | SessionRunnerModel.Error
-  | MessageDecodeError
-  | SystemContext.InitializationBlocked
-  | ToolOutputStore.Error
+  LLMError | SessionRunnerModel.Error | MessageDecodeError | SystemContext.InitializationBlocked | ToolOutputStore.Error

 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {
-  /** Drains eligible durable work. Explicit runs perform one provider attempt even when no work is eligible. */
-  readonly run: (input: {
+  /** Drains eligible durable work. Explicit runs perform one physical attempt even when no work is eligible. */
+  readonly drain: (input: {
    readonly sessionID: SessionSchema.ID
    readonly force: boolean
  }) => Effect.Effect<void, RunError>
--- a/packages/core/src/session/runner/llm.ts
+++ b/packages/core/src/session/runner/llm.ts
@ -1,3 +1,5 @@
+export * as SessionRunnerLLM from "./llm"
+
 import {
  LLM,
  LLMClient,
@ -59,11 +61,11 @@ import { llmClient } from "../../effect/app-node-platform"
 * - Runtime context assembly
 *   - Track V1 runtime-context parity canonically in `specs/v2/session.md`.
 *
- * - One provider turn
+ * - One step
 *   - [x] Translate every projected V2 Session message variant into canonical
 *     `@opencode-ai/llm` messages.
 *   - [ ] Resolve policy-filtered built-in, MCP, plugin, and structured-output tool definitions.
- *   - [x] Stream exactly one `llm.stream(request)` provider turn.
+ *   - [x] Stream exactly one `llm.stream(request)` physical attempt.
 *   - [x] Persist assistant text and usage events incrementally as they arrive.
 *   - [ ] Persist snapshots, patches, and retry notices incrementally as they arrive.
 *   - [x] Persist reasoning, provider errors, and tool-call events incrementally as they arrive.
@ -75,8 +77,8 @@ import { llmClient } from "../../effect/app-node-platform"
 *   - [x] Start each recorded local call eagerly and await all settlements before continuation.
 *   - [ ] Add scoped runtime context, progress updates, attachment normalization,
 *     plugins, and cancellation settlement.
- *   - [x] Reload projected history and start the next explicit provider turn after local tool results.
- *   - [x] Continue for durable user steering accepted during an active provider turn.
+ *   - [x] Reload projected history and start the next explicit step after local tool results.
+ *   - [x] Continue for durable user steering accepted during an active step.
 *   - [ ] Continue for compaction or another continuation condition when required.
 *
 * - Post-run maintenance
@ -84,12 +86,12 @@ import { llmClient } from "../../effect/app-node-platform"
 *   - [ ] Coalesce streamed deltas and add covering projected-history indexes.
 *   - [ ] Update title, summaries, compaction state, and cleanup in bounded background work.
 *
- * Use `llm.stream(request)` for each provider turn. Keep tool execution and continuation here.
+ * Use `llm.stream(request)` for each physical attempt. Keep tool execution and continuation here.
 * Durable continuation recovery remains a separate future slice with an explicit retry policy.
 *
 * The current slice loads V2 history, translates it, resolves a model through a core service, and persists one
- * provider turn. Registry definitions are advertised, local tool calls are settled durably, and an
- * explicit loop starts the next provider turn after local settlement. Configured agent step limits bound the loop.
+ * step. Registry definitions are advertised, local tool calls are settled durably, and an
+ * explicit loop starts the next step after local settlement. Configured agent step limits bound the loop.
 */

 const layer = Layer.effect(
@ -112,14 +114,14 @@ const layer = Layer.effect(
    const db = (yield* Database.Service).db
    const compaction = yield* SessionCompaction.Service
    const title = yield* SessionTitle.Service
-    // Title generation is a side effect of the first turn; it must not delay turn continuation.
+    // Title generation is a side effect of the first step; it must not delay step continuation.
    // Tracked per process so repeated wakes before the second user message arrives don't
    // re-fire a redundant LLM call; `SessionTitle` itself is idempotent based on durable history.
    const titleAttempted = new Set<SessionSchema.ID>()
    const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
    const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID: SessionSchema.ID) {
      const session = yield* store.get(sessionID)
-      if (!session) return yield* Effect.die(`Session not found: ${sessionID}`)
+      if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
      return session
    })

@ -132,7 +134,6 @@ const layer = Layer.effect(
          if (tool.type !== "tool" || (tool.state.status !== "pending" && tool.state.status !== "running")) continue
          yield* events.publish(SessionEvent.Tool.Failed, {
            sessionID,
-            timestamp: yield* DateTime.now,
            assistantMessageID: message.id,
            callID: tool.id,
            error: { type: "unknown", message: "Tool execution interrupted" },
@ -165,7 +166,7 @@ const layer = Layer.effect(
        { concurrency: "unbounded" },
      ).pipe(Effect.map(SystemContext.combine))

-    const runTurnAttempt = Effect.fn("SessionRunner.runTurn")(function* (
+    const attemptStep = Effect.fn("SessionRunner.attemptStep")(function* (
      sessionID: SessionSchema.ID,
      promotion: SessionInput.Delivery | undefined,
      step: number,
@ -176,7 +177,7 @@ const layer = Layer.effect(
        return yield* Effect.interrupt
      const agent = yield* agents.select(session.agent)
      // Establish what the model knows before admitting what the user said, so
-      // a blocked first turn leaves pending inputs untouched.
+      // a blocked first step leaves pending inputs untouched.
      const checkpoint = yield* SessionContextCheckpoint.prepare(
        db,
        events,
@ -230,7 +231,7 @@ const layer = Layer.effect(
        snapshot: startSnapshot,
      })
      const publication = Semaphore.makeUnsafe(1)
-      // Durable publishes are serialized so tool fibers and turn settlement never interleave
+      // Durable publishes are serialized so tool fibers and step settlement never interleave
      // mid-event.
      const serialized = <A, E, R>(effect: Effect.Effect<A, E, R>) => publication.withPermit(effect)
      const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = []) =>
@ -281,7 +282,7 @@ const layer = Layer.effect(
        Effect.ensuring(serialized(publisher.flush())),
      )

-      // Captures the end snapshot, diffs it against the turn's start, and durably ends the
+      // Captures the end snapshot, diffs it against the step's start, and durably ends the
      // assistant step.
      const publishStepEnd = (settlement: NonNullable<ReturnType<typeof publisher.stepSettlement>>) =>
        Effect.gen(function* () {
@ -295,7 +296,6 @@ const layer = Layer.effect(
          yield* serialized(
            events.publish(SessionEvent.Step.Ended, {
              sessionID: session.id,
-              timestamp: yield* DateTime.now,
              assistantMessageID: yield* publisher.startAssistant(),
              finish: settlement.finish,
              cost: 0,
@ -316,7 +316,7 @@ const layer = Layer.effect(
          const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)

          // A context overflow before any assistant output is recoverable: compact and
-          // restart the turn instead of surfacing the provider error.
+          // restart the step instead of surfacing the provider error.
          if (
            recoverOverflow &&
            !publisher.hasAssistantStarted() &&
@ -325,7 +325,7 @@ const layer = Layer.effect(
          )
            return { _tag: "RestartAfterOverflowCompaction", step: currentStep } as const

-          // An unrecovered held-back overflow becomes the turn's durable provider error. A
+          // An unrecovered held-back overflow becomes the step's durable provider error. A
          // thrown LLM failure fails hosted tool calls and the assistant unless a provider
          // error was already recorded from the stream.
          if (overflowFailure) yield* publish(overflowFailure)
@ -346,12 +346,12 @@ const layer = Layer.effect(
          if (questionDismissed || streamInterrupted || toolsInterrupted) {
            yield* FiberSet.clear(toolFibers)
            yield* serialized(publisher.failUnsettledTools("Tool execution interrupted"))
-            yield* serialized(publisher.failAssistant("Provider turn interrupted"))
+            yield* serialized(publisher.failAssistant("Step interrupted"))
            // Match V1: dismissing a question halts the loop like an interruption.
            if (questionDismissed) return yield* Effect.interrupt
          }
          // A settled tool fiber failure is one of two things. A defect from a tool
-          // implementation becomes a failed tool call the model can read, and the turn still
+          // implementation becomes a failed tool call the model can read, and the step still
          // settles so the model may recover. A typed infrastructure failure (tool output
          // could not be persisted) also fails the assistant and then fails the drain.
          const settledFailure = settled._tag === "Failure" && !toolsInterrupted ? settled.cause : undefined
@ -387,7 +387,7 @@ const layer = Layer.effect(
      )
    }, Effect.scoped)

-    const runTurn = Effect.fnUntraced(function* (
+    const runStep = Effect.fnUntraced(function* (
      sessionID: SessionSchema.ID,
      promotion: SessionInput.Delivery | undefined,
      step: number,
@ -399,7 +399,7 @@ const layer = Layer.effect(
      let currentPromotion = promotion
      let currentStep = step
      while (true) {
-        const attempt = yield* runTurnAttempt(sessionID, currentPromotion, currentStep, recoverOverflow)
+        const attempt = yield* attemptStep(sessionID, currentPromotion, currentStep, recoverOverflow)
        if (attempt._tag === "Completed") return { needsContinuation: attempt.needsContinuation, step: attempt.step }
        if (attempt._tag === "RestartAfterOverflowCompaction") recoverOverflow = undefined
        yield* Effect.yieldNow
@ -410,7 +410,7 @@ const layer = Layer.effect(

    // ExecutionSettled is published per execution (busy period) by SessionExecution, not per
    // drain here.
-    const run = Effect.fn("SessionRunner.run")(function* (input: {
+    const drain = Effect.fn("SessionRunner.drain")(function* (input: {
      readonly sessionID: SessionSchema.ID
      readonly force: boolean
    }) {
@ -423,9 +423,13 @@ const layer = Layer.effect(
      while (shouldRun) {
        let needsContinuation = true
        let step = 1
+        // Repeat steps while continuation is needed. A step needs continuation only
+        // when it recorded local tool calls whose results the model has not yet seen;
+        // a provider error suppresses it. Pending steers also continue the loop so
+        // interjections are answered before the session goes idle.
        while (needsContinuation) {
-          const result = yield* runTurn(input.sessionID, promotion, step)
-          // Steer/queue promotion inside runTurn has already made the pending input a visible
+          const result = yield* runStep(input.sessionID, promotion, step)
+          // Steer/queue promotion inside runStep has already made the pending input a visible
          // user message by this point, so the first-user-message check below is reliable.
          if (!titleAttempted.has(input.sessionID)) {
            titleAttempted.add(input.sessionID)
@ -441,7 +445,7 @@ const layer = Layer.effect(
      }
    })

-    return Service.of({ run })
+    return Service.of({ drain })
  }),
 )

--- a/packages/core/src/session/runner/model.ts
+++ b/packages/core/src/session/runner/model.ts
@ -2,8 +2,11 @@ export * as SessionRunnerModel from "./model"

 import { makeLocationNode } from "../../effect/app-node"
 import { type Model } from "@opencode-ai/llm"
+// ast-grep-ignore: no-star-import
 import * as AnthropicMessages from "@opencode-ai/llm/protocols/anthropic-messages"
+// ast-grep-ignore: no-star-import
 import * as OpenAICompatibleChat from "@opencode-ai/llm/protocols/openai-compatible-chat"
+// ast-grep-ignore: no-star-import
 import * as OpenAIResponses from "@opencode-ai/llm/protocols/openai-responses"
 import { Auth, type AnyRoute } from "@opencode-ai/llm/route"
 import { Context, Effect, Layer, Schema } from "effect"
--- a/packages/core/src/session/runner/publish-llm-event.ts
+++ b/packages/core/src/session/runner/publish-llm-event.ts
@ -50,7 +50,7 @@ const settledOutput = (value: ToolOutput | undefined, result: ToolResultValue):
  return { structured: record(settled.structured), content: settled.content }
 }

-/** Persist one provider turn without executing tools or starting a continuation turn. */
+/** Persist one step without executing tools or starting a continuation step. */
 export const createLLMEventPublisher = (events: EventV2.Interface, input: Input) => {
  const tools = new Map<
    string,
@ -78,14 +78,13 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
    yield* events.publish(SessionEvent.Step.Started, {
      ...input,
      assistantMessageID,
-      timestamp: yield* timestamp,
      snapshot: input.snapshot,
    })
    return assistantMessageID
  })
  const currentAssistantMessageID = () =>
    assistantMessageID === undefined
-      ? Effect.die("Tool event before assistant step start")
+      ? Effect.die(new Error("Tool event before assistant step start"))
      : Effect.succeed(assistantMessageID)

  const fragments = (
@ -95,20 +94,20 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
    const chunks = new Map<string, string[]>()
    const start = (id: string) =>
      Effect.suspend(() => {
-        if (chunks.has(id)) return Effect.die(`Duplicate ${name} start: ${id}`)
+        if (chunks.has(id)) return Effect.die(new Error(`Duplicate ${name} start: ${id}`))
        chunks.set(id, [])
        return Effect.void
      })
    const append = (id: string, value: string) =>
      Effect.suspend(() => {
        const current = chunks.get(id)
-        if (!current) return Effect.die(`${name} delta before start: ${id}`)
+        if (!current) return Effect.die(new Error(`${name} delta before start: ${id}`))
        current.push(value)
        return Effect.void
      })
    const end = Effect.fnUntraced(function* (id: string, providerMetadata?: ProviderMetadata) {
      const current = chunks.get(id)
-      if (!current) return yield* Effect.die(`${name} end before start: ${id}`)
+      if (!current) return yield* Effect.die(new Error(`${name} end before start: ${id}`))
      yield* ended(id, current.join(""), providerMetadata)
      chunks.delete(id)
    })
@ -123,7 +122,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      yield* events.publish(SessionEvent.Text.Ended, {
        sessionID: input.sessionID,
        assistantMessageID: yield* currentAssistantMessageID(),
-        timestamp: yield* timestamp,
        textID,
        text: value,
      })
@ -134,7 +132,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      yield* events.publish(SessionEvent.Reasoning.Ended, {
        sessionID: input.sessionID,
        assistantMessageID: yield* currentAssistantMessageID(),
-        timestamp: yield* timestamp,
        reasoningID,
        text: value,
        providerMetadata,
@ -144,10 +141,9 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
  const toolInput = fragments("tool input", (callID, value) =>
    Effect.gen(function* () {
      const tool = tools.get(callID)
-      if (!tool) return yield* Effect.die(`Tool input end before start: ${callID}`)
+      if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${callID}`))
      yield* events.publish(SessionEvent.Tool.Input.Ended, {
        sessionID: input.sessionID,
-        timestamp: yield* timestamp,
        assistantMessageID: tool.assistantMessageID,
        callID,
        text: value,
@ -163,7 +159,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
  })

  const startToolInput = Effect.fnUntraced(function* (event: { readonly id: string; readonly name: string }) {
-    if (tools.has(event.id)) return yield* Effect.die(`Duplicate tool input start: ${event.id}`)
+    if (tools.has(event.id)) return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`))
    const assistantMessageID = yield* startAssistant()
    tools.set(event.id, {
      assistantMessageID,
@ -176,7 +172,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
    yield* toolInput.start(event.id)
    yield* events.publish(SessionEvent.Tool.Input.Started, {
      sessionID: input.sessionID,
-      timestamp: yield* timestamp,
      assistantMessageID,
      callID: event.id,
      name: event.name,
@ -185,10 +180,10 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)

  const endToolInput = Effect.fnUntraced(function* (event: { readonly id: string; readonly name: string }) {
    const tool = tools.get(event.id)
-    if (!tool) return yield* Effect.die(`Tool input end before start: ${event.id}`)
+    if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${event.id}`))
    if (tool.name !== event.name)
-      return yield* Effect.die(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`)
-    if (tool.inputEnded) return yield* Effect.die(`Duplicate tool input end: ${event.id}`)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`))
+    if (tool.inputEnded) return yield* Effect.die(new Error(`Duplicate tool input end: ${event.id}`))
    yield* toolInput.end(event.id)
  })

@ -204,7 +199,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
    assistantFailed = true
    yield* events.publish(SessionEvent.Step.Failed, {
      sessionID: input.sessionID,
-      timestamp: yield* timestamp,
      assistantMessageID,
      error: { type: "unknown", message },
    })
@ -219,7 +213,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      tool.settled = true
      yield* events.publish(SessionEvent.Tool.Failed, {
        sessionID: input.sessionID,
-        timestamp: yield* timestamp,
        assistantMessageID: tool.assistantMessageID,
        callID,
        error: { type: "unknown", message },
@ -233,7 +226,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)

  const assistantMessageIDForTool = (callID: string) => {
    const tool = tools.get(callID)
-    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(`Unknown tool call: ${callID}`)
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${callID}`))
  }

  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (
@ -248,7 +241,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        yield* events.publish(SessionEvent.Text.Started, {
          sessionID: input.sessionID,
          assistantMessageID: yield* startAssistant(),
-          timestamp: yield* timestamp,
          textID: event.id,
        })
        return
@ -257,7 +249,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        yield* events.publish(SessionEvent.Text.Delta, {
          sessionID: input.sessionID,
          assistantMessageID: yield* currentAssistantMessageID(),
-          timestamp: yield* timestamp,
          textID: event.id,
          delta: event.text,
        })
@ -270,7 +261,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        yield* events.publish(SessionEvent.Reasoning.Started, {
          sessionID: input.sessionID,
          assistantMessageID: yield* startAssistant(),
-          timestamp: yield* timestamp,
          reasoningID: event.id,
          providerMetadata: event.providerMetadata,
        })
@ -280,7 +270,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        yield* events.publish(SessionEvent.Reasoning.Delta, {
          sessionID: input.sessionID,
          assistantMessageID: yield* currentAssistantMessageID(),
-          timestamp: yield* timestamp,
          reasoningID: event.id,
          delta: event.text,
        })
@ -293,14 +282,13 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        return
      case "tool-input-delta": {
        const tool = tools.get(event.id)
-        if (!tool) return yield* Effect.die(`Tool input delta before start: ${event.id}`)
+        if (!tool) return yield* Effect.die(new Error(`Tool input delta before start: ${event.id}`))
        if (tool.name !== event.name)
-          return yield* Effect.die(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`)
-        if (tool.inputEnded) return yield* Effect.die(`Tool input delta after end: ${event.id}`)
+          return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`))
+        if (tool.inputEnded) return yield* Effect.die(new Error(`Tool input delta after end: ${event.id}`))
        yield* toolInput.append(event.id, event.text)
        yield* events.publish(SessionEvent.Tool.Input.Delta, {
          sessionID: input.sessionID,
-          timestamp: yield* timestamp,
          assistantMessageID: tool.assistantMessageID,
          callID: event.id,
          delta: event.text,
@ -315,14 +303,13 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        const tool = tools.get(event.id)!
        if (!tool.inputEnded) yield* endToolInput(event)
        if (tool.name !== event.name)
-          return yield* Effect.die(`Tool call name changed for ${event.id}: ${tool.name} -> ${event.name}`)
-        if (tool.called) return yield* Effect.die(`Duplicate tool call: ${event.id}`)
+          return yield* Effect.die(new Error(`Tool call name changed for ${event.id}: ${tool.name} -> ${event.name}`))
+        if (tool.called) return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`))
        tool.called = true
        tool.providerExecuted = event.providerExecuted === true
        tool.providerMetadata = event.providerMetadata
        yield* events.publish(SessionEvent.Tool.Called, {
          sessionID: input.sessionID,
-          timestamp: yield* timestamp,
          assistantMessageID: tool.assistantMessageID,
          callID: event.id,
          tool: event.name,
@ -336,12 +323,12 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      }
      case "tool-result": {
        const tool = tools.get(event.id)
-        if (!tool?.called) return yield* Effect.die(`Tool result before call: ${event.id}`)
+        if (!tool?.called) return yield* Effect.die(new Error(`Tool result before call: ${event.id}`))
        if (tool.name !== event.name)
-          return yield* Effect.die(`Tool result name changed for ${event.id}: ${tool.name} -> ${event.name}`)
+          return yield* Effect.die(new Error(`Tool result name changed for ${event.id}: ${tool.name} -> ${event.name}`))
        if (tool.settled) {
          if (event.result.type === "error") return
-          return yield* Effect.die(`Duplicate tool result: ${event.id}`)
+          return yield* Effect.die(new Error(`Duplicate tool result: ${event.id}`))
        }
        tool.settled = true
        const result = settledOutput(event.output, event.result)
@ -352,7 +339,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        if ("error" in result) {
          yield* events.publish(SessionEvent.Tool.Failed, {
            sessionID: input.sessionID,
-            timestamp: yield* timestamp,
            assistantMessageID: tool.assistantMessageID,
            callID: event.id,
            error: result.error,
@ -363,7 +349,6 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
        }
        yield* events.publish(SessionEvent.Tool.Success, {
          sessionID: input.sessionID,
-          timestamp: yield* timestamp,
          assistantMessageID: tool.assistantMessageID,
          callID: event.id,
          ...result,
@ -375,14 +360,13 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      }
      case "tool-error": {
        const tool = tools.get(event.id)
-        if (!tool?.called) return yield* Effect.die(`Tool error before call: ${event.id}`)
+        if (!tool?.called) return yield* Effect.die(new Error(`Tool error before call: ${event.id}`))
        if (tool.name !== event.name)
-          return yield* Effect.die(`Tool error name changed for ${event.id}: ${tool.name} -> ${event.name}`)
-        if (tool.settled) return yield* Effect.die(`Duplicate tool error: ${event.id}`)
+          return yield* Effect.die(new Error(`Tool error name changed for ${event.id}: ${tool.name} -> ${event.name}`))
+        if (tool.settled) return yield* Effect.die(new Error(`Duplicate tool error: ${event.id}`))
        tool.settled = true
        yield* events.publish(SessionEvent.Tool.Failed, {
          sessionID: input.sessionID,
-          timestamp: yield* timestamp,
          assistantMessageID: tool.assistantMessageID,
          callID: event.id,
          error: { type: "unknown", message: event.message },
@ -396,7 +380,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
      case "step-finish":
        yield* flush()
        assistantActive = false
-        if (stepSettlement) return yield* Effect.die("Duplicate step finish")
+        if (stepSettlement) return yield* Effect.die(new Error("Duplicate step finish"))
        stepSettlement = { finish: event.reason, tokens: tokens(event.usage) }
        return
      case "finish":
--- a/packages/core/src/session/runner/to-llm-message.ts
+++ b/packages/core/src/session/runner/to-llm-message.ts
@ -7,6 +7,7 @@ import {
  type Model,
  type ProviderMetadata,
 } from "@opencode-ai/llm"
+import { Option, Schema } from "effect"
 import { SessionMessage } from "../message"
 import type { FileAttachment } from "../prompt"

@ -18,14 +19,12 @@ const media = (file: FileAttachment): ContentPart => ({
  metadata: file.description === undefined ? undefined : { description: file.description },
 })

-const toolInput = (tool: SessionMessage.AssistantTool) => {
-  if (tool.state.status !== "pending") return tool.state.input
-  try {
-    return JSON.parse(tool.state.input) as unknown
-  } catch {
-    return tool.state.input
-  }
-}
+const decodeToolInput = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+
+const toolInput = (tool: SessionMessage.AssistantTool) =>
+  tool.state.status === "pending"
+    ? Option.getOrElse(decodeToolInput(tool.state.input), () => tool.state.input)
+    : tool.state.input

 const toolCall = (tool: SessionMessage.AssistantTool, providerMetadata: ProviderMetadata | undefined): ContentPart =>
  ToolCallPart.make({
--- a/packages/core/src/session/sql.ts
+++ b/packages/core/src/session/sql.ts
@ -1,5 +1,5 @@
 import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core"
-import * as DatabasePath from "../database/path"
+import { directoryColumn, pathColumn } from "../database/path"
 import { ProjectTable } from "../project/sql"
 import type { SessionMessage } from "./message"
 import type { Prompt } from "./prompt"
@ -31,8 +31,8 @@ export const SessionTable = sqliteTable(
    workspace_id: text().$type<WorkspaceV2.ID>(),
    parent_id: text().$type<SessionSchema.ID>(),
    slug: text().notNull(),
-    directory: DatabasePath.directoryColumn().notNull(),
-    path: DatabasePath.pathColumn(),
+    directory: directoryColumn().notNull(),
+    path: pathColumn(),
    title: text().notNull(),
    version: text().notNull(),
    share_url: text(),
--- a/packages/core/src/session/title.ts
+++ b/packages/core/src/session/title.ts
@ -42,9 +42,10 @@ const make = (dependencies: Dependencies) => {
    if (!firstUser) return
    const agent = yield* dependencies.agents.get(AgentV2.ID.make("title"))
    if (!agent) return
-    const resolved = yield* (agent.model
-      ? dependencies.models.resolve({ ...session, model: agent.model })
-      : dependencies.models.resolve(session)
+    const resolved = yield* (
+      agent.model
+        ? dependencies.models.resolve({ ...session, model: agent.model })
+        : dependencies.models.resolve(session)
    ).pipe(Effect.catch(() => Effect.succeed(undefined)))
    if (!resolved) return
    const chunks: string[] = []
@ -76,7 +77,6 @@ const make = (dependencies: Dependencies) => {
    if (!title) return
    yield* dependencies.events.publish(SessionEvent.Renamed, {
      sessionID: session.id,
-      timestamp: yield* DateTime.now,
      title: truncate(title),
    })
  })
--- a/packages/core/src/shell/select.ts
+++ b/packages/core/src/shell/select.ts
@ -4,7 +4,7 @@ import path from "path"
 import { spawn, type ChildProcess } from "child_process"
 import { readFile } from "fs/promises"
 import { statSync } from "fs"
-import { setTimeout as sleep } from "node:timers/promises"
+import { setTimeout } from "node:timers/promises"
 import { Flag } from "../flag/flag"
 import { FSUtil } from "../fs-util"
 import { which } from "../util/which"
@ -46,13 +46,13 @@ export async function killTree(proc: ChildProcess, opts?: { exited?: () => boole

  try {
    process.kill(-pid, "SIGTERM")
-    await sleep(SIGKILL_TIMEOUT_MS)
+    await setTimeout(SIGKILL_TIMEOUT_MS)
    if (!opts?.exited?.()) {
      process.kill(-pid, "SIGKILL")
    }
  } catch {
    proc.kill("SIGTERM")
-    await sleep(SIGKILL_TIMEOUT_MS)
+    await setTimeout(SIGKILL_TIMEOUT_MS)
    if (!opts?.exited?.()) {
      proc.kill("SIGKILL")
    }
--- a/packages/core/src/system-context/index.ts
+++ b/packages/core/src/system-context/index.ts
@ -12,7 +12,7 @@ import { Effect, Option, Schema } from "effect"
 * The durable `Applied` record tracks what the model was last told, per source:
 * it is the model's current belief. Interpreters uphold one invariant —
 * `reconcile` never rewrites the baseline; it only narrates drift as update
- * text. Only `rebaseline` (compaction) and `initialize` (first turn) produce
+ * text. Only `rebaseline` (compaction) and `initialize` (first step) produce
 * baseline text.
 *
 * Returning `unavailable` means observation failed temporarily. It differs from
--- a/packages/core/src/tool/read.ts
+++ b/packages/core/src/tool/read.ts
@ -97,8 +97,8 @@ export const Plugin = {
              // skipped, and discovery failures never fail the read.
              yield* Effect.gen(function* () {
                if (target.externalDirectory !== undefined) return
-                const resolved = FSUtil.resolve(target.canonical)
-                const root = FSUtil.resolve(location.directory)
+                const resolved = yield* fs.resolve(target.canonical)
+                const root = yield* fs.resolve(location.directory)
                // up() searches its stop directory, so the Location-root AGENTS.md (already
                // supplied by the core/instructions baseline) is dropped by the dirname filter.
                const discovered = yield* fs.up({
@ -106,7 +106,7 @@ export const Plugin = {
                  start: type === "directory" ? resolved : dirname(resolved),
                  stop: root,
                })
-                const candidates = discovered.map(FSUtil.resolve).filter((file) => dirname(file) !== root)
+                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root)
                if (candidates.length === 0) return
                yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates })
              }).pipe(
--- a/packages/core/src/tool/shell.ts
+++ b/packages/core/src/tool/shell.ts
@ -80,17 +80,21 @@ const modelOutput = (output: Output): string | undefined => {

 const shellTokens = (command: string) => command.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? []
 const unquote = (value: string) => value.replace(/^(['"])(.*)\1$/, "$2")
-const externalCommandDirectories = (command: string, cwd: string) => {
+const externalCommandDirectories = Effect.fn("ShellTool.externalCommandDirectories")(function* (
+  fs: FSUtil.Interface,
+  command: string,
+  cwd: string,
+) {
  const directories = new Set<string>()
  for (const token of shellTokens(command)) {
    const value = unquote(token).replace(/[;,|&]+$/, "")
    if (!path.isAbsolute(value)) continue
-    const resolved = FSUtil.resolve(value)
+    const resolved = yield* fs.resolve(value)
    if (FSUtil.contains(cwd, resolved)) continue
-    directories.add(FSUtil.resolve(path.dirname(resolved)))
+    directories.add(yield* fs.resolve(path.dirname(resolved)))
  }
  return [...directories]
-}
+})

 export const Plugin = {
  id: "core-shell-tool",
@ -168,7 +172,7 @@ export const Plugin = {
                  agent: context.agent,
                  source,
                })
-              const warnings = externalCommandDirectories(input.command, target.canonical).map(
+              const warnings = (yield* externalCommandDirectories(fsUtil, input.command, target.canonical)).map(
                (directory) =>
                  `Command argument references external directory ${path.join(directory, "*").replaceAll("\\", "/")}. Shell runs with host-user filesystem, process, and network authority; this scan is advisory only.`,
              )