perf: comprehensive optimization across all layers

Batch 1-4 (core/llm/opencode/tui):
- Eliminate O(n²) projector rebuild with incremental updates
- Add HTTP request timeouts and transport retry logic
- Implement streaming compression to avoid blocking event loop
- Optimize TUI markdown rendering with incremental updates

Batch 5 (protocol/server):
- Add bounded queue for PTY WebSocket to prevent memory growth
- Harden CORS origin validation and use timing-safe auth comparison

Batch 6 (effect-drizzle-sqlite):
- Default to immediate transactions to prevent cross-process conflicts
- Add statement caching in node driver (LRU 1000)
- Consolidate PRAGMA settings to database.ts

Batch 7 (infrastructure):
- Fix CI trigger branches to include dev
- Support OPENCODE_VERSION env var for release builds
- Use INSERT OR IGNORE for idempotent migrations
- Add workspace.project_id index for query performance

All changes maintain backward compatibility and pass typecheck.

Author: edy

.github/workflows/ci.yml

@@ -2,9 +2,9 @@ name: ci
 
 on:
   push:
-    branches: [main]
+    branches: [dev, main]
   pull_request:
-    branches: [main]
+    branches: [dev, main]
 
 jobs:
   typecheck:

packages/core/src/control-plane/workspace.sql.ts

@@ -1,20 +1,24 @@
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core"
 import { ProjectTable } from "../project/sql"
 import { ProjectV2 } from "../project"
 import { WorkspaceV2 } from "../workspace"
 
-export const WorkspaceTable = sqliteTable("workspace", {
-  id: text().$type<WorkspaceV2.ID>().primaryKey(),
-  type: text().notNull(),
-  name: text().notNull().default(""),
-  branch: text(),
-  directory: text(),
-  extra: text({ mode: "json" }),
-  project_id: text()
-    .$type<ProjectV2.ID>()
-    .notNull()
-    .references(() => ProjectTable.id, { onDelete: "cascade" }),
-  time_used: integer()
-    .notNull()
-    .$default(() => Date.now()),
-})
+export const WorkspaceTable = sqliteTable(
+  "workspace",
+  {
+    id: text().$type<WorkspaceV2.ID>().primaryKey(),
+    type: text().notNull(),
+    name: text().notNull().default(""),
+    branch: text(),
+    directory: text(),
+    extra: text({ mode: "json" }),
+    project_id: text()
+      .$type<ProjectV2.ID>()
+      .notNull()
+      .references(() => ProjectTable.id, { onDelete: "cascade" }),
+    time_used: integer()
+      .notNull()
+      .$default(() => Date.now()),
+  },
+  (table) => [index("workspace_project_idx").on(table.project_id)],
+)

packages/core/src/database/migration.ts

@@ -31,7 +31,7 @@ export function apply(db: Database) {
           )
           yield* Effect.forEach(migrations, (migration) =>
             tx.run(
-              sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
+              sql`INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
             ),
           )
         }),
@@ -72,7 +72,7 @@ export function applyOnly(db: Database, input: Migration[]) {
         Effect.gen(function* () {
           yield* migration.up(tx)
           yield* tx.run(
-            sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
+            sql`INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`,
           )
         }),
       )

packages/core/src/database/sqlite.bun.ts

@@ -161,7 +161,6 @@ const nativeLayer = (config: Config) =>
         create: config.create ?? true,
       })
       yield* Effect.addFinalizer(() => Effect.sync(() => native.close()))
-      if (config.disableWAL !== true) native.run("PRAGMA journal_mode = WAL;")
       return native
     }),
   )

packages/core/src/database/sqlite.node.ts

@@ -53,9 +53,25 @@ const make = (options: Config) =>
       ? Statement.defaultTransforms(options.transformResultNames).array
       : undefined
 
+    const statementCache = new Map<string, ReturnType<typeof native.prepare>>()
+    const MAX_CACHED_STATEMENTS = 1000
+
+    const getStatement = (query: string) => {
+      let stmt = statementCache.get(query)
+      if (!stmt) {
+        if (statementCache.size >= MAX_CACHED_STATEMENTS) {
+          const firstKey = statementCache.keys().next().value
+          if (firstKey !== undefined) statementCache.delete(firstKey)
+        }
+        stmt = native.prepare(query)
+        statementCache.set(query, stmt)
+      }
+      return stmt
+    }
+
     const run = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-        const statement = native.prepare(query)
+        const statement = getStatement(query)
         statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
         try {
           return Effect.succeed(statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>)
@@ -70,7 +86,7 @@ const make = (options: Config) =>
 
     const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>((fiber) => {
-        const statement = native.prepare(query)
+        const statement = getStatement(query)
         statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
         statement.setReturnArrays(true)
         try {
@@ -156,7 +172,6 @@ const nativeLayer = (config: Config) =>
         open: true,
       })
       yield* Effect.addFinalizer(() => Effect.sync(() => native.close()))
-      if (config.disableWAL !== true && config.readonly !== true) native.exec("PRAGMA journal_mode = WAL;")
       return native
     }),
   )

packages/core/src/session/input.ts

@@ -2,6 +2,7 @@ export * as SessionInput from "./input"
 
 import { and, asc, eq, isNull, lte } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
+import { isDeepStrictEqual } from "node:util"
 import { Admitted, Delivery } from "@opencode-ai/schema/session-input"
 import type { Database } from "../database/database"
 import type { EventV2 } from "../event"
@@ -198,8 +199,7 @@ export const equivalent = (
 ) => input.delivery === expected.delivery && matchesPrompt(input, expected)
 
 const matchesPrompt = (input: Admitted, expected: { readonly sessionID: SessionSchema.ID; readonly prompt: Prompt }) =>
-  input.sessionID === expected.sessionID &&
-  JSON.stringify(encodePrompt(input.prompt)) === JSON.stringify(encodePrompt(expected.prompt))
+  input.sessionID === expected.sessionID && isDeepStrictEqual(encodePrompt(input.prompt), encodePrompt(expected.prompt))
 
 const matchesProjection = (
   input: Admitted,

packages/core/src/session/runner/llm.ts

@@ -229,6 +229,7 @@ const layer = Layer.effect(
       const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = []) =>
         withPublication(publisher.publish(event, outputPaths))
       let overflowFailure: ProviderErrorEvent | undefined
+      let didExecuteHostTool = false
       const providerStream = llm.stream(request).pipe(
         Stream.runForEach((event) =>
           Effect.gen(function* () {
@@ -241,6 +242,7 @@ const layer = Layer.effect(
             }
             yield* publish(event)
             if (event.type !== "tool-call" || event.providerExecuted) return
+            didExecuteHostTool = true
             if (!toolMaterialization) {
               yield* withPublication(publisher.failUnsettledTools("Tools are disabled after the maximum agent steps"))
               return
@@ -315,7 +317,7 @@ const layer = Layer.effect(
           }
           const stepSettlement = publisher.stepSettlement()
           if (stepSettlement && !publisher.hasProviderError()) {
-            const endSnapshot = yield* snapshots.capture()
+            const endSnapshot = didExecuteHostTool ? yield* snapshots.capture() : undefined
             const files =
               startSnapshot && endSnapshot
                 ? yield* snapshots

packages/effect-drizzle-sqlite/src/effect-sqlite/session.ts

@@ -142,7 +142,7 @@ export class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLite
           Effect.flatMap(([scope, connection]) => {
             const transaction = this.executeTransactionStatement(
               connection,
-              id === 0 ? `begin ${config?.behavior ?? "deferred"}` : `savepoint effect_sql_${id}`,
+              id === 0 ? `begin ${config?.behavior ?? "immediate"}` : `savepoint effect_sql_${id}`,
             ).pipe(
               Effect.flatMap(() =>
                 Effect.provideContext(

packages/llm/src/protocols/openai-responses.ts

@@ -681,7 +681,7 @@ const onOutputItemAdded = (state: ParserState, event: OpenAIResponsesEvent): Ste
       tools: ToolStream.start(state.tools, item.id, {
         id: item.call_id ?? item.id,
         name: item.name ?? "",
-        input: item.arguments ?? "",
+        chunks: item.arguments ? [item.arguments] : [],
         providerMetadata,
       }),
     },

packages/llm/src/protocols/shared.ts

@@ -32,7 +32,7 @@ export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.op
 export interface ToolAccumulator {
   readonly id: string
   readonly name: string
-  readonly input: string
+  readonly chunks: ReadonlyArray<string>
 }
 
 /**
@@ -171,6 +171,11 @@ export interface ValidatedMedia {
   readonly bytes: Uint8Array
 }
 
+const VALIDATED_MEDIA_CACHE_LIMIT = 50
+const validatedMediaCache = new Map<string, ValidatedMedia>()
+
+const cacheKey = (mime: string, base64: string) => `${mime}\0${base64}`
+
 export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function* (
   route: string,
   part: MediaPart,
@@ -194,6 +199,10 @@ export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function*
     base64 = part.data
   }
 
+  const key = cacheKey(mime, base64)
+  const cached = validatedMediaCache.get(key)
+  if (cached) return cached
+
   if (Buffer.byteLength(base64, "utf8") > MAX_MEDIA_ENCODED_BYTES)
     return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_ENCODED_BYTES} byte encoded limit`)
   if (!base64 || base64.length % 4 !== 0 || !base64Pattern.test(base64))
@@ -202,7 +211,10 @@ export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function*
   if (bytes.byteLength > MAX_MEDIA_DECODED_BYTES)
     return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`)
   if (bytes.toString("base64") !== base64) return yield* invalidRequest(`${route} media must contain canonical base64`)
-  return { mime, base64, dataUrl: `data:${mime};base64,${base64}`, bytes } satisfies ValidatedMedia
+  const result: ValidatedMedia = { mime, base64, dataUrl: `data:${mime};base64,${base64}`, bytes }
+  if (validatedMediaCache.size >= VALIDATED_MEDIA_CACHE_LIMIT) validatedMediaCache.clear()
+  validatedMediaCache.set(key, result)
+  return result
 })
 
 export const validateToolFile = (route: string, part: ToolFileContent, supportedMimes: ReadonlySet<string>) =>