effectify fromDirectory: use git/fsys/pathSvc/db throughout

- Convert all git calls to ChildProcessSpawner-based git helper
- Use FileSystem for cached ID read/write and sandbox existence checks
- Use Path for all path resolution (no more raw path module)
- Use db() for all Database operations (select, upsert, session migration)
- Parallel sandbox existence checks via Effect.forEach + concurrency
- Remove iife, existsSync dependencies

.opencode/command/changelog.md

@@ -0,0 +1,5 @@
+go through each PR merged since the last tag
+
+for each PR spawn a subagent to summarize what the PR was about. focus on user facing changes. if it was entirely internal or code related you can ignore it. also skip docs updates. each subagent should append its summary to UPCOMING_CHANGELOG.md
+
+once that is done, read UPCOMING_CHANGELOG.md and group it into sections for better readability. make sure all PR references are preserved

bun.lock

@@ -26,7 +26,7 @@
     },
     "packages/app": {
       "name": "@opencode-ai/app",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@kobalte/core": "catalog:",
         "@opencode-ai/sdk": "workspace:*",
@@ -78,7 +78,7 @@
     },
     "packages/console/app": {
       "name": "@opencode-ai/console-app",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@cloudflare/vite-plugin": "1.15.2",
         "@ibm/plex": "6.4.1",
@@ -112,7 +112,7 @@
     },
     "packages/console/core": {
       "name": "@opencode-ai/console-core",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@aws-sdk/client-sts": "3.782.0",
         "@jsx-email/render": "1.1.1",
@@ -139,7 +139,7 @@
     },
     "packages/console/function": {
       "name": "@opencode-ai/console-function",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@ai-sdk/anthropic": "2.0.0",
         "@ai-sdk/openai": "2.0.2",
@@ -163,7 +163,7 @@
     },
     "packages/console/mail": {
       "name": "@opencode-ai/console-mail",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@jsx-email/all": "2.2.3",
         "@jsx-email/cli": "1.4.3",
@@ -187,7 +187,7 @@
     },
     "packages/desktop": {
       "name": "@opencode-ai/desktop",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@opencode-ai/app": "workspace:*",
         "@opencode-ai/ui": "workspace:*",
@@ -220,7 +220,7 @@
     },
     "packages/desktop-electron": {
       "name": "@opencode-ai/desktop-electron",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@opencode-ai/app": "workspace:*",
         "@opencode-ai/ui": "workspace:*",
@@ -251,7 +251,7 @@
     },
     "packages/enterprise": {
       "name": "@opencode-ai/enterprise",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@opencode-ai/ui": "workspace:*",
         "@opencode-ai/util": "workspace:*",
@@ -280,7 +280,7 @@
     },
     "packages/function": {
       "name": "@opencode-ai/function",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@octokit/auth-app": "8.0.1",
         "@octokit/rest": "catalog:",
@@ -296,7 +296,7 @@
     },
     "packages/opencode": {
       "name": "opencode",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "bin": {
         "opencode": "./bin/opencode",
       },
@@ -420,7 +420,7 @@
     },
     "packages/plugin": {
       "name": "@opencode-ai/plugin",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@opencode-ai/sdk": "workspace:*",
         "zod": "catalog:",
@@ -444,7 +444,7 @@
     },
     "packages/sdk/js": {
       "name": "@opencode-ai/sdk",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "devDependencies": {
         "@hey-api/openapi-ts": "0.90.10",
         "@tsconfig/node22": "catalog:",
@@ -455,7 +455,7 @@
     },
     "packages/slack": {
       "name": "@opencode-ai/slack",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@opencode-ai/sdk": "workspace:*",
         "@slack/bolt": "^3.17.1",
@@ -490,7 +490,7 @@
     },
     "packages/ui": {
       "name": "@opencode-ai/ui",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@kobalte/core": "catalog:",
         "@opencode-ai/sdk": "workspace:*",
@@ -536,7 +536,7 @@
     },
     "packages/util": {
       "name": "@opencode-ai/util",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "zod": "catalog:",
       },
@@ -547,7 +547,7 @@
     },
     "packages/web": {
       "name": "@opencode-ai/web",
-      "version": "1.2.27",
+      "version": "1.3.0",
       "dependencies": {
         "@astrojs/cloudflare": "12.6.3",
         "@astrojs/markdown-remark": "6.3.1",

packages/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/app",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "description": "",
   "type": "module",
   "exports": {

packages/app/src/pages/layout.tsx

@@ -2368,14 +2368,12 @@ export default function Layout(props: ParentProps) {
                     size={layout.sidebar.width()}
                     min={244}
                     max={typeof window === "undefined" ? 1000 : window.innerWidth * 0.3 + 64}
-                    collapseThreshold={244}
                     onResize={(w) => {
                       setState("sizing", true)
                       if (sizet !== undefined) clearTimeout(sizet)
                       sizet = window.setTimeout(() => setState("sizing", false), 120)
                       layout.sidebar.resize(w)
                     }}
-                    onCollapse={layout.sidebar.close}
                   />
                 </div>
               </Show>

packages/console/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/console-app",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/console/core/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/console-core",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "license": "MIT",

packages/console/function/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/console-function",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "$schema": "https://json.schemastore.org/package.json",
   "private": true,
   "type": "module",

packages/console/mail/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/console-mail",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "dependencies": {
     "@jsx-email/all": "2.2.3",
     "@jsx-email/cli": "1.4.3",

packages/desktop-electron/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opencode-ai/desktop-electron",
   "private": true,
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "homepage": "https://opencode.ai",

packages/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opencode-ai/desktop",
   "private": true,
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/enterprise/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/enterprise",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "license": "MIT",

packages/extensions/zed/extension.toml

@@ -1,7 +1,7 @@
 id = "opencode"
 name = "OpenCode"
 description = "The open source coding agent."
-version = "1.2.27"
+version = "1.3.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.2.27/opencode-darwin-arm64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.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.2.27/opencode-darwin-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.0/opencode-darwin-x64.zip"
 cmd = "./opencode"
 args = ["acp"]
 
 [agent_servers.opencode.targets.linux-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.2.27/opencode-linux-arm64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.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.2.27/opencode-linux-x64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.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.2.27/opencode-windows-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.0/opencode-windows-x64.zip"
 cmd = "./opencode.exe"
 args = ["acp"]

packages/function/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/function",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "$schema": "https://json.schemastore.org/package.json",
   "private": true,
   "type": "module",

packages/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "name": "opencode",
   "type": "module",
   "license": "MIT",

packages/opencode/specs/effect-migration.md

@@ -173,6 +173,6 @@ Still open and likely worth migrating:
 - [ ] `SessionPrompt`
 - [ ] `SessionCompaction`
 - [ ] `Provider`
-- [ ] `Project`
+- [x] `Project`
 - [ ] `LSP`
 - [ ] `MCP`

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -5,8 +5,8 @@ import { MouseButton, TextAttributes } from "@opentui/core"
 import { RouteProvider, useRoute } from "@tui/context/route"
 import { Switch, Match, createEffect, untrack, ErrorBoundary, createSignal, onMount, batch, Show, on } from "solid-js"
 import { win32DisableProcessedInput, win32FlushInputBuffer, win32InstallCtrlCGuard } from "./win32"
-import { Installation } from "@/installation"
 import { Flag } from "@/flag/flag"
+import semver from "semver"
 import { DialogProvider, useDialog } from "@tui/ui/dialog"
 import { DialogProvider as DialogProviderList } from "@tui/component/dialog-provider"
 import { SDKProvider, useSDK } from "@tui/context/sdk"
@@ -29,6 +29,7 @@ import { PromptHistoryProvider } from "./component/prompt/history"
 import { FrecencyProvider } from "./component/prompt/frecency"
 import { PromptStashProvider } from "./component/prompt/stash"
 import { DialogAlert } from "./ui/dialog-alert"
+import { DialogConfirm } from "./ui/dialog-confirm"
 import { ToastProvider, useToast } from "./ui/toast"
 import { ExitProvider, useExit } from "./context/exit"
 import { Session as SessionApi } from "@/session"
@@ -103,6 +104,7 @@ async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
 }
 
 import type { EventSource } from "./context/sdk"
+import { Installation } from "@/installation"
 
 export function tui(input: {
   url: string
@@ -729,13 +731,51 @@ function App() {
     })
   })
 
-  sdk.event.on(Installation.Event.UpdateAvailable.type, (evt) => {
+  sdk.event.on("installation.update-available", async (evt) => {
+    const version = evt.properties.version
+
+    const skipped = kv.get("skipped_version")
+    if (skipped && !semver.gt(version, skipped)) return
+
+    const choice = await DialogConfirm.show(
+      dialog,
+      `Update Available`,
+      `A new release v${version} is available. Would you like to update now?`,
+      "skip",
+    )
+
+    if (choice === false) {
+      kv.set("skipped_version", version)
+      return
+    }
+
+    if (choice !== true) return
+
     toast.show({
       variant: "info",
-      title: "Update Available",
-      message: `OpenCode v${evt.properties.version} is available. Run 'opencode upgrade' to update manually.`,
-      duration: 10000,
+      message: `Updating to v${version}...`,
+      duration: 30000,
     })
+
+    const result = await sdk.client.global.upgrade({ target: version })
+
+    if (result.error || !result.data?.success) {
+      toast.show({
+        variant: "error",
+        title: "Update Failed",
+        message: "Update failed",
+        duration: 10000,
+      })
+      return
+    }
+
+    await DialogAlert.show(
+      dialog,
+      "Update Complete",
+      `Successfully updated to OpenCode v${result.data.version}. Please restart the application.`,
+    )
+
+    exit()
   })
 
   return (

packages/opencode/src/cli/cmd/tui/ui/dialog-confirm.tsx

@@ -11,8 +11,11 @@ export type DialogConfirmProps = {
   message: string
   onConfirm?: () => void
   onCancel?: () => void
+  label?: string
 }
 
+export type DialogConfirmResult = boolean | undefined
+
 export function DialogConfirm(props: DialogConfirmProps) {
   const dialog = useDialog()
   const { theme } = useTheme()
@@ -45,7 +48,7 @@ export function DialogConfirm(props: DialogConfirmProps) {
         <text fg={theme.textMuted}>{props.message}</text>
       </box>
       <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
-        <For each={["cancel", "confirm"]}>
+        <For each={["cancel", "confirm"] as const}>
           {(key) => (
             <box
               paddingLeft={1}
@@ -58,7 +61,7 @@ export function DialogConfirm(props: DialogConfirmProps) {
               }}
             >
               <text fg={key === store.active ? theme.selectedListItemText : theme.textMuted}>
-                {Locale.titlecase(key)}
+                {Locale.titlecase(key === "cancel" ? (props.label ?? key) : key)}
               </text>
             </box>
           )}
@@ -68,8 +71,8 @@ export function DialogConfirm(props: DialogConfirmProps) {
   )
 }
 
-DialogConfirm.show = (dialog: DialogContext, title: string, message: string) => {
-  return new Promise<boolean>((resolve) => {
+DialogConfirm.show = (dialog: DialogContext, title: string, message: string, label?: string) => {
+  return new Promise<DialogConfirmResult>((resolve) => {
     dialog.replace(
       () => (
         <DialogConfirm
@@ -77,9 +80,10 @@ DialogConfirm.show = (dialog: DialogContext, title: string, message: string) =>
           message={message}
           onConfirm={() => resolve(true)}
           onCancel={() => resolve(false)}
+          label={label}
         />
       ),
-      () => resolve(false),
+      () => resolve(undefined),
     )
   })
 }

packages/opencode/src/cli/upgrade.ts

@@ -8,12 +8,18 @@ export async function upgrade() {
   const method = await Installation.method()
   const latest = await Installation.latest(method).catch(() => {})
   if (!latest) return
-  if (Installation.VERSION === latest) return
 
-  if (config.autoupdate === false || Flag.OPENCODE_DISABLE_AUTOUPDATE) {
+  if (Flag.OPENCODE_ALWAYS_NOTIFY_UPDATE) {
+    await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
     return
   }
-  if (config.autoupdate === "notify") {
+
+  if (Installation.VERSION === latest) return
+  if (config.autoupdate === false || Flag.OPENCODE_DISABLE_AUTOUPDATE) return
+
+  const kind = Installation.getReleaseType(Installation.VERSION, latest)
+
+  if (config.autoupdate === "notify" || kind !== "patch") {
     await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
     return
   }

packages/opencode/src/flag/flag.ts

@@ -18,6 +18,7 @@ export namespace Flag {
   export declare const OPENCODE_CONFIG_DIR: string | undefined
   export const OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"]
   export const OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE")
+  export const OPENCODE_ALWAYS_NOTIFY_UPDATE = truthy("OPENCODE_ALWAYS_NOTIFY_UPDATE")
   export const OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE")
   export const OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE")
   export const OPENCODE_PERMISSION = process.env["OPENCODE_PERMISSION"]

packages/opencode/src/installation/index.ts

@@ -15,11 +15,15 @@ declare global {
   const OPENCODE_CHANNEL: string
 }
 
+import semver from "semver"
+
 export namespace Installation {
   const log = Log.create({ service: "installation" })
 
   export type Method = "curl" | "npm" | "yarn" | "pnpm" | "bun" | "brew" | "scoop" | "choco" | "unknown"
 
+  export type ReleaseType = "patch" | "minor" | "major"
+
   export const Event = {
     Updated: BusEvent.define(
       "installation.updated",
@@ -35,6 +39,17 @@ export namespace Installation {
     ),
   }
 
+  export function getReleaseType(current: string, latest: string): ReleaseType {
+    const currMajor = semver.major(current)
+    const currMinor = semver.minor(current)
+    const newMajor = semver.major(latest)
+    const newMinor = semver.minor(latest)
+
+    if (newMajor > currMajor) return "major"
+    if (newMinor > currMinor) return "minor"
+    return "patch"
+  }
+
   export const Info = z
     .object({
       version: z.string(),

packages/opencode/src/project/project.ts

@@ -6,7 +6,6 @@ import { ProjectTable } from "./project.sql"
 import { SessionTable } from "../session/session.sql"
 import { Log } from "../util/log"
 import { Flag } from "@/flag/flag"
-import { fn } from "@opencode-ai/util/fn"
 import { BusEvent } from "@/bus/bus-event"
 import { iife } from "@/util/iife"
 import { GlobalBus } from "@/bus/global"
@@ -15,6 +14,10 @@ import { git } from "../util/git"
 import { Glob } from "../util/glob"
 import { which } from "../util/which"
 import { ProjectID } from "./schema"
+import { Effect, FileSystem, Layer, Path, ServiceMap, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node"
+import { makeRunPromise } from "@/effect/run-service"
 
 export namespace Project {
   const log = Log.create({ service: "project" })
@@ -360,40 +363,40 @@ export namespace Project {
     return (await fromDirectory(input.directory)).project
   }
 
-  export const update = fn(
-    z.object({
-      projectID: ProjectID.zod,
-      name: z.string().optional(),
-      icon: Info.shape.icon.optional(),
-      commands: Info.shape.commands.optional(),
-    }),
-    async (input) => {
-      const id = ProjectID.make(input.projectID)
-      const result = Database.use((db) =>
-        db
-          .update(ProjectTable)
-          .set({
-            name: input.name,
-            icon_url: input.icon?.url,
-            icon_color: input.icon?.color,
-            commands: input.commands,
-            time_updated: Date.now(),
-          })
-          .where(eq(ProjectTable.id, id))
-          .returning()
-          .get(),
-      )
-      if (!result) throw new Error(`Project not found: ${input.projectID}`)
-      const data = fromRow(result)
-      GlobalBus.emit("event", {
-        payload: {
-          type: Event.Updated.type,
-          properties: data,
-        },
-      })
-      return data
-    },
-  )
+  export const UpdateInput = z.object({
+    projectID: ProjectID.zod,
+    name: z.string().optional(),
+    icon: Info.shape.icon.optional(),
+    commands: Info.shape.commands.optional(),
+  })
+  export type UpdateInput = z.infer<typeof UpdateInput>
+
+  export async function update(input: UpdateInput) {
+    const id = ProjectID.make(input.projectID)
+    const result = Database.use((db) =>
+      db
+        .update(ProjectTable)
+        .set({
+          name: input.name,
+          icon_url: input.icon?.url,
+          icon_color: input.icon?.color,
+          commands: input.commands,
+          time_updated: Date.now(),
+        })
+        .where(eq(ProjectTable.id, id))
+        .returning()
+        .get(),
+    )
+    if (!result) throw new Error(`Project not found: ${input.projectID}`)
+    const data = fromRow(result)
+    GlobalBus.emit("event", {
+      payload: {
+        type: Event.Updated.type,
+        properties: data,
+      },
+    })
+    return data
+  }
 
   export async function sandboxes(id: ProjectID) {
     const row = Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
@@ -453,4 +456,359 @@ export namespace Project {
     })
     return data
   }
+
+  // ---------------------------------------------------------------------------
+  // Effect service
+  // ---------------------------------------------------------------------------
+
+  export interface Interface {
+    readonly fromDirectory: (directory: string) => Effect.Effect<{ project: Info; sandbox: string }>
+    readonly discover: (input: Info) => Effect.Effect<void>
+    readonly list: () => Effect.Effect<Info[]>
+    readonly get: (id: ProjectID) => Effect.Effect<Info | undefined>
+    readonly update: (input: UpdateInput) => Effect.Effect<Info>
+    readonly initGit: (input: { directory: string; project: Info }) => Effect.Effect<Info>
+    readonly setInitialized: (id: ProjectID) => Effect.Effect<void>
+    readonly sandboxes: (id: ProjectID) => Effect.Effect<string[]>
+    readonly addSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
+    readonly removeSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Project") {}
+
+  type GitResult = { code: number; text: string; stderr: string }
+
+  export const layer: Layer.Layer<
+    Service,
+    never,
+    FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner
+  > = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fsys = yield* FileSystem.FileSystem
+      const pathSvc = yield* Path.Path
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+      const git = Effect.fnUntraced(
+        function* (args: string[], opts?: { cwd?: string }) {
+          const handle = yield* spawner.spawn(ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true }))
+          const [text, stderr] = yield* Effect.all(
+            [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
+            { concurrency: 2 },
+          )
+          const code = yield* handle.exitCode
+          return { code, text, stderr } satisfies GitResult
+        },
+        Effect.scoped,
+        Effect.catch(() => Effect.succeed({ code: 1, text: "", stderr: "" } satisfies GitResult)),
+      )
+
+      const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
+        Effect.sync(() => Database.use(fn))
+
+      function emitUpdated(data: Info) {
+        GlobalBus.emit("event", {
+          payload: { type: Event.Updated.type, properties: data },
+        })
+      }
+
+      return Service.of({
+        fromDirectory: Effect.fn("Project.fromDirectory")(function* (directory: string) {
+          log.info("fromDirectory", { directory })
+
+          const resolveGitPath = (cwd: string, name: string) => {
+            if (!name) return cwd
+            name = name.replace(/[\r\n]+$/, "")
+            if (!name) return cwd
+            name = Filesystem.windowsPath(name)
+            if (pathSvc.isAbsolute(name)) return pathSvc.normalize(name)
+            return pathSvc.resolve(cwd, name)
+          }
+
+          const readCachedProjectId = Effect.fnUntraced(function* (dir: string) {
+            const content = yield* fsys.readFileString(pathSvc.join(dir, "opencode")).pipe(
+              Effect.map((x) => x.trim()),
+              Effect.map(ProjectID.make),
+              Effect.catch(() => Effect.succeed(undefined)),
+            )
+            return content
+          })
+
+          // Phase 1: discover git info
+          type DiscoveryResult = { id: ProjectID; worktree: string; sandbox: string; vcs: Info["vcs"] }
+
+          const data: DiscoveryResult = yield* Effect.gen(function* () {
+            const matches = Filesystem.up({ targets: [".git"], start: directory })
+            const dotgit = yield* Effect.promise(() => matches.next().then((x) => x.value))
+            yield* Effect.promise(() => matches.return())
+
+            if (!dotgit) {
+              return {
+                id: ProjectID.global,
+                worktree: "/",
+                sandbox: "/",
+                vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+              }
+            }
+
+            let sandbox = pathSvc.dirname(dotgit)
+            const gitBinary = which("git")
+            let id = yield* readCachedProjectId(dotgit)
+
+            if (!gitBinary) {
+              return {
+                id: id ?? ProjectID.global,
+                worktree: sandbox,
+                sandbox,
+                vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+              }
+            }
+
+            const commonDir = yield* git(["rev-parse", "--git-common-dir"], { cwd: sandbox })
+            const worktree = commonDir.code === 0
+              ? (() => {
+                  const common = resolveGitPath(sandbox, commonDir.text.trim())
+                  return common === sandbox ? sandbox : pathSvc.dirname(common)
+                })()
+              : undefined
+
+            if (!worktree) {
+              return {
+                id: id ?? ProjectID.global,
+                worktree: sandbox,
+                sandbox,
+                vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+              }
+            }
+
+            if (id == null) {
+              id = yield* readCachedProjectId(pathSvc.join(worktree, ".git"))
+            }
+
+            if (!id) {
+              const revList = yield* git(["rev-list", "--max-parents=0", "HEAD"], { cwd: sandbox })
+              const roots = revList.code === 0
+                ? revList.text.split("\n").filter(Boolean).map((x) => x.trim()).toSorted()
+                : undefined
+
+              if (!roots) {
+                return {
+                  id: ProjectID.global,
+                  worktree: sandbox,
+                  sandbox,
+                  vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+                }
+              }
+
+              id = roots[0] ? ProjectID.make(roots[0]) : undefined
+              if (id) {
+                yield* fsys.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect.ignore)
+              }
+            }
+
+            if (!id) {
+              return { id: ProjectID.global, worktree: sandbox, sandbox, vcs: "git" as const }
+            }
+
+            const topLevel = yield* git(["rev-parse", "--show-toplevel"], { cwd: sandbox })
+            if (topLevel.code === 0) {
+              sandbox = resolveGitPath(sandbox, topLevel.text.trim())
+            } else {
+              return {
+                id,
+                worktree: sandbox,
+                sandbox,
+                vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+              }
+            }
+
+            return { id, sandbox, worktree, vcs: "git" as const }
+          })
+
+          // Phase 2: upsert
+          const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, data.id)).get())
+          const existing = row
+            ? fromRow(row)
+            : {
+                id: data.id,
+                worktree: data.worktree,
+                vcs: data.vcs,
+                sandboxes: [] as string[],
+                time: { created: Date.now(), updated: Date.now() },
+              }
+
+          if (Flag.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY) discover(existing)
+
+          const result: Info = {
+            ...existing,
+            worktree: data.worktree,
+            vcs: data.vcs,
+            time: { ...existing.time, updated: Date.now() },
+          }
+          if (data.sandbox !== result.worktree && !result.sandboxes.includes(data.sandbox))
+            result.sandboxes.push(data.sandbox)
+          result.sandboxes = yield* Effect.forEach(
+            result.sandboxes,
+            (s) => fsys.exists(s).pipe(Effect.orDie, Effect.map((exists) => (exists ? s : undefined))),
+            { concurrency: "unbounded" },
+          ).pipe(Effect.map((arr) => arr.filter((x): x is string => x !== undefined)))
+
+          yield* db((d) =>
+            d.insert(ProjectTable).values({
+              id: result.id,
+              worktree: result.worktree,
+              vcs: result.vcs ?? null,
+              name: result.name,
+              icon_url: result.icon?.url,
+              icon_color: result.icon?.color,
+              time_created: result.time.created,
+              time_updated: result.time.updated,
+              time_initialized: result.time.initialized,
+              sandboxes: result.sandboxes,
+              commands: result.commands,
+            }).onConflictDoUpdate({
+              target: ProjectTable.id,
+              set: {
+                worktree: result.worktree,
+                vcs: result.vcs ?? null,
+                name: result.name,
+                icon_url: result.icon?.url,
+                icon_color: result.icon?.color,
+                time_updated: result.time.updated,
+                time_initialized: result.time.initialized,
+                sandboxes: result.sandboxes,
+                commands: result.commands,
+              },
+            }).run(),
+          )
+
+          if (data.id !== ProjectID.global) {
+            yield* db((d) =>
+              d
+                .update(SessionTable)
+                .set({ project_id: data.id })
+                .where(and(eq(SessionTable.project_id, ProjectID.global), eq(SessionTable.directory, data.worktree)))
+                .run(),
+            )
+          }
+
+          emitUpdated(result)
+          return { project: result, sandbox: data.sandbox }
+        }),
+
+        discover: Effect.fn("Project.discover")(function* (input: Info) {
+          if (input.vcs !== "git") return
+          if (input.icon?.override) return
+          if (input.icon?.url) return
+
+          const matches = yield* Effect.promise(() =>
+            Glob.scan("**/favicon.{ico,png,svg,jpg,jpeg,webp}", {
+              cwd: input.worktree,
+              absolute: true,
+              include: "file",
+            }),
+          )
+          const shortest = matches.sort((a, b) => a.length - b.length)[0]
+          if (!shortest) return
+
+          const buffer = yield* fsys.readFile(shortest).pipe(Effect.orDie)
+          const base64 = Buffer.from(buffer).toString("base64")
+          const mime = Filesystem.mimeType(shortest) || "image/png"
+          const url = `data:${mime};base64,${base64}`
+          yield* Effect.promise(() => update({ projectID: input.id, icon: { url } }))
+        }),
+
+        list: Effect.fn("Project.list")(function* () {
+          return yield* db((d) => d.select().from(ProjectTable).all().map(fromRow))
+        }),
+
+        get: Effect.fn("Project.get")(function* (id: ProjectID) {
+          const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
+          return row ? fromRow(row) : undefined
+        }),
+
+        update: Effect.fn("Project.update")(function* (input: UpdateInput) {
+          const id = ProjectID.make(input.projectID)
+          const result = yield* db((d) =>
+            d
+              .update(ProjectTable)
+              .set({
+                name: input.name,
+                icon_url: input.icon?.url,
+                icon_color: input.icon?.color,
+                commands: input.commands,
+                time_updated: Date.now(),
+              })
+              .where(eq(ProjectTable.id, id))
+              .returning()
+              .get(),
+          )
+          if (!result) throw new Error(`Project not found: ${input.projectID}`)
+          const data = fromRow(result)
+          emitUpdated(data)
+          return data
+        }),
+
+        initGit: Effect.fn("Project.initGit")(function* (input: { directory: string; project: Info }) {
+          if (input.project.vcs === "git") return input.project
+          const result = yield* git(["init", "--quiet"], { cwd: input.directory })
+          if (result.code !== 0) {
+            throw new Error(result.stderr.trim() || result.text.trim() || "Failed to initialize git repository")
+          }
+          const { project } = yield* Effect.promise(() => fromDirectory(input.directory))
+          return project
+        }),
+
+        setInitialized: Effect.fn("Project.setInitialized")(function* (id: ProjectID) {
+          yield* db((d) =>
+            d.update(ProjectTable).set({ time_initialized: Date.now() }).where(eq(ProjectTable.id, id)).run(),
+          )
+        }),
+
+        sandboxes: Effect.fn("Project.sandboxes")(function* (id: ProjectID) {
+          const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
+          if (!row) return []
+          const data = fromRow(row)
+          const valid: string[] = []
+          for (const dir of data.sandboxes) {
+            if (yield* fsys.exists(dir).pipe(Effect.orDie)) valid.push(dir)
+          }
+          return valid
+        }),
+
+        addSandbox: Effect.fn("Project.addSandbox")(function* (id: ProjectID, directory: string) {
+          const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
+          if (!row) throw new Error(`Project not found: ${id}`)
+          const sboxes = [...row.sandboxes]
+          if (!sboxes.includes(directory)) sboxes.push(directory)
+          const result = yield* db((d) =>
+              d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where(eq(ProjectTable.id, id)).returning().get(),
+          )
+          if (!result) throw new Error(`Project not found: ${id}`)
+          emitUpdated(fromRow(result))
+        }),
+
+        removeSandbox: Effect.fn("Project.removeSandbox")(function* (id: ProjectID, directory: string) {
+          const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
+          if (!row) throw new Error(`Project not found: ${id}`)
+          const sboxes = row.sandboxes.filter((s) => s !== directory)
+          const result = yield* db((d) =>
+              d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where(eq(ProjectTable.id, id)).returning().get(),
+          )
+          if (!result) throw new Error(`Project not found: ${id}`)
+          emitUpdated(fromRow(result))
+        }),
+      })
+    }),
+  )
+
+  const defaultLayer = layer.pipe(
+    Layer.provide(NodeChildProcessSpawner.layer),
+    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(NodePath.layer),
+  )
+  const runPromise = makeRunPromise(Service, defaultLayer)
+
+  // Note: list, get, setInitialized remain as direct sync functions (callers rely on sync access).
+  // The Effect service wraps them for Effect-native consumers.
 }

packages/opencode/src/server/routes/global.ts

@@ -1,7 +1,8 @@
 import { Hono } from "hono"
-import { describeRoute, resolver, validator } from "hono-openapi"
+import { describeRoute, validator, resolver } from "hono-openapi"
 import { streamSSE } from "hono/streaming"
 import z from "zod"
+import { Bus } from "../../bus"
 import { BusEvent } from "@/bus/bus-event"
 import { GlobalBus } from "@/bus/global"
 import { AsyncQueue } from "@/util/queue"
@@ -195,5 +196,62 @@ export const GlobalRoutes = lazy(() =>
         })
         return c.json(true)
       },
+    )
+    .post(
+      "/upgrade",
+      describeRoute({
+        summary: "Upgrade opencode",
+        description: "Upgrade opencode to the specified version or latest if not specified.",
+        operationId: "global.upgrade",
+        responses: {
+          200: {
+            description: "Upgrade result",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z.union([
+                    z.object({
+                      success: z.literal(true),
+                      version: z.string(),
+                    }),
+                    z.object({
+                      success: z.literal(false),
+                      error: z.string(),
+                    }),
+                  ]),
+                ),
+              },
+            },
+          },
+          ...errors(400),
+        },
+      }),
+      validator(
+        "json",
+        z.object({
+          target: z.string().optional(),
+        }),
+      ),
+      async (c) => {
+        const method = await Installation.method()
+        if (method === "unknown") {
+          return c.json({ success: false, error: "Unknown installation method" }, 400)
+        }
+        const target = c.req.valid("json").target || (await Installation.latest(method))
+        const result = await Installation.upgrade(method, target)
+          .then(() => ({ success: true as const, version: target }))
+          .catch((e) => ({ success: false as const, error: e instanceof Error ? e.message : String(e) }))
+        if (result.success) {
+          GlobalBus.emit("event", {
+            directory: "global",
+            payload: {
+              type: Installation.Event.Updated.type,
+              properties: { version: target },
+            },
+          })
+          return c.json(result)
+        }
+        return c.json(result, 500)
+      },
     ),
 )

packages/opencode/src/server/routes/project.ts

@@ -107,7 +107,7 @@ export const ProjectRoutes = lazy(() =>
         },
       }),
       validator("param", z.object({ projectID: ProjectID.zod })),
-      validator("json", Project.update.schema.omit({ projectID: true })),
+      validator("json", Project.UpdateInput.omit({ projectID: true })),
       async (c) => {
         const projectID = c.req.valid("param").projectID
         const body = c.req.valid("json")

packages/opencode/test/project/project.test.ts

@@ -393,3 +393,75 @@ describe("Project.update", () => {
     expect(updated.commands?.start).toBe("make start")
   })
 })
+
+describe("Project.list and Project.get", () => {
+  test("list returns all projects", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await Project.fromDirectory(Filesystem.resolve(tmp.path))
+
+    const all = Project.list()
+    expect(all.length).toBeGreaterThan(0)
+    expect(all.find((p) => p.id === project.id)).toBeDefined()
+  })
+
+  test("get returns project by id", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await Project.fromDirectory(Filesystem.resolve(tmp.path))
+
+    const found = Project.get(project.id)
+    expect(found).toBeDefined()
+    expect(found!.id).toBe(project.id)
+  })
+
+  test("get returns undefined for unknown id", () => {
+    const found = Project.get(ProjectID.make("nonexistent"))
+    expect(found).toBeUndefined()
+  })
+})
+
+describe("Project.setInitialized", () => {
+  test("sets time_initialized on project", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await Project.fromDirectory(Filesystem.resolve(tmp.path))
+
+    expect(project.time.initialized).toBeUndefined()
+
+    Project.setInitialized(project.id)
+
+    const updated = Project.get(project.id)
+    expect(updated?.time.initialized).toBeDefined()
+  })
+})
+
+describe("Project.addSandbox and Project.removeSandbox", () => {
+  test("addSandbox adds directory and removeSandbox removes it", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await Project.fromDirectory(Filesystem.resolve(tmp.path))
+    const sandboxDir = path.join(tmp.path, "sandbox-test")
+
+    await Project.addSandbox(project.id, sandboxDir)
+
+    let found = Project.get(project.id)
+    expect(found?.sandboxes).toContain(sandboxDir)
+
+    await Project.removeSandbox(project.id, sandboxDir)
+
+    found = Project.get(project.id)
+    expect(found?.sandboxes).not.toContain(sandboxDir)
+  })
+
+  test("addSandbox emits GlobalBus event", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await Project.fromDirectory(Filesystem.resolve(tmp.path))
+    const sandboxDir = path.join(tmp.path, "sandbox-event")
+
+    const events: any[] = []
+    const on = (evt: any) => events.push(evt)
+    GlobalBus.on("event", on)
+
+    await Project.addSandbox(project.id, sandboxDir)
+
+    GlobalBus.off("event", on)
+    expect(events.some((e) => e.payload.type === Project.Event.Updated.type)).toBe(true)
+  })
+})

packages/plugin/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/plugin",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/sdk/js/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/sdk",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/sdk/js/src/v2/gen/sdk.gen.ts

@@ -46,6 +46,8 @@ import type {
   GlobalDisposeResponses,
   GlobalEventResponses,
   GlobalHealthResponses,
+  GlobalUpgradeErrors,
+  GlobalUpgradeResponses,
   InstanceDisposeResponses,
   LspStatusResponses,
   McpAddErrors,
@@ -303,6 +305,30 @@ export class Global extends HeyApiClient {
     })
   }
 
+  /**
+   * Upgrade opencode
+   *
+   * Upgrade opencode to the specified version or latest if not specified.
+   */
+  public upgrade<ThrowOnError extends boolean = false>(
+    parameters?: {
+      target?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "body", key: "target" }] }])
+    return (options?.client ?? this.client).post<GlobalUpgradeResponses, GlobalUpgradeErrors, ThrowOnError>({
+      url: "/global/upgrade",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+
   private _config?: Config
   get config(): Config {
     return (this._config ??= new Config({ client: this.client }))

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -2030,6 +2030,41 @@ export type GlobalDisposeResponses = {
 
 export type GlobalDisposeResponse = GlobalDisposeResponses[keyof GlobalDisposeResponses]
 
+export type GlobalUpgradeData = {
+  body?: {
+    target?: string
+  }
+  path?: never
+  query?: never
+  url: "/global/upgrade"
+}
+
+export type GlobalUpgradeErrors = {
+  /**
+   * Bad request
+   */
+  400: BadRequestError
+}
+
+export type GlobalUpgradeError = GlobalUpgradeErrors[keyof GlobalUpgradeErrors]
+
+export type GlobalUpgradeResponses = {
+  /**
+   * Upgrade result
+   */
+  200:
+    | {
+        success: true
+        version: string
+      }
+    | {
+        success: false
+        error: string
+      }
+}
+
+export type GlobalUpgradeResponse = GlobalUpgradeResponses[keyof GlobalUpgradeResponses]
+
 export type AuthRemoveData = {
   body?: never
   path: {

packages/sdk/openapi.json

@@ -158,6 +158,82 @@
         ]
       }
     },
+    "/global/upgrade": {
+      "post": {
+        "operationId": "global.upgrade",
+        "summary": "Upgrade opencode",
+        "description": "Upgrade opencode to the specified version or latest if not specified.",
+        "responses": {
+          "200": {
+            "description": "Upgrade result",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "success": {
+                          "type": "boolean",
+                          "const": true
+                        },
+                        "version": {
+                          "type": "string"
+                        }
+                      },
+                      "required": ["success", "version"]
+                    },
+                    {
+                      "type": "object",
+                      "properties": {
+                        "success": {
+                          "type": "boolean",
+                          "const": false
+                        },
+                        "error": {
+                          "type": "string"
+                        }
+                      },
+                      "required": ["success", "error"]
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequestError"
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "target": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.global.upgrade({\n  ...\n})"
+          }
+        ]
+      }
+    },
     "/auth/{providerID}": {
       "put": {
         "operationId": "auth.set",

packages/slack/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/slack",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/ui",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "exports": {

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/util",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "license": "MIT",

packages/web/package.json

@@ -2,7 +2,7 @@
   "name": "@opencode-ai/web",
   "type": "module",
   "license": "MIT",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "scripts": {
     "dev": "astro dev",
     "dev:remote": "VITE_API_URL=https://api.opencode.ai astro dev",

sdks/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "opencode",
   "displayName": "opencode",
   "description": "opencode for VS Code",
-  "version": "1.2.27",
+  "version": "1.3.0",
   "publisher": "sst-dev",
   "repository": {
     "type": "git",