refactor(core): remove unused small model selection

packages/core/src/bus.ts

@@ -3,7 +3,7 @@ export * as Bus from "./bus"
 import { Cause, Context, DateTime, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Event } from "@opencode-ai/schema/event"
 import type { EventLog } from "@opencode-ai/schema/event-log"
-import { and, asc, eq, gt, inArray, lte, sql } from "drizzle-orm"
+import { and, asc, eq, gt, lte, sql } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
@@ -134,8 +134,6 @@ export interface Interface {
     readonly after?: number
     readonly follow?: boolean
   }) => Stream.Stream<LogItem>
-  /** Latest committed seq per aggregate. Aggregates without events are absent. */
-  readonly sequences: (aggregateIDs: ReadonlyArray<string>) => Effect.Effect<ReadonlyMap<string, Event.Seq>>
   /** @deprecated Use `subscribe()` and consume the returned stream. */
   readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>
   readonly project: <D extends Event.Definition>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>
@@ -657,19 +655,6 @@ export const layerWith = (options?: LayerOptions) =>
           }),
         )
 
-      const sequences = (aggregateIDs: ReadonlyArray<string>): Effect.Effect<ReadonlyMap<string, Event.Seq>> => {
-        if (aggregateIDs.length === 0) return Effect.succeed(new Map())
-        return db
-          .select({ aggregateID: EventSequenceTable.aggregate_id, seq: EventSequenceTable.seq })
-          .from(EventSequenceTable)
-          .where(inArray(EventSequenceTable.aggregate_id, Array.from(aggregateIDs)))
-          .all()
-          .pipe(
-            Effect.orDie,
-            Effect.map((rows) => new Map(rows.map((row) => [row.aggregateID, Event.Seq.make(row.seq)]))),
-          )
-      }
-
       const listen = (listener: Subscriber): Effect.Effect<Unsubscribe> =>
         Effect.sync(() => {
           listeners.push(listener)
@@ -691,7 +676,6 @@ export const layerWith = (options?: LayerOptions) =>
         publish,
         subscribe,
         log,
-        sequences,
         listen,
         project,
         replay,

packages/core/src/catalog.ts

@@ -52,7 +52,6 @@ export interface Interface extends State.Transformable<Draft> {
     readonly all: () => Effect.Effect<Model.Info[]>
     readonly available: () => Effect.Effect<Model.Info[]>
     readonly default: () => Effect.Effect<Model.Info | undefined>
-    readonly small: (providerID: Provider.ID) => Effect.Effect<Model.Info | undefined>
   }
 }
 
@@ -206,59 +205,6 @@ const layer = Layer.effect(
 
           return (yield* result.model.available())[0]
         }),
-
-        small: Effect.fn("Catalog.model.small")(function* (providerID) {
-          const record = state.get().providers.get(providerID)
-          if (!record) return
-          const provider = record.provider
-
-          // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
-          if (providerID === Provider.ID.azure || providerID === Provider.ID.make("azure-cognitive-services")) {
-            return
-          }
-
-          if (providerID === Provider.ID.opencode) {
-            const gpt5Nano = record.models.get(Model.ID.make("gpt-5-nano"))
-            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
-          }
-
-          const candidates = pipe(
-            Array.fromIterable(record.models.values()),
-            Array.filter(
-              (model) =>
-                model.providerID === providerID &&
-                model.enabled &&
-                model.status === "active" &&
-                model.capabilities.input.some((item) => item.startsWith("text")) &&
-                model.capabilities.output.some((item) => item.startsWith("text")),
-            ),
-            Array.map((model) => ({
-              model,
-              cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
-              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
-              small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
-            })),
-            Array.filter((item) => item.cost > 0 && item.age <= 18),
-          )
-
-          const pick = (items: typeof candidates) => {
-            if (!Array.isReadonlyArrayNonEmpty(items)) return
-            const maxCost = Math.max(...items.map((item) => item.cost), 0.01)
-            const maxAge = Math.max(...items.map((item) => item.age), 0.01)
-            const selected = Array.min(
-              items,
-              Order.mapInput(
-                Order.Number,
-                (item: (typeof candidates)[number]) =>
-                  (item.cost / maxCost) * 0.8 + (item.age / maxAge) * 0.2,
-              ),
-            )
-            return projectModel(selected.model, provider)
-          }
-
-          const small = candidates.filter((item) => item.small)
-          return pick(small.length > 0 ? small : candidates)
-        }),
       },
     }
 
@@ -266,6 +212,4 @@ const layer = Layer.effect(
   }),
 )
 
-const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
-
 export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node, Integration.node] })

packages/core/src/formatter.ts

@@ -1,6 +1,6 @@
 export * as Formatter from "./formatter"
 
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import path from "path"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -11,16 +11,7 @@ import { Config } from "./config"
 import { Location } from "./location"
 import { make, type Info } from "./formatter/builtins"
 
-export const Status = Schema.Struct({
-  name: Schema.String,
-  extensions: Schema.Array(Schema.String),
-  enabled: Schema.Boolean,
-}).annotate({ identifier: "FormatterStatus" })
-export type Status = typeof Status.Type
-
 export interface Interface {
-  readonly init: () => Effect.Effect<void>
-  readonly status: () => Effect.Effect<Status[]>
   readonly file: (filepath: string) => Effect.Effect<boolean>
 }
 
@@ -84,23 +75,6 @@ const layer = Layer.effect(
       return result
     })
 
-    const init = Effect.fn("Formatter.init")(function* () {
-      yield* load
-    })
-
-    const status = Effect.fn("Formatter.status")(function* () {
-      yield* load
-      return yield* Effect.forEach(formatters, (formatter) =>
-        command(formatter).pipe(
-          Effect.map((enabled) => ({
-            name: formatter.name,
-            extensions: [...formatter.extensions],
-            enabled: enabled !== false,
-          })),
-        ),
-      )
-    })
-
     const file = Effect.fn("Formatter.file")(function* (filepath: string) {
       yield* load
       const matching = formatters.filter((formatter) =>
@@ -143,7 +117,7 @@ const layer = Layer.effect(
       return false
     })
 
-    return Service.of({ init, status, file })
+    return Service.of({ file })
   }),
 )
 

packages/core/src/git.ts

@@ -1,7 +1,7 @@
 export * as Git from "./git"
 
 import path from "path"
-import { Context, Effect, Layer, Schema, Stream } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { AbsolutePath, RelativePath } from "./schema"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -35,9 +35,6 @@ const snapshotConfig = `[core]
 	threads = true
 `
 
-export const ChangeSet = Schema.String.pipe(Schema.brand("Git.ChangeSet"))
-export type ChangeSet = typeof ChangeSet.Type
-
 export const TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"))
 export type TreeID = typeof TreeID.Type
 
@@ -72,13 +69,6 @@ export class WorktreeError extends Schema.TaggedErrorClass<WorktreeError>()("Git
   cause: Schema.optional(Schema.Defect()),
 }) {}
 
-export class PatchError extends Schema.TaggedErrorClass<PatchError>()("Git.PatchError", {
-  operation: Schema.Literals(["capture", "apply", "reset"]),
-  directory: AbsolutePath,
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
 export interface Interface {
   readonly repo: {
     readonly discover: (input: AbsolutePath) => Effect.Effect<Repository | undefined>
@@ -115,20 +105,6 @@ export interface Interface {
     ) => Effect.Effect<void, OperationError>
     readonly resetHard: (repository: Repository, revision: string) => Effect.Effect<void, OperationError>
   }
-  readonly change: {
-    readonly capture: (input: { repository: Repository; path: AbsolutePath }) => Effect.Effect<ChangeSet, PatchError>
-    readonly apply: (input: {
-      repository: Repository
-      path: AbsolutePath
-      changes: ChangeSet
-    }) => Effect.Effect<void, PatchError>
-    readonly discard: (input: {
-      repository: Repository
-      path: AbsolutePath
-      index: "preserve" | "reset"
-      untracked: "preserve" | "remove"
-    }) => Effect.Effect<void, PatchError>
-  }
   readonly worktree: {
     readonly create: (input: {
       repository: Repository
@@ -678,132 +654,6 @@ const layer = Layer.effect(
         ),
     )
 
-    const capture = Effect.fn("Git.change.capture")(function* (input: { repository: Repository; path: AbsolutePath }) {
-      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
-      const tracked = yield* execute(
-        input.repository.worktree,
-        proc,
-      )(["diff", "--binary", "HEAD", "--", scope]).pipe(
-        Effect.mapError(
-          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
-        ),
-      )
-      if (tracked.exitCode !== 0) {
-        return yield* new PatchError({
-          operation: "capture",
-          directory: input.path,
-          message: tracked.stderr.trim() || tracked.text.trim() || "Failed to capture tracked changes",
-        })
-      }
-
-      const untracked = yield* execute(
-        input.repository.worktree,
-        proc,
-      )(["ls-files", "--others", "--exclude-standard", "-z", "--", scope]).pipe(
-        Effect.mapError(
-          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
-        ),
-      )
-      if (untracked.exitCode !== 0) {
-        return yield* new PatchError({
-          operation: "capture",
-          directory: input.path,
-          message: untracked.stderr.trim() || untracked.text.trim() || "Failed to list untracked changes",
-        })
-      }
-
-      const created = yield* Effect.forEach(untracked.text.split("\0").filter(Boolean), (file) =>
-        execute(
-          input.repository.worktree,
-          proc,
-        )(["diff", "--binary", "--no-index", "--", "/dev/null", file]).pipe(
-          Effect.mapError(
-            (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
-          ),
-          Effect.flatMap((result) =>
-            // git diff --no-index returns 1 when differences were found.
-            result.exitCode === 0 || result.exitCode === 1
-              ? Effect.succeed(result.text)
-              : Effect.fail(
-                  new PatchError({
-                    operation: "capture",
-                    directory: input.path,
-                    message:
-                      result.stderr.trim() || result.text.trim() || `Failed to capture untracked change: ${file}`,
-                  }),
-                ),
-          ),
-        ),
-      )
-      return ChangeSet.make([tracked.text, ...created].filter(Boolean).join("\n"))
-    })
-
-    const apply = Effect.fn("Git.change.apply")(function* (input: {
-      repository: Repository
-      path: AbsolutePath
-      changes: ChangeSet
-    }) {
-      const result = yield* proc
-        .run(
-          ChildProcess.make("git", ["apply", "-"], {
-            cwd: input.path,
-            extendEnv: true,
-            stdin: Stream.make(new TextEncoder().encode(input.changes)),
-          }),
-        )
-        .pipe(
-          Effect.mapError(
-            (cause) => new PatchError({ operation: "apply", directory: input.path, message: cause.message, cause }),
-          ),
-        )
-      if (result.exitCode === 0) return
-      return yield* new PatchError({
-        operation: "apply",
-        directory: input.path,
-        message:
-          result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Failed to apply changes",
-      })
-    })
-
-    const discard = Effect.fn("Git.change.discard")(function* (input: {
-      repository: Repository
-      path: AbsolutePath
-      index: "preserve" | "reset"
-      untracked: "preserve" | "remove"
-    }) {
-      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
-      const restore = yield* execute(
-        input.repository.worktree,
-        proc,
-      )(input.index === "reset" ? ["checkout", "HEAD", "--", scope] : ["checkout", "--", scope]).pipe(
-        Effect.mapError(
-          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
-        ),
-      )
-      if (restore.exitCode !== 0) {
-        return yield* new PatchError({
-          operation: "reset",
-          directory: input.path,
-          message: restore.stderr.trim() || restore.text.trim() || "Failed to restore tracked changes",
-        })
-      }
-      if (input.untracked === "preserve") return
-      const clean = yield* execute(
-        input.repository.worktree,
-        proc,
-      )(["clean", "-fd", "--", scope]).pipe(
-        Effect.mapError(
-          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
-        ),
-      )
-      if (clean.exitCode === 0) return
-      return yield* new PatchError({
-        operation: "reset",
-        directory: input.path,
-        message: clean.stderr.trim() || clean.text.trim() || "Failed to clean untracked changes",
-      })
-    })
-
     const worktreeRun = Effect.fnUntraced(function* (
       operation: "create" | "remove" | "list",
       repository: Repository,
@@ -879,7 +729,6 @@ const layer = Layer.effect(
       remote: { get: remote },
       history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
       sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
-      change: { capture, apply, discard },
       worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
       index: { refresh, ignored },
       tree: {

packages/core/src/shell/select.ts

@@ -1,15 +1,12 @@
 export * as ShellSelect from "./select"
 
 import path from "path"
-import { spawn, type ChildProcess } from "child_process"
 import { readFile } from "fs/promises"
 import { statSync } from "fs"
-import { setTimeout } from "node:timers/promises"
 import { Schema } from "effect"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { which } from "../util/which"
 
-const SIGKILL_TIMEOUT_MS = 200
 const META: Record<string, { deny?: boolean; login?: boolean; posix?: boolean; ps?: boolean }> = {
   bash: { login: true, posix: true },
   dash: { login: true, posix: true },
@@ -33,37 +30,6 @@ export const Options = Schema.Struct({
 })
 export type Options = typeof Options.Type
 
-export async function killTree(proc: ChildProcess, opts?: { exited?: () => boolean }): Promise<void> {
-  const pid = proc.pid
-  if (!pid || opts?.exited?.()) return
-
-  if (process.platform === "win32") {
-    await new Promise<void>((resolve) => {
-      const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
-        stdio: "ignore",
-        windowsHide: true,
-      })
-      killer.once("exit", () => resolve())
-      killer.once("error", () => resolve())
-    })
-    return
-  }
-
-  try {
-    process.kill(-pid, "SIGTERM")
-    await setTimeout(SIGKILL_TIMEOUT_MS)
-    if (!opts?.exited?.()) {
-      process.kill(-pid, "SIGKILL")
-    }
-  } catch {
-    proc.kill("SIGTERM")
-    await setTimeout(SIGKILL_TIMEOUT_MS)
-    if (!opts?.exited?.()) {
-      proc.kill("SIGKILL")
-    }
-  }
-}
-
 function stat(file: string) {
   return statSync(file, { throwIfNoEntry: false }) ?? undefined
 }

packages/core/test/bus.test.ts

@@ -1298,24 +1298,4 @@ describe("Bus", () => {
     }),
   )
 
-  it.effect("sequences returns the latest committed seq per aggregate and omits unknown aggregates", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const first = Session.ID.create()
-      const second = Session.ID.create()
-      yield* bus.publish(DurableMessage, durableData(first, "zero"))
-      yield* bus.publish(DurableMessage, durableData(first, "one"))
-      yield* bus.publish(DurableMessage, durableData(second, "zero"))
-
-      const sequences = yield* bus.sequences([first, second, Session.ID.create()])
-
-      expect(sequences).toEqual(
-        new Map([
-          [first, Event.Seq.make(1)],
-          [second, Event.Seq.make(0)],
-        ]),
-      )
-      expect(yield* bus.sequences([])).toEqual(new Map())
-    }),
-  )
 })

packages/core/test/catalog.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Fiber, Layer, Stream } from "effect"
 import { TestClock } from "effect/testing"
 import { Catalog } from "@opencode-ai/core/catalog"
@@ -292,46 +291,4 @@ describe("Catalog", () => {
       })
     }),
   )
-
-  it.effect("small model prefers small keyword candidates before cost scoring", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.make("test")
-      yield* catalog.transform((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("cheap-large"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(1),
-              output: Money.USDPerMillionTokens.make(1),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
-          model.time.released = Date.now()
-        })
-        catalog.model.update(providerID, Model.ID.make("expensive-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(10),
-              output: Money.USDPerMillionTokens.make(10),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
-          model.time.released = Date.now()
-        })
-      })
-
-      expect((yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
-    }),
-  )
 })

packages/core/test/formatter.test.ts

@@ -56,52 +56,22 @@ function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>)
 }
 
 describe("Formatter", () => {
-  it.live("status() returns empty list when no formatters are configured", () =>
+  it.live("does not run formatters marked as disabled in config", () =>
     withTemp((directory) =>
-      Formatter.Service.use((formatter) => formatter.status()).pipe(Effect.provide(formatterLayer(directory))),
-    ),
-  )
-
-  it.live("status() returns built-in formatters when formatter is true", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          const gofmt = statuses.find((item) => item.name === "gofmt")
-          expect(gofmt).toBeDefined()
-          expect(gofmt?.extensions).toContain(".go")
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, true))),
-    ),
-  )
-
-  it.live("status() keeps built-in formatters when config object is provided", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          expect(statuses.find((item) => item.name === "gofmt")?.extensions).toContain(".go")
-          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: {} }))),
-    ),
-  )
-
-  it.live("status() excludes formatters marked as disabled in config", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          expect(statuses.find((item) => item.name === "gofmt")).toBeUndefined()
-          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: { disabled: true } }))),
-    ),
-  )
-
-  it.live("service initializes without error", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) => formatter.init()).pipe(Effect.provide(formatterLayer(directory))),
+      Effect.gen(function* () {
+        const file = path.join(directory, "test.disabled")
+        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(false)
+      }).pipe(
+        Effect.provide(
+          formatterLayer(directory, {
+            disabled: {
+              disabled: true,
+              command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
+              extensions: [".disabled"],
+            },
+          }),
+        ),
+      ),
     ),
   )
 
@@ -115,22 +85,29 @@ describe("Formatter", () => {
     ),
   )
 
-  it.live("status() initializes formatter state per directory", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      ([off, on]) =>
+  it.live("loads formatter state per directory", () =>
+    withTemp((off) =>
+      withTemp((on) =>
         Effect.gen(function* () {
-          const disabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
-            Effect.provide(formatterLayer(off.path, false)),
+          const offFile = path.join(off, "test.isolated")
+          const onFile = path.join(on, "test.isolated")
+          const disabled = yield* Formatter.Service.use((formatter) => formatter.file(offFile)).pipe(
+            Effect.provide(formatterLayer(off, false)),
           )
-          const enabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
-            Effect.provide(formatterLayer(on.path, true)),
+          const enabled = yield* Formatter.Service.use((formatter) => formatter.file(onFile)).pipe(
+            Effect.provide(
+              formatterLayer(on, {
+                isolated: {
+                  command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
+                  extensions: [".isolated"],
+                },
+              }),
+            ),
           )
-          expect(disabled).toEqual([])
-          expect(enabled.find((item) => item.name === "gofmt")).toBeDefined()
+          expect(disabled).toBe(false)
+          expect(enabled).toBe(true)
         }),
-      (directories) =>
-        Effect.promise(() => Promise.all(directories.map((tmp) => tmp[Symbol.asyncDispose]())).then(() => undefined)),
+      ),
     ),
   )
 

packages/core/test/generate.test.ts

@@ -30,7 +30,6 @@ const catalog = Layer.mock(Catalog.Service, {
     all: () => Effect.die("unused"),
     available: () => Effect.die("unused"),
     default: () => Effect.die("unused"),
-    small: () => Effect.die("unused"),
   },
 })
 const integrations = Layer.mock(Integration.Service, {

packages/core/test/plugin/provider-opencode.test.ts

@@ -484,31 +484,4 @@ describe("OpencodePlugin", () => {
       }),
     ),
   )
-
-  it.effect("prefers gpt-5-nano as the opencode small model", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.opencode
-
-      yield* catalog.transform((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("cheap-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(1, 1)]
-          model.time.released = Date.now()
-        })
-        catalog.model.update(providerID, Model.ID.make("gpt-5-nano"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(10, 10)]
-          model.time.released = Date.now()
-        })
-      })
-
-      const selected = yield* catalog.model.small(providerID)
-
-      expect(selected?.id).toBe(Model.ID.make("gpt-5-nano"))
-    }),
-  )
 })

packages/core/test/session-log.test.ts

@@ -41,17 +41,15 @@ describe("Session.log", () => {
   it.effect("replays public session events and marks synced at the aggregate watermark", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
-      const bus = yield* Bus.Service
       const created = yield* session.create({ location })
       yield* session.rename({ sessionID: created.id, title: "session.renamed" })
 
       const items = Array.from(yield* Stream.runCollect(session.log({ sessionID: created.id })))
-      const watermark = (yield* bus.sequences([created.id])).get(created.id)
 
       // Session creation commits a non-public durable event, so the marker's
       // seq covers more of the aggregate than the public events emitted.
       expect(items.map((item) => item.type)).toEqual(["session.renamed", "log.synced"])
-      expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID: created.id, seq: watermark })
+      expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID: created.id, seq: Event.Seq.make(1) })
     }),
   )
 

packages/core/test/session-runner-recorded.test.ts

@@ -102,7 +102,6 @@ const promptCatalog = Layer.mock(Catalog.Service, {
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
     default: () => Effect.succeed(undefined),
-    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>

packages/core/test/session-runner.test.ts

@@ -362,7 +362,6 @@ const promptCatalog = Layer.mock(Catalog.Service, {
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
     default: () => Effect.succeed(undefined),
-    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [

packages/server/src/auth.ts

@@ -2,10 +2,6 @@ export * as ServerAuth from "./auth"
 
 import { Context, Layer, Option, Redacted } from "effect"
 
-export type Credentials = {
-  password?: string
-}
-
 export type DecodedCredentials = {
   readonly username: string
   readonly password: Redacted.Redacted
@@ -37,16 +33,3 @@ export function authorized(credentials: DecodedCredentials, config: Info) {
     Redacted.value(credentials.password) === config.password.value
   )
 }
-
-export function header(credentials?: Credentials) {
-  const password = credentials?.password
-  if (!password) return undefined
-
-  return `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
-}
-
-export function headers(credentials?: Credentials) {
-  const authorization = header(credentials)
-  if (!authorization) return undefined
-  return { Authorization: authorization }
-}

packages/server/test/auth.test.ts

@@ -7,7 +7,3 @@ test("accepts only the fixed opencode username", () => {
   expect(ServerAuth.authorized({ username: "opencode", password: Redacted.make("secret") }, config)).toBe(true)
   expect(ServerAuth.authorized({ username: "custom", password: Redacted.make("secret") }, config)).toBe(false)
 })
-
-test("encodes the fixed opencode username", () => {
-  expect(ServerAuth.header({ password: "secret" })).toBe(`Basic ${Buffer.from("opencode:secret").toString("base64")}`)
-})