@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-ynb0qzj9.js

@@ -0,0 +1,118 @@
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_form
+} from "./location-mutation-w6yb7hdq.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/question.ts
+var exports_question = {};
+__export(exports_question, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  description: () => description,
+  QuestionTool: () => exports_question,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  CancelledError: () => CancelledError
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { Question } from "@opencode-ai/schema/question";
+var name = "question";
+var description = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- A "Type your own answer" option is added automatically; don't include a separate option for free form answers
+- Set \`multiple: true\` to allow selecting more than one option
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
+var Input = Schema.Struct({
+  questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
+});
+var Output = Schema.Struct({
+  answers: Schema.Array(Question.Answer)
+});
+
+class CancelledError extends Schema.TaggedErrorClass()("QuestionTool.CancelledError", {}) {
+  get message() {
+    return "The user dismissed this question";
+  }
+}
+var toModelOutput = (questions, answers) => {
+  const formatted = questions.map((question, index) => `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`).join(", ");
+  return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+};
+var Plugin = {
+  id: "opencode.tool.question",
+  effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
+    const forms = yield* exports_form.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => permission.assert({
+        action: "question",
+        resources: ["*"],
+        sessionID: context.sessionID,
+        agent: context.agent,
+        source: { type: "tool", messageID: context.messageID, id: context.id }
+      }).pipe(Effect.mapError((error) => new ToolFailure({ message: "Permission denied: question", error })), Effect.andThen(forms.ask({
+        sessionID: context.sessionID,
+        title: "Questions",
+        metadata: {
+          kind: "question",
+          tool: { messageID: context.messageID, id: context.id }
+        },
+        fields: [
+          toField(input.questions[0], 0),
+          ...input.questions.slice(1).map((question, index) => toField(question, index + 1))
+        ]
+      }).pipe(Effect.orDie)), Effect.flatMap((state) => {
+        if (state.status === "cancelled")
+          return Effect.die(new CancelledError);
+        const output = {
+          answers: input.questions.map((_, index) => {
+            const value = state.answer[`q${index}`];
+            if (value === undefined)
+              return [];
+            if (typeof value === "object")
+              return Array.from(value);
+            return [String(value)];
+          })
+        };
+        return Effect.succeed({
+          output,
+          content: toModelOutput(input.questions, output.answers),
+          metadata: { answers: output.answers }
+        });
+      }))
+    })).pipe(Effect.orDie);
+  })
+};
+function toField(question, index) {
+  return {
+    key: `q${index}`,
+    title: question.header,
+    description: question.question,
+    type: question.multiple === true ? "multiselect" : "string",
+    options: question.options.map((option) => ({
+      value: option.label,
+      label: option.label,
+      description: option.description
+    })),
+    custom: true
+  };
+}
+
+export { name, description, Input, Output, CancelledError, toModelOutput, Plugin, exports_question };

package/dist/chunks/location-mutation-yrqrg4vp.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260603040000_session_message_projection_order.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603040000_session_message_projection_order",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`ALTER TABLE \`session_message\` ADD COLUMN \`seq\` integer NOT NULL;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_type_time_created_id_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+    });
+  }
+};
+var _20260603040000_session_message_projection_order_default = migration;
+
+export { _20260603040000_session_message_projection_order_default };

package/dist/chunks/location-mutation-yyhat9md.js

@@ -0,0 +1,231 @@
+import {
+  exports_tool
+} from "./location-mutation-yz0wm9s3.js";
+import {
+  definition,
+  execute,
+  normalizeContent
+} from "./location-mutation-d6s8p2vk.js";
+import {
+  exports_image
+} from "./location-mutation-ffvt207n.js";
+import {
+  exports_wildcard
+} from "./location-mutation-y67x6rf6.js";
+import {
+  exports_hooks
+} from "./location-mutation-0dwyqmzq.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  node: () => node,
+  Tool: () => exports_tool2,
+  TextContent: () => TextContent,
+  Service: () => Service,
+  RegistrationError: () => RegistrationError,
+  FileContent: () => FileContent,
+  Error: () => Error2,
+  Content: () => Content,
+  CallID: () => CallID
+});
+import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { ToolDefinition } from "@opencode-ai/ai";
+import { Tool } from "@opencode-ai/schema/tool";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+class RegistrationError extends Schema.TaggedErrorClass()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Tool") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const hooks = yield* exports_hooks.Service;
+  const image = yield* exports_image.Service;
+  const normalizeImages = Effect.fn("Tool.normalizeImages")(function* (content) {
+    const normalized = yield* Effect.forEach(content, (item) => {
+      if (item.type !== "file" || !item.mime.startsWith("image/"))
+        return Effect.succeed(item);
+      const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1];
+      if (base64 === undefined)
+        return Effect.succeed(item);
+      const resource = item.name ?? `${item.mime} tool output`;
+      return image.normalize(resource, { uri: resource, content: base64, encoding: "base64", mime: item.mime }).pipe(Effect.map((result) => ({
+        ...item,
+        uri: `data:${result.mime};base64,${result.content}`,
+        mime: result.mime
+      })), Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(item)), Effect.catchTag("Image.DecodeError", () => Effect.succeed("decode")), Effect.catchTag("Image.SizeError", () => Effect.succeed("size")));
+    });
+    const note = (reason, text) => {
+      const count = normalized.filter((item) => item === reason).length;
+      if (count === 0)
+        return [];
+      return [{ type: "text", text: `[${count} image${count === 1 ? "" : "s"} omitted: ${text}]` }];
+    };
+    return [
+      ...normalized.filter((item) => typeof item !== "string"),
+      ...note("decode", "could not be decoded."),
+      ...note("size", "could not be resized below the image size limit.")
+    ];
+  });
+  const local = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
+    const beforeEvent = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input
+    };
+    yield* hooks.trigger("tool", "execute.before", beforeEvent);
+    const execution = yield* execute(tool, beforeEvent.input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const base = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input: beforeEvent.input
+    };
+    if ("failure" in execution) {
+      const afterEvent2 = {
+        ...base,
+        status: "error",
+        error: execution.failure
+      };
+      yield* hooks.trigger("tool", "execute.after", afterEvent2);
+      return yield* afterEvent2.error;
+    }
+    const afterEvent = {
+      ...base,
+      status: "completed",
+      result: {
+        ...execution.value.output === undefined ? {} : { output: execution.value.output },
+        content: execution.value.content,
+        ...execution.value.metadata === undefined ? {} : { metadata: execution.value.metadata }
+      }
+    };
+    yield* hooks.trigger("tool", "execute.after", afterEvent);
+    const afterContent = yield* normalizeImages(normalizeContent(afterEvent.result.content, afterEvent.result.output));
+    return {
+      ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
+      content: afterContent,
+      ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
+    };
+  });
+  const transform = Effect.fn("Tool.transform")(function* (callback) {
+    const tools = [];
+    yield* Effect.sync(() => callback({ add: (tool) => tools.push(tool) }));
+    yield* Effect.forEach(tools.flatMap((tool) => tool.options?.namespace === undefined ? [] : [tool.options.namespace]), validateNamespace, { discard: true });
+    const entries = normalizedEntries(tools);
+    yield* Effect.forEach(entries, (entry) => validateName(normalizedName(entry.tool)), { discard: true });
+    const collision = entries.find((entry, index) => entries.findIndex((candidate) => candidate.key === entry.key) !== index);
+    if (collision)
+      return yield* Effect.fail(new RegistrationError({
+        name: collision.key,
+        message: `Duplicate normalized tool name: ${collision.key}`
+      }));
+    const reserved = entries.find((entry) => entry.tool.options?.codemode === false && entry.key === "execute");
+    if (reserved)
+      return yield* Effect.fail(new RegistrationError({
+        name: reserved.key,
+        message: 'Tool name "execute" is reserved for CodeMode'
+      }));
+    if (entries.length === 0)
+      return;
+    yield* Effect.forEach(entries, (entry) => Effect.try({
+      try: () => ToolDefinition.make(definition(entry.tool)),
+      catch: (error) => new RegistrationError({
+        name: entry.key,
+        message: `Invalid tool definition ${entry.key}: ${error instanceof Error ? error.message : String(error)}`
+      })
+    }), { discard: true });
+    yield* Effect.uninterruptible(lock.withPermit(Effect.gen(function* () {
+      const token = {};
+      for (const entry of entries)
+        local.set(entry.key, [...local.get(entry.key) ?? [], { token, tool: entry.tool }]);
+      yield* Effect.addFinalizer(() => lock.withPermit(Effect.sync(() => {
+        for (const entry of entries) {
+          const remaining = local.get(entry.key)?.filter((item) => item.token !== token) ?? [];
+          if (remaining.length > 0)
+            local.set(entry.key, remaining);
+          else
+            local.delete(entry.key);
+        }
+      })));
+    })));
+  });
+  return Service.of({
+    transform,
+    snapshot: Effect.fn("Tool.snapshot")((permissions) => lock.withPermit(Effect.gen(function* () {
+      const active = new Map;
+      const rules = permissions ?? [];
+      for (const [name, entries] of local) {
+        const tool = entries.at(-1)?.tool;
+        if (!tool)
+          continue;
+        if (whollyDisabled(tool.options?.permission ?? name, rules))
+          continue;
+        active.set(name, tool);
+      }
+      const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
+      const codemode = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const executeRule = rules.findLast((rule) => exports_wildcard.match("execute", rule.action));
+      const codemodeEnabled = executeRule?.resource !== "*" || executeRule.effect !== "deny";
+      const codemodeTool = codemodeEnabled ? exports_tool.create(codemode, (name, tool, input, context) => executeTool(tool, name, input, context)) : undefined;
+      const codeModeCatalog = codemodeEnabled ? exports_tool.catalog(codemode) : undefined;
+      return {
+        ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
+        definitions: [
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
+          ...codemodeTool ? [definition(codemodeTool)] : []
+        ],
+        execute: (input) => {
+          const context = {
+            sessionID: input.sessionID,
+            agent: input.agent,
+            messageID: input.messageID,
+            id: Tool.CallID.make(input.call.id),
+            progress: input.progress ?? (() => Effect.void)
+          };
+          if (input.call.name === "execute" && codemodeTool)
+            return executeTool(codemodeTool, input.call.name, input.call.input, context);
+          const tool = direct.get(input.call.name);
+          if (tool)
+            return executeTool(tool, input.call.name, input.call.input, context);
+          return new Tool.Error({ message: `Unknown tool: ${input.call.name}` });
+        }
+      };
+    })))
+  });
+}));
+var whollyDisabled = (action, rules) => {
+  const rule = rules.findLast((rule2) => exports_wildcard.match(action, rule2.action));
+  return rule?.resource === "*" && rule.effect === "deny";
+};
+var validateName = (name) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name) ? Effect.void : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }));
+var validateNamespace = (namespace) => namespace.split(".").every((segment) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(segment)) ? Effect.void : Effect.fail(new RegistrationError({
+  name: namespace,
+  message: `Invalid tool namespace: ${JSON.stringify(namespace)}`
+}));
+var normalizedName = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName = (tool) => tool.options?.namespace === undefined ? normalizedName(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`;
+var normalizedEntries = (tools) => tools.map((tool) => ({
+  key: effectiveName(tool),
+  tool
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_hooks.node, exports_image.node]
+});
+
+export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };

package/dist/chunks/location-mutation-yz0wm9s3.js

@@ -0,0 +1,183 @@
+import {
+  definition
+} from "./location-mutation-d6s8p2vk.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/codemode/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  create: () => create,
+  catalog: () => catalog,
+  CodeModeTool: () => exports_tool
+});
+import { CodeMode, Tool, toolError } from "@opencode-ai/codemode";
+import { Effect, Ref, Schema, Semaphore } from "effect";
+var ExecuteFile = Schema.Struct({
+  data: Schema.String,
+  mime: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+});
+var ExecuteCall = Schema.Struct({
+  tool: Schema.String,
+  status: Schema.Literals(["running", "completed", "error"]),
+  input: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json))
+});
+var ExecuteOutput = Schema.Struct({
+  output: Schema.String,
+  toolCalls: Schema.Array(ExecuteCall),
+  error: Schema.optionalKey(Schema.Literal(true)),
+  files: Schema.Array(ExecuteFile)
+});
+var description = [
+  "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
+  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
+  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
+].join(`
+`);
+var create = (registrations, executeTool) => {
+  return {
+    name: "execute",
+    description,
+    input: CodeMode.Input,
+    output: ExecuteOutput,
+    execute: ({ code }, context) => Effect.gen(function* () {
+      const callIndex = yield* Ref.make(0);
+      const files = yield* Ref.make([]);
+      const calls = yield* Ref.make([]);
+      const lock = Semaphore.makeUnsafe(1);
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls2) => context.progress({ toolCalls: toolCalls2 }))));
+      const result = yield* runtime(registrations, (name, tool, input) => Effect.gen(function* () {
+        const index = yield* Ref.getAndUpdate(callIndex, (index2) => index2 + 1);
+        const executed = yield* executeTool(name, tool, input, context).pipe(Effect.mapError((failure) => toolError(failure.message, failure)));
+        const content2 = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content2);
+        if (outputFileParts.length > 0)
+          yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
+        if (executed.output !== undefined)
+          return executed.output;
+        const text = content2.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+        return text === "" ? null : text;
+      }), {
+        onToolCallStart: ({ index, name, input }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = { tool: name, status: "running", ...shown ? { input: shown } : {} };
+            return next;
+          });
+        },
+        onToolCallEnd: ({ index, name, input, outcome }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = {
+              ...items[index] ?? { tool: name, ...shown ? { input: shown } : {} },
+              status: outcome === "success" ? "completed" : "error"
+            };
+            return next;
+          });
+        }
+      }).execute(code);
+      const toolCalls = yield* Ref.get(calls);
+      const collected = (yield* Ref.get(files)).toSorted((left, right) => left.index - right.index).flatMap((item) => item.files);
+      const output = formatResult(result);
+      const value = {
+        output,
+        toolCalls,
+        files: collected,
+        ...result.ok ? {} : { error: true }
+      };
+      const content = [{ type: "text", text: value.output }];
+      content.push(...value.files.map((file) => ({
+        type: "file",
+        uri: `data:${file.mime};base64,${file.data}`,
+        mime: file.mime,
+        ...file.name === undefined ? {} : { name: file.name }
+      })));
+      const metadata = {
+        toolCalls: value.toolCalls,
+        ...value.error ? { error: true } : {}
+      };
+      return {
+        output: value,
+        content,
+        metadata
+      };
+    })
+  };
+};
+var catalog = (registrations) => {
+  const pinned = new Set(Array.from(registrations.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
+  return runtime(registrations, () => Effect.fail(toolError("Execute context is unavailable"))).catalog().map((entry) => ({ ...entry, pinned: pinned.has(entry.path) }));
+};
+function runtime(registrations, executeTool, hooks) {
+  const tools = {};
+  for (const [name, registration] of registrations) {
+    const child = definition(registration);
+    const path = qualifiedName(registration);
+    tools[path] = Tool.make({
+      description: child.description,
+      input: child.inputSchema,
+      output: child.outputSchema ?? Schema.NullOr(Schema.String),
+      execute: (input) => executeTool(name, registration, input)
+    });
+  }
+  return CodeMode.make({ tools, ...hooks });
+}
+function qualifiedName(registration) {
+  const normalized = registration.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (registration.options?.namespace === undefined)
+    return normalized;
+  return `${registration.options.namespace}.${normalized}`;
+}
+function displayInput(input) {
+  if (input === null || input === undefined)
+    return;
+  if (typeof input !== "object" || Array.isArray(input))
+    return { input };
+  if (Object.keys(input).length === 0)
+    return;
+  return input;
+}
+function formatResult(result) {
+  const output = result.ok ? formatValue(result.value) : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))].join(`
+`).trim();
+  const warnings = result.ok && result.warnings && result.warnings.length > 0 ? `Warnings:
+${result.warnings.map((item) => `- [${item.kind}] ${item.message}`).join(`
+`)}` : undefined;
+  const logs = result.logs && result.logs.length > 0 ? `Logs:
+${result.logs.join(`
+`)}` : undefined;
+  return [output, warnings, logs].filter((part) => part !== undefined && part !== "").join(`
+
+`);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function outputFiles(content) {
+  return content.flatMap((part) => {
+    if (part.type !== "file")
+      return [];
+    const prefix = `data:${part.mime};base64,`;
+    if (!part.uri.startsWith(prefix))
+      return [];
+    return [
+      {
+        data: part.uri.slice(prefix.length),
+        mime: part.mime,
+        ...part.name === undefined ? {} : { name: part.name }
+      }
+    ];
+  });
+}
+
+export { create, catalog, exports_tool };

package/dist/chunks/location-mutation-yzxgy8cb.js

@@ -0,0 +1,112 @@
+import {
+  exports_instruction_discovery
+} from "./location-mutation-q9z9bptr.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  exports_watcher
+} from "./location-mutation-k6vwd7kr.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/instruction.ts
+var exports_instruction = {};
+__export(exports_instruction, {
+  Plugin: () => Plugin,
+  ConfigInstructionPlugin: () => exports_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";
+var Plugin = define({
+  id: "opencode.config.instruction",
+  effect: Effect.fn(function* () {
+    const discovery = yield* exports_instruction_discovery.Service;
+    yield* Effect.gen(function* () {
+      const fs = yield* FSUtil.Service;
+      const global = yield* Global.Service;
+      const location = yield* exports_location.Service;
+      const watcher = yield* exports_watcher.Service;
+      const changes = yield* PubSub.sliding(1);
+      const lock = Semaphore.makeUnsafe(1);
+      const start = yield* fs.resolve(location.directory);
+      const root = yield* fs.resolve(location.project.directory);
+      const home = yield* fs.resolve(global.home);
+      const project = discovery.project && FSUtil.contains(root, start);
+      const stop = FSUtil.contains(home, start) ? home : root;
+      const globalFile = yield* fs.resolve(join(global.config, "AGENTS.md"));
+      const loaded = { current: { type: "available", files: [] } };
+      const publish = (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) {
+        const content = yield* fs.readFileStringSafe(path);
+        if (content !== undefined)
+          return new exports_instruction_discovery.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 exports_instructions.unavailable;
+        return files.filter((file) => file !== undefined);
+      });
+      const isolate = (source, effect) => effect.pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load instruction source", { source, cause }).pipe(Effect.as(exports_instructions.unavailable))));
+      const refresh = Effect.fn("ConfigInstructionPlugin.refresh")(function* (file) {
+        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, stop) {
+  if (start === stop)
+    return [start];
+  return [start, ...ancestorDirectories(dirname(start), stop)];
+}
+
+export { Plugin, exports_instruction };