Merge branch 'dev' into kit/effectify-worktree

Migrate Worktree from direct Instance ALS reads to the Effect service
pattern: define Interface, Service, layer (yielding InstanceContext),
and promise facades using runPromiseInstance. Wire into instances.ts.

packages/opencode/specs/effect-migration.md

@@ -129,7 +129,7 @@ Still open and likely worth migrating:
 - [ ] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
-- [ ] `Worktree`
+- [x] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
 - [ ] `Command`

packages/opencode/src/agent/agent.ts

@@ -322,11 +322,11 @@ export namespace Agent {
       }),
     } satisfies Parameters<typeof generateObject>[0]
 
-    // TODO: clean this up so provider specific logic doesnt bleed over
     if (defaultModel.providerID === "openai" && (await Auth.get(defaultModel.providerID))?.type === "oauth") {
       const result = streamObject({
         ...params,
         providerOptions: ProviderTransform.providerOptions(model, {
+          instructions: SystemPrompt.instructions(),
           store: false,
         }),
         onError: () => {},

packages/opencode/src/effect/instances.ts

@@ -10,6 +10,7 @@ import { ProviderAuth } from "@/provider/auth"
 import { Question } from "@/question"
 import { Skill } from "@/skill/skill"
 import { Snapshot } from "@/snapshot"
+import { Worktree } from "@/worktree"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -26,6 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
+  | Worktree.Service
 
 // NOTE: LayerMap only passes the key (directory string) to lookup, but we need
 // the full instance context (directory, worktree, project). We read from the
@@ -46,6 +48,7 @@ function lookup(_key: string) {
     Layer.fresh(File.layer),
     Layer.fresh(Skill.defaultLayer),
     Layer.fresh(Snapshot.defaultLayer),
+    Layer.fresh(Worktree.layer),
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/session/llm.ts

@@ -63,14 +63,14 @@ export namespace LLM {
       Provider.getProvider(input.model.providerID),
       Auth.get(input.model.providerID),
     ])
-    // TODO: move this to a proper hook
-    const isOpenaiOauth = provider.id === "openai" && auth?.type === "oauth"
+    const isCodex = provider.id === "openai" && auth?.type === "oauth"
 
-    const system: string[] = []
+    const system = []
     system.push(
       [
         // use agent prompt otherwise provider prompt
-        ...(input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(input.model)),
+        // For Codex sessions, skip SystemPrompt.provider() since it's sent via options.instructions
+        ...(input.agent.prompt ? [input.agent.prompt] : isCodex ? [] : SystemPrompt.provider(input.model)),
         // any custom prompt passed into this call
         ...input.system,
         // any custom prompt from last user message
@@ -108,22 +108,10 @@ export namespace LLM {
       mergeDeep(input.agent.options),
       mergeDeep(variant),
     )
-    if (isOpenaiOauth) {
-      options.instructions = system.join("\n")
+    if (isCodex) {
+      options.instructions = SystemPrompt.instructions()
     }
 
-    const messages = isOpenaiOauth
-      ? input.messages
-      : [
-          ...system.map(
-            (x): ModelMessage => ({
-              role: "system",
-              content: x,
-            }),
-          ),
-          ...input.messages,
-        ]
-
     const params = await Plugin.trigger(
       "chat.params",
       {
@@ -158,9 +146,7 @@ export namespace LLM {
     )
 
     const maxOutputTokens =
-      isOpenaiOauth || provider.id.includes("github-copilot")
-        ? undefined
-        : ProviderTransform.maxOutputTokens(input.model)
+      isCodex || provider.id.includes("github-copilot") ? undefined : ProviderTransform.maxOutputTokens(input.model)
 
     const tools = await resolveTools(input)
 
@@ -231,7 +217,15 @@ export namespace LLM {
         ...headers,
       },
       maxRetries: input.retries ?? 0,
-      messages,
+      messages: [
+        ...system.map(
+          (x): ModelMessage => ({
+            role: "system",
+            content: x,
+          }),
+        ),
+        ...input.messages,
+      ],
       model: wrapLanguageModel({
         model: language,
         middleware: [

packages/opencode/src/session/system.ts

@@ -7,7 +7,7 @@ import PROMPT_DEFAULT from "./prompt/default.txt"
 import PROMPT_BEAST from "./prompt/beast.txt"
 import PROMPT_GEMINI from "./prompt/gemini.txt"
 
-import PROMPT_CODEX from "./prompt/codex.txt"
+import PROMPT_CODEX from "./prompt/codex_header.txt"
 import PROMPT_TRINITY from "./prompt/trinity.txt"
 import type { Provider } from "@/provider/provider"
 import type { Agent } from "@/agent/agent"
@@ -15,10 +15,14 @@ import { PermissionNext } from "@/permission"
 import { Skill } from "@/skill"
 
 export namespace SystemPrompt {
+  export function instructions() {
+    return PROMPT_CODEX.trim()
+  }
+
   export function provider(model: Provider.Model) {
-    if (model.api.id.includes("gpt-4") || model.api.id.includes("o1") || model.api.id.includes("o3"))
+    if (model.api.id.includes("gpt-5")) return [PROMPT_CODEX]
+    if (model.api.id.includes("gpt-") || model.api.id.includes("o1") || model.api.id.includes("o3"))
       return [PROMPT_BEAST]
-    if (model.api.id.includes("gpt")) return [PROMPT_CODEX]
     if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
     if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
     if (model.api.id.toLowerCase().includes("trinity")) return [PROMPT_TRINITY]

packages/opencode/src/worktree/index.ts

@@ -9,12 +9,14 @@ import { Project } from "../project/project"
 import { Database, eq } from "../storage/db"
 import { ProjectTable } from "../project/project.sql"
 import type { ProjectID } from "../project/schema"
-import { fn } from "../util/fn"
 import { Log } from "../util/log"
 import { Process } from "../util/process"
 import { git } from "../util/git"
 import { BusEvent } from "@/bus/bus-event"
 import { GlobalBus } from "@/bus/global"
+import { InstanceContext } from "@/effect/instance-context"
+import { runPromiseInstance } from "@/effect/runtime"
+import { Effect, Layer, ServiceMap } from "effect"
 
 export namespace Worktree {
   const log = Log.create({ service: "worktree" })
@@ -267,7 +269,7 @@ export namespace Worktree {
     return process.platform === "win32" ? normalized.toLowerCase() : normalized
   }
 
-  async function candidate(root: string, base?: string) {
+  async function candidateName(worktreeDir: string, root: string, base?: string) {
     for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
       const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
       const branch = `opencode/${name}`
@@ -277,7 +279,7 @@ export namespace Worktree {
 
       const ref = `refs/heads/${branch}`
       const branchCheck = await git(["show-ref", "--verify", "--quiet", ref], {
-        cwd: Instance.worktree,
+        cwd: worktreeDir,
       })
       if (branchCheck.exitCode === 0) continue
 
@@ -335,338 +337,419 @@ export namespace Worktree {
     }, 0)
   }
 
+  // ---------------------------------------------------------------------------
+  // Effect service
+  // ---------------------------------------------------------------------------
+
+  export interface Interface {
+    readonly makeWorktreeInfo: (name?: string) => Effect.Effect<Info>
+    readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<() => Promise<void>>
+    readonly create: (input?: CreateInput) => Effect.Effect<Info>
+    readonly remove: (input: RemoveInput) => Effect.Effect<boolean>
+    readonly reset: (input: ResetInput) => Effect.Effect<boolean>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Worktree") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+
+      const makeWorktreeInfoEffect = Effect.fn("Worktree.makeWorktreeInfo")(function* (name?: string) {
+        return yield* Effect.promise(async () => {
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const root = path.join(Global.Path.data, "worktree", instance.project.id)
+          await fs.mkdir(root, { recursive: true })
+
+          const base = name ? slug(name) : ""
+          return candidateName(instance.worktree, root, base || undefined)
+        })
+      })
+
+      const createFromInfoEffect = Effect.fn("Worktree.createFromInfo")(function* (
+        info: Info,
+        startCommand?: string,
+      ) {
+        return yield* Effect.promise(async (): Promise<() => Promise<void>> => {
+          const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
+            cwd: instance.worktree,
+          })
+          if (created.exitCode !== 0) {
+            throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
+          }
+
+          await Project.addSandbox(instance.project.id, info.directory).catch(() => undefined)
+
+          const projectID = instance.project.id
+          const extra = startCommand?.trim()
+
+          return () => {
+            const start = async () => {
+              const populated = await git(["reset", "--hard"], { cwd: info.directory })
+              if (populated.exitCode !== 0) {
+                const message = errorText(populated) || "Failed to populate worktree"
+                log.error("worktree checkout failed", { directory: info.directory, message })
+                GlobalBus.emit("event", {
+                  directory: info.directory,
+                  payload: {
+                    type: Event.Failed.type,
+                    properties: {
+                      message,
+                    },
+                  },
+                })
+                return
+              }
+
+              const booted = await Instance.provide({
+                directory: info.directory,
+                init: InstanceBootstrap,
+                fn: () => undefined,
+              })
+                .then(() => true)
+                .catch((error) => {
+                  const message = error instanceof Error ? error.message : String(error)
+                  log.error("worktree bootstrap failed", { directory: info.directory, message })
+                  GlobalBus.emit("event", {
+                    directory: info.directory,
+                    payload: {
+                      type: Event.Failed.type,
+                      properties: {
+                        message,
+                      },
+                    },
+                  })
+                  return false
+                })
+              if (!booted) return
+
+              GlobalBus.emit("event", {
+                directory: info.directory,
+                payload: {
+                  type: Event.Ready.type,
+                  properties: {
+                    name: info.name,
+                    branch: info.branch,
+                  },
+                },
+              })
+
+              await runStartScripts(info.directory, { projectID, extra })
+            }
+
+            return start().catch((error) => {
+              log.error("worktree start task failed", { directory: info.directory, error })
+            })
+          }
+        })
+      })
+
+      const createEffect = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
+        const parsed = input ? CreateInput.optional().parse(input) : undefined
+        const info = yield* makeWorktreeInfoEffect(parsed?.name)
+        const bootstrap = yield* createFromInfoEffect(info, parsed?.startCommand)
+        // This is needed due to how worktrees currently work in the
+        // desktop app
+        setTimeout(() => {
+          bootstrap()
+        }, 0)
+        return info
+      })
+
+      const removeEffect = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
+        return yield* Effect.promise(async () => {
+          const parsed = RemoveInput.parse(input)
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const directory = await canonical(parsed.directory)
+          const locate = async (stdout: Uint8Array | undefined) => {
+            const lines = outputText(stdout)
+              .split("\n")
+              .map((line) => line.trim())
+            const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
+              if (!line) return acc
+              if (line.startsWith("worktree ")) {
+                acc.push({ path: line.slice("worktree ".length).trim() })
+                return acc
+              }
+              const current = acc[acc.length - 1]
+              if (!current) return acc
+              if (line.startsWith("branch ")) {
+                current.branch = line.slice("branch ".length).trim()
+              }
+              return acc
+            }, [])
+
+            return (async () => {
+              for (const item of entries) {
+                if (!item.path) continue
+                const key = await canonical(item.path)
+                if (key === directory) return item
+              }
+            })()
+          }
+
+          const clean = (target: string) =>
+            fs
+              .rm(target, {
+                recursive: true,
+                force: true,
+                maxRetries: 5,
+                retryDelay: 100,
+              })
+              .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error)
+                throw new RemoveFailedError({ message: message || "Failed to remove git worktree directory" })
+              })
+
+          const stop = async (target: string) => {
+            if (!(await exists(target))) return
+            await git(["fsmonitor--daemon", "stop"], { cwd: target })
+          }
+
+          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+          if (list.exitCode !== 0) {
+            throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
+          }
+
+          const entry = await locate(list.stdout)
+
+          if (!entry?.path) {
+            const directoryExists = await exists(directory)
+            if (directoryExists) {
+              await stop(directory)
+              await clean(directory)
+            }
+            return true
+          }
+
+          await stop(entry.path)
+          const removed = await git(["worktree", "remove", "--force", entry.path], {
+            cwd: instance.worktree,
+          })
+          if (removed.exitCode !== 0) {
+            const next = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+            if (next.exitCode !== 0) {
+              throw new RemoveFailedError({
+                message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
+              })
+            }
+
+            const stale = await locate(next.stdout)
+            if (stale?.path) {
+              throw new RemoveFailedError({ message: errorText(removed) || "Failed to remove git worktree" })
+            }
+          }
+
+          await clean(entry.path)
+
+          const branch = entry.branch?.replace(/^refs\/heads\//, "")
+          if (branch) {
+            const deleted = await git(["branch", "-D", branch], { cwd: instance.worktree })
+            if (deleted.exitCode !== 0) {
+              throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
+            }
+          }
+
+          return true
+        })
+      })
+
+      const resetEffect = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
+        return yield* Effect.promise(async () => {
+          const parsed = ResetInput.parse(input)
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const directory = await canonical(parsed.directory)
+          const primary = await canonical(instance.worktree)
+          if (directory === primary) {
+            throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
+          }
+
+          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+          if (list.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
+          }
+
+          const lines = outputText(list.stdout)
+            .split("\n")
+            .map((line) => line.trim())
+          const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
+            if (!line) return acc
+            if (line.startsWith("worktree ")) {
+              acc.push({ path: line.slice("worktree ".length).trim() })
+              return acc
+            }
+            const current = acc[acc.length - 1]
+            if (!current) return acc
+            if (line.startsWith("branch ")) {
+              current.branch = line.slice("branch ".length).trim()
+            }
+            return acc
+          }, [])
+
+          const entry = await (async () => {
+            for (const item of entries) {
+              if (!item.path) continue
+              const key = await canonical(item.path)
+              if (key === directory) return item
+            }
+          })()
+          if (!entry?.path) {
+            throw new ResetFailedError({ message: "Worktree not found" })
+          }
+
+          const remoteList = await git(["remote"], { cwd: instance.worktree })
+          if (remoteList.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
+          }
+
+          const remotes = outputText(remoteList.stdout)
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+
+          const remote = remotes.includes("origin")
+            ? "origin"
+            : remotes.length === 1
+              ? remotes[0]
+              : remotes.includes("upstream")
+                ? "upstream"
+                : ""
+
+          const remoteHead = remote
+            ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: instance.worktree })
+            : { exitCode: 1, stdout: undefined, stderr: undefined }
+
+          const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
+          const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
+          const remoteBranch =
+            remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
+
+          const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
+            cwd: instance.worktree,
+          })
+          const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
+            cwd: instance.worktree,
+          })
+          const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
+
+          const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
+          if (!target) {
+            throw new ResetFailedError({ message: "Default branch not found" })
+          }
+
+          if (remoteBranch) {
+            const fetch = await git(["fetch", remote, remoteBranch], { cwd: instance.worktree })
+            if (fetch.exitCode !== 0) {
+              throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
+            }
+          }
+
+          if (!entry.path) {
+            throw new ResetFailedError({ message: "Worktree path not found" })
+          }
+
+          const worktreePath = entry.path
+
+          const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
+          if (resetToTarget.exitCode !== 0) {
+            throw new ResetFailedError({
+              message: errorText(resetToTarget) || "Failed to reset worktree to target",
+            })
+          }
+
+          const cleanResult = await sweep(worktreePath)
+          if (cleanResult.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(cleanResult) || "Failed to clean worktree" })
+          }
+
+          const update = await git(["submodule", "update", "--init", "--recursive", "--force"], {
+            cwd: worktreePath,
+          })
+          if (update.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
+          }
+
+          const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], {
+            cwd: worktreePath,
+          })
+          if (subReset.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" })
+          }
+
+          const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], {
+            cwd: worktreePath,
+          })
+          if (subClean.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" })
+          }
+
+          const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
+          if (status.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" })
+          }
+
+          const dirty = outputText(status.stdout)
+          if (dirty) {
+            throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
+          }
+
+          const projectID = instance.project.id
+          queueStartScripts(worktreePath, { projectID })
+
+          return true
+        })
+      })
+
+      return Service.of({
+        makeWorktreeInfo: makeWorktreeInfoEffect,
+        createFromInfo: createFromInfoEffect,
+        create: createEffect,
+        remove: removeEffect,
+        reset: resetEffect,
+      })
+    }),
+  )
+
+  // ---------------------------------------------------------------------------
+  // Promise facades
+  // ---------------------------------------------------------------------------
+
   export async function makeWorktreeInfo(name?: string): Promise<Info> {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
-    await fs.mkdir(root, { recursive: true })
-
-    const base = name ? slug(name) : ""
-    return candidate(root, base || undefined)
+    return runPromiseInstance(Service.use((svc) => svc.makeWorktreeInfo(name)))
   }
 
   export async function createFromInfo(info: Info, startCommand?: string) {
-    const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
-      cwd: Instance.worktree,
-    })
-    if (created.exitCode !== 0) {
-      throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
-    }
-
-    await Project.addSandbox(Instance.project.id, info.directory).catch(() => undefined)
-
-    const projectID = Instance.project.id
-    const extra = startCommand?.trim()
-
-    return () => {
-      const start = async () => {
-        const populated = await git(["reset", "--hard"], { cwd: info.directory })
-        if (populated.exitCode !== 0) {
-          const message = errorText(populated) || "Failed to populate worktree"
-          log.error("worktree checkout failed", { directory: info.directory, message })
-          GlobalBus.emit("event", {
-            directory: info.directory,
-            payload: {
-              type: Event.Failed.type,
-              properties: {
-                message,
-              },
-            },
-          })
-          return
-        }
-
-        const booted = await Instance.provide({
-          directory: info.directory,
-          init: InstanceBootstrap,
-          fn: () => undefined,
-        })
-          .then(() => true)
-          .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error)
-            log.error("worktree bootstrap failed", { directory: info.directory, message })
-            GlobalBus.emit("event", {
-              directory: info.directory,
-              payload: {
-                type: Event.Failed.type,
-                properties: {
-                  message,
-                },
-              },
-            })
-            return false
-          })
-        if (!booted) return
-
-        GlobalBus.emit("event", {
-          directory: info.directory,
-          payload: {
-            type: Event.Ready.type,
-            properties: {
-              name: info.name,
-              branch: info.branch,
-            },
-          },
-        })
-
-        await runStartScripts(info.directory, { projectID, extra })
-      }
-
-      return start().catch((error) => {
-        log.error("worktree start task failed", { directory: info.directory, error })
-      })
-    }
+    return runPromiseInstance(Service.use((svc) => svc.createFromInfo(info, startCommand)))
   }
 
-  export const create = fn(CreateInput.optional(), async (input) => {
-    const info = await makeWorktreeInfo(input?.name)
-    const bootstrap = await createFromInfo(info, input?.startCommand)
-    // This is needed due to how worktrees currently work in the
-    // desktop app
-    setTimeout(() => {
-      bootstrap()
-    }, 0)
-    return info
-  })
+  export const create = Object.assign(
+    async (input?: CreateInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.create(input)))
+    },
+    { schema: CreateInput.optional() },
+  )
 
-  export const remove = fn(RemoveInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
+  export const remove = Object.assign(
+    async (input: RemoveInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.remove(input)))
+    },
+    { schema: RemoveInput },
+  )
 
-    const directory = await canonical(input.directory)
-    const locate = async (stdout: Uint8Array | undefined) => {
-      const lines = outputText(stdout)
-        .split("\n")
-        .map((line) => line.trim())
-      const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-        if (!line) return acc
-        if (line.startsWith("worktree ")) {
-          acc.push({ path: line.slice("worktree ".length).trim() })
-          return acc
-        }
-        const current = acc[acc.length - 1]
-        if (!current) return acc
-        if (line.startsWith("branch ")) {
-          current.branch = line.slice("branch ".length).trim()
-        }
-        return acc
-      }, [])
-
-      return (async () => {
-        for (const item of entries) {
-          if (!item.path) continue
-          const key = await canonical(item.path)
-          if (key === directory) return item
-        }
-      })()
-    }
-
-    const clean = (target: string) =>
-      fs
-        .rm(target, {
-          recursive: true,
-          force: true,
-          maxRetries: 5,
-          retryDelay: 100,
-        })
-        .catch((error) => {
-          const message = error instanceof Error ? error.message : String(error)
-          throw new RemoveFailedError({ message: message || "Failed to remove git worktree directory" })
-        })
-
-    const stop = async (target: string) => {
-      if (!(await exists(target))) return
-      await git(["fsmonitor--daemon", "stop"], { cwd: target })
-    }
-
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
-
-    const entry = await locate(list.stdout)
-
-    if (!entry?.path) {
-      const directoryExists = await exists(directory)
-      if (directoryExists) {
-        await stop(directory)
-        await clean(directory)
-      }
-      return true
-    }
-
-    await stop(entry.path)
-    const removed = await git(["worktree", "remove", "--force", entry.path], {
-      cwd: Instance.worktree,
-    })
-    if (removed.exitCode !== 0) {
-      const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-      if (next.exitCode !== 0) {
-        throw new RemoveFailedError({
-          message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
-        })
-      }
-
-      const stale = await locate(next.stdout)
-      if (stale?.path) {
-        throw new RemoveFailedError({ message: errorText(removed) || "Failed to remove git worktree" })
-      }
-    }
-
-    await clean(entry.path)
-
-    const branch = entry.branch?.replace(/^refs\/heads\//, "")
-    if (branch) {
-      const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree })
-      if (deleted.exitCode !== 0) {
-        throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
-      }
-    }
-
-    return true
-  })
-
-  export const reset = fn(ResetInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const directory = await canonical(input.directory)
-    const primary = await canonical(Instance.worktree)
-    if (directory === primary) {
-      throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
-    }
-
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
-
-    const lines = outputText(list.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-    const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-      if (!line) return acc
-      if (line.startsWith("worktree ")) {
-        acc.push({ path: line.slice("worktree ".length).trim() })
-        return acc
-      }
-      const current = acc[acc.length - 1]
-      if (!current) return acc
-      if (line.startsWith("branch ")) {
-        current.branch = line.slice("branch ".length).trim()
-      }
-      return acc
-    }, [])
-
-    const entry = await (async () => {
-      for (const item of entries) {
-        if (!item.path) continue
-        const key = await canonical(item.path)
-        if (key === directory) return item
-      }
-    })()
-    if (!entry?.path) {
-      throw new ResetFailedError({ message: "Worktree not found" })
-    }
-
-    const remoteList = await git(["remote"], { cwd: Instance.worktree })
-    if (remoteList.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
-    }
-
-    const remotes = outputText(remoteList.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-      .filter(Boolean)
-
-    const remote = remotes.includes("origin")
-      ? "origin"
-      : remotes.length === 1
-        ? remotes[0]
-        : remotes.includes("upstream")
-          ? "upstream"
-          : ""
-
-    const remoteHead = remote
-      ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
-      : { exitCode: 1, stdout: undefined, stderr: undefined }
-
-    const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
-    const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
-    const remoteBranch = remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
-
-    const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
-      cwd: Instance.worktree,
-    })
-    const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
-      cwd: Instance.worktree,
-    })
-    const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
-
-    const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
-    if (!target) {
-      throw new ResetFailedError({ message: "Default branch not found" })
-    }
-
-    if (remoteBranch) {
-      const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree })
-      if (fetch.exitCode !== 0) {
-        throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
-      }
-    }
-
-    if (!entry.path) {
-      throw new ResetFailedError({ message: "Worktree path not found" })
-    }
-
-    const worktreePath = entry.path
-
-    const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
-    if (resetToTarget.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(resetToTarget) || "Failed to reset worktree to target" })
-    }
-
-    const clean = await sweep(worktreePath)
-    if (clean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" })
-    }
-
-    const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath })
-    if (update.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
-    }
-
-    const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], {
-      cwd: worktreePath,
-    })
-    if (subReset.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" })
-    }
-
-    const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], {
-      cwd: worktreePath,
-    })
-    if (subClean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" })
-    }
-
-    const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
-    if (status.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" })
-    }
-
-    const dirty = outputText(status.stdout)
-    if (dirty) {
-      throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
-    }
-
-    const projectID = Instance.project.id
-    queueStartScripts(worktreePath, { projectID })
-
-    return true
-  })
+  export const reset = Object.assign(
+    async (input: ResetInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.reset(input)))
+    },
+    { schema: ResetInput },
+  )
 }

packages/ui/src/components/message-part.tsx

@@ -4,15 +4,15 @@ import {
   createMemo,
   createSignal,
   For,
-  Index,
   Match,
   onMount,
   Show,
   Switch,
   onCleanup,
+  Index,
   type JSX,
 } from "solid-js"
-import { createStore, unwrap } from "solid-js/store"
+import { createStore } from "solid-js/store"
 import stripAnsi from "strip-ansi"
 import { Dynamic } from "solid-js/web"
 import {
@@ -481,15 +481,6 @@ function partDefaultOpen(part: PartType, shell = false, edit = false) {
   return toolDefaultOpen(part.tool, shell, edit)
 }
 
-function bindMessage<T extends MessageType>(input: T) {
-  const data = useData()
-  const base = structuredClone(unwrap(input)) as T
-  return createMemo(() => {
-    const next = data.store.message?.[base.sessionID]?.find((item) => item.id === base.id)
-    return (next as T | undefined) ?? base
-  })
-}
-
 export function AssistantParts(props: {
   messages: AssistantMessage[]
   showAssistantCopyPartID?: string | null
@@ -530,55 +521,62 @@ export function AssistantParts(props: {
 
   return (
     <Index each={grouped()}>
-      {(entry) => {
-        const kind = createMemo(() => entry().type)
-        const parts = createMemo(
-          () => {
-            const value = entry()
-            if (value.type !== "context") return emptyTools
-            return value.refs
-              .map((ref) => part().get(ref.messageID)?.get(ref.partID))
-              .filter((part): part is ToolPart => !!part && isContextGroupTool(part))
-          },
-          emptyTools,
-          { equals: same },
-        )
-        const busy = createMemo(() => props.working && last() === entry().key)
-        const message = createMemo(() => {
-          const value = entry()
-          if (value.type !== "part") return
-          return msgs().get(value.ref.messageID)
-        })
-        const item = createMemo(() => {
-          const value = entry()
-          if (value.type !== "part") return
-          return part().get(value.ref.messageID)?.get(value.ref.partID)
-        })
-        const ready = createMemo(() => {
-          if (kind() !== "part") return
-          const msg = message()
-          const value = item()
-          if (!msg || !value) return
-          return { msg, value }
-        })
+      {(entryAccessor) => {
+        const entryType = createMemo(() => entryAccessor().type)
 
         return (
-          <>
-            <Show when={kind() === "context" && parts().length > 0}>
-              <ContextToolGroup parts={parts()} busy={busy()} />
-            </Show>
-            <Show when={ready()}>
-              {(ready) => (
-                <Part
-                  part={ready().value}
-                  message={ready().msg}
-                  showAssistantCopyPartID={props.showAssistantCopyPartID}
-                  turnDurationMs={props.turnDurationMs}
-                  defaultOpen={partDefaultOpen(ready().value, props.shellToolDefaultOpen, props.editToolDefaultOpen)}
-                />
-              )}
-            </Show>
-          </>
+          <Switch>
+            <Match when={entryType() === "context"}>
+              {(() => {
+                const parts = createMemo(
+                  () => {
+                    const entry = entryAccessor()
+                    if (entry.type !== "context") return emptyTools
+                    return entry.refs
+                      .map((ref) => part().get(ref.messageID)?.get(ref.partID))
+                      .filter((part): part is ToolPart => !!part && isContextGroupTool(part))
+                  },
+                  emptyTools,
+                  { equals: same },
+                )
+                const busy = createMemo(() => props.working && last() === entryAccessor().key)
+
+                return (
+                  <Show when={parts().length > 0}>
+                    <ContextToolGroup parts={parts()} busy={busy()} />
+                  </Show>
+                )
+              })()}
+            </Match>
+            <Match when={entryType() === "part"}>
+              {(() => {
+                const message = createMemo(() => {
+                  const entry = entryAccessor()
+                  if (entry.type !== "part") return
+                  return msgs().get(entry.ref.messageID)
+                })
+                const item = createMemo(() => {
+                  const entry = entryAccessor()
+                  if (entry.type !== "part") return
+                  return part().get(entry.ref.messageID)?.get(entry.ref.partID)
+                })
+
+                return (
+                  <Show when={message()}>
+                    <Show when={item()}>
+                      <Part
+                        part={item()!}
+                        message={message()!}
+                        showAssistantCopyPartID={props.showAssistantCopyPartID}
+                        turnDurationMs={props.turnDurationMs}
+                        defaultOpen={partDefaultOpen(item()!, props.shellToolDefaultOpen, props.editToolDefaultOpen)}
+                      />
+                    </Show>
+                  </Show>
+                )
+              })()}
+            </Match>
+          </Switch>
         )
       }}
     </Index>
@@ -690,22 +688,25 @@ export function registerPartComponent(type: string, component: PartComponent) {
 }
 
 export function Message(props: MessageProps) {
-  if (props.message.role === "user") {
-    return <UserMessageDisplay message={props.message as UserMessage} parts={props.parts} actions={props.actions} />
-  }
-
-  if (props.message.role === "assistant") {
-    return (
-      <AssistantMessageDisplay
-        message={props.message as AssistantMessage}
-        parts={props.parts}
-        showAssistantCopyPartID={props.showAssistantCopyPartID}
-        showReasoningSummaries={props.showReasoningSummaries}
-      />
-    )
-  }
-
-  return undefined
+  return (
+    <Switch>
+      <Match when={props.message.role === "user" && props.message}>
+        {(userMessage) => (
+          <UserMessageDisplay message={userMessage() as UserMessage} parts={props.parts} actions={props.actions} />
+        )}
+      </Match>
+      <Match when={props.message.role === "assistant" && props.message}>
+        {(assistantMessage) => (
+          <AssistantMessageDisplay
+            message={assistantMessage() as AssistantMessage}
+            parts={props.parts}
+            showAssistantCopyPartID={props.showAssistantCopyPartID}
+            showReasoningSummaries={props.showReasoningSummaries}
+          />
+        )}
+      </Match>
+    </Switch>
+  )
 }
 
 export function AssistantMessageDisplay(props: {
@@ -732,42 +733,52 @@ export function AssistantMessageDisplay(props: {
 
   return (
     <Index each={grouped()}>
-      {(entry) => {
-        const kind = createMemo(() => entry().type)
-        const parts = createMemo(
-          () => {
-            const value = entry()
-            if (value.type !== "context") return emptyTools
-            return value.refs
-              .map((ref) => part().get(ref.partID))
-              .filter((part): part is ToolPart => !!part && isContextGroupTool(part))
-          },
-          emptyTools,
-          { equals: same },
-        )
-        const item = createMemo(() => {
-          const value = entry()
-          if (value.type !== "part") return
-          return part().get(value.ref.partID)
-        })
-        const ready = createMemo(() => {
-          if (kind() !== "part") return
-          const value = item()
-          if (!value) return
-          return value
-        })
+      {(entryAccessor) => {
+        const entryType = createMemo(() => entryAccessor().type)
 
         return (
-          <>
-            <Show when={kind() === "context" && parts().length > 0}>
-              <ContextToolGroup parts={parts()} />
-            </Show>
-            <Show when={ready()}>
-              {(ready) => (
-                <Part part={ready()} message={props.message} showAssistantCopyPartID={props.showAssistantCopyPartID} />
-              )}
-            </Show>
-          </>
+          <Switch>
+            <Match when={entryType() === "context"}>
+              {(() => {
+                const parts = createMemo(
+                  () => {
+                    const entry = entryAccessor()
+                    if (entry.type !== "context") return emptyTools
+                    return entry.refs
+                      .map((ref) => part().get(ref.partID))
+                      .filter((part): part is ToolPart => !!part && isContextGroupTool(part))
+                  },
+                  emptyTools,
+                  { equals: same },
+                )
+
+                return (
+                  <Show when={parts().length > 0}>
+                    <ContextToolGroup parts={parts()} />
+                  </Show>
+                )
+              })()}
+            </Match>
+            <Match when={entryType() === "part"}>
+              {(() => {
+                const item = createMemo(() => {
+                  const entry = entryAccessor()
+                  if (entry.type !== "part") return
+                  return part().get(entry.ref.partID)
+                })
+
+                return (
+                  <Show when={item()}>
+                    <Part
+                      part={item()!}
+                      message={props.message}
+                      showAssistantCopyPartID={props.showAssistantCopyPartID}
+                    />
+                  </Show>
+                )
+              })()}
+            </Match>
+          </Switch>
         )
       }}
     </Index>
@@ -834,9 +845,11 @@ function ContextToolGroup(props: { parts: ToolPart[]; busy?: boolean }) {
       <Collapsible.Content>
         <div data-component="context-tool-group-list">
           <Index each={props.parts}>
-            {(part) => {
-              const trigger = createMemo(() => contextToolTrigger(part(), i18n))
-              const running = createMemo(() => part().state.status === "pending" || part().state.status === "running")
+            {(partAccessor) => {
+              const trigger = createMemo(() => contextToolTrigger(partAccessor(), i18n))
+              const running = createMemo(
+                () => partAccessor().state.status === "pending" || partAccessor().state.status === "running",
+              )
               return (
                 <div data-slot="context-tool-group-item">
                   <div data-component="tool-trigger">
@@ -874,7 +887,6 @@ export function UserMessageDisplay(props: { message: UserMessage; parts: PartTyp
   const data = useData()
   const dialog = useDialog()
   const i18n = useI18n()
-  const message = bindMessage(props.message)
   const [state, setState] = createStore({
     copied: false,
     busy: undefined as "fork" | "revert" | undefined,
@@ -897,8 +909,8 @@ export function UserMessageDisplay(props: { message: UserMessage; parts: PartTyp
   const agents = createMemo(() => (props.parts?.filter((p) => p.type === "agent") as AgentPart[]) ?? [])
 
   const model = createMemo(() => {
-    const providerID = message().model?.providerID
-    const modelID = message().model?.modelID
+    const providerID = props.message.model?.providerID
+    const modelID = props.message.model?.modelID
     if (!providerID || !modelID) return ""
     const match = data.store.provider?.all?.find((p) => p.id === providerID)
     return match?.models?.[modelID]?.name ?? modelID
@@ -906,13 +918,13 @@ export function UserMessageDisplay(props: { message: UserMessage; parts: PartTyp
   const timefmt = createMemo(() => new Intl.DateTimeFormat(i18n.locale(), { timeStyle: "short" }))
 
   const stamp = createMemo(() => {
-    const created = message().time?.created
+    const created = props.message.time?.created
     if (typeof created !== "number") return ""
     return timefmt().format(created)
   })
 
   const metaHead = createMemo(() => {
-    const agent = message().agent
+    const agent = props.message.agent
     const items = [agent ? agent[0]?.toUpperCase() + agent.slice(1) : "", model()]
     return items.filter((x) => !!x).join("\u00A0\u00B7\u00A0")
   })
@@ -938,8 +950,8 @@ export function UserMessageDisplay(props: { message: UserMessage; parts: PartTyp
     void Promise.resolve()
       .then(() =>
         act({
-          sessionID: message().sessionID,
-          messageID: message().id,
+          sessionID: props.message.sessionID,
+          messageID: props.message.id,
         }),
       )
       .finally(() => {
@@ -1298,27 +1310,27 @@ PART_MAPPING["text"] = function TextPartDisplay(props) {
   const i18n = useI18n()
   const numfmt = createMemo(() => new Intl.NumberFormat(i18n.locale()))
   const part = () => props.part as TextPart
-  const message = bindMessage(props.message)
   const interrupted = createMemo(
-    () => message().role === "assistant" && (message() as AssistantMessage).error?.name === "MessageAbortedError",
+    () =>
+      props.message.role === "assistant" && (props.message as AssistantMessage).error?.name === "MessageAbortedError",
   )
 
   const model = createMemo(() => {
-    const current = message()
-    if (current.role !== "assistant") return ""
-    const match = data.store.provider?.all?.find((p) => p.id === current.providerID)
-    return match?.models?.[current.modelID]?.name ?? current.modelID
+    if (props.message.role !== "assistant") return ""
+    const message = props.message as AssistantMessage
+    const match = data.store.provider?.all?.find((p) => p.id === message.providerID)
+    return match?.models?.[message.modelID]?.name ?? message.modelID
   })
 
   const duration = createMemo(() => {
-    const current = message()
-    if (current.role !== "assistant") return ""
-    const completed = current.time.completed
+    if (props.message.role !== "assistant") return ""
+    const message = props.message as AssistantMessage
+    const completed = message.time.completed
     const ms =
       typeof props.turnDurationMs === "number"
         ? props.turnDurationMs
         : typeof completed === "number"
-          ? completed - current.time.created
+          ? completed - message.time.created
           : -1
     if (!(ms >= 0)) return ""
     const total = Math.round(ms / 1000)
@@ -1332,9 +1344,8 @@ PART_MAPPING["text"] = function TextPartDisplay(props) {
   })
 
   const meta = createMemo(() => {
-    const current = message()
-    if (current.role !== "assistant") return ""
-    const agent = current.agent
+    if (props.message.role !== "assistant") return ""
+    const agent = (props.message as AssistantMessage).agent
     const items = [
       agent ? agent[0]?.toUpperCase() + agent.slice(1) : "",
       model(),
@@ -1347,13 +1358,13 @@ PART_MAPPING["text"] = function TextPartDisplay(props) {
   const displayText = () => (part().text ?? "").trim()
   const throttledText = createThrottledValue(displayText)
   const isLastTextPart = createMemo(() => {
-    const last = (data.store.part?.[message().id] ?? [])
+    const last = (data.store.part?.[props.message.id] ?? [])
       .filter((item): item is TextPart => item?.type === "text" && !!item.text?.trim())
       .at(-1)
     return last?.id === part().id
   })
   const showCopy = createMemo(() => {
-    if (message().role !== "assistant") return isLastTextPart()
+    if (props.message.role !== "assistant") return isLastTextPart()
     if (props.showAssistantCopyPartID === null) return false
     if (typeof props.showAssistantCopyPartID === "string") return props.showAssistantCopyPartID === part().id
     return isLastTextPart()