chore remove snapshot install smoke test

fix npm cli binary installation
chore: generate
2026-08-10 03:19:59 -04:00 · 2026-05-15 18:37:19 -04:00 · 2026-05-15 18:33:39 -04:00 · 2026-05-15 22:09:43 +00:00 · 2026-05-16 00:07:59 +02:00 · 2026-05-15 23:04:20 +02:00
166 changed files with 6619 additions and 3211 deletions
@@ -0,0 +1,50 @@
+name: close-prs
+
+on:
+  schedule:
+    - cron: "0 22 * * *" # Daily at 10:00 PM UTC
+  workflow_dispatch:
+    inputs:
+      dry-run:
+        description: "Log matching PRs without closing them"
+        type: boolean
+        default: true
+      max-close:
+        description: "Maximum matching PRs to close"
+        type: string
+        required: false
+        default: "50"
+
+jobs:
+  close:
+    runs-on: ubuntu-latest
+    timeout-minutes: 240
+    permissions:
+      contents: read
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: latest
+
+      - name: Close old PRs without enough positive reactions
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          max_close="${{ inputs['max-close'] }}"
+          if [ -z "$max_close" ]; then
+            max_close="50"
+          fi
+
+          args=("--threshold" "2" "--age-months" "1" "--sleep-ms" "20000" "--max-close" "$max_close")
+
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+            args+=("--execute")
+          elif [ "${{ inputs['dry-run'] }}" = "false" ]; then
+            args+=("--execute")
+          fi
+
+          bun script/github/close-prs.ts "${args[@]}"
@@ -1,235 +0,0 @@
-name: close-stale-prs
-
-on:
-  workflow_dispatch:
-    inputs:
-      dryRun:
-        description: "Log actions without closing PRs"
-        type: boolean
-        default: false
-  schedule:
-    - cron: "0 6 * * *"
-
-permissions:
-  contents: read
-  issues: write
-  pull-requests: write
-
-jobs:
-  close-stale-prs:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - name: Close inactive PRs
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const DAYS_INACTIVE = 60
-            const MAX_RETRIES = 3
-
-            // Adaptive delay: fast for small batches, slower for large to respect
-            // GitHub's 80 content-generating requests/minute limit
-            const SMALL_BATCH_THRESHOLD = 10
-            const SMALL_BATCH_DELAY_MS = 1000  // 1s for daily operations (≤10 PRs)
-            const LARGE_BATCH_DELAY_MS = 2000  // 2s for backlog (>10 PRs) = ~30 ops/min, well under 80 limit
-
-            const startTime = Date.now()
-            const cutoff = new Date(Date.now() - DAYS_INACTIVE * 24 * 60 * 60 * 1000)
-            const { owner, repo } = context.repo
-            const dryRun = context.payload.inputs?.dryRun === "true"
-
-            core.info(`Dry run mode: ${dryRun}`)
-            core.info(`Cutoff date: ${cutoff.toISOString()}`)
-
-            function sleep(ms) {
-              return new Promise(resolve => setTimeout(resolve, ms))
-            }
-
-            async function withRetry(fn, description = 'API call') {
-              let lastError
-              for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-                try {
-                  const result = await fn()
-                  return result
-                } catch (error) {
-                  lastError = error
-                  const isRateLimited = error.status === 403 &&
-                    (error.message?.includes('rate limit') || error.message?.includes('secondary'))
-
-                  if (!isRateLimited) {
-                    throw error
-                  }
-
-                  // Parse retry-after header, default to 60 seconds
-                  const retryAfter = error.response?.headers?.['retry-after']
-                    ? parseInt(error.response.headers['retry-after'])
-                    : 60
-
-                  // Exponential backoff: retryAfter * 2^attempt
-                  const backoffMs = retryAfter * 1000 * Math.pow(2, attempt)
-
-                  core.warning(`${description}: Rate limited (attempt ${attempt + 1}/${MAX_RETRIES}). Waiting ${backoffMs / 1000}s before retry...`)
-
-                  await sleep(backoffMs)
-                }
-              }
-              core.error(`${description}: Max retries (${MAX_RETRIES}) exceeded`)
-              throw lastError
-            }
-
-            const query = `
-              query($owner: String!, $repo: String!, $cursor: String) {
-                repository(owner: $owner, name: $repo) {
-                  pullRequests(first: 100, states: OPEN, after: $cursor) {
-                    pageInfo {
-                      hasNextPage
-                      endCursor
-                    }
-                    nodes {
-                      number
-                      title
-                      author {
-                        login
-                      }
-                      createdAt
-                      commits(last: 1) {
-                        nodes {
-                          commit {
-                            committedDate
-                          }
-                        }
-                      }
-                      comments(last: 1) {
-                        nodes {
-                          createdAt
-                        }
-                      }
-                      reviews(last: 1) {
-                        nodes {
-                          createdAt
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            `
-
-            const allPrs = []
-            let cursor = null
-            let hasNextPage = true
-            let pageCount = 0
-
-            while (hasNextPage) {
-              pageCount++
-              core.info(`Fetching page ${pageCount} of open PRs...`)
-
-              const result = await withRetry(
-                () => github.graphql(query, { owner, repo, cursor }),
-                `GraphQL page ${pageCount}`
-              )
-
-              allPrs.push(...result.repository.pullRequests.nodes)
-              hasNextPage = result.repository.pullRequests.pageInfo.hasNextPage
-              cursor = result.repository.pullRequests.pageInfo.endCursor
-
-              core.info(`Page ${pageCount}: fetched ${result.repository.pullRequests.nodes.length} PRs (total: ${allPrs.length})`)
-
-              // Delay between pagination requests (use small batch delay for reads)
-              if (hasNextPage) {
-                await sleep(SMALL_BATCH_DELAY_MS)
-              }
-            }
-
-            core.info(`Found ${allPrs.length} open pull requests`)
-
-            const stalePrs = allPrs.filter((pr) => {
-              const dates = [
-                new Date(pr.createdAt),
-                pr.commits.nodes[0] ? new Date(pr.commits.nodes[0].commit.committedDate) : null,
-                pr.comments.nodes[0] ? new Date(pr.comments.nodes[0].createdAt) : null,
-                pr.reviews.nodes[0] ? new Date(pr.reviews.nodes[0].createdAt) : null,
-              ].filter((d) => d !== null)
-
-              const lastActivity = dates.sort((a, b) => b.getTime() - a.getTime())[0]
-
-              if (!lastActivity || lastActivity > cutoff) {
-                core.info(`PR #${pr.number} is fresh (last activity: ${lastActivity?.toISOString() || "unknown"})`)
-                return false
-              }
-
-              core.info(`PR #${pr.number} is STALE (last activity: ${lastActivity.toISOString()})`)
-              return true
-            })
-
-            if (!stalePrs.length) {
-              core.info("No stale pull requests found.")
-              return
-            }
-
-            core.info(`Found ${stalePrs.length} stale pull requests`)
-
-            // ============================================
-            // Close stale PRs
-            // ============================================
-            const requestDelayMs = stalePrs.length > SMALL_BATCH_THRESHOLD
-              ? LARGE_BATCH_DELAY_MS
-              : SMALL_BATCH_DELAY_MS
-
-            core.info(`Using ${requestDelayMs}ms delay between operations (${stalePrs.length > SMALL_BATCH_THRESHOLD ? 'large' : 'small'} batch mode)`)
-
-            let closedCount = 0
-            let skippedCount = 0
-
-            for (const pr of stalePrs) {
-              const issue_number = pr.number
-              const closeComment = `Closing this pull request because it has had no updates for more than ${DAYS_INACTIVE} days. If you plan to continue working on it, feel free to reopen or open a new PR.`
-
-              if (dryRun) {
-                core.info(`[dry-run] Would close PR #${issue_number} from ${pr.author?.login || 'unknown'}: ${pr.title}`)
-                continue
-              }
-
-              try {
-                // Add comment
-                await withRetry(
-                  () => github.rest.issues.createComment({
-                    owner,
-                    repo,
-                    issue_number,
-                    body: closeComment,
-                  }),
-                  `Comment on PR #${issue_number}`
-                )
-
-                // Close PR
-                await withRetry(
-                  () => github.rest.pulls.update({
-                    owner,
-                    repo,
-                    pull_number: issue_number,
-                    state: "closed",
-                  }),
-                  `Close PR #${issue_number}`
-                )
-
-                closedCount++
-                core.info(`Closed PR #${issue_number} from ${pr.author?.login || 'unknown'}: ${pr.title}`)
-
-                // Delay before processing next PR
-                await sleep(requestDelayMs)
-              } catch (error) {
-                skippedCount++
-                core.error(`Failed to close PR #${issue_number}: ${error.message}`)
-              }
-            }
-
-            const elapsed = Math.round((Date.now() - startTime) / 1000)
-            core.info(`\n========== Summary ==========`)
-            core.info(`Total open PRs found: ${allPrs.length}`)
-            core.info(`Stale PRs identified: ${stalePrs.length}`)
-            core.info(`PRs closed: ${closedCount}`)
-            core.info(`PRs skipped (errors): ${skippedCount}`)
-            core.info(`Elapsed time: ${elapsed}s`)
-            core.info(`=============================`)
@@ -29,7 +29,7 @@
    },
    "packages/app": {
      "name": "@opencode-ai/app",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/core": "workspace:*",
@@ -84,7 +84,7 @@
    },
    "packages/console/app": {
      "name": "@opencode-ai/console-app",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -119,7 +119,7 @@
    },
    "packages/console/core": {
      "name": "@opencode-ai/console-core",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -146,7 +146,7 @@
    },
    "packages/console/function": {
      "name": "@opencode-ai/console-function",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@ai-sdk/anthropic": "3.0.64",
        "@ai-sdk/openai": "3.0.48",
@@ -168,7 +168,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode-ai/console-mail",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -192,7 +192,7 @@
    },
    "packages/core": {
      "name": "@opencode-ai/core",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -253,7 +253,7 @@
    },
    "packages/desktop": {
      "name": "@opencode-ai/desktop",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "drizzle-orm": "catalog:",
        "effect": "catalog:",
@@ -307,7 +307,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode-ai/enterprise",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@opencode-ai/core": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -337,7 +337,7 @@
    },
    "packages/function": {
      "name": "@opencode-ai/function",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -353,7 +353,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode-ai/http-recorder",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "effect": "catalog:",
@@ -366,7 +366,7 @@
    },
    "packages/llm": {
      "name": "@opencode-ai/llm",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@smithy/eventstream-codec": "4.2.14",
        "@smithy/util-utf8": "4.2.2",
@@ -384,7 +384,7 @@
    },
    "packages/opencode": {
      "name": "opencode",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -520,7 +520,7 @@
    },
    "packages/plugin": {
      "name": "@opencode-ai/plugin",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "effect": "catalog:",
@@ -558,7 +558,7 @@
    },
    "packages/sdk/js": {
      "name": "@opencode-ai/sdk",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "cross-spawn": "catalog:",
      },
@@ -573,7 +573,7 @@
    },
    "packages/slack": {
      "name": "@opencode-ai/slack",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "@slack/bolt": "^3.17.1",
@@ -608,7 +608,7 @@
    },
    "packages/ui": {
      "name": "@opencode-ai/ui",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/core": "workspace:*",
@@ -657,7 +657,7 @@
    },
    "packages/web": {
      "name": "@opencode-ai/web",
-      "version": "1.14.50",
+      "version": "1.15.0",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -70,11 +70,10 @@ const modelHttpErrorsQuery = (product: "go" | "zen") => {
  }).json
 }

-const providerHttpErrorsQuery = (product: "go" | "zen") => {
+const providerHttpErrorsQuery = () => {
  const filters = [
    { column: "provider", op: "exists" },
    { column: "user_agent", op: "contains", value: "opencode" },
-    { column: "isGoTier", op: "=", value: product === "go" ? "true" : "false" },
  ]
  const successHttpStatus = calculatedField({
    name: "is_success_http_status",
@@ -101,11 +100,15 @@ const providerHttpErrorsQuery = (product: "go" | "zen") => {
        name: "FAILED",
        column: failedProviderHttpStatus.name,
        filterCombination: "AND",
-        filters: [...filters, { column: "event_type", op: "=", value: "llm.error" }],
+        filters: [
+          ...filters,
+          { column: "event_type", op: "=", value: "llm.error" },
+          { column: "llm.error.code", op: "!=", value: "404" },
+        ],
      },
    ],
    formulas: [
-      { name: "ERROR", expression: "IF(GTE(SUM($SUCCESS, $FAILED), 50), DIV($FAILED, SUM($SUCCESS, $FAILED)), 0)" },
+      { name: "ERROR", expression: "IF(GTE(SUM($SUCCESS, $FAILED), 200), DIV($FAILED, SUM($SUCCESS, $FAILED)), 0)" },
    ],
    timeRange: 900,
  }).json
@@ -215,29 +218,10 @@ new honeycomb.Trigger("LowModelTpsZen", {
  ],
 })

-new honeycomb.Trigger("IncreasedProviderHttpErrorsGo", {
-  name: "Increased Provider HTTP Errors [Go]",
+new honeycomb.Trigger("IncreasedProviderHttpErrors", {
+  name: "Increased Provider HTTP Errors",
  description,
-  queryJson: providerHttpErrorsQuery("go"),
-  alertType: "on_change",
-  frequency: 300,
-  thresholds: [{ op: ">=", value: 0.7, exceededLimit: 1 }],
-  recipients: [
-    {
-      id: webhookRecipient.id,
-      notificationDetails: [
-        {
-          variables: [{ name: "type", value: "provider_http_errors" }],
-        },
-      ],
-    },
-  ],
-})
-
-new honeycomb.Trigger("IncreasedProviderHttpErrorsZen", {
-  name: "Increased Provider HTTP Errors [Zen]",
-  description,
-  queryJson: providerHttpErrorsQuery("zen"),
+  queryJson: providerHttpErrorsQuery(),
  alertType: "on_change",
  frequency: 300,
  thresholds: [{ op: ">=", value: 0.7, exceededLimit: 1 }],
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/app",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "description": "",
  "type": "module",
  "exports": {
@@ -125,6 +125,7 @@ export function applyDirectoryEvent(input: {
      const info = (event.properties as { info: Session }).info
      const result = Binary.search(input.store.session, info.id, (s) => s.id)
      if (info.time.archived) {
+        if (input.store.session[result.index]!.time.archived === info.time.archived) break
        if (result.found) {
          input.setStore(
            "session",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-app",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/console-core",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-function",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-mail",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "name": "@opencode-ai/core",
  "type": "module",
  "license": "MIT",
@@ -5,7 +5,8 @@ import { produce, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { PluginV2 } from "./plugin"
 import { ProviderV2 } from "./provider"
-import { Instance } from "./instance"
+import { Location } from "./location"
+import { EventV2 } from "./event"

 type ProviderRecord = {
  provider: ProviderV2.Info
@@ -24,6 +25,15 @@ export class ModelNotFoundError extends Schema.TaggedErrorClass<ModelNotFoundErr
  modelID: ModelV2.ID,
 }) {}

+export const Event = {
+  ModelUpdated: EventV2.define({
+    type: "catalog.model.updated",
+    schema: {
+      model: ModelV2.Info,
+    },
+  }),
+}
+
 export interface Interface {
  readonly provider: {
    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info, ProviderNotFoundError>
@@ -57,10 +67,11 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    yield* Instance.Service
+    yield* Location.Service
    let records = HashMap.empty<ProviderV2.ID, ProviderRecord>()
    let defaultModel: { providerID: ProviderV2.ID; modelID: ModelV2.ID } | undefined
    const plugin = yield* PluginV2.Service
+    const events = yield* EventV2.Service

    const resolve = (model: ModelV2.Info) => {
      const provider = Option.getOrThrow(HashMap.get(records, model.providerID)).provider
@@ -157,14 +168,12 @@ export const layer = Layer.effect(
          )
          const updated = yield* plugin.trigger("model.update", {}, { model, cancel: false })
          if (updated.cancel) return
+          const next = new ModelV2.Info({ ...updated.model, id: modelID, providerID })
          records = HashMap.set(records, providerID, {
            provider: record.provider,
-            models: HashMap.set(
-              record.models,
-              modelID,
-              new ModelV2.Info({ ...updated.model, id: modelID, providerID }),
-            ),
+            models: HashMap.set(record.models, modelID, next),
          })
+          yield* events.publish(Event.ModelUpdated, { model: resolve(next) })
          return
        }),

@@ -257,4 +266,4 @@ export const layer = Layer.effect(

 const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/

-export const defaultLayer = layer.pipe(Layer.provide(PluginV2.defaultLayer))
+export const defaultLayer = layer.pipe(Layer.provideMerge(EventV2.defaultLayer), Layer.provide(PluginV2.defaultLayer))
@@ -0,0 +1,157 @@
+import { Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
+import { Location } from "./location"
+import { withStatics } from "./schema"
+import { Identifier } from "./util/identifier"
+
+export const ID = Schema.String.pipe(
+  Schema.brand("Event.ID"),
+  withStatics((schema) => ({ create: () => schema.make("evt_" + Identifier.ascending()) })),
+)
+export type ID = typeof ID.Type
+
+export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
+  readonly type: Type
+  readonly version?: number
+  readonly aggregate?: string
+  readonly data: DataSchema
+}
+
+export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>
+
+export type Payload<D extends Definition = Definition> = {
+  readonly id: ID
+  readonly type: D["type"]
+  readonly data: Data<D>
+  readonly version?: number
+  readonly location?: Location.Ref
+  readonly metadata?: Record<string, unknown>
+}
+
+export type Sync = (event: Payload) => Effect.Effect<void>
+
+export const registry = new Map<string, Definition>()
+
+export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
+  readonly type: Type
+  readonly version?: number
+  readonly aggregate?: string
+  readonly schema: Fields
+}): Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>> {
+  const Data = Schema.Struct(input.schema)
+  const Payload = Schema.Struct({
+    id: ID,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    type: Schema.Literal(input.type),
+    version: Schema.optional(Schema.Number),
+    location: Schema.optional(Location.Ref),
+    data: Data,
+  }).annotate({ identifier: input.type })
+
+  const definition = Object.assign(Payload, {
+    type: input.type,
+    ...(input.version === undefined ? {} : { version: input.version }),
+    ...(input.aggregate === undefined ? {} : { aggregate: input.aggregate }),
+    data: Data,
+  })
+  registry.set(input.type, definition)
+  return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
+    Definition<Type, Schema.Struct<Fields>>
+}
+
+export function definitions() {
+  return registry.values().toArray()
+}
+
+export interface PublishOptions {
+  readonly id?: ID
+  readonly metadata?: Record<string, unknown>
+}
+
+export type Unsubscribe = Effect.Effect<void>
+
+export interface Interface {
+  readonly publish: <D extends Definition>(
+    definition: D,
+    data: Data<D>,
+    options?: PublishOptions,
+  ) => Effect.Effect<Payload<D>>
+  readonly publishEvent: <D extends Definition>(event: Payload<D>) => Effect.Effect<Payload<D>>
+  readonly subscribe: <D extends Definition>(definition: D) => Stream.Stream<Payload<D>>
+  readonly all: () => Stream.Stream<Payload>
+  readonly sync: (handler: Sync) => Effect.Effect<Unsubscribe>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Event") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const all = yield* PubSub.unbounded<Payload>()
+    const typed = new Map<string, PubSub.PubSub<Payload>>()
+    const syncHandlers = new Array<Sync>()
+
+    const getOrCreate = (definition: Definition) =>
+      Effect.gen(function* () {
+        const existing = typed.get(definition.type)
+        if (existing) return existing
+        const pubsub = yield* PubSub.unbounded<Payload>()
+        typed.set(definition.type, pubsub)
+        return pubsub
+      })
+
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        yield* PubSub.shutdown(all)
+        yield* Effect.forEach(typed.values(), PubSub.shutdown, { discard: true })
+      }),
+    )
+
+    function publishEvent<D extends Definition>(event: Payload<D>) {
+      return Effect.gen(function* () {
+        for (const sync of syncHandlers) {
+          yield* sync(event as Payload)
+        }
+        const pubsub = typed.get(event.type)
+        if (pubsub) yield* PubSub.publish(pubsub, event as Payload)
+        yield* PubSub.publish(all, event as Payload)
+        return event
+      })
+    }
+
+    function publish<D extends Definition>(definition: D, data: Data<D>, options?: PublishOptions) {
+      return Effect.gen(function* () {
+        const location = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service))
+        const event = {
+          id: options?.id ?? ID.create(),
+          ...(options?.metadata ? { metadata: options.metadata } : {}),
+          type: definition.type,
+          ...(definition.version === undefined ? {} : { version: definition.version }),
+          ...(location ? { location } : {}),
+          data,
+        } as Payload<D>
+        return yield* publishEvent(event)
+      })
+    }
+
+    const subscribe = <D extends Definition>(definition: D): Stream.Stream<Payload<D>> =>
+      Stream.unwrap(getOrCreate(definition).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))).pipe(
+        Stream.map((event) => event as Payload<D>),
+      )
+
+    const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(all)
+    const sync = (handler: Sync): Effect.Effect<Unsubscribe> =>
+      Effect.sync(() => {
+        syncHandlers.push(handler)
+        return Effect.sync(() => {
+          const index = syncHandlers.indexOf(handler)
+          if (index >= 0) syncHandlers.splice(index, 1)
+        })
+      })
+
+    return Service.of({ publish, publishEvent, subscribe, all: streamAll, sync })
+  }),
+)
+
+export const defaultLayer = layer
+
+export * as EventV2 from "./event"
@@ -5,15 +5,7 @@ function truthy(key: string) {
  return value === "true" || value === "1"
 }

-function number(key: string) {
-  const value = process.env[key]
-  if (!value) return undefined
-  const parsed = Number(value)
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
-}
-
 const OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL")
-const OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE")
 const copy = process.env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"]

 export const Flag = {
@@ -30,21 +22,14 @@ export const Flag = {
  OPENCODE_DISABLE_TERMINAL_TITLE: truthy("OPENCODE_DISABLE_TERMINAL_TITLE"),
  OPENCODE_SHOW_TTFD: truthy("OPENCODE_SHOW_TTFD"),
  OPENCODE_PERMISSION: process.env["OPENCODE_PERMISSION"],
-  OPENCODE_DISABLE_DEFAULT_PLUGINS: truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS"),
-  OPENCODE_DISABLE_LSP_DOWNLOAD: truthy("OPENCODE_DISABLE_LSP_DOWNLOAD"),
  OPENCODE_DISABLE_AUTOCOMPACT: truthy("OPENCODE_DISABLE_AUTOCOMPACT"),
  OPENCODE_DISABLE_MODELS_FETCH: truthy("OPENCODE_DISABLE_MODELS_FETCH"),
  OPENCODE_DISABLE_MOUSE: truthy("OPENCODE_DISABLE_MOUSE"),
-  OPENCODE_DISABLE_CLAUDE_CODE,
-  OPENCODE_DISABLE_CLAUDE_CODE_PROMPT: OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT"),
-  OPENCODE_DISABLE_EXTERNAL_SKILLS: truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS"),
  OPENCODE_FAKE_VCS: process.env["OPENCODE_FAKE_VCS"],
  OPENCODE_SERVER_PASSWORD: process.env["OPENCODE_SERVER_PASSWORD"],
  OPENCODE_SERVER_USERNAME: process.env["OPENCODE_SERVER_USERNAME"],
-  OPENCODE_ENABLE_QUESTION_TOOL: truthy("OPENCODE_ENABLE_QUESTION_TOOL"),

  // Experimental
-  OPENCODE_EXPERIMENTAL,
  OPENCODE_EXPERIMENTAL_FILEWATCHER: Config.boolean("OPENCODE_EXPERIMENTAL_FILEWATCHER").pipe(
    Config.withDefault(false),
  ),
@@ -53,22 +38,13 @@ export const Flag = {
  ),
  OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT:
    copy === undefined ? process.platform === "win32" : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"),
-  OPENCODE_ENABLE_EXA: truthy("OPENCODE_ENABLE_EXA") || OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA"),
-  OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
-  OPENCODE_EXPERIMENTAL_LSP_TOOL: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL"),
-  OPENCODE_EXPERIMENTAL_PLAN_MODE: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE"),
-  OPENCODE_EXPERIMENTAL_SCOUT: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_SCOUT"),
-  OPENCODE_ENABLE_PARALLEL: truthy("OPENCODE_ENABLE_PARALLEL") || truthy("OPENCODE_EXPERIMENTAL_PARALLEL"),
+  OPENCODE_EXPERIMENTAL_MINIMAL_THINKING: truthy("OPENCODE_EXPERIMENTAL_MINIMAL_THINKING"),
  OPENCODE_MODELS_URL: process.env["OPENCODE_MODELS_URL"],
  OPENCODE_MODELS_PATH: process.env["OPENCODE_MODELS_PATH"],
  OPENCODE_DB: process.env["OPENCODE_DB"],
-  OPENCODE_SKIP_MIGRATIONS: truthy("OPENCODE_SKIP_MIGRATIONS"),
-  OPENCODE_STRICT_CONFIG_DEPS: truthy("OPENCODE_STRICT_CONFIG_DEPS"),

  OPENCODE_WORKSPACE_ID: process.env["OPENCODE_WORKSPACE_ID"],
  OPENCODE_EXPERIMENTAL_WORKSPACES: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES"),
-  OPENCODE_EXPERIMENTAL_EVENT_SYSTEM: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EVENT_SYSTEM"),
-  OPENCODE_EXPERIMENTAL_SESSION_SWITCHING: OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_SESSION_SWITCHING"),

  // Evaluated at access time (not module load) because tests, the CLI, and
  // external tooling set these env vars at runtime.
@@ -1,12 +0,0 @@
-import { Layer, LayerMap } from "effect"
-import { Instance } from "./instance"
-import { Catalog } from "./catalog"
-import { PluginBoot } from "./plugin/boot"
-
-export class InstanceServiceMap extends LayerMap.Service<InstanceServiceMap>()("@opencode/example/InstanceServiceMap", {
-  lookup: (ref: Instance.Ref) => {
-    const instance = Layer.succeed(Instance.Service, Instance.Service.of(ref))
-    return Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(Layer.provide(instance))
-  },
-  idleTimeToLive: "5 minutes",
-}) {}
@@ -1,10 +0,0 @@
-import { Context } from "effect"
-
-export * as Instance from "./instance"
-
-export type Ref = {
-  readonly directory: string
-  readonly workspaceID?: string
-}
-
-export class Service extends Context.Service<Service, Ref>()("@opencode/Instance") {}
@@ -0,0 +1,12 @@
+import { Layer, LayerMap } from "effect"
+import { Location } from "./location"
+import { Catalog } from "./catalog"
+import { PluginBoot } from "./plugin/boot"
+
+export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
+  lookup: (ref: Location.Ref) => {
+    const location = Layer.succeed(Location.Service, Location.Service.of(ref))
+    return Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(Layer.provide(location))
+  },
+  idleTimeToLive: "5 minutes",
+}) {}
@@ -0,0 +1,11 @@
+import { Context, Schema } from "effect"
+
+export * as Location from "./location"
+
+export const Ref = Schema.Struct({
+  directory: Schema.String,
+  workspaceID: Schema.optional(Schema.String),
+}).annotate({ identifier: "Location.Ref" })
+export type Ref = typeof Ref.Type
+
+export class Service extends Context.Service<Service, Ref>()("@opencode/Location") {}
@@ -1,12 +1,13 @@
-import { SessionID } from "@/session/schema"
-import { NonNegativeInt } from "@opencode-ai/core/schema"
-import { EventV2 } from "./event"
-import { FileAttachment, Prompt } from "@opencode-ai/core/session-prompt"
 import { Schema } from "effect"
+import { EventV2 } from "./event"
+import { ModelV2 } from "./model"
+import { NonNegativeInt } from "./schema"
+import { Session } from "./session"
+import { FileAttachment, Prompt } from "./session-prompt"
+import { ToolOutput } from "./tool-output"
+import { V2Schema } from "./v2-schema"
+
 export { FileAttachment }
-import { ToolOutput } from "@opencode-ai/core/tool-output"
-import { V2Schema } from "@opencode-ai/core/v2-schema"
-import { ModelV2 } from "@opencode-ai/core/model"

 export const Source = Schema.Struct({
  start: NonNegativeInt,
@@ -15,92 +16,94 @@ export const Source = Schema.Struct({
 }).annotate({
  identifier: "session.next.event.source",
 })
-export type Source = Schema.Schema.Type<typeof Source>
+export type Source = typeof Source.Type

 const Base = {
  timestamp: V2Schema.DateTimeUtcFromMillis,
-  sessionID: SessionID,
+  sessionID: Session.ID,
 }

+const options = {
+  aggregate: "sessionID",
+  version: 1,
+} as const
+
 export const UnknownError = Schema.Struct({
  type: Schema.Literal("unknown"),
  message: Schema.String,
 }).annotate({
  identifier: "Session.Error.Unknown",
 })
-export type UnknownError = Schema.Schema.Type<typeof UnknownError>
+export type UnknownError = typeof UnknownError.Type

 export const AgentSwitched = EventV2.define({
  type: "session.next.agent.switched",
-  aggregate: "sessionID",
-  version: 1,
+  ...options,
  schema: {
    ...Base,
    agent: Schema.String,
  },
 })
-export type AgentSwitched = Schema.Schema.Type<typeof AgentSwitched>
+export type AgentSwitched = typeof AgentSwitched.Type

 export const ModelSwitched = EventV2.define({
  type: "session.next.model.switched",
-  aggregate: "sessionID",
-  version: 1,
+  ...options,
  schema: {
    ...Base,
    model: ModelV2.Ref,
  },
 })
-export type ModelSwitched = Schema.Schema.Type<typeof ModelSwitched>
+export type ModelSwitched = typeof ModelSwitched.Type

 export const Prompted = EventV2.define({
  type: "session.next.prompted",
-  aggregate: "sessionID",
-  version: 1,
+  ...options,
  schema: {
    ...Base,
    prompt: Prompt,
  },
 })
-export type Prompted = Schema.Schema.Type<typeof Prompted>
+export type Prompted = typeof Prompted.Type

 export const Synthetic = EventV2.define({
  type: "session.next.synthetic",
-  aggregate: "sessionID",
+  ...options,
  schema: {
    ...Base,
    text: Schema.String,
  },
 })
-export type Synthetic = Schema.Schema.Type<typeof Synthetic>
+export type Synthetic = typeof Synthetic.Type

 export namespace Shell {
  export const Started = EventV2.define({
    type: "session.next.shell.started",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
      command: Schema.String,
    },
  })
-  export type Started = Schema.Schema.Type<typeof Started>
+  export type Started = typeof Started.Type

  export const Ended = EventV2.define({
    type: "session.next.shell.ended",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
      output: Schema.String,
    },
  })
-  export type Ended = Schema.Schema.Type<typeof Ended>
+  export type Ended = typeof Ended.Type
 }

 export namespace Step {
  export const Started = EventV2.define({
    type: "session.next.step.started",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      agent: Schema.String,
@@ -108,11 +111,11 @@ export namespace Step {
      snapshot: Schema.String.pipe(Schema.optional),
    },
  })
-  export type Started = Schema.Schema.Type<typeof Started>
+  export type Started = typeof Started.Type

  export const Ended = EventV2.define({
    type: "session.next.step.ended",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      finish: Schema.String,
@@ -129,123 +132,123 @@ export namespace Step {
      snapshot: Schema.String.pipe(Schema.optional),
    },
  })
-  export type Ended = Schema.Schema.Type<typeof Ended>
+  export type Ended = typeof Ended.Type

  export const Failed = EventV2.define({
    type: "session.next.step.failed",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      error: UnknownError,
    },
  })
-  export type Failed = Schema.Schema.Type<typeof Failed>
+  export type Failed = typeof Failed.Type
 }

 export namespace Text {
  export const Started = EventV2.define({
    type: "session.next.text.started",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
    },
  })
-  export type Started = Schema.Schema.Type<typeof Started>
+  export type Started = typeof Started.Type

  export const Delta = EventV2.define({
    type: "session.next.text.delta",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      delta: Schema.String,
    },
  })
-  export type Delta = Schema.Schema.Type<typeof Delta>
+  export type Delta = typeof Delta.Type

  export const Ended = EventV2.define({
    type: "session.next.text.ended",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      text: Schema.String,
    },
  })
-  export type Ended = Schema.Schema.Type<typeof Ended>
+  export type Ended = typeof Ended.Type
 }

 export namespace Reasoning {
  export const Started = EventV2.define({
    type: "session.next.reasoning.started",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      reasoningID: Schema.String,
    },
  })
-  export type Started = Schema.Schema.Type<typeof Started>
+  export type Started = typeof Started.Type

  export const Delta = EventV2.define({
    type: "session.next.reasoning.delta",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      reasoningID: Schema.String,
      delta: Schema.String,
    },
  })
-  export type Delta = Schema.Schema.Type<typeof Delta>
+  export type Delta = typeof Delta.Type

  export const Ended = EventV2.define({
    type: "session.next.reasoning.ended",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      reasoningID: Schema.String,
      text: Schema.String,
    },
  })
-  export type Ended = Schema.Schema.Type<typeof Ended>
+  export type Ended = typeof Ended.Type
 }

 export namespace Tool {
  export namespace Input {
    export const Started = EventV2.define({
      type: "session.next.tool.input.started",
-      aggregate: "sessionID",
+      ...options,
      schema: {
        ...Base,
        callID: Schema.String,
        name: Schema.String,
      },
    })
-    export type Started = Schema.Schema.Type<typeof Started>
+    export type Started = typeof Started.Type

    export const Delta = EventV2.define({
      type: "session.next.tool.input.delta",
-      aggregate: "sessionID",
+      ...options,
      schema: {
        ...Base,
        callID: Schema.String,
        delta: Schema.String,
      },
    })
-    export type Delta = Schema.Schema.Type<typeof Delta>
+    export type Delta = typeof Delta.Type

    export const Ended = EventV2.define({
      type: "session.next.tool.input.ended",
-      aggregate: "sessionID",
+      ...options,
      schema: {
        ...Base,
        callID: Schema.String,
        text: Schema.String,
      },
    })
-    export type Ended = Schema.Schema.Type<typeof Ended>
+    export type Ended = typeof Ended.Type
  }

  export const Called = EventV2.define({
    type: "session.next.tool.called",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
@@ -257,11 +260,11 @@ export namespace Tool {
      }),
    },
  })
-  export type Called = Schema.Schema.Type<typeof Called>
+  export type Called = typeof Called.Type

  export const Progress = EventV2.define({
    type: "session.next.tool.progress",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
@@ -269,11 +272,11 @@ export namespace Tool {
      content: Schema.Array(ToolOutput.Content),
    },
  })
-  export type Progress = Schema.Schema.Type<typeof Progress>
+  export type Progress = typeof Progress.Type

  export const Success = EventV2.define({
    type: "session.next.tool.success",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
@@ -285,11 +288,11 @@ export namespace Tool {
      }),
    },
  })
-  export type Success = Schema.Schema.Type<typeof Success>
+  export type Success = typeof Success.Type

  export const Failed = EventV2.define({
    type: "session.next.tool.failed",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      callID: Schema.String,
@@ -300,7 +303,7 @@ export namespace Tool {
      }),
    },
  })
-  export type Failed = Schema.Schema.Type<typeof Failed>
+  export type Failed = typeof Failed.Type
 }

 export const RetryError = Schema.Struct({
@@ -313,49 +316,50 @@ export const RetryError = Schema.Struct({
 }).annotate({
  identifier: "session.next.retry_error",
 })
-export type RetryError = Schema.Schema.Type<typeof RetryError>
+export type RetryError = typeof RetryError.Type

 export const Retried = EventV2.define({
  type: "session.next.retried",
-  aggregate: "sessionID",
+  ...options,
  schema: {
    ...Base,
    attempt: Schema.Finite,
    error: RetryError,
  },
 })
-export type Retried = Schema.Schema.Type<typeof Retried>
+export type Retried = typeof Retried.Type

 export namespace Compaction {
  export const Started = EventV2.define({
    type: "session.next.compaction.started",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
    },
  })
-  export type Started = Schema.Schema.Type<typeof Started>
+  export type Started = typeof Started.Type

  export const Delta = EventV2.define({
    type: "session.next.compaction.delta",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      text: Schema.String,
    },
  })
+  export type Delta = typeof Delta.Type

  export const Ended = EventV2.define({
    type: "session.next.compaction.ended",
-    aggregate: "sessionID",
+    ...options,
    schema: {
      ...Base,
      text: Schema.String,
      include: Schema.String.pipe(Schema.optional),
    },
  })
-  export type Ended = Schema.Schema.Type<typeof Ended>
+  export type Ended = typeof Ended.Type
 }

 export const All = Schema.Union(
@@ -392,16 +396,7 @@ export const All = Schema.Union(
  },
 ).pipe(Schema.toTaggedUnion("type"))

-// user
-// assistant
-// assistant
-// assistant
-// user
-// compaction marker
-// -> text
-// assistant
-
-export type Event = Schema.Schema.Type<typeof All>
+export type Event = typeof All.Type
 export type Type = Event["type"]

 export * as SessionEvent from "./session-event"
@@ -1,10 +1,10 @@
 import { Schema } from "effect"
-import { Prompt } from "@opencode-ai/core/session-prompt"
+import { Prompt } from "./session-prompt"
 import { SessionEvent } from "./session-event"
 import { EventV2 } from "./event"
-import { ToolOutput } from "@opencode-ai/core/tool-output"
-import { V2Schema } from "@opencode-ai/core/v2-schema"
-import { ModelV2 } from "@opencode-ai/core/model"
+import { ToolOutput } from "./tool-output"
+import { V2Schema } from "./v2-schema"
+import { ModelV2 } from "./model"

 export const ID = EventV2.ID
 export type ID = Schema.Schema.Type<typeof ID>
@@ -20,7 +20,7 @@ const Base = {
 export class AgentSwitched extends Schema.Class<AgentSwitched>("Session.Message.AgentSwitched")({
  ...Base,
  type: Schema.Literal("agent-switched"),
-  agent: SessionEvent.AgentSwitched.fields.data.fields.agent,
+  agent: SessionEvent.AgentSwitched.data.fields.agent,
 }) {}

 export class ModelSwitched extends Schema.Class<ModelSwitched>("Session.Message.ModelSwitched")({
@@ -43,16 +43,16 @@ export class User extends Schema.Class<User>("Session.Message.User")({

 export class Synthetic extends Schema.Class<Synthetic>("Session.Message.Synthetic")({
  ...Base,
-  sessionID: SessionEvent.Synthetic.fields.data.fields.sessionID,
-  text: SessionEvent.Synthetic.fields.data.fields.text,
+  sessionID: SessionEvent.Synthetic.data.fields.sessionID,
+  text: SessionEvent.Synthetic.data.fields.text,
  type: Schema.Literal("synthetic"),
 }) {}

 export class Shell extends Schema.Class<Shell>("Session.Message.Shell")({
  ...Base,
  type: Schema.Literal("shell"),
-  callID: SessionEvent.Shell.Started.fields.data.fields.callID,
-  command: SessionEvent.Shell.Started.fields.data.fields.command,
+  callID: SessionEvent.Shell.Started.data.fields.callID,
+  command: SessionEvent.Shell.Started.data.fields.command,
  output: Schema.String,
  time: Schema.Struct({
    created: V2Schema.DateTimeUtcFromMillis,
@@ -130,7 +130,7 @@ export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistan
  ...Base,
  type: Schema.Literal("assistant"),
  agent: Schema.String,
-  model: SessionEvent.Step.Started.fields.data.fields.model,
+  model: SessionEvent.Step.Started.data.fields.model,
  content: AssistantContent.pipe(Schema.Array),
  snapshot: Schema.Struct({
    start: Schema.String.pipe(Schema.optional),
@@ -147,7 +147,7 @@ export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistan
      write: Schema.Finite,
    }),
  }).pipe(Schema.optional),
-  error: SessionEvent.Step.Failed.fields.data.fields.error.pipe(Schema.optional),
+  error: SessionEvent.Step.Failed.data.fields.error.pipe(Schema.optional),
  time: Schema.Struct({
    created: V2Schema.DateTimeUtcFromMillis,
    completed: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
@@ -156,7 +156,7 @@ export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistan

 export class Compaction extends Schema.Class<Compaction>("Session.Message.Compaction")({
  type: Schema.Literal("compaction"),
-  reason: SessionEvent.Compaction.Started.fields.data.fields.reason,
+  reason: SessionEvent.Compaction.Started.data.fields.reason,
  summary: Schema.String,
  include: Schema.String.pipe(Schema.optional),
  ...Base,
@@ -0,0 +1,13 @@
+export * as Session from "./session"
+
+import { Schema } from "effect"
+import { withStatics } from "./schema"
+import { Identifier } from "./util/identifier"
+
+export const ID = Schema.String.check(Schema.isStartsWith("ses")).pipe(
+  Schema.brand("SessionID"),
+  withStatics((schema) => ({
+    descending: (id?: string) => schema.make(id ?? "ses_" + Identifier.descending()),
+  })),
+)
+export type ID = typeof ID.Type
@@ -1,14 +1,21 @@
 import { describe, expect } from "bun:test"
-import { DateTime, Effect, Layer, Option } from "effect"
+import { DateTime, Effect, Fiber, Layer, Option, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { Instance } from "@opencode-ai/core/instance"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "./lib/effect"

-const instanceLayer = Layer.succeed(Instance.Service, Instance.Service.of({ directory: "test" }))
-const it = testEffect(Catalog.layer.pipe(Layer.provideMerge(PluginV2.defaultLayer), Layer.provide(instanceLayer)))
+const locationLayer = Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))
+const it = testEffect(
+  Catalog.layer.pipe(
+    Layer.provideMerge(EventV2.defaultLayer),
+    Layer.provideMerge(PluginV2.defaultLayer),
+    Layer.provideMerge(locationLayer),
+  ),
+)

 describe("CatalogV2", () => {
  it.effect("normalizes provider baseURL into endpoint url", () =>
@@ -69,6 +76,31 @@ describe("CatalogV2", () => {
    }),
  )

+  it.effect("publishes model updated events", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const events = yield* EventV2.Service
+      const providerID = ProviderV2.ID.make("test")
+      const modelID = ModelV2.ID.make("model")
+      const fiber = yield* events
+        .subscribe(Catalog.Event.ModelUpdated)
+        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+
+      yield* Effect.yieldNow
+      yield* catalog.provider.update(providerID, () => {})
+      yield* catalog.model.update(providerID, modelID, (model) => {
+        model.name = "Updated Model"
+      })
+      const event = Array.from(yield* Fiber.join(fiber))[0]
+
+      expect(event?.type).toBe("catalog.model.updated")
+      expect(event?.data.model.providerID).toBe(providerID)
+      expect(event?.data.model.id).toBe(modelID)
+      expect(event?.data.model.name).toBe("Updated Model")
+      expect(event?.location).toEqual({ directory: "test" })
+    }),
+  )
+
  it.effect("resolves unknown model endpoint from provider endpoint", () =>
    Effect.gen(function* () {
      const catalog = yield* Catalog.Service
@@ -0,0 +1,132 @@
+import { describe, expect } from "bun:test"
+import { Effect, Fiber, Layer, Schema, Stream } from "effect"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Location } from "@opencode-ai/core/location"
+import { testEffect } from "./lib/effect"
+
+const locationLayer = Layer.succeed(
+  Location.Service,
+  Location.Service.of({ directory: "project", workspaceID: "workspace" }),
+)
+const it = testEffect(EventV2.layer.pipe(Layer.provideMerge(locationLayer)))
+const itWithoutLocation = testEffect(EventV2.layer)
+
+const Message = EventV2.define({
+  type: "test.message",
+  schema: {
+    text: Schema.String,
+  },
+})
+
+const GlobalMessage = EventV2.define({
+  type: "test.global",
+  schema: {
+    text: Schema.String,
+  },
+})
+
+const VersionedMessage = EventV2.define({
+  type: "test.versioned",
+  version: 2,
+  schema: {
+    text: Schema.String,
+  },
+})
+
+describe("EventV2", () => {
+  it.effect("publishes events with the current location", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const fiber = yield* events.subscribe(Message).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      yield* Effect.yieldNow
+      const event = yield* events.publish(Message, { text: "hello" })
+      const received = Array.from(yield* Fiber.join(fiber))
+
+      expect(received).toEqual([event])
+      expect(event.type).toBe("test.message")
+      expect(event).not.toHaveProperty("version")
+      expect(event.data).toEqual({ text: "hello" })
+      expect(event.location).toEqual({ directory: "project", workspaceID: "workspace" })
+    }),
+  )
+
+  itWithoutLocation.effect("omits location when no location is available", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const event = yield* events.publish(GlobalMessage, { text: "hello" })
+
+      expect(event).not.toHaveProperty("location")
+      expect(event.type).toBe("test.global")
+    }),
+  )
+
+  it.effect("publishes definition version", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const event = yield* events.publish(VersionedMessage, { text: "hello" })
+
+      expect(event.type).toBe("test.versioned")
+      expect(event.version).toBe(2)
+    }),
+  )
+
+  it.effect("stores definitions in the exported registry", () =>
+    Effect.sync(() => {
+      expect(EventV2.registry.get(Message.type)).toBe(Message)
+    }),
+  )
+
+  it.effect("publishes to typed and wildcard subscriptions", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const typed = yield* events.subscribe(Message).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      const wildcard = yield* events.all().pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+      yield* Effect.yieldNow
+      const event = yield* events.publish(Message, { text: "hello" })
+
+      expect(Array.from(yield* Fiber.join(typed))).toEqual([event])
+      expect(Array.from(yield* Fiber.join(wildcard))).toEqual([event])
+    }),
+  )
+
+  it.effect("runs sync handlers inline", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const received = new Array<EventV2.Payload>()
+      const unsubscribe = yield* events.sync((event) =>
+        Effect.sync(() => {
+          received.push(event)
+        }),
+      )
+
+      const event = yield* events.publish(Message, { text: "hello" })
+      yield* unsubscribe
+      yield* events.publish(Message, { text: "after unsubscribe" })
+
+      expect(received).toEqual([event])
+    }),
+  )
+
+  it.effect("runs sync handlers before publishing to streams", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2.Service
+      const received = new Array<string>()
+      const fiber = yield* events.all().pipe(
+        Stream.take(1),
+        Stream.runForEach(() => Effect.sync(() => received.push("stream"))),
+        Effect.forkScoped,
+      )
+      yield* events.sync((event) =>
+        Effect.sync(() => {
+          received.push(event.type)
+        }),
+      )
+
+      yield* Effect.yieldNow
+      yield* events.publish(Message, { text: "hello" })
+      yield* Fiber.join(fiber)
+
+      expect(received).toEqual([Message.type, "stream"])
+    }),
+  )
+})
@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { DateTime, Effect, Layer, Option } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { Instance } from "@opencode-ai/core/instance"
+import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { OpencodePlugin } from "@opencode-ai/core/plugin/provider/opencode"
@@ -9,7 +9,7 @@ import { ProviderV2 } from "@opencode-ai/core/provider"
 import { it, model, provider, withEnv } from "./provider-helper"

 const cost = (input: number, output = 0) => [{ input, output, cache: { read: 0, write: 0 } }]
-const instanceLayer = Layer.succeed(Instance.Service, Instance.Service.of({ directory: "test" }))
+const locationLayer = Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))

 describe("OpencodePlugin", () => {
  it.effect("uses a public key and cancels paid models without credentials", () =>
@@ -192,6 +192,6 @@ describe("OpencodePlugin", () => {
      const selected = yield* catalog.model.small(providerID)

      expect(Option.getOrUndefined(selected)?.id).toBe(ModelV2.ID.make("gpt-5-nano"))
-    }).pipe(Effect.provide(Catalog.defaultLayer.pipe(Layer.provide(instanceLayer)))),
+    }).pipe(Effect.provide(Catalog.defaultLayer.pipe(Layer.provide(locationLayer)))),
  )
 })
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop",
  "private": true,
-  "version": "1.14.50",
+  "version": "1.15.0",
  "type": "module",
  "license": "MIT",
  "homepage": "https://opencode.ai",
@@ -84,6 +84,7 @@ export function createMainWindow() {
    width: state.width,
    height: state.height,
    show: false,
+    autoHideMenuBar: true,
    title: "OpenCode",
    icon: iconPath(),
    backgroundColor,
@@ -142,6 +143,7 @@ export function createLoadingWindow() {
    resizable: false,
    center: true,
    show: true,
+    autoHideMenuBar: true,
    icon: iconPath(),
    backgroundColor,
    ...(process.platform === "darwin" ? { titleBarStyle: "hidden" as const } : {}),
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/enterprise",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,7 +1,7 @@
 id = "opencode"
 name = "OpenCode"
 description = "The open source coding agent."
-version = "1.14.50"
+version = "1.15.0"
 schema_version = 1
 authors = ["Anomaly"]
 repository = "https://github.com/anomalyco/opencode"
@@ -11,26 +11,26 @@ name = "OpenCode"
 icon = "./icons/opencode.svg"

 [agent_servers.opencode.targets.darwin-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.50/opencode-darwin-arm64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.15.0/opencode-darwin-arm64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.darwin-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.50/opencode-darwin-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.15.0/opencode-darwin-x64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.50/opencode-linux-arm64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.15.0/opencode-linux-arm64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.50/opencode-linux-x64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.15.0/opencode-linux-x64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.windows-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.50/opencode-windows-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.15.0/opencode-windows-x64.zip"
 cmd = "./opencode.exe"
 args = ["acp"]
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/function",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "name": "@opencode-ai/http-recorder",
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "name": "@opencode-ai/llm",
  "type": "module",
  "license": "MIT",
@@ -128,17 +128,8 @@ See `specs/effect/migration.md` for the compact pattern reference and examples.

 Use `Effect.cached` when multiple concurrent callers should share a single in-flight computation rather than storing `Fiber | undefined` or `Promise | undefined` manually. See `specs/effect/migration.md` for the full pattern.

-## Instance.bind — ALS for native callbacks
+## Callback boundaries

-`Instance.bind(fn)` captures the current Instance AsyncLocalStorage context and restores it synchronously when called.
+Use `EffectBridge` for native or external callbacks (`@parcel/watcher`, `node-pty`, native `fs.watch`, plugin callbacks, etc.) that need to re-enter Effect services with instance/workspace context.

-Use it for native addon callbacks (`@parcel/watcher`, `node-pty`, native `fs.watch`, etc.) that need to call `Bus.publish` or anything that reads `Instance.directory`.
-
-You do not need it for `setTimeout`, `Promise.then`, `EventEmitter.on`, or Effect fibers.
-
-```typescript
-const cb = Instance.bind((err, evts) => {
-  Bus.publish(MyEvent, { ... })
-})
-nativeAddon.subscribe(dir, cb)
-```
+Plain async code should pass explicit context or stay inside an Effect fiber; do not add ambient instance context shims.
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.50",
+  "version": "1.15.0",
  "name": "opencode",
  "type": "module",
  "license": "MIT",
@@ -244,6 +244,7 @@ for (const item of targets) {
      {
        name,
        version: Script.version,
+        preferUnplugged: true,
        os: [item.os],
        cpu: [item.arch],
      },
@@ -1,102 +1,189 @@
 #!/usr/bin/env node

+import childProcess from "child_process"
 import fs from "fs"
-import path from "path"
 import os from "os"
-import { fileURLToPath } from "url"
+import path from "path"
 import { createRequire } from "module"
+import { fileURLToPath } from "url"

 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
+const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))

-function detectPlatformAndArch() {
-  // Map platform names
-  let platform
-  switch (os.platform()) {
-    case "darwin":
-      platform = "darwin"
-      break
-    case "linux":
-      platform = "linux"
-      break
-    case "win32":
-      platform = "windows"
-      break
-    default:
-      platform = os.platform()
-      break
-  }
-
-  // Map architecture names
-  let arch
-  switch (os.arch()) {
-    case "x64":
-      arch = "x64"
-      break
-    case "arm64":
-      arch = "arm64"
-      break
-    case "arm":
-      arch = "arm"
-      break
-    default:
-      arch = os.arch()
-      break
-  }
-
-  return { platform, arch }
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+}
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+  arm: "arm",
 }

-function findBinary() {
-  const { platform, arch } = detectPlatformAndArch()
-  const packageName = `opencode-${platform}-${arch}`
-  const binaryName = platform === "windows" ? "opencode.exe" : "opencode"
+const platform = platformMap[os.platform()] ?? os.platform()
+const arch = archMap[os.arch()] ?? os.arch()
+const base = `opencode-${platform}-${arch}`
+const sourceBinary = platform === "windows" ? "opencode.exe" : "opencode"
+const targetBinary = path.join(__dirname, "bin", "opencode.exe")

-  try {
-    // Use require.resolve to find the package
-    const packageJsonPath = require.resolve(`${packageName}/package.json`)
-    const packageDir = path.dirname(packageJsonPath)
-    const binaryPath = path.join(packageDir, "bin", binaryName)
+function supportsAvx2() {
+  if (arch !== "x64") return false

-    if (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found at ${binaryPath}`)
-    }
-
-    return { binaryPath, binaryName }
-  } catch (error) {
-    throw new Error(`Could not find package ${packageName}: ${error.message}`, { cause: error })
-  }
-}
-
-async function main() {
-  try {
-    if (os.platform() === "win32") {
-      // On Windows, the .exe is already included in the package and bin field points to it
-      // No postinstall setup needed
-      console.log("Windows detected: binary setup not needed (using packaged .exe)")
-      return
-    }
-
-    // On non-Windows platforms, just verify the binary package exists
-    // Don't replace the wrapper script - it handles binary execution
-    const { binaryPath } = findBinary()
-    const target = path.join(__dirname, "bin", ".opencode")
-    if (fs.existsSync(target)) fs.unlinkSync(target)
+  if (platform === "linux") {
    try {
-      fs.linkSync(binaryPath, target)
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
    } catch {
-      fs.copyFileSync(binaryPath, target)
+      return false
    }
-    fs.chmodSync(target, 0o755)
-  } catch (error) {
-    console.error("Failed to setup opencode binary:", error.message)
-    process.exit(1)
  }
+
+  if (platform === "darwin") {
+    try {
+      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
+        encoding: "utf8",
+        timeout: 1500,
+      })
+      if (result.status !== 0) return false
+      return (result.stdout || "").trim() === "1"
+    } catch {
+      return false
+    }
+  }
+
+  if (platform === "windows") {
+    const command =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
+
+    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", command], {
+          encoding: "utf8",
+          timeout: 3000,
+          windowsHide: true,
+        })
+        if (result.status !== 0) continue
+        const output = (result.stdout || "").trim().toLowerCase()
+        if (output === "true" || output === "1") return true
+        if (output === "false" || output === "0") return false
+      } catch {
+        continue
+      }
+    }
+  }
+
+  return false
+}
+
+function isMusl() {
+  if (platform !== "linux") return false
+
+  try {
+    if (fs.existsSync("/etc/alpine-release")) return true
+  } catch {
+    // Ignore filesystem probes that are blocked by the host.
+  }
+
+  try {
+    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
+    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
+  } catch {
+    return false
+  }
+}
+
+function packageNames() {
+  const baseline = arch === "x64" && !supportsAvx2()
+
+  if (platform === "linux") {
+    if (isMusl()) {
+      if (arch === "x64")
+        return baseline
+          ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+          : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
+      return [`${base}-musl`, base]
+    }
+
+    if (arch === "x64")
+      return baseline
+        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
+    return [base, `${base}-musl`]
+  }
+
+  if (arch === "x64") return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`]
+  return [base]
+}
+
+function resolveBinary(name) {
+  const packageJsonPath = require.resolve(`${name}/package.json`)
+  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", sourceBinary)
+  if (!fs.existsSync(binaryPath)) throw new Error(`Binary not found at ${binaryPath}`)
+  return binaryPath
+}
+
+function installPackage(name) {
+  const version = packageJson.optionalDependencies?.[name]
+  if (!version) return
+
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-install-"))
+  try {
+    const result = childProcess.spawnSync(
+      "npm",
+      ["install", "--ignore-scripts", "--no-save", "--loglevel=error", "--prefix", temp, `${name}@${version}`],
+      { stdio: "inherit", windowsHide: true },
+    )
+    if (result.status !== 0) return
+    const packageDir = path.join(temp, "node_modules", name)
+    copyBinary(path.join(packageDir, "bin", sourceBinary), targetBinary)
+    return true
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true })
+  }
+}
+
+function copyBinary(source, target) {
+  if (!fs.existsSync(source)) throw new Error(`Binary not found at ${source}`)
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  if (fs.existsSync(target)) fs.unlinkSync(target)
+  try {
+    fs.linkSync(source, target)
+  } catch {
+    fs.copyFileSync(source, target)
+  }
+  fs.chmodSync(target, 0o755)
+}
+
+function verifyBinary() {
+  const result = childProcess.spawnSync(targetBinary, ["--version"], {
+    encoding: "utf8",
+    stdio: "ignore",
+    windowsHide: true,
+  })
+  return result.status === 0
+}
+
+function main() {
+  for (const name of packageNames()) {
+    try {
+      copyBinary(resolveBinary(name), targetBinary)
+      if (verifyBinary()) return
+    } catch {
+      if (installPackage(name) && verifyBinary()) return
+    }
+  }
+
+  throw new Error(
+    `It seems your package manager failed to install the right opencode CLI package. Try manually installing ${packageNames()
+      .map((name) => JSON.stringify(name))
+      .join(" or ")}.`,
+  )
 }

 try {
-  void main()
+  main()
 } catch (error) {
-  console.error("Postinstall script error:", error.message)
-  process.exit(0)
+  console.error(error.message)
+  process.exit(1)
 }
@@ -32,22 +32,32 @@ console.log("binaries", binaries)
 const version = Object.values(binaries)[0]

 await $`mkdir -p ./dist/${pkg.name}`
-await $`cp -r ./bin ./dist/${pkg.name}/bin`
+await $`mkdir -p ./dist/${pkg.name}/bin`
 await $`cp ./script/postinstall.mjs ./dist/${pkg.name}/postinstall.mjs`
 await Bun.file(`./dist/${pkg.name}/LICENSE`).write(await Bun.file("../../LICENSE").text())
+await Bun.file(`./dist/${pkg.name}/bin/${pkg.name}.exe`).write(
+  [
+    "#!/usr/bin/env node",
+    "console.error('The opencode native binary was not installed. Run `node postinstall.mjs` from the opencode-ai package directory to finish setup.')",
+    "process.exit(1)",
+    "",
+  ].join("\n"),
+)

 await Bun.file(`./dist/${pkg.name}/package.json`).write(
  JSON.stringify(
    {
      name: pkg.name + "-ai",
      bin: {
-        [pkg.name]: `./bin/${pkg.name}`,
+        [pkg.name]: `./bin/${pkg.name}.exe`,
      },
      scripts: {
-        postinstall: "bun ./postinstall.mjs || node ./postinstall.mjs",
+        postinstall: "node ./postinstall.mjs",
      },
      version: version,
      license: pkg.license,
+      os: ["darwin", "linux", "win32"],
+      cpu: ["arm64", "x64"],
      optionalDependencies: binaries,
    },
    null,
@@ -6,7 +6,6 @@ Current status on this branch:

 - `src/` has 5 `makeRuntime(...)` call sites total.
 - 2 are intentionally excluded from this checklist: `src/bus/index.ts` and `src/effect/cross-spawn-spawner.ts`.
- 1 is tracked primarily by the instance-context migration rather than facade removal: `src/project/instance.ts`.
 - That leaves 2 live runtime-backed service facades still worth tracking here: `src/npm/index.ts` and `src/cli/cmd/tui/config/tui.ts`.

 Recent progress:
@@ -18,7 +17,6 @@ Recent progress:

 - `src/cli/cmd/tui/config/tui.ts` still exports `makeRuntime(...)` plus async facade helpers for `get()` and `waitForDependencies()`.
 - `src/npm/index.ts` still exports `makeRuntime(...)` plus async facade helpers for `install()`, `add()`, `outdated()`, and `which()`.
- `src/project/instance.ts` still uses a dedicated runtime for project boot, but that file is really part of the broader legacy instance-context transition tracked in `instance-context.md`.

 ## Completed Batches

@@ -192,7 +190,6 @@ Most of the original facade-removal backlog is already done. The practical remai

 1. remove the `Npm` runtime-backed facade from `src/npm/index.ts`
 2. remove the `TuiConfig` runtime-backed facade from `src/cli/cmd/tui/config/tui.ts`
-3. keep `src/project/instance.ts` in the separate instance-context migration, not this checklist

 ## Checklist

@@ -197,13 +197,9 @@ For background loops, use `Effect.repeat` or `Effect.schedule` with

 [`EffectBridge`](../../src/effect/bridge.ts) is the sanctioned helper for
 Promise/callback interop that needs to preserve instance/workspace context.
-Keep it, but reduce its dependency on legacy `Instance.current` /
-`Instance.restore` over time.
-
-`Instance.bind` / `Instance.restore` are transitional legacy tools. Use
-them only for native callbacks that still require legacy ALS context. Do
-not use them for `setTimeout`, `Promise.then`, `EventEmitter.on`, or
-Effect fibers.
+It preserves explicit `InstanceRef` / `WorkspaceRef` context for effects run
+through the bridge. Plain JS callbacks that need instance data should receive
+that data explicitly.

 ## Testing

@@ -1,309 +1,13 @@
-# Instance context migration
+# Instance Context

-Practical plan for retiring the promise-backed / ALS-backed `Instance` helper in `src/project/instance.ts` and moving instance selection fully into Effect-provided scope.
+Instance selection is now Effect-provided context.

-## Goal
+Use these APIs:

-End state:
+- `InstanceRef` for the current project context.
+- `WorkspaceRef` for the current workspace id.
+- `InstanceState.context` / `InstanceState.directory` inside Effect services that require an instance.
+- `InstanceStore` at entry boundaries that need to load, reload, or dispose project contexts.
+- `EffectBridge` for native, plugin, or plain JavaScript callback boundaries that need to re-enter Effect with captured refs.

- request, CLI, TUI, and tool entrypoints shift into an instance through Effect, not `Instance.provide(...)`
- Effect code reads the current instance from `InstanceRef` or its eventual replacement, not from ALS-backed sync getters
- per-directory boot, caching, and disposal are scoped Effect resources, not a module-level `Map<string, Promise<InstanceContext>>`
- ALS remains only as a temporary bridge for native callback APIs that fire outside the Effect fiber tree
-
-## Current split
-
-Today `src/project/instance.ts` still owns two separate concerns:
-
- ambient current-instance context through `LocalContext` / `AsyncLocalStorage`
- per-directory boot and deduplication through `cache: Map<string, Promise<InstanceContext>>`
-
-At the same time, the Effect side already exists:
-
- `src/effect/instance-ref.ts` provides `InstanceRef` and `WorkspaceRef`
- `src/effect/run-service.ts` already attaches those refs when a runtime starts inside an active instance ALS context
- `src/effect/instance-state.ts` already prefers `InstanceRef` and only falls back to ALS when needed
-
-That means the migration is not "invent instance context in Effect". The migration is "stop relying on the legacy helper as the primary source of truth".
-
-## End state shape
-
-Near-term target shape:
-
-```ts
-InstanceScope.with({ directory, workspaceID }, effect)
-```
-
-Responsibilities of `InstanceScope.with(...)`:
-
- resolve `directory`, `project`, and `worktree`
- acquire or reuse the scoped per-directory instance environment
- provide `InstanceRef` and `WorkspaceRef`
- run the caller's Effect inside that environment
-
-Code inside the boundary should then do one of these:
-
-```ts
-const ctx = yield * InstanceState.context
-const dir = yield * InstanceState.directory
-```
-
-Long-term, once `InstanceState` itself is replaced by keyed layers / `LayerMap`, those reads can move to an `InstanceContext` service without changing the outer migration order.
-
-## Migration phases
-
-### Phase 1: stop expanding the legacy surface
-
-Rules for all new code:
-
- do not add new `Instance.directory`, `Instance.worktree`, `Instance.project`, or `Instance.current` reads inside Effect code
- do not add new `Instance.provide(...)` boundaries unless there is no Effect-native seam yet
- use `InstanceState.context`, `InstanceState.directory`, or an explicit `ctx` parameter inside Effect code
-
-Success condition:
-
- the file inventory below only shrinks from here
-
-### Phase 2: remove direct sync getter reads from Effect services
-
-Convert Effect services first, before replacing the top-level boundary. These modules already run inside Effect and mostly need `yield* InstanceState.context` or a yielded `ctx` instead of ambient sync access.
-
-Primary batch, highest payoff:
-
- `src/file/index.ts`
- `src/lsp/server.ts`
- `src/worktree/index.ts`
- `src/file/watcher.ts`
- `src/format/formatter.ts`
- `src/session/index.ts`
- `src/project/vcs.ts`
-
-Mechanical replacement rule:
-
- `Instance.directory` -> `ctx.directory` or `yield* InstanceState.directory`
- `Instance.worktree` -> `ctx.worktree`
- `Instance.project` -> `ctx.project`
-
-Do not thread strings manually through every public method if the service already has access to Effect context.
-
-### Phase 3: convert entry boundaries to provide instance refs directly
-
-After the service bodies stop assuming ALS, move the top-level boundaries to shift into Effect explicitly.
-
-Main boundaries:
-
- HTTP server middleware and experimental `HttpApi` entrypoints
- CLI commands
- TUI worker / attach / thread entrypoints
- tool execution entrypoints
-
-These boundaries should become Effect-native wrappers that:
-
- decode directory / workspace inputs
- resolve the instance context once
- provide `InstanceRef` and `WorkspaceRef`
- run the requested Effect
-
-At that point `Instance.provide(...)` becomes a legacy adapter instead of the normal code path.
-
-### Phase 4: replace promise boot cache with scoped instance runtime
-
-Once boundaries and services both rely on Effect context, replace the module-level promise cache in `src/project/instance.ts`.
-
-Target replacement:
-
- keyed scoped runtime or keyed layer acquisition for each directory
- reuse via `ScopedCache`, `LayerMap`, or another keyed Effect resource manager
- cleanup performed by scope finalizers instead of `disposeAll()` iterating a Promise map
-
-This phase should absorb the current responsibilities of:
-
- `cache` in `src/project/instance.ts`
- `boot(...)`
- most of `disposeInstance(...)`
- manual `reload(...)` / `disposeAll()` fan-out logic
-
-### Phase 5: shrink ALS to callback bridges only
-
-Keep ALS only where a library invokes callbacks outside the Effect fiber tree and we still need to call code that reads instance context synchronously.
-
-Known bridge cases today:
-
- `src/file/watcher.ts`
- `src/session/llm.ts`
- some LSP and plugin callback paths
-
-If those libraries become fully wrapped in Effect services, the remaining `Instance.bind(...)` uses can disappear too.
-
-### Phase 6: delete the legacy sync API
-
-Only after earlier phases land:
-
- remove broad use of `Instance.current`, `Instance.directory`, `Instance.worktree`, `Instance.project`
- reduce `src/project/instance.ts` to a thin compatibility shim or delete it entirely
- remove the ALS fallback from `InstanceState.context`
-
-## Inventory of direct legacy usage
-
-Direct legacy usage means any source file that still calls one of:
-
- `Instance.current`
- `Instance.directory`
- `Instance.worktree`
- `Instance.project`
- `Instance.provide(...)`
- `Instance.bind(...)`
- `Instance.restore(...)`
- `Instance.reload(...)`
- `Instance.dispose()` / `Instance.disposeAll()`
-
-Current total: `56` files in `packages/opencode/src`.
-
-### Core bridge and plumbing
-
-These files define or adapt the current bridge. They should change last, after callers have moved.
-
- `src/project/instance.ts`
- `src/effect/run-service.ts`
- `src/effect/instance-state.ts`
- `src/project/bootstrap.ts`
- `src/config/config.ts`
-
-Migration rule:
-
- keep these as compatibility glue until the outer boundaries and inner services stop depending on ALS
-
-### HTTP and server boundaries
-
-These are the current request-entry seams that still create or consume instance context through the legacy helper.
-
- `src/server/routes/instance/middleware.ts`
- `src/server/routes/instance/index.ts`
- `src/server/routes/instance/project.ts`
- `src/server/routes/control/workspace.ts`
- `src/server/routes/instance/file.ts`
- `src/server/routes/instance/experimental.ts`
- `src/server/routes/global.ts`
-
-Migration rule:
-
- move these to explicit Effect entrypoints that provide `InstanceRef` / `WorkspaceRef`
- do not move these first; first reduce the number of downstream handlers and services that still expect ambient ALS
-
-### CLI and TUI boundaries
-
-These commands still enter an instance through `Instance.provide(...)` or read sync getters directly.
-
- `src/cli/bootstrap.ts`
- `src/cli/cmd/agent.ts`
- `src/cli/cmd/debug/agent.ts`
- `src/cli/cmd/debug/ripgrep.ts`
- `src/cli/cmd/github.ts`
- `src/cli/cmd/import.ts`
- `src/cli/cmd/mcp.ts`
- `src/cli/cmd/models.ts`
- `src/cli/cmd/plug.ts`
- `src/cli/cmd/pr.ts`
- `src/cli/cmd/providers.ts`
- `src/cli/cmd/stats.ts`
- `src/cli/cmd/tui/attach.ts`
- `src/cli/cmd/tui/plugin/runtime.ts`
- `src/cli/cmd/tui/thread.ts`
- `src/cli/cmd/tui/worker.ts`
-
-Migration rule:
-
- converge these on one shared `withInstance(...)` Effect entry helper instead of open-coded `Instance.provide(...)`
- after that helper is proven, inline the legacy implementation behind an Effect-native scope provider
-
-### Tool boundary code
-
-These tools mostly use direct getters for path resolution and repo-relative display logic.
-
- `src/tool/apply_patch.ts`
- `src/tool/bash.ts`
- `src/tool/edit.ts`
- `src/tool/lsp.ts`
- `src/tool/plan.ts`
- `src/tool/read.ts`
- `src/tool/write.ts`
-
-Migration rule:
-
- expose the current instance as an explicit Effect dependency for tool execution
- keep path logic local; avoid introducing another global singleton for tool state
-
-### Effect services still reading ambient instance state
-
-These modules are already the best near-term migration targets because they are in Effect code but still read sync getters from the legacy helper.
-
- `src/agent/agent.ts`
- `src/cli/cmd/tui/config/tui-migrate.ts`
- `src/file/index.ts`
- `src/file/watcher.ts`
- `src/format/formatter.ts`
- `src/lsp/client.ts`
- `src/lsp/index.ts`
- `src/lsp/server.ts`
- `src/mcp/index.ts`
- `src/project/vcs.ts`
- `src/provider/provider.ts`
- `src/pty/index.ts`
- `src/session/session.ts`
- `src/session/instruction.ts`
- `src/session/llm.ts`
- `src/session/system.ts`
- `src/sync/index.ts`
- `src/worktree/index.ts`
-
-Migration rule:
-
- replace direct getter reads with `yield* InstanceState.context` or a yielded `ctx`
- isolate `Instance.bind(...)` callers and convert only the truly callback-driven edges to bridge mode
-
-### Highest-churn hotspots
-
-Current highest direct-usage counts by file:
-
- `src/file/index.ts` - `18`
- `src/lsp/server.ts` - `14`
- `src/worktree/index.ts` - `12`
- `src/file/watcher.ts` - `9`
- `src/cli/cmd/mcp.ts` - `8`
- `src/format/formatter.ts` - `8`
- `src/tool/apply_patch.ts` - `8`
- `src/cli/cmd/github.ts` - `7`
-
-These files should drive the first measurable burn-down.
-
-## Recommended implementation order
-
-1. Migrate direct getter reads inside Effect services, starting with `file`, `lsp`, `worktree`, `format`, and `session`.
-2. Add one shared Effect-native boundary helper for CLI / tool / HTTP entrypoints so we stop open-coding `Instance.provide(...)`.
-3. Move experimental `HttpApi` entrypoints to that helper so the new server stack proves the pattern.
-4. Convert remaining CLI and tool boundaries.
-5. Replace the promise cache with a keyed scoped runtime or keyed layer map.
-6. Delete ALS fallback paths once only callback bridges still depend on them.
-
-## Definition of done
-
-This migration is done when all of the following are true:
-
- new requests and commands enter an instance by providing Effect context, not ALS
- Effect services no longer read `Instance.directory`, `Instance.worktree`, `Instance.project`, or `Instance.current`
- `Instance.provide(...)` is gone from normal request / CLI / tool execution
- per-directory boot and disposal are handled by scoped Effect resources
- `Instance.bind(...)` is either gone or confined to a tiny set of native callback adapters
-
-## Tracker and worktree
-
-Active tracker items:
-
- `lh7l73` - overall `HttpApi` migration
- `yobwlk` - remove direct `Instance.*` reads inside Effect services
- `7irl1e` - replace `InstanceState` / legacy instance caching with keyed Effect layers
-
-Dedicated worktree for this transition:
-
- path: `/Users/kit/code/open-source/opencode-worktrees/instance-effect-shift`
- branch: `kit/instance-effect-shift`
+Do not add new ambient instance globals. Promise and callback boundaries should either stay in Effect, use `EffectBridge`, or pass the required context explicitly.
@@ -24,10 +24,6 @@ Small follow-ups that do not fit neatly into the main facade, route, tool, or sc
 - [ ] `cli/cmd/tui/config/tui.ts` - switch TUI config loading from async `ConfigPaths.*` wrappers to the `ConfigPaths.Service` once that service exists.
 - [ ] `cli/cmd/tui/config/tui-migrate.ts` - decide whether to leave this as a plain async module using wrapper functions or effectify it fully after `ConfigPaths.Service` lands.

-## Instance cleanup
-
- [ ] `project/instance.ts` - keep shrinking the legacy ALS / Promise cache after the remaining `Instance.*` callers move over.
-
 ## Notes

 - Prefer small, semantics-preserving config migrations. Config precedence, legacy key migration, and plugin origin tracking are easy to break accidentally.
@@ -64,13 +64,11 @@ P6  OA
  explicit and testable instead of mutable module state.
  Shrinks: [`global.ts`](../../../core/src/global.ts) import-time side
  effects, mutable `Global.Path` overrides, and its `Flag` dependency.
- `INST` Instance shim — remove ambient `Instance` usage and old ALS
-  access patterns.
-  Shrinks: [`src/project/instance.ts`](../../src/project/instance.ts).
+- `INST` Instance context — keep project context explicit through Effect refs
+  and bridge boundaries.
 - `BRIDGE` Promise/callback interop — keep bridge helpers, but reduce
  legacy ALS coupling.
-  Shrinks: [`src/effect/bridge.ts`](../../src/effect/bridge.ts)
-  dependency on [`project/instance.ts`](../../src/project/instance.ts).
+  Shrinks: ad hoc Promise/callback re-entry code.
 - `PROC` AppProcess migration — prefer `AppProcess.Service` over raw
  process wrappers.
  Shrinks: direct spawn callsites and legacy process helpers.
@@ -221,74 +219,13 @@ Next PR candidates:

 ## P4: Instance And Bridge

-[`project/instance.ts`](../../src/project/instance.ts) is the deletion
-target. [`effect/bridge.ts`](../../src/effect/bridge.ts) is not a near-term
-deletion target; Promise/callback interop will continue to exist.
+Instance context migration is complete for the legacy sync shim. Promise and callback interop continues through [`effect/bridge.ts`](../../src/effect/bridge.ts).

-Goal:
+Current rules:

- Keep a sanctioned bridge for Promise/callback boundaries.
- Reduce bridge dependence on legacy `Instance.restore` / `Instance.current`.
- Move callers toward `InstanceRef`, `WorkspaceRef`, `InstanceState`, or
-  explicit context where practical.
- Delete `project/instance.ts` only after ambient Instance coupling is gone.
-
-Important distinction:
-
- `InstanceState.context`, `InstanceState.directory`, and
-  `InstanceState.workspaceID` are acceptable inside normal Effect service
-  code when `InstanceRef` / `WorkspaceRef` are provided by the runtime.
- The deletion blockers are the fallback and callback paths that rely on
-  ambient ALS: direct `Instance.*` reads, `InstanceState.bind(...)`,
-  `AppRuntime.runPromise(...)` re-entry from plain JS, and bridge restore
-  code that installs legacy ALS before invoking callbacks.
-
-Current bottom-up inventory from `dev`:
-
- Direct `Instance.*` value readers:
-  [`tool/repo_overview.ts`](../../src/tool/repo_overview.ts),
-  [`control-plane/adapters/worktree.ts`](../../src/control-plane/adapters/worktree.ts),
-  [`cli/bootstrap.ts`](../../src/cli/bootstrap.ts).
- `InstanceState.bind(...)` callback boundaries:
-  [`file/watcher.ts`](../../src/file/watcher.ts) native watcher callback,
-  [`storage/db.ts`](../../src/storage/db.ts) transaction/effect callbacks,
-  [`session/llm.ts`](../../src/session/llm.ts) workflow approval callback.
- `AppRuntime.runPromise(...)` / re-entry from plain JS:
-  [`project/with-instance.ts`](../../src/project/with-instance.ts),
-  [`project/instance-runtime.ts`](../../src/project/instance-runtime.ts),
-  [`control-plane/adapters/worktree.ts`](../../src/control-plane/adapters/worktree.ts),
-  [`cli/effect-cmd.ts`](../../src/cli/effect-cmd.ts), plus global/non-instance
-  callsites such as CLI upgrade and ACP agent defaults.
- Intentional bridge users to classify, not delete blindly:
-  workspace adapters in [`control-plane/workspace.ts`](../../src/control-plane/workspace.ts),
-  MCP, command execution, plugins, pty lifecycle, bus scope cleanup, task
-  cancellation, and HTTP lifecycle reload/dispose paths.
- Core fallback layer to shrink last:
-  [`effect/run-service.ts`](../../src/effect/run-service.ts),
-  [`effect/bridge.ts`](../../src/effect/bridge.ts), and
-  [`effect/instance-state.ts`](../../src/effect/instance-state.ts).
-
-Recommended PR order:
-
- [ ] `INST-1` Remove direct `Instance.*` value readers. Start with
-      `repo_overview`, `worktree` adapter, and `cli/bootstrap`; pass context
-      explicitly or obtain it from an Effect boundary.
- [ ] `INST-2` Move type-only `InstanceContext` imports from
-      [`project/instance.ts`](../../src/project/instance.ts) to
-      [`project/instance-context.ts`](../../src/project/instance-context.ts).
- [ ] `INST-3` Audit each `InstanceState.bind(...)` callback from the inside
-      out: list what the callback calls (`Bus.publish`, database effects,
-      permission/session services), then replace ambient capture with explicit
-      `InstanceRef` / `WorkspaceRef` provision or an `EffectBridge` call.
- [ ] `INST-4` Classify `AppRuntime.runPromise(...)` callsites as global,
-      instance-scoped with explicit refs, or bridge-required. Eliminate the
-      instance-scoped callsites that rely on `run-service.attach()` falling
-      back to `Instance.current`.
- [ ] `INST-5` After consumers are explicit, remove `Instance.current` fallback
-      from `InstanceState.context` and `run-service.attach()`.
- [ ] `INST-6` Move any remaining `restore` / `bind` compatibility helpers to
-      the boundary that still needs them, then delete
-      [`project/instance.ts`](../../src/project/instance.ts).
+- Effect services read instance data from `InstanceRef`, `WorkspaceRef`, `InstanceState`, or explicit arguments.
+- Plain JavaScript callback boundaries use `EffectBridge` or explicit context arguments.
+- Runtime entrypoints must provide refs explicitly when they are instance-scoped.

 ## Lower Priority Tracks

@@ -39,10 +39,9 @@ import { Filesystem } from "@/util/filesystem"
 import { Hash } from "@opencode-ai/core/util/hash"
 import { ACPSessionManager } from "./session"
 import type { ACPConfig } from "./types"
+import { ACPRuntime } from "./runtime"
 import { Provider } from "@/provider/provider"
 import { ModelID, ProviderID } from "../provider/schema"
-import { Agent as AgentModule } from "../agent/agent"
-import { AppRuntime } from "@/effect/app-runtime"
 import { Installation } from "@/installation"
 import { MessageV2 } from "@/session/message-v2"
 import { Config } from "@/config/config"
@@ -1094,7 +1093,7 @@ export class Agent implements ACPAgent {

    const currentModeId = await (async () => {
      if (!availableModes.length) return undefined
-      const defaultAgent = await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultInfo()))
+      const defaultAgent = await ACPRuntime.defaultAgentInfo(directory)
      const resolvedModeId = availableModes.find((mode) => mode.name === defaultAgent.name)?.id ?? availableModes[0].id
      this.sessionManager.setMode(sessionId, resolvedModeId)
      return resolvedModeId
@@ -1328,8 +1327,7 @@ export class Agent implements ACPAgent {
    if (!current) {
      this.sessionManager.setModel(session.id, model)
    }
-    const agent =
-      session.modeId ?? (await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultInfo()))).name
+    const agent = session.modeId ?? (await ACPRuntime.defaultAgentInfo(directory)).name

    const parts: Array<
      | { type: "text"; text: string; synthetic?: boolean; ignored?: boolean }
@@ -0,0 +1,22 @@
+import { Agent } from "@/agent/agent"
+import { AppRuntime, type AppServices } from "@/effect/app-runtime"
+import { InstanceRef } from "@/effect/instance-ref"
+import { InstanceRuntime } from "@/project/instance-runtime"
+import { Effect } from "effect"
+
+// Global ACP Effect re-entry: no project InstanceRef is provided.
+export const runGlobal = AppRuntime.runPromise
+
+// Directory-scoped ACP Effect re-entry: load the project instance and provide InstanceRef.
+export async function runDirectory<A, E>(input: { directory: string; effect: Effect.Effect<A, E, AppServices> }) {
+  const ctx = await InstanceRuntime.load({ directory: input.directory })
+  return AppRuntime.runPromise(input.effect.pipe(Effect.provideService(InstanceRef, ctx)))
+}
+
+export const defaultAgentInfo = (directory: string) =>
+  runDirectory({
+    directory,
+    effect: Agent.Service.use((svc) => svc.defaultInfo()),
+  })
+
+export * as ACPRuntime from "./runtime"
@@ -1,4 +1,5 @@
 import { Schema } from "effect"
+import { EventV2 } from "@opencode-ai/core/event"

 export type Definition<Type extends string = string, Properties extends Schema.Top = Schema.Top> = {
  type: Type
@@ -17,16 +18,28 @@ export function define<Type extends string, Properties extends Schema.Top>(
 }

 export function effectPayloads() {
-  return registry
-    .entries()
-    .map(([type, def]) =>
-      Schema.Struct({
-        id: Schema.String,
-        type: Schema.Literal(type),
-        properties: def.properties,
-      }).annotate({ identifier: `Event.${type}` }),
-    )
-    .toArray()
+  return [
+    ...registry
+      .entries()
+      .map(([type, def]) =>
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.Literal(type),
+          properties: def.properties,
+        }).annotate({ identifier: `Event.${type}` }),
+      )
+      .toArray(),
+    ...EventV2.registry
+      .values()
+      .map((definition) =>
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.Literal(definition.type),
+          properties: definition.data,
+        }).annotate({ identifier: `Event.${definition.type}` }),
+      )
+      .toArray(),
+  ]
 }

 export * as BusEvent from "./bus-event"
@@ -1,17 +1,11 @@
-import { Instance } from "../project/instance"
 import { InstanceRuntime } from "../project/instance-runtime"
-import { WithInstance } from "../project/with-instance"
+import { context } from "../project/instance-context"

 export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
-  return WithInstance.provide({
-    directory,
-    fn: async () => {
-      try {
-        const result = await cb()
-        return result
-      } finally {
-        await InstanceRuntime.disposeInstance(Instance.current)
-      }
-    },
-  })
+  const ctx = await InstanceRuntime.load({ directory })
+  try {
+    return await context.provide(ctx, cb)
+  } finally {
+    await InstanceRuntime.disposeInstance(ctx)
+  }
 }
@@ -11,7 +11,7 @@ import { Permission } from "../../../permission"
 import { iife } from "../../../util/iife"
 import { effectCmd, fail } from "../../effect-cmd"
 import { InstanceRef } from "@/effect/instance-ref"
-import type { InstanceContext } from "@/project/instance"
+import type { InstanceContext } from "@/project/instance-context"

 export const AgentCommand = effectCmd({
  command: "agent <name>",
@@ -1,11 +1,11 @@
 import { EOL } from "os"
 import { Effect, Layer, Option } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { InstanceServiceMap } from "@opencode-ai/core/instance-layer"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
 import { effectCmd } from "../../effect-cmd"

-const Runtime = Layer.mergeAll(InstanceServiceMap.layer)
+const Runtime = Layer.mergeAll(LocationServiceMap.layer)

 export const V2Command = effectCmd({
  command: "v2",
@@ -37,7 +37,7 @@ export const V2Command = effectCmd({
      process.stdout.write(JSON.stringify(result, null, 2) + EOL)
    },
    Effect.provide(
-      InstanceServiceMap.get({
+      LocationServiceMap.get({
        directory: process.cwd(),
      }),
    ),
@@ -1,11 +1,20 @@
 const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })

+function promptOffsetWidth(value: string) {
+  let width = 0
+  for (const part of graphemes.segment(value)) {
+    // Textarea offsets count newlines as one position; Bun.stringWidth counts them as zero.
+    width += part.segment === "\n" ? 1 : Bun.stringWidth(part.segment)
+  }
+  return width
+}
+
 function displayOffsetIndex(value: string, offset: number) {
  if (offset <= 0) return 0

  let width = 0
  for (const part of graphemes.segment(value)) {
-    const next = width + Bun.stringWidth(part.segment)
+    const next = width + promptOffsetWidth(part.segment)
    if (next > offset) return part.index
    width = next
  }
@@ -13,20 +22,20 @@ function displayOffsetIndex(value: string, offset: number) {
  return value.length
 }

-export function displaySlice(value: string, start = 0, end = Bun.stringWidth(value)) {
+export function displaySlice(value: string, start = 0, end = promptOffsetWidth(value)) {
  return value.slice(displayOffsetIndex(value, start), displayOffsetIndex(value, end))
 }

 export function displayCharAt(value: string, offset: number) {
  let width = 0
  for (const part of graphemes.segment(value)) {
-    const next = width + Bun.stringWidth(part.segment)
+    const next = width + promptOffsetWidth(part.segment)
    if (offset === width || offset < next) return part.segment
    width = next
  }
 }

-export function mentionTriggerIndex(value: string, offset = Bun.stringWidth(value)) {
+export function mentionTriggerIndex(value: string, offset = promptOffsetWidth(value)) {
  const text = displaySlice(value, 0, offset)
  const index = text.lastIndexOf("@")
  if (index === -1) return
@@ -34,6 +43,6 @@ export function mentionTriggerIndex(value: string, offset = Bun.stringWidth(valu
  const before = index === 0 ? undefined : text[index - 1]
  const query = text.slice(index)
  if ((before === undefined || /\s/.test(before)) && !/\s/.test(query)) {
-    return Bun.stringWidth(text.slice(0, index))
+    return promptOffsetWidth(text.slice(0, index))
  }
 }
@@ -76,8 +76,6 @@ const appBindingCommands = [
  "command.palette.show",
  "session.list",
  "session.new",
-  "session.cycle_recent",
-  "session.cycle_recent_reverse",
  "session.quick_switch.1",
  "session.quick_switch.2",
  "session.quick_switch.3",
@@ -481,37 +479,15 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
          dialog.clear()
        },
      },
-      ...(Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING
-        ? [
-            {
-              name: "session.cycle_recent",
-              title: "Cycle to previous recent session",
-              category: "Session",
-              hidden: true,
-              run: () => {
-                local.session.cycleRecent(1)
-              },
-            },
-            {
-              name: "session.cycle_recent_reverse",
-              title: "Cycle to next recent session",
-              category: "Session",
-              hidden: true,
-              run: () => {
-                local.session.cycleRecent(-1)
-              },
-            },
-            ...Array.from({ length: 9 }, (_, i) => ({
-              name: `session.quick_switch.${i + 1}`,
-              title: `Switch to session in quick slot ${i + 1}`,
-              category: "Session",
-              hidden: true,
-              run: () => {
-                local.session.quickSwitch(i + 1)
-              },
-            })),
-          ]
-        : []),
+      ...Array.from({ length: 9 }, (_, i) => ({
+        name: `session.quick_switch.${i + 1}`,
+        title: `Switch to session in quick slot ${i + 1}`,
+        category: "Session",
+        hidden: true,
+        run: () => {
+          local.session.quickSwitch(i + 1)
+        },
+      })),
      {
        name: "model.list",
        title: "Switch model",
@@ -826,14 +802,7 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {

  useBindings(() => ({
    enabled: command.matcher,
-    bindings: tuiConfig.keybinds.gather(
-      "app",
-      Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING
-        ? appBindingCommands
-        : appBindingCommands.filter(
-            (c) => !c.startsWith("session.cycle_recent") && !c.startsWith("session.quick_switch"),
-          ),
-    ),
+    bindings: tuiConfig.keybinds.gather("app", appBindingCommands),
  }))

  useBindings(() => ({
@@ -31,6 +31,8 @@ export function DialogSessionList() {
  const [toDelete, setToDelete] = createSignal<string>()
  const [search, setSearch] = createDebouncedSignal("", 150)
  const deleteHint = useCommandShortcut("session.delete")
+  const quickSwitch1 = useCommandShortcut("session.quick_switch.1")
+  const quickSwitch9 = useCommandShortcut("session.quick_switch.9")

  const [searchResults, { refetch }] = createResource(
    () => ({ query: search(), filter: sync.session.query() }),
@@ -130,10 +132,18 @@ export function DialogSessionList() {

  const [browseOrder] = createSignal<string[]>(orderByRecency(sync.data.session))

-  const RECENT_LIMIT = 5
+  const quickSwitchHint = createMemo(() => {
+    const first = quickSwitch1()
+    const last = quickSwitch9()
+    if (!first || !last) return undefined
+    return quickSwitchRange(first, last)
+  })
+  const quickSwitchFooterHints = createMemo(() => {
+    const hint = quickSwitchHint()
+    return hint && local.session.slots().length > 0 ? [{ title: "switch", label: hint }] : []
+  })

  const options = createMemo(() => {
-    const enabled = Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING
    const today = new Date().toDateString()
    const sessionMap = new Map(
      sessions()
@@ -144,17 +154,9 @@ export function DialogSessionList() {
    const searchResult = searchResults()
    const displayOrder = searchResult ? orderByRecency(searchResult) : browseOrder()

-    const dismissed = enabled ? new Set(local.session.dismissedRecent()) : new Set<string>()
-    const pinned = enabled ? local.session.pinned().filter((id) => sessionMap.has(id)) : []
+    const pinned = local.session.pinned().filter((id) => sessionMap.has(id))
    const pinnedSet = new Set(pinned)
-    const slotByID = enabled
-      ? new Map<string, number>(local.session.slots().map((id, i) => [id, i + 1]))
-      : new Map<string, number>()
-
-    const recent = enabled
-      ? displayOrder.filter((id) => !pinnedSet.has(id) && !dismissed.has(id)).slice(0, RECENT_LIMIT)
-      : []
-    const recentSet = new Set(recent)
+    const slotByID = new Map<string, number>(local.session.slots().map((id, i) => [id, i + 1]))

    function buildOption(id: string, category: string) {
      const x = sessionMap.get(id)
@@ -198,7 +200,7 @@ export function DialogSessionList() {
    }

    const remaining = displayOrder
-      .filter((id) => !pinnedSet.has(id) && !recentSet.has(id))
+      .filter((id) => !pinnedSet.has(id))
      .map((id) => {
        const x = sessionMap.get(id)
        if (!x) return undefined
@@ -207,11 +209,7 @@ export function DialogSessionList() {
      })
      .filter((x) => x !== undefined)

-    return [
-      ...pinned.map((id) => buildOption(id, "Pinned")).filter((x) => x !== undefined),
-      ...recent.map((id) => buildOption(id, "Recent")).filter((x) => x !== undefined),
-      ...remaining,
-    ]
+    return [...pinned.map((id) => buildOption(id, "Pinned")).filter((x) => x !== undefined), ...remaining]
  })

  onMount(() => {
@@ -236,32 +234,13 @@ export function DialogSessionList() {
        dialog.clear()
      }}
      actions={[
-        ...(Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING
-          ? [
-              {
-                command: "session.pin.toggle",
-                title: "pin/unpin",
-                onTrigger: (option: { value: string }) => {
-                  local.session.togglePin(option.value)
-                },
-              },
-              {
-                command: "session.toggle.recent",
-                title: "toggle recent",
-                onTrigger: (option: { value: string }) => {
-                  if (local.session.isPinned(option.value)) {
-                    toast.show({
-                      variant: "info",
-                      message: "Unpin the session first to toggle it in Recent",
-                      duration: 3000,
-                    })
-                    return
-                  }
-                  local.session.toggleRecent(option.value)
-                },
-              },
-            ]
-          : []),
+        {
+          command: "session.pin.toggle",
+          title: "pin/unpin",
+          onTrigger: (option: { value: string }) => {
+            local.session.togglePin(option.value)
+          },
+        },
        {
          command: "session.delete",
          title: "delete",
@@ -318,6 +297,13 @@ export function DialogSessionList() {
          },
        },
      ]}
+      footerHints={quickSwitchFooterHints()}
    />
  )
 }
+
+function quickSwitchRange(first: string, last: string) {
+  const prefix = first.slice(0, -1)
+  if (first.endsWith("1") && last === `${prefix}9`) return `${prefix}1-9`
+  return `${first} through ${last}`
+}
@@ -87,9 +87,6 @@ export const Definitions = {
  session_child_cycle_reverse: keybind("left", "Go to previous child session"),
  session_parent: keybind("up", "Go to parent session"),
  session_pin_toggle: keybind("ctrl+f", "Pin or unpin session in the session list"),
-  session_toggle_recent: keybind("ctrl+h", "Show or hide session in the Recent group"),
-  session_cycle_recent: keybind("<leader>]", "Cycle to the previous recent session"),
-  session_cycle_recent_reverse: keybind("<leader>[", "Cycle to the next recent session"),
  session_quick_switch_1: keybind("<leader>1", "Switch to session in quick slot 1"),
  session_quick_switch_2: keybind("<leader>2", "Switch to session in quick slot 2"),
  session_quick_switch_3: keybind("<leader>3", "Switch to session in quick slot 3"),
@@ -273,9 +270,6 @@ export const CommandMap = {
  session_child_cycle_reverse: "session.child.previous",
  session_parent: "session.parent",
  session_pin_toggle: "session.pin.toggle",
-  session_toggle_recent: "session.toggle.recent",
-  session_cycle_recent: "session.cycle_recent",
-  session_cycle_recent_reverse: "session.cycle_recent_reverse",
  session_quick_switch_1: "session.quick_switch.1",
  session_quick_switch_2: "session.quick_switch.2",
  session_quick_switch_3: "session.quick_switch.3",
@@ -1,6 +1,6 @@
 import { createStore } from "solid-js/store"
 import { createSimpleContext } from "./helper"
-import { batch, createEffect, createMemo, on } from "solid-js"
+import { batch, createEffect, createMemo } from "solid-js"
 import { useSync } from "@tui/context/sync"
 import { useTheme } from "@tui/context/theme"
 import { useRoute } from "@tui/context/route"
@@ -8,7 +8,6 @@ import { useEvent } from "@tui/context/event"
 import { uniqueBy } from "remeda"
 import path from "path"
 import { Global } from "@opencode-ai/core/global"
-import { Flag } from "@opencode-ai/core/flag/flag"
 import { iife } from "@/util/iife"
 import { useToast } from "../ui/toast"
 import { useArgs } from "./args"
@@ -387,13 +386,9 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
      const [sessionStore, setSessionStore] = createStore<{
        ready: boolean
        pinned: string[]
-        dismissedRecent: string[]
-        recentOrder: string[]
      }>({
        ready: false,
        pinned: [],
-        dismissedRecent: [],
-        recentOrder: [],
      })

      const filePath = path.join(Global.Path.state, "session.json")
@@ -409,16 +404,12 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        state.pending = false
        void Filesystem.writeJson(filePath, {
          pinned: sessionStore.pinned,
-          dismissedRecent: sessionStore.dismissedRecent,
-          recentOrder: sessionStore.recentOrder,
        })
      }

      Filesystem.readJson(filePath)
        .then((x: any) => {
          if (Array.isArray(x.pinned)) setSessionStore("pinned", x.pinned)
-          if (Array.isArray(x.dismissedRecent)) setSessionStore("dismissedRecent", x.dismissedRecent)
-          if (Array.isArray(x.recentOrder)) setSessionStore("recentOrder", x.recentOrder)
        })
        .catch(() => {})
        .finally(() => {
@@ -428,19 +419,10 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({

      const route = useRoute()
      const event = useEvent()
-      let cycling = false

      const slots = createMemo(() => {
-        const rootSessions = sync.data.session.filter((x) => x.parentID === undefined)
-        const existing = new Set(rootSessions.map((x) => x.id))
-        const dismissed = new Set(sessionStore.dismissedRecent)
-        const pins = sessionStore.pinned.filter((id) => existing.has(id))
-        const pinnedSet = new Set(pins)
-        const recent = rootSessions
-          .filter((x) => !pinnedSet.has(x.id) && !dismissed.has(x.id))
-          .toSorted((a, b) => b.time.updated - a.time.updated)
-          .map((x) => x.id)
-        return [...pins, ...recent].slice(0, 9)
+        const existing = new Set(sync.data.session.filter((x) => x.parentID === undefined).map((x) => x.id))
+        return sessionStore.pinned.filter((id) => existing.has(id)).slice(0, 9)
      })

      function prune(sessionID: string) {
@@ -451,18 +433,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
              sessionStore.pinned.filter((x) => x !== sessionID),
            )
          }
-          if (sessionStore.dismissedRecent.includes(sessionID)) {
-            setSessionStore(
-              "dismissedRecent",
-              sessionStore.dismissedRecent.filter((x) => x !== sessionID),
-            )
-          }
-          if (sessionStore.recentOrder.includes(sessionID)) {
-            setSessionStore(
-              "recentOrder",
-              sessionStore.recentOrder.filter((x) => x !== sessionID),
-            )
-          }
          save()
        })
      }
@@ -471,25 +441,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        prune(evt.properties.info.id)
      })

-      if (Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING) {
-        createEffect(
-          on(
-            () => (sessionStore.ready && route.data.type === "session" ? route.data.sessionID : undefined),
-            (sessionID) => {
-              if (!sessionID) return
-              if (cycling) {
-                cycling = false
-                return
-              }
-              const filtered = sessionStore.recentOrder.filter((x) => x !== sessionID)
-              const next = [sessionID, ...filtered].slice(0, 20)
-              setSessionStore("recentOrder", next)
-              save()
-            },
-          ),
-        )
-      }
-
      return {
        get ready() {
          return sessionStore.ready
@@ -497,19 +448,10 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
        pinned() {
          return sessionStore.pinned
        },
-        dismissedRecent() {
-          return sessionStore.dismissedRecent
-        },
-        recentOrder() {
-          return sessionStore.recentOrder
-        },
        slots,
        isPinned(sessionID: string) {
          return sessionStore.pinned.includes(sessionID)
        },
-        isDismissed(sessionID: string) {
-          return sessionStore.dismissedRecent.includes(sessionID)
-        },
        togglePin(sessionID: string) {
          batch(() => {
            const exists = sessionStore.pinned.includes(sessionID)
@@ -520,52 +462,12 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
            save()
          })
        },
-        toggleRecent(sessionID: string) {
-          batch(() => {
-            const exists = sessionStore.dismissedRecent.includes(sessionID)
-            const next = exists
-              ? sessionStore.dismissedRecent.filter((x) => x !== sessionID)
-              : [sessionID, ...sessionStore.dismissedRecent]
-            setSessionStore("dismissedRecent", next)
-            save()
-          })
-        },
        quickSwitch(slot: number) {
          const target = slots()[slot - 1]
          if (!target) return
          if (route.data.type === "session" && route.data.sessionID === target) return
          route.navigate({ type: "session", sessionID: target })
        },
-        cycleRecent(direction: 1 | -1) {
-          if (route.data.type !== "session") {
-            toast.show({
-              variant: "info",
-              message: "Open a session first to cycle between recent sessions",
-              duration: 3000,
-            })
-            return
-          }
-          const current = route.data.sessionID
-          const order = sessionStore.recentOrder.filter((id) =>
-            sync.data.session.some((s) => s.id === id && s.parentID === undefined),
-          )
-          if (order.length < 2) {
-            toast.show({
-              variant: "info",
-              message: "No other recent sessions to cycle to",
-              duration: 3000,
-            })
-            return
-          }
-          const index = order.indexOf(current)
-          if (index === -1) return
-          const next = index + direction
-          if (next < 0 || next >= order.length) return
-          const target = order[next]
-          if (!target || target === current) return
-          cycling = true
-          route.navigate({ type: "session", sessionID: target })
-        },
      }
    })

@@ -0,0 +1,67 @@
+import { createMemo, type Setter } from "solid-js"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { useKV } from "./kv"
+
+export type ThinkingMode = "show" | "minimal" | "hide"
+
+const MODES: readonly ThinkingMode[] = ["show", "minimal", "hide"] as const
+
+// OpenAI's Responses API surfaces reasoning summaries that start with a bolded
+// title line: "**Inspecting PR workflow**\n\n<body>". GitHub Copilot routes
+// through the same shape, and the opencode provider relays it too. Pull the
+// title out for a nicer label; return null for providers that don't follow
+// this convention so the caller can fall back to a generic "Thinking" string.
+export function reasoningTitle(text: string): string | null {
+  const match = text.trimStart().match(/^\*\*([^*\n]+)\*\*/)
+  return match ? match[1].trim() : null
+}
+
+export function isThinkingMode(value: unknown): value is ThinkingMode {
+  return typeof value === "string" && (MODES as readonly string[]).includes(value)
+}
+
+// Cycle order matches the slash command: show → minimal → hide → show.
+export function nextThinkingMode(current: ThinkingMode): ThinkingMode {
+  const idx = MODES.indexOf(current)
+  return MODES[(idx + 1) % MODES.length] ?? "show"
+}
+
+export function useThinkingMode() {
+  const kv = useKV()
+  // Capture pre-state before `kv.signal` seeds a default, so we can detect
+  // first-time users with a legacy `thinking_visibility` boolean and migrate.
+  // The KVProvider only renders children once kv.ready, so reads here are safe.
+  const hadStored = kv.get("thinking_mode") !== undefined
+  const legacy = kv.get("thinking_visibility")
+  const [stored, setStored] = kv.signal<ThinkingMode>("thinking_mode", "minimal")
+
+  // The kv signal exposes its setter typed as `Setter<T>` which carries Solid's
+  // overload set; passing an updater fn through a property access loses the
+  // bivariance trick the existing `setX((prev) => ...)` callsites rely on.
+  // Wrap it in a sane shape so consumers can just call `set(next)` or pass
+  // an updater.
+  const set = (next: ThinkingMode | ((prev: ThinkingMode) => ThinkingMode)) => {
+    if (typeof next === "function") setStored(next as Setter<ThinkingMode>)
+    else setStored(() => next)
+  }
+
+  // Preserve previous experience for users who had explicitly toggled the
+  // legacy `thinking_visibility` boolean. First-time users (no legacy key)
+  // get the new "minimal" default.
+  if (!hadStored) {
+    if (legacy === true) set("show")
+    else if (legacy === false) set("hide")
+  }
+
+  const mode = createMemo<ThinkingMode>(() => {
+    if (Flag.OPENCODE_EXPERIMENTAL_MINIMAL_THINKING) return "minimal"
+    const value = stored()
+    return isThinkingMode(value) ? value : "minimal"
+  })
+
+  return {
+    mode,
+    set,
+    locked: () => Flag.OPENCODE_EXPERIMENTAL_MINIMAL_THINKING === true,
+  }
+}
@@ -1,7 +1,6 @@
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
 import { createMemo, For, type Accessor } from "solid-js"
 import { DEFAULT_THEMES, useTheme } from "@tui/context/theme"
-import { Flag } from "@opencode-ai/core/flag/flag"
 import { useCommandShortcut } from "../../keymap"

 const themeCount = Object.keys(DEFAULT_THEMES).length
@@ -29,8 +28,6 @@ type Shortcuts = {
  messagesToggleConceal: TipShortcut
  modelCycleRecent: TipShortcut
  modelList: TipShortcut
-  sessionCycleRecent: TipShortcut
-  sessionCycleRecentReverse: TipShortcut
  sessionExport: TipShortcut
  sessionInterrupt: TipShortcut
  sessionList: TipShortcut
@@ -41,7 +38,6 @@ type Shortcuts = {
  sessionQuickSwitch9: TipShortcut
  sessionSidebarToggle: TipShortcut
  sessionTimeline: TipShortcut
-  sessionToggleRecent: TipShortcut
  statusView: TipShortcut
  terminalSuspend: TipShortcut
  themeList: TipShortcut
@@ -73,6 +69,7 @@ function parse(tip: string): TipPart[] {
 }

 const NO_MODELS_TIP = "Run {highlight}/connect{/highlight} to add an AI provider and start coding"
+const NO_MODELS_PARTS = parse(NO_MODELS_TIP)

 function shortcutText(value: string) {
  return `{highlight}${value}{/highlight}`
@@ -121,8 +118,6 @@ export function Tips(props: { api: TuiPluginApi; connected?: boolean }) {
    messagesToggleConceal: configShortcut(props.api, "session.toggle.conceal"),
    modelCycleRecent: useCommandShortcut("model.cycle_recent"),
    modelList: useCommandShortcut("model.list"),
-    sessionCycleRecent: useCommandShortcut("session.cycle_recent"),
-    sessionCycleRecentReverse: useCommandShortcut("session.cycle_recent_reverse"),
    sessionExport: configShortcut(props.api, "session.export"),
    sessionInterrupt: configShortcut(props.api, "session.interrupt"),
    sessionList: useCommandShortcut("session.list"),
@@ -133,7 +128,6 @@ export function Tips(props: { api: TuiPluginApi; connected?: boolean }) {
    sessionQuickSwitch9: useCommandShortcut("session.quick_switch.9"),
    sessionSidebarToggle: configShortcut(props.api, "session.sidebar.toggle"),
    sessionTimeline: configShortcut(props.api, "session.timeline"),
-    sessionToggleRecent: configShortcut(props.api, "session.toggle.recent"),
    statusView: useCommandShortcut("opencode.status"),
    terminalSuspend: useCommandShortcut("terminal.suspend"),
    themeList: useCommandShortcut("theme.switch"),
@@ -145,8 +139,13 @@ export function Tips(props: { api: TuiPluginApi; connected?: boolean }) {
      return value ? [value] : []
    })
    return tips[Math.floor(tipOffset * tips.length)] ?? NO_MODELS_TIP
-  })
-  const parts = createMemo(() => parse(tip()))
+  }, NO_MODELS_TIP)
+  // Solid can expose a memo's initial value while a pure computation is pending.
+  const parts = createMemo(() => {
+    const value = tip()
+    if (typeof value === "string") return parse(value)
+    return NO_MODELS_PARTS
+  }, NO_MODELS_PARTS)

  return (
    <box flexDirection="row" maxWidth="100%">
@@ -176,23 +175,12 @@ const TIPS: Tip[] = [
  (shortcuts) => `Use ${commandText("/models", shortcuts.modelList())} to see and switch between available AI models`,
  (shortcuts) => `Use ${commandText("/themes", shortcuts.themeList())} to switch between ${themeCount} built-in themes`,
  (shortcuts) => `Use ${commandText("/new", shortcuts.sessionNew())} to start a fresh conversation session`,
-  (shortcuts) => `Use ${commandText("/sessions", shortcuts.sessionList())} to list and continue previous conversations`,
-  ...(Flag.OPENCODE_EXPERIMENTAL_SESSION_SWITCHING
-    ? ([
-        (shortcuts) =>
-          press(shortcuts.sessionPinToggle(), "in the session list to pin a session so it stays at the top"),
-        (shortcuts) =>
-          shortcuts.sessionQuickSwitch1() && shortcuts.sessionQuickSwitch9()
-            ? `Pinned and recent sessions are bound to ${shortcutText(shortcuts.sessionQuickSwitch1())} through ${shortcutText(shortcuts.sessionQuickSwitch9())} for one-press switching`
-            : undefined,
-        (shortcuts) =>
-          shortcuts.sessionCycleRecent() && shortcuts.sessionCycleRecentReverse()
-            ? `Press ${shortcutText(shortcuts.sessionCycleRecent())} / ${shortcutText(shortcuts.sessionCycleRecentReverse())} to cycle through recently visited sessions`
-            : undefined,
-        (shortcuts) =>
-          press(shortcuts.sessionToggleRecent(), "in the session list to show or hide a session in the Recent group"),
-      ] satisfies Tip[])
-    : []),
+  (shortcuts) => `Use ${commandText("/sessions", shortcuts.sessionList())} to list, pin, and continue sessions`,
+  (shortcuts) => press(shortcuts.sessionPinToggle(), "in the session list to pin a session so it stays at the top"),
+  (shortcuts) =>
+    shortcuts.sessionQuickSwitch1() && shortcuts.sessionQuickSwitch9()
+      ? `Pinned sessions are assigned quick slots; use ${shortcutText(shortcuts.sessionQuickSwitch1())} through ${shortcutText(shortcuts.sessionQuickSwitch9())} to switch`
+      : undefined,
  "Run {highlight}/compact{/highlight} to summarize long sessions near context limits",
  (shortcuts) => `Use ${commandText("/export", shortcuts.sessionExport())} to save the conversation as Markdown`,
  (shortcuts) => press(shortcuts.messagesCopy(), "to copy the assistant's last message to clipboard"),
@@ -5,6 +5,7 @@ import { SplitBorder } from "@tui/component/border"
 import { Spinner } from "@tui/component/spinner"
 import { useTheme } from "@tui/context/theme"
 import { useLocal } from "@tui/context/local"
+import { reasoningTitle, useThinkingMode } from "@tui/context/thinking"
 import { useRenderer, useTerminalDimensions, type JSX } from "@opentui/solid"
 import { TextAttributes, type BoxRenderable, type SyntaxStyle } from "@opentui/core"
 import { useBindings } from "../../keymap"
@@ -317,7 +318,11 @@ function AssistantMessage(props: {
              <AssistantText part={part as SessionMessageAssistantText} syntax={props.syntax} />
            </Match>
            <Match when={part.type === "reasoning"}>
-              <AssistantReasoning part={part as SessionMessageAssistantReasoning} subtleSyntax={props.subtleSyntax} />
+              <AssistantReasoning
+                part={part as SessionMessageAssistantReasoning}
+                subtleSyntax={props.subtleSyntax}
+                completedAt={() => props.message.time.completed}
+              />
            </Match>
            <Match when={part.type === "tool"}>
              <AssistantTool part={part as SessionMessageAssistantTool} sessionID={props.sessionID} />
@@ -378,30 +383,64 @@ function AssistantText(props: { part: SessionMessageAssistantText; syntax: Synta
  )
 }

-function AssistantReasoning(props: { part: SessionMessageAssistantReasoning; subtleSyntax: SyntaxStyle }) {
+function AssistantReasoning(props: {
+  part: SessionMessageAssistantReasoning
+  subtleSyntax: SyntaxStyle
+  completedAt: () => number | undefined
+}) {
  const { theme } = useTheme()
+  const thinking = useThinkingMode()
+  const [expanded, setExpanded] = createSignal(false)
  const content = createMemo(() => props.part.text.replace("[REDACTED]", "").trim())
+  const inMinimal = createMemo(() => thinking.mode() === "minimal")
+  // v2 reasoning parts have no per-part `time.end` (see SessionMessageAssistantReasoning
+  // in the v2 SDK); we settle on parent-message completion instead.
+  const isDone = createMemo(() => props.completedAt() !== undefined)
+  const title = createMemo(() => reasoningTitle(content()))
+
+  const toggle = () => {
+    if (!inMinimal()) return
+    setExpanded((prev) => !prev)
+  }
+
  return (
-    <Show when={content()}>
-      <box
-        paddingLeft={2}
-        marginTop={1}
-        flexDirection="column"
-        border={["left"]}
-        customBorderChars={SplitBorder.customBorderChars}
-        borderColor={theme.backgroundElement}
-        flexShrink={0}
-      >
-        <code
-          filetype="markdown"
-          drawUnstyledText={false}
-          streaming={true}
-          syntaxStyle={props.subtleSyntax}
-          content={"_Thinking:_ " + content()}
-          conceal={true}
-          fg={theme.textMuted}
-        />
-      </box>
+    <Show when={content() && thinking.mode() !== "hide"}>
+      <Switch>
+        <Match when={!inMinimal() || expanded()}>
+          <box
+            paddingLeft={2}
+            marginTop={1}
+            flexDirection="column"
+            border={["left"]}
+            customBorderChars={SplitBorder.customBorderChars}
+            borderColor={theme.backgroundElement}
+            flexShrink={0}
+            onMouseUp={toggle}
+          >
+            <code
+              filetype="markdown"
+              drawUnstyledText={false}
+              streaming={true}
+              syntaxStyle={props.subtleSyntax}
+              content={(inMinimal() ? "▼ " : "") + "_Thinking:_ " + content()}
+              conceal={true}
+              fg={theme.textMuted}
+            />
+          </box>
+        </Match>
+        <Match when={isDone()}>
+          <box paddingLeft={3} marginTop={1} flexShrink={0} onMouseUp={toggle}>
+            <text fg={theme.textMuted} wrapMode="none">
+              {title() ? "▶ Thought: " + title() : "▶ Thought"}
+            </text>
+          </box>
+        </Match>
+        <Match when={true}>
+          <box paddingLeft={3} marginTop={1} flexShrink={0} onMouseUp={toggle}>
+            <Spinner color={theme.textMuted}>{title() ? "Thinking: " + title() : "Thinking"}</Spinner>
+          </box>
+        </Match>
+      </Switch>
    </Show>
  )
 }
@@ -82,6 +82,7 @@ import * as Model from "../../util/model"
 import { formatTranscript } from "../../util/transcript"
 import { UI } from "@/cli/ui.ts"
 import { useTuiConfig } from "../../context/tui-config"
+import { nextThinkingMode, reasoningTitle, useThinkingMode, type ThinkingMode } from "../../context/thinking"
 import { getScrollAcceleration } from "../../util/scroll"
 import { TuiPluginRuntime } from "@/cli/cmd/tui/plugin/runtime"
 import { DialogRetryAction } from "../../component/dialog-retry-action"
@@ -157,6 +158,7 @@ const context = createContext<{
  width: number
  sessionID: string
  conceal: () => boolean
+  thinkingMode: () => ThinkingMode
  showThinking: () => boolean
  showTimestamps: () => boolean
  showDetails: () => boolean
@@ -214,7 +216,9 @@ export function Session() {
  const [sidebar, setSidebar] = kv.signal<"auto" | "hide">("sidebar", "auto")
  const [sidebarOpen, setSidebarOpen] = createSignal(false)
  const [conceal, setConceal] = createSignal(true)
-  const [showThinking, setShowThinking] = kv.signal("thinking_visibility", true)
+  const thinking = useThinkingMode()
+  const thinkingMode = thinking.mode
+  const showThinking = createMemo(() => thinkingMode() !== "hide")
  const [timestamps, setTimestamps] = kv.signal<"hide" | "show">("timestamps", "hide")
  const [showDetails, setShowDetails] = kv.signal("tool_details_visibility", true)
  const [showAssistantMetadata, _setShowAssistantMetadata] = kv.signal("assistant_metadata_visibility", true)
@@ -683,7 +687,12 @@ export function Session() {
      },
    },
    {
-      title: showThinking() ? "Hide thinking" : "Show thinking",
+      title: (() => {
+        const next = nextThinkingMode(thinkingMode())
+        if (next === "minimal") return "Switch thinking to minimal"
+        if (next === "hide") return "Hide thinking"
+        return "Show thinking"
+      })(),
      value: "session.toggle.thinking",
      category: "Session",
      slash: {
@@ -691,7 +700,17 @@ export function Session() {
        aliases: ["toggle-thinking"],
      },
      run: () => {
-        setShowThinking((prev) => !prev)
+        // Env override forces minimal for the process. Updating KV here would
+        // silently diverge from what's rendered; tell the user instead.
+        if (thinking.locked()) {
+          toast.show({
+            message: "Thinking mode is locked to minimal by OPENCODE_EXPERIMENTAL_MINIMAL_THINKING",
+            variant: "info",
+          })
+          dialog.clear()
+          return
+        }
+        thinking.set(nextThinkingMode(thinkingMode()))
        dialog.clear()
      },
    },
@@ -1086,6 +1105,7 @@ export function Session() {
          },
          sessionID: route.sessionID,
          conceal,
+          thinkingMode,
          showThinking,
          showTimestamps,
          showDetails,
@@ -1492,32 +1512,77 @@ const PART_MAPPING = {
 function ReasoningPart(props: { last: boolean; part: ReasoningPart; message: AssistantMessage }) {
  const { theme, subtleSyntax } = useTheme()
  const ctx = use()
+  // Collapsed by default in minimal mode: a single line throughout, so the
+  // layout never shifts. Click to open the full markdown block, click to close.
+  const [expanded, setExpanded] = createSignal(false)
+
  const content = createMemo(() => {
-    // Filter out redacted reasoning chunks from OpenRouter
-    // OpenRouter sends encrypted reasoning data that appears as [REDACTED]
+    // OpenRouter encrypts some reasoning blocks; drop the placeholder.
    return props.part.text.replace("[REDACTED]", "").trim()
  })
+  // Reasoning is finalized when the server sets `time.end` (see processor.ts).
+  // Flips independently of the parent message completing.
+  const isDone = createMemo(() => props.part.time.end !== undefined)
+  const inMinimal = createMemo(() => ctx.thinkingMode() === "minimal")
+  const duration = createMemo(() => {
+    const end = props.part.time.end
+    return end === undefined ? 0 : Math.max(0, end - props.part.time.start)
+  })
+  // OpenAI / Copilot / opencode-via-OpenAI emit `**Title**\n\n<body>` summary
+  // blocks. Surface the title both while streaming and after settling so the
+  // collapsed line carries real signal, not just a duration.
+  const title = createMemo(() => reasoningTitle(content()))
+
+  const toggle = () => {
+    if (!inMinimal()) return
+    setExpanded((prev) => !prev)
+  }
+
  return (
-    <Show when={content() && ctx.showThinking()}>
-      <box
-        id={"text-" + props.part.id}
-        paddingLeft={2}
-        marginTop={1}
-        flexDirection="column"
-        border={["left"]}
-        customBorderChars={SplitBorder.customBorderChars}
-        borderColor={theme.backgroundElement}
-      >
-        <code
-          filetype="markdown"
-          drawUnstyledText={false}
-          streaming={true}
-          syntaxStyle={subtleSyntax()}
-          content={"_Thinking:_ " + content()}
-          conceal={ctx.conceal()}
-          fg={theme.textMuted}
-        />
-      </box>
+    <Show when={content() && ctx.thinkingMode() !== "hide"}>
+      <Switch>
+        <Match when={!inMinimal() || expanded()}>
+          {/* Full markdown block: `show` mode, or `minimal` after the user opens it. */}
+          <box
+            id={"text-" + props.part.id}
+            paddingLeft={2}
+            marginTop={1}
+            flexDirection="column"
+            border={["left"]}
+            customBorderChars={SplitBorder.customBorderChars}
+            borderColor={theme.backgroundElement}
+            onMouseUp={toggle}
+          >
+            <code
+              filetype="markdown"
+              drawUnstyledText={false}
+              streaming={true}
+              syntaxStyle={subtleSyntax()}
+              content={(inMinimal() ? "▼ " : "") + "_Thinking:_ " + content()}
+              conceal={ctx.conceal()}
+              fg={theme.textMuted}
+            />
+          </box>
+        </Match>
+        <Match when={isDone()}>
+          {/* Settled: ▶ at the start as the click-to-expand cue. */}
+          <box id={"text-" + props.part.id} paddingLeft={3} marginTop={1} flexShrink={0} onMouseUp={toggle}>
+            <text fg={theme.textMuted} wrapMode="none">
+              {"▶ " +
+                (title()
+                  ? "Thought: " + title() + " · " + Locale.duration(duration())
+                  : "Thought for " + Locale.duration(duration()))}
+            </text>
+          </box>
+        </Match>
+        <Match when={true}>
+          {/* Streaming: leading animated spinner, no disclosure arrow yet — it
+              snaps in once reasoning settles, signalling "done, click to expand". */}
+          <box id={"text-" + props.part.id} paddingLeft={3} marginTop={1} flexShrink={0} onMouseUp={toggle}>
+            <Spinner color={theme.textMuted}>{title() ? "Thinking: " + title() : "Thinking"}</Spinner>
+          </box>
+        </Match>
+      </Switch>
    </Show>
  )
 }
@@ -1533,6 +1598,7 @@ function TextPart(props: { last: boolean; part: TextPart; message: AssistantMess
          streaming={true}
          internalBlockMode="top-level"
          content={props.part.text.trim()}
+          tableOptions={{ style: "grid" }}
          conceal={ctx.conceal()}
          fg={theme.markdownText}
          bg={theme.background}
@@ -38,6 +38,11 @@ export interface DialogSelectProps<T> {
    disabled?: boolean
    onTrigger: (option: DialogSelectOption<T>) => void
  }[]
+  footerHints?: {
+    title: string
+    label: string
+    side?: "left" | "right"
+  }[]
  bindings?: readonly Binding<Renderable, KeyEvent>[]
  current?: T
 }
@@ -334,11 +339,12 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
  }
  props.ref?.(ref)

-  const visibleActions = createMemo(() =>
-    actions()
+  const visibleActions = createMemo(() => [
+    ...actions()
      .map((item) => ({ ...item, label: actionLabels().get(item.command) ?? "" }))
      .filter((item) => !item.disabled && item.label),
-  )
+    ...(props.footerHints ?? []),
+  ])
  const left = createMemo(() => visibleActions().filter((item) => item.side !== "right"))
  const right = createMemo(() => visibleActions().filter((item) => item.side === "right"))

@@ -2,7 +2,6 @@ import { Installation } from "@/installation"
 import { Server } from "@/server/server"
 import * as Log from "@opencode-ai/core/util/log"
 import { InstanceRuntime } from "@/project/instance-runtime"
-import { WithInstance } from "@/project/with-instance"
 import { Rpc } from "@/util/rpc"
 import { upgrade } from "@/cli/upgrade"
 import { Config } from "@/config/config"
@@ -77,12 +76,8 @@ export const rpc = {
    return { url: server.url.toString() }
  },
  async checkUpgrade(input: { directory: string }) {
-    await WithInstance.provide({
-      directory: input.directory,
-      fn: async () => {
-        await upgrade().catch(() => {})
-      },
-    })
+    await InstanceRuntime.load({ directory: input.directory })
+    await upgrade().catch(() => {})
  },
  async reload() {
    await AppRuntime.runPromise(
@@ -3,7 +3,6 @@ import { Effect, Schema } from "effect"
 import { AppRuntime, type AppServices } from "@/effect/app-runtime"
 import { InstanceStore } from "@/project/instance-store"
 import { InstanceRef } from "@/effect/instance-ref"
-import { Instance } from "@/project/instance"
 import { cmd, type WithDoubleDash } from "./cmd/cmd"

 /**
@@ -83,19 +82,11 @@ export const effectCmd = <Args, A>(opts: EffectCmdOpts<Args, A>) =>
        return
      }
      const directory = opts.directory?.(args) ?? process.cwd()
-      // Two-phase: load ctx, then run body inside Instance.current ALS.
-      // Effect's InstanceRef is provided via fiber context, but that context is
-      // lost across `await` inside `Effect.promise(async () => ...)` callbacks
-      // — when handlers re-enter Effect via `AppRuntime.runPromise(svc.method())`
-      // there, attach() falls back to Instance.current ALS, which Node preserves
-      // across awaits. Matches the pre-effectCmd `bootstrap()` behavior.
      const { store, ctx } = await AppRuntime.runPromise(
        InstanceStore.Service.use((store) => store.load({ directory }).pipe(Effect.map((ctx) => ({ store, ctx })))),
      )
      try {
-        await Instance.restore(ctx, () =>
-          AppRuntime.runPromise(opts.handler(args).pipe(Effect.provideService(InstanceRef, ctx))),
-        )
+        await AppRuntime.runPromise(opts.handler(args).pipe(Effect.provideService(InstanceRef, ctx)))
      } finally {
        await AppRuntime.runPromise(store.dispose(ctx))
      }
@@ -1,7 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
 import { EffectBridge } from "@/effect/bridge"
-import type { InstanceContext } from "@/project/instance"
+import type { InstanceContext } from "@/project/instance-context"
 import { SessionID, MessageID } from "@/session/schema"
 import { Effect, Layer, Context, Schema } from "effect"
 import { Config } from "@/config/config"
@@ -10,7 +10,6 @@ import { Flag } from "@opencode-ai/core/flag/flag"
 import { Auth } from "../auth"
 import { Env } from "../env"
 import { applyEdits, modify } from "jsonc-parser"
-import { type InstanceContext } from "../project/instance"
 import { InstallationLocal, InstallationVersion } from "@opencode-ai/core/installation/version"
 import { existsSync } from "fs"
 import { Account } from "@/account/account"
@@ -20,7 +19,7 @@ import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { InstanceState } from "@/effect/instance-state"
 import { Context, Duration, Effect, Exit, Fiber, Layer, Option, Schema } from "effect"
 import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
-import { containsPath } from "../project/instance-context"
+import { containsPath, type InstanceContext } from "../project/instance-context"
 import { NonNegativeInt, PositiveInt, type DeepMutable } from "@opencode-ai/core/schema"
 import { ConfigAgent } from "./agent"
 import { ConfigAttachment } from "./attachment"
@@ -1,5 +1,6 @@
-import { Schema } from "effect"
-import { type WorkspaceAdapter, WorkspaceInfo } from "../types"
+import { Effect, Schema } from "effect"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { type WorkspaceAdapter, type WorkspaceAdapterContext, WorkspaceInfo } from "../types"

 const WorktreeConfig = Schema.Struct({
  name: WorkspaceInfo.fields.name,
@@ -9,53 +10,81 @@ const WorktreeConfig = Schema.Struct({
 const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)

 async function loadWorktree() {
-  const [{ AppRuntime }, { Instance }, { Worktree }] = await Promise.all([
-    import("@/effect/app-runtime"),
-    import("@/project/instance"),
-    import("@/worktree"),
-  ])
-  return { AppRuntime, Instance, Worktree }
+  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
+  return { AppRuntime, Worktree }
 }

+function requireInstance(context: WorkspaceAdapterContext | undefined) {
+  if (!context?.instance) throw new Error("Worktree adapter requires an instance context")
+  return context.instance
+}
+
+const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>, context: WorkspaceAdapterContext | undefined) =>
+  effect.pipe(
+    Effect.provideService(InstanceRef, requireInstance(context)),
+    Effect.provideService(WorkspaceRef, context?.workspaceID),
+  )
+
 export const WorktreeAdapter: WorkspaceAdapter = {
  name: "Worktree",
  description: "Create a git worktree",
-  async configure(info) {
+  async configure(info, context) {
    const { AppRuntime, Worktree } = await loadWorktree()
-    const next = await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })))
+    const next = await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })),
+        context,
+      ),
+    )
    return {
      ...info,
      name: next.name,
      directory: next.directory,
    }
  },
-  async create(info) {
+  async create(info, _env, _from, context) {
    const { AppRuntime, Worktree } = await loadWorktree()
    const config = decodeWorktreeConfig(info)
    await AppRuntime.runPromise(
-      Worktree.Service.use((svc) =>
-        svc.createFromInfo({
-          name: config.name,
-          directory: config.directory,
-          ...(config.branch ? { branch: config.branch } : {}),
-        }),
+      provideContext(
+        Worktree.Service.use((svc) =>
+          svc.createFromInfo({
+            name: config.name,
+            directory: config.directory,
+            ...(config.branch ? { branch: config.branch } : {}),
+          }),
+        ),
+        context,
      ),
    )
  },
-  async list() {
-    const { AppRuntime, Instance, Worktree } = await loadWorktree()
-    return (await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.list()))).map((info) => ({
+  async list(context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const ctx = requireInstance(context)
+    return (
+      await AppRuntime.runPromise(
+        provideContext(
+          Worktree.Service.use((svc) => svc.list()),
+          context,
+        ),
+      )
+    ).map((info) => ({
      type: "worktree",
      name: info.name,
      branch: info.branch,
      directory: info.directory,
-      projectID: Instance.project.id,
+      projectID: ctx.project.id,
    }))
  },
-  async remove(info) {
+  async remove(info, context) {
    const { AppRuntime, Worktree } = await loadWorktree()
    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.remove({ directory: config.directory })))
+    await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.remove({ directory: config.directory })),
+        context,
+      ),
+    )
  },
  target(info) {
    const config = decodeWorktreeConfig(info)
@@ -1,5 +1,6 @@
 import { Schema, Struct } from "effect"
 import { ProjectID } from "@/project/schema"
+import type { InstanceContext } from "@/project/instance-context"
 import { WorkspaceID } from "./schema"
 import type { DeepMutable } from "@opencode-ai/core/schema"

@@ -37,12 +38,22 @@ export type Target =
      headers?: HeadersInit
    }

+export type WorkspaceAdapterContext = {
+  readonly instance?: InstanceContext
+  readonly workspaceID?: WorkspaceID
+}
+
 export type WorkspaceAdapter = {
  name: string
  description: string
-  configure(info: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>
-  create(info: WorkspaceInfo, env: Record<string, string | undefined>, from?: WorkspaceInfo): Promise<void>
-  list?(): WorkspaceListedInfo[] | Promise<WorkspaceListedInfo[]>
-  remove(info: WorkspaceInfo): Promise<void>
-  target(info: WorkspaceInfo): Target | Promise<Target>
+  configure(info: WorkspaceInfo, context?: WorkspaceAdapterContext): WorkspaceInfo | Promise<WorkspaceInfo>
+  create(
+    info: WorkspaceInfo,
+    env: Record<string, string | undefined>,
+    from?: WorkspaceInfo,
+    context?: WorkspaceAdapterContext,
+  ): Promise<void>
+  list?(context?: WorkspaceAdapterContext): WorkspaceListedInfo[] | Promise<WorkspaceListedInfo[]>
+  remove(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Promise<void>
+  target(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Target | Promise<Target>
 }
@@ -0,0 +1,51 @@
+import { Effect } from "effect"
+import { EffectBridge } from "@/effect/bridge"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { getAdapter } from "./adapters"
+import type { WorkspaceAdapter, WorkspaceInfo } from "./types"
+
+const context = Effect.gen(function* () {
+  return {
+    instance: yield* InstanceRef,
+    workspaceID: yield* WorkspaceRef,
+  }
+})
+
+export const target = (info: WorkspaceInfo) =>
+  Effect.gen(function* () {
+    const adapter = getAdapter(info.projectID, info.type)
+    const ctx = yield* context
+    return yield* EffectBridge.fromPromise(() => adapter.target(info, ctx))
+  })
+
+export const configure = (adapter: WorkspaceAdapter, info: WorkspaceInfo) =>
+  Effect.gen(function* () {
+    const ctx = yield* context
+    return yield* EffectBridge.fromPromise(() => adapter.configure(info, ctx))
+  })
+
+export const create = (
+  adapter: WorkspaceAdapter,
+  info: WorkspaceInfo,
+  env: Record<string, string | undefined>,
+  from?: WorkspaceInfo,
+) =>
+  Effect.gen(function* () {
+    const ctx = yield* context
+    return yield* EffectBridge.fromPromise(() => adapter.create(info, env, from, ctx))
+  })
+
+export const list = (adapter: WorkspaceAdapter) =>
+  Effect.gen(function* () {
+    const ctx = yield* context
+    return yield* EffectBridge.fromPromise(() => Promise.resolve(adapter.list?.(ctx) ?? []))
+  })
+
+export const remove = (info: WorkspaceInfo) =>
+  Effect.gen(function* () {
+    const adapter = getAdapter(info.projectID, info.type)
+    const ctx = yield* context
+    return yield* EffectBridge.fromPromise(() => adapter.remove(info, ctx))
+  })
+
+export * as WorkspaceAdapterRuntime from "./workspace-adapter-runtime"
@@ -26,11 +26,11 @@ import { SessionID } from "@/session/schema"
 import { NotFoundError } from "@/storage/storage"
 import { errorData } from "@/util/error"
 import { waitEvent } from "./util"
-import { WorkspaceContext } from "./workspace-context"
-import { EffectBridge } from "@/effect/bridge"
+import { WorkspaceRef } from "@/effect/instance-ref"
 import { Vcs } from "@/project/vcs"
 import { InstanceStore } from "@/project/instance-store"
 import { InstanceBootstrap } from "@/project/bootstrap"
+import { WorkspaceAdapterRuntime } from "./workspace-adapter-runtime"

 export const Info = Schema.Struct({
  ...WorkspaceInfoSchema.fields,
@@ -281,8 +281,7 @@ export const layer = Layer.effect(
        const workspace = yield* get(input.workspaceID)
        if (!workspace) return input.fallback

-        const adapter = getAdapter(workspace.projectID, workspace.type)
-        const target = yield* EffectBridge.fromPromise(() => adapter.target(workspace))
+        const target = yield* WorkspaceAdapterRuntime.target(workspace)

        if (target.type === "local") {
          const store = yield* InstanceStore.Service
@@ -375,35 +374,27 @@ export const layer = Layer.effect(
        events: events.length,
      })

-      yield* Effect.promise(async () => {
-        await WorkspaceContext.provide({
-          workspaceID: space.id,
-          async fn() {
-            await Effect.runPromise(
-              Effect.forEach(
-                events,
-                (event) =>
-                  sync.replay(
-                    {
-                      id: event.id,
-                      aggregateID: event.aggregate_id,
-                      seq: event.seq,
-                      type: event.type,
-                      data: event.data,
-                    },
-                    { publish: true },
-                  ),
-                { discard: true },
-              ),
+      yield* Effect.forEach(
+        events,
+        (event) =>
+          sync
+            .replay(
+              {
+                id: event.id,
+                aggregateID: event.aggregate_id,
+                seq: event.seq,
+                type: event.type,
+                data: event.data,
+              },
+              { publish: true },
            )
-          },
-        })
-      })
+            .pipe(Effect.provideService(WorkspaceRef, space.id)),
+        { discard: true },
+      )
    })

    const syncWorkspaceLoop = Effect.fn("Workspace.syncWorkspaceLoop")(function* (space: Info) {
-      const adapter = getAdapter(space.projectID, space.type)
-      const target = yield* EffectBridge.fromPromise(() => adapter.target(space))
+      const target = yield* WorkspaceAdapterRuntime.target(space)

      if (target.type === "local") return

@@ -486,8 +477,7 @@ export const layer = Layer.effect(
    const startSync = Effect.fn("Workspace.startSync")(function* (space: Info) {
      if (!flags.experimentalWorkspaces) return

-      const adapter = getAdapter(space.projectID, space.type)
-      const target = yield* EffectBridge.fromPromise(() => adapter.target(space)).pipe(
+      const target = yield* WorkspaceAdapterRuntime.target(space).pipe(
        Effect.catch((error) =>
          Effect.sync(() => {
            setStatus(space.id, "error")
@@ -538,15 +528,13 @@ export const layer = Layer.effect(
    const create = Effect.fn("Workspace.create")(function* (input: CreateInput) {
      const id = WorkspaceID.ascending(input.id)
      const adapter = getAdapter(input.projectID, input.type)
-      const config = yield* EffectBridge.fromPromise(() =>
-        adapter.configure({
-          ...input,
-          id,
-          name: Slug.create(),
-          directory: null,
-          extra: input.extra ?? null,
-        }),
-      )
+      const config = yield* WorkspaceAdapterRuntime.configure(adapter, {
+        ...input,
+        id,
+        name: Slug.create(),
+        directory: null,
+        extra: input.extra ?? null,
+      })

      const info: Info = {
        id,
@@ -583,7 +571,7 @@ export const layer = Layer.effect(
        OTEL_RESOURCE_ATTRIBUTES: process.env.OTEL_RESOURCE_ATTRIBUTES,
      }

-      yield* EffectBridge.fromPromise(() => adapter.create(config, env))
+      yield* WorkspaceAdapterRuntime.create(adapter, config, env)
      yield* Effect.all(
        [
          waitEvent({
@@ -622,8 +610,7 @@ export const layer = Layer.effect(
        if (current?.workspaceID) {
          const previous = yield* get(current.workspaceID)
          if (previous) {
-            const adapter = getAdapter(previous.projectID, previous.type)
-            const target = yield* EffectBridge.fromPromise(() => adapter.target(previous))
+            const target = yield* WorkspaceAdapterRuntime.target(previous)

            if (target.type === "remote") {
              yield* syncHistory(previous, target.url, target.headers).pipe(
@@ -701,8 +688,7 @@ export const layer = Layer.effect(
            workspaceID,
          })

-        const adapter = getAdapter(space.projectID, space.type)
-        const target = yield* EffectBridge.fromPromise(() => adapter.target(space))
+        const target = yield* WorkspaceAdapterRuntime.target(space)

        if (target.type === "local") {
          yield* sync.run(Session.Event.Updated, {
@@ -855,16 +841,14 @@ export const layer = Layer.effect(
      const discovered = yield* Effect.forEach(
        registeredAdapters(project.id),
        ([type, adapter]) =>
-          adapter.list
-            ? EffectBridge.fromPromise(() => Promise.resolve(adapter.list?.() ?? [])).pipe(
-                Effect.catchCause((error) =>
-                  Effect.sync(() => {
-                    log.warn("workspace adapter list failed", { type, error })
-                    return []
-                  }),
-                ),
-              )
-            : Effect.succeed([]),
+          WorkspaceAdapterRuntime.list(adapter).pipe(
+            Effect.catchCause((error) =>
+              Effect.sync(() => {
+                log.warn("workspace adapter list failed", { type, error })
+                return []
+              }),
+            ),
+          ),
        { concurrency: "unbounded" },
      ).pipe(Effect.map((items) => items.flat()))

@@ -937,8 +921,7 @@ export const layer = Layer.effect(
      const info = fromRow(row)
      yield* Effect.catchCause(
        Effect.gen(function* () {
-          const adapter = getAdapter(info.projectID, row.type)
-          yield* EffectBridge.fromPromise(() => adapter.remove(info))
+          yield* WorkspaceAdapterRuntime.remove(info)
        }),
        () =>
          Effect.sync(() => {
@@ -56,6 +56,7 @@ import { Npm } from "@opencode-ai/core/npm"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"
 import { DataMigration } from "@/data-migration"
 import { BackgroundJob } from "@/background/job"
+import { EventV2Bridge } from "@/event-v2-bridge"
 import { RuntimeFlags } from "@/effect/runtime-flags"

 export const AppLayer = Layer.mergeAll(
@@ -111,6 +112,7 @@ export const AppLayer = Layer.mergeAll(
  ShareNext.defaultLayer,
  SessionShare.defaultLayer,
  SyncEvent.defaultLayer,
+  EventV2Bridge.defaultLayer,
  DataMigration.defaultLayer,
 ).pipe(Layer.provideMerge(InstanceLayer.layer), Layer.provideMerge(Observability.layer))

@@ -1,8 +1,6 @@
-import { Effect, Exit, Fiber } from "effect"
+import { Context, Effect, Exit, Fiber } from "effect"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { Instance, type InstanceContext } from "@/project/instance"
 import type { WorkspaceID } from "@/control-plane/schema"
-import { LocalContext } from "@/util/local-context"
 import { InstanceRef, WorkspaceRef } from "./instance-ref"
 import { attachWith } from "./run-service"

@@ -10,67 +8,75 @@ export interface Shape {
  readonly promise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
  readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>
  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>
+  readonly bind: <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => (...args: Args) => Result
 }

-function restore<R>(instance: InstanceContext | undefined, workspace: WorkspaceID | undefined, fn: () => R): R {
-  if (instance && workspace !== undefined) {
-    return WorkspaceContext.restore(workspace, () => Instance.restore(instance, fn))
-  }
-  if (instance) return Instance.restore(instance, fn)
+function restoreWorkspace<R>(workspace: WorkspaceID | undefined, fn: () => R): R {
  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
  return fn()
 }

+function captureSync() {
+  const fiber = Fiber.getCurrent()
+  const instance = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
+  const workspace =
+    (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined) ?? WorkspaceContext.workspaceID
+  return { instance, workspace }
+}
+
+export const bind = <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => {
+  const captured = captureSync()
+  return (...args: Args) =>
+    restoreWorkspace(captured.workspace, () =>
+      Effect.runSync(
+        attachWith(
+          Effect.sync(() => fn(...args)),
+          captured,
+        ),
+      ),
+    )
+}
+
 /**
- * Bridge from Effect into a Promise-returning JS callback while installing
- * legacy `Instance.context` and `WorkspaceContext` AsyncLocalStorage for
- * the duration of the callback. Effect's `InstanceRef`/`WorkspaceRef` do
- * not propagate across async/await boundaries inside `Effect.promise(() =>
- * async fn)` callbacks that re-enter Effect via `AppRuntime.runPromise`,
- * but Node's AsyncLocalStorage does. Use this whenever an Effect crosses
- * into JS that may itself spawn new Effect runtimes (workspace adapters,
- * legacy plugins, etc.).
+ * Bridge from Effect into a Promise-returning JS callback while preserving
+ * `WorkspaceContext` AsyncLocalStorage for callback code that still reads it.
+ * `InstanceRef` is captured for effects run through the returned bridge APIs;
+ * plain JS callbacks that need it should receive the ref explicitly.
 *
- * Mirrors `Effect.promise` but restores legacy ALS first.
+ * Mirrors `Effect.promise` but restores workspace ALS first.
 */
 export const fromPromise = <T>(fn: () => Promise<T> | T): Effect.Effect<T> =>
  Effect.gen(function* () {
-    const instance = yield* InstanceRef
    const workspace = yield* WorkspaceRef
-    return yield* Effect.promise(() => Promise.resolve(restore(instance, workspace, () => fn())))
+    return yield* Effect.promise(() => Promise.resolve(restoreWorkspace(workspace, () => fn())))
  })

 export function make(): Effect.Effect<Shape> {
  return Effect.gen(function* () {
    const ctx = yield* Effect.context()
-    const value = yield* InstanceRef
-    const instance =
-      value ??
-      (() => {
-        try {
-          return Instance.current
-        } catch (err) {
-          if (!(err instanceof LocalContext.NotFound)) throw err
-        }
-      })()
-    const workspace = (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
-    const attach = <A, E, R>(effect: Effect.Effect<A, E, R>) => attachWith(effect, { instance, workspace })
+    const captured = captureSync()
+    const instance = (yield* InstanceRef) ?? captured.instance
+    const workspace = (yield* WorkspaceRef) ?? captured.workspace
    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      attach(effect).pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>
+      attachWith(effect.pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>, { instance, workspace })

    return {
      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restore(instance, workspace, () => Effect.runPromise(wrap(effect))),
+        restoreWorkspace(workspace, () => Effect.runPromise(wrap(effect))),
      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restore(instance, workspace, () => Effect.runFork(wrap(effect))),
+        restoreWorkspace(workspace, () => Effect.runFork(wrap(effect))),
      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
        Effect.callback<A, E>((resume) => {
-          restore(instance, workspace, () =>
+          restoreWorkspace(workspace, () =>
            Effect.runPromiseExit(wrap(effect)).then((exit) =>
              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
            ),
          )
        }),
+      bind:
+        <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) =>
+        (...args: Args) =>
+          restoreWorkspace(workspace, () => Effect.runSync(wrap(Effect.sync(() => fn(...args))))),
    } satisfies Shape
  })
 }
@@ -1,5 +1,5 @@
 import { Context } from "effect"
-import type { InstanceContext } from "@/project/instance"
+import type { InstanceContext } from "@/project/instance-context"
 import type { WorkspaceID } from "@/control-plane/schema"

 export const InstanceRef = Context.Reference<InstanceContext | undefined>("~opencode/InstanceRef", {
@@ -1,7 +1,6 @@
-import { Effect, Fiber, ScopedCache, Scope, Context } from "effect"
+import { Effect, ScopedCache, Scope } from "effect"
 import * as EffectLogger from "@opencode-ai/core/effect/logger"
-import { Instance, type InstanceContext } from "@/project/instance"
-import { LocalContext } from "@/util/local-context"
+import type { InstanceContext } from "@/project/instance-context"
 import { InstanceRef, WorkspaceRef } from "./instance-ref"
 import { registerDisposer } from "./instance-registry"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
@@ -13,20 +12,10 @@ export interface InstanceState<A, E = never, R = never> {
  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
 }

-export const bind = <F extends (...args: any[]) => any>(fn: F): F => {
-  try {
-    return Instance.bind(fn)
-  } catch (err) {
-    if (!(err instanceof LocalContext.NotFound)) throw err
-  }
-  const fiber = Fiber.getCurrent()
-  const ctx = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
-  if (!ctx) return fn
-  return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
-}
-
 export const context = Effect.gen(function* () {
-  return (yield* InstanceRef) ?? Instance.current
+  const ctx = yield* InstanceRef
+  if (!ctx) return yield* Effect.die(new Error("InstanceRef not provided"))
+  return ctx
 })

 export const workspaceID = Effect.gen(function* () {
@@ -1,11 +1,9 @@
 import { Effect, Fiber, Layer, ManagedRuntime } from "effect"
 import * as Context from "effect/Context"
-import { Instance } from "@/project/instance"
-import { LocalContext } from "@/util/local-context"
 import { InstanceRef, WorkspaceRef } from "./instance-ref"
 import * as Observability from "@opencode-ai/core/effect/observability"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { InstanceContext } from "@/project/instance"
+import type { InstanceContext } from "@/project/instance-context"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"

 type Refs = {
@@ -25,17 +23,9 @@ export function attachWith<A, E, R>(effect: Effect.Effect<A, E, R>, refs: Refs):

 export function attach<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> {
  const workspace = WorkspaceContext.workspaceID
-  const instance = (() => {
-    try {
-      return Instance.current
-    } catch (err) {
-      if (!(err instanceof LocalContext.NotFound)) throw err
-    }
-  })()
-  if (instance && workspace !== undefined) return attachWith(effect, { instance, workspace })
  const fiber = Fiber.getCurrent()
  return attachWith(effect, {
-    instance: instance ?? (fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined),
+    instance: fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined,
    workspace: workspace ?? (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined),
  })
 }
@@ -17,6 +17,13 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
  disableDefaultPlugins: bool("OPENCODE_DISABLE_DEFAULT_PLUGINS"),
  disableChannelDb: bool("OPENCODE_DISABLE_CHANNEL_DB"),
  disableEmbeddedWebUi: bool("OPENCODE_DISABLE_EMBEDDED_WEB_UI"),
+  disableExternalSkills: bool("OPENCODE_DISABLE_EXTERNAL_SKILLS"),
+  disableLspDownload: bool("OPENCODE_DISABLE_LSP_DOWNLOAD"),
+  skipMigrations: bool("OPENCODE_SKIP_MIGRATIONS"),
+  disableClaudeCodePrompt: Config.all({
+    broad: bool("OPENCODE_DISABLE_CLAUDE_CODE"),
+    direct: bool("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT"),
+  }).pipe(Config.map((flags) => flags.broad || flags.direct)),
  disableClaudeCodeSkills: Config.all({
    broad: bool("OPENCODE_DISABLE_CLAUDE_CODE"),
    direct: bool("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS"),
@@ -41,6 +48,7 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
  experimentalEventSystem: enabledByExperimental("OPENCODE_EXPERIMENTAL_EVENT_SYSTEM"),
  experimentalWorkspaces: enabledByExperimental("OPENCODE_EXPERIMENTAL_WORKSPACES"),
  experimentalIconDiscovery: enabledByExperimental("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY"),
+  outputTokenMax: positiveInteger("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
  bashDefaultTimeoutMs: positiveInteger("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
  client: Config.string("OPENCODE_CLIENT").pipe(Config.withDefault("cli")),
 }) {}
@@ -0,0 +1,89 @@
+// Temporary V2 bridge: core events are the publish path, but the rest of
+// opencode and the HTTP event stream still expect legacy bus/sync payloads.
+// This layer goes away once consumers subscribe to core EventV2 directly.
+import { Bus as ProjectBus } from "@/bus"
+import { GlobalBus } from "@/bus/global"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { InstanceStore } from "@/project/instance-store"
+import { SyncEvent } from "@/sync"
+import { EventV2 } from "@opencode-ai/core/event"
+import "@opencode-ai/core/catalog"
+import "@opencode-ai/core/session-event"
+import { Context, Effect, Layer, Option } from "effect"
+
+export function toSyncDefinition<D extends EventV2.Definition>(definition: D) {
+  const result = {
+    type: definition.type,
+    version: definition.version,
+    aggregate: definition.aggregate,
+    schema: definition.data,
+    properties: definition.data,
+  }
+  return result as SyncEvent.Definition<D["type"], D["data"], D["data"]>
+}
+
+export class Service extends Context.Service<Service, EventV2.Interface>()("@opencode/EventV2Bridge") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const events = yield* EventV2.Service
+    const bus = yield* ProjectBus.Service
+    const sync = yield* SyncEvent.Service
+
+    const publishGlobal = (event: EventV2.Payload) =>
+      Effect.sync(() => {
+        GlobalBus.emit("event", {
+          workspace: event.location?.workspaceID,
+          payload: {
+            id: event.id,
+            type: event.type,
+            properties: event.data,
+          },
+        })
+      })
+
+    const provideEventLocation = <E, R>(event: EventV2.Payload, effect: Effect.Effect<void, E, R>) => {
+      return Effect.gen(function* () {
+        const ctx = yield* InstanceRef
+        if (ctx) return yield* effect
+        const store = Option.getOrUndefined(yield* Effect.serviceOption(InstanceStore.Service))
+        if (!event.location?.directory || !store) return yield* publishGlobal(event)
+        return yield* store.load({ directory: event.location.directory }).pipe(
+          Effect.flatMap((ctx) => {
+            const withInstance = effect.pipe(Effect.provideService(InstanceRef, ctx))
+            if (!event.location?.workspaceID) return withInstance
+            return withInstance.pipe(Effect.provideService(WorkspaceRef, event.location.workspaceID))
+          }),
+        )
+      })
+    }
+
+    const unsubscribe = yield* events.sync((event) => {
+      const definition = EventV2.registry.get(event.type)
+      if (!definition) return Effect.void
+      const aggregateID = definition.aggregate
+        ? (event.data as Record<string, unknown>)[definition.aggregate]
+        : undefined
+
+      if (definition.version !== undefined && typeof aggregateID === "string") {
+        return provideEventLocation(event, sync.run(toSyncDefinition(definition), event.data))
+      }
+
+      return provideEventLocation(
+        event,
+        bus.publish({ type: definition.type, properties: definition.data }, event.data, { id: event.id }),
+      )
+    })
+    yield* Effect.addFinalizer(() => unsubscribe)
+    return Service.of(events)
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provideMerge(EventV2.defaultLayer),
+  Layer.provide(SyncEvent.defaultLayer),
+  Layer.provide(ProjectBus.defaultLayer),
+)
+
+export * as EventV2Bridge from "./event-v2-bridge"
@@ -2,10 +2,11 @@ import { Cause, Effect, Layer, Context, Schema } from "effect"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 import type ParcelWatcher from "@parcel/watcher"
-import { readdir } from "fs/promises"
+import { readdir, realpath } from "fs/promises"
 import path from "path"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
+import { EffectBridge } from "@/effect/bridge"
 import { InstanceState } from "@/effect/instance-state"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Git } from "@/git"
@@ -88,13 +89,13 @@ export const layer = Layer.effect(
          if (!w) return

          log.info("watcher backend", { directory: ctx.directory, platform: process.platform, backend })
-
+          const bridge = yield* EffectBridge.make()
          const subs: ParcelWatcher.AsyncSubscription[] = []
          yield* Effect.addFinalizer(() =>
            Effect.promise(() => Promise.allSettled(subs.map((sub) => sub.unsubscribe()))),
          )

-          const cb: ParcelWatcher.SubscribeCallback = InstanceState.bind((err, evts) => {
+          const cb: ParcelWatcher.SubscribeCallback = bridge.bind((err, evts) => {
            if (err) return
            for (const evt of evts) {
              if (evt.type === "create") void Bus.publish(Event.Updated, { file: evt.path, event: "add" })
@@ -131,8 +132,14 @@ export const layer = Layer.effect(
            const result = yield* git.run(["rev-parse", "--git-dir"], {
              cwd: ctx.worktree,
            })
-            const vcsDir = result.exitCode === 0 ? path.resolve(ctx.worktree, result.text().trim()) : undefined
-            if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
+            const resolved = result.exitCode === 0 ? path.resolve(ctx.worktree, result.text().trim()) : undefined
+            const vcsDir = resolved ? yield* Effect.promise(() => realpath(resolved).catch(() => resolved)) : undefined
+            if (
+              vcsDir &&
+              !cfgIgnores.includes(".git") &&
+              !cfgIgnores.includes(vcsDir) &&
+              (!resolved || !cfgIgnores.includes(resolved))
+            ) {
              const ignore = (yield* Effect.promise(() => readdir(vcsDir).catch(() => []))).filter(
                (entry) => entry !== "HEAD",
              )
@@ -1,5 +1,5 @@
 import { Npm } from "@opencode-ai/core/npm"
-import type { InstanceContext } from "../project/instance"
+import type { InstanceContext } from "../project/instance-context"
 import { Filesystem } from "@/util/filesystem"
 import { Process } from "@/util/process"
 import { which } from "../util/which"
@@ -7,10 +7,13 @@ import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types
 import * as Log from "@opencode-ai/core/util/log"
 import { Process } from "@/util/process"
 import { LANGUAGE_EXTENSIONS } from "./language"
-import { Schema } from "effect"
+import { Effect, Schema } from "effect"
 import type * as LSPServer from "./server"
 import { withTimeout } from "../util/timeout"
 import { Filesystem } from "@/util/filesystem"
+import { InstanceRef } from "@/effect/instance-ref"
+import { makeRuntime } from "@/effect/run-service"
+import type { InstanceContext } from "@/project/instance-context"

 const DIAGNOSTICS_DEBOUNCE_MS = 150
 const DIAGNOSTICS_DOCUMENT_WAIT_TIMEOUT_MS = 5_000
@@ -25,6 +28,7 @@ const FILE_CHANGE_CHANGED = 2
 const TEXT_DOCUMENT_SYNC_INCREMENTAL = 2

 const log = Log.create({ service: "lsp.client" })
+const busRuntime = makeRuntime(Bus.Service, Bus.layer)

 export type Info = NonNullable<Awaited<ReturnType<typeof create>>>

@@ -134,9 +138,16 @@ function shouldSeedDiagnosticsOnFirstPush(serverID: string) {
  return serverID === "typescript"
 }

-export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; directory: string }) {
+export async function create(input: {
+  serverID: string
+  server: LSPServer.Handle
+  root: string
+  directory: string
+  instance: InstanceContext
+}) {
  const logger = log.clone().tag("serverID", input.serverID)
  logger.info("starting client")
+  const instance = input.instance

  const connection = createMessageConnection(
    new StreamMessageReader(input.server.process.stdout as any),
@@ -162,7 +173,11 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
    dedupeDiagnostics([...(pushDiagnostics.get(filePath) ?? []), ...(pullDiagnostics.get(filePath) ?? [])])
  const updatePushDiagnostics = (filePath: string, next: Diagnostic[]) => {
    pushDiagnostics.set(filePath, next)
-    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+    void busRuntime.runPromise((svc) =>
+      svc
+        .publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+        .pipe(Effect.provideService(InstanceRef, instance)),
+    )
  }
  const updatePullDiagnostics = (filePath: string, next: Diagnostic[]) => {
    pullDiagnostics.set(filePath, next)
@@ -510,10 +525,14 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
      }

      timeoutTimer = setTimeout(() => finish(false), request.timeout)
-      unsub = Bus.subscribe(Event.Diagnostics, (event) => {
-        if (event.properties.path !== request.path || event.properties.serverID !== input.serverID) return
-        schedule()
-      })
+      unsub = busRuntime.runSync((svc) =>
+        svc
+          .subscribeCallback(Event.Diagnostics, (event) => {
+            if (event.properties.path !== request.path || event.properties.serverID !== input.serverID) return
+            schedule()
+          })
+          .pipe(Effect.provideService(InstanceRef, instance)),
+      )
      schedule()
    })
  }
@@ -237,6 +237,7 @@ export const layer = Layer.effect(
            server: handle,
            root,
            directory: ctx.directory,
+            instance: ctx,
          }).catch(async (err) => {
            s.broken.add(key)
            await Process.stop(handle.process)
@@ -6,8 +6,7 @@ import * as Log from "@opencode-ai/core/util/log"
 import { text } from "node:stream/consumers"
 import fs from "fs/promises"
 import { Filesystem } from "@/util/filesystem"
-import type { InstanceContext } from "../project/instance"
-import { Flag } from "@opencode-ai/core/flag/flag"
+import type { InstanceContext } from "../project/instance-context"
 import { Archive } from "@/util/archive"
 import { Process } from "@/util/process"
 import { which } from "../util/which"
@@ -126,11 +125,11 @@ export const Vue: Info = {
  id: "vue",
  extensions: [".vue"],
  root: NearestRoot(["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("vue-language-server")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("@vue/language-server")
      if (!resolved) return
      binary = resolved
@@ -155,13 +154,13 @@ export const ESLint: Info = {
  id: "eslint",
  root: NearestRoot(["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"]),
  extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"],
-  async spawn(root, ctx) {
+  async spawn(root, ctx, flags) {
    const eslint = Module.resolve("eslint", ctx.directory)
    if (!eslint) return
    log.info("spawning eslint server")
    const serverPath = path.join(Global.Path.bin, "vscode-eslint", "server", "out", "eslintServer.js")
    if (!(await Filesystem.exists(serverPath))) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading and building VS Code ESLint server")
      const response = await fetch("https://github.com/microsoft/vscode-eslint/archive/refs/heads/main.zip")
      if (!response.ok) return
@@ -351,11 +350,11 @@ export const Gopls: Info = {
    return NearestRoot(["go.mod", "go.sum"])(file, ctx)
  },
  extensions: [".go"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("gopls")
    if (!bin) {
      if (!which("go")) return
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return

      log.info("installing gopls")
      const proc = Process.spawn(["go", "install", "golang.org/x/tools/gopls@latest"], {
@@ -386,7 +385,7 @@ export const Rubocop: Info = {
  id: "ruby-lsp",
  root: NearestRoot(["Gemfile"]),
  extensions: [".rb", ".rake", ".gemspec", ".ru"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("rubocop")
    if (!bin) {
      const ruby = which("ruby")
@@ -395,7 +394,7 @@ export const Rubocop: Info = {
        log.info("Ruby not found, please install Ruby first")
        return
      }
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("installing rubocop")
      const proc = Process.spawn(["gem", "install", "rubocop", "--bindir", Global.Path.bin], {
        stdout: "pipe",
@@ -486,11 +485,11 @@ export const Pyright: Info = {
  id: "pyright",
  extensions: [".py", ".pyi"],
  root: NearestRoot(["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("pyright-langserver")
    const args = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("pyright", "pyright-langserver")
      if (!resolved) return
      binary = resolved
@@ -530,7 +529,7 @@ export const ElixirLS: Info = {
  id: "elixir-ls",
  extensions: [".ex", ".exs"],
  root: NearestRoot(["mix.exs", "mix.lock"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("elixir-ls")
    if (!binary) {
      const elixirLsPath = path.join(Global.Path.bin, "elixir-ls")
@@ -548,7 +547,7 @@ export const ElixirLS: Info = {
          return
        }

-        if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+        if (flags.disableLspDownload) return
        log.info("downloading elixir-ls from GitHub releases")

        const response = await fetch("https://github.com/elixir-lsp/elixir-ls/archive/refs/heads/master.zip")
@@ -593,7 +592,7 @@ export const Zls: Info = {
  id: "zls",
  extensions: [".zig", ".zon"],
  root: NearestRoot(["build.zig"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("zls")

    if (!bin) {
@@ -603,7 +602,7 @@ export const Zls: Info = {
        return
      }

-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading zls from GitHub releases")

      const releaseResponse = await fetch("https://api.github.com/repos/zigtools/zls/releases/latest")
@@ -705,8 +704,8 @@ export const CSharp: Info = {
  id: "csharp",
  root: NearestRoot([".slnx", ".sln", ".csproj", "global.json"]),
  extensions: [".cs", ".csx"],
-  async spawn(root) {
-    const bin = await getRoslynLanguageServer()
+  async spawn(root, _ctx, flags) {
+    const bin = await getRoslynLanguageServer(flags.disableLspDownload)
    if (!bin) return

    return {
@@ -721,8 +720,8 @@ export const Razor: Info = {
  id: "razor",
  root: NearestRoot([".slnx", ".sln", ".csproj", "global.json"]),
  extensions: [".razor", ".cshtml"],
-  async spawn(root) {
-    const bin = await getRoslynLanguageServer()
+  async spawn(root, _ctx, flags) {
+    const bin = await getRoslynLanguageServer(flags.disableLspDownload)
    if (!bin) return

    const razor = await findVscodeRazorExtension()
@@ -753,26 +752,26 @@ export const Razor: Info = {

 let roslynLanguageServerInstall: Promise<string | undefined> | undefined

-async function getRoslynLanguageServer() {
+async function getRoslynLanguageServer(disableLspDownload: boolean) {
  const existing = which("roslyn-language-server")
  if (existing) return existing

  const global = await roslynLanguageServerGlobalPath()
  if (global) return global

-  roslynLanguageServerInstall ||= installRoslynLanguageServer().finally(() => {
+  roslynLanguageServerInstall ||= installRoslynLanguageServer(disableLspDownload).finally(() => {
    roslynLanguageServerInstall = undefined
  })
  return roslynLanguageServerInstall
 }

-async function installRoslynLanguageServer() {
+async function installRoslynLanguageServer(disableLspDownload: boolean) {
  if (!which("dotnet")) {
    log.error(".NET SDK is required to install roslyn-language-server")
    return
  }

-  if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+  if (disableLspDownload) return
  log.info("installing roslyn-language-server via dotnet tool")
  const proc = Process.spawn(["dotnet", "tool", "install", "--global", "roslyn-language-server", "--prerelease"], {
    stdout: "pipe",
@@ -850,7 +849,7 @@ export const FSharp: Info = {
  id: "fsharp",
  root: NearestRoot([".slnx", ".sln", ".fsproj", "global.json"]),
  extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("fsautocomplete")
    if (!bin) {
      if (!which("dotnet")) {
@@ -858,7 +857,7 @@ export const FSharp: Info = {
        return
      }

-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("installing fsautocomplete via dotnet tool")
      const proc = Process.spawn(["dotnet", "tool", "install", "fsautocomplete", "--tool-path", Global.Path.bin], {
        stdout: "pipe",
@@ -967,7 +966,7 @@ export const Clangd: Info = {
  id: "clangd",
  root: NearestRoot(["compile_commands.json", "compile_flags.txt", ".clangd"]),
  extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    const args = ["--background-index", "--clang-tidy"]
    const fromPath = which("clangd")
    if (fromPath) {
@@ -1002,7 +1001,7 @@ export const Clangd: Info = {
      }
    }

-    if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+    if (flags.disableLspDownload) return
    log.info("downloading clangd from GitHub releases")

    const releaseResponse = await fetch("https://api.github.com/repos/clangd/clangd/releases/latest")
@@ -1113,11 +1112,11 @@ export const Svelte: Info = {
  id: "svelte",
  extensions: [".svelte"],
  root: NearestRoot(["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("svelteserver")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("svelte-language-server")
      if (!resolved) return
      binary = resolved
@@ -1140,7 +1139,7 @@ export const Astro: Info = {
  id: "astro",
  extensions: [".astro"],
  root: NearestRoot(["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"]),
-  async spawn(root, ctx) {
+  async spawn(root, ctx, flags) {
    const tsserver = Module.resolve("typescript/lib/tsserver.js", ctx.directory)
    if (!tsserver) {
      log.info("typescript not found, required for Astro language server")
@@ -1151,7 +1150,7 @@ export const Astro: Info = {
    let binary = which("astro-ls")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("@astrojs/language-server")
      if (!resolved) return
      binary = resolved
@@ -1201,7 +1200,7 @@ export const JDTLS: Info = {
    if (settingsRoot) return settingsRoot
  },
  extensions: [".java"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    const java = which("java")
    if (!java) {
      log.error("Java 21 or newer is required to run the JDTLS. Please install it first.")
@@ -1219,7 +1218,7 @@ export const JDTLS: Info = {
    const launcherDir = path.join(distPath, "plugins")
    const installed = await pathExists(launcherDir)
    if (!installed) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("Downloading JDTLS LSP server.")
      await fs.mkdir(distPath, { recursive: true })
      const releaseURL =
@@ -1311,13 +1310,13 @@ export const KotlinLS: Info = {
    // 4) Maven fallback
    return NearestRoot(["pom.xml"])(file, ctx)
  },
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    const distPath = path.join(Global.Path.bin, "kotlin-ls")
    const launcherScript =
      process.platform === "win32" ? path.join(distPath, "kotlin-lsp.cmd") : path.join(distPath, "kotlin-lsp.sh")
    const installed = await Filesystem.exists(launcherScript)
    if (!installed) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("Downloading Kotlin Language Server from GitHub.")

      const releaseResponse = await fetch("https://api.github.com/repos/Kotlin/kotlin-lsp/releases/latest")
@@ -1398,11 +1397,11 @@ export const YamlLS: Info = {
  id: "yaml-ls",
  extensions: [".yaml", ".yml"],
  root: NearestRoot(["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("yaml-language-server")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("yaml-language-server")
      if (!resolved) return
      binary = resolved
@@ -1432,11 +1431,11 @@ export const LuaLS: Info = {
    "selene.yml",
  ]),
  extensions: [".lua"],
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("lua-language-server")

    if (!bin) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading lua-language-server from GitHub releases")

      const releaseResponse = await fetch("https://api.github.com/repos/LuaLS/lua-language-server/releases/latest")
@@ -1565,11 +1564,11 @@ export const PHPIntelephense: Info = {
  id: "php intelephense",
  extensions: [".php"],
  root: NearestRoot(["composer.json", "composer.lock", ".php-version"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("intelephense")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("intelephense")
      if (!resolved) return
      binary = resolved
@@ -1649,11 +1648,11 @@ export const BashLS: Info = {
  id: "bash",
  extensions: [".sh", ".bash", ".zsh", ".ksh"],
  root: async (_file, ctx) => ctx.directory,
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("bash-language-server")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("bash-language-server")
      if (!resolved) return
      binary = resolved
@@ -1675,11 +1674,11 @@ export const TerraformLS: Info = {
  id: "terraform",
  extensions: [".tf", ".tfvars"],
  root: NearestRoot([".terraform.lock.hcl", "terraform.tfstate", "*.tf"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("terraform-ls")

    if (!bin) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading terraform-ls from HashiCorp releases")

      const releaseResponse = await fetch("https://api.releases.hashicorp.com/v1/releases/terraform-ls/latest")
@@ -1756,11 +1755,11 @@ export const TexLab: Info = {
  id: "texlab",
  extensions: [".tex", ".bib"],
  root: NearestRoot([".latexmkrc", "latexmkrc", ".texlabroot", "texlabroot"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("texlab")

    if (!bin) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading texlab from GitHub releases")

      const response = await fetch("https://api.github.com/repos/latex-lsp/texlab/releases/latest")
@@ -1844,11 +1843,11 @@ export const DockerfileLS: Info = {
  id: "dockerfile",
  extensions: [".dockerfile", "Dockerfile"],
  root: async (_file, ctx) => ctx.directory,
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let binary = which("docker-langserver")
    const args: string[] = []
    if (!binary) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      const resolved = await Npm.which("dockerfile-language-server-nodejs")
      if (!resolved) return
      binary = resolved
@@ -1940,11 +1939,11 @@ export const Tinymist: Info = {
  id: "tinymist",
  extensions: [".typ", ".typc"],
  root: NearestRoot(["typst.toml"]),
-  async spawn(root) {
+  async spawn(root, _ctx, flags) {
    let bin = which("tinymist")

    if (!bin) {
-      if (Flag.OPENCODE_DISABLE_LSP_DOWNLOAD) return
+      if (flags.disableLspDownload) return
      log.info("downloading tinymist from GitHub releases")

      const response = await fetch("https://api.github.com/repos/Myriad-Dreamin/tinymist/releases/latest")
@@ -1,36 +0,0 @@
-import { context, type InstanceContext } from "./instance-context"
-
-export type { InstanceContext } from "./instance-context"
-
-export const Instance = {
-  get current() {
-    return context.use()
-  },
-  get directory() {
-    return context.use().directory
-  },
-  get worktree() {
-    return context.use().worktree
-  },
-  get project() {
-    return context.use().project
-  },
-
-  /**
-   * Captures the current instance ALS context and returns a wrapper that
-   * restores it when called. Use this for callbacks that fire outside the
-   * instance async context (native addons, event emitters, timers, etc.).
-   */
-  bind<F extends (...args: any[]) => any>(fn: F): F {
-    const ctx = context.use()
-    return ((...args: any[]) => context.provide(ctx, () => fn(...args))) as F
-  },
-  /**
-   * Run a synchronous function within the given instance context ALS.
-   * Use this to bridge from Effect (where InstanceRef carries context)
-   * back to sync code that reads Instance.directory from ALS.
-   */
-  restore<R>(ctx: InstanceContext, fn: () => R): R {
-    return context.provide(ctx, fn)
-  },
-}
@@ -1,12 +0,0 @@
-import { AppRuntime } from "@/effect/app-runtime"
-import { context } from "./instance-context"
-import { InstanceStore } from "./instance-store"
-
-export async function provide<R>(input: { directory: string; fn: () => R }): Promise<R> {
-  const ctx = await AppRuntime.runPromise(
-    InstanceStore.Service.use((store) => store.load({ directory: input.directory })),
-  )
-  return context.provide(ctx, () => input.fn())
-}
-
-export * as WithInstance from "./with-instance"
@@ -4,7 +4,6 @@ import type { JSONSchema7 } from "@ai-sdk/provider"
 import type * as Provider from "./provider"
 import type * as ModelsDev from "@opencode-ai/core/models"
 import { iife } from "@/util/iife"
-import { Flag } from "@opencode-ai/core/flag/flag"

 type Modality = NonNullable<ModelsDev.Model["modalities"]>["input"][number]

@@ -16,7 +15,7 @@ function mimeToModality(mime: string): Modality | undefined {
  return undefined
 }

-export const OUTPUT_TOKEN_MAX = Flag.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX || 32_000
+export const OUTPUT_TOKEN_MAX = 32_000

 export function sanitizeSurrogates(content: string) {
  return content.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD")
@@ -1251,8 +1250,8 @@ export function providerOptions(model: Provider.Model, options: { [x: string]: a
  return { [key]: options }
 }

-export function maxOutputTokens(model: Provider.Model): number {
-  return Math.min(model.limit.output, OUTPUT_TOKEN_MAX) || OUTPUT_TOKEN_MAX
+export function maxOutputTokens(model: Provider.Model, outputTokenMax = OUTPUT_TOKEN_MAX): number {
+  return Math.min(model.limit.output, outputTokenMax) || outputTokenMax
 }

 export function schema(model: Provider.Model, schema: JSONSchema7): JSONSchema7 {
@@ -0,0 +1,3 @@
+import { initProjectors } from "./projectors"
+
+initProjectors()
@@ -1,28 +1,28 @@
 import { Catalog } from "@opencode-ai/core/catalog"
-import { Instance } from "@opencode-ai/core/instance"
-import { InstanceServiceMap } from "@opencode-ai/core/instance-layer"
+import { Location } from "@opencode-ai/core/location"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
 import { Effect, Layer, Schema } from "effect"
 import { HttpServerRequest } from "effect/unstable/http"
 import { HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi"

-export const InstanceQuery = Schema.Struct({
-  instance: Schema.optional(
+export const LocationQuery = Schema.Struct({
+  location: Schema.optional(
    Schema.Struct({
      directory: Schema.optional(Schema.String),
      workspace: Schema.optional(Schema.String),
    }),
  ),
-}).annotate({ identifier: "V2InstanceQuery" })
+}).annotate({ identifier: "V2LocationQuery" })

-export const instanceQueryOpenApi = OpenApi.annotations({
+export const locationQueryOpenApi = OpenApi.annotations({
  transform: (operation) => {
    const parameters = operation.parameters
    if (!Array.isArray(parameters)) return operation
    return {
      ...operation,
      parameters: parameters.map((parameter) =>
-        parameter?.name === "instance" && parameter?.in === "query"
+        parameter?.name === "location" && parameter?.in === "query"
          ? { ...parameter, style: "deepObject", explode: true }
          : parameter,
      ),
@@ -30,30 +30,30 @@ export const instanceQueryOpenApi = OpenApi.annotations({
  },
 })

-export class V2InstanceMiddleware extends HttpApiMiddleware.Service<
-  V2InstanceMiddleware,
+export class V2LocationMiddleware extends HttpApiMiddleware.Service<
+  V2LocationMiddleware,
  {
    provides: Catalog.Service | PluginBoot.Service
  }
->()("@opencode/ExperimentalHttpApiV2Instance") {}
+>()("@opencode/ExperimentalHttpApiV2Location") {}

-function ref(request: HttpServerRequest.HttpServerRequest): Instance.Ref {
+function ref(request: HttpServerRequest.HttpServerRequest): Location.Ref {
  const query = new URL(request.url, "http://localhost").searchParams
  return {
-    directory: query.get("instance[directory]") || request.headers["x-opencode-directory"] || process.cwd(),
-    workspaceID: query.get("instance[workspace]") || request.headers["x-opencode-workspace"],
+    directory: query.get("location[directory]") || request.headers["x-opencode-directory"] || process.cwd(),
+    workspaceID: query.get("location[workspace]") || request.headers["x-opencode-workspace"],
  }
 }

 export const layer = Layer.effect(
-  V2InstanceMiddleware,
+  V2LocationMiddleware,
  Effect.gen(function* () {
-    const instances = yield* InstanceServiceMap
-    return V2InstanceMiddleware.of((effect) =>
+    const locations = yield* LocationServiceMap
+    return V2LocationMiddleware.of((effect) =>
      Effect.gen(function* () {
        const request = yield* HttpServerRequest.HttpServerRequest
-        return yield* effect.pipe(Effect.provide(instances.get(ref(request))))
+        return yield* effect.pipe(Effect.provide(locations.get(ref(request))))
      }),
    )
  }),
-).pipe(Layer.provide(InstanceServiceMap.layer))
+).pipe(Layer.provide(LocationServiceMap.layer))
@@ -1,5 +1,5 @@
 import { SessionID } from "@/session/schema"
-import { SessionMessage } from "@/v2/session-message"
+import { SessionMessage } from "@opencode-ai/core/session-message"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "../../middleware/authorization"
@@ -2,15 +2,15 @@ import { ModelV2 } from "@opencode-ai/core/model"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "../../middleware/authorization"
-import { InstanceQuery, instanceQueryOpenApi, V2InstanceMiddleware } from "./instance"
+import { LocationQuery, locationQueryOpenApi, V2LocationMiddleware } from "./location"

 export const ModelGroup = HttpApiGroup.make("v2.model")
  .add(
    HttpApiEndpoint.get("models", "/api/model", {
-      query: InstanceQuery,
+      query: LocationQuery,
      success: Schema.Array(ModelV2.Info),
    })
-      .annotateMerge(instanceQueryOpenApi)
+      .annotateMerge(locationQueryOpenApi)
      .annotateMerge(
        OpenApi.annotations({
          identifier: "v2.model.list",
@@ -25,5 +25,5 @@ export const ModelGroup = HttpApiGroup.make("v2.model")
      description: "Experimental v2 model routes.",
    }),
  )
-  .middleware(V2InstanceMiddleware)
+  .middleware(V2LocationMiddleware)
  .middleware(Authorization)
@@ -3,15 +3,15 @@ import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { ApiNotFoundError } from "../../errors"
 import { Authorization } from "../../middleware/authorization"
-import { InstanceQuery, instanceQueryOpenApi, V2InstanceMiddleware } from "./instance"
+import { LocationQuery, locationQueryOpenApi, V2LocationMiddleware } from "./location"

 export const ProviderGroup = HttpApiGroup.make("v2.provider")
  .add(
    HttpApiEndpoint.get("providers", "/api/provider", {
-      query: InstanceQuery,
+      query: LocationQuery,
      success: Schema.Array(ProviderV2.Info),
    })
-      .annotateMerge(instanceQueryOpenApi)
+      .annotateMerge(locationQueryOpenApi)
      .annotateMerge(
        OpenApi.annotations({
          identifier: "v2.provider.list",
@@ -23,11 +23,11 @@ export const ProviderGroup = HttpApiGroup.make("v2.provider")
  .add(
    HttpApiEndpoint.get("provider", "/api/provider/:providerID", {
      params: { providerID: ProviderV2.ID },
-      query: InstanceQuery,
+      query: LocationQuery,
      success: ProviderV2.Info,
      error: ApiNotFoundError,
    })
-      .annotateMerge(instanceQueryOpenApi)
+      .annotateMerge(locationQueryOpenApi)
      .annotateMerge(
        OpenApi.annotations({
          identifier: "v2.provider.get",
@@ -43,5 +43,5 @@ export const ProviderGroup = HttpApiGroup.make("v2.provider")
      description: "Experimental v2 provider routes.",
    }),
  )
-  .middleware(V2InstanceMiddleware)
+  .middleware(V2LocationMiddleware)
  .middleware(Authorization)
@@ -1,5 +1,5 @@
 import { SessionID } from "@/session/schema"
-import { SessionMessage } from "@/v2/session-message"
+import { SessionMessage } from "@opencode-ai/core/session-message"
 import { Prompt } from "@opencode-ai/core/session-prompt"
 import { SessionV2 } from "@/v2/session"
 import { Schema } from "effect"
@@ -1,12 +1,12 @@
 import { SessionV2 } from "@/v2/session"
 import { Layer } from "effect"
-import { layer as v2InstanceLayer } from "../groups/v2/instance"
+import { layer as v2LocationLayer } from "../groups/v2/location"
 import { messageHandlers } from "./v2/message"
 import { modelHandlers } from "./v2/model"
 import { providerHandlers } from "./v2/provider"
 import { sessionHandlers } from "./v2/session"

 export const v2Handlers = Layer.mergeAll(sessionHandlers, messageHandlers, modelHandlers, providerHandlers).pipe(
-  Layer.provide(v2InstanceLayer),
+  Layer.provide(v2LocationLayer),
  Layer.provide(SessionV2.defaultLayer),
 )
@@ -1,4 +1,4 @@
-import { SessionMessage } from "@/v2/session-message"
+import { SessionMessage } from "@opencode-ai/core/session-message"
 import { SessionV2 } from "@/v2/session"
 import { Effect, Schema } from "effect"
 import * as DateTime from "effect/DateTime"
@@ -1,5 +1,5 @@
 import { EffectBridge } from "@/effect/bridge"
-import type { InstanceContext } from "@/project/instance"
+import type { InstanceContext } from "@/project/instance-context"
 import { InstanceStore } from "@/project/instance-store"
 import * as Log from "@opencode-ai/core/util/log"
 import { Effect } from "effect"
@@ -1,4 +1,4 @@
-import { WorkspaceRef } from "@/effect/instance-ref"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
 import { InstanceStore } from "@/project/instance-store"
 import { Effect, Layer } from "effect"
 import { HttpRouter, HttpServerResponse } from "effect/unstable/http"
@@ -26,9 +26,10 @@ function provideInstanceContext<E>(
 ): Effect.Effect<HttpServerResponse.HttpServerResponse, E, WorkspaceRouteContext> {
  return Effect.gen(function* () {
    const route = yield* WorkspaceRouteContext
-    return yield* store.provide(
-      { directory: decode(route.directory) },
-      effect.pipe(Effect.provideService(WorkspaceRef, route.workspaceID)),
+    const ctx = yield* store.load({ directory: decode(route.directory) })
+    return yield* effect.pipe(
+      Effect.provideService(InstanceRef, ctx),
+      Effect.provideService(WorkspaceRef, route.workspaceID),
    )
  })
 }
@@ -1,8 +1,7 @@
-import { getAdapter } from "@/control-plane/adapters"
 import { WorkspaceID } from "@/control-plane/schema"
 import type { Target } from "@/control-plane/types"
 import { Workspace } from "@/control-plane/workspace"
-import { EffectBridge } from "@/effect/bridge"
+import { WorkspaceAdapterRuntime } from "@/control-plane/workspace-adapter-runtime"
 import { Session } from "@/session/session"
 import { HttpApiProxy } from "./proxy"
 import * as Fence from "@/server/shared/fence"
@@ -93,8 +92,7 @@ function missingWorkspaceResponse(id: WorkspaceID): HttpServerResponse.HttpServe
 }

 function resolveTarget(workspace: Workspace.Info): Effect.Effect<Target> {
-  const adapter = getAdapter(workspace.projectID, workspace.type)
-  return EffectBridge.fromPromise(() => adapter.target(workspace))
+  return WorkspaceAdapterRuntime.target(workspace)
 }

 function proxyRemote(
@@ -45,6 +45,7 @@ import { SessionSummary } from "@/session/summary"
 import { Todo } from "@/session/todo"
 import { SessionShare } from "@/share/session"
 import { ShareNext } from "@/share/share-next"
+import { EventV2Bridge } from "@/event-v2-bridge"
 import { Skill } from "@/skill"
 import { Snapshot } from "@/snapshot"
 import { SyncEvent } from "@/sync"
@@ -221,6 +222,7 @@ export function createRoutes(
      ShareNext.defaultLayer,
      Snapshot.defaultLayer,
      SyncEvent.defaultLayer,
+      EventV2Bridge.defaultLayer,
      Skill.defaultLayer,
      Todo.defaultLayer,
      ToolRegistry.defaultLayer,
@@ -1,3 +1,5 @@
+import "./init-projectors"
+
 import { NodeHttpServer } from "@effect/platform-node"
 import * as Log from "@opencode-ai/core/util/log"
 import { ConfigProvider, Context, Effect, Exit, Layer, Scope } from "effect"
@@ -5,7 +7,6 @@ import { HttpRouter, HttpServer } from "effect/unstable/http"
 import { OpenApi } from "effect/unstable/httpapi"
 import { createServer } from "node:http"
 import { MDNS } from "./mdns"
-import { initProjectors } from "./projectors"
 import { HttpApiApp } from "./routes/instance/httpapi/server"
 import { disposeMiddleware } from "./routes/instance/httpapi/lifecycle"
 import { WebSocketTracker } from "./routes/instance/httpapi/websocket-tracker"
@@ -16,8 +17,6 @@ import { lazy } from "@/util/lazy"
 // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
 globalThis.AI_SDK_LOG_WARNINGS = false

-initProjectors()
-
 const log = Log.create({ service: "server" })

 export type Listener = {
@@ -19,8 +19,9 @@ import { isOverflow as overflow, usable } from "./overflow"
 import { makeRuntime } from "@/effect/run-service"
 import { serviceUse } from "@/effect/service-use"
 import { RuntimeFlags } from "@/effect/runtime-flags"
-import { SyncEvent } from "@/sync"
-import { SessionEvent } from "@/v2/session-event"
+import { EventV2 } from "@opencode-ai/core/event"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { SessionEvent } from "@opencode-ai/core/session-event"

 const log = Log.create({ service: "session.compaction" })

@@ -210,19 +211,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Se

 export const use = serviceUse(Service)

-export const layer: Layer.Layer<
-  Service,
-  never,
-  | Bus.Service
-  | Config.Service
-  | Session.Service
-  | Agent.Service
-  | Plugin.Service
-  | SessionProcessor.Service
-  | Provider.Service
-  | SyncEvent.Service
-  | RuntimeFlags.Service
-> = Layer.effect(
+export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const bus = yield* Bus.Service
@@ -232,14 +221,19 @@ export const layer: Layer.Layer<
    const plugin = yield* Plugin.Service
    const processors = yield* SessionProcessor.Service
    const provider = yield* Provider.Service
-    const sync = yield* SyncEvent.Service
+    const events = yield* EventV2Bridge.Service
    const flags = yield* RuntimeFlags.Service

    const isOverflow = Effect.fn("SessionCompaction.isOverflow")(function* (input: {
      tokens: MessageV2.Assistant["tokens"]
      model: Provider.Model
    }) {
-      return overflow({ cfg: yield* config.get(), tokens: input.tokens, model: input.model })
+      return overflow({
+        cfg: yield* config.get(),
+        tokens: input.tokens,
+        model: input.model,
+        outputTokenMax: flags.outputTokenMax,
+      })
    })

    const estimate = Effect.fn("SessionCompaction.estimate")(function* (input: {
@@ -577,7 +571,7 @@ export const layer: Layer.Layer<
          },
        )
        if (flags.experimentalEventSystem) {
-          yield* sync.run(SessionEvent.Compaction.Ended.Sync, {
+          yield* events.publish(SessionEvent.Compaction.Ended, {
            sessionID: input.sessionID,
            timestamp: DateTime.makeUnsafe(Date.now()),
            text: summary ?? "",
@@ -613,7 +607,7 @@ export const layer: Layer.Layer<
        overflow: input.overflow,
      })
      if (flags.experimentalEventSystem) {
-        yield* sync.run(SessionEvent.Compaction.Started.Sync, {
+        yield* events.publish(SessionEvent.Compaction.Started, {
          sessionID: input.sessionID,
          timestamp: DateTime.makeUnsafe(Date.now()),
          reason: input.auto ? "auto" : "manual",
@@ -639,8 +633,8 @@ export const defaultLayer = Layer.suspend(() =>
    Layer.provide(Plugin.defaultLayer),
    Layer.provide(Bus.layer),
    Layer.provide(Config.defaultLayer),
-    Layer.provide(SyncEvent.defaultLayer),
    Layer.provide(RuntimeFlags.defaultLayer),
+    Layer.provide(EventV2Bridge.defaultLayer),
  ),
 )

@@ -3,6 +3,7 @@ import { Effect, Layer, Context } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { Config } from "@/config/config"
 import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { withTransientReadRetry } from "@/util/effect-http-client"
@@ -10,9 +11,9 @@ import { Global } from "@opencode-ai/core/global"
 import type { MessageV2 } from "./message-v2"
 import type { MessageID } from "./schema"

-const FILES = [
+const files = (disableClaudeCodePrompt: boolean) => [
  "AGENTS.md",
-  ...(Flag.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT ? [] : ["CLAUDE.md"]),
+  ...(disableClaudeCodePrompt ? [] : ["CLAUDE.md"]),
  "CONTEXT.md", // deprecated
 ]

@@ -50,18 +51,20 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/In
 export const layer: Layer.Layer<
  Service,
  never,
-  AppFileSystem.Service | Config.Service | Global.Service | HttpClient.HttpClient
+  AppFileSystem.Service | Config.Service | Global.Service | HttpClient.HttpClient | RuntimeFlags.Service
 > = Layer.effect(
  Service,
  Effect.gen(function* () {
    const cfg = yield* Config.Service
    const fs = yield* AppFileSystem.Service
    const global = yield* Global.Service
+    const flags = yield* RuntimeFlags.Service
    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
    const globalFiles = [
      path.join(global.config, "AGENTS.md"),
-      ...(!Flag.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
+      ...(!flags.disableClaudeCodePrompt ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
    ]
+    const instructionFiles = files(flags.disableClaudeCodePrompt)

    const state = yield* InstanceState.make(
      Effect.fn("Instruction.state")(() =>
@@ -117,8 +120,10 @@ export const layer: Layer.Layer<

      // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
      if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
-        for (const file of FILES) {
-          const matches = yield* fs.findUp(file, ctx.directory, ctx.worktree)
+        for (const file of instructionFiles) {
+          const matches = yield* fs
+            .findUp(file, ctx.directory, ctx.worktree)
+            .pipe(Effect.catch(() => Effect.succeed([])))
          if (matches.length > 0) {
            matches.forEach((item) => paths.add(path.resolve(item)))
            break
@@ -163,7 +168,7 @@ export const layer: Layer.Layer<
    })

    const find = Effect.fn("Instruction.find")(function* (dir: string) {
-      for (const file of FILES) {
+      for (const file of instructionFiles) {
        const filepath = path.resolve(path.join(dir, file))
        if (yield* fs.existsSafe(filepath)) return filepath
      }
@@ -223,6 +228,7 @@ export const defaultLayer = layer.pipe(
  Layer.provide(Global.layer),
  Layer.provide(AppFileSystem.defaultLayer),
  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(RuntimeFlags.defaultLayer),
 )

 export function loaded(messages: MessageV2.WithParts[]) {
@@ -173,7 +173,7 @@ const live: Layer.Layer<
            : undefined,
          topP: input.agent.topP ?? ProviderTransform.topP(input.model),
          topK: ProviderTransform.topK(input.model),
-          maxOutputTokens: ProviderTransform.maxOutputTokens(input.model),
+          maxOutputTokens: ProviderTransform.maxOutputTokens(input.model, flags.outputTokenMax),
          options,
        },
      )
@@ -256,7 +256,7 @@ const live: Layer.Layer<

        const bridge = yield* EffectBridge.make()
        const approvedToolsForSession = new Set<string>()
-        workflowModel.approvalHandler = InstanceState.bind(async (approvalTools) => {
+        workflowModel.approvalHandler = bridge.bind(async (approvalTools) => {
          const uniqueNames = [...new Set(approvalTools.map((t: { name: string }) => t.name))] as string[]
          // Auto-approve tools that were already approved in this session
          // (prevents infinite approval loops for server-side MCP tools)
@@ -5,18 +5,24 @@ import type { MessageV2 } from "./message-v2"

 const COMPACTION_BUFFER = 20_000

-export function usable(input: { cfg: Config.Info; model: Provider.Model }) {
+export function usable(input: { cfg: Config.Info; model: Provider.Model; outputTokenMax?: number }) {
  const context = input.model.limit.context
  if (context === 0) return 0

  const reserved =
-    input.cfg.compaction?.reserved ?? Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model))
+    input.cfg.compaction?.reserved ??
+    Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
  return input.model.limit.input
    ? Math.max(0, input.model.limit.input - reserved)
-    : Math.max(0, context - ProviderTransform.maxOutputTokens(input.model))
+    : Math.max(0, context - ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
 }

-export function isOverflow(input: { cfg: Config.Info; tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
+export function isOverflow(input: {
+  cfg: Config.Info
+  tokens: MessageV2.Assistant["tokens"]
+  model: Provider.Model
+  outputTokenMax?: number
+}) {
  if (input.cfg.compaction?.auto === false) return false
  if (input.model.limit.context === 0) return false

@@ -21,8 +21,9 @@ import { Question } from "@/question"
 import { errorMessage } from "@/util/error"
 import * as Log from "@opencode-ai/core/util/log"
 import { isRecord } from "@/util/record"
-import { SyncEvent } from "@/sync"
-import { SessionEvent } from "@/v2/session-event"
+import { EventV2 } from "@opencode-ai/core/event"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { SessionEvent } from "@opencode-ai/core/session-event"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import * as DateTime from "effect/DateTime"
@@ -84,23 +85,7 @@ type StreamEvent = Event

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

-export const layer: Layer.Layer<
-  Service,
-  never,
-  | Session.Service
-  | Config.Service
-  | Bus.Service
-  | Snapshot.Service
-  | Agent.Service
-  | LLM.Service
-  | Permission.Service
-  | Plugin.Service
-  | Image.Service
-  | SessionSummary.Service
-  | SessionStatus.Service
-  | SyncEvent.Service
-  | RuntimeFlags.Service
-> = Layer.effect(
+export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const session = yield* Session.Service
@@ -115,7 +100,7 @@ export const layer: Layer.Layer<
    const scope = yield* Scope.Scope
    const status = yield* SessionStatus.Service
    const image = yield* Image.Service
-    const sync = yield* SyncEvent.Service
+    const events = yield* EventV2Bridge.Service
    const flags = yield* RuntimeFlags.Service

    const create = Effect.fn("SessionProcessor.create")(function* (input: Input) {
@@ -236,7 +221,7 @@ export const layer: Layer.Layer<
            if (value.id in ctx.reasoningMap) return
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Reasoning.Started.Sync, {
+              yield* events.publish(SessionEvent.Reasoning.Started, {
                sessionID: ctx.sessionID,
                reasoningID: value.id,
                timestamp: DateTime.makeUnsafe(Date.now()),
@@ -271,7 +256,7 @@ export const layer: Layer.Layer<
            if (!(value.id in ctx.reasoningMap)) return
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Reasoning.Ended.Sync, {
+              yield* events.publish(SessionEvent.Reasoning.Ended, {
                sessionID: ctx.sessionID,
                reasoningID: value.id,
                text: ctx.reasoningMap[value.id].text,
@@ -292,7 +277,7 @@ export const layer: Layer.Layer<
            }
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Tool.Input.Started.Sync, {
+              yield* events.publish(SessionEvent.Tool.Input.Started, {
                sessionID: ctx.sessionID,
                callID: value.id,
                name: value.toolName,
@@ -323,7 +308,7 @@ export const layer: Layer.Layer<
          case "tool-input-end": {
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Tool.Input.Ended.Sync, {
+              yield* events.publish(SessionEvent.Tool.Input.Ended, {
                sessionID: ctx.sessionID,
                callID: value.id,
                text: "",
@@ -340,7 +325,7 @@ export const layer: Layer.Layer<
            const toolCall = yield* readToolCall(value.toolCallId)
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Tool.Called.Sync, {
+              yield* events.publish(SessionEvent.Tool.Called, {
                sessionID: ctx.sessionID,
                callID: value.toolCallId,
                tool: value.toolName,
@@ -428,7 +413,7 @@ export const layer: Layer.Layer<
            }
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Tool.Success.Sync, {
+              yield* events.publish(SessionEvent.Tool.Success, {
                sessionID: ctx.sessionID,
                callID: value.toolCallId,
                structured: output.metadata,
@@ -458,7 +443,7 @@ export const layer: Layer.Layer<
            const toolCall = yield* readToolCall(value.toolCallId)
            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
            if (flags.experimentalEventSystem) {
-              yield* sync.run(SessionEvent.Tool.Failed.Sync, {
+              yield* events.publish(SessionEvent.Tool.Failed, {
                sessionID: ctx.sessionID,
                callID: value.toolCallId,
                error: {
@@ -483,7 +468,7 @@ export const layer: Layer.Layer<
            if (!ctx.assistantMessage.summary) {
              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
              if (flags.experimentalEventSystem) {
-                yield* sync.run(SessionEvent.Step.Started.Sync, {
+                yield* events.publish(SessionEvent.Step.Started, {
                  sessionID: ctx.sessionID,
                  agent: input.assistantMessage.agent,
                  model: {
@@ -515,7 +500,7 @@ export const layer: Layer.Layer<
            if (!ctx.assistantMessage.summary) {
              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
              if (flags.experimentalEventSystem) {
-                yield* sync.run(SessionEvent.Step.Ended.Sync, {
+                yield* events.publish(SessionEvent.Step.Ended, {
                  sessionID: ctx.sessionID,
                  finish: value.finishReason,
                  cost: usage.cost,
@@ -572,7 +557,7 @@ export const layer: Layer.Layer<
            if (!ctx.assistantMessage.summary) {
              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
              if (flags.experimentalEventSystem) {
-                yield* sync.run(SessionEvent.Text.Started.Sync, {
+                yield* events.publish(SessionEvent.Text.Started, {
                  sessionID: ctx.sessionID,
                  timestamp: DateTime.makeUnsafe(Date.now()),
                })
@@ -619,7 +604,7 @@ export const layer: Layer.Layer<
            if (!ctx.assistantMessage.summary) {
              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
              if (flags.experimentalEventSystem) {
-                yield* sync.run(SessionEvent.Text.Ended.Sync, {
+                yield* events.publish(SessionEvent.Text.Ended, {
                  sessionID: ctx.sessionID,
                  text: ctx.currentText.text,
                  timestamp: DateTime.makeUnsafe(Date.now()),
@@ -715,7 +700,7 @@ export const layer: Layer.Layer<
        if (!ctx.assistantMessage.summary) {
          // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
          if (flags.experimentalEventSystem) {
-            yield* sync.run(SessionEvent.Step.Failed.Sync, {
+            yield* events.publish(SessionEvent.Step.Failed, {
              sessionID: ctx.sessionID,
              error: {
                type: "unknown",
@@ -769,7 +754,7 @@ export const layer: Layer.Layer<
                set: (info) => {
                  // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
                  const event = flags.experimentalEventSystem
-                    ? sync.run(SessionEvent.Retried.Sync, {
+                    ? events.publish(SessionEvent.Retried, {
                        sessionID: ctx.sessionID,
                        attempt: info.attempt,
                        error: {
@@ -830,8 +815,8 @@ export const defaultLayer = Layer.suspend(() =>
    Layer.provide(Image.defaultLayer),
    Layer.provide(Bus.layer),
    Layer.provide(Config.defaultLayer),
-    Layer.provide(SyncEvent.defaultLayer),
    Layer.provide(RuntimeFlags.defaultLayer),
+    Layer.provide(EventV2Bridge.defaultLayer),
  ),
 )

@@ -1,10 +1,11 @@
 import { and, desc, eq } from "@/storage/db"
 import type { Database } from "@/storage/db"
-import { SessionMessage } from "@/v2/session-message"
-import { SessionMessageUpdater } from "@/v2/session-message-updater"
-import { SessionEvent } from "@/v2/session-event"
+import { SessionMessage } from "@opencode-ai/core/session-message"
+import { SessionMessageUpdater } from "@opencode-ai/core/session-message-updater"
+import { SessionEvent } from "@opencode-ai/core/session-event"
 import * as DateTime from "effect/DateTime"
 import { SyncEvent } from "@/sync"
+import { EventV2Bridge } from "@/event-v2-bridge"
 import { SessionMessageTable, SessionTable } from "./session.sql"
 import type { SessionID } from "./schema"
 import { Schema } from "effect"
@@ -119,7 +120,7 @@ function update(db: Database.TxOrDb, event: SessionEvent.Event) {
 }

 export default [
-  SyncEvent.project(SessionEvent.AgentSwitched.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.AgentSwitched), (db, data, event) => {
    db.update(SessionTable)
      .set({
        agent: data.agent,
@@ -129,7 +130,7 @@ export default [
      .run()
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.agent.switched", data })
  }),
-  SyncEvent.project(SessionEvent.ModelSwitched.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.ModelSwitched), (db, data, event) => {
    db.update(SessionTable)
      .set({
        model: data.model,
@@ -139,65 +140,65 @@ export default [
      .run()
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.model.switched", data })
  }),
-  SyncEvent.project(SessionEvent.Prompted.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Prompted), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.prompted", data })
  }),
-  SyncEvent.project(SessionEvent.Synthetic.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Synthetic), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.synthetic", data })
  }),
-  SyncEvent.project(SessionEvent.Shell.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Shell.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.shell.started", data })
  }),
-  SyncEvent.project(SessionEvent.Shell.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Shell.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.shell.ended", data })
  }),
-  SyncEvent.project(SessionEvent.Step.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Step.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.step.started", data })
  }),
-  SyncEvent.project(SessionEvent.Step.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Step.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.step.ended", data })
  }),
-  SyncEvent.project(SessionEvent.Step.Failed.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Step.Failed), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.step.failed", data })
  }),
-  SyncEvent.project(SessionEvent.Text.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Text.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.text.started", data })
  }),
-  SyncEvent.project(SessionEvent.Text.Delta.Sync, () => {}),
-  SyncEvent.project(SessionEvent.Text.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Text.Delta), () => {}),
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Text.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.text.ended", data })
  }),
-  SyncEvent.project(SessionEvent.Tool.Input.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Input.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.tool.input.started", data })
  }),
-  SyncEvent.project(SessionEvent.Tool.Input.Delta.Sync, () => {}),
-  SyncEvent.project(SessionEvent.Tool.Input.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Input.Delta), () => {}),
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Input.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.tool.input.ended", data })
  }),
-  SyncEvent.project(SessionEvent.Tool.Called.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Called), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.tool.called", data })
  }),
-  SyncEvent.project(SessionEvent.Tool.Success.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Success), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.tool.success", data })
  }),
-  SyncEvent.project(SessionEvent.Tool.Failed.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Tool.Failed), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.tool.failed", data })
  }),
-  SyncEvent.project(SessionEvent.Reasoning.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Reasoning.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.reasoning.started", data })
  }),
-  SyncEvent.project(SessionEvent.Reasoning.Delta.Sync, () => {}),
-  SyncEvent.project(SessionEvent.Reasoning.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Reasoning.Delta), () => {}),
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Reasoning.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.reasoning.ended", data })
  }),
-  SyncEvent.project(SessionEvent.Retried.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Retried), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.retried", data })
  }),
-  SyncEvent.project(SessionEvent.Compaction.Started.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Compaction.Started), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.compaction.started", data })
  }),
-  SyncEvent.project(SessionEvent.Compaction.Delta.Sync, () => {}),
-  SyncEvent.project(SessionEvent.Compaction.Ended.Sync, (db, data, event) => {
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Compaction.Delta), () => {}),
+  SyncEvent.project(EventV2Bridge.toSyncDefinition(SessionEvent.Compaction.Ended), (db, data, event) => {
    update(db, { id: SessionMessage.ID.make(event.id), type: "session.next.compaction.ended", data })
  }),
 ]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dax Raad	b246824fdb	chore remove snapshot install smoke test	2026-05-15 18:37:19 -04:00
Dax Raad	e9db6c4209	fix npm cli binary installation	2026-05-15 18:33:39 -04:00
opencode-agent[bot]	da495fd2e0	chore: generate	2026-05-15 22:09:43 +00:00
vimtor	85cd447910	chore: reduce alerts noise	2026-05-16 00:07:59 +02:00
Sebastian	0f31fd631b	Fix multiline mentions (#27649 )	2026-05-15 23:04:20 +02:00
Sebastian	aa07e21945	handle undefined tips (#27635 )	2026-05-15 23:04:00 +02:00
Shoubhit Dash	f060874b29	feat(tui): add minimal thinking mode with click-to-expand (#27623 )	2026-05-16 02:09:58 +05:30
vimtor	f21c582db9	chore: reduce alerting noise	2026-05-15 22:18:50 +02:00
Shoubhit Dash	65f96a5851	refactor(instance): retire WithInstance adapter (#27782 )	2026-05-16 01:30:07 +05:30
Aiden Cline	48122b31cc	fix(tool): bridge custom tool zod metadata (#27770 )	2026-05-15 14:50:21 -05:00
opencode-agent[bot]	0df2f5b45f	chore: generate	2026-05-15 19:48:45 +00:00
Shoubhit Dash	499e8e4b78	test(instance): add effect-native fixture helpers (#27781 )	2026-05-16 01:17:37 +05:30
Shoubhit Dash	f33b4455a1	feat(tui): enable pinned session switching (#27780 )	2026-05-16 01:10:16 +05:30
Shoubhit Dash	a24abd2b11	refactor(lsp): require explicit instance context (#27767 )	2026-05-16 00:46:27 +05:30
opencode-agent[bot]	d44bef2107	chore: generate	2026-05-15 18:45:24 +00:00
Shoubhit Dash	f99339e525	fix(tui): keep session switching pinned-only (#27775 )	2026-05-16 00:14:07 +05:30
Shoubhit Dash	2b0e72ab79	refactor(workspace): centralize adapter invocation (#27768 )	2026-05-15 23:59:01 +05:30
Shoubhit Dash	2fdee50b3b	refactor(acp): extract runtime reentry (#27769 )	2026-05-15 23:58:52 +05:30
opencode-agent[bot]	48293c5271	chore: generate	2026-05-15 17:37:07 +00:00
Shoubhit Dash	0c9cfe923f	refactor(instance): remove legacy runtime fallback (#27757 )	2026-05-15 23:05:44 +05:30
opencode-agent[bot]	9975c1ed1c	chore: generate	2026-05-15 15:12:20 +00:00
Aiden Cline	ef7d801271	fix(tool): preserve custom tool arg descriptions (#27750 ) Co-authored-by: khimaros <231498+khimaros@users.noreply.github.com>	2026-05-15 10:11:01 -05:00
opencode-agent[bot]	eb630075c3	chore: generate	2026-05-15 15:01:55 +00:00
Shoubhit Dash	a2392ca60d	refactor(worktree): provide runtime reentry refs (#27754 )	2026-05-15 20:30:29 +05:30
opencode-agent[bot]	f9371eb66c	chore: generate	2026-05-15 14:36:04 +00:00
Shoubhit Dash	fa9a2cb24d	refactor(instance): remove remaining bind call sites (#27731 )	2026-05-15 20:04:42 +05:30
Victor Navarro	2d90f325fc	ci: catch provider errors across all opencode tiers (#27495 )	2026-05-15 16:31:59 +02:00
Aiden Cline	c2ffd7cf14	fix: markdown table rendering (#27747 )	2026-05-15 09:22:24 -05:00
vimtor	104f5d5a14	chore: exclude provider from triggers	2026-05-15 16:01:11 +02:00
Shoubhit Dash	1c7c03332e	test(workspace): avoid legacy instance reads (#27727 )	2026-05-15 17:07:21 +05:30
opencode-agent[bot]	984eefa6f8	chore: generate	2026-05-15 11:02:14 +00:00
Shoubhit Dash	bf64f8cbb5	refactor(cli): dispose bootstrap instance explicitly (#27721 )	2026-05-15 16:30:54 +05:30
opencode-agent[bot]	727a83aa7a	chore: generate	2026-05-15 10:46:06 +00:00
Shoubhit Dash	e65383810a	refactor(tool): read repo overview directory from instance state (#27717 )	2026-05-15 16:14:49 +05:30
Shoubhit Dash	12b666e2c9	refactor(project): import instance context directly (#27714 )	2026-05-15 15:59:56 +05:30
Shoubhit Dash	eb5ef1c073	refactor(flags): remove unused flag exports (#27709 )	2026-05-15 15:35:24 +05:30
Shoubhit Dash	356f684186	refactor(flags): migrate skip migrations flag (#27705 )	2026-05-15 14:54:29 +05:30
Shoubhit Dash	7b370406a9	refactor(flags): migrate lsp download flag (#27699 )	2026-05-15 14:35:31 +05:30
Shoubhit Dash	202cc863b4	refactor(flags): migrate claude code prompt flag (#27690 )	2026-05-15 14:17:04 +05:30
Shoubhit Dash	22cb0395e2	refactor(flags): migrate external skills flag (#27685 )	2026-05-15 13:24:56 +05:30
Shoubhit Dash	2d6bedecd4	refactor(flags): migrate output token max to runtime flags (#27680 )	2026-05-15 13:07:35 +05:30
opencode-agent[bot]	2080390ca6	chore: generate	2026-05-15 07:36:10 +00:00
Kagura	1ac3f09468	fix(watcher): resolve symlinked .git path before subscribing (#27016 ) Co-authored-by: Simon Klee <hello@simonklee.dk>	2026-05-15 09:34:53 +02:00
Aiden Cline	ca8f578f2f	ci: skip previously cleaned PRs (#27670 )	2026-05-15 00:23:09 -05:00
Aiden Cline	d59d99665b	ci: Automate PR cleanup (#27667 )	2026-05-14 23:47:59 -05:00
opencode	c43edc5b71	sync release versions for v1.15.0	2026-05-15 04:03:54 +00:00
Dax Raad	7a012cac08	fix(tool): ignore invalid custom tool exports	2026-05-14 23:36:28 -04:00
James Long	af06e52708	fix(session): ignore instruction lookup errors (#27656 )	2026-05-14 23:12:30 -04:00
Dax Raad	f807152724	core: fix event projector lookup to use versioned type keys Fixes a bug where projectors were stored with Definition object references as Map keys but lookups were failing due to object identity mismatches. Now uses versioned type strings as keys, ensuring events are correctly matched to their projectors during sync processing. This fixes issues where certain events would not be properly projected to the read model, causing stale or missing data in views.	2026-05-14 22:52:03 -04:00
Dax Raad	b0ea7a5aa7	more test fixes	2026-05-14 22:45:09 -04:00
opencode-agent[bot]	34b1be5bcd	chore: generate	2026-05-15 02:34:06 +00:00
Dax Raad	16639eee76	test fixes	2026-05-14 22:32:38 -04:00
opencode-agent[bot]	10c8493940	chore: generate	2026-05-15 02:14:56 +00:00
Dax Raad	a50ff72f3f	fix: remove debug logging	2026-05-14 22:13:15 -04:00
Dax Raad	5f4e5e6896	more typecheck fixes	2026-05-14 22:05:12 -04:00
Dax Raad	f39cf911d7	fix missing event types in sdk	2026-05-14 21:57:25 -04:00
Brendan Allan	f179dcbf02	fix(app): only run session.updated archive logic if archive state changes (#27637 )	2026-05-15 09:42:47 +08:00
opencode-agent[bot]	fd6a8520b8	chore: generate	2026-05-15 00:52:06 +00:00
Dax	e11e089e42	Add Effect-native core event system (#27415 )	2026-05-15 00:50:23 +00:00
Luna Seemann	73cdba959b	feat(desktop): auto-hide menu bar on Linux and Windows (#27618 )	2026-05-15 08:48:29 +08:00
opencode	4e7a60dac6	sync release versions for v1.14.51	2026-05-15 00:39:54 +00:00