@opencode-ai/core 0.0.0-dev-17471

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

@@ -0,0 +1,28 @@
+// src/database/migration/20260323234822_events.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260323234822_events",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`event_sequence\` (
+          \`aggregate_id\` text PRIMARY KEY,
+          \`seq\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event\` (
+          \`id\` text PRIMARY KEY,
+          \`aggregate_id\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260323234822_events_default = migration;
+
+export { _20260323234822_events_default };

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

@@ -0,0 +1,171 @@
+import {
+  exports_host
+} from "./location-mutation-zkhjdecp.js";
+import {
+  exports_runtime
+} from "./location-mutation-jm193w7g.js";
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_tool
+} from "./location-mutation-yyhat9md.js";
+import {
+  exports_reference
+} from "./location-mutation-rzy4xjjz.js";
+import {
+  exports_command
+} from "./location-mutation-apjvmrx3.js";
+import {
+  exports_aisdk
+} from "./location-mutation-wqhtb879.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_websearch
+} from "./location-mutation-9m1tawx7.js";
+import {
+  exports_hooks
+} from "./location-mutation-0dwyqmzq.js";
+import {
+  exports_catalog
+} from "./location-mutation-5gvndtda.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  node: () => node,
+  Service: () => Service,
+  Plugin: () => exports_plugin,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event
+});
+import { Event, ID, Info } from "@opencode-ai/schema/plugin";
+import { Plugin } from "@opencode-ai/schema/plugin";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Exit, Layer, Logger, References, Scope, Semaphore } from "effect";
+class Service extends Context.Service()("@opencode/Plugin") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const scope = yield* Scope.make();
+  const active = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  let host;
+  const load = Effect.fnUntraced(function* (plugin) {
+    const child = yield* Scope.fork(scope);
+    const inherit = yield* exports_state.inherit();
+    const loaded = yield* Effect.suspend(() => plugin.effect(host)).pipe(inherit, Effect.updateContext((context) => Context.make(Scope.Scope, child).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.andThen(bus.publish(Plugin.Event.Added, { id: Plugin.ID.make(plugin.id) })), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void), Effect.exit);
+    if (Exit.isSuccess(loaded))
+      return child;
+    yield* Effect.logWarning("failed to load plugin", {
+      "plugin.id": plugin.id,
+      cause: loaded.cause
+    });
+    return;
+  });
+  const activate = Effect.fn("Plugin.activate")(function* (plugins) {
+    const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }));
+    const ids = new Set;
+    for (const definition of definitions) {
+      if (ids.has(definition.id))
+        yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`));
+      ids.add(definition.id);
+    }
+    yield* lock.withPermit(Effect.gen(function* () {
+      const next = definitions.map((definition) => ({ id: definition.id, version: definition.version }));
+      const current = Array.from(active.values(), (entry) => ({
+        id: entry.plugin.id,
+        version: entry.plugin.version
+      }));
+      if (current.length === next.length && current.every((definition, index) => {
+        const candidate = next[index];
+        return definition.id === candidate?.id && definition.version === candidate.version;
+      }))
+        return;
+      yield* exports_state.batch(Effect.gen(function* () {
+        for (const definition of definitions) {
+          const previous = active.get(definition.id);
+          active.delete(definition.id);
+          if (previous)
+            yield* Scope.close(previous.scope, Exit.void).pipe(Effect.ignore);
+          const loaded = yield* load(definition);
+          if (loaded) {
+            active.set(definition.id, { plugin: definition, scope: loaded });
+            continue;
+          }
+          if (!previous)
+            continue;
+          const restored = yield* load(previous.plugin);
+          if (restored) {
+            active.set(definition.id, { plugin: previous.plugin, scope: restored });
+            continue;
+          }
+          yield* Effect.logError("failed to restore plugin; deactivating", {
+            "plugin.id": definition.id
+          });
+        }
+        const removed = Array.from(active.entries()).filter(([id]) => !ids.has(id)).toReversed();
+        removed.forEach(([id]) => active.delete(id));
+        yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void).pipe(Effect.ignore), {
+          discard: true
+        });
+      }));
+      yield* bus.publish(Plugin.Event.Updated, {});
+    }));
+  });
+  yield* Effect.addFinalizer((exit) => Effect.gen(function* () {
+    active.clear();
+    yield* exports_state.batch(Scope.close(scope, exit));
+  }));
+  const service = Service.of({
+    activate,
+    list: Effect.fn("Plugin.list")(function* () {
+      return Array.from(active.keys()).map((id) => ({ id }));
+    })
+  });
+  host = yield* exports_host.make(service);
+  return service;
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    exports_app.node,
+    exports_agent.node,
+    exports_aisdk.node,
+    exports_catalog.node,
+    exports_command.node,
+    exports_integration.node,
+    exports_location.node,
+    exports_reference.node,
+    exports_skill.node,
+    exports_tool.node,
+    exports_hooks.node,
+    exports_runtime.node,
+    exports_websearch.node
+  ]
+});
+
+export { Service, node, exports_plugin, Event, ID, Info };

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

@@ -0,0 +1,97 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/google-vertex.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+function resolveProject(options) {
+  return options.project ?? process.env.GOOGLE_VERTEX_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCP_PROJECT ?? process.env.GCLOUD_PROJECT;
+}
+function resolveLocation(options) {
+  return options.location ?? process.env.GOOGLE_VERTEX_LOCATION ?? process.env.GOOGLE_CLOUD_LOCATION ?? process.env.VERTEX_LOCATION ?? "us-central1";
+}
+function vertexEndpoint(location) {
+  if (location === "global")
+    return "aiplatform.googleapis.com";
+  return `${location}-aiplatform.googleapis.com`;
+}
+function replaceVertexVars(value, project, location) {
+  return value.replaceAll("${GOOGLE_VERTEX_PROJECT}", project ?? "${GOOGLE_VERTEX_PROJECT}").replaceAll("${GOOGLE_VERTEX_LOCATION}", location).replaceAll("${GOOGLE_VERTEX_ENDPOINT}", vertexEndpoint(location));
+}
+function authFetch(fetchWithRuntimeOptions) {
+  return async (input, init) => {
+    const { GoogleAuth } = await import("google-auth-library");
+    const auth = new GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] });
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${token.token}`);
+    return typeof fetchWithRuntimeOptions === "function" ? fetchWithRuntimeOptions(input, { ...init, headers }) : fetch(input, { ...init, headers });
+  };
+}
+var GoogleVertexPlugin = define({
+  id: "opencode.provider.google-vertex",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/google-vertex" && !(item.provider.id === exports_provider.ID.googleVertex && exports_provider.packageName(item.provider.package)?.includes("@ai-sdk/openai-compatible")))
+          continue;
+        const project = resolveProject(item.provider.settings ?? {});
+        const location = String(resolveLocation(item.provider.settings ?? {}));
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.settings = {
+            ...provider.settings,
+            ...project ? { project } : {},
+            location,
+            ...typeof provider.settings?.baseURL === "string" ? { baseURL: replaceVertexVars(provider.settings.baseURL, project, location) } : {},
+            ...exports_provider.packageName(provider.package)?.includes("@ai-sdk/openai-compatible") ? { fetch: authFetch(provider.settings?.fetch) } : {}
+          };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID === exports_provider.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
+        evt.options.fetch = authFetch(evt.options.fetch);
+        return;
+      }
+      if (evt.package === "@ai-sdk/google-vertex/anthropic") {
+        const mod2 = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"));
+        const project2 = resolveProject(evt.options);
+        const location2 = String(resolveLocation(evt.options));
+        const regionalBaseURL = (location2 === "eu" || location2 === "us") && project2 && !evt.options.baseURL ? `https://aiplatform.${location2}.rep.googleapis.com/v1/projects/${project2}/locations/${location2}/publishers/anthropic/models` : undefined;
+        evt.sdk = mod2.createVertexAnthropic({
+          ...evt.options,
+          project: project2,
+          location: location2,
+          ...regionalBaseURL ? { baseURL: regionalBaseURL } : {}
+        });
+        return;
+      }
+      if (evt.package !== "@ai-sdk/google-vertex")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex"));
+      const project = resolveProject(evt.options);
+      const location = resolveLocation(evt.options);
+      const options = { ...evt.options };
+      delete options.fetch;
+      evt.sdk = mod.createVertex({
+        ...options,
+        project,
+        location
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.googleVertex)
+        return;
+      evt.language = evt.sdk.languageModel(String(evt.model.modelID ?? evt.model.id).trim());
+    }));
+  })
+});
+
+export { GoogleVertexPlugin };

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

@@ -0,0 +1,4 @@
+// src/pty/schema.ts
+import { ID } from "@opencode-ai/schema/pty";
+
+export { ID };

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

@@ -0,0 +1,41 @@
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+
+// src/plugin/provider/llmgateway.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var LLMGatewayPlugin = define({
+  id: "opencode.provider.llmgateway",
+  effect: Effect.fn(function* (ctx) {
+    const integrations = yield* exports_integration.Service;
+    const configured = new Set((yield* integrations.list()).map((integration) => integration.id));
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (item.provider.activation === "disabled")
+          continue;
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://api.llmgateway.io/v1")
+          continue;
+        if (!configured.has(exports_integration.ID.make(item.provider.id)))
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-Source": "opencode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { LLMGatewayPlugin };

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

@@ -0,0 +1,19 @@
+// src/database/migration/20260622202450_simplify_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622202450_simplify_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+    });
+  }
+};
+var _20260622202450_simplify_session_input_default = migration;
+
+export { _20260622202450_simplify_session_input_default };

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

@@ -0,0 +1,45 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/system-prompt.ts
+var exports_system_prompt = {};
+__export(exports_system_prompt, {
+  make: () => make,
+  SessionSystemPrompt: () => exports_system_prompt
+});
+
+// src/session/runner/prompt/system.txt
+var system_default = `You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.
+
+# Harness
+- Responses are rendered as GitHub-flavored Markdown.
+- \`<system-reminder>\` blocks are harness instructions, not user-authored content. Read and follow them.
+\${OPENCODE_TOOL_GUIDANCE}
+
+# Communication
+- Use clear file paths when referring to files.
+- Keep responses clear and concise, and avoid unnecessary technical jargon.
+
+# Working in codebases
+- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.
+- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.
+`;
+
+// src/session/system-prompt.ts
+function make(tools) {
+  const instructions = [];
+  if (tools.includes("write")) {
+    instructions.push("- Use the write tool to create files or completely replace their content. Prefer using the edit tool for targeted changes.");
+  }
+  if (tools.includes("edit")) {
+    instructions.push("- Use the edit tool for targeted changes to existing text files. It replaces the exact text in `oldString` with `newString`, and the values must differ. By default, `oldString` must occur exactly once. If it occurs multiple times, include more surrounding context to make it unique or set `replaceAll` to true to replace every occurrence.");
+  }
+  if (tools.includes("read")) {
+    instructions.push("- Prefer using the read tool rather than shell commands like `cat`.");
+  }
+  return system_default.replace("${OPENCODE_TOOL_GUIDANCE}", instructions.join(`
+`));
+}
+
+export { make, exports_system_prompt };

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

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/util/token.ts
+var exports_token = {};
+__export(exports_token, {
+  estimate: () => estimate,
+  Token: () => exports_token
+});
+var CHARS_PER_TOKEN = 4;
+var estimate = (input) => Math.max(0, Math.round(input.length / CHARS_PER_TOKEN));
+
+export { estimate, exports_token };

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

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Rule: () => Rule,
+  Object: () => Object,
+  Info: () => Info,
+  ConfigPermissionV1: () => exports_permission,
+  Action: () => Action
+});
+import { Schema, SchemaGetter } from "effect";
+var Action = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object = Schema.Record(Schema.String, Action).annotate({ identifier: "PermissionObjectConfig" });
+var Rule = Schema.Union([Action, Object]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule),
+  edit: Schema.optional(Rule),
+  glob: Schema.optional(Rule),
+  grep: Schema.optional(Rule),
+  list: Schema.optional(Rule),
+  bash: Schema.optional(Rule),
+  task: Schema.optional(Rule),
+  external_directory: Schema.optional(Rule),
+  question: Schema.optional(Action),
+  webfetch: Schema.optional(Action),
+  websearch: Schema.optional(Action),
+  lsp: Schema.optional(Rule),
+  doom_loop: Schema.optional(Action),
+  skill: Schema.optional(Rule)
+}), [Schema.Record(Schema.String, Rule)]);
+var InputSchema = Schema.Union([Action, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action, Object, Rule, Info, exports_permission };

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

@@ -0,0 +1,92 @@
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/warming.ts
+var exports_warming = {};
+__export(exports_warming, {
+  WarmingPlugin: () => exports_warming,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Clock, Duration, Effect, Scope } from "effect";
+var defaults = {
+  prompt: "This is a keep-alive request. Do not perform any work or use tools. Reply with exactly: OK",
+  interval: Duration.minutes(4),
+  duration: Duration.minutes(30)
+};
+var Plugin = define({
+  id: "opencode.warming",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loadSettings = Effect.fn("WarmingPlugin.loadSettings")(function* () {
+      const warming = exports_config.latest(yield* config.entries(), "warming");
+      if (!warming)
+        return;
+      const settings = warming === true ? defaults : { ...defaults, ...warming };
+      const interval = Duration.toMillis(settings.interval);
+      const duration = Duration.toMillis(settings.duration);
+      if (Number.isFinite(interval) && interval > 0 && Number.isFinite(duration) && duration > 0)
+        return settings;
+      yield* Effect.logWarning("warming interval and duration must be finite positive durations");
+    });
+    const scope = yield* Scope.Scope;
+    const sessions = new Map;
+    const loop = Effect.fn("WarmingPlugin.loop")(function* (sessionID) {
+      const current = sessions.get(sessionID);
+      if (!current)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      const next = Math.min(current.last + Duration.toMillis(current.settings.interval), current.expires);
+      if (now < next) {
+        yield* Effect.sleep(Duration.millis(next - now));
+        return yield* loop(sessionID);
+      }
+      if (now >= current.expires) {
+        sessions.delete(sessionID);
+        return;
+      }
+      const last = current.last;
+      yield* Effect.logInfo("warming session", { sessionID, last });
+      yield* ctx.session.generate({ sessionID, prompt: current.settings.prompt }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to warm session", { sessionID, cause })));
+      const latest = sessions.get(sessionID);
+      if (latest === current && latest.last === last)
+        latest.last = yield* Clock.currentTimeMillis;
+      return yield* loop(sessionID);
+    });
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const active = sessions.get(event.sessionID);
+      const settings = yield* loadSettings();
+      if (!settings) {
+        sessions.delete(event.sessionID);
+        return;
+      }
+      const message = event.messages.at(-1);
+      if (message?.role === "user" && message.content.length === 1 && message.content[0]?.type === "text" && (message.content[0].text === active?.settings.prompt || message.content[0].text === settings.prompt)) {
+        if (active)
+          active.settings = settings;
+        return;
+      }
+      const now = yield* Clock.currentTimeMillis;
+      const duration = Duration.toMillis(settings.duration);
+      if (active) {
+        active.last = now;
+        active.expires = now + duration;
+        active.settings = settings;
+        return;
+      }
+      sessions.set(event.sessionID, { last: now, expires: now + duration, settings });
+      yield* Effect.logInfo("scheduled session warming", {
+        sessionID: event.sessionID,
+        interval: settings.interval,
+        expires: now + duration
+      });
+      yield* loop(event.sessionID).pipe(Effect.catchCause((cause) => Effect.logError("session warming loop failed", { sessionID: event.sessionID, cause })), Effect.forkIn(scope));
+    }));
+  })
+});
+
+export { Plugin, exports_warming };

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

@@ -0,0 +1,91 @@
+import {
+  exports_markdown
+} from "./location-mutation-7wcmqxrc.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  Plugin: () => Plugin,
+  ConfigCommandPlugin: () => exports_command
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode-ai/schema/config/command";
+import path from "path";
+import { Effect, Option, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const fs = yield* FSUtil.Service;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), (entry) => {
+        if (entry.type === "document")
+          return Effect.succeed([{ commands: entry.info.commands }]);
+        if (entry.type !== "directory")
+          return Effect.succeed([]);
+        return loadDirectory(fs, entry.path).pipe(Effect.map((commands) => [
+          { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }
+        ]));
+      }).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
+    const sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))));
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"));
+    yield* Stream.merge(sourceChanges, configUpdates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((draft) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          draft.update(name, (item) => {
+            item.template = command.template;
+            if (command.description !== undefined)
+              item.description = command.description;
+            if (command.agent !== undefined)
+              item.agent = command.agent;
+            if (command.model !== undefined)
+              item.model = {
+                id: command.model.model,
+                providerID: command.model.providerID,
+                ...command.model.variant === undefined ? {} : { variant: command.model.variant }
+              };
+            if (command.subtask !== undefined)
+              item.subtask = command.subtask;
+          });
+        }
+      }
+    });
+  })
+});
+var sourceDirectories = ["command", "commands"];
+function isCommandSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function loadDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const files = yield* fs.scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.catch(() => Effect.succeed([])));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.catch(() => Effect.succeed(undefined)))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return;
+  const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
+  if (!info)
+    return;
+  return {
+    name: path.relative(directory, filepath).replaceAll("\\", "/").replace(/^(command|commands)\//, "").replace(/\.md$/, ""),
+    info
+  };
+}
+
+export { Plugin, exports_command };