fix(core): move branch watch into Vcs

LocationWatcher only existed to republish git/hg metadata as
filesystem.changed for Vcs. Nothing else consumed those events.
Vcs now owns the Parcel watch, same as skills and config.

packages/app/src/components/prompt-input/submit.ts

@@ -76,27 +76,6 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
     return true
   }
 
-  const select = async () => {
-    const session = input.session()
-    if (session?.agent !== input.draft.agent) {
-      await input.api.switchAgent({ sessionID: input.draft.sessionID, agent: input.draft.agent })
-    }
-    if (
-      session?.model?.providerID === input.draft.model.providerID &&
-      session.model.id === input.draft.model.modelID &&
-      (session.model.variant ?? "default") === (input.draft.variant ?? "default")
-    )
-      return
-    await input.api.switchModel({
-      sessionID: input.draft.sessionID,
-      model: {
-        id: input.draft.model.modelID,
-        providerID: input.draft.model.providerID,
-        variant: input.draft.variant,
-      },
-    })
-  }
-
   const [head, ...tail] = text.split(" ")
   const cmd = head?.startsWith("/") ? head.slice(1) : undefined
   if (cmd && input.sync.data.command.find((item) => item.name === cmd)) {
@@ -107,13 +86,18 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
         return false
       }
 
-      await select()
       const messageID = Identifier.ascending("message")
       await input.api.command({
         sessionID: input.draft.sessionID,
         id: messageID,
         command: cmd,
         arguments: tail.join(" "),
+        agent: input.draft.agent,
+        model: {
+          id: input.draft.model.modelID,
+          providerID: input.draft.model.providerID,
+          variant: input.draft.variant,
+        },
         files: await Promise.all(
           images.map(async (attachment) => ({
             uri: await blobDataUrl(attachment.blob, attachment.mime),
@@ -183,7 +167,24 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
       return false
     }
 
-    await select()
+    const session = input.session()
+    if (session?.agent !== input.draft.agent) {
+      await input.api.switchAgent({ sessionID: input.draft.sessionID, agent: input.draft.agent })
+    }
+    if (
+      session?.model?.providerID !== input.draft.model.providerID ||
+      session.model.id !== input.draft.model.modelID ||
+      (session.model.variant ?? "default") !== (input.draft.variant ?? "default")
+    ) {
+      await input.api.switchModel({
+        sessionID: input.draft.sessionID,
+        model: {
+          id: input.draft.model.modelID,
+          providerID: input.draft.model.providerID,
+          variant: input.draft.variant,
+        },
+      })
+    }
 
     await input.api.prompt({
       sessionID: input.draft.sessionID,
@@ -523,22 +524,14 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         clearInput()
         const messageID = Identifier.ascending("message")
         serverSync().session.set("session_status", session.id, { type: "busy" })
-        void (async () => {
-          if (session.agent !== agent) await sdk().api.session.switchAgent({ sessionID: session.id, agent })
-          if (
-            session.model?.providerID !== model.providerID ||
-            session.model.id !== model.modelID ||
-            (session.model.variant ?? "default") !== (variant ?? "default")
-          )
-            await sdk().api.session.switchModel({
-              sessionID: session.id,
-              model: { id: model.modelID, providerID: model.providerID, variant },
-            })
-          await sdk().api.session.command({
+        sdk()
+          .api.session.command({
             sessionID: session.id,
             id: messageID,
             command: commandName,
             arguments: args.join(" "),
+            agent,
+            model: { id: model.modelID, providerID: model.providerID, variant },
             files: await Promise.all(
               images.map(async (attachment) => ({
                 uri: await blobDataUrl(attachment.blob, attachment.mime),
@@ -546,14 +539,14 @@ export function createPromptSubmit(input: PromptSubmitInput) {
               })),
             ),
           })
-        })().catch((err) => {
-          serverSync().session.set("session_status", session.id, { type: "idle" })
-          showToast({
-            title: language.t("prompt.toast.commandSendFailed.title"),
-            description: formatServerError(err, language.t, language.t("common.requestFailed")),
+          .catch((err) => {
+            serverSync().session.set("session_status", session.id, { type: "idle" })
+            showToast({
+              title: language.t("prompt.toast.commandSendFailed.title"),
+              description: formatServerError(err, language.t, language.t("common.requestFailed")),
+            })
+            restoreInput()
           })
-          restoreInput()
-        })
         return
       }
     }

packages/cli/src/commands/handlers/mini.ts

@@ -4,7 +4,6 @@ import { Runtime } from "../../framework/runtime"
 import { ServerConnection } from "../../services/server-connection"
 import { Config } from "../../config"
 import { resolve } from "@opencode-ai/tui/config"
-import { Global } from "@opencode-ai/util/global"
 
 export default Runtime.handler(Commands.commands.mini, (input) =>
   Effect.gen(function* () {
@@ -17,7 +16,6 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
       mismatch: "replace",
     })
     const config = yield* Config.Service
-    const global = yield* Global.Service
     const resolved = resolve(yield* config.get(), { terminalSuspend: process.platform !== "win32" })
     const fileSystem = yield* FileSystem.FileSystem
     const runServicePromise = Effect.runPromiseWith(Context.make(FileSystem.FileSystem, fileSystem))
@@ -41,7 +39,6 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
         config: {
           update: (update) => runServicePromise(config.update(update)),
         },
-        paths: { home: global.home, state: global.state, log: global.log },
       }),
     )
   }),

packages/cli/src/mini-host.ts

@@ -1,5 +1,6 @@
 import type { MiniFrontendInput } from "@opencode-ai/tui/mini"
 import { createModelPreferenceRepository } from "@opencode-ai/tui/model-preference"
+import { Global } from "@opencode-ai/util/global"
 import fs from "node:fs"
 import { readFile } from "node:fs/promises"
 import path from "node:path"
@@ -128,9 +129,13 @@ export async function usingInteractiveStdin<T>(
 export function createMiniHost(input: {
   terminal: InteractiveStdin
   directory: string
-  paths: { home: string; state: string; log: string }
+  paths?: { home: string; state: string; log: string }
 }): MiniHost {
-  const paths = input.paths
+  const paths = input.paths ?? {
+    home: Global.Path.home,
+    state: Global.Path.state,
+    log: Global.Path.log,
+  }
   const diagnostics = {
     pid: process.pid,
     cwd: input.directory,

packages/cli/src/mini.ts

@@ -22,7 +22,6 @@ export type MiniCommandInput = {
   demo?: boolean
   tuiConfig?: MiniFrontendInput["tuiConfig"]
   config?: MiniFrontendInput["config"]
-  paths: { home: string; state: string; log: string }
 }
 
 type Model = MiniFrontendInput["model"]
@@ -105,7 +104,7 @@ export async function runMini(input: MiniCommandInput) {
         }))
       const frontend = await frontendTask
       return frontend.runMiniFrontend({
-        host: createMiniHost({ terminal, directory, paths: input.paths }),
+        host: createMiniHost({ terminal, directory }),
         sdk,
         directory,
         target: resolveTarget,

packages/cli/src/server-process.ts

@@ -39,8 +39,7 @@ export const run = Effect.fnUntraced(function* (options: Options) {
 })
 
 const processEffect = Effect.fnUntraced(function* (options: Options) {
-  const global = yield* Global.Service
-  if (options.mode === "service") yield* Effect.sync(() => process.chdir(global.home))
+  if (options.mode === "service") yield* Effect.sync(() => process.chdir(Global.Path.home))
   return yield* Effect.scoped(
     Effect.gen(function* () {
       const serviceOptions = options.mode === "service" ? yield* ServiceConfig.options() : undefined

packages/client/src/effect/api/api.ts

@@ -193,6 +193,8 @@ export type Endpoint5_13Input = {
   readonly id?: SessionMessage.ID | undefined
   readonly command: string
   readonly arguments?: string | undefined
+  readonly agent?: Agent.ID | undefined
+  readonly model?: Model.Ref | undefined
   readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
   readonly agents?: ReadonlyArray<AgentAttachment> | undefined
   readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined

packages/client/src/effect/generated/client.ts

@@ -431,6 +431,8 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
         id: input["id"],
         command: input["command"],
         arguments: input["arguments"],
+        agent: input["agent"],
+        model: input["model"],
         files: input["files"],
         agents: input["agents"],
         skills: input["skills"],

packages/client/src/promise/generated/client.ts

@@ -635,6 +635,8 @@ export function make(options: ClientOptions) {
               id: input["id"],
               command: input["command"],
               arguments: input["arguments"],
+              agent: input["agent"],
+              model: input["model"],
               files: input["files"],
               agents: input["agents"],
               skills: input["skills"],

packages/client/src/promise/generated/types.ts

@@ -3485,6 +3485,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3506,6 +3508,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3527,6 +3531,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3544,10 +3550,58 @@ export type SessionCommandInput = {
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["arguments"]
+  readonly agent?: {
+    readonly id?: string | null
+    readonly command: string
+    readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly files?: ReadonlyArray<{
+      readonly uri: string
+      readonly name?: string
+      readonly description?: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly agents?: ReadonlyArray<{
+      readonly name: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly skills?: ReadonlyArray<{
+      readonly id: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly delivery?: "steer" | "queue" | null
+    readonly resume?: boolean | null
+  }["agent"]
+  readonly model?: {
+    readonly id?: string | null
+    readonly command: string
+    readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly files?: ReadonlyArray<{
+      readonly uri: string
+      readonly name?: string
+      readonly description?: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly agents?: ReadonlyArray<{
+      readonly name: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly skills?: ReadonlyArray<{
+      readonly id: string
+      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
+    }>
+    readonly delivery?: "steer" | "queue" | null
+    readonly resume?: boolean | null
+  }["model"]
   readonly files?: {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3569,6 +3623,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3590,6 +3646,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3611,6 +3669,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string
@@ -3632,6 +3692,8 @@ export type SessionCommandInput = {
     readonly id?: string | null
     readonly command: string
     readonly arguments?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly files?: ReadonlyArray<{
       readonly uri: string
       readonly name?: string

packages/core/src/command.ts

@@ -11,7 +11,6 @@ import { ChildProcess } from "effect/unstable/process"
 import { Config } from "./config"
 import { Location } from "./location"
 import { ShellSelect } from "./shell/select"
-import { Global } from "@opencode-ai/util/global"
 
 export const Info = Command.Info
 export type Info = Command.Info
@@ -62,7 +61,6 @@ export const layer = (options?: ShellSelect.Options) =>
       const processes = yield* AppProcess.Service
       const config = yield* Config.Service
       const location = yield* Location.Service
-      const global = yield* Global.Service
       const state = State.create<Data, Draft>({
         name: "command",
         initial: () => ({ commands: new Map() }),
@@ -113,7 +111,6 @@ export const layer = (options?: ShellSelect.Options) =>
               location,
               processes,
               shell: options,
-              bin: global.bin,
             })
 
           const prompt = (yield* mcp.prompts()).find(
@@ -167,7 +164,6 @@ function evaluateTemplate(
     readonly location: Location.Info
     readonly processes: AppProcess.Interface
     readonly shell?: ShellSelect.Options
-    readonly bin: string
   },
 ) {
   return Effect.gen(function* () {
@@ -201,16 +197,11 @@ const evaluateShell = Effect.fnUntraced(function* (
     readonly location: Location.Info
     readonly processes: AppProcess.Interface
     readonly shell?: ShellSelect.Options
-    readonly bin: string
   },
 ) {
   const matches = Array.from(text.matchAll(shellRegex))
   if (matches.length === 0) return text
-  const shell = ShellSelect.preferred(
-    Config.latest(yield* services.config.entries(), "shell"),
-    services.shell,
-    services.bin,
-  )
+  const shell = ShellSelect.preferred(Config.latest(yield* services.config.entries(), "shell"), services.shell)
   const outputs = yield* Effect.forEach(
     matches,
     (match) => {
@@ -271,7 +262,7 @@ export function configured(options?: ShellSelect.Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [MCP.node, Bus.node, AppProcess.node, Config.node, Location.node, Global.node],
+    deps: [MCP.node, Bus.node, AppProcess.node, Config.node, Location.node],
   })
 }
 

packages/core/src/config/plugin/instruction.ts

@@ -1,122 +0,0 @@
-export * as ConfigInstructionPlugin from "./instruction"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { dirname, join } from "path"
-import { Effect, PubSub, Semaphore, Stream } from "effect"
-import { Watcher } from "../../filesystem/watcher"
-import { InstructionDiscovery } from "../../instruction-discovery"
-import { Instructions } from "../../instructions/index"
-import { Location } from "../../location"
-import { AbsolutePath } from "../../schema"
-
-type Loaded =
-  | { readonly type: "available"; readonly files: InstructionDiscovery.File[] }
-  | { readonly type: "unavailable" }
-
-export const Plugin = define({
-  id: "opencode.config.instruction",
-  effect: Effect.fn(function* () {
-    const discovery = yield* InstructionDiscovery.Service
-    yield* Effect.gen(function* () {
-      const fs = yield* FSUtil.Service
-      const global = yield* Global.Service
-      const location = yield* Location.Service
-      const watcher = yield* Watcher.Service
-      const changes = yield* PubSub.sliding<string>(1)
-      const lock = Semaphore.makeUnsafe(1)
-      const start = yield* fs.resolve(location.directory)
-      const stop = yield* fs.resolve(location.project.directory)
-      const project = discovery.project && FSUtil.contains(stop, start)
-      const globalFile = yield* fs.resolve(join(global.config, "AGENTS.md"))
-      const loaded: { current: Loaded } = { current: { type: "available", files: [] } }
-
-      const publish = (update: Watcher.Update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid)
-      const candidates = [
-        globalFile,
-        ...(project ? ancestorDirectories(start, stop).map((directory) => join(directory, "AGENTS.md")) : []),
-      ]
-      for (const path of new Set(candidates)) {
-        const updates = yield* watcher.subscribe({ path, type: "file" })
-        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped({ startImmediately: true }))
-      }
-
-      const read = Effect.fn("ConfigInstructionPlugin.read")(function* (path: string) {
-        const content = yield* fs.readFileStringSafe(path)
-        if (content !== undefined) return new InstructionDiscovery.File({ path: AbsolutePath.make(path), content })
-        yield* Effect.logDebug("instruction file skipped", { path, reason: "unavailable" })
-      })
-
-      const globalSource = Effect.fn("ConfigInstructionPlugin.globalSource")(function* () {
-        const file = yield* read(globalFile)
-        return file ? [file] : []
-      })
-
-      const projectSource = Effect.fn("ConfigInstructionPlugin.projectSource")(function* () {
-        if (!project) return []
-        const discovered = new Set(
-          yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve),
-        )
-        const files = yield* Effect.forEach(discovered, read, { concurrency: "unbounded" })
-        if (files.some((file) => file === undefined)) return Instructions.unavailable
-        return files.filter((file): file is InstructionDiscovery.File => file !== undefined)
-      })
-
-      const isolate = <A, E, R>(source: string, effect: Effect.Effect<A, E, R>) =>
-        effect.pipe(
-          Effect.catchCause((cause) =>
-            Effect.logWarning("failed to load instruction source", { source, cause }).pipe(
-              Effect.as(Instructions.unavailable),
-            ),
-          ),
-        )
-
-      const refresh = Effect.fn("ConfigInstructionPlugin.refresh")(function* (file?: string) {
-        yield* lock.withPermit(
-          Effect.gen(function* () {
-            const sources = yield* Effect.all({
-              global: isolate("global", globalSource()),
-              project: isolate("project", projectSource()),
-            })
-            loaded.current =
-              Array.isArray(sources.global) && Array.isArray(sources.project)
-                ? { type: "available", files: [...sources.global, ...sources.project] }
-                : { type: "unavailable" }
-            if (!file) return
-            yield* Effect.logDebug("instructions rescanned", {
-              file,
-              instructions:
-                loaded.current.type === "available" ? loaded.current.files.map((item) => item.path) : "unavailable",
-            })
-          }),
-        )
-      })
-
-      yield* Stream.fromPubSub(changes).pipe(
-        Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(discovery.reload()))),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* refresh()
-      yield* discovery.transform((draft) => {
-        if (loaded.current.type === "unavailable") {
-          draft.unavailable()
-          return
-        }
-        for (const file of loaded.current.files) draft.add(file)
-      })
-    }).pipe(
-      Effect.catchCause((cause) =>
-        Effect.logWarning("failed to activate instruction source", { cause }).pipe(
-          Effect.andThen(discovery.transform((draft) => draft.unavailable())),
-          Effect.asVoid,
-        ),
-      ),
-    )
-  }),
-})
-
-function ancestorDirectories(start: string, stop: string): string[] {
-  if (start === stop) return [start]
-  return [start, ...ancestorDirectories(dirname(start), stop)]
-}

packages/core/src/config/plugin/skill-file.ts

@@ -1,57 +0,0 @@
-export * as SkillFile from "./skill-file"
-
-import path from "path"
-import { Result, Schema, type SchemaIssue, SchemaParser } from "effect"
-import { ConfigMarkdown } from "../markdown"
-import { AbsolutePath } from "../../schema"
-import { Skill } from "../../skill"
-
-const Frontmatter = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  slash: Schema.Boolean.pipe(Schema.optional),
-  metadata: Schema.Unknown.pipe(Schema.optional),
-})
-const decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter)
-
-export type ParseResult =
-  | { readonly _tag: "Parsed"; readonly skill: Skill.Info }
-  | { readonly _tag: "Skipped"; readonly reason: "markdown" }
-  | { readonly _tag: "Skipped"; readonly reason: "frontmatter"; readonly issue: SchemaIssue.Issue }
-
-const metadataBoolean = (metadata: unknown, key: string) => {
-  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
-    return undefined
-  }
-  const value = Reflect.get(metadata, key)
-  if (typeof value === "boolean") return value
-  if (typeof value !== "string") return undefined
-  const normalized = value.trim().toLowerCase()
-  if (normalized === "true") return true
-  if (normalized === "false") return false
-  return undefined
-}
-
-export function parse(directory: string, filepath: string, content: string): ParseResult {
-  const markdown = ConfigMarkdown.parseOption(content)
-  if (!markdown) return { _tag: "Skipped", reason: "markdown" }
-  const decoded = decodeFrontmatter(markdown.data)
-  if (Result.isFailure(decoded)) return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure }
-  const frontmatter = decoded.success
-  const id =
-    path.dirname(filepath) === directory ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath))
-  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash
-  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke")
-  return {
-    _tag: "Parsed",
-    skill: {
-      id: Skill.ID.make(id),
-      name: Skill.Name.make(frontmatter.name ?? id),
-      ...(frontmatter.description === undefined ? {} : { description: frontmatter.description }),
-      ...(slash === undefined ? {} : { slash }),
-      ...(autoinvoke === undefined ? {} : { autoinvoke }),
-      location: AbsolutePath.make(filepath),
-      content: markdown.content,
-    },
-  }
-}

packages/core/src/config/plugin/skill.ts

@@ -1,191 +1,64 @@
 export * as ConfigSkillPlugin from "./skill"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import type { Entry } from "@opencode-ai/schema/config"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
 import path from "path"
-import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect"
+import { Effect, Stream } from "effect"
 import { Config } from "../../config"
-import { Watcher } from "../../filesystem/watcher"
-import { Location } from "../../location"
 import { AbsolutePath } from "../../schema"
 import { Skill } from "../../skill"
-import { SkillDiscovery } from "../../skill/discovery"
-import { SkillFile } from "./skill-file"
-
-type Source = Skill.DirectorySource | Skill.UrlSource
+import { Global } from "@opencode-ai/util/global"
+import { Location } from "../../location"
 
 export const Plugin = define({
   id: "opencode.config.skill",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const discovery = yield* SkillDiscovery.Service
-    const fs = yield* FSUtil.Service
     const global = yield* Global.Service
     const location = yield* Location.Service
-    const watcher = yield* Watcher.Service
-    const loaded: { entries: Entry[]; skills: Skill.Info[] } = {
-      entries: yield* config.entries(),
-      skills: [],
-    }
-    const watches = yield* FiberMap.make<string>()
-    const changes = yield* PubSub.sliding<string>(1)
-    const lock = Semaphore.makeUnsafe(1)
-
-    const watch = Effect.fn("ConfigSkillPlugin.watch")(function* (directory: string, type: Watcher.WatchInput["type"]) {
-      const target = path.resolve(directory)
-      const updates = yield* watcher.subscribe({ path: target, type })
-      yield* FiberMap.run(
-        watches,
-        `${type}:${target}`,
-        updates.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))),
-        { onlyIfMissing: true, startImmediately: true },
-      )
-    })
-
-    function firstMissing(target: string): Effect.Effect<string | undefined> {
-      const parent = path.dirname(target)
-      if (parent === target) return Effect.succeed(undefined)
-      return fs.isDir(parent).pipe(Effect.flatMap((exists) => (exists ? Effect.succeed(target) : firstMissing(parent))))
-    }
-
-    const watchDirectory: (directory: string) => Effect.Effect<string[]> = Effect.fn(
-      "ConfigSkillPlugin.watchDirectory",
-    )(function* (directory: string) {
-      const target = path.resolve(directory)
-      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      if (resolved) {
-        yield* watch(resolved, "directory")
-        if (resolved !== target) yield* watch(target, "file")
-        return resolved === target ? [target] : [target, resolved]
-      }
-      const missing = yield* firstMissing(target)
-      if (missing) yield* watch(missing, "file")
-      if (
-        yield* fs.realPath(directory).pipe(
-          Effect.as(true),
-          Effect.catch(() => Effect.succeed(false)),
-        )
-      ) {
-        if (missing) yield* FiberMap.remove(watches, `file:${path.resolve(missing)}`)
-        return yield* watchDirectory(directory)
-      }
-      return [target]
-    })
-
-    const sources = () => {
-      const result: Source[] = []
-      const add = (source: Source) => {
-        if (result.some((item) => Skill.Source.equals(item, source))) return
-        result.push(source)
-      }
+    const loaded = { entries: yield* config.entries() }
+    yield* ctx.skill.transform((draft) => {
       const claude = loaded.entries.flatMap((entry) => (entry.type === "claude" ? [entry.path] : []))
       const agents = loaded.entries.flatMap((entry) => (entry.type === "agents" ? [entry.path] : []))
       const directories = loaded.entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
       const items = loaded.entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
       for (const directory of [...claude, ...agents]) {
-        add(Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }))
+        draft.source(
+          Skill.DirectorySource.make({
+            type: "directory",
+            path: AbsolutePath.make(path.join(directory, "skills")),
+          }),
+        )
       }
       for (const directory of directories) {
-        add(Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }))
-        add(Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }))
+        draft.source(
+          Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
+        )
+        draft.source(
+          Skill.DirectorySource.make({
+            type: "directory",
+            path: AbsolutePath.make(path.join(directory, "skills")),
+          }),
+        )
       }
       for (const item of items) {
         if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-          add(Skill.UrlSource.make({ type: "url", url: item }))
+          draft.source(Skill.UrlSource.make({ type: "url", url: item }))
           continue
         }
         const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
-        add(
+        draft.source(
           Skill.DirectorySource.make({
             type: "directory",
             path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
           }),
         )
       }
-      return result
-    }
-
-    const load = Effect.fn("ConfigSkillPlugin.load")(function* (source: Source) {
-      const directories =
-        source.type === "directory"
-          ? [source.path]
-          : yield* discovery.pull(source.url).pipe(
-              Effect.catchCause((cause) =>
-                Effect.logWarning("failed to load skill source", {
-                  source: Skill.Source.key(source),
-                  cause,
-                }).pipe(Effect.as([] as AbsolutePath[])),
-              ),
-            )
-      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat()
-      const skills: Skill.Info[] = []
-      for (const directory of directories) {
-        const files = yield* fs
-          .scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
-          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
-        for (const filepath of files.toSorted()) {
-          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)))
-          if (!roots.some((root) => FSUtil.contains(root, resolved))) yield* watch(path.dirname(resolved), "directory")
-          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          if (!content) continue
-          const parsed = SkillFile.parse(directory, filepath, content)
-          if (parsed._tag === "Skipped") {
-            yield* Effect.logDebug("skill file skipped", {
-              filepath,
-              reason: parsed.reason,
-              ...(parsed.reason === "frontmatter" ? { issue: parsed.issue } : {}),
-            })
-            continue
-          }
-          skills.push(parsed.skill)
-        }
-      }
-      yield* Effect.logDebug("skill source loaded", {
-        source: Skill.Source.key(source),
-        type: source.type,
-        directories,
-        skills: skills.map((skill) => skill.id),
-      })
-      return skills
-    })
-
-    const refresh = Effect.fn("ConfigSkillPlugin.refresh")(function* (file?: string) {
-      yield* lock.withPermit(
-        Effect.gen(function* () {
-          yield* FiberMap.clear(watches)
-          const skills = new Map<Skill.ID, Skill.Info>()
-          const current = sources()
-          for (const source of current) {
-            for (const skill of yield* load(source)) skills.set(skill.id, skill)
-          }
-          loaded.skills = Array.from(skills.values())
-          if (file) {
-            yield* Effect.logInfo("skills rescanned", {
-              file,
-              sources: current.map(Skill.Source.key),
-              skills: loaded.skills.map((skill) => skill.id),
-            })
-          }
-        }),
-      )
-    })
-
-    yield* Stream.fromPubSub(changes).pipe(
-      Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(ctx.skill.reload()))),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    yield* refresh()
-    yield* ctx.skill.transform((draft) => {
-      for (const skill of loaded.skills) draft.add(skill)
     })
     yield* ctx.event.subscribe().pipe(
       Stream.filter((event) => event.type === "config.updated"),
       Stream.runForEach(() =>
         config.entries().pipe(
           Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(refresh()),
           Effect.andThen(ctx.skill.reload()),
         ),
       ),

packages/core/src/config/plugin/source.ts

@@ -1,179 +0,0 @@
-export * as ConfigPluginSource from "./source"
-
-import { Directory, Document, type Entry } from "@opencode-ai/schema/config"
-import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Option, PubSub, Scope, Stream } from "effect"
-import path from "path"
-import { fileURLToPath } from "url"
-import { Config } from "../../config"
-import { Watcher } from "../../filesystem/watcher"
-import { Location } from "../../location"
-
-export type Operation =
-  | {
-      readonly type: "add"
-      readonly target: string
-      readonly options: Record<string, unknown>
-      readonly mtime?: number
-    }
-  | {
-      readonly type: "remove"
-      readonly target: string
-    }
-
-export interface Interface {
-  readonly operations: () => Effect.Effect<readonly Operation[], never, Scope.Scope>
-  readonly changes: () => Stream.Stream<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ConfigPluginSource") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const watcher = yield* Watcher.Service
-    const fs = yield* FSUtil.Service
-    const location = yield* Location.Service
-    const configuredChanges = yield* PubSub.unbounded<void>()
-    const watched = new Set<string>()
-
-    // Configured local plugin files can live outside config roots, where the
-    // config change feed cannot see them; watch those entrypoints directly.
-    // Watches start on first sighting and are never torn down individually:
-    // a stale watch after a config edit costs one deduped fs handle and a
-    // no-op activation, and every watch dies with this layer's scope.
-    const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (
-      entries: readonly Entry[],
-      operations: readonly Operation[],
-    ) {
-      for (const operation of operations) {
-        if (operation.type !== "add" || !path.isAbsolute(operation.target)) continue
-        if (watched.has(operation.target)) continue
-        // The config change feed already covers {plugin,plugins} directories.
-        if (isPluginSource(entries, operation.target)) continue
-        // Directory targets can't hot-reload (their stat mtime ignores edits
-        // inside), so don't watch what can't trigger anything.
-        if (yield* fs.isDir(operation.target)) continue
-        watched.add(operation.target)
-        const updates = yield* watcher.subscribe({ path: operation.target, type: "file" })
-        yield* updates.pipe(
-          Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)),
-          Effect.catchCause((cause) =>
-            Effect.logError("configured plugin watch failed", { target: operation.target, cause }),
-          ),
-          Effect.forkScoped({ startImmediately: true }),
-        )
-      }
-    })
-
-    return Service.of({
-      operations: Effect.fn("ConfigPluginSource.operations")(function* () {
-        const entries = yield* config.entries()
-        const operations = yield* scan(fs, location, entries)
-        yield* watchConfiguredSources(entries, operations)
-        return operations
-      }),
-      changes: () =>
-        Stream.merge(
-          config.changes().pipe(
-            Stream.filterEffect((update) =>
-              Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path)),
-            ),
-            Stream.map(() => undefined),
-          ),
-          Stream.fromPubSub(configuredChanges),
-        ),
-    })
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Config.node, FSUtil.node, Watcher.node, Location.node],
-})
-
-export const empty = makeLocationNode({
-  service: Service,
-  layer: Layer.succeed(
-    Service,
-    Service.of({
-      operations: () => Effect.succeed([]),
-      changes: () => Stream.never,
-    }),
-  ),
-  deps: [],
-})
-
-function parse(input: ConfigPlugin.Plugin): Operation {
-  if (typeof input !== "string") {
-    return { type: "add", target: input.package, options: input.options ?? {} }
-  }
-  if (!input.startsWith("-")) return { type: "add", target: input, options: {} }
-  if (input.length === 1) throw new Error("Plugin remove operation requires a target")
-  return { type: "remove", target: input.slice(1) }
-}
-
-const scan = Effect.fn("ConfigPluginSource.scan")(function* (
-  fs: FSUtil.Interface,
-  location: Location.Interface,
-  entries: readonly Entry[],
-) {
-  const discovered = yield* Effect.forEach(
-    entries.filter((entry): entry is Directory => entry.type === "directory"),
-    (entry) => discoverDirectory(fs, entry.path),
-  ).pipe(Effect.map((items) => items.flat()))
-  const configured = entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .flatMap((entry) =>
-      (entry.info.plugins ?? []).map(parse).map((operation) => {
-        if (operation.type === "remove") return operation
-        const directory = entry.path ? path.dirname(entry.path) : location.directory
-        const target = operation.target.startsWith("file://")
-          ? fileURLToPath(operation.target)
-          : operation.target.startsWith("./") || operation.target.startsWith("../")
-            ? path.resolve(directory, operation.target)
-            : operation.target
-        return { ...operation, target }
-      }),
-    )
-  // Explicit config is applied last so it can remove auto-discovered packages.
-  return yield* Effect.forEach([...discovered, ...configured], (operation) => {
-    if (operation.type === "remove" || !path.isAbsolute(operation.target)) return Effect.succeed(operation)
-    return fs.stat(operation.target).pipe(
-      Effect.map((info) => ({
-        ...operation,
-        mtime: Option.getOrElse(info.mtime, () => new Date(0)).getTime(),
-      })),
-      Effect.catch(() => Effect.succeed(operation)),
-    )
-  })
-})
-
-function discoverDirectory(fs: FSUtil.Interface, directory: string) {
-  return Effect.gen(function* () {
-    const files = yield* fs
-      .scan("{plugin,plugins}/*.{ts,js}", {
-        cwd: directory,
-        absolute: true,
-        include: "file",
-        dot: true,
-        symlink: true,
-      })
-      .pipe(Effect.orElseSucceed(() => []))
-    return files.sort().map((target): Operation => ({ type: "add", target, options: {} }))
-  })
-}
-
-const sourceDirectories = ["plugin", "plugins"] as const
-
-function isPluginSource(entries: readonly Entry[], file: string) {
-  return entries.some(
-    (entry) =>
-      entry.type === "directory" &&
-      sourceDirectories.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)),
-  )
-}

packages/core/src/database/database.ts

@@ -40,19 +40,16 @@ const databaseLayer = Layer.effect(
 )
 
 export function layer(options: Options = { path: ":memory:" }) {
-  return Layer.unwrap(
-    Effect.gen(function* () {
-      const global = yield* Global.Service
-      const provide = (filename: string) => databaseLayer.pipe(Layer.provide(sqliteLayer({ filename })))
-      const filename = options.path ?? ":memory:"
-      if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
-      return provide(join(global.data, filename))
-    }),
-  )
+  return Layer.suspend(() => {
+    const provide = (filename: string) => databaseLayer.pipe(Layer.provide(sqliteLayer({ filename })))
+    const filename = options.path ?? ":memory:"
+    if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
+    return provide(join(Global.Path.data, filename))
+  })
 }
 
 export function configured(options?: Options) {
-  return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] })
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [] })
 }
 
 export const node = configured({ path: ":memory:" })

packages/core/src/database/migration.ts

@@ -5,7 +5,6 @@ import { Effect, Semaphore } from "effect"
 import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
 import { migrations } from "./migration.gen"
 import schema from "./schema.gen"
-import { Global } from "@opencode-ai/util/global"
 
 type Database = EffectDrizzleSqlite.EffectSQLiteDatabase
 type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0]
@@ -14,7 +13,7 @@ const lock = Semaphore.makeUnsafe(1)
 export type Migration = {
   id: string
   foreignKeys?: boolean
-  up: (tx: Transaction) => Effect.Effect<void, unknown, Global.Service>
+  up: (tx: Transaction) => Effect.Effect<void, unknown>
 }
 
 export function apply(db: Database) {

packages/core/src/database/migration/20260805200742_import_legacy_credentials.ts

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises"
 import path from "node:path"
 import { sql } from "drizzle-orm"
 import { Effect, Option, Schema } from "effect"
@@ -34,10 +33,7 @@ const wellKnownSourcesKey = "wellknown:sources"
 const migration: DatabaseMigration.Migration = {
   id: "20260805200742_import_legacy_credentials",
   up(tx) {
-    return Effect.gen(function* () {
-      const global = yield* Global.Service
-      return yield* importLegacyCredentials(tx, path.join(global.data, "auth.json"))
-    })
+    return importLegacyCredentials(tx, path.join(Global.Path.data, "auth.json"))
   },
 }
 
@@ -45,9 +41,9 @@ export default migration
 
 export function importLegacyCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], filepath: string) {
   return Effect.gen(function* () {
-    const content = yield* Effect.promise(() => readFile(filepath, "utf8").catch(() => undefined))
-    if (content === undefined) return
-    const input = Option.getOrUndefined(decodeJson(content))
+    const file = Bun.file(filepath)
+    if (!(yield* Effect.promise(() => file.exists()))) return
+    const input = Option.getOrUndefined(decodeJson(yield* Effect.promise(() => file.text())))
     if (typeof input !== "object" || input === null || Array.isArray(input)) {
       return yield* Effect.fail(new Error("Legacy credential file must contain an object"))
     }

packages/core/src/database/v1-migration.ts

@@ -467,11 +467,10 @@ function updateProgress(progress: Progress) {
   if (runtimeState.status === "running") runtimeState = { status: "running", progress }
 }
 
-export function run(options: Options = {}): Effect.Effect<RunResult, never, Database.Service | Global.Service> {
+export function run(options: Options = {}): Effect.Effect<RunResult, never, Database.Service> {
   return lock.withPermit(
     Effect.gen(function* () {
       const { db } = yield* Database.Service
-      const global = yield* Global.Service
       const state = yield* readState(db)
       if (state?.phase === "completed") return { status: "completed" as const }
       if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
@@ -479,7 +478,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
         const now = Date.now()
         yield* db.run(sql`
           INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
-          VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
+          VALUES (${Project.ID.global}, ${path.parse(Global.Path.data).root}, ${now}, ${now}, '[]')
         `)
         if (state === undefined)
           yield* db
@@ -493,7 +492,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
               }),
             )
             .pipe(Effect.orDie)
-        const sourceTotal = yield* countNextSessions(nextPath(options, global.data))
+        const sourceTotal = yield* countNextSessions(nextPath(options))
         const legacyTotal = (yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0
         const cursor = state?.phase === "sessions" ? state.cursor : undefined
         const migrated =
@@ -503,7 +502,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
             : 0
         const denominator = sourceTotal + legacyTotal
         updateProgress({ label: "Migrating sessions", numerator: migrated, denominator })
-        yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
+        yield* importNextDatabase(db, nextPath(options), (completed) => {
           updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator })
         })
         updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator })
@@ -622,10 +621,10 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
   )
 }
 
-function nextPath(options: Options, data: string) {
+function nextPath(options: Options) {
   if (options.nextDatabasePath) return options.nextDatabasePath
   if (process.env.OPENCODE_DB === ":memory:") return undefined
-  return path.join(data, "opencode-next.db")
+  return path.join(Global.Path.data, "opencode-next.db")
 }
 
 function openNextDatabase(sourcePath: string) {

packages/core/src/filesystem/location-watcher.ts

@@ -1,71 +0,0 @@
-export * as LocationWatcher from "./location-watcher"
-
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Stream } from "effect"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Document } from "@opencode-ai/schema/config"
-import path from "path"
-import { Config } from "../config"
-import { Bus } from "../bus"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Git } from "../git"
-import { Location } from "../location"
-import { Watcher } from "./watcher"
-
-export interface Interface {}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/LocationWatcher") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const location = yield* Location.Service
-    const watcher = yield* Watcher.Service
-    const bus = yield* Bus.Service
-    const fs = yield* FSUtil.Service
-    const git = yield* Git.Service
-    const configService = yield* Config.Service
-    const publish = (update: { type: "create" | "update" | "delete"; path: string }) =>
-      bus.publish(FileSystem.Event.Changed, {
-        file: update.path,
-        event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink",
-      })
-
-    yield* Effect.gen(function* () {
-      const config = (yield* configService.entries())
-        .filter((entry): entry is Document => entry.type === "document")
-        .flatMap((item) => item.info.watcher?.ignore ?? [])
-
-      if (location.vcs?.type === "git") {
-        const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
-        const vcs = resolved
-          ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved)))
-          : undefined
-        if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
-          const updates = yield* watcher.subscribe({ path: path.join(vcs, "HEAD"), type: "file" })
-          yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
-        }
-      }
-      if (location.vcs?.type === "hg") {
-        const store = location.vcs.store
-        const vcs = yield* fs.realPath(store).pipe(Effect.catch(() => Effect.succeed(store)))
-        if (!config.includes(".hg") && !config.includes(vcs)) {
-          const updates = yield* watcher.subscribe({ path: path.join(vcs, "branch"), type: "file" })
-          yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
-        }
-      }
-    }).pipe(
-      Effect.withSpan("LocationWatcher.start", { attributes: { directory: location.directory } }),
-      Effect.catchCause((cause) => Effect.logError("failed to init location watcher service", { cause })),
-      Effect.forkScoped,
-    )
-
-    return Service.of({})
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Watcher.node, FSUtil.node, Location.node, Config.node, Git.node, Bus.node],
-})

packages/core/src/formatter.ts

@@ -7,7 +7,6 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Npm } from "@opencode-ai/util/npm"
 import { AppProcess } from "@opencode-ai/util/process"
-import { Global } from "@opencode-ai/util/global"
 import { Config } from "./config"
 import { Location } from "./location"
 import { make, type Info } from "./formatter/builtins"
@@ -26,7 +25,6 @@ const layer = Layer.effect(
     const location = yield* Location.Service
     const npm = yield* Npm.Service
     const processes = yield* AppProcess.Service
-    const global = yield* Global.Service
     const commands = new Map<string, string[] | false>()
     let formatters: Info[] = []
 
@@ -44,7 +42,6 @@ const layer = Layer.effect(
           fs,
           npm,
           processes,
-          bin: global.bin,
         })
         formatters = builtIns
         if (configured === true) return
@@ -125,5 +122,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Config.node, FSUtil.node, Location.node, Npm.node, AppProcess.node, Global.node],
+  deps: [Config.node, FSUtil.node, Location.node, Npm.node, AppProcess.node],
 })

packages/core/src/formatter/builtins.ts

@@ -18,10 +18,8 @@ export function make(input: {
   readonly fs: FSUtil.Interface
   readonly npm: Npm.Interface
   readonly processes: AppProcess.Interface
-  readonly bin: string
 }) {
   const disabled = false as const
-  const findExecutable = (name: string) => which(name, undefined, input.bin)
   const findUp = (target: string) => input.fs.findUp(target, input.directory, input.worktree)
   const readText = (file: string) => input.fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""))
   const commandOutput = (command: string[]) =>
@@ -39,7 +37,7 @@ export function make(input: {
     name: "gofmt",
     extensions: [".go"],
     enabled: Effect.sync(() => {
-      const match = findExecutable("gofmt")
+      const match = which("gofmt")
       return match ? [match, "-w", "$FILE"] : disabled
     }),
   }
@@ -48,7 +46,7 @@ export function make(input: {
     name: "mix",
     extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
     enabled: Effect.sync(() => {
-      const match = findExecutable("mix")
+      const match = which("mix")
       return match ? [match, "format", "$FILE"] : disabled
     }),
   }
@@ -151,7 +149,7 @@ export function make(input: {
     name: "zig",
     extensions: [".zig", ".zon"],
     enabled: Effect.sync(() => {
-      const match = findExecutable("zig")
+      const match = which("zig")
       return match ? [match, "fmt", "$FILE"] : disabled
     }),
   }
@@ -161,7 +159,7 @@ export function make(input: {
     extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
     enabled: Effect.gen(function* () {
       if (!(yield* findUp(".clang-format")).length) return disabled
-      const match = findExecutable("clang-format")
+      const match = which("clang-format")
       return match ? [match, "-i", "$FILE"] : disabled
     }).pipe(Effect.orElseSucceed(() => disabled)),
   }
@@ -170,7 +168,7 @@ export function make(input: {
     name: "ktlint",
     extensions: [".kt", ".kts"],
     enabled: Effect.sync(() => {
-      const match = findExecutable("ktlint")
+      const match = which("ktlint")
       return match ? [match, "-F", "$FILE"] : disabled
     }),
   }
@@ -179,18 +177,17 @@ export function make(input: {
     name: "ruff",
     extensions: [".py", ".pyi"],
     enabled: Effect.gen(function* () {
-      const bin = findExecutable("ruff")
-      if (!bin) return disabled
+      if (!which("ruff")) return disabled
       for (const config of ["pyproject.toml", "ruff.toml", ".ruff.toml"]) {
         const found = yield* findUp(config)
         if (!found.length) continue
         if (config !== "pyproject.toml" || (yield* readText(found[0])).includes("[tool.ruff]")) {
-          return [bin, "format", "$FILE"]
+          return ["ruff", "format", "$FILE"]
         }
       }
       for (const dependency of ["requirements.txt", "pyproject.toml", "Pipfile"]) {
         const found = yield* findUp(dependency)
-        if (found.length && (yield* readText(found[0])).includes("ruff")) return [bin, "format", "$FILE"]
+        if (found.length && (yield* readText(found[0])).includes("ruff")) return ["ruff", "format", "$FILE"]
       }
       return disabled
     }).pipe(Effect.orElseSucceed(() => disabled)),
@@ -200,7 +197,7 @@ export function make(input: {
     name: "air",
     extensions: [".R"],
     enabled: Effect.gen(function* () {
-      const bin = findExecutable("air")
+      const bin = which("air")
       if (!bin) return disabled
       const output = yield* commandOutput([bin, "--help"])
       if (output._tag === "None" || output.value.exitCode !== 0) return disabled
@@ -213,34 +210,34 @@ export function make(input: {
     name: "uv",
     extensions: [".py", ".pyi"],
     enabled: Effect.gen(function* () {
-      const bin = findExecutable("uv")
+      const bin = which("uv")
       if (!bin) return disabled
       const output = yield* commandOutput([bin, "format", "--help"])
       return output._tag === "Some" && output.value.exitCode === 0 ? [bin, "format", "--", "$FILE"] : disabled
     }),
   }
 
-  const rubocop = executable("rubocop", [".rb", ".rake", ".gemspec", ".ru"], ["--autocorrect", "$FILE"], findExecutable)
-  const standardrb = executable("standardrb", [".rb", ".rake", ".gemspec", ".ru"], ["--fix", "$FILE"], findExecutable)
-  const htmlbeautifier = executable("htmlbeautifier", [".erb", ".html.erb"], ["$FILE"], findExecutable)
-  const dart = executable("dart", [".dart"], ["format", "$FILE"], findExecutable)
+  const rubocop = executable("rubocop", [".rb", ".rake", ".gemspec", ".ru"], ["--autocorrect", "$FILE"])
+  const standardrb = executable("standardrb", [".rb", ".rake", ".gemspec", ".ru"], ["--fix", "$FILE"])
+  const htmlbeautifier = executable("htmlbeautifier", [".erb", ".html.erb"], ["$FILE"])
+  const dart = executable("dart", [".dart"], ["format", "$FILE"])
 
   const ocamlformat: Info = {
     name: "ocamlformat",
     extensions: [".ml", ".mli"],
     enabled: Effect.gen(function* () {
       if (!(yield* findUp(".ocamlformat")).length) return disabled
-      const match = findExecutable("ocamlformat")
+      const match = which("ocamlformat")
       return match ? [match, "-i", "$FILE"] : disabled
     }).pipe(Effect.orElseSucceed(() => disabled)),
   }
 
-  const terraform = executable("terraform", [".tf", ".tfvars"], ["fmt", "$FILE"], findExecutable)
-  const latexindent = executable("latexindent", [".tex"], ["-w", "-s", "$FILE"], findExecutable)
-  const gleam = executable("gleam", [".gleam"], ["format", "$FILE"], findExecutable)
-  const shfmt = executable("shfmt", [".sh", ".bash"], ["-w", "$FILE"], findExecutable)
-  const nixfmt = executable("nixfmt", [".nix"], ["$FILE"], findExecutable)
-  const rustfmt = executable("rustfmt", [".rs"], ["$FILE"], findExecutable)
+  const terraform = executable("terraform", [".tf", ".tfvars"], ["fmt", "$FILE"])
+  const latexindent = executable("latexindent", [".tex"], ["-w", "-s", "$FILE"])
+  const gleam = executable("gleam", [".gleam"], ["format", "$FILE"])
+  const shfmt = executable("shfmt", [".sh", ".bash"], ["-w", "$FILE"])
+  const nixfmt = executable("nixfmt", [".nix"], ["$FILE"])
+  const rustfmt = executable("rustfmt", [".rs"], ["$FILE"])
 
   const pint: Info = {
     name: "pint",
@@ -256,9 +253,9 @@ export function make(input: {
     }).pipe(Effect.orElseSucceed(() => disabled)),
   }
 
-  const ormolu = executable("ormolu", [".hs"], ["-i", "$FILE"], findExecutable)
-  const cljfmt = executable("cljfmt", [".clj", ".cljs", ".cljc", ".edn"], ["fix", "--quiet", "$FILE"], findExecutable)
-  const dfmt = executable("dfmt", [".d"], ["-i", "$FILE"], findExecutable)
+  const ormolu = executable("ormolu", [".hs"], ["-i", "$FILE"])
+  const cljfmt = executable("cljfmt", [".clj", ".cljs", ".cljc", ".edn"], ["fix", "--quiet", "$FILE"])
+  const dfmt = executable("dfmt", [".d"], ["-i", "$FILE"])
 
   return [
     gofmt,
@@ -290,17 +287,12 @@ export function make(input: {
   ] satisfies Info[]
 }
 
-function executable(
-  name: string,
-  extensions: readonly string[],
-  args: string[],
-  findExecutable: (name: string) => string | null,
-): Info {
+function executable(name: string, extensions: readonly string[], args: string[]): Info {
   return {
     name,
     extensions,
     enabled: Effect.sync(() => {
-      const match = findExecutable(name)
+      const match = which(name)
       return match ? [match, ...args] : false
     }),
   }

packages/core/src/instruction-discovery.ts

@@ -1,13 +1,15 @@
 export * as InstructionDiscovery from "./instruction-discovery"
 
-import { Context, Effect, Layer, Schema, Types } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Bus } from "./bus"
-import { Instructions } from "./instructions/index"
+import { Array, Context, Effect, Layer, Schema } from "effect"
+import { isAbsolute, join, relative, sep } from "path"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Global } from "@opencode-ai/util/global"
+import { Location } from "./location"
 import { AbsolutePath } from "./schema"
-import { State } from "./state"
+import { Instructions } from "./instructions/index"
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 
-export class File extends Schema.Class<File>("InstructionDiscovery.File")({
+class File extends Schema.Class<File>("InstructionDiscovery.File")({
   path: AbsolutePath,
   content: Schema.String,
 }) {}
@@ -15,30 +17,7 @@ export class File extends Schema.Class<File>("InstructionDiscovery.File")({
 const Files = Schema.Array(File)
 const key = Instructions.Key.make("core/instructions")
 
-export const Event = {
-  Updated: Bus.ephemeral({ type: "instruction-discovery.updated", schema: {} }),
-}
-
-export type Data = {
-  files: Map<AbsolutePath, Types.DeepMutable<File>>
-  available: boolean
-}
-
-export type Draft = {
-  list: () => readonly Types.DeepMutable<File>[]
-  // Map insertion order is render order: config adds global then nearest-to-farthest project files;
-  // sibling contributors interleave by transform registration order.
-  add: (file: File) => void
-  update: (path: string, update: (file: Types.DeepMutable<File>) => void) => void
-  remove: (path: string) => void
-  unavailable: () => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
-  // Discovery policy lives here because internal plugins have no per-composition options channel.
-  // Move it into plugin config once plugins can consume their own options.
-  readonly project: boolean
-  readonly list: () => Effect.Effect<File[] | Instructions.Unavailable>
+export interface Interface {
   readonly load: () => Effect.Effect<Instructions.List>
 }
 
@@ -53,26 +32,9 @@ export const layer = (options?: Options) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const state = State.create<Data, Draft>({
-        name: "instruction-discovery",
-        initial: () => ({ files: new Map(), available: true }),
-        draft: (draft) => ({
-          list: () => Array.from(draft.files.values()),
-          add: (file) => draft.files.set(file.path, new File(file) as Types.DeepMutable<File>),
-          update: (path, update) => {
-            const current = draft.files.get(AbsolutePath.make(path))
-            if (!current) return
-            update(current)
-            current.path = AbsolutePath.make(path)
-          },
-          remove: (path) => draft.files.delete(AbsolutePath.make(path)),
-          unavailable: () => {
-            draft.available = false
-          },
-        }),
-        finalize: () => bus.publish(Event.Updated, {}).pipe(Effect.asVoid),
-      })
+      const fs = yield* FSUtil.Service
+      const global = yield* Global.Service
+      const location = yield* Location.Service
 
       const source = (value: ReadonlyArray<File> | Instructions.Unavailable | Instructions.Removed) =>
         Instructions.make<ReadonlyArray<File>>({
@@ -87,22 +49,52 @@ export const layer = (options?: Options) =>
           },
         })
 
-      const list = Effect.fn("InstructionDiscovery.list")(function* () {
-        const current = state.get()
-        if (!current.available) return Instructions.unavailable
-        return Array.from(current.files.values())
+      const observe = Effect.fn("InstructionDiscovery.observe")(function* () {
+        const start = yield* fs.resolve(location.directory)
+        const stop = yield* fs.resolve(location.project.directory)
+        const fromProject = relative(stop, start)
+        const insideProject =
+          fromProject === "" ||
+          (fromProject !== ".." && !fromProject.startsWith(`..${sep}`) && !isAbsolute(fromProject))
+        const discovered = new Set(
+          yield* Effect.forEach(
+            options?.project === false || !insideProject
+              ? []
+              : yield* fs.up({
+                  targets: ["AGENTS.md"],
+                  start,
+                  stop,
+                }),
+            fs.resolve,
+          ),
+        )
+        const paths = Array.dedupe([yield* fs.resolve(join(global.config, "AGENTS.md")), ...discovered])
+        const files = yield* Effect.forEach(
+          paths,
+          (path) =>
+            fs
+              .readFileStringSafe(path)
+              .pipe(
+                Effect.map((content) =>
+                  content === undefined ? undefined : new File({ path: AbsolutePath.make(path), content }),
+                ),
+              ),
+          { concurrency: "unbounded" },
+        )
+        if (files.some((file, index) => file === undefined && discovered.has(paths[index])))
+          return Instructions.unavailable
+        return files.filter((file): file is File => file !== undefined)
       })
 
       return Service.of({
-        project: options?.project !== false,
-        transform: state.transform,
-        reload: state.reload,
-        list,
-        load: Effect.fn("InstructionDiscovery.load")(function* () {
-          const files = yield* list()
-          if (!Array.isArray(files)) return source(files)
-          return source(files.length === 0 ? Instructions.removed : files)
-        }),
+        load: () =>
+          observe().pipe(
+            Effect.map((files) =>
+              Array.isArray(files) && files.length === 0 ? source(Instructions.removed) : source(files),
+            ),
+            Effect.catch(() => Effect.succeed(source(Instructions.unavailable))),
+            Effect.catchDefect(() => Effect.succeed(source(Instructions.unavailable))),
+          ),
       })
     }),
   )
@@ -111,7 +103,7 @@ export function configured(options?: Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [Bus.node],
+    deps: [FSUtil.node, Global.node, Location.node],
   })
 }
 

packages/core/src/location-services.ts

@@ -15,7 +15,6 @@ import { FileSystemSearch } from "./filesystem/search"
 import { Generate } from "./generate"
 import { Form } from "./form"
 import { Image } from "./image"
-import { LocationWatcher } from "./filesystem/location-watcher"
 import { Integration } from "./integration"
 import { Location } from "./location"
 import { LocationMutation } from "./location-mutation"
@@ -99,8 +98,6 @@ const locationServiceNodes = [
   Snapshot.node,
   SessionRunnerLLM.node,
   Vcs.node,
-  // Start repository watches only after boot-critical filesystem and Git work.
-  LocationWatcher.node,
 ] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
 
 export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)

packages/core/src/models-dev.ts

@@ -1,8 +1,11 @@
-import { Context, Duration, Effect, Layer, Option, Schedule, Schema, Semaphore } from "effect"
+import path from "path"
+import { Context, Duration, Effect, Layer, Option, Schedule, Schema } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { ModelsDev } from "@opencode-ai/schema/models-dev"
 import { Money } from "@opencode-ai/schema/money"
 import { App } from "./app"
+import { Global } from "@opencode-ai/util/global"
+import { Flock } from "@opencode-ai/util/flock"
 import { Hash } from "@opencode-ai/util/hash"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Bus } from "./bus"
@@ -10,7 +13,6 @@ import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Model } from "./model"
 import { Provider } from "./provider"
-import { KV } from "./kv"
 
 export const CatalogModelStatus = Schema.Literals(["alpha", "beta", "deprecated"])
 export type CatalogModelStatus = typeof CatalogModelStatus.Type
@@ -535,18 +537,6 @@ export type Options = typeof Options.Type
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/ModelsDev") {}
 
-const CatalogJson = Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown))
-const Cache = Schema.Struct({
-  updatedAt: Schema.Number,
-  body: CatalogJson,
-})
-const defaultSource = "https://models.opencode.ai"
-
-function cacheKey(source: string) {
-  if (source === defaultSource) return "models-dev:catalog"
-  return `models-dev:catalog:${Hash.fast(source)}`
-}
-
 export const layer = (options?: Options) =>
   Layer.effect(
     Service,
@@ -554,7 +544,6 @@ export const layer = (options?: Options) =>
       const fs = yield* FSUtil.Service
       const bus = yield* Bus.Service
       const app = yield* App.Metadata
-      const kv = yield* KV.Service
       const http = HttpClient.filterStatusOk(
         (yield* HttpClient.HttpClient).pipe(
           HttpClient.retryTransient({
@@ -565,28 +554,21 @@ export const layer = (options?: Options) =>
         ),
       )
 
-      const source = options?.url || defaultSource
+      const source = options?.url || "https://models.opencode.ai"
       const fetch = options?.fetch ?? true
       const userAgent = App.useragent(app)
-      const key = cacheKey(source)
+      const filepath = path.join(
+        Global.Path.cache,
+        source === "https://models.opencode.ai" ? "models.json" : `models-${Hash.fast(source)}.json`,
+      )
       const ttl = Duration.minutes(5)
-      const lock = Semaphore.makeUnsafe(1)
-
-      const loadFromCache = Effect.fnUntraced(function* () {
-        const value = yield* kv.get(key)
-        const cached = Schema.decodeUnknownOption(Cache)(value)
-        if (Option.isSome(cached))
-          return {
-            catalog: cached.value.body as Record<string, SourceProvider>,
-            updatedAt: cached.value.updatedAt,
-          }
-        if (value !== undefined) yield* kv.remove(key)
-      })
+      const lockKey = `models-dev:${filepath}`
 
       const fresh = Effect.fnUntraced(function* () {
-        const cached = yield* loadFromCache()
-        if (!cached) return false
-        return Date.now() - cached.updatedAt < Duration.toMillis(ttl)
+        const stat = yield* fs.stat(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
+        if (!stat) return false
+        const mtime = Option.getOrElse(stat.mtime, () => new Date(0)).getTime()
+        return Date.now() - mtime < Duration.toMillis(ttl)
       })
 
       const fetchApi = Effect.fn("ModelsDev.fetchApi")(function* () {
@@ -598,12 +580,15 @@ export const layer = (options?: Options) =>
         )
       })
 
-      const loadFromFile = options?.file
-        ? fs.readJson(options.file).pipe(
-            Effect.map((input) => input as Record<string, SourceProvider>),
-            Effect.catch(() => Effect.succeed(undefined)),
-          )
-        : Effect.succeed(undefined)
+      const loadFromDisk = fs.readJson(options?.file ?? filepath).pipe(
+        Effect.map((input) => input as Record<string, SourceProvider>),
+        Effect.catch((error) => {
+          if (options?.file === undefined && error._tag === "FileSystemError" && error.method === "readJson") {
+            return fs.remove(filepath, { force: true }).pipe(Effect.ignore, Effect.as(undefined))
+          }
+          return Effect.succeed(undefined)
+        }),
+      )
 
       const loadSnapshot = Effect.sync(() =>
         typeof OPENCODE_MODELS_DEV === "undefined" ? undefined : OPENCODE_MODELS_DEV,
@@ -611,27 +596,33 @@ export const layer = (options?: Options) =>
 
       const fetchAndWrite = Effect.fn("ModelsDev.fetchAndWrite")(function* () {
         const text = yield* fetchApi()
-        const catalog = (yield* Schema.decodeUnknownEffect(CatalogJson)(text)) as Record<string, SourceProvider>
-        yield* kv.set(key, { updatedAt: Date.now(), body: text })
-        return catalog
+        const tempfile = `${filepath}.${process.pid}.${Date.now()}.tmp`
+        yield* fs.writeWithDirs(tempfile, text).pipe(
+          Effect.andThen(fs.rename(tempfile, filepath)),
+          Effect.catch((error) =>
+            Effect.gen(function* () {
+              yield* fs.remove(tempfile, { force: true }).pipe(Effect.ignore)
+              return yield* Effect.fail(error)
+            }),
+          ),
+        )
+        return text
       })
 
       const populate = Effect.gen(function* () {
-        const fromFile = yield* loadFromFile
-        if (fromFile) return normalize(fromFile)
-        const cached = options?.file ? undefined : yield* loadFromCache()
-        if (cached) return normalize(cached.catalog)
+        const fromDisk = yield* loadFromDisk
+        if (fromDisk) return normalize(fromDisk)
         const bundled = yield* loadSnapshot
         if (bundled) return normalize(bundled)
         if (!fetch) return []
-        const catalog = yield* lock.withPermit(
+        // Flock is cross-process: concurrent opencode CLIs can race on this cache file.
+        const text = yield* Effect.scoped(
           Effect.gen(function* () {
-            const stored = options?.file ? undefined : yield* loadFromCache()
-            if (stored) return stored.catalog
+            yield* Flock.effect(lockKey)
             return yield* fetchAndWrite()
           }),
         )
-        return normalize(catalog)
+        return normalize(JSON.parse(text) as Record<string, SourceProvider>)
       }).pipe(Effect.withSpan("ModelsDev.populate"), Effect.orDie)
 
       const [cachedGet, invalidate] = yield* Effect.cachedInvalidateWithTTL(populate, Duration.infinity)
@@ -639,19 +630,21 @@ export const layer = (options?: Options) =>
       const get = (): Effect.Effect<readonly Snapshot[]> => cachedGet
 
       const refresh = Effect.fn("ModelsDev.refresh")(function* (force = false) {
-        yield* lock
-          .withPermit(
-            Effect.gen(function* () {
-              if (!force && (yield* fresh())) return
-              yield* fetchAndWrite()
-              yield* invalidate
-              yield* bus.publish(ModelsDev.Event.Refreshed, {})
-            }),
-          )
-          .pipe(
-            Effect.tapCause((cause) => Effect.logError("Failed to fetch models.dev", { cause: cause })),
-            Effect.ignore,
-          )
+        if (!force && (yield* fresh())) return
+        yield* Effect.scoped(
+          Effect.gen(function* () {
+            yield* Flock.effect(lockKey)
+            // Re-check under the lock: another process may have refreshed between
+            // our outer check and lock acquisition.
+            if (!force && (yield* fresh())) return
+            yield* fetchAndWrite()
+            yield* invalidate
+            yield* bus.publish(ModelsDev.Event.Refreshed, {})
+          }),
+        ).pipe(
+          Effect.tapCause((cause) => Effect.logError("Failed to fetch models.dev", { cause: cause })),
+          Effect.ignore,
+        )
       })
 
       if (fetch && !process.argv.includes("--get-yargs-completions")) {
@@ -667,7 +660,7 @@ export function configured(options?: Options) {
   return makeGlobalNode({
     service: Service,
     layer: layer(options),
-    deps: [FSUtil.node, Bus.node, App.node, KV.node, httpClient],
+    deps: [FSUtil.node, Bus.node, App.node, httpClient],
   })
 }
 

packages/core/src/plugin/host.ts

@@ -290,10 +290,8 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       transform: (callback) =>
         skill.transform((draft) => {
           callback({
-            list: () => mutable(draft.list()),
-            add: (value) => draft.add(Schema.decodeUnknownSync(Skill.Info)(value)),
-            update: draft.update,
-            remove: draft.remove,
+            source: (source) => draft.source(Schema.decodeUnknownSync(Skill.Source)(source)),
+            list: draft.list,
           })
         }),
     },

packages/core/src/plugin/internal.ts

@@ -1,8 +1,6 @@
 export * as PluginInternal from "./internal"
 
 import type { Plugin } from "@opencode-ai/plugin/effect/plugin"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Context, Effect, Scope } from "effect"
 import { HttpClient } from "effect/unstable/http"
 import { Agent } from "../agent"
@@ -12,7 +10,6 @@ import { Config } from "../config"
 import { Credential } from "../credential"
 import { ConfigAgentPlugin } from "../config/plugin/agent"
 import { ConfigCommandPlugin } from "../config/plugin/command"
-import { ConfigInstructionPlugin } from "../config/plugin/instruction"
 import { ConfigProviderPlugin } from "../config/plugin/provider"
 import { ConfigPolicyPlugin } from "../config/plugin/policy"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
@@ -27,7 +24,6 @@ import { FileSystem } from "../filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Image } from "../image"
-import { InstructionDiscovery } from "../instruction-discovery"
 import { Integration } from "../integration"
 import { KV } from "../kv"
 import { Location } from "../location"
@@ -41,8 +37,6 @@ import { Ripgrep } from "../ripgrep"
 import { SessionInstructions } from "../session/instructions"
 import { Shell } from "../shell"
 import { Skill } from "../skill"
-import { SkillDiscovery } from "../skill/discovery"
-import { Watcher } from "../filesystem/watcher"
 import { PatchTool } from "../tool/plugin/patch"
 import { EditTool } from "../tool/plugin/edit"
 import { GlobTool } from "../tool/plugin/glob"
@@ -85,7 +79,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const global = yield* Global.Service
   const http = yield* HttpClient.HttpClient
   const image = yield* Image.Service
-  const instructionDiscovery = yield* InstructionDiscovery.Service
   const integration = yield* Integration.Service
   const kv = yield* KV.Service
   const location = yield* Location.Service
@@ -102,9 +95,7 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const instructions = yield* SessionInstructions.Service
   const shell = yield* Shell.Service
   const skill = yield* Skill.Service
-  const skillDiscovery = yield* SkillDiscovery.Service
   const tools = yield* Tool.Service
-  const watcher = yield* Watcher.Service
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
     Context.make(Agent.Service, agent),
@@ -121,7 +112,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Global.Service, global),
     Context.make(HttpClient.HttpClient, http),
     Context.make(Image.Service, image),
-    Context.make(InstructionDiscovery.Service, instructionDiscovery),
     Context.make(Integration.Service, integration),
     Context.make(KV.Service, kv),
     Context.make(Location.Service, location),
@@ -138,9 +128,7 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(SessionInstructions.Service, instructions),
     Context.make(Shell.Service, shell),
     Context.make(Skill.Service, skill),
-    Context.make(SkillDiscovery.Service, skillDiscovery),
     Context.make(Tool.Service, tools),
-    Context.make(Watcher.Service, watcher),
     Context.make(WellKnown.Service, wellknown),
   )
 })
@@ -149,44 +137,6 @@ type ContextServices<A> = A extends Context.Context<infer R> ? R : never
 
 export type Requirements = ContextServices<Effect.Success<ReturnType<typeof services>>>
 
-export const requirements = LayerNode.group([
-  Agent.node,
-  Catalog.node,
-  Command.node,
-  Config.node,
-  Credential.node,
-  Bus.node,
-  Environment.node,
-  FileMutation.node,
-  Formatter.node,
-  FileSystem.node,
-  FSUtil.node,
-  Global.node,
-  httpClient,
-  Image.node,
-  InstructionDiscovery.node,
-  Integration.node,
-  KV.node,
-  Location.node,
-  LocationMutation.node,
-  ModelsDev.node,
-  Npm.node,
-  Permission.node,
-  PluginRuntime.node,
-  Form.node,
-  ReadToolFileSystem.node,
-  Reference.node,
-  WebSearch.node,
-  Ripgrep.node,
-  SessionInstructions.node,
-  Shell.node,
-  Skill.node,
-  SkillDiscovery.node,
-  Tool.node,
-  Watcher.node,
-  WellKnown.node,
-])
-
 export type InternalPlugin = Plugin<Requirements | Scope.Scope>
 
 const pre = [
@@ -214,7 +164,6 @@ const pre = [
 ] as const satisfies readonly InternalPlugin[]
 
 const post = [
-  ConfigInstructionPlugin.Plugin,
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,

packages/core/src/plugin/promise.ts

@@ -310,6 +310,8 @@ export function fromPromise(plugin: Plugin) {
                   ...input,
                   sessionID: Session.ID.make(input.sessionID),
                   id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+                  agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+                  model: input.model == null ? undefined : model(input.model),
                   skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
                   arguments: input.arguments ?? undefined,
                   delivery: input.delivery ?? undefined,

packages/core/src/plugin/skill.ts

@@ -28,23 +28,29 @@ export const Plugin = define({
   effect: Effect.fn(function* (ctx) {
     const reportContent = yield* reportContentWithDiagnostics(ctx.app)
     yield* ctx.skill.transform((draft) => {
-      draft.add(
-        Skill.Info.make({
-          id: Skill.ID.make("opencode"),
-          name: Skill.Name.make("OpenCode"),
-          description: OpencodeDescription,
-          location: AbsolutePath.make("/builtin/opencode.md"),
-          content: OpencodeContent,
+      draft.source(
+        Skill.EmbeddedSource.make({
+          type: "embedded",
+          skill: Skill.Info.make({
+            id: Skill.ID.make("opencode"),
+            name: Skill.Name.make("OpenCode"),
+            description: OpencodeDescription,
+            location: AbsolutePath.make("/builtin/opencode.md"),
+            content: OpencodeContent,
+          }),
         }),
       )
-      draft.add(
-        Skill.Info.make({
-          id: Skill.ID.make("report"),
-          name: Skill.Name.make("Report"),
-          description: REPORT_DESCRIPTION,
-          slash: true,
-          location: AbsolutePath.make("/builtin/report.md"),
-          content: reportContent,
+      draft.source(
+        Skill.EmbeddedSource.make({
+          type: "embedded",
+          skill: Skill.Info.make({
+            id: Skill.ID.make("report"),
+            name: Skill.Name.make("Report"),
+            description: REPORT_DESCRIPTION,
+            slash: true,
+            location: AbsolutePath.make("/builtin/report.md"),
+            content: reportContent,
+          }),
         }),
       )
     })

packages/core/src/plugin/supervisor.ts

@@ -1,17 +1,48 @@
 export * as PluginSupervisor from "./supervisor"
 
 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
-import { Event } from "@opencode-ai/schema/config"
-import { Context, Deferred, Effect, Layer, Schema, Stream } from "effect"
+import { Directory, Document, Event, type Entry } from "@opencode-ai/schema/config"
+import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
+import { Context, Deferred, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import path from "path"
-import { pathToFileURL } from "url"
-import { ConfigPluginSource } from "../config/plugin/source"
+import { fileURLToPath, pathToFileURL } from "url"
+import { Agent } from "../agent"
+import { Catalog } from "../catalog"
+import { Command } from "../command"
+import { Config } from "../config"
+import { Credential } from "../credential"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Bus } from "../bus"
+import { Environment } from "../environment"
+import { FileMutation } from "../file-mutation"
+import { Formatter } from "../formatter"
+import { FileSystem } from "../filesystem"
+import { Watcher } from "../filesystem/watcher"
+import { Form } from "../form"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Global } from "@opencode-ai/util/global"
+import { Image } from "../image"
+import { Integration } from "../integration"
+import { KV } from "../kv"
+import { Location } from "../location"
+import { LocationMutation } from "../location-mutation"
+import { ModelsDev } from "../models-dev"
 import { Npm } from "@opencode-ai/util/npm"
+import { Permission } from "../permission"
 import { Plugin } from "../plugin"
 import { PluginPromise } from "../plugin/promise"
+import { Reference } from "../reference"
+import { Ripgrep } from "../ripgrep"
+import { SessionInstructions } from "../session/instructions"
+import { Shell } from "../shell"
+import { Skill } from "../skill"
+import { ReadToolFileSystem } from "../tool/read-filesystem"
+import { Tool } from "../tool"
+import { WebSearch } from "../websearch"
+import { WellKnown } from "../wellknown"
 import { PluginInternal } from "./internal"
+import { PluginRuntime } from "./runtime"
 import { SdkPlugins } from "./sdk"
 import { importModule } from "@opencode-ai/util/runtime-import"
 
@@ -32,10 +63,65 @@ const PluginModule = Schema.Struct({
   ]),
 })
 
+type Operation =
+  | {
+      readonly type: "add"
+      readonly target: string
+      readonly options: Record<string, unknown>
+      readonly mtime?: number
+    }
+  | {
+      readonly type: "remove"
+      readonly target: string
+    }
+
+function parse(input: ConfigPlugin.Plugin): Operation {
+  if (typeof input !== "string") {
+    return { type: "add", target: input.package, options: input.options ?? {} }
+  }
+  if (!input.startsWith("-")) return { type: "add", target: input, options: {} }
+  if (input.length === 1) throw new Error("Plugin remove operation requires a target")
+  return { type: "remove", target: input.slice(1) }
+}
+
+const scan = Effect.fn("PluginSupervisor.scan")(function* (entries: readonly Entry[]) {
+  const fs = yield* FSUtil.Service
+  const location = yield* Location.Service
+  const discovered = yield* Effect.forEach(
+    entries.filter((entry): entry is Directory => entry.type === "directory"),
+    (entry) => discoverDirectory(fs, entry.path),
+  ).pipe(Effect.map((items) => items.flat()))
+  const configured = entries
+    .filter((entry): entry is Document => entry.type === "document")
+    .flatMap((entry) =>
+      (entry.info.plugins ?? []).map(parse).map((operation) => {
+        if (operation.type === "remove") return operation
+        const directory = entry.path ? path.dirname(entry.path) : location.directory
+        const target = operation.target.startsWith("file://")
+          ? fileURLToPath(operation.target)
+          : operation.target.startsWith("./") || operation.target.startsWith("../")
+            ? path.resolve(directory, operation.target)
+            : operation.target
+        return { ...operation, target }
+      }),
+    )
+  // Explicit config is applied last so it can remove auto-discovered packages.
+  return yield* Effect.forEach([...discovered, ...configured], (operation) => {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target)) return Effect.succeed(operation)
+    return fs.stat(operation.target).pipe(
+      Effect.map((info) => ({
+        ...operation,
+        mtime: Option.getOrElse(info.mtime, () => new Date(0)).getTime(),
+      })),
+      Effect.catch(() => Effect.succeed(operation)),
+    )
+  })
+})
+
 const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
   pre: readonly Plugin.Versioned[],
   post: readonly Plugin.Versioned[],
-  operations: readonly ConfigPluginSource.Operation[],
+  operations: readonly Operation[],
 ) {
   const matches = (selector: string, target: string) =>
     selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target)
@@ -82,9 +168,7 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
   ]
 })
 
-const load = Effect.fn("PluginSupervisor.load")(function* (
-  operation: Extract<ConfigPluginSource.Operation, { type: "add" }>,
-) {
+const load = Effect.fn("PluginSupervisor.load")(function* (operation: Extract<Operation, { type: "add" }>) {
   const npm = yield* Npm.Service
   const entrypoint = path.isAbsolute(operation.target)
     ? pathToFileURL(operation.target).href
@@ -108,6 +192,31 @@ const load = Effect.fn("PluginSupervisor.load")(function* (
   } satisfies Plugin.Versioned
 })
 
+function discoverDirectory(fs: FSUtil.Interface, directory: string) {
+  return Effect.gen(function* () {
+    const files = yield* fs
+      .scan("{plugin,plugins}/*.{ts,js}", {
+        cwd: directory,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+    return files.sort().map((target): Operation => ({ type: "add", target, options: {} }))
+  })
+}
+
+const sourceDirectories = ["plugin", "plugins"] as const
+
+function isPluginSource(entries: readonly Entry[], file: string) {
+  return entries.some(
+    (entry) =>
+      entry.type === "directory" &&
+      sourceDirectories.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)),
+  )
+}
+
 export interface Interface {
   /** Wait for the initial plugin generation and startup updates to settle. */
   readonly flush: Effect.Effect<void>
@@ -115,29 +224,72 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/PluginSupervisor") {}
 
-export const layer = Layer.effect(
+const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const registry = yield* Plugin.Service
     const sdk = yield* SdkPlugins.Service
-    const sources = yield* ConfigPluginSource.Service
+    const config = yield* Config.Service
     const bus = yield* Bus.Service
+    const watcher = yield* Watcher.Service
+    const fs = yield* FSUtil.Service
     const ready = { current: yield* Deferred.make<void>() }
     let observed = 0
 
+    // Configured local plugin files can live outside config roots, where the
+    // config change feed cannot see them; watch those entrypoints directly.
+    // Watches start on first sighting and are never torn down individually:
+    // a stale watch after a config edit costs one deduped fs handle and a
+    // no-op activation, and every watch dies with this layer's scope.
+    const configuredChanges = yield* PubSub.unbounded<void>()
+    const watched = new Set<string>()
+    const watchConfiguredSources = Effect.fn("PluginSupervisor.watchConfiguredSources")(function* (
+      entries: readonly Entry[],
+      operations: readonly Operation[],
+    ) {
+      for (const operation of operations) {
+        if (operation.type !== "add" || !path.isAbsolute(operation.target)) continue
+        if (watched.has(operation.target)) continue
+        // The config change feed already covers {plugin,plugins} directories.
+        if (isPluginSource(entries, operation.target)) continue
+        // Directory targets can't hot-reload (their stat mtime ignores edits
+        // inside), so don't watch what can't trigger anything.
+        if (yield* fs.isDir(operation.target)) continue
+        watched.add(operation.target)
+        const updates = yield* watcher.subscribe({ path: operation.target, type: "file" })
+        yield* updates.pipe(
+          Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)),
+          Effect.catchCause((cause) =>
+            Effect.logError("configured plugin watch failed", { target: operation.target, cause }),
+          ),
+          Effect.forkScoped({ startImmediately: true }),
+        )
+      }
+    })
+
     const activate = Effect.fn("PluginSupervisor.activate")(function* () {
       // Resolve OpenCode's internal plugins with their privileged Location services.
       const internal = yield* PluginInternal.list()
       // Combine internal plugins with host-contributed SDK plugins in boot order.
       const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()]
       const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }))
-      const operations = yield* sources.operations()
+      const entries = yield* config.entries()
+      const operations = yield* scan(entries)
+      yield* watchConfiguredSources(entries, operations)
       // Apply config operations and load enabled package plugins into one ordered generation.
       const plugins = yield* resolve(pre, post, operations)
       // Replace the active generation in one scoped, batched activation.
       yield* registry.activate(plugins)
     })
-    const updates = Stream.merge(sources.changes(), bus.subscribe([Event.Updated, SdkPlugins.Updated])).pipe(
+    const updates = Stream.merge(
+      config.changes().pipe(
+        Stream.filterEffect((update) =>
+          Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path)),
+        ),
+        Stream.merge(Stream.fromPubSub(configuredChanges)),
+      ),
+      bus.subscribe([Event.Updated, SdkPlugins.Updated]),
+    ).pipe(
       // Make accepted work visible to flush before coalescing the burst.
       Stream.mapEffect(() =>
         Effect.gen(function* () {
@@ -163,13 +315,48 @@ export const layer = Layer.effect(
   }),
 )
 
-const nodeDeps = [
-  Plugin.node,
-  SdkPlugins.node,
-  ConfigPluginSource.node,
-  Bus.node,
-  Npm.node,
-  PluginInternal.requirements,
-] as const
+const nodeLayer = layer as Layer.Layer<Service, never, PluginInternal.Requirements>
 
-export const node = makeLocationNode({ service: Service, layer, deps: nodeDeps })
+export const node = makeLocationNode({
+  service: Service,
+  layer: nodeLayer,
+  deps: [
+    Plugin.node,
+    SdkPlugins.node,
+    Agent.node,
+    Catalog.node,
+    Command.node,
+    Config.node,
+    Credential.node,
+    Bus.node,
+    Environment.node,
+    FileMutation.node,
+    Formatter.node,
+    FileSystem.node,
+    FSUtil.node,
+    Global.node,
+    httpClient,
+    Image.node,
+    Integration.node,
+    KV.node,
+    Location.node,
+    LocationMutation.node,
+    ModelsDev.node,
+    Npm.node,
+    Permission.node,
+    PluginRuntime.node,
+    Form.node,
+    ReadToolFileSystem.node,
+    Reference.node,
+    Ripgrep.node,
+    SessionInstructions.node,
+    Shell.node,
+    Skill.node,
+    Tool.node,
+    Watcher.node,
+    WebSearch.node,
+    WellKnown.node,
+  ],
+})
+
+export { layer }

packages/core/src/pty.ts

@@ -9,7 +9,6 @@ import { Bus } from "./bus"
 import { Location } from "./location"
 import { PtyID } from "./pty/schema"
 import { ShellSelect } from "./shell/select"
-import { Global } from "@opencode-ai/util/global"
 import { lazy } from "./util/lazy"
 
 const BUFFER_LIMIT = 1024 * 1024 * 2
@@ -97,7 +96,6 @@ export const layer = (options?: ShellSelect.Options) =>
       const bus = yield* Bus.Service
       const location = yield* Location.Service
       const config = yield* Config.Service
-      const global = yield* Global.Service
       const context = yield* Effect.context()
       const runFork = Effect.runForkWith(context)
       const sessions = new Map<PtyID, Active>()
@@ -167,8 +165,7 @@ export const layer = (options?: ShellSelect.Options) =>
 
       const create = Effect.fn("Pty.create")(function* (input: CreateInput) {
         const id = PtyID.ascending()
-        const command =
-          input.command || ShellSelect.preferred(Config.latest(yield* config.entries(), "shell"), options, global.bin)
+        const command = input.command || ShellSelect.preferred(Config.latest(yield* config.entries(), "shell"), options)
         const args = ShellSelect.login(command) ? [...(input.args ?? []), "-l"] : [...(input.args ?? [])]
         const cwd = input.cwd || location.directory
         const env = {
@@ -318,11 +315,7 @@ export const layer = (options?: ShellSelect.Options) =>
   )
 
 export function configured(options?: ShellSelect.Options) {
-  return makeLocationNode({
-    service: Service,
-    layer: layer(options),
-    deps: [Bus.node, Location.node, Config.node, Global.node],
-  })
+  return makeLocationNode({ service: Service, layer: layer(options), deps: [Bus.node, Location.node, Config.node] })
 }
 
 export const node = configured()

packages/core/src/ripgrep/binary.ts

@@ -34,8 +34,6 @@ export namespace RipgrepBinary {
       const fs = yield* FSUtil.Service
       const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
       const spawner = yield* ChildProcessSpawner
-      const global = yield* Global.Service
-      const findExecutable = (name: string) => which(name, undefined, global.bin)
 
       const run = Effect.fnUntraced(function* (command: string, args: string[]) {
         const handle = yield* spawner.spawn(ChildProcess.make(command, args, { extendEnv: true, stdin: "ignore" }))
@@ -55,12 +53,10 @@ export namespace RipgrepBinary {
         config: (typeof PLATFORM)[keyof typeof PLATFORM],
         target: string,
       ) {
-        const dir = yield* fs.makeTempDirectoryScoped({ directory: global.bin, prefix: "ripgrep-" })
+        const dir = yield* fs.makeTempDirectoryScoped({ directory: Global.Path.bin, prefix: "ripgrep-" })
 
         if (config.extension === "zip") {
-          const shell =
-            (yield* Effect.sync(() => findExecutable("powershell.exe") ?? findExecutable("pwsh.exe"))) ??
-            "powershell.exe"
+          const shell = (yield* Effect.sync(() => which("powershell.exe") ?? which("pwsh.exe"))) ?? "powershell.exe"
           const result = yield* run(shell, [
             "-NoProfile",
             "-NonInteractive",
@@ -95,10 +91,10 @@ export namespace RipgrepBinary {
       return Service.of({
         filepath: yield* Effect.cached(
           Effect.gen(function* () {
-            const system = yield* Effect.sync(() => findExecutable(process.platform === "win32" ? "rg.exe" : "rg"))
+            const system = yield* Effect.sync(() => which(process.platform === "win32" ? "rg.exe" : "rg"))
             if (system && (yield* fs.isFile(system).pipe(Effect.orDie))) return system
 
-            const target = path.join(global.bin, `rg${process.platform === "win32" ? ".exe" : ""}`)
+            const target = path.join(Global.Path.bin, `rg${process.platform === "win32" ? ".exe" : ""}`)
             if (yield* fs.isFile(target).pipe(Effect.orDie)) return target
 
             const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
@@ -107,10 +103,10 @@ export namespace RipgrepBinary {
 
             const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`
             const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`
-            const archive = path.join(global.bin, filename)
+            const archive = path.join(Global.Path.bin, filename)
 
             yield* Effect.logInfo("downloading ripgrep", { url })
-            yield* fs.ensureDir(global.bin).pipe(Effect.orDie)
+            yield* fs.ensureDir(Global.Path.bin).pipe(Effect.orDie)
             const bytes = yield* HttpClientRequest.get(url).pipe(
               http.execute,
               Effect.flatMap((response) => response.arrayBuffer),
@@ -131,6 +127,6 @@ export namespace RipgrepBinary {
   export const node = makeGlobalNode({
     service: Service,
     layer: layer,
-    deps: [FSUtil.node, Global.node, httpClient, CrossSpawnSpawner.node],
+    deps: [FSUtil.node, httpClient, CrossSpawnSpawner.node],
   })
 }

packages/core/src/session.ts

@@ -233,6 +233,8 @@ export interface Interface {
     sessionID: SessionSchema.ID
     command: string
     arguments?: string
+    agent?: Agent.ID
+    model?: Model.Ref
     files?: PromptInput.Prompt["files"]
     agents?: PromptInput.Prompt["agents"]
     skills?: PromptInput.Prompt["skills"]
@@ -623,13 +625,13 @@ const layer = Layer.effect(
         const evaluated = yield* commands.evaluate({ name: input.command, arguments: input.arguments })
 
         // TODO(v2 commands): decide whether command-level subtask/background execution belongs in v2 commands.
-        const agent = command.agent
+        const agent = command.agent ?? input.agent
         const commandAgent = yield* Effect.gen(function* () {
           if (!command.agent) return undefined
           const agents = yield* Agent.Service.pipe(Effect.provide(locations.get(session.location)))
           return yield* agents.get(Agent.ID.make(command.agent))
         })
-        const model = command.model ?? commandAgent?.model
+        const model = command.model ?? commandAgent?.model ?? input.model
         if (agent !== undefined && session.agent !== Agent.ID.make(agent))
           yield* result.switchAgent({ sessionID: input.sessionID, agent: Agent.ID.make(agent) })
         if (model !== undefined) yield* result.switchModel({ sessionID: input.sessionID, model })

packages/core/src/shell.ts

@@ -143,9 +143,7 @@ export const layer = (options?: ShellSelect.Options) =>
       })
 
       const resolve = () =>
-        config
-          .entries()
-          .pipe(Effect.map((entries) => ShellSelect.preferred(Config.latest(entries, "shell"), options, global.bin)))
+        config.entries().pipe(Effect.map((entries) => ShellSelect.preferred(Config.latest(entries, "shell"), options)))
 
       const name = () => resolve().pipe(Effect.map(ShellSelect.name))
 

packages/core/src/shell/select.ts

@@ -34,19 +34,15 @@ function stat(file: string) {
   return statSync(file, { throwIfNoEntry: false }) ?? undefined
 }
 
-function findExecutable(name: string, bin?: string) {
-  return which(name, undefined, bin)
-}
-
-function full(file: string, options?: Options, bin?: string) {
+function full(file: string, options?: Options) {
   if (process.platform !== "win32") return file
   const shell = FSUtil.windowsPath(file)
   if (path.win32.dirname(shell) !== ".") {
-    if (shell.startsWith("/") && name(shell) === "bash") return gitbash(options, bin) || shell
+    if (shell.startsWith("/") && name(shell) === "bash") return gitbash(options) || shell
     return shell
   }
-  if (name(shell) === "bash") return gitbash(options, bin) || findExecutable(shell, bin) || shell
-  return findExecutable(shell, bin) || shell
+  if (name(shell) === "bash") return gitbash(options) || which(shell) || shell
+  return which(shell) || shell
 }
 
 function meta(file: string) {
@@ -61,26 +57,21 @@ function rooted(file: string) {
   return path.isAbsolute(FSUtil.windowsPath(file))
 }
 
-function resolve(file: string, options?: Options, bin?: string) {
-  const shell = full(file, options, bin)
+function resolve(file: string, options?: Options) {
+  const shell = full(file, options)
   if (rooted(shell)) {
     if (stat(shell)?.isFile()) return shell
     return
   }
-  return findExecutable(shell, bin) ?? undefined
+  return which(shell) ?? undefined
 }
 
-function win(options?: Options, bin?: string) {
+function win(options?: Options) {
   return Array.from(
     new Set(
-      [
-        findExecutable("pwsh", bin),
-        findExecutable("powershell", bin),
-        gitbash(options, bin),
-        process.env.COMSPEC || "cmd.exe",
-      ]
+      [which("pwsh"), which("powershell"), gitbash(options), process.env.COMSPEC || "cmd.exe"]
         .filter((item): item is string => Boolean(item))
-        .map((file) => full(file, options, bin)),
+        .map((file) => full(file, options)),
     ),
   )
 }
@@ -91,27 +82,27 @@ async function unix() {
   return ["/bin/bash", "/bin/zsh", "/bin/sh"]
 }
 
-function select(file: string | undefined, options?: Options, opts?: { acceptable?: boolean }, bin?: string) {
+function select(file: string | undefined, options?: Options, opts?: { acceptable?: boolean }) {
   if (file && (!opts?.acceptable || ok(file))) {
-    const shell = resolve(file, options, bin)
+    const shell = resolve(file, options)
     if (shell) return shell
   }
-  if (process.platform === "win32") return win(options, bin)[0]
-  return fallback(bin)
+  if (process.platform === "win32") return win(options)[0]
+  return fallback()
 }
 
-export function gitbash(options?: Options, bin?: string) {
+export function gitbash(options?: Options) {
   if (process.platform !== "win32") return
   if (options?.gitbash) return options.gitbash
-  const git = findExecutable("git", bin)
+  const git = which("git")
   if (!git) return
   const file = path.join(git, "..", "..", "bin", "bash.exe")
   if (stat(file)?.size) return file
 }
 
-function fallback(bin?: string) {
+function fallback() {
   if (process.platform === "darwin") return "/bin/zsh"
-  const bash = findExecutable("bash", bin)
+  const bash = which("bash")
   if (bash) return bash
   return "/bin/sh"
 }
@@ -129,12 +120,12 @@ export function ps(file: string) {
   return meta(file)?.ps === true
 }
 
-function info(file: string, options?: Options, bin?: string): Item {
-  const item = full(file, options, bin)
+function info(file: string, options?: Options): Item {
+  const item = full(file, options)
   const n = name(item)
   return {
     path: item,
-    name: resolve(n, options, bin) ? n : item,
+    name: resolve(n, options) ? n : item,
     acceptable: ok(item),
   }
 }
@@ -148,36 +139,30 @@ export function args(file: string, command: string) {
   return ["-c", command]
 }
 
-let defaultPreferred: { bin?: string; value: string } | undefined
-let defaultAcceptable: { bin?: string; value: string } | undefined
+let defaultPreferred: string | undefined
+let defaultAcceptable: string | undefined
 
-export function preferred(configShell?: string, options?: Options, bin?: string) {
-  if (configShell) return select(configShell, options, undefined, bin)
-  if (options?.gitbash) return select(process.env.SHELL, options, undefined, bin)
-  const cached = defaultPreferred
-  if (cached && cached.bin === bin) return cached.value
-  const value = select(process.env.SHELL, undefined, undefined, bin) ?? fallback(bin)
-  defaultPreferred = { bin, value }
-  return value
+export function preferred(configShell?: string, options?: Options) {
+  if (configShell) return select(configShell, options)
+  if (options?.gitbash) return select(process.env.SHELL, options)
+  defaultPreferred ??= select(process.env.SHELL)
+  return defaultPreferred
 }
 preferred.reset = () => {
   defaultPreferred = undefined
 }
 
-export function acceptable(configShell?: string, options?: Options, bin?: string) {
-  if (configShell) return select(configShell, options, { acceptable: true }, bin)
-  if (options?.gitbash) return select(process.env.SHELL, options, { acceptable: true }, bin)
-  const cached = defaultAcceptable
-  if (cached && cached.bin === bin) return cached.value
-  const value = select(process.env.SHELL, undefined, { acceptable: true }, bin) ?? fallback(bin)
-  defaultAcceptable = { bin, value }
-  return value
+export function acceptable(configShell?: string, options?: Options) {
+  if (configShell) return select(configShell, options, { acceptable: true })
+  if (options?.gitbash) return select(process.env.SHELL, options, { acceptable: true })
+  defaultAcceptable ??= select(process.env.SHELL, undefined, { acceptable: true })
+  return defaultAcceptable
 }
 acceptable.reset = () => {
   defaultAcceptable = undefined
 }
 
-export async function list(options?: Options, bin?: string): Promise<Item[]> {
-  const shells = process.platform === "win32" ? win(options, bin) : await unix()
-  return shells.filter((shell) => resolve(shell, options, bin)).map((shell) => info(shell, options, bin))
+export async function list(options?: Options): Promise<Item[]> {
+  const shells = process.platform === "win32" ? win(options) : await unix()
+  return shells.filter((shell) => resolve(shell, options)).map((shell) => info(shell, options))
 }

packages/core/src/skill.ts

@@ -2,12 +2,17 @@ export * as Skill from "./skill"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
-import { Context, Effect, Layer, Types } from "effect"
+import { Context, Effect, FiberMap, Layer, PubSub, Schema, Semaphore, Stream, Types } from "effect"
 import { Skill } from "@opencode-ai/schema/skill"
 import { Agent } from "./agent"
+import { ConfigMarkdown } from "./config/markdown"
 import { Bus } from "./bus"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Permission } from "./permission"
+import { AbsolutePath } from "./schema"
+import { SkillDiscovery } from "./skill/discovery"
 import { State } from "./state"
+import { Watcher } from "./filesystem/watcher"
 
 export const DirectorySource = Skill.DirectorySource
 export type DirectorySource = Skill.DirectorySource
@@ -52,18 +57,38 @@ export const toModelOutput = (skill: Info, files: ReadonlyArray<string>) => {
   ].join("\n")
 }
 
+const Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional),
+})
+const decodeFrontmatter = Schema.decodeUnknownOption(Frontmatter)
+
+const metadataBoolean = (metadata: unknown, key: string) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return undefined
+  }
+  const value = (metadata as { readonly [key: string]: unknown })[key]
+  if (typeof value === "boolean") return value
+  if (typeof value !== "string") return undefined
+  const normalized = value.trim().toLowerCase()
+  if (normalized === "true") return true
+  if (normalized === "false") return false
+  return undefined
+}
+
 export type Data = {
-  skills: Map<ID, Types.DeepMutable<Info>>
+  sources: Types.DeepMutable<Source>[]
 }
 
 export type Draft = {
-  list: () => readonly Types.DeepMutable<Info>[]
-  add: (skill: Info) => void
-  update: (id: string, update: (skill: Types.DeepMutable<Info>) => void) => void
-  remove: (id: string) => void
+  source: (source: Source) => void
+  list: () => readonly Source[]
 }
 
 export interface Interface extends State.Transformable<Draft> {
+  readonly sources: () => Effect.Effect<Source[]>
   readonly list: () => Effect.Effect<Info[]>
 }
 
@@ -72,35 +97,179 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Sk
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const discovery = yield* SkillDiscovery.Service
+    const fs = yield* FSUtil.Service
     const bus = yield* Bus.Service
+    const watcher = yield* Watcher.Service
+    const cache = new Map<string, { skills: Info[]; paths: readonly string[] }>()
+    const watches = yield* FiberMap.make<string>()
+    const lock = Semaphore.makeUnsafe(1)
+    const changes = yield* PubSub.unbounded<string>()
+
+    const invalidate = Effect.fn("Skill.invalidateFromWatcher")(function* (file: string) {
+      const changed = yield* lock.withPermit(
+        Effect.gen(function* () {
+          const invalidated = Array.from(cache.entries()).filter(([, loaded]) =>
+            loaded.paths.some((item) => FSUtil.overlaps(item, file)),
+          )
+          if (invalidated.length === 0) return false
+          cache.clear()
+          yield* FiberMap.clear(watches)
+          yield* Effect.logInfo("skill cache invalidated", {
+            file,
+            sources: invalidated.map(([key]) => key),
+            skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
+          })
+          return true
+        }),
+      )
+      if (!changed) return
+      yield* bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
+    })
+
+    yield* Stream.fromPubSub(changes).pipe(Stream.runForEach(invalidate), Effect.forkScoped({ startImmediately: true }))
+
+    const watch = Effect.fn("Skill.watch")(function* (directory: string, type: Watcher.WatchInput["type"]) {
+      const target = path.resolve(directory)
+      const updates = yield* watcher.subscribe(
+        type === "file" ? { path: target, type: "file" } : { path: target, type: "directory" },
+      )
+      yield* FiberMap.run(
+        watches,
+        `${type}:${target}`,
+        updates.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))),
+        {
+          onlyIfMissing: true,
+          startImmediately: true,
+        },
+      )
+    })
+
+    function firstMissing(target: string): Effect.Effect<string | undefined> {
+      const parent = path.dirname(target)
+      if (parent === target) return Effect.succeed(undefined)
+      return fs.isDir(parent).pipe(Effect.flatMap((exists) => (exists ? Effect.succeed(target) : firstMissing(parent))))
+    }
+
+    const watchDirectory: (directory: string) => Effect.Effect<string[]> = Effect.fn("Skill.watchDirectory")(function* (
+      directory: string,
+    ) {
+      const target = path.resolve(directory)
+      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      if (resolved) {
+        yield* watch(resolved, "directory")
+        if (resolved !== target) {
+          yield* watch(target, "file")
+        }
+        return resolved === target ? [target] : [target, resolved]
+      }
+      const missing = yield* firstMissing(target)
+      if (missing) yield* watch(missing, "file")
+      if (
+        yield* fs.realPath(directory).pipe(
+          Effect.as(true),
+          Effect.catch(() => Effect.succeed(false)),
+        )
+      ) {
+        if (missing) yield* FiberMap.remove(watches, `file:${path.resolve(missing)}`)
+        return yield* watchDirectory(directory)
+      }
+      return [target]
+    })
 
     const state = State.create<Data, Draft>({
       name: "skill",
-      initial: () => ({ skills: new Map() }),
+      initial: () => ({ sources: [] }),
       draft: (draft) => ({
-        list: () => Array.from(draft.skills.values()),
-        add: (skill) => {
-          draft.skills.set(skill.id, { ...skill } as Types.DeepMutable<Info>)
-        },
-        update: (id, update) => {
-          const current = draft.skills.get(ID.make(id))
-          if (!current) return
-          update(current)
-          current.id = ID.make(id)
-        },
-        remove: (id) => {
-          draft.skills.delete(ID.make(id))
+        source: (source) => {
+          if (draft.sources.some((item) => Source.equals(item, source))) return
+          draft.sources.push(source as Types.DeepMutable<Source>)
         },
+        list: () => draft.sources as Source[],
       }),
-      finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid),
+      finalize: () =>
+        lock
+          .withPermit(FiberMap.clear(watches).pipe(Effect.andThen(Effect.sync(() => cache.clear())), Effect.asVoid))
+          .pipe(Effect.andThen(bus.publish(Skill.Event.Updated, {})), Effect.asVoid),
+    })
+
+    const load = Effect.fn("Skill.load")(function* (source: Source) {
+      const skills: Info[] = []
+      if (source.type === "embedded") {
+        yield* Effect.logDebug("skill source loaded", {
+          source: Source.key(source),
+          type: source.type,
+          directories: [],
+          skills: [source.skill.id],
+        })
+        return { skills: [source.skill], paths: [] }
+      }
+      const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url)
+      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat()
+      const paths = [...roots]
+      for (const directory of directories) {
+        const files = yield* fs
+          .scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
+          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+        for (const filepath of files.toSorted()) {
+          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)))
+          if (!roots.some((root) => FSUtil.contains(root, resolved))) {
+            const external = path.dirname(resolved)
+            paths.push(external)
+            yield* watch(external, "directory")
+          }
+          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
+          if (!content) continue
+          const markdown = ConfigMarkdown.parseOption(content)
+          if (!markdown) continue
+          const frontmatter = decodeFrontmatter(markdown.data).valueOrUndefined
+          if (!frontmatter) continue
+          const id =
+            path.dirname(filepath) === directory
+              ? path.basename(filepath, ".md")
+              : path.basename(path.dirname(filepath))
+          skills.push({
+            id: ID.make(id),
+            name: Name.make(frontmatter.name ?? id),
+            description: frontmatter.description,
+            slash: metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash,
+            autoinvoke: metadataBoolean(frontmatter.metadata, "opencode/autoinvoke"),
+            location: AbsolutePath.make(filepath),
+            content: markdown.content,
+          })
+        }
+      }
+      yield* Effect.logDebug("skill source loaded", {
+        source: Source.key(source),
+        type: source.type,
+        directories,
+        skills: skills.map((skill) => skill.id),
+      })
+      return { skills, paths }
+    })
+
+    const list = Effect.fn("Skill.list")(function* () {
+      return yield* lock.withPermit(
+        Effect.gen(function* () {
+          const skills = new Map<ID, Info>()
+          for (const source of state.get().sources) {
+            const key = Source.key(source)
+            const loaded = cache.get(key) ?? (yield* load(source))
+            cache.set(key, loaded)
+            for (const skill of loaded.skills) skills.set(skill.id, skill)
+          }
+          return Array.from(skills.values())
+        }),
+      )
     })
 
     return Service.of({
       transform: state.transform,
       reload: state.reload,
-      list: Effect.fn("Skill.list")(function* () {
-        return Array.from(state.get().skills.values())
+      sources: Effect.fn("Skill.sources")(function* () {
+        return state.get().sources
       }),
+      list,
     })
   }),
 )
@@ -108,5 +277,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node],
+  deps: [SkillDiscovery.node, FSUtil.node, Bus.node, Watcher.node],
 })

packages/core/src/util/which.ts

@@ -1,9 +1,10 @@
 import whichPkg from "which"
 import path from "path"
+import { Global } from "@opencode-ai/util/global"
 
-export function which(cmd: string, env?: NodeJS.ProcessEnv, bin?: string) {
+export function which(cmd: string, env?: NodeJS.ProcessEnv) {
   const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? ""
-  const full = base && bin ? base + path.delimiter + bin : base || bin
+  const full = base ? base + path.delimiter + Global.Path.bin : Global.Path.bin
   const result = whichPkg.sync(cmd, {
     nothrow: true,
     path: full,

packages/core/src/vcs.ts

@@ -3,7 +3,6 @@ export * as Vcs from "./vcs"
 import path from "path"
 import { Context, Effect, Layer, Stream } from "effect"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
 import { VcsEvent } from "@opencode-ai/schema/vcs-event"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -11,6 +10,8 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "./location"
 import { AppProcess } from "@opencode-ai/util/process"
 import { Bus } from "./bus"
+import { Git } from "./git"
+import { Watcher } from "./filesystem/watcher"
 import { VcsGit } from "./vcs/git"
 import { VcsHg } from "./vcs/hg"
 
@@ -44,29 +45,36 @@ const layer = Layer.effect(
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const bus = yield* Bus.Service
+    const git = yield* Git.Service
+    const watcher = yield* Watcher.Service
     const impl = adapter(proc, fs, location)
     const vcs = location.vcs
     const state = { info: impl ? yield* impl.info() : ({ branch: {} } satisfies Info) }
 
     if (vcs && impl) {
-      const store = yield* fs.realPath(vcs.store).pipe(Effect.catch(() => Effect.succeed(vcs.store)))
-      const isBranchMetadata =
-        vcs.type === "git"
-          ? (file: string) => path.basename(file) === "HEAD" && FSUtil.contains(store, file)
-          : (file: string) => path.resolve(file) === path.join(store, "branch")
-      yield* bus.subscribe(FileSystem.Event.Changed).pipe(
-        Stream.filter((event) => isBranchMetadata(event.data.file)),
-        Stream.runForEach((event) =>
-          Effect.gen(function* () {
-            const next = yield* impl.info()
-            const changed = state.info.branch.current !== next.branch.current
-            state.info = next
-            if (!changed) return
-            yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current })
-          }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } })),
-        ),
-        Effect.forkScoped({ startImmediately: true }),
-      )
+      yield* Effect.gen(function* () {
+        const discovered = vcs.type === "git" ? (yield* git.repo.discover(location.directory))?.gitDirectory : undefined
+        const target = discovered ?? vcs.store
+        const dir = yield* fs.realPath(target).pipe(Effect.catch(() => Effect.succeed(target)))
+        const keep = vcs.type === "git" ? ["HEAD", "HEAD.lock"] : ["branch"]
+        const ignore = (yield* fs.readDirectoryEntries(dir).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
+          (entry) => (keep.includes(entry.name) ? [] : [entry.name]),
+        )
+        const updates = yield* watcher.subscribe({ path: dir, type: "directory", ignore })
+        yield* updates.pipe(
+          Stream.filter((update) => keep.includes(path.basename(update.path))),
+          Stream.runForEach((update) =>
+            Effect.gen(function* () {
+              const next = yield* impl.info()
+              const changed = state.info.branch.current !== next.branch.current
+              state.info = next
+              if (!changed) return
+              yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current })
+            }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: update.path } })),
+          ),
+          Effect.forkScoped({ startImmediately: true }),
+        )
+      }).pipe(Effect.catchCause((cause) => Effect.logError("failed to watch vcs metadata", { cause })))
     }
 
     return Service.of({
@@ -88,5 +96,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer: layer,
-  deps: [AppProcess.node, FSUtil.node, Location.node, Bus.node],
+  deps: [AppProcess.node, FSUtil.node, Location.node, Bus.node, Git.node, Watcher.node],
 })

packages/core/test/config/fixture/skills/first-source/first/SKILL.md

@@ -1,6 +0,0 @@
----
-name: first
-description: First skill
----
-
-# first

packages/core/test/config/fixture/skills/second-source/second/SKILL.md

@@ -1,6 +0,0 @@
----
-name: second
-description: Second skill
----
-
-# second

packages/core/test/config/plugin.test.ts

@@ -5,10 +5,8 @@ import { describe, expect } from "bun:test"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { ConfigPluginSource } from "@opencode-ai/core/config/plugin/source"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Global } from "@opencode-ai/util/global"
 import { Bus } from "@opencode-ai/core/bus"
 import { Location } from "@opencode-ai/core/location"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
@@ -21,19 +19,10 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Effect, Fiber, Logger, Stream } from "effect"
 import { Database } from "../../src/database/database"
 import { tmpdir } from "../fixture/tmpdir"
-import { tempGlobalLayer } from "../fixture/global"
 import { testEffect } from "../lib/effect"
 
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
-    [Global.node, tempGlobalLayer],
-  ]),
-)
-const staticIt = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
-    [ConfigPluginSource.node, ConfigPluginSource.empty],
-    [Global.node, tempGlobalLayer],
-  ]),
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node])),
 )
 
 describe("PluginSupervisor config", () => {
@@ -168,29 +157,6 @@ describe("PluginSupervisor config", () => {
     ),
   )
 
-  staticIt.live("uses only internal and SDK plugins when the static source is wired", () =>
-    Effect.gen(function* () {
-      const sdk = yield* SdkPlugins.Service
-      yield* sdk.register(EffectPlugin.define({ id: "static-sdk", effect: () => Effect.void }))
-      yield* withLocation(
-        { plugins: ["-*", path.join(import.meta.dir, "../plugin/fixtures/config-promise-plugin.ts")] },
-        Effect.gen(function* () {
-          yield* ready()
-          const plugins = yield* Plugin.Service
-          const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
-          expect(ids).toContain("opencode.agent")
-          expect(ids).toContain("static-sdk")
-          expect(ids).not.toContain("config-promise-plugin")
-
-          const agents = yield* Agent.Service
-          expect(yield* agents.get(Agent.ID.make("directory"))).toBeUndefined()
-          expect(yield* agents.get(Agent.ID.make("configured"))).toBeUndefined()
-        }),
-        true,
-      )
-    }),
-  )
-
   it.live("reloads an auto-discovered plugin when its file changes", () =>
     withLocation(
       undefined,

packages/core/test/config/reload.test.ts

@@ -46,7 +46,9 @@ describe("config plugin reloads", () => {
 
       expect((yield* agents.get(Agent.ID.make("first")))?.description).toBe("First agent")
       expect((yield* commands.get("first"))?.description).toBe("First command")
-      expect((yield* skills.list()).some((skill) => skill.id === "first")).toBe(true)
+      expect(
+        (yield* skills.sources()).some((source) => source.type === "directory" && source.path === "/skills/first"),
+      ).toBe(true)
       expect((yield* references.list()).map((reference) => reference.name)).toEqual(["first"])
       expect(yield* catalog.provider.get(Provider.ID.make("first"))).toBeDefined()
 
@@ -67,8 +69,12 @@ describe("config plugin reloads", () => {
         }),
       )
 
-      expect((yield* skills.list()).some((skill) => skill.id === "first")).toBe(false)
-      expect((yield* skills.list()).some((skill) => skill.id === "second")).toBe(true)
+      expect(
+        (yield* skills.sources()).some((source) => source.type === "directory" && source.path === "/skills/first"),
+      ).toBe(false)
+      expect(
+        (yield* skills.sources()).some((source) => source.type === "directory" && source.path === "/skills/second"),
+      ).toBe(true)
     }).pipe(
       Effect.provide(Config.testLayer([config("first")])),
       Effect.provideService(Global.Service, Global.Service.of(Global.make())),
@@ -83,7 +89,7 @@ function config(name: string) {
     info: decode({
       agents: { [name]: { description: `${title(name)} agent`, mode: "subagent" } },
       commands: { [name]: { template: `${title(name)} command`, description: `${title(name)} command` } },
-      skills: [path.join(import.meta.dir, "fixture", "skills", `${name}-source`)],
+      skills: [`/skills/${name}`],
       references: { [name]: `/references/${name}` },
       providers: { [name]: { models: { chat: { name: `${title(name)} model` } } } },
     }),

packages/core/test/config/skill.test.ts

@@ -1,379 +1,87 @@
-import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Layer, Schema, Stream } from "effect"
+import { Effect, Layer, Schema, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import {
-  AgentsDirectory,
-  ClaudeDirectory,
-  Directory as ConfigDirectory,
-  Document,
-  type Entry,
-  Info,
-} from "@opencode-ai/schema/config"
+import { AgentsDirectory, ClaudeDirectory, Directory, Document, Info } from "@opencode-ai/schema/config"
 import { ConfigSkillPlugin } from "@opencode-ai/core/config/plugin/skill"
-import { SkillFile } from "@opencode-ai/core/config/plugin/skill-file"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
-import { Bus } from "@opencode-ai/core/bus"
-import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
-import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
-import { tmpdir } from "../fixture/tmpdir"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { host } from "../plugin/host"
 
-const urls = new Map<string, AbsolutePath[]>()
-const failedUrls = new Set<string>()
-let pulls = 0
-const discoveryLayer = Layer.succeed(
-  SkillDiscovery.Service,
-  SkillDiscovery.Service.of({
-    pull: (url) => {
-      pulls++
-      if (failedUrls.has(url)) return Effect.die(`failed to pull ${url}`)
-      return Effect.succeed(urls.get(url) ?? [])
-    },
-  }),
-)
-const watcherLayer = Watcher.testLayer
-const it = testEffect(
-  Layer.mergeAll(
-    AppNodeBuilder.build(LayerNode.group([Skill.node, Bus.node, FSUtil.node])),
-    discoveryLayer,
-    watcherLayer,
-  ),
-)
+const it = testEffect(Layer.empty)
 const decode = Schema.decodeUnknownSync(Info)
 
-function write(directory: string, name: string, description: string) {
-  return fs.writeFile(
-    path.join(directory, name, "SKILL.md"),
-    `---
-name: ${name}
-description: ${description}
----
-# ${name}`,
-  )
-}
-
-const startEntries = Effect.fnUntraced(function* (entries: Entry[], directory: string, home = directory) {
-  const service = yield* Skill.Service
-  yield* ConfigSkillPlugin.Plugin.effect(
-    host({
-      skill: {
-        list: () => Effect.die("unused skill.list"),
-        transform: service.transform,
-        reload: service.reload,
-      },
-    }),
-  ).pipe(
-    Effect.provide(Config.testLayer(entries)),
-    Effect.provideService(Global.Service, Global.Service.of({ ...Global.make(), home })),
-    Effect.provideService(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
-  )
-  return service
-})
-
-const start = (skills: string[], directory: string) =>
-  startEntries(
-    [
-      new Document({
-        type: "document",
-        info: decode({ skills }),
-      }),
-    ],
-    directory,
-  )
-
-function emitAndWait(update: Watcher.Update) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    const bus = yield* Bus.Service
-    const deferred = yield* Deferred.make<void>()
-    const fiber = yield* bus.subscribe(Skill.Event.Updated).pipe(
-      Stream.runForEach(() => Deferred.succeed(deferred, undefined).pipe(Effect.asVoid)),
-      Effect.forkScoped,
-    )
-    yield* Effect.yieldNow
-    yield* watcher.emit(update)
-    yield* Deferred.await(deferred).pipe(Effect.timeout("2 seconds"))
-    yield* Fiber.interrupt(fiber)
-  })
-}
-
-describe("SkillFile.parse", () => {
-  it.effect("parses root and nested skill ids and metadata flags", () =>
-    Effect.sync(() => {
-      const directory = "/repo/skills"
-      expect(
-        SkillFile.parse(
-          directory,
-          "/repo/skills/manual/SKILL.md",
-          `---
-name: Manual
-description: Manual only
-metadata:
-  opencode/slash: "true"
-  opencode/autoinvoke: false
----
-# manual`,
-        ),
-      ).toEqual({
-        _tag: "Parsed",
-        skill: {
-          id: Skill.ID.make("manual"),
-          name: Skill.Name.make("Manual"),
-          description: "Manual only",
-          slash: true,
-          autoinvoke: false,
-          location: AbsolutePath.make("/repo/skills/manual/SKILL.md"),
-          content: "# manual",
-        },
-      })
-      expect(SkillFile.parse(directory, "/repo/skills/foo.md", "---\nslash: true\n---\n# foo")).toMatchObject({
-        _tag: "Parsed",
-        skill: { id: Skill.ID.make("foo") },
-      })
-      expect(
-        SkillFile.parse(directory, "/repo/skills/broken.md", "---\ndescription: foo: bar\nmetadata: [\n---\n# broken"),
-      ).toEqual({ _tag: "Skipped", reason: "markdown" })
-      expect(SkillFile.parse(directory, "/repo/skills/broken.md", "---\nslash: nope\n---\n# broken")).toMatchObject({
-        _tag: "Skipped",
-        reason: "frontmatter",
-        issue: expect.anything(),
-      })
-    }),
-  )
-})
-
 describe("ConfigSkillPlugin.Plugin", () => {
-  it.live("maps config entry types to skill directories", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const claude = path.join(tmp.path, "claude")
-          const agents = path.join(tmp.path, "agents")
-          const opencode = path.join(tmp.path, "opencode")
-          const home = path.join(tmp.path, "home")
-          const directory = path.join(tmp.path, "project")
-          const expected = [
-            path.join(claude, "skills"),
-            path.join(agents, "skills"),
-            path.join(opencode, "skill"),
-            path.join(opencode, "skills"),
-            path.join(home, "shared"),
-            path.join(directory, "relative"),
-          ]
-          yield* Effect.promise(() => Promise.all(expected.map((item) => fs.mkdir(item, { recursive: true }))))
+  it.effect("registers configured skill directories and URLs", () =>
+    Effect.gen(function* () {
+      const directory = AbsolutePath.make("/repo/packages/app")
+      const sources: Skill.Source[] = []
+      const transform = Effect.fnUntraced(function* (update: (draft: Skill.Draft) => void | Effect.Effect<void>) {
+        const result = update({
+          source: (source) => {
+            sources.push(source)
+          },
+          list: () => sources,
+        })
+        if (Effect.isEffect(result)) yield* result
+        const dispose = Effect.sync(() => {
+          sources.length = 0
+        })
+        yield* Effect.addFinalizer(() => dispose)
+        return { dispose }
+      })
 
-          yield* startEntries(
-            [
-              new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(claude) }),
-              new AgentsDirectory({ type: "agents", path: AbsolutePath.make(agents) }),
-              new ConfigDirectory({ type: "directory", path: AbsolutePath.make(opencode) }),
-              new Document({ type: "document", info: decode({ skills: ["~/shared", "./relative"] }) }),
-            ],
-            directory,
-            home,
-          )
-          const watcher = yield* Watcher.Test
-          expect(yield* watcher.subscriptions()).toEqual(expected.map((item) => ({ path: item, type: "directory" })))
+      yield* ConfigSkillPlugin.Plugin.effect(
+        host({
+          skill: { list: () => Effect.die("unused skill.list"), transform, reload: () => Effect.void },
         }),
-      ),
-    ),
-  )
+      ).pipe(
+        Effect.provideService(Global.Service, Global.Service.of({ ...Global.make(), home: "/home/test" })),
+        Effect.provideService(Location.Service, Location.Service.of(location({ directory }))),
+        Effect.provide(
+          Config.testLayer([
+            new ClaudeDirectory({ type: "claude", path: AbsolutePath.make("/repo/.claude") }),
+            new AgentsDirectory({ type: "agents", path: AbsolutePath.make("/repo/.agents") }),
+            new Directory({ type: "directory", path: AbsolutePath.make("/repo/.opencode") }),
+            new Document({
+              type: "document",
+              info: decode({
+                skills: ["./skills", "~/shared-skills", "/opt/skills", "https://example.test/skills/"],
+              }),
+            }),
+          ]),
+        ),
+      )
 
-  it.live("loads directory and URL sources with later-source precedence", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const first = path.join(tmp.path, "first")
-          const second = path.join(tmp.path, "second")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(first, "review"), { recursive: true })
-            await fs.mkdir(path.join(second, "review"), { recursive: true })
-            await write(first, "review", "First")
-            await write(second, "review", "Second")
-          })
-          pulls = 0
-          urls.set("https://example.test/skills/", [AbsolutePath.make(second)])
-
-          const skill = yield* start([first, "https://example.test/skills/"], tmp.path)
-          expect((yield* skill.list()).find((item) => item.id === "review")?.description).toBe("Second")
-          expect(pulls).toBe(1)
+      expect(sources).toEqual([
+        Skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.join("/repo/.claude", "skills")),
         }),
-      ),
-    ),
-  )
-
-  it.live("keeps directory skills when a URL source fails", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "review"), { recursive: true })
-            await write(tmp.path, "review", "Available")
-          })
-          const url = "https://unreachable.example.test/skills/"
-          failedUrls.add(url)
-
-          const skill = yield* start([tmp.path, url], tmp.path)
-          expect((yield* skill.list()).find((item) => item.id === "review")?.description).toBe("Available")
-          failedUrls.delete(url)
+        Skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.join("/repo/.agents", "skills")),
         }),
-      ),
-    ),
-  )
-
-  it.live("rescans directory sources when watched files change", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
-            await write(tmp.path, "deploy", "Initial")
-          })
-          const skill = yield* start([tmp.path], tmp.path)
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Initial")
-
-          const deploy = path.join(tmp.path, "deploy", "SKILL.md")
-          yield* Effect.promise(() => write(tmp.path, "deploy", "Updated"))
-          yield* emitAndWait({ type: "update", path: deploy })
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated")
-
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "review"), { recursive: true })
-            await write(tmp.path, "review", "Review")
-          })
-          yield* emitAndWait({ type: "create", path: path.join(tmp.path, "review", "SKILL.md") })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([
-            Skill.ID.make("deploy"),
-            Skill.ID.make("review"),
-          ])
-
-          yield* Effect.promise(() => fs.rm(path.join(tmp.path, "review"), { recursive: true }))
-          yield* emitAndWait({ type: "delete", path: path.join(tmp.path, "review", "SKILL.md") })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
+        Skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.join("/repo/.opencode", "skill")),
         }),
-      ),
-    ),
-  )
-
-  it.live("watches canonical directories behind symlinked skills", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const target = path.join(tmp.path, "target", "bro")
-          const file = path.join(target, "SKILL.md")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(source, { recursive: true })
-            await fs.mkdir(target, { recursive: true })
-            await fs.writeFile(file, "---\nname: bro\ndescription: Initial\n---\n# bro")
-            await fs.symlink(target, path.join(source, "bro"), process.platform === "win32" ? "junction" : undefined)
-          })
-
-          const skill = yield* start([source], tmp.path)
-          const watcher = yield* Watcher.Test
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Initial")
-          expect(yield* watcher.subscriptions()).toContainEqual({ path: target, type: "directory" })
-
-          yield* Effect.promise(() => fs.writeFile(file, "---\nname: bro\ndescription: Updated\n---\n# bro"))
-          yield* emitAndWait({ type: "update", path: file })
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Updated")
+        Skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.join("/repo/.opencode", "skills")),
         }),
-      ),
-    ),
-  )
-
-  it.live("reloads symlinked sources when their target changes", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const first = path.join(tmp.path, "first")
-          const second = path.join(tmp.path, "second")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(first, "bro"), { recursive: true })
-            await fs.mkdir(path.join(second, "bro"), { recursive: true })
-            await write(first, "bro", "First")
-            await write(second, "bro", "Second")
-            await fs.symlink(first, source, process.platform === "win32" ? "junction" : undefined)
-          })
-
-          const skill = yield* start([source], tmp.path)
-          const watcher = yield* Watcher.Test
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("First")
-          expect(yield* watcher.subscriptions()).toEqual([
-            { path: first, type: "directory" },
-            { path: source, type: "file" },
-          ])
-
-          yield* Effect.promise(async () => {
-            await fs.unlink(source)
-            await fs.symlink(second, source, process.platform === "win32" ? "junction" : undefined)
-          })
-          yield* emitAndWait({ type: "update", path: source })
-
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Second")
-          expect(yield* watcher.subscriptions()).toEqual([
-            { path: first, type: "directory" },
-            { path: source, type: "file" },
-            { path: second, type: "directory" },
-            { path: source, type: "file" },
-          ])
+        Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
+        Skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.join("/home/test", "shared-skills")),
         }),
-      ),
-    ),
-  )
-
-  it.live("follows missing source directories as their parents appear", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "generated", "skills")
-          const skill = yield* start([source], tmp.path)
-          const watcher = yield* Watcher.Test
-          expect(yield* skill.list()).toEqual([])
-          expect(yield* watcher.subscriptions()).toEqual([{ path: path.join(tmp.path, "generated"), type: "file" }])
-
-          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "generated")))
-          yield* emitAndWait({ type: "create", path: path.join(tmp.path, "generated") })
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(source, "deploy"), { recursive: true })
-            await write(source, "deploy", "Deploy")
-          })
-          yield* emitAndWait({ type: "create", path: source })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-        }),
-      ),
-    ),
+        Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make("/opt/skills") }),
+        Skill.UrlSource.make({ type: "url", url: "https://example.test/skills/" }),
+      ])
+    }),
   )
 })

packages/core/test/database-migration.test.ts

@@ -11,19 +11,11 @@ import { migrations } from "@opencode-ai/core/database/migration.gen"
 import { Database } from "@opencode-ai/core/database/database"
 import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
-import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
-import { Global } from "@opencode-ai/util/global"
+import { importLegacyCredentials } from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
 
-const run = <A, E>(
-  effect: Effect.Effect<A, E, SqlClient | Global.Service>,
-  global = Global.make({ data: path.join(process.cwd(), ".test-data") }),
-) =>
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClient>) =>
   Effect.runPromise(
-    effect.pipe(
-      Effect.provideService(Global.Service, global),
-      Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })),
-      Effect.scoped,
-    ),
+    effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })), Effect.scoped),
   )
 
 const makeDb = EffectDrizzleSqlite.makeWithDefaults()
@@ -39,7 +31,7 @@ describe("DatabaseMigration", () => {
           Effect.scoped(Layer.build(layer)),
         ),
         { concurrency: "unbounded" },
-      ).pipe(Effect.provideService(Global.Service, Global.make({ data: tmp.path }))),
+      ),
     )
   })
 
@@ -135,8 +127,7 @@ describe("DatabaseMigration", () => {
           VALUES ('existing', 'anthropic', 'Existing', ${JSON.stringify({ type: "key", key: "current-key" })}, ${now}, ${now})
         `)
 
-        yield* db.run(sql`DELETE FROM migration WHERE id = ${legacyCredentialsMigration.id}`)
-        yield* DatabaseMigration.applyOnly(db, [legacyCredentialsMigration])
+        yield* db.transaction((tx) => importLegacyCredentials(tx, source))
 
         expect(yield* db.all(sql`SELECT integration_id, label, value FROM credential ORDER BY integration_id`)).toEqual(
           [
@@ -168,28 +159,11 @@ describe("DatabaseMigration", () => {
           value: JSON.stringify(["https://example.com"]),
         })
       }),
-      Global.make({ data: tmp.path }),
     )
 
     expect(await Bun.file(source).text()).toBe(content)
   })
 
-  test("skips legacy credential import when the source file is absent", async () => {
-    await using tmp = await tmpdir()
-
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* DatabaseMigration.apply(db)
-        yield* db.run(sql`DELETE FROM migration WHERE id = ${legacyCredentialsMigration.id}`)
-        yield* DatabaseMigration.applyOnly(db, [legacyCredentialsMigration])
-
-        expect(yield* db.all(sql`SELECT id FROM credential`)).toEqual([])
-      }),
-      Global.make({ data: tmp.path }),
-    )
-  })
-
   test("rolls back a failed migration without recording it", async () => {
     await run(
       Effect.gen(function* () {

packages/core/test/filesystem/watcher.test.ts

@@ -1,28 +1,15 @@
-import { $ } from "bun"
 import { describe, expect } from "bun:test"
-import fs from "fs/promises"
 import path from "path"
-import { Deferred, Duration, Effect, Fiber, Layer, Option, Schedule, Stream } from "effect"
-import { Config } from "@opencode-ai/core/config"
+import { Deferred, Effect, Fiber, Layer, Schedule, Stream } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Bus } from "@opencode-ai/core/bus"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { LocationWatcher } from "@opencode-ai/core/filesystem/location-watcher"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Location } from "@opencode-ai/core/location"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 
-type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 const describeNative = process.env.CI ? describe.skip : describe
 
-const it = testEffect(AppNodeBuilder.build(LayerNode.group([FSUtil.node, Bus.node])))
-
-const configLayer = Config.testLayer()
+const it = testEffect(AppNodeBuilder.build(FSUtil.node))
 
 describe("Watcher.testLayer", () => {
   it.effect("records subscriptions and broadcasts emitted updates through the service", () =>
@@ -40,7 +27,6 @@ describe("Watcher.testLayer", () => {
       yield* test.emit({ type: "update", path: "/root/file.md" })
 
       expect(Array.from(yield* Fiber.join(received))).toEqual([{ type: "update", path: "/root/file.md" }])
-      // subscriptions() reports acquired watches, so paths come back resolved.
       expect(yield* test.subscriptions()).toEqual([{ path: path.resolve("/root"), type: "directory" }])
     }).pipe(Effect.provide(Watcher.testLayer)),
   )
@@ -126,167 +112,20 @@ describe("Watcher lifecycle", () => {
         expect(counts.unsubscribes).toBe(0)
         return consumer
       }).pipe(withNative(native))
-      // Closing the layer scope tears the native subscription down while the
-      // consumer still holds a reference; the consumer's own release as its
-      // stream ends must not tear it down a second time.
       yield* Fiber.join(consumer)
       expect(counts.unsubscribes).toBe(1)
     })
   })
 })
 
-function provide(directory: string, vcs?: Location.Interface["vcs"], watcher?: Layer.Layer<Watcher.Service>) {
-  const locationLayer = Layer.succeed(
-    Location.Service,
-    Location.Service.of(location({ directory: AbsolutePath.make(directory) }, { vcs })),
-  )
-  const built = AppNodeBuilder.build(LocationWatcher.node, [
-    [Config.node, configLayer],
-    [Location.node, locationLayer],
-    ...(watcher ? ([[Watcher.node, watcher]] as const) : []),
-  ])
-  return Effect.provide(built)
-}
-
-function withTmp<A, E, R>(
-  f: (directory: string, vcs?: Location.Interface["vcs"]) => Effect.Effect<A, E, R>,
-  options?: {
-    vcs?: "git" | "hg"
-    init?: (directory: string) => Promise<void>
-    watcher?: Layer.Layer<Watcher.Service>
-  },
-) {
+function withTmp<A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) {
   return Effect.acquireRelease(
-    Effect.promise(async () => {
-      const tmp = await tmpdir()
-      if (options?.vcs === "hg") {
-        await fs.mkdir(path.join(tmp.path, ".hg"))
-        return { tmp, vcs: { type: "hg" as const, store: AbsolutePath.make(path.join(tmp.path, ".hg")) } }
-      }
-      if (options?.vcs !== "git") return { tmp, vcs: undefined }
-      await $`git init`.cwd(tmp.path).quiet()
-      await $`git config core.fsmonitor false`.cwd(tmp.path).quiet()
-      await $`git config commit.gpgsign false`.cwd(tmp.path).quiet()
-      await $`git config user.email test@opencode.test`.cwd(tmp.path).quiet()
-      await $`git config user.name Test`.cwd(tmp.path).quiet()
-      await $`git commit --allow-empty -m root`.cwd(tmp.path).quiet()
-      await options.init?.(tmp.path)
-      return { tmp, vcs: { type: "git" as const, store: AbsolutePath.make(path.join(tmp.path, ".git")) } }
-    }),
-    ({ tmp }) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(Effect.flatMap(({ tmp, vcs }) => f(tmp.path, vcs).pipe(provide(tmp.path, vcs, options?.watcher))))
+    Effect.promise(() => tmpdir()),
+    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+  ).pipe(Effect.flatMap((tmp) => f(tmp.path)))
 }
 
-describe("LocationWatcher subscriptions", () => {
-  it.live("watches only exact Git branch metadata", () => {
-    const subscriptions: Watcher.WatchInput[] = []
-    const watcher = Layer.succeed(
-      Watcher.Service,
-      Watcher.Service.of({
-        subscribe: (input) => Effect.sync(() => subscriptions.push(input)).pipe(Effect.as(Stream.empty)),
-      }),
-    )
-    return withTmp(
-      (directory) =>
-        Effect.gen(function* () {
-          yield* LocationWatcher.Service
-          yield* Effect.sync(() => subscriptions.length).pipe(
-            Effect.filterOrFail((count) => count > 0),
-            Effect.retry(Schedule.spaced("10 millis")),
-          )
-          yield* Effect.sleep("10 millis")
-          expect(subscriptions).toEqual([{ path: path.join(directory, ".git", "HEAD"), type: "file" }])
-        }),
-      { vcs: "git", watcher },
-    )
-  })
-
-  it.live("watches only exact Hg branch metadata", () => {
-    const subscriptions: Watcher.WatchInput[] = []
-    const watcher = Layer.succeed(
-      Watcher.Service,
-      Watcher.Service.of({
-        subscribe: (input) => Effect.sync(() => subscriptions.push(input)).pipe(Effect.as(Stream.empty)),
-      }),
-    )
-    return withTmp(
-      (directory) =>
-        Effect.gen(function* () {
-          yield* LocationWatcher.Service
-          yield* Effect.sync(() => subscriptions.length).pipe(
-            Effect.filterOrFail((count) => count > 0),
-            Effect.retry(Schedule.spaced("10 millis")),
-          )
-          yield* Effect.sleep("10 millis")
-          expect(subscriptions).toEqual([{ path: path.join(directory, ".hg", "branch"), type: "file" }])
-        }),
-      { vcs: "hg", watcher },
-    )
-  })
-})
-
-function wait(check: (event: WatcherEvent) => boolean) {
-  return Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const deferred = yield* Deferred.make<WatcherEvent>()
-    const fiber = yield* bus.subscribe(FileSystem.Event.Changed).pipe(
-      Stream.runForEach((event) => {
-        if (!check(event.data)) return Effect.void
-        return Deferred.succeed(deferred, event.data).pipe(Effect.asVoid)
-      }),
-      Effect.forkScoped,
-    )
-    yield* Effect.yieldNow
-    return { deferred, fiber }
-  })
-}
-
-function maybeNextUpdate<E>(
-  check: (event: WatcherEvent) => boolean,
-  trigger: Effect.Effect<void, E>,
-  timeout: Duration.Input = "5 seconds",
-) {
-  return Effect.acquireUseRelease(
-    wait(check),
-    ({ deferred }) => trigger.pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeoutOption(timeout)),
-    ({ fiber }) => Fiber.interrupt(fiber),
-  )
-}
-
-function nextUpdate<E>(check: (event: WatcherEvent) => boolean, trigger: Effect.Effect<void, E>) {
-  return Effect.gen(function* () {
-    const result = yield* maybeNextUpdate(check, trigger)
-    if (Option.isSome(result)) return result.value
-    return yield* Effect.fail(new Error("timed out waiting for file watcher update"))
-  })
-}
-
-function eventuallyUpdate<E>(check: (event: WatcherEvent) => boolean, trigger: () => Effect.Effect<void, E>) {
-  return Effect.gen(function* () {
-    while (true) {
-      const result = yield* maybeNextUpdate(check, trigger(), "250 millis")
-      if (Option.isSome(result)) return result.value
-    }
-  }).pipe(
-    Effect.timeoutOrElse({
-      duration: "5 seconds",
-      orElse: () => Effect.fail(new Error("timed out waiting for file watcher readiness")),
-    }),
-  )
-}
-
-function ready(file: string, eventFile = file) {
-  return Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const content = (yield* fs.readFileStringSafe(file)) ?? `ready-${Math.random()}`
-    yield* eventuallyUpdate(
-      (event) => event.file === eventFile,
-      () => fs.writeFileString(file, content),
-    ).pipe(Effect.asVoid)
-  })
-}
-
-describeNative("LocationWatcher", () => {
+describeNative("Watcher", () => {
   it.live("limits file watches to the exact target", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
@@ -333,68 +172,4 @@ describeNative("LocationWatcher", () => {
       }).pipe(Effect.provide(AppNodeBuilder.build(Watcher.node))),
     ),
   )
-
-  it.live("publishes .git/HEAD events", () =>
-    withTmp(
-      (directory) =>
-        Effect.gen(function* () {
-          const fs = yield* FSUtil.Service
-          const head = path.join(directory, ".git", "HEAD")
-          const branch = `watch-${Math.random().toString(36).slice(2)}`
-          yield* ready(head)
-          yield* Effect.promise(() => $`git branch ${branch}`.cwd(directory).quiet())
-          expect(
-            yield* nextUpdate((event) => event.file === head, fs.writeFileString(head, `ref: refs/heads/${branch}\n`)),
-          ).toEqual({ file: head, event: "change" })
-        }),
-      { vcs: "git" },
-    ),
-  )
-
-  const describeSymlink = process.platform !== "win32" ? describe : describe.skip
-  describeSymlink("symlinked .git", () => {
-    it.live("publishes .git/HEAD events through a symlinked .git directory", () =>
-      withTmp(
-        (directory) =>
-          Effect.gen(function* () {
-            const afs = yield* FSUtil.Service
-            const actual = path.join(directory, "..", `actual_${path.basename(directory)}`)
-            yield* Effect.addFinalizer(() => Effect.promise(() => fs.rm(actual, { recursive: true, force: true })))
-            const head = path.join(directory, ".git", "HEAD")
-            yield* ready(head, path.join(actual, "HEAD"))
-            const branch = `watch-${Math.random().toString(36).slice(2)}`
-            yield* Effect.promise(() => $`git branch ${branch}`.cwd(directory).quiet())
-            expect(
-              yield* nextUpdate(
-                (event) => event.file === path.join(actual, "HEAD"),
-                afs.writeFileString(head, `ref: refs/heads/${branch}\n`),
-              ),
-            ).toEqual({ file: path.join(actual, "HEAD"), event: "change" })
-          }),
-        {
-          vcs: "git",
-          init: async (directory) => {
-            const actual = path.join(directory, "..", `actual_${path.basename(directory)}`)
-            await fs.rename(path.join(directory, ".git"), actual)
-            await fs.symlink(actual, path.join(directory, ".git"))
-          },
-        },
-      ),
-    )
-  })
-
-  it.live("publishes .hg/branch events", () =>
-    withTmp(
-      (directory) =>
-        Effect.gen(function* () {
-          const fs = yield* FSUtil.Service
-          const branch = path.join(directory, ".hg", "branch")
-          yield* ready(branch)
-          expect(
-            yield* nextUpdate((event) => event.file === branch, fs.writeFileString(branch, "feature\n")),
-          ).toMatchObject({ file: branch })
-        }),
-      { vcs: "hg" },
-    ),
-  )
 })

packages/core/test/fixture/global.ts

@@ -1,27 +0,0 @@
-import path from "path"
-import { Global } from "@opencode-ai/util/global"
-import { Effect, Layer } from "effect"
-import { tmpdir } from "./tmpdir"
-
-export const tempGlobalLayer = Layer.unwrap(
-  Effect.acquireRelease(
-    Effect.promise(() => tmpdir()),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(
-    Effect.map((tmp) => {
-      const data = path.join(tmp.path, "data")
-      const cache = path.join(tmp.path, "cache")
-      return Global.layerWith({
-        home: path.join(tmp.path, "home"),
-        data,
-        cache,
-        config: path.join(tmp.path, "config"),
-        state: path.join(tmp.path, "state"),
-        tmp: path.join(tmp.path, "tmp"),
-        bin: path.join(cache, "bin"),
-        log: path.join(data, "log"),
-        repos: path.join(data, "repos"),
-      })
-    }),
-  ),
-)

packages/core/test/global.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { Global } from "@opencode-ai/util/global"
+
+describe("global paths", () => {
+  test("tmp path is the canonical system temp directory", async () => {
+    expect(Global.Path.tmp).toBe(await fs.realpath(path.join(os.tmpdir(), "opencode")))
+    expect(Global.make().tmp).toBe(Global.Path.tmp)
+  })
+
+  test("tmp path is created on module load", async () => {
+    expect((await fs.stat(Global.Path.tmp)).isDirectory()).toBe(true)
+  })
+})

packages/core/test/instruction-discovery.test.ts

@@ -1,124 +1,49 @@
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
+import { Effect, Layer } from "effect"
 import fs from "fs/promises"
 import path from "path"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Bus } from "@opencode-ai/core/bus"
-import { ConfigInstructionPlugin } from "@opencode-ai/core/config/plugin/instruction"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
-import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
-import { Instructions } from "@opencode-ai/core/instructions"
-import { Location } from "@opencode-ai/core/location"
-import { AbsolutePath } from "@opencode-ai/core/schema"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { tempGlobalLayer } from "./fixture/global"
+import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
+import { Location } from "@opencode-ai/core/location"
+import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
-import { readInitial, readUpdate, state } from "./lib/instructions"
 import { testEffect } from "./lib/effect"
-import { host } from "./plugin/host"
+import { readInitial, readUpdate, state } from "./lib/instructions"
 
 const it = testEffect(Layer.empty)
 
 const instructionLayer = (input: {
-  config?: string
+  config: string
   locationServiceLayer: Layer.Layer<Location.Service>
   filesystemLayer?: Layer.Layer<FSUtil.Service>
   project?: boolean
-}) => {
-  const watcher = Watcher.testLayer
-  return Layer.mergeAll(
-    AppNodeBuilder.build(
-      LayerNode.group([InstructionDiscovery.node, Bus.node, FSUtil.node, Global.node, Location.node, Watcher.node]),
-      [
-        [InstructionDiscovery.node, InstructionDiscovery.configured({ project: input.project })],
-        [Global.node, input.config ? Global.layerWith({ config: input.config }) : tempGlobalLayer],
-        [Location.node, input.locationServiceLayer],
-        [Watcher.node, watcher],
-        ...(input.filesystemLayer ? [[FSUtil.node, input.filesystemLayer] as const] : []),
-      ],
-    ),
-    watcher,
-  )
-}
-
-const start = Effect.fnUntraced(function* () {
-  yield* ConfigInstructionPlugin.Plugin.effect(host())
-  return yield* InstructionDiscovery.Service
-})
-
-const file = (path: string, content: string) =>
-  new InstructionDiscovery.File({ path: AbsolutePath.make(path), content })
-
-function emitAndWait(update: Watcher.Update) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    const bus = yield* Bus.Service
-    const updated = yield* Deferred.make<void>()
-    const fiber = yield* bus.subscribe(InstructionDiscovery.Event.Updated).pipe(
-      Stream.runForEach(() => Deferred.succeed(updated, undefined).pipe(Effect.asVoid)),
-      Effect.forkScoped,
-    )
-    yield* Effect.yieldNow
-    yield* watcher.emit(update)
-    yield* Deferred.await(updated).pipe(Effect.timeout("2 seconds"))
-    yield* Fiber.interrupt(fiber)
-  })
-}
+}) =>
+  AppNodeBuilder.build(InstructionDiscovery.node, [
+    [InstructionDiscovery.node, InstructionDiscovery.configured({ project: input.project })],
+    [Global.node, Global.layerWith({ config: input.config })],
+    [Location.node, input.locationServiceLayer],
+    ...(input.filesystemLayer ? [[FSUtil.node, input.filesystemLayer] as const] : []),
+  ])
 
 describe("InstructionDiscovery", () => {
-  it.effect("stores ordered values with last-write-wins precedence", () =>
-    Effect.gen(function* () {
-      const discovery = yield* InstructionDiscovery.Service
-      yield* discovery.transform((draft) => {
-        draft.add(file("/repo/AGENTS.md", "first"))
-        draft.add(file("/repo/packages/AGENTS.md", "package"))
-        draft.add(file("/repo/AGENTS.md", "last"))
-        draft.update("/repo/packages/AGENTS.md", (current) => {
-          current.content = "updated"
-          current.path = AbsolutePath.make("/ignored")
-        })
-        draft.remove("/missing")
-      })
-
-      expect(yield* discovery.list()).toEqual([
-        file("/repo/AGENTS.md", "last"),
-        file("/repo/packages/AGENTS.md", "updated"),
-      ])
-    }).pipe(Effect.provide(AppNodeBuilder.build(LayerNode.group([InstructionDiscovery.node, Bus.node])))),
-  )
-
-  it.effect("preserves admitted values while the source is unavailable", () =>
-    Effect.gen(function* () {
-      const discovery = yield* InstructionDiscovery.Service
-      yield* discovery.transform((draft) => draft.unavailable())
-      expect(
-        (yield* readUpdate(
-          yield* discovery.load(),
-          state({ "core/instructions": [{ path: "/repo/AGENTS.md", content: "old" }] }),
-        )).changed,
-      ).toBe(false)
-    }).pipe(Effect.provide(AppNodeBuilder.build(LayerNode.group([InstructionDiscovery.node, Bus.node])))),
-  )
-})
-
-describe("ConfigInstructionPlugin.Plugin", () => {
-  it.live("loads global and upward project files and rescans them on change", () =>
+  it.live("loads global and upward project AGENTS.md files as one aggregate context", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
     ).pipe(
-      Effect.flatMap((tmp) => {
-        const global = path.join(tmp.path, "global")
-        const project = path.join(tmp.path, "project")
-        const directory = path.join(project, "packages", "core")
-        const outside = path.join(tmp.path, "AGENTS.md")
-        const globalFile = path.join(global, "AGENTS.md")
-        const projectFile = path.join(project, "AGENTS.md")
-        const packageFile = path.join(directory, "AGENTS.md")
-        return Effect.gen(function* () {
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const global = path.join(tmp.path, "global")
+          const project = path.join(tmp.path, "project")
+          const directory = path.join(project, "packages", "core")
+          const outside = path.join(tmp.path, "AGENTS.md")
+          const globalFile = path.join(global, "AGENTS.md")
+          const projectFile = path.join(project, "AGENTS.md")
+          const packageFile = path.join(directory, "AGENTS.md")
           yield* Effect.promise(async () => {
             await fs.mkdir(global, { recursive: true })
             await fs.mkdir(directory, { recursive: true })
@@ -128,15 +53,25 @@ describe("ConfigInstructionPlugin.Plugin", () => {
             await fs.writeFile(packageFile, "package")
           })
 
-          const discovery = yield* start()
-          const watcher = yield* Watcher.Test
-          expect(yield* watcher.subscriptions()).toEqual([
-            { path: globalFile, type: "file" },
-            { path: packageFile, type: "file" },
-            { path: path.join(project, "packages", "AGENTS.md"), type: "file" },
-            { path: projectFile, type: "file" },
-          ])
-          const initialized = yield* readInitial(yield* discovery.load())
+          const load = InstructionDiscovery.Service.pipe(
+            Effect.flatMap((service) => service.load()),
+            Effect.provide(
+              instructionLayer({
+                config: global,
+                locationServiceLayer: Layer.succeed(
+                  Location.Service,
+                  Location.Service.of(
+                    location(
+                      { directory: AbsolutePath.make(directory) },
+                      { projectDirectory: AbsolutePath.make(project) },
+                    ),
+                  ),
+                ),
+              }),
+            ),
+          )
+
+          const initialized = yield* readInitial(yield* load)
           expect(initialized.text).toBe(
             [
               `Instructions from: ${globalFile}\nglobal`,
@@ -147,14 +82,13 @@ describe("ConfigInstructionPlugin.Plugin", () => {
           expect(initialized.text).not.toContain("outside")
 
           yield* Effect.promise(() => fs.writeFile(packageFile, "changed"))
-          yield* emitAndWait({ type: "update", path: packageFile })
-          expect((yield* readUpdate(yield* discovery.load(), initialized)).text).toContain(
+          expect((yield* readUpdate(yield* load, initialized)).text).toContain(
             `Instructions from: ${packageFile}\nchanged`,
           )
 
           yield* Effect.promise(() => fs.rm(packageFile))
-          yield* emitAndWait({ type: "delete", path: packageFile })
-          expect((yield* readUpdate(yield* discovery.load(), initialized)).text).toBe(
+          const partial = yield* readUpdate(yield* load, initialized)
+          expect(partial.text).toBe(
             [
               "These instructions replace all previously loaded ambient instructions.",
               `Instructions from: ${globalFile}\nglobal`,
@@ -162,30 +96,12 @@ describe("ConfigInstructionPlugin.Plugin", () => {
             ].join("\n\n"),
           )
 
-          yield* Effect.promise(() => fs.rm(globalFile))
-          yield* emitAndWait({ type: "delete", path: globalFile })
-          yield* Effect.promise(() => fs.rm(projectFile))
-          yield* emitAndWait({ type: "delete", path: projectFile })
-          expect((yield* readUpdate(yield* discovery.load(), initialized)).text).toBe(
+          yield* Effect.promise(() => Promise.all([fs.rm(globalFile), fs.rm(projectFile)]))
+          expect((yield* readUpdate(yield* load, initialized)).text).toBe(
             "Previously loaded instructions no longer apply.",
           )
-        }).pipe(
-          Effect.provide(
-            instructionLayer({
-              config: global,
-              locationServiceLayer: Layer.succeed(
-                Location.Service,
-                Location.Service.of(
-                  location(
-                    { directory: AbsolutePath.make(directory) },
-                    { projectDirectory: AbsolutePath.make(project) },
-                  ),
-                ),
-              ),
-            }),
-          ),
-        )
-      }),
+        }),
+      ),
     ),
   )
 
@@ -198,150 +114,115 @@ describe("ConfigInstructionPlugin.Plugin", () => {
         Effect.gen(function* () {
           const file = path.join(tmp.path, "AGENTS.md")
           yield* Effect.promise(() => fs.writeFile(file, ""))
-          const discovery = yield* start()
-          expect((yield* readInitial(yield* discovery.load())).text).toBe(`Instructions from: ${file}\n`)
-        }).pipe(
-          Effect.provide(
-            instructionLayer({
-              config: path.join(tmp.path, "global"),
-              locationServiceLayer: Layer.succeed(
-                Location.Service,
-                Location.Service.of(location({ directory: AbsolutePath.make(tmp.path) })),
-              ),
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.live("discovers a newly created instruction file in an intermediate directory", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) => {
-        const project = path.join(tmp.path, "project")
-        const intermediate = path.join(project, "packages", "AGENTS.md")
-        const directory = path.join(project, "packages", "core")
-        const projectFile = path.join(project, "AGENTS.md")
-        return Effect.gen(function* () {
-          yield* Effect.promise(() => fs.mkdir(directory, { recursive: true }))
-          yield* Effect.promise(() => fs.writeFile(projectFile, "project"))
-          const discovery = yield* start()
-          expect((yield* readInitial(yield* discovery.load())).text).toBe(`Instructions from: ${projectFile}\nproject`)
-
-          yield* Effect.promise(() => fs.writeFile(intermediate, "intermediate"))
-          yield* emitAndWait({ type: "create", path: intermediate })
-
-          expect((yield* readInitial(yield* discovery.load())).text).toBe(
-            [`Instructions from: ${intermediate}\nintermediate`, `Instructions from: ${projectFile}\nproject`].join(
-              "\n\n",
+          const context = yield* InstructionDiscovery.Service.pipe(
+            Effect.flatMap((service) => service.load()),
+            Effect.provide(
+              instructionLayer({
+                config: path.join(tmp.path, "global"),
+                locationServiceLayer: Layer.succeed(
+                  Location.Service,
+                  Location.Service.of(location({ directory: AbsolutePath.make(tmp.path) })),
+                ),
+              }),
             ),
           )
-        }).pipe(
-          Effect.provide(
-            instructionLayer({
-              config: path.join(tmp.path, "global"),
-              locationServiceLayer: Layer.succeed(
-                Location.Service,
-                Location.Service.of(
-                  location(
-                    { directory: AbsolutePath.make(directory) },
-                    { projectDirectory: AbsolutePath.make(project) },
-                  ),
-                ),
-              ),
-            }),
-          ),
-        )
-      }),
+
+          expect((yield* readInitial(context)).text).toBe(`Instructions from: ${file}\n`)
+        }),
+      ),
     ),
   )
 
-  it.effect("isolates source failure without failing activation", () => {
-    const failingFS = Layer.effect(
-      FSUtil.Service,
-      FSUtil.Service.pipe(
-        Effect.map((fs) =>
-          FSUtil.Service.of({ ...fs, up: () => Effect.fail(new FSUtil.FileSystemError({ method: "up" })) }),
-        ),
-      ),
-    ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
-    return Effect.gen(function* () {
-      const discovery = yield* start()
-      expect(
-        (yield* readUpdate(
-          yield* discovery.load(),
-          state({ "core/instructions": [{ path: "/repo/AGENTS.md", content: "old" }] }),
-        )).changed,
-      ).toBe(false)
-    }).pipe(
-      Effect.provide(
-        instructionLayer({
-          filesystemLayer: failingFS,
-          locationServiceLayer: Layer.succeed(
-            Location.Service,
-            Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+  it.effect("preserves admitted instructions while observation is unavailable", () =>
+    Effect.gen(function* () {
+      const failingFS = Layer.effect(
+        FSUtil.Service,
+        FSUtil.Service.pipe(
+          Effect.map((fs) =>
+            FSUtil.Service.of({ ...fs, up: () => Effect.fail(new FSUtil.FileSystemError({ method: "up" })) }),
           ),
-        }),
-      ),
-    )
-  })
-
-  it.effect("marks a discovered file that disappears before read as unavailable", () => {
-    const discovered = AbsolutePath.make("/repo/AGENTS.md")
-    const racingFS = Layer.effect(
-      FSUtil.Service,
-      FSUtil.Service.pipe(
-        Effect.map((fs) =>
-          FSUtil.Service.of({
-            ...fs,
-            up: () => Effect.succeed([discovered]),
-            readFileStringSafe: () => Effect.succeed(undefined),
+        ),
+      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
+      const context = yield* InstructionDiscovery.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: failingFS,
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+            ),
           }),
         ),
-      ),
-    ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
-    return Effect.gen(function* () {
-      const discovery = yield* start()
-      expect(
-        (yield* readUpdate(
-          yield* discovery.load(),
-          state({ "core/instructions": [{ path: discovered, content: "old" }] }),
-        )).changed,
-      ).toBe(false)
-    }).pipe(
-      Effect.provide(
-        instructionLayer({
-          filesystemLayer: racingFS,
-          locationServiceLayer: Layer.succeed(
-            Location.Service,
-            Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
-          ),
-        }),
-      ),
-    )
-  })
+      )
 
-  it.effect("canonicalizes boundaries and honors project opt-out", () =>
+      expect(
+        (yield* readUpdate(context, state({ "core/instructions": [{ path: "/repo/AGENTS.md", content: "old" }] })))
+          .changed,
+      ).toBe(false)
+    }),
+  )
+
+  it.effect("preserves admitted instructions when a discovered file disappears before read", () =>
     Effect.gen(function* () {
-      const observed: { values: { targets: string[]; start: string; stop?: string }[] } = { values: [] }
+      const file = AbsolutePath.make("/repo/AGENTS.md")
+      const racingFS = Layer.effect(
+        FSUtil.Service,
+        FSUtil.Service.pipe(
+          Effect.map((fs) =>
+            FSUtil.Service.of({
+              ...fs,
+              up: () => Effect.succeed([file]),
+              readFileStringSafe: () => Effect.succeed(undefined),
+            }),
+          ),
+        ),
+      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
+      const context = yield* InstructionDiscovery.Service.pipe(
+        Effect.flatMap((service) => service.load()),
+        Effect.provide(
+          instructionLayer({
+            config: "/global",
+            filesystemLayer: racingFS,
+            locationServiceLayer: Layer.succeed(
+              Location.Service,
+              Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
+            ),
+          }),
+        ),
+      )
+
+      expect(
+        (yield* readUpdate(context, state({ "core/instructions": [{ path: file, content: "old" }] }))).changed,
+      ).toBe(false)
+    }),
+  )
+
+  it.effect("canonicalizes upward discovery boundaries", () =>
+    Effect.gen(function* () {
+      let observed: { targets: string[]; start: string; stop?: string } | undefined
       const observingFS = Layer.effect(
         FSUtil.Service,
         FSUtil.Service.pipe(
           Effect.map((fs) =>
             FSUtil.Service.of({
               ...fs,
-              up: (options) => Effect.sync(() => (observed.values.push(options), [])),
+              up: (options) =>
+                Effect.sync(() => {
+                  observed = options
+                  return []
+                }),
             }),
           ),
         ),
       ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
 
-      yield* start().pipe(
+      yield* InstructionDiscovery.Service.pipe(
+        Effect.flatMap((service) => service.load()),
         Effect.provide(
           instructionLayer({
+            config: "/global",
             filesystemLayer: observingFS,
             locationServiceLayer: Layer.succeed(
               Location.Service,
@@ -352,11 +233,31 @@ describe("ConfigInstructionPlugin.Plugin", () => {
           }),
         ),
       )
-      yield* start().pipe(
+
+      expect(observed).toEqual({
+        targets: ["AGENTS.md"],
+        start: FSUtil.resolve("/repo"),
+        stop: FSUtil.resolve("/repo"),
+      })
+    }),
+  )
+
+  it.effect("honors the project instruction opt-out", () =>
+    Effect.gen(function* () {
+      let scanned = false
+
+      yield* InstructionDiscovery.Service.pipe(
+        Effect.flatMap((service) => service.load()),
         Effect.provide(
           instructionLayer({
-            filesystemLayer: observingFS,
+            config: "/global",
             project: false,
+            filesystemLayer: Layer.effect(
+              FSUtil.Service,
+              FSUtil.Service.pipe(
+                Effect.map((fs) => FSUtil.Service.of({ ...fs, up: () => Effect.sync(() => ((scanned = true), [])) })),
+              ),
+            ).pipe(Layer.provide(LayerNode.compile(FSUtil.node))),
             locationServiceLayer: Layer.succeed(
               Location.Service,
               Location.Service.of(location({ directory: AbsolutePath.make("/repo") })),
@@ -364,10 +265,25 @@ describe("ConfigInstructionPlugin.Plugin", () => {
           }),
         ),
       )
-      yield* start().pipe(
+
+      expect(scanned).toBe(false)
+    }),
+  )
+
+  it.effect("does not discover project instructions outside the canonical project root", () =>
+    Effect.gen(function* () {
+      let scanned = false
+      yield* InstructionDiscovery.Service.pipe(
+        Effect.flatMap((service) => service.load()),
         Effect.provide(
           instructionLayer({
-            filesystemLayer: observingFS,
+            config: "/global",
+            filesystemLayer: Layer.effect(
+              FSUtil.Service,
+              FSUtil.Service.pipe(
+                Effect.map((fs) => FSUtil.Service.of({ ...fs, up: () => Effect.sync(() => ((scanned = true), [])) })),
+              ),
+            ).pipe(Layer.provide(LayerNode.compile(FSUtil.node))),
             locationServiceLayer: Layer.succeed(
               Location.Service,
               Location.Service.of(
@@ -381,8 +297,7 @@ describe("ConfigInstructionPlugin.Plugin", () => {
         ),
       )
 
-      const repo = path.resolve("/repo")
-      expect(observed.values).toEqual([{ targets: ["AGENTS.md"], start: repo, stop: repo }])
+      expect(scanned).toBe(false)
     }),
   )
 })

packages/core/test/instructions/builtins.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import os from "os"
 import { Effect, Layer } from "effect"
 import * as TestClock from "effect/testing/TestClock"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -17,7 +16,6 @@ const directory = AbsolutePath.make(FSUtil.resolve("/repo/packages/core"))
 const projectDirectory = AbsolutePath.make(FSUtil.resolve("/repo"))
 const timestamp = Date.parse("2026-06-03T12:00:00.000Z")
 const sessionID = SessionSchema.ID.make("ses_builtin_test")
-const temporary = os.tmpdir()
 const localDate = (time: number) => new Date(time).toDateString()
 const locationLayer = Layer.succeed(
   Location.Service,
@@ -31,7 +29,7 @@ const locationLayer = Layer.succeed(
 const it = testEffect(
   AppNodeBuilder.build(InstructionBuiltIns.node, [
     [Location.node, locationLayer],
-    [Global.node, Global.layerWith({ config: temporary, tmp: temporary })],
+    [Global.node, Global.layerWith({ config: "/global", tmp: "/temporary" })],
   ]),
 )
 
@@ -51,7 +49,7 @@ describe("InstructionBuiltIns", () => {
           `  Workspace root folder: ${projectDirectory}`,
           "  Is directory a git repo: yes",
           `  Platform: ${process.platform}`,
-          `  Use ${temporary} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
+          "  Use /temporary for temporary work outside the workspace; it already exists and is pre-approved for external directory access.",
           "</env>",
           "",
           `Today's date: ${localDate(timestamp)}`,

packages/core/test/location-layer.test.ts

@@ -9,7 +9,6 @@ import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Global } from "@opencode-ai/util/global"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { Location } from "@opencode-ai/core/location"
 import { Plugin } from "@opencode-ai/core/plugin"
@@ -22,7 +21,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { tmpdir } from "./fixture/tmpdir"
-import { tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
 import { toolDefinitions, waitForTool } from "./lib/tool"
 import { Database } from "../src/database/database"
@@ -30,15 +28,9 @@ import { Bus } from "../src/bus"
 import { Reference } from "../src/reference"
 import { Tool } from "../src/tool"
 
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, LocationServiceMap.node]), [
-    [Global.node, tempGlobalLayer],
-  ]),
-)
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, LocationServiceMap.node])))
 const itWithSdk = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
-    [Global.node, tempGlobalLayer],
-  ]),
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node])),
 )
 
 describe("LocationServiceMap", () => {

packages/core/test/models.test.ts

@@ -1,17 +1,19 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect, beforeEach, afterAll, test } from "bun:test"
 import { Money } from "@opencode-ai/schema/money"
 import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { KV } from "@opencode-ai/core/kv"
+import { Global } from "@opencode-ai/util/global"
 import { Model } from "@opencode-ai/core/model"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { Provider } from "@opencode-ai/core/provider"
 import { it } from "./lib/effect"
+import { readFile, rm, writeFile, utimes, mkdir } from "fs/promises"
+import path from "path"
 
-const cacheKey = "models-dev:catalog"
+const cacheFile = path.join(Global.Path.cache, "models.json")
 
 test("normalizes permissive interleaved values to compatibility", () => {
   expect(Model.compatibility("reasoning_text")).toEqual({ reasoningField: "reasoning_text" })
@@ -162,18 +164,7 @@ const makeMockClient = (state: Ref.Ref<MockState>) =>
     }),
   )
 
-interface MockCache {
-  readonly values: Map<string, KV.Value>
-}
-
-const makeMockKV = (cache: MockCache) =>
-  Layer.mock(KV.Service, {
-    get: (key) => Effect.sync(() => cache.values.get(key)),
-    set: (key, value) => Effect.sync(() => cache.values.set(key, value)).pipe(Effect.asVoid),
-    remove: (key) => Effect.sync(() => cache.values.delete(key)).pipe(Effect.asVoid),
-  })
-
-const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: ModelsDev.Options = { fetch: false }) =>
+const buildLayer = (state: Ref.Ref<MockState>, options: ModelsDev.Options = { fetch: false }) =>
   // Layer.fresh is required because the ModelsDev implementation is a module-level Layer constant,
   // and Effect.provide uses a process-global MemoMap by default — without fresh,
   // every test would reuse the cachedInvalidateWithTTL state from the first run.
@@ -181,20 +172,31 @@ const buildLayer = (state: Ref.Ref<MockState>, cache: MockCache, options: Models
     AppNodeBuilder.build(ModelsDev.node, [
       [ModelsDev.node, ModelsDev.configured(options)],
       [LayerNodePlatform.httpClient, Layer.succeed(HttpClient.HttpClient, makeMockClient(state))],
-      [KV.node, makeMockKV(cache)],
     ]),
   )
 
-const makeCache = (): MockCache => ({ values: new Map() })
+const writeCacheText = (text: string, mtimeMs?: number) =>
+  Effect.promise(async () => {
+    await mkdir(Global.Path.cache, { recursive: true })
+    await writeFile(cacheFile, text)
+    if (mtimeMs !== undefined) {
+      const t = mtimeMs / 1000
+      await utimes(cacheFile, t, t)
+    }
+  })
 
-const writeCacheText = (cache: MockCache, text: string, updatedAt = Date.now()) =>
-  cache.values.set(cacheKey, { updatedAt, body: text })
+const writeCache = (data: object, mtimeMs?: number) => writeCacheText(JSON.stringify(data), mtimeMs)
 
-const writeCache = (cache: MockCache, data: object, updatedAt?: number) =>
-  writeCacheText(cache, JSON.stringify(data), updatedAt)
+const provided = <A, E>(state: Ref.Ref<MockState>, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
+  eff.pipe(Effect.provide(buildLayer(state)))
 
-const provided = <A, E>(state: Ref.Ref<MockState>, cache: MockCache, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
-  eff.pipe(Effect.provide(buildLayer(state, cache)))
+beforeEach(async () => {
+  await rm(cacheFile, { force: true })
+})
+
+afterAll(async () => {
+  await rm(cacheFile, { force: true })
+})
 
 const initialState: MockState = {
   body: JSON.stringify(fixture),
@@ -203,14 +205,12 @@ const initialState: MockState = {
 }
 
 describe("ModelsDev Service", () => {
-  it.live("get() returns normalized snapshots from KV when a cache entry exists", () =>
+  it.live("get() returns normalized snapshots from disk when cache file exists", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
       const state = yield* Ref.make(initialState)
       const result = yield* provided(
         state,
-        cache,
         ModelsDev.Service.use((s) => s.get()),
       )
       expect(result).toEqual(fixtureSnapshot)
@@ -219,13 +219,11 @@ describe("ModelsDev Service", () => {
     }),
   )
 
-  it.live("get() returns empty catalog when KV is empty, fetch disabled, and no bundled snapshot is injected", () =>
+  it.live("get() returns empty catalog when disk empty, fetch disabled, and no bundled snapshot is injected", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
       const state = yield* Ref.make(initialState)
       const result = yield* provided(
         state,
-        cache,
         ModelsDev.Service.use((s) => s.get()),
       )
       expect(result).toEqual([])
@@ -234,15 +232,14 @@ describe("ModelsDev Service", () => {
     }),
   )
 
-  it.live("get() recovers from a corrupted KV entry by fetching a fresh catalog", () =>
+  it.live("get() recovers from a corrupted cache file by fetching a fresh catalog", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCacheText(cache, "{")
+      yield* writeCacheText("{")
       const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const context = yield* Layer.build(buildLayer(state, cache, { fetch: true }))
+      const context = yield* Layer.build(buildLayer(state, { fetch: true }))
       const result = yield* ModelsDev.Service.use((s) => s.get()).pipe(Effect.provide(context))
       expect(result).toEqual(fixture2Snapshot)
-      expect(cache.values.get(cacheKey)).toMatchObject({ body: JSON.stringify(fixture2) })
+      expect(yield* Effect.promise(() => readFile(cacheFile, "utf8"))).toBe(JSON.stringify(fixture2))
       const final = yield* Ref.get(state)
       expect(final.calls.length).toBe(1)
     }),
@@ -250,10 +247,9 @@ describe("ModelsDev Service", () => {
 
   it.live("uses the default models URL when the configured URL is empty", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
       const state = yield* Ref.make(initialState)
       yield* ModelsDev.Service.use((service) => service.get()).pipe(
-        Effect.provide(buildLayer(state, cache, { url: "", fetch: true })),
+        Effect.provide(buildLayer(state, { url: "", fetch: true })),
       )
       expect((yield* Ref.get(state)).calls[0]?.url).toBe("https://models.opencode.ai/api.json")
     }),
@@ -261,31 +257,32 @@ describe("ModelsDev Service", () => {
 
   it.live("get() is single-flight under concurrent calls", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
+      yield* writeCache(fixture)
       const state = yield* Ref.make(initialState)
-      const results = yield* Effect.gen(function* () {
-        const svc = yield* ModelsDev.Service
-        return yield* Effect.all([svc.get(), svc.get(), svc.get(), svc.get(), svc.get()], {
-          concurrency: "unbounded",
-        })
-      }).pipe(Effect.provide(buildLayer(state, cache, { fetch: true })))
+      const results = yield* provided(
+        state,
+        Effect.gen(function* () {
+          const svc = yield* ModelsDev.Service
+          return yield* Effect.all([svc.get(), svc.get(), svc.get(), svc.get(), svc.get()], {
+            concurrency: "unbounded",
+          })
+        }),
+      )
       for (const result of results) expect(result).toEqual(fixtureSnapshot)
-      expect((yield* Ref.get(state)).calls.length).toBe(1)
     }),
   )
 
-  it.live("get() caches across calls (later KV writes are ignored until invalidate)", () =>
+  it.live("get() caches across calls (later disk writes are ignored until invalidate)", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
       const state = yield* Ref.make(initialState)
       const first = yield* provided(
         state,
-        cache,
         Effect.gen(function* () {
           const svc = yield* ModelsDev.Service
           const a = yield* svc.get()
-          writeCache(cache, fixture2)
+          // mutate disk between calls — cache should mask the change
+          yield* writeCache(fixture2)
           const b = yield* svc.get()
           return { a, b }
         }),
@@ -297,12 +294,10 @@ describe("ModelsDev Service", () => {
 
   it.live("refresh(true) fetches via HttpClient and updates the cache", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
       const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
       const result = yield* provided(
         state,
-        cache,
         Effect.gen(function* () {
           const svc = yield* ModelsDev.Service
           const before = yield* svc.get()
@@ -313,7 +308,6 @@ describe("ModelsDev Service", () => {
       )
       expect(result.before).toEqual(fixtureSnapshot)
       expect(result.after).toEqual(fixture2Snapshot)
-      expect(cache.values.get(cacheKey)).toMatchObject({ body: JSON.stringify(fixture2) })
       const final = yield* Ref.get(state)
       expect(final.calls.length).toBe(1)
       expect(final.calls[0].url).toContain("/api.json")
@@ -321,14 +315,13 @@ describe("ModelsDev Service", () => {
     }),
   )
 
-  it.live("refresh(false) skips fetch when the KV entry is fresh", () =>
+  it.live("refresh(false) skips fetch when on-disk file is fresh", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture, Date.now() - 1000)
+      // Fresh: mtime within the 5-minute TTL.
+      yield* writeCache(fixture, Date.now() - 1000)
       const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
       yield* provided(
         state,
-        cache,
         ModelsDev.Service.use((s) => s.refresh(false)),
       )
       const final = yield* Ref.get(state)
@@ -336,14 +329,13 @@ describe("ModelsDev Service", () => {
     }),
   )
 
-  it.live("refresh(false) fetches when the KV entry is stale", () =>
+  it.live("refresh(false) fetches when on-disk file is stale", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture, Date.now() - 10 * 60 * 1000)
+      // Stale: mtime 10 minutes ago, beyond the 5-minute TTL.
+      yield* writeCache(fixture, Date.now() - 10 * 60 * 1000)
       const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
       const after = yield* provided(
         state,
-        cache,
         Effect.gen(function* () {
           const svc = yield* ModelsDev.Service
           yield* svc.refresh(false)
@@ -358,12 +350,10 @@ describe("ModelsDev Service", () => {
 
   it.live("refresh swallows HTTP errors and leaves cache intact", () =>
     Effect.gen(function* () {
-      const cache = makeCache()
-      writeCache(cache, fixture)
+      yield* writeCache(fixture)
       const state = yield* Ref.make({ ...initialState, status: 500, body: "boom" })
       const result = yield* provided(
         state,
-        cache,
         Effect.gen(function* () {
           const svc = yield* ModelsDev.Service
           yield* svc.refresh(true)

packages/core/test/plugin/fixture.ts

@@ -19,11 +19,9 @@ import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
 import { Reference } from "@opencode-ai/core/reference"
 import { Skill } from "@opencode-ai/core/skill"
-import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { Tool } from "@opencode-ai/core/tool"
 import { WebSearch } from "@opencode-ai/core/websearch"
-import { Effect, Layer } from "effect"
+import { Effect, Layer, Stream } from "effect"
 import { tempLocationLayer } from "../fixture/location"
 
 const npmLayer = Layer.succeed(
@@ -55,10 +53,8 @@ export const PluginTestLayer = AppNodeBuilder.build(
     PluginHooks.node,
     Reference.node,
     Skill.node,
-    SkillDiscovery.node,
     PluginHooks.node,
     Tool.node,
-    Watcher.node,
     WebSearch.node,
   ]),
   [

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

@@ -543,10 +543,11 @@ describe("Session.create", () => {
         Effect.promise(() => tmpdir()),
         (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
       )
+      const targetDatabase = Database.layer({ path: path.join(tmp.path, "target.sqlite") })
       const targetLayer = AppNodeBuilder.build(
         LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node]),
         [
-          [Database.node, Database.configured({ path: path.join(tmp.path, "target.sqlite") })],
+          [Database.node, targetDatabase],
           [Bus.node, Bus.configured({ persist: true })],
         ],
       )

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

@@ -99,10 +99,7 @@ const builtins = Layer.mock(InstructionBuiltIns.Service, {
       }),
     ),
 })
-const discovery = Layer.mock(InstructionDiscovery.Service, {
-  project: true,
-  load: () => Effect.succeed(Instructions.empty),
-})
+const discovery = Layer.mock(InstructionDiscovery.Service, { load: () => Effect.succeed(Instructions.empty) })
 const skills = Layer.mock(SkillInstructions.Service, { load: () => Effect.succeed(Instructions.empty) })
 const references = Layer.mock(ReferenceInstructions.Service, { load: () => Effect.succeed(Instructions.empty) })
 const mcp = Layer.mock(McpInstructions.Service, { load: () => Effect.succeed(Instructions.empty) })

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

@@ -83,10 +83,7 @@ const models = Layer.mock(SessionRunnerModel.Service)({
     ),
 })
 const systemContext = Layer.mock(InstructionBuiltIns.Service, { load: () => Effect.succeed(Instructions.empty) })
-const instructionContext = Layer.mock(InstructionDiscovery.Service, {
-  project: true,
-  load: () => Effect.succeed(Instructions.empty),
-})
+const instructionContext = Layer.mock(InstructionDiscovery.Service, { load: () => Effect.succeed(Instructions.empty) })
 const skillInstructions = Layer.mock(SkillInstructions.Service, { load: () => Effect.succeed(Instructions.empty) })
 const referenceInstructions = Layer.mock(ReferenceInstructions.Service, {
   load: () => Effect.succeed(Instructions.empty),

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

@@ -312,10 +312,7 @@ const systemContext = Layer.mock(InstructionBuiltIns.Service, {
       }),
     ),
 })
-const instructionContext = Layer.mock(InstructionDiscovery.Service, {
-  project: true,
-  load: () => Effect.succeed(Instructions.empty),
-})
+const instructionContext = Layer.mock(InstructionDiscovery.Service, { load: () => Effect.succeed(Instructions.empty) })
 const skillInstructions = Layer.mock(SkillInstructions.Service, {
   load: (agent) =>
     Effect.succeed(

packages/core/test/skill.test.ts

@@ -1,102 +1,438 @@
+import fs from "fs/promises"
+import path from "path"
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Stream } from "effect"
+import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
+import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
+import { Watcher } from "@opencode-ai/core/filesystem/watcher"
+import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node])))
+const urls = new Map<string, AbsolutePath[]>()
+let pulls = 0
+const discovery = Layer.succeed(
+  SkillDiscovery.Service,
+  SkillDiscovery.Service.of({
+    pull: (url) => {
+      pulls++
+      return Effect.succeed(urls.get(url) ?? [])
+    },
+  }),
+)
+const watcherLayer = Watcher.testLayer
+const it = testEffect(
+  Layer.mergeAll(
+    AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node]), [
+      [SkillDiscovery.node, discovery],
+      [Watcher.node, watcherLayer],
+    ]),
+    watcherLayer,
+  ),
+)
 
-const info = (id: string, description: string) =>
-  Skill.Info.make({
-    id: Skill.ID.make(id),
-    name: Skill.Name.make(id),
-    description,
-    location: AbsolutePath.make(`/skills/${id}/SKILL.md`),
-    content: `# ${id}`,
+function write(directory: string, name: string, description: string) {
+  return fs.writeFile(
+    path.join(directory, name, "SKILL.md"),
+    `---
+name: ${name}
+description: ${description}
+---
+# ${name}`,
+  )
+}
+
+function waitForSkillUpdate() {
+  return Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const deferred = yield* Deferred.make<void>()
+    const fiber = yield* bus.subscribe(Skill.Event.Updated).pipe(
+      Stream.runForEach(() => Deferred.succeed(deferred, undefined).pipe(Effect.asVoid)),
+      Effect.forkScoped,
+    )
+    yield* Effect.yieldNow
+    return { deferred, fiber }
   })
+}
+
+function expectSubscription(check: (input: Watcher.WatchInput) => boolean) {
+  return Effect.gen(function* () {
+    const watcher = yield* Watcher.Test
+    expect((yield* watcher.subscriptions()).some(check)).toBe(true)
+  })
+}
+
+function emitAndWait(update: Watcher.Update) {
+  return Effect.gen(function* () {
+    const watcher = yield* Watcher.Test
+    yield* Effect.acquireUseRelease(
+      waitForSkillUpdate(),
+      ({ deferred }) => watcher.emit(update).pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
+      ({ fiber }) => Fiber.interrupt(fiber),
+    )
+  })
+}
 
 describe("Skill", () => {
-  it.effect("registers values with last-write-wins precedence", () =>
+  it.live("publishes updates when skill sources change", () =>
     Effect.gen(function* () {
       const skill = yield* Skill.Service
-      yield* skill.transform((draft) => {
-        draft.add(info("review", "First"))
-        draft.add(info("deploy", "Deploy"))
-        draft.add(info("review", "Second"))
-        expect(draft.list().map((item) => item.id)).toEqual([Skill.ID.make("review"), Skill.ID.make("deploy")])
-      })
 
-      expect(yield* skill.list()).toEqual([info("review", "Second"), info("deploy", "Deploy")])
+      yield* Effect.acquireUseRelease(
+        waitForSkillUpdate(),
+        ({ deferred }) =>
+          skill
+            .transform((editor) =>
+              editor.source({ type: "directory", path: AbsolutePath.make("/tmp/opencode-skills") }),
+            )
+            .pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
+        ({ fiber }) => Fiber.interrupt(fiber),
+      )
     }),
   )
 
-  it.effect("updates and removes registered values", () =>
-    Effect.gen(function* () {
-      const skill = yield* Skill.Service
-      yield* skill.transform((draft) => {
-        draft.add(info("review", "Initial"))
-        draft.update("review", (value) => {
-          value.description = "Updated"
-          value.id = Skill.ID.make("ignored")
-        })
-        draft.update("missing", () => Effect.die("unreachable"))
-        draft.add(info("deploy", "Deploy"))
-        draft.remove("deploy")
-      })
+  it.live("registers sources and resolves later source precedence", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const first = path.join(tmp.path, "first")
+          const second = path.join(tmp.path, "second")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(first, "review"), { recursive: true })
+            await fs.mkdir(path.join(second, "review"), { recursive: true })
+            await write(first, "review", "First")
+            await write(second, "review", "Second")
+            await fs.writeFile(path.join(first, "foo.md"), "---\nslash: true\n---\n# foo")
+          })
 
-      expect(yield* skill.list()).toEqual([info("review", "Updated")])
-    }),
-  )
+          const skill = yield* Skill.Service
+          const watcher = yield* Watcher.Test
+          yield* skill.transform((editor) => {
+            editor.source({ type: "directory", path: AbsolutePath.make(first) })
+            editor.source({ type: "directory", path: AbsolutePath.make(first) })
+            editor.source({ type: "directory", path: AbsolutePath.make(second) })
+            expect(editor.list()).toEqual([
+              { type: "directory", path: AbsolutePath.make(first) },
+              { type: "directory", path: AbsolutePath.make(second) },
+            ])
+          })
 
-  it.effect("restores earlier values when an updating transform is disposed", () =>
-    Effect.gen(function* () {
-      const skill = yield* Skill.Service
-      const original = info("review", "Initial")
-      yield* skill.transform((draft) => draft.add(original))
-      const updated = yield* skill.transform((draft) =>
-        draft.update("review", (value) => {
-          value.description = "Updated"
+          expect(yield* skill.sources()).toEqual([
+            { type: "directory", path: AbsolutePath.make(first) },
+            { type: "directory", path: AbsolutePath.make(second) },
+          ])
+          expect(yield* skill.list()).toEqual([
+            Skill.Info.make({
+              id: Skill.ID.make("foo"),
+              name: Skill.Name.make("foo"),
+              slash: true,
+              location: AbsolutePath.make(path.join(first, "foo.md")),
+              content: "# foo",
+            }),
+            {
+              id: Skill.ID.make("review"),
+              name: Skill.Name.make("review"),
+              description: "Second",
+              location: AbsolutePath.make(path.join(second, "review", "SKILL.md")),
+              content: "# review",
+            },
+          ])
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: first, type: "directory" },
+            { path: second, type: "directory" },
+          ])
+
+          yield* Effect.promise(() => write(second, "review", "Updated Second"))
+          yield* emitAndWait({ type: "update", path: path.join(second, "review", "SKILL.md") })
+
+          expect((yield* skill.list()).find((item) => item.id === "review")?.description).toBe("Updated Second")
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: first, type: "directory" },
+            { path: second, type: "directory" },
+            { path: first, type: "directory" },
+            { path: second, type: "directory" },
+          ])
         }),
-      )
-
-      expect((yield* skill.list())[0]?.description).toBe("Updated")
-      yield* updated.dispose
-      expect((yield* skill.list())[0]?.description).toBe("Initial")
-      expect(original.description).toBe("Initial")
-    }),
+      ),
+    ),
   )
 
-  it.live("publishes updates after committed values are visible", () =>
-    Effect.gen(function* () {
-      const skill = yield* Skill.Service
-      const bus = yield* Bus.Service
-      const updated = yield* Deferred.make<Skill.Info[]>()
-      const fiber = yield* bus.subscribe(Skill.Event.Updated).pipe(
-        Stream.runForEach(() => skill.list().pipe(Effect.flatMap((values) => Deferred.succeed(updated, values)))),
-        Effect.forkScoped,
-      )
-      yield* Effect.yieldNow
+  it.live("loads URL sources and filters skills for agents", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
+            await write(tmp.path, "deploy", "Deploy production")
+          })
+          pulls = 0
+          urls.set("https://example.test/skills/", [AbsolutePath.make(tmp.path)])
 
-      yield* skill.transform((draft) => draft.add(info("review", "Visible")))
-      expect(yield* Deferred.await(updated).pipe(Effect.timeout("1 second"))).toEqual([info("review", "Visible")])
-      yield* Fiber.interrupt(fiber)
-    }),
-  )
+          const agents = yield* Agent.Service
+          yield* agents.transform((editor) =>
+            editor.update(Agent.ID.make("reviewer"), (agent) => {
+              agent.permissions.push({ action: "skill", resource: "deploy", effect: "deny" })
+            }),
+          )
 
-  it.effect("filters values by agent permissions", () =>
-    Effect.gen(function* () {
-      const agents = yield* Agent.Service
-      yield* agents.transform((draft) =>
-        draft.update(Agent.ID.make("reviewer"), (agent) => {
-          agent.permissions.push({ action: "skill", resource: "deploy", effect: "deny" })
+          const skill = yield* Skill.Service
+          yield* skill.transform((editor) => editor.source({ type: "url", url: "https://example.test/skills/" }))
+
+          expect((yield* skill.list()).map((item) => item.name)).toEqual([Skill.Name.make("deploy")])
+          expect((yield* skill.list()).map((item) => item.name)).toEqual([Skill.Name.make("deploy")])
+          expect(pulls).toBe(1)
+          expect(Skill.available(yield* skill.list(), (yield* agents.get(Agent.ID.make("reviewer")))!)).toEqual([])
         }),
-      )
-      const agent = yield* agents.get(Agent.ID.make("reviewer"))
-      expect(Skill.available([info("deploy", "Deploy")], agent!)).toEqual([])
-    }),
+      ),
+    ),
+  )
+
+  it.live("parses opencode metadata flags from skill frontmatter", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(tmp.path, "manual"), { recursive: true })
+            await fs.writeFile(
+              path.join(tmp.path, "manual", "SKILL.md"),
+              `---
+name: manual
+description: Manual only
+metadata:
+  opencode/slash: true
+  opencode/autoinvoke: false
+---
+# manual`,
+            )
+          })
+
+          const skill = yield* Skill.Service
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
+
+          expect(yield* skill.list()).toEqual([
+            {
+              id: Skill.ID.make("manual"),
+              name: Skill.Name.make("manual"),
+              description: "Manual only",
+              slash: true,
+              autoinvoke: false,
+              location: AbsolutePath.make(path.join(tmp.path, "manual", "SKILL.md")),
+              content: "# manual",
+            },
+          ])
+        }),
+      ),
+    ),
+  )
+
+  it.live("clears cached skills when sources reload", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
+            await write(tmp.path, "deploy", "Initial deploy")
+          })
+
+          const skill = yield* Skill.Service
+          const watcher = yield* Watcher.Test
+          const bus = yield* Bus.Service
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
+          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Initial deploy")
+          expect(yield* watcher.subscriptions()).toEqual([{ path: tmp.path, type: "directory" }])
+
+          let refreshed: Skill.Info[] = []
+          const unsubscribe = yield* bus.listen((event) => {
+            if (event.type !== Skill.Event.Updated.type) return Effect.void
+            return skill.list().pipe(
+              Effect.tap((items) => Effect.sync(() => (refreshed = items))),
+              Effect.asVoid,
+            )
+          })
+
+          yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
+          yield* skill.reload().pipe(Effect.timeout("1 second"))
+          yield* unsubscribe
+
+          expect(refreshed.find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: tmp.path, type: "directory" },
+            { path: tmp.path, type: "directory" },
+          ])
+        }),
+      ),
+    ),
+  )
+
+  it.live("reloads project sources created after their missing parent", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const source = path.join(tmp.path, "generated", "skills")
+          const file = path.join(source, "deploy", "SKILL.md")
+          const skill = yield* Skill.Service
+          const watcher = yield* Watcher.Test
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
+          expect(yield* skill.list()).toEqual([])
+          expect(yield* watcher.subscriptions()).toEqual([{ path: path.join(tmp.path, "generated"), type: "file" }])
+
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "generated")))
+          yield* emitAndWait({ type: "create", path: path.join(tmp.path, "generated") })
+          expect(yield* skill.list()).toEqual([])
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: path.join(tmp.path, "generated"), type: "file" },
+            { path: source, type: "file" },
+          ])
+
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.dirname(file), { recursive: true })
+            await write(source, "deploy", "Deploy production")
+          })
+          yield* emitAndWait({ type: "create", path: source })
+
+          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: path.join(tmp.path, "generated"), type: "file" },
+            { path: source, type: "file" },
+            { path: source, type: "directory" },
+          ])
+        }),
+      ),
+    ),
+  )
+
+  it.live("watches directory sources for added and changed skills", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
+            await write(tmp.path, "deploy", "Initial deploy")
+          })
+
+          const skill = yield* Skill.Service
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
+          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
+          yield* expectSubscription((input) => input.type === "directory" && input.path === tmp.path)
+
+          const deploy = path.join(tmp.path, "deploy", "SKILL.md")
+          yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
+          yield* emitAndWait({ type: "update", path: deploy })
+          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
+
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(tmp.path, "review"), { recursive: true })
+            await write(tmp.path, "review", "Review changes")
+          })
+          const review = path.join(tmp.path, "review", "SKILL.md")
+          yield* emitAndWait({ type: "create", path: review })
+          expect((yield* skill.list()).map((item) => item.id)).toEqual([
+            Skill.ID.make("deploy"),
+            Skill.ID.make("review"),
+          ])
+
+          yield* Effect.promise(() => fs.rm(path.join(tmp.path, "review"), { recursive: true }))
+          yield* emitAndWait({ type: "delete", path: review })
+          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
+        }),
+      ),
+    ),
+  )
+
+  it.live("watches canonical directories behind symlinked skills", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const source = path.join(tmp.path, "source")
+          const target = path.join(tmp.path, "target", "bro")
+          const file = path.join(target, "SKILL.md")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(source, { recursive: true })
+            await fs.mkdir(target, { recursive: true })
+            await fs.writeFile(file, "---\nname: bro\ndescription: Initial\n---\n# bro")
+            await fs.symlink(target, path.join(source, "bro"))
+          })
+
+          const skill = yield* Skill.Service
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
+          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Initial")
+          yield* expectSubscription((input) => input.type === "directory" && input.path === target)
+
+          yield* Effect.promise(() => fs.writeFile(file, "---\nname: bro\ndescription: Updated\n---\n# bro"))
+          yield* emitAndWait({ type: "update", path: file })
+          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Updated")
+        }),
+      ),
+    ),
+  )
+
+  it.live("invalidates symlinked sources when their target changes", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const source = path.join(tmp.path, "source")
+          const first = path.join(tmp.path, "first")
+          const second = path.join(tmp.path, "second")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(path.join(first, "bro"), { recursive: true })
+            await fs.mkdir(path.join(second, "bro"), { recursive: true })
+            await write(first, "bro", "First")
+            await write(second, "bro", "Second")
+            await fs.symlink(first, source)
+          })
+
+          const skill = yield* Skill.Service
+          const watcher = yield* Watcher.Test
+          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
+          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("First")
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: first, type: "directory" },
+            { path: source, type: "file" },
+          ])
+
+          yield* Effect.promise(async () => {
+            await fs.unlink(source)
+            await fs.symlink(second, source)
+          })
+          yield* emitAndWait({ type: "update", path: source })
+
+          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Second")
+          expect(yield* watcher.subscriptions()).toEqual([
+            { path: first, type: "directory" },
+            { path: source, type: "file" },
+            { path: second, type: "directory" },
+            { path: source, type: "file" },
+          ])
+        }),
+      ),
+    ),
   )
 })

packages/core/test/tool-shell.test.ts

@@ -33,7 +33,6 @@ import { ShellTool } from "@opencode-ai/core/tool/plugin/shell"
 import { ToolOutput } from "@opencode-ai/core/tool-output"
 import { Tool } from "@opencode-ai/core/tool"
 import { tmpdir } from "./fixture/tmpdir"
-import { tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
 import { toolIdentity, executeTool, toolDefinitions, waitForTool } from "./lib/tool"
 
@@ -139,7 +138,6 @@ const layer = AppNodeBuilder.build(
   [
     [SessionExecution.node, executionNode],
     [Permission.node, permission],
-    [Global.node, tempGlobalLayer],
   ],
 )
 

packages/core/test/tool-skill.test.ts

@@ -81,6 +81,7 @@ describe("SkillTool", () => {
             Skill.Service.of({
               transform: (_transform) => Effect.die("unused"),
               reload: () => Effect.die("unused"),
+              sources: () => Effect.die("unused"),
               list: () => Effect.succeed(current),
             }),
           )

packages/core/test/tool-subagent.test.ts

@@ -4,7 +4,6 @@ import path from "path"
 import { Money } from "@opencode-ai/schema/money"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Global } from "@opencode-ai/util/global"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Database } from "@opencode-ai/core/database/database"
 import { Bus } from "@opencode-ai/core/bus"
@@ -27,7 +26,6 @@ import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { SubagentTool } from "@opencode-ai/core/tool/plugin/subagent"
 import { Tool } from "@opencode-ai/core/tool"
 import { tmpdir } from "./fixture/tmpdir"
-import { tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
 import { executeTool, toolIdentity, waitForTool } from "./lib/tool"
 
@@ -102,10 +100,7 @@ const layer = AppNodeBuilder.build(
     PluginRuntime.providerNode,
     LocationServiceMap.node,
   ]),
-  [
-    [SessionExecution.node, executionNode],
-    [Global.node, tempGlobalLayer],
-  ],
+  [[SessionExecution.node, executionNode]],
 )
 
 const it = testEffect(layer)

packages/core/test/v1-migration.test.ts

@@ -18,14 +18,9 @@ import { tmpdir } from "./fixture/tmpdir"
 import path from "path"
 
 const makeDb = EffectDrizzleSqlite.makeWithDefaults()
-const run = <A, E>(effect: Effect.Effect<A, E, SqlClient | Scope.Scope | Global.Service>) =>
+const run = <A, E>(effect: Effect.Effect<A, E, SqlClient | Scope.Scope>) =>
   Effect.runPromise(
-    Effect.scoped(
-      effect.pipe(
-        Effect.provideService(Global.Service, Global.make({ data: path.join(process.cwd(), ".test-data") })),
-        Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })),
-      ),
-    ),
+    Effect.scoped(effect.pipe(Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })))),
   )
 
 const session = (
@@ -777,7 +772,7 @@ describe("V1Migration database workflow", () => {
     `)
   })
 
-  const database = <A, E>(effect: Effect.Effect<A, E, Database.Service | Global.Service | Scope.Scope>) =>
+  const database = <A, E>(effect: Effect.Effect<A, E, Database.Service | Scope.Scope>) =>
     run(
       Effect.gen(function* () {
         const db = yield* makeDb
@@ -940,7 +935,6 @@ describe("V1Migration database workflow", () => {
     await database(
       Effect.gen(function* () {
         const { db } = yield* Database.Service
-        const global = yield* Global.Service
         yield* db.run(
           sql`INSERT INTO session (id, project_id, slug, directory, title, version, time_created, time_updated) VALUES ('ses_orphan', 'missing-project', 'orphan', '/tmp/orphan', 'Orphan', '1', 1, 2)`,
         )
@@ -950,7 +944,7 @@ describe("V1Migration database workflow", () => {
           project_id: "global",
         })
         expect(yield* db.get(sql`SELECT worktree FROM project WHERE id = 'global'`)).toEqual({
-          worktree: path.parse(global.data).root,
+          worktree: path.parse(Global.Path.data).root,
         })
         expect(yield* db.get(sql`SELECT value FROM kv WHERE key = 'migration.v1-v2'`)).toEqual({
           value: '{"phase":"completed"}',

packages/core/test/vcs-hg.test.ts

@@ -8,7 +8,6 @@ import { Bus } from "@opencode-ai/core/bus"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Vcs } from "@opencode-ai/core/vcs"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { VcsEvent } from "@opencode-ai/schema/vcs-event"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -42,7 +41,9 @@ const withTmp = <A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) =>
 
 const withHg = <A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) =>
   withTmp((directory) =>
-    Effect.promise(() => hg(directory, "init")).pipe(Effect.andThen(f(directory).pipe(provide(directory)))),
+    Effect.promise(() => hg(directory, "init")).pipe(
+      Effect.andThen(f(directory).pipe(provide(directory))),
+    ),
   )
 
 async function hg(directory: string, ...args: string[]) {
@@ -124,13 +125,7 @@ describeHg("Vcs mercurial", () => {
           .subscribe(VcsEvent.BranchUpdated)
           .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
         yield* Effect.promise(() => hg(directory, "branch", "-q", "feature"))
-        expect(yield* vcs.info()).toEqual({ branch: { current: "default", default: "default" } })
-
-        yield* bus.publish(FileSystem.Event.Changed, {
-          file: path.join(directory, ".hg", "branch"),
-          event: "change",
-        })
-        expect(yield* Fiber.join(updated)).toMatchObject({
+        expect(yield* Fiber.join(updated).pipe(Effect.timeout("5 seconds"))).toMatchObject({
           _tag: "Some",
           value: { location: { directory }, data: { branch: "feature" } },
         })

packages/core/test/vcs.test.ts

@@ -8,27 +8,66 @@ import { Bus } from "@opencode-ai/core/bus"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Vcs } from "@opencode-ai/core/vcs"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
+import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { VcsEvent } from "@opencode-ai/schema/vcs-event"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
 
+const describeNative = process.env.CI ? describe.skip : describe
+
+const locationLayer = (directory: string, git?: boolean) =>
+  Layer.succeed(
+    Location.Service,
+    Location.Service.of(
+      location(
+        { directory: AbsolutePath.make(directory) },
+        git ? { vcs: { type: "git", store: AbsolutePath.make(path.join(directory, ".git")) } } : {},
+      ),
+    ),
+  )
+
 const provide = (directory: string, input: { git?: boolean } = {}) =>
+  Effect.provide(
+    LayerNode.compile(LayerNode.group([Vcs.node, Bus.node]), [[Location.node, locationLayer(directory, input.git)]]),
+  )
+
+function fakeWatcher() {
+  const subscriptions: Watcher.WatchInput[] = []
+  const active = new Set<(update: Watcher.Update) => void>()
+  const native = Watcher.Native.of({
+    subscribe: (input) =>
+      Effect.sync(() => {
+        subscriptions.push(
+          input.type === "file"
+            ? { path: input.target, type: "file" }
+            : input.ignore.length > 0
+              ? { path: input.target, type: "directory", ignore: input.ignore }
+              : { path: input.target, type: "directory" },
+        )
+        active.add(input.publish)
+        return {
+          unsubscribe: () => {
+            active.delete(input.publish)
+            return Promise.resolve()
+          },
+        }
+      }),
+  })
+  return {
+    subscriptions: () => [...subscriptions],
+    emit: (update: Watcher.Update) => {
+      for (const publish of active) publish(update)
+    },
+    layer: Watcher.layer().pipe(Layer.provide(Layer.succeed(Watcher.Native, native))),
+  }
+}
+
+const provideFake = (directory: string, fake: ReturnType<typeof fakeWatcher>, git = true) =>
   Effect.provide(
     LayerNode.compile(LayerNode.group([Vcs.node, Bus.node]), [
-      [
-        Location.node,
-        Layer.succeed(
-          Location.Service,
-          Location.Service.of(
-            location(
-              { directory: AbsolutePath.make(directory) },
-              input.git ? { vcs: { type: "git", store: AbsolutePath.make(path.join(directory, ".git")) } } : {},
-            ),
-          ),
-        ),
-      ],
+      [Location.node, locationLayer(directory, git)],
+      [Watcher.node, fake.layer],
     ]),
   )
 
@@ -93,35 +132,84 @@ describe("Vcs", () => {
     ),
   )
 
-  it.live("caches branch info and publishes HEAD changes", () =>
-    withGit((directory) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(async () => {
-          await fs.writeFile(path.join(directory, "file.txt"), "one\n")
-          await commitAll(directory, "initial")
-        })
-        const vcs = yield* Vcs.Service
-        const bus = yield* Bus.Service
-        expect(yield* vcs.info()).toEqual({ branch: { current: "main", default: undefined } })
-
-        const updated = yield* bus
-          .subscribe(VcsEvent.BranchUpdated)
-          .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
-        yield* Effect.promise(() => $`git checkout -q -b feature`.cwd(directory).quiet())
-
-        yield* bus.publish(FileSystem.Event.Changed, { file: path.join(directory, "HEAD"), event: "change" })
-        expect(yield* vcs.info()).toEqual({ branch: { current: "main", default: undefined } })
-
-        yield* bus.publish(FileSystem.Event.Changed, { file: path.join(directory, ".git", "HEAD"), event: "change" })
-        expect(yield* Fiber.join(updated)).toMatchObject({
-          _tag: "Some",
-          value: { location: { directory }, data: { branch: "feature" } },
-        })
-        expect(yield* vcs.info()).toEqual({ branch: { current: "feature", default: "main" } })
-      }),
-    ),
+  it.live("watches git branch metadata", () =>
+    withTmp((directory) => {
+      const fake = fakeWatcher()
+      return Effect.promise(() => initRepo(directory)).pipe(
+        Effect.andThen(
+          Effect.gen(function* () {
+            yield* Vcs.Service
+            expect(fake.subscriptions()).toHaveLength(1)
+            const git = fake.subscriptions()[0]
+            if (git?.type !== "directory") throw new Error("expected a directory watch")
+            expect(git.path).toBe(path.join(directory, ".git"))
+            expect(git.ignore ?? []).not.toContain("HEAD")
+            expect(git.ignore ?? []).toContain("objects")
+          }).pipe(provideFake(directory, fake)),
+        ),
+      )
+    }),
   )
 
+  it.live("caches branch info and publishes HEAD changes", () =>
+    withTmp((directory) => {
+      const fake = fakeWatcher()
+      return Effect.promise(async () => {
+        await initRepo(directory)
+        await fs.writeFile(path.join(directory, "file.txt"), "one\n")
+        await commitAll(directory, "initial")
+      }).pipe(
+        Effect.andThen(
+          Effect.gen(function* () {
+            const vcs = yield* Vcs.Service
+            const bus = yield* Bus.Service
+            expect(yield* vcs.info()).toMatchObject({ branch: { current: "main" } })
+
+            const updated = yield* bus
+              .subscribe(VcsEvent.BranchUpdated)
+              .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
+            yield* Effect.promise(() => $`git checkout -q -b feature`.cwd(directory).quiet())
+            fake.emit({ type: "update", path: path.join(directory, ".git", "index.lock") })
+            expect(yield* vcs.info()).toMatchObject({ branch: { current: "main" } })
+
+            fake.emit({ type: "update", path: path.join(directory, ".git", "HEAD.lock") })
+            expect(yield* Fiber.join(updated)).toMatchObject({
+              _tag: "Some",
+              value: { location: { directory }, data: { branch: "feature" } },
+            })
+            expect(yield* vcs.info()).toMatchObject({ branch: { current: "feature" } })
+          }).pipe(provideFake(directory, fake)),
+        ),
+      )
+    }),
+  )
+
+  describeNative("native watches", () => {
+    it.live("publishes branch updates on git checkout", () =>
+      withGit((directory) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(async () => {
+            await fs.writeFile(path.join(directory, "file.txt"), "one\n")
+            await commitAll(directory, "initial")
+          })
+          const vcs = yield* Vcs.Service
+          const bus = yield* Bus.Service
+          expect(yield* vcs.info()).toMatchObject({ branch: { current: "main" } })
+          const updated = yield* bus
+            .subscribe(VcsEvent.BranchUpdated)
+            .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
+          yield* Effect.promise(() => $`git checkout -q -b feature`.cwd(directory).quiet())
+          expect(yield* Fiber.join(updated).pipe(Effect.timeout("5 seconds"))).toMatchObject({
+            _tag: "Some",
+            value: { data: { branch: "feature" } },
+          })
+          expect(yield* vcs.info()).toMatchObject({ branch: { current: "feature" } })
+        }),
+      ),
+      { timeout: 15_000 },
+    )
+  })
+
   it.live("diffs the working copy against HEAD with patches", () =>
     withGit((directory) =>
       Effect.gen(function* () {

packages/merman/src/markdown.ts

@@ -44,10 +44,6 @@ export interface MermaidMarkdownRendererOptions {
     muted?: ColorInput
     warning?: ColorInput
     background?: ColorInput
-    request?: ColorInput
-    response?: ColorInput
-    note?: ColorInput
-    noteBackground?: ColorInput
   }
 }
 
@@ -135,12 +131,12 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
             participant: color(colors.primary),
             lifeline: color(colors.muted),
             group: color(colors.secondary),
-            request: color(colors.request ?? colors.primary),
-            response: color(colors.response ?? colors.primary),
+            request: color(colors.primary),
+            response: color(colors.primary),
             fragment: color(colors.secondary),
             fragmentLabelBg: color(colors.background),
-            note: color(colors.note ?? colors.warning),
-            noteBg: color(colors.noteBackground ?? colors.background),
+            note: color(colors.warning),
+            noteBg: color(colors.background),
           }),
         ),
         height: size.height,

packages/merman/src/palette.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
 import { RGBA } from "@opentui/core"
-import { blendColor } from "./core/color/style.js"
 import { createOpenCodeDiagramPalette } from "./palette.js"
 
 type Rgb = readonly [number, number, number]
@@ -32,15 +31,11 @@ describe("OpenCode diagram palette", () => {
   }>)("derives a controlled neutral ladder for a $name", ({ text, subdued, secondary, muted }) => {
     const primary = rgb(text)
     const info = RGBA.fromInts(40, 120, 220)
-    const success = RGBA.fromInts(80, 180, 120)
-    const warning = RGBA.fromInts(220, 160, 80)
     const background = RGBA.fromInts(10, 20, 30)
     const palette = createOpenCodeDiagramPalette({
       text: primary,
       subdued: rgb(subdued),
       info,
-      success,
-      warning,
       background,
     })
 
@@ -50,9 +45,5 @@ describe("OpenCode diagram palette", () => {
     expect(palette.muted.equals(rgb(muted))).toBe(true)
     expect(palette.warning).toBe(info)
     expect(palette.background).toBe(background)
-    expect(palette.request).toBe(success)
-    expect(palette.response).toBe(warning)
-    expect(palette.note).toBe(primary)
-    expect(palette.noteBackground.equals(blendColor(background, rgb(subdued), 0.25))).toBe(true)
   })
 })

packages/merman/src/palette.ts

@@ -5,8 +5,6 @@ export interface OpenCodeDiagramPaletteInput {
   readonly text: RGBA
   readonly subdued: RGBA
   readonly info: RGBA
-  readonly success: RGBA
-  readonly warning: RGBA
   readonly background: RGBA
 }
 
@@ -18,9 +16,5 @@ export function createOpenCodeDiagramPalette(input: OpenCodeDiagramPaletteInput)
     muted: blendColor(input.text, input.subdued, 0.7),
     warning: input.info,
     background: input.background,
-    request: input.success,
-    response: input.warning,
-    note: input.text,
-    noteBackground: blendColor(input.background, input.subdued, 0.25),
   }
 }

packages/merman/src/plugin.ts

@@ -12,8 +12,6 @@ export default Plugin.define({
           text: context.theme.text.default,
           subdued: context.theme.text.subdued,
           info: context.theme.text.feedback.info.default,
-          success: context.theme.text.feedback.success.default,
-          warning: context.theme.text.feedback.warning.default,
           background: context.theme.background.default,
         }),
       })),

packages/merman/src/sequence/diagram.test.ts

@@ -51,15 +51,16 @@ sequenceDiagram
 `)
 
     expectDiagram(output).toEqualDiagram(`
-      Browser           Server
-      ───┬───           ───┬──
-         │                 │
-         │ GET /           │
-         ├─────────────────►
-         │                 │
-         │ 401 WWW-Auth    │
-         ◄─────────────────┤
-         │                 │
+      ╭─────────╮       ╭────────╮
+      │ Browser │       │ Server │
+      ╰────┬────╯       ╰────┬───╯
+           │                 │
+           │     GET /       │
+           ├─────────────────►
+           │                 │
+           │  401 WWW-Auth   │
+           ◄─────────────────┤
+           │                 │
     `)
   })
 
@@ -139,13 +140,13 @@ sequenceDiagram
 `)
 
     const lines = output.split("\n")
-    const browserCenter = lines[0]!.indexOf("w")
-    const serverCenter = lines[0]!.indexOf("v")
+    const browserCenter = lines[1]!.indexOf("w")
+    const serverCenter = lines[1]!.indexOf("v")
 
-    expect(lines[1]?.[browserCenter]).toBe("┬")
-    expect(lines[2]?.[browserCenter]).toBe("│")
-    expect(lines[1]?.[serverCenter]).toBe("┬")
-    expect(lines[2]?.[serverCenter]).toBe("│")
+    expect(lines[2]?.[browserCenter]).toBe("┬")
+    expect(lines[3]?.[browserCenter]).toBe("│")
+    expect(lines[2]?.[serverCenter]).toBe("┬")
+    expect(lines[3]?.[serverCenter]).toBe("│")
   })
 
   test("ramps participant frames into neutral lifelines", () => {
@@ -276,8 +277,8 @@ sequenceDiagram
   A->>B: hello`)
 
     expect(output).not.toContain("<br")
-    expect(output).toContain("First line")
-    expect(output).toContain("Second line")
+    expect(output).toContain("│ First line  │")
+    expect(output).toContain("│ Second line │")
   })
 
   test("parses Mermaid arrow head variants", () => {
@@ -313,27 +314,28 @@ sequenceDiagram
 `)
 
     expect(output).toMatchInlineSnapshot(`
-      " A                  B
-      ─┬─                ─┬─
-       │                  │
-       │ open solid       │
-       ├─────────────────>│
-       │                  │
-       │ open dashed      │
-       │<─────────────────┤
-       │                  │
-       │ failed solid     │
-       ├─────────────────✕│
-       │                  │
-       │ failed dashed    │
-       │✕─────────────────┤
-       │                  │
-       │ async solid      │
-       ├─────────────────)│
-       │                  │
-       │ async dashed     │
-       │(─────────────────┤
-       │                  │"
+      "╭───╮              ╭───╮
+      │ A │              │ B │
+      ╰─┬─╯              ╰─┬─╯
+        │                  │
+        │   open solid     │
+        ├─────────────────>│
+        │                  │
+        │   open dashed    │
+        │<─────────────────┤
+        │                  │
+        │  failed solid    │
+        ├─────────────────✕│
+        │                  │
+        │  failed dashed   │
+        │✕─────────────────┤
+        │                  │
+        │   async solid    │
+        ├─────────────────)│
+        │                  │
+        │  async dashed    │
+        │(─────────────────┤
+        │                  │"
     `)
   })
 
@@ -385,7 +387,7 @@ sequenceDiagram
   end
 `)
     const lines = output.split("\n")
-    const participantCenter = lines.find((line) => line.includes("  A"))!.indexOf("A")
+    const participantCenter = lines.find((line) => line.includes("│ A │"))!.indexOf("A")
     const fragmentStart = lines.find((line) => line.includes("alt: ok"))!.indexOf("╭")
 
     expect(fragmentStart).toBeLessThan(participantCenter)
@@ -555,7 +557,7 @@ sequenceDiagram
     const fragmentMessageRow = fragment.split("\n").find((line) => line.includes("this non adjacent message"))!
     expect(groupMessageRow.trimEnd().endsWith("│")).toBe(true)
     expect(fragmentMessageRow).toContain("this non adjacent message is deliberately much wider than the frame")
-    expect(fragmentMessageRow.match(/│/g)?.length).toBe(3)
+    expect(fragmentMessageRow.match(/│/g)?.length).toBe(2)
   })
 
   test("keeps long notes inside groups and nested fragment frames intact", () => {
@@ -598,7 +600,7 @@ sequenceDiagram
     const groupBorderRight = output.split("\n")[0]!.lastIndexOf("╮")
     const lines = output.split("\n")
     const externalLabelRow = lines.findIndex((line) => line.includes("External"))
-    const externalHeaderLeft = lines[externalLabelRow + 1]!.lastIndexOf("─")
+    const externalHeaderLeft = lines[externalLabelRow - 1]!.lastIndexOf("╭")
 
     expect(externalHeaderLeft).toBeGreaterThan(groupBorderRight)
   })
@@ -653,17 +655,18 @@ sequenceDiagram
 `)
 
     expect(output).toMatchInlineSnapshot(`
-      "                   ╭─ Backend ───────────────────────────────╮
-      Browser            │ API              Cache              DB  │
-      ───┬───            │ ─┬─              ──┬──              ─┬─ │
-         │               │  │                 │                 │  │
-         │ GET /users/42 │  │                 │                 │  │
-         ├──────────────────►                 │                 │  │
-         │               │  │                 │                 │  │
-         │               │  │ get user:42     │                 │  │
-         │               │  ├─────────────────►                 │  │
-         │               │  │                 │                 │  │
-                         ╰─────────────────────────────────────────╯"
+      "                   ╭─ Backend ──────────────────────────────────╮
+      ╭─────────╮        │ ╭─────╮          ╭───────╮          ╭────╮ │
+      │ Browser │        │ │ API │          │ Cache │          │ DB │ │
+      ╰────┬────╯        │ ╰──┬──╯          ╰───┬───╯          ╰──┬─╯ │
+           │             │    │                 │                 │   │
+           │  GET /users/42   │                 │                 │   │
+           ├──────────────────►                 │                 │   │
+           │             │    │                 │                 │   │
+           │             │    │  get user:42    │                 │   │
+           │             │    ├─────────────────►                 │   │
+           │             │    │                 │                 │   │
+                         ╰────────────────────────────────────────────╯"
     `)
   })
 
@@ -703,17 +706,18 @@ sequenceDiagram
 `)
 
     expect(output).toMatchInlineSnapshot(`
-      "Service
-      ───┬───
-         │
-         ├────────────────────╮
-         │ Check Permissions  │
-         ◄────────────────────╯
-         │"
+      "╭─────────╮
+      │ Service │
+      ╰────┬────╯
+           │
+           ├────────────────────╮
+           │ Check Permissions  │
+           ◄────────────────────╯
+           │"
     `)
   })
 
-  test("renders note badges in their reserved rows", () => {
+  test("frames notes in their reserved rows", () => {
     const output = renderSequenceDiagram(`
 sequenceDiagram
   Browser->>Server: one
@@ -725,9 +729,11 @@ sequenceDiagram
     const nextMessageRow = lines.findIndex((line) => line.includes("two"))
 
     expect(noteRow).toBeGreaterThan(0)
-    expect(lines[noteRow - 1]?.trim()).toBe("│                 │")
-    expect(lines[noteRow]).toContain(" phase ")
-    expect(lines[noteRow + 1]?.trim()).toBe("│                 │")
+    expect(lines[noteRow - 1]).toContain("╭")
+    expect(lines[noteRow - 1]).toContain("╮")
+    expect(lines[noteRow]).toContain("│ phase │")
+    expect(lines[noteRow + 1]).toContain("╰")
+    expect(lines[noteRow + 1]).toContain("╯")
     expect(nextMessageRow).toBe(noteRow + 2)
   })
 

packages/merman/src/sequence/drawing.ts

@@ -191,9 +191,29 @@ function renderSelfMessage(
 }
 
 function renderNote(grid: SequenceGrid, placement: Extract<SequenceStepPlacement, { type: "note" }>): void {
-  placement.textLines.forEach((line, index) =>
-    setText(grid, placement.textX, placement.textY + index, line, "noteBadge"),
-  )
+  const width = Math.max(...placement.textLines.map(diagramTextWidth))
+  const left = placement.textX
+  const right = left + width - 1
+  const top = placement.textY - 1
+  const bottom = placement.textY + placement.textLines.length
+
+  for (let x = left + 1; x < right; x++) {
+    setCell(grid, x, top, SEQUENCE_BORDER.horizontal, "note")
+    setCell(grid, x, bottom, SEQUENCE_BORDER.horizontal, "note")
+  }
+  for (let y = top + 1; y < bottom; y++) {
+    setCell(grid, left, y, SEQUENCE_BORDER.vertical, "note")
+    setCell(grid, right, y, SEQUENCE_BORDER.vertical, "note")
+  }
+  setCell(grid, left, top, SEQUENCE_BORDER.topLeft, "note")
+  setCell(grid, right, top, SEQUENCE_BORDER.topRight, "note")
+  setCell(grid, left, bottom, SEQUENCE_BORDER.bottomLeft, "note")
+  setCell(grid, right, bottom, SEQUENCE_BORDER.bottomRight, "note")
+  placement.textLines.forEach((line, index) => setText(grid, left, placement.textY + index, line, "noteBadge"))
+  for (let y = placement.textY; y < bottom; y++) {
+    setCell(grid, left, y, SEQUENCE_BORDER.vertical, "note")
+    setCell(grid, right, y, SEQUENCE_BORDER.vertical, "note")
+  }
 }
 
 export function drawSequenceDiagramGrid(
@@ -216,12 +236,22 @@ export function drawSequenceDiagramGrid(
         setText(grid, centeredStart(center, line), participantHeaderY + index, line, "participant"),
       )
     } else {
-      labelLines.forEach((line, index) =>
-        setText(grid, centeredStart(center, line), participantHeaderTopY + index, line, "participant"),
-      )
       for (let x = headerLeftX; x <= headerRightX; x++) {
+        setCell(grid, x, participantHeaderTopY, SEQUENCE_BORDER.horizontal, "participant")
         setCell(grid, x, participantRuleY, SEQUENCE_BORDER.horizontal, "participant")
       }
+
+      setCell(grid, headerLeftX, participantHeaderTopY, SEQUENCE_BORDER.topLeft, "participant")
+      setCell(grid, headerRightX, participantHeaderTopY, SEQUENCE_BORDER.topRight, "participant")
+      for (let y = participantHeaderY; y < participantRuleY; y++) {
+        setCell(grid, headerLeftX, y, SEQUENCE_BORDER.vertical, "participant")
+        setCell(grid, headerRightX, y, SEQUENCE_BORDER.vertical, "participant")
+      }
+      setCell(grid, headerLeftX, participantRuleY, SEQUENCE_BORDER.bottomLeft, "participant")
+      setCell(grid, headerRightX, participantRuleY, SEQUENCE_BORDER.bottomRight, "participant")
+      labelLines.forEach((line, index) =>
+        setText(grid, centeredStart(center, line), participantHeaderY + index, line, "participant"),
+      )
       setCell(grid, center, participantRuleY, SEQUENCE_BORDER.topT, "participant")
     }
 

packages/merman/src/sequence/placement.test.ts

@@ -206,7 +206,7 @@ ${Array.from(
     expect(explicit.activations).toEqual(shorthand.activations)
   })
 
-  test("left-aligns message label blocks inside their arrow span", () => {
+  test("centers message label blocks over their arrow span", () => {
     const plan = createSequencePlacementPlan(
       parseMermaidSequenceDiagram(`sequenceDiagram
   participant A
@@ -214,6 +214,8 @@ ${Array.from(
   A->>B: short<br/>a much longer line`),
     )
     const message = plan.steps.find((step) => step.type === "message")!
-    expect(message.labelX).toBe(message.leftX + 2)
+    const labelWidth = Math.max(...message.labelLines.map(diagramTextWidth))
+
+    expect(message.labelX * 2 + labelWidth).toBe(message.leftX + message.rightX)
   })
 })

packages/merman/src/sequence/placement.ts

@@ -142,7 +142,7 @@ function messageLabelText(message: SequenceMessage): string {
 
 function participantHeaderWidth(label: string, compact: boolean): number {
   const width = labelLinesWidth(mermaidLabelLines(label))
-  return compact ? width : Math.max(3, width)
+  return compact ? width : Math.max(5, width + 4)
 }
 
 function fragmentLabelText(fragment: SequenceFragment): string {
@@ -247,7 +247,7 @@ function getStepContentBounds(
     const leftX = Math.min(fromX, toX)
     const rightX = Math.max(fromX, toX)
     const labelWidth = messageWidth(step.message)
-    const labelLeftX = leftX + 2
+    const labelLeftX = Math.floor((leftX + rightX - labelWidth) / 2)
     return { leftX: Math.min(leftX, labelLeftX), rightX: Math.max(rightX, labelLeftX + labelWidth - 1) }
   }
   if (step.type !== "note") return undefined
@@ -525,8 +525,8 @@ export function createSequencePlacementPlan(
     ...diagram.participants.map((participant) => mermaidLabelLines(participant.label).length),
   )
   const participantHeaderTopY = hasGroups ? 1 : 0
-  const participantHeaderY = participantHeaderTopY
-  const participantRuleY = participantHeaderTopY + (compact ? participantLabelHeight - 1 : participantLabelHeight)
+  const participantHeaderY = participantHeaderTopY + (compact ? 0 : 1)
+  const participantRuleY = participantHeaderTopY + (compact ? participantLabelHeight - 1 : participantLabelHeight + 1)
   const lifelineStartY = participantRuleY + 1
   const stepStartY = lifelineStartY + 1
   const width = Math.max(contentBounds.rightX + 1, ...groups.map((group) => group.rightX + 1), fragments.rightX + 1)
@@ -650,7 +650,7 @@ export function createSequencePlacementPlan(
       const inlineLabel = inlineMessageLabel(step.message, labelLines, fromX, toX, compact)
       const arrowY = inlineLabel ? stepY : stepY + labelLines.length
       const renderedLabelWidth = inlineLabel ? visualLength(inlineLabel) : labelLinesWidth(labelLines)
-      const labelX = inlineLabel ? Math.floor((leftX + rightX - renderedLabelWidth) / 2) : leftX + 2
+      const labelX = Math.floor((leftX + rightX - renderedLabelWidth) / 2)
       steps.push({
         type: "message",
         message: step.message,

packages/plugin/src/effect/skill.ts

@@ -1,13 +1,11 @@
 import type { SkillApi } from "@opencode-ai/client/effect/api"
 import { Skill } from "@opencode-ai/schema/skill"
-import type { Effect, Types } from "effect"
+import type { Effect } from "effect"
 import type { Transform } from "./registration.js"
 
 export interface SkillDraft {
-  list(): readonly Types.DeepMutable<Skill.Info>[]
-  add(skill: Skill.Info): void
-  update(id: string, update: (skill: Types.DeepMutable<Skill.Info>) => void): void
-  remove(id: string): void
+  source(source: Skill.Source): void
+  list(): readonly Skill.Source[]
 }
 
 export interface SkillDomain extends SkillApi<unknown> {

packages/plugin/src/promise/skill.ts

@@ -1,13 +1,10 @@
 import type { SkillApi } from "@opencode-ai/client/promise/api"
 import type { Skill } from "@opencode-ai/schema/skill"
 import type { Transform } from "./registration.js"
-import type { DeepMutable } from "./types.js"
 
 export interface SkillDraft {
-  list(): readonly DeepMutable<Skill.Info>[]
-  add(skill: Skill.Info): void
-  update(id: string, update: (skill: DeepMutable<Skill.Info>) => void): void
-  remove(id: string): void
+  source(source: Skill.Source): void
+  list(): readonly Skill.Source[]
 }
 
 export interface SkillDomain extends SkillApi {

packages/protocol/src/groups/session.ts

@@ -341,6 +341,8 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           id: SessionMessage.ID.pipe(Schema.optional),
           command: Schema.String,
           arguments: Schema.String.pipe(Schema.optional),
+          agent: Agent.ID.pipe(Schema.optional),
+          model: Model.Ref.pipe(Schema.optional),
           files: PromptInput.Prompt.fields.files,
           agents: PromptInput.Prompt.fields.agents,
           skills: PromptInput.Prompt.fields.skills,

packages/server/src/handlers/session.ts

@@ -355,6 +355,8 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
                 id: ctx.payload.id,
                 command: ctx.payload.command,
                 arguments: ctx.payload.arguments,
+                agent: ctx.payload.agent,
+                model: ctx.payload.model,
                 files: ctx.payload.files,
                 agents: ctx.payload.agents,
                 skills: ctx.payload.skills,

packages/server/src/routes.ts

@@ -46,7 +46,6 @@ import type { ServerOptions } from "./options"
 import { modalWorkspaceDriver, provider as modalProvider } from "./workspace/modal-workspace"
 
 const applicationServices = LayerNode.group([
-  Global.node,
   Database.node,
   Bus.node,
   EventLogger.node,

packages/tui/src/app.tsx

@@ -72,7 +72,7 @@ import { DialogOpen } from "./component/dialog-open"
 import { SessionTabs } from "./component/session-tabs"
 import { sessionTabsFitVertically } from "./ui/layout"
 import { ThemeErrorToast } from "./component/theme-error-toast"
-import { createThemeSource, ThemeProvider, useTheme, useThemes } from "./context/theme"
+import { ThemeProvider, useTheme, useThemes } from "./context/theme"
 import { Home } from "./routes/home"
 import { Session } from "./routes/session"
 import { PromptHistoryProvider } from "./prompt/history"
@@ -372,10 +372,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                                 <DataProvider>
                                                   <LocationProvider>
                                                     <SessionTabsProvider>
-                                                      <ThemeProvider
-                                                        mode={mode}
-                                                        source={createThemeSource(global.config)}
-                                                      >
+                                                      <ThemeProvider mode={mode}>
                                                         <ThemeErrorToast />
                                                         <LocalProvider>
                                                           <PromptStashProvider>

packages/tui/src/component/prompt/index.tsx

@@ -1149,23 +1149,15 @@ export function Prompt(props: PromptProps) {
     } else if (slashHead && isCommand) {
       move.startSubmit()
       const model = { providerID: selection.providerID, id: selection.modelID, variant }
-      if (session?.agent !== agent.id) await client.api.session.switchAgent({ sessionID, agent: agent.id })
       const cancelCommit = local.model.trackSessionCommit(sessionID, model)
-      if (
-        session?.model?.providerID !== model.providerID ||
-        session.model.id !== model.id ||
-        (session.model.variant ?? "default") !== (model.variant ?? "default")
-      )
-        await client.api.session.switchModel({ sessionID, model }).catch((error) => {
-          cancelCommit()
-          throw error
-        })
 
       void client.api.session
         .command({
           sessionID,
           command: slashHead.name,
           arguments: slashHead.arguments,
+          agent: agent.id,
+          model,
           files: store.prompt.files,
           agents: store.prompt.agents,
           skills: store.prompt.skills?.length ? store.prompt.skills : undefined,

packages/tui/src/context/theme.tsx

@@ -28,6 +28,7 @@ import { createEffect, createMemo, onCleanup, onMount, type Accessor, type Paren
 import { createStore, produce } from "solid-js/store"
 import { createSimpleContext } from "./helper"
 import { useConfig } from "../config"
+import { Global } from "@opencode-ai/util/global"
 import { DevTools } from "../devtools"
 import { configDirectories } from "../util/config-directories"
 
@@ -68,15 +69,15 @@ export type ThemeSource = Readonly<{
   subscribeRefresh?(refresh: () => void): () => void
 }>
 
-export const createThemeSource = (config: string): ThemeSource => ({
+const themeSource: ThemeSource = {
   async discover() {
-    return discoverThemes(configDirectories(config, process.cwd()))
+    return discoverThemes(configDirectories(Global.Path.config, process.cwd()))
   },
   subscribeRefresh(refresh) {
     process.on("SIGUSR2", refresh)
     return () => process.off("SIGUSR2", refresh)
   },
-})
+}
 
 export { discoverThemes } from "../theme/discovery"
 
@@ -138,11 +139,11 @@ subscribeThemes((themes) => setStore("themes", themes))
 
 const themeContext = createSimpleContext({
   name: "Theme",
-  init: (props: { mode: "dark" | "light"; source: ThemeSource }): ThemeContextValue => {
+  init: (props: { mode: "dark" | "light"; source?: ThemeSource }): ThemeContextValue => {
     const renderer = useRenderer()
     const configState = useConfig()
     const config = configState.data
-    const themes = props.source
+    const themes = props.source ?? themeSource
     const pick = (value: unknown) => {
       if (value === "dark" || value === "light") return value
       return

packages/tui/src/mini/stream-v2.transport.ts

@@ -1653,6 +1653,8 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       )
     }
 
+    const selected = await resolveSelectedModel(input, client, next)
+    if (next.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
     input.trace?.write("send.command", { sessionID: input.sessionID, messageID, command: command.name, delivery })
     return client.session.command(
       {
@@ -1660,6 +1662,8 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         id: messageID,
         command: command.name,
         arguments: command.arguments,
+        agent: next.agent,
+        model: selected,
         files: attachments.files.length ? attachments.files : undefined,
         agents: agents.length ? agents : undefined,
         skills: skills.length ? skills : undefined,
@@ -1702,10 +1706,12 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       const client = sdk
       if (next.agent)
         await client.session.switchAgent({ sessionID: input.sessionID, agent: next.agent }, { signal: next.signal })
-      const selected = await resolveSelectedModel(input, client, next)
-      if (next.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
-      if (selected)
-        await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
+      if (!next.prompt.command) {
+        const selected = await resolveSelectedModel(input, client, next)
+        if (next.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
+        if (selected)
+          await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
+      }
       mergePending(await admitPrompt(next, client, delivery))
       settlementClient = client
     },
@@ -1744,12 +1750,6 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         return
       }
       if (command) {
-        if (next.agent)
-          await client.session.switchAgent({ sessionID: input.sessionID, agent: next.agent }, { signal: next.signal })
-        const selected = await resolveSelectedModel(input, client, next)
-        if (next.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
-        if (selected)
-          await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
         await runTurnWait(
           next,
           messageID,

packages/tui/src/routes/session/index.tsx

@@ -5,7 +5,6 @@ import {
   createMemo,
   createSignal,
   For,
-  Index,
   Match,
   on,
   onCleanup,
@@ -13,7 +12,6 @@ import {
   Show,
   Switch,
   useContext,
-  type Accessor,
 } from "solid-js"
 import path from "node:path"
 import { EOL, tmpdir } from "node:os"
@@ -3021,63 +3019,6 @@ function executeCalls(value: unknown): ExecuteCall[] {
   })
 }
 
-export function executeCallSummary(call: ExecuteCall) {
-  const args = primitiveInputSummary(call.input ?? {}).replace(/\s+/g, " ")
-  return `↳ ${call.tool}${call.status === "error" ? " (failed)" : ""}${args ? ` ${args}` : ""}`
-}
-
-function ExecuteCallView(props: { call: Accessor<ExecuteCall> }) {
-  const theme = useTheme()
-  const renderer = useRenderer()
-  const [expanded, setExpanded] = createSignal(false)
-  const [hover, setHover] = createSignal(false)
-  const input = createMemo(() => Object.entries(props.call().input ?? {}))
-  const expandable = createMemo(() => input().length > 0)
-  const title = createMemo(() => `↳ ${props.call().tool}${props.call().status === "error" ? " (failed)" : ""}`)
-
-  return (
-    <box
-      paddingLeft={3 + INLINE_TOOL_ICON_WIDTH}
-      onMouseOver={() => expandable() && setHover(true)}
-      onMouseOut={() => setHover(false)}
-      onMouseUp={() => {
-        if (!expandable() || renderer.getSelection()?.getSelectedText()) return
-        setExpanded((value) => !value)
-      }}
-    >
-      <text
-        wrapMode="none"
-        truncate
-        fg={
-          props.call().status === "error"
-            ? theme.text.feedback.error.default
-            : hover()
-              ? theme.text.default
-              : theme.text.subdued
-        }
-      >
-        {expanded() ? title() : executeCallSummary(props.call())}
-      </text>
-      <Show when={expanded()}>
-        <box paddingLeft={2}>
-          <For each={input()}>
-            {([key, value]) => (
-              <box flexDirection="row">
-                <text flexShrink={0} fg={theme.text.subdued}>
-                  {key}:{" "}
-                </text>
-                <text flexGrow={1} wrapMode="word" fg={theme.text.default}>
-                  {typeof value === "string" ? value : JSON.stringify(value, null, 2)}
-                </text>
-              </box>
-            )}
-          </For>
-        </box>
-      </Show>
-    </box>
-  )
-}
-
 // The `execute` tool streams child tool calls through metadata, not a child session like Task.
 function Execute(props: ToolProps) {
   const ctx = use()
@@ -3088,6 +3029,14 @@ function Execute(props: ToolProps) {
   const hasRuntimeError = createMemo(() => props.metadata.error === true || props.part.state.status === "error")
   const outputPreview = createMemo(() => collapseToolOutput(output(), 4, 4 * Math.max(20, ctx.width - 6)).output)
   const showOutput = createMemo(() => output() && hasRuntimeError())
+  const content = createMemo(() => {
+    const lines = ["execute"]
+    for (const call of calls()) {
+      const args = primitiveInputSummary(call.input ?? {})
+      lines.push(`↳ ${call.tool}${args ? ` ${args}` : ""}${call.status === "error" ? " (failed)" : ""}`)
+    }
+    return lines.join("\n")
+  })
 
   return (
     <>
@@ -3099,9 +3048,8 @@ function Execute(props: ToolProps) {
         complete={true}
         part={props.part}
       >
-        execute
+        {content()}
       </InlineTool>
-      <Index each={calls()}>{(call) => <ExecuteCallView call={call} />}</Index>
       <Show when={showOutput()}>
         <box paddingLeft={3}>
           <For each={outputPreview().split("\n")}>

packages/tui/test/cli/tui/command-palette.test.tsx

@@ -10,7 +10,6 @@ import { ThemeProvider } from "../../../src/context/theme"
 import { DialogProvider, useDialog } from "../../../src/ui/dialog"
 import { ToastProvider } from "../../../src/ui/toast"
 import { TestTuiContexts } from "../../fixture/tui-environment"
-import { emptyThemeSource } from "../../fixture/fixture"
 
 test("searches settings globally and opens the matching setting", async () => {
   let current: Info = {}
@@ -54,7 +53,7 @@ test("searches settings globally and opens the matching setting", async () => {
       <TestTuiContexts>
         <ConfigProvider config={resolve(current, { terminalSuspend: true })} service={service}>
           <Keymap.Provider>
-            <ThemeProvider mode="dark" source={emptyThemeSource}>
+            <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
               <ToastProvider>
                 <DialogProvider>
                   <Fixture />

packages/tui/test/cli/tui/data.test.tsx

@@ -16,7 +16,6 @@ import { ThemeProvider } from "../../../src/context/theme"
 import { Composer } from "../../../src/routes/session/composer"
 import { createSessionRows, type SessionRow } from "../../../src/routes/session/rows"
 import { createApi, createEventStream, createFetch, directory, json, worktree } from "../../fixture/tui-client"
-import { emptyThemeSource } from "../../fixture/fixture"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 
@@ -1980,7 +1979,7 @@ test("keeps shell state scoped to location", async () => {
     return (
       <RouteProvider initialRoute={{ type: "session", sessionID: "ses_shared" }}>
         <Keymap.Provider>
-          <ThemeProvider mode="dark" source={emptyThemeSource}>
+          <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
             <Composer sessionID="ses_shared" open={true} defaultTab="shell" />
           </ThemeProvider>
         </Keymap.Provider>

packages/tui/test/cli/tui/dialog-open.test.tsx

@@ -16,7 +16,6 @@ import { ThemeProvider } from "../../../src/context/theme"
 import { DialogProvider, useDialog } from "../../../src/ui/dialog"
 import { ToastProvider } from "../../../src/ui/toast"
 import { createApi, createEventStream, createFetch, json, type FetchHandler } from "../../fixture/tui-client"
-import { emptyThemeSource } from "../../fixture/fixture"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
@@ -227,7 +226,7 @@ async function renderOpen(
                       <DataProvider>
                         <LocationProvider>
                           <SessionTabsProvider>
-                            <ThemeProvider mode="dark" source={emptyThemeSource}>
+                            <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
                               <DialogProvider>
                                 <Probe />
                               </DialogProvider>

packages/tui/test/cli/tui/dialog-prompt.test.tsx

@@ -5,7 +5,7 @@ import { expect, test } from "bun:test"
 import { mkdir } from "node:fs/promises"
 import path from "node:path"
 import { onCleanup } from "solid-js"
-import { emptyThemeSource, tmpdir } from "../../fixture/fixture"
+import { tmpdir } from "../../fixture/fixture"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import type { TuiKeybind } from "../../../src/config/keybind"
 import { TestTuiContexts } from "../../fixture/tui-environment"
@@ -58,7 +58,7 @@ async function mountPrompt(input: {
       >
         <ConfigProvider config={resolvedConfig}>
           <Keymap.Provider>
-            <ThemeProvider mode="dark" source={emptyThemeSource}>
+            <ThemeProvider mode="dark">
               <ToastProvider>
                 <DialogProvider>
                   <Prompt />

packages/tui/test/cli/tui/dialog-select.test.tsx

@@ -9,7 +9,7 @@ import { dialogWidth } from "../../../src/ui/dialog"
 import { dialogSelectContentWidth, type DialogSelectOption } from "../../../src/ui/dialog-select"
 import { truncateFilePath } from "../../../src/ui/file-path"
 import { stringWidth } from "../../../src/util/string-width"
-import { emptyThemeSource, tmpdir } from "../../fixture/fixture"
+import { tmpdir } from "../../fixture/fixture"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 
@@ -62,7 +62,7 @@ async function renderSelect(
       <TestTuiContexts directory={root} paths={{ home: root, state, worktree: root }}>
         <ConfigProvider config={config}>
           <Keymap.Provider>
-            <ThemeProvider mode="dark" source={emptyThemeSource}>
+            <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
               <ToastProvider>
                 <DialogProvider>
                   <Select />
@@ -138,7 +138,7 @@ async function mountSelect(
       <TestTuiContexts directory={root} paths={{ home: root, state, worktree: root }}>
         <ConfigProvider config={config}>
           <Keymap.Provider>
-            <ThemeProvider mode="dark" source={emptyThemeSource}>
+            <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
               <ToastProvider>
                 <DialogProvider>
                   <Fixture />

packages/tui/test/cli/tui/diff-viewer-file-tree.test.tsx

@@ -4,7 +4,6 @@ import { testRender } from "@opentui/solid"
 import type { JSX } from "solid-js"
 import { onMount, type ParentProps } from "solid-js"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { emptyThemeSource } from "../../fixture/fixture"
 import { ThemeProvider, useThemes } from "../../../src/context/theme"
 import type { Plugin } from "@opencode-ai/plugin/tui"
 import { ConfigProvider } from "../../../src/config"
@@ -150,7 +149,7 @@ function withTheme(component: () => JSX.Element, onReady = () => {}) {
   return (
     <TestTuiContexts>
       <ConfigProvider config={createTuiResolvedConfig()}>
-        <ThemeProvider mode="dark" source={emptyThemeSource}>
+        <ThemeProvider mode="dark">
           <Ready onReady={onReady}>{component()}</Ready>
         </ThemeProvider>
       </ConfigProvider>

packages/tui/test/cli/tui/diff-viewer.test.tsx

@@ -12,7 +12,6 @@ import type {
   Slot,
 } from "@opencode-ai/plugin/tui/context"
 import { ThemeProvider, useThemes } from "../../../src/context/theme"
-import { emptyThemeSource } from "../../fixture/fixture"
 import { ConfigProvider } from "../../../src/config"
 import { TuiKeybind } from "../../../src/config/keybind"
 import { Keymap } from "../../../src/context/keymap"
@@ -225,7 +224,7 @@ async function renderDiffViewer(vcsDiff: unknown[], height = 20, initialRoute?:
         <ConfigProvider config={config}>
           <Keymap.Provider>
             <ToastProvider>
-              <ThemeProvider mode="dark" source={emptyThemeSource}>
+              <ThemeProvider mode="dark">
                 <DialogProvider>
                   <Content />
                 </DialogProvider>

packages/tui/test/cli/tui/form.test.tsx

@@ -10,7 +10,7 @@ import { ThemeProvider } from "../../../src/context/theme"
 import { Keymap } from "../../../src/context/keymap"
 import { ConfigProvider } from "../../../src/config"
 import { ToastProvider } from "../../../src/ui/toast"
-import { emptyThemeSource, tmpdir } from "../../fixture/fixture"
+import { tmpdir } from "../../fixture/fixture"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import { createApi, createEventStream, createFetch } from "../../fixture/tui-client"
@@ -72,7 +72,7 @@ async function mountForm(root: string, width = 80) {
           <ConfigProvider config={config}>
             <Keymap.Provider>
               <ClientProvider api={createApi(transport.fetch)}>
-                <ThemeProvider mode="dark" source={emptyThemeSource}>
+                <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
                   <ToastProvider>
                     <FormPrompt form={form} />
                   </ToastProvider>

packages/tui/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -3,7 +3,6 @@ import { For } from "solid-js"
 import { testRender, type JSX } from "@opentui/solid"
 import {
   InlineToolRow,
-  executeCallSummary,
   isBackgroundSubagent,
   parseApplyPatchFiles,
   parseDiagnostics,
@@ -183,22 +182,6 @@ describe("TUI inline tool wrapping", () => {
     expect(parseQuestionAnswers({})).toBeUndefined()
   })
 
-  test("summarizes execute calls on one line", () => {
-    expect(
-      executeCallSummary({
-        tool: "session.prompt",
-        status: "completed",
-        input: { sessionID: "ses_example", notify: true },
-      }),
-    ).toBe("↳ session.prompt [sessionID=ses_example, notify=true]")
-    expect(executeCallSummary({ tool: "session.get", status: "error", input: { nested: { hidden: true } } })).toBe(
-      "↳ session.get (failed)",
-    )
-    expect(
-      executeCallSummary({ tool: "session.prompt", status: "completed", input: { text: "first line\nsecond line" } }),
-    ).toBe("↳ session.prompt [text=first line second line]")
-  })
-
   test("ignores diagnostics with malformed nested ranges", () => {
     expect(
       parseDiagnostics(

packages/tui/test/fixture/fixture.ts

@@ -1,9 +1,6 @@
 import { mkdtemp, realpath, rm } from "node:fs/promises"
 import path from "node:path"
 import os from "node:os"
-import type { ThemeSource } from "../../src/context/theme"
-
-export const emptyThemeSource: ThemeSource = { discover: () => Promise.resolve({}) }
 
 export async function tmpdir() {
   const directory = await realpath(await mkdtemp(path.join(os.tmpdir(), "opencode-tui-test-")))

packages/tui/test/mini/stream-v2.transport.test.ts

@@ -2855,6 +2855,8 @@ describe("V2 mini transport", () => {
       id: "msg_cmd",
       command: "deploy",
       arguments: "prod",
+      agent: "build",
+      model: { providerID: "test", id: "model" },
       files: [
         { uri: "file:///tmp/context.txt", name: "context.txt" },
         {
@@ -2866,11 +2868,9 @@ describe("V2 mini transport", () => {
       skills: [{ id: "api-design", mention: { start: 13, end: 24, text: "/api-design" } }],
       delivery: "steer",
     })
-    expect(client.session.switchAgent).toHaveBeenCalledWith({ sessionID: "ses_1", agent: "build" }, expect.anything())
-    expect(client.session.switchModel).toHaveBeenCalledWith(
-      { sessionID: "ses_1", model: { providerID: "test", id: "model" } },
-      expect.anything(),
-    )
+    // Selection rides the command payload; no separate client-side switch.
+    expect(client.session.switchAgent).not.toHaveBeenCalled()
+    expect(client.session.switchModel).not.toHaveBeenCalled()
     await transport.close()
   })
 

packages/util/src/global.ts

@@ -1,5 +1,5 @@
 import path from "path"
-import fs from "fs"
+import fs from "fs/promises"
 import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
 import os from "os"
 import { Context, Effect, Layer } from "effect"
@@ -13,6 +13,8 @@ const config = path.join(xdgConfig!, app)
 const state = path.join(xdgState!, app)
 const tmp = path.join(os.tmpdir(), app)
 
+await fs.mkdir(tmp, { recursive: true })
+
 const paths = {
   get home() {
     return process.env.OPENCODE_TEST_HOME ?? os.homedir()
@@ -24,13 +26,22 @@ const paths = {
   cache,
   config,
   state,
-  tmp,
+  tmp: await fs.realpath(tmp),
 }
 
 export const Path = paths
 
 Flock.setGlobal({ state })
 
+await Promise.all([
+  fs.mkdir(Path.data, { recursive: true }),
+  fs.mkdir(Path.config, { recursive: true }),
+  fs.mkdir(Path.state, { recursive: true }),
+  fs.mkdir(Path.log, { recursive: true }),
+  fs.mkdir(Path.bin, { recursive: true }),
+  fs.mkdir(Path.repos, { recursive: true }),
+])
+
 export class Service extends Context.Service<Service, Interface>()("@opencode/Global") {}
 
 export interface Interface {
@@ -46,14 +57,13 @@ export interface Interface {
 }
 
 export function make(input: Partial<Interface> = {}): Interface {
-  // The acquired service canonicalizes default tmp; use it instead of Path.tmp for path comparisons.
   return {
     home: Path.home,
     data: Path.data,
     cache: Path.cache,
     config: Path.config,
     state: Path.state,
-    tmp: input.tmp ?? Path.tmp,
+    tmp: Path.tmp,
     bin: Path.bin,
     log: Path.log,
     repos: Path.repos,
@@ -61,27 +71,17 @@ export function make(input: Partial<Interface> = {}): Interface {
   }
 }
 
-const acquire = (input: Partial<Interface>) =>
-  Effect.gen(function* () {
-    const service = Service.of(make(input))
-    yield* Effect.promise(() =>
-      Promise.all(
-        [service.data, service.config, service.state, service.log, service.bin, service.repos, service.tmp].map(
-          (directory) => fs.promises.mkdir(directory, { recursive: true }),
-        ),
-      ),
-    )
-    const canonicalTmp = yield* Effect.promise(() => fs.promises.realpath(service.tmp))
-    return Service.of({ ...service, tmp: input.tmp ?? canonicalTmp })
-  })
-
 const layer = Layer.effect(
   Service,
-  Effect.suspend(() => acquire({ config: process.env.OPENCODE_CONFIG_DIR ?? Path.config })),
+  Effect.sync(() => Service.of(make({ config: process.env.OPENCODE_CONFIG_DIR ?? Path.config }))),
 )
 
 export const node = makeGlobalNode({ service: Service, layer: layer, deps: [] })
 
-export const layerWith = (input: Partial<Interface>) => Layer.effect(Service, acquire(input))
+export const layerWith = (input: Partial<Interface>) =>
+  Layer.effect(
+    Service,
+    Effect.sync(() => Service.of(make(input))),
+  )
 
 export * as Global from "./global.js"

packages/util/src/observability/logging.ts

@@ -1,4 +1,4 @@
-import { Effect, FileSystem, Formatter, Logger, type LogLevel } from "effect"
+import { Formatter, Logger, type LogLevel } from "effect"
 import path from "path"
 import { Global } from "../global.js"
 import { runID } from "./shared.js"
@@ -53,11 +53,7 @@ export function file(local = true, channel = "local") {
 
 export function fileLogger(target = file(), id: string = runID) {
   // Do not set batchWindow to 0; it causes high idle CPU usage.
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    yield* fs.makeDirectory(path.dirname(target), { recursive: true })
-    return yield* Logger.toFile(formatter(id), target, { flag: "a" })
-  })
+  return Logger.toFile(formatter(id), target, { flag: "a" })
 }
 
 const stderrLogger = Logger.make((options) => process.stderr.write(formatter().log(options) + "\n"))

packages/util/test/global.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs"
-import os from "os"
-import path from "path"
-import { pathToFileURL } from "url"
-import { Context, Effect, Layer } from "effect"
-import { Global } from "../src/global.js"
-
-describe("global", () => {
-  test("importing the module does not create directories", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-global-import-"))
-    const directories = ["data", "cache", "config", "state", "tmp"].map((directory) => path.join(root, directory))
-    const module = pathToFileURL(path.join(import.meta.dir, "../src/global.ts")).href
-    const result = Bun.spawnSync({
-      cmd: [process.execPath, "-e", `const { Global } = await import(${JSON.stringify(module)}); void Global.Path.tmp`],
-      env: {
-        ...process.env,
-        XDG_DATA_HOME: directories[0],
-        XDG_CACHE_HOME: directories[1],
-        XDG_CONFIG_HOME: directories[2],
-        XDG_STATE_HOME: directories[3],
-        TMPDIR: directories[4],
-      },
-      stderr: "pipe",
-    })
-
-    expect(result.exitCode, result.stderr.toString()).toBe(0)
-    directories.forEach((directory) => expect(fs.existsSync(path.join(directory, "opencode"))).toBe(false))
-    fs.rmSync(root, { recursive: true, force: true })
-  })
-
-  test("building layerWith creates service directories and preserves an explicit tmp", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-global-layer-"))
-    const directories = {
-      data: path.join(root, "data"),
-      config: path.join(root, "config"),
-      state: path.join(root, "state"),
-      log: path.join(root, "log"),
-      bin: path.join(root, "bin"),
-      repos: path.join(root, "repos"),
-      tmp: path.join(root, "nested", "..", "tmp"),
-    }
-
-    const context = await Effect.runPromise(Effect.scoped(Layer.build(Global.layerWith(directories))))
-
-    Object.values(directories).forEach((directory) => expect(fs.statSync(directory).isDirectory()).toBe(true))
-    expect(Context.get(context, Global.Service).tmp).toBe(directories.tmp)
-    fs.rmSync(root, { recursive: true, force: true })
-  })
-
-  test("building a layer with default tmp creates and canonicalizes it", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-global-layer-"))
-    const directories = ["data", "cache", "config", "state", "tmp"].map((directory) => path.join(root, directory))
-    const module = pathToFileURL(path.join(import.meta.dir, "../src/global.ts")).href
-    const result = Bun.spawnSync({
-      cmd: [
-        process.execPath,
-        "-e",
-        `
-          import { Context, Effect, Layer } from "effect"
-          const { Global } = await import(${JSON.stringify(module)})
-          const context = await Effect.runPromise(Effect.scoped(Layer.build(Global.layerWith({}))))
-          process.stdout.write(Context.get(context, Global.Service).tmp)
-        `,
-      ],
-      cwd: path.join(import.meta.dir, ".."),
-      env: {
-        ...process.env,
-        XDG_DATA_HOME: directories[0],
-        XDG_CACHE_HOME: directories[1],
-        XDG_CONFIG_HOME: directories[2],
-        XDG_STATE_HOME: directories[3],
-        TMPDIR: directories[4],
-      },
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    expect(result.exitCode, result.stderr.toString()).toBe(0)
-    expect(result.stdout.toString()).toBe(fs.realpathSync(path.join(directories[4], "opencode")))
-    const created = [
-      path.join(directories[0], "opencode"),
-      path.join(directories[1], "opencode", "bin"),
-      path.join(directories[2], "opencode"),
-      path.join(directories[3], "opencode"),
-      path.join(directories[0], "opencode", "log"),
-      path.join(directories[0], "opencode", "repos"),
-      path.join(directories[4], "opencode"),
-    ]
-    created.forEach((directory) => expect(fs.statSync(directory).isDirectory()).toBe(true))
-    fs.rmSync(root, { recursive: true, force: true })
-  })
-})

scripts/drive-mermaid-visual.ts

@@ -1,75 +0,0 @@
-import { mkdir } from "node:fs/promises"
-import { defineScript, Effect, Llm } from "opencode-drive"
-
-const theme = Bun.env.DRIVE_THEME ?? "opencode"
-const output = Bun.env.DRIVE_SCREENSHOT ?? `artifacts/mermaid-${theme}.png`
-const animate = Bun.env.DRIVE_ANIMATE === "1"
-const cycleThemes = Bun.env.DRIVE_CYCLE_THEMES === "1"
-
-const response = `\`\`\`mermaid
-sequenceDiagram
-  participant B as Browser
-  participant S as Server
-  participant T as Ticket store
-  participant P as PTY
-  B->>S: GET /
-  S-->>B: 401 WWW-Auth
-  Note over B,S: native browser Basic prompt
-  B->>S: GET / · Basic
-  S-->>B: 200 web UI
-  Note over B,S: user opens terminal
-  B->>S: POST connect-token<br/>· Basic (cached by browser)<br/>· X-OpenCode-Ticket: 1
-  S->>T: issue { ptyID, … }
-  S-->>B: { ticket }
-  B->>S: WS …?ticket=…<br/>Upgrade: websocket
-  S->>T: consume(token,scope)
-  T-->>S: ok, delete
-  S->>P: attach
-  P-->>B: WS frames
-\`\`\``
-
-export default defineScript({
-  config: {
-    autoupdate: false,
-  },
-  tuiConfig: {
-    theme: {
-      name: theme,
-      mode: "dark",
-    },
-  },
-  tui: {
-    viewport: { cols: 180, rows: 64 },
-  },
-  run: ({ ui, llm }) =>
-    Effect.gen(function* () {
-      yield* ui.submit("Show the connection flow as a Mermaid sequence diagram")
-      yield* llm.send(
-        Llm.text(response, animate ? { delay: 80, chunkSize: 20 } : { delay: 0, chunkSize: response.length }),
-      )
-      yield* ui.waitFor("WS frames", { timeout: 10_000 })
-      if (cycleThemes) {
-        yield* Effect.sleep(800)
-        yield* Effect.forEach(
-          ["everforest", "synthwave84", "matrix", "opencode"],
-          (next) =>
-            Effect.gen(function* () {
-              yield* ui.press("x", { ctrl: true })
-              yield* ui.press("t")
-              yield* ui.waitFor("Themes")
-              yield* ui.type(next)
-              yield* Effect.sleep(700)
-              yield* ui.enter()
-              yield* Effect.sleep(1_200)
-            }),
-          { discard: true },
-        )
-      }
-      const screenshot = yield* ui.screenshot(`mermaid-${theme}`)
-      yield* Effect.promise(async () => {
-        await mkdir("artifacts", { recursive: true })
-        await Bun.write(output, Bun.file(screenshot))
-      })
-      yield* Effect.log(`Saved ${output}`)
-    }),
-})