refactor(core): move instruction discovery to the config side

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

@@ -0,0 +1,122 @@
+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/instruction-discovery.ts

@@ -1,23 +1,44 @@
 export * as InstructionDiscovery from "./instruction-discovery"
 
-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 { Instructions } from "./instructions/index"
+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 { AbsolutePath } from "./schema"
+import { State } from "./state"
 
-class File extends Schema.Class<File>("InstructionDiscovery.File")({
+export class File extends Schema.Class<File>("InstructionDiscovery.File")({
   path: AbsolutePath,
   content: Schema.String,
 }) {}
 
 const Files = Schema.Array(File)
 const key = Instructions.Key.make("core/instructions")
 
-export interface Interface {
+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>
   readonly load: () => Effect.Effect<Instructions.List>
 }
 
@@ -32,9 +53,26 @@ export const layer = (options?: Options) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
-      const fs = yield* FSUtil.Service
-      const global = yield* Global.Service
-      const location = yield* Location.Service
+      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 source = (value: ReadonlyArray<File> | Instructions.Unavailable | Instructions.Removed) =>
         Instructions.make<ReadonlyArray<File>>({
@@ -49,52 +87,22 @@ export const layer = (options?: Options) =>
           },
         })
 
-      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)
+      const list = Effect.fn("InstructionDiscovery.list")(function* () {
+        const current = state.get()
+        if (!current.available) return Instructions.unavailable
+        return Array.from(current.files.values())
       })
 
       return Service.of({
-        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))),
-          ),
+        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)
+        }),
       })
     }),
   )
@@ -103,7 +111,7 @@ export function configured(options?: Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [FSUtil.node, Global.node, Location.node],
+    deps: [Bus.node],
   })
 }
 

packages/core/src/plugin/internal.ts

@@ -12,6 +12,7 @@ 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"
@@ -26,6 +27,7 @@ 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"
@@ -83,6 +85,7 @@ 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
@@ -118,6 +121,7 @@ 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),
@@ -160,6 +164,7 @@ export const requirements = LayerNode.group([
   Global.node,
   httpClient,
   Image.node,
+  InstructionDiscovery.node,
   Integration.node,
   KV.node,
   Location.node,
@@ -209,6 +214,7 @@ const pre = [
 ] as const satisfies readonly InternalPlugin[]
 
 const post = [
+  ConfigInstructionPlugin.Plugin,
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,

packages/core/test/fixture/global.ts

@@ -0,0 +1,27 @@
+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"),
+      })
+    }),
+  ),
+)