@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-7zdm33ac.js

@@ -0,0 +1,453 @@
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  makeUnsafe2
+} from "./aisdk-native-y71avatq.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/git.ts
+var exports_git3 = {};
+__export(exports_git3, {
+  Git: () => exports_git3,
+  OperationError: () => OperationError3,
+  Repository: () => Repository2,
+  Service: () => Service75,
+  TreeID: () => TreeID2,
+  Worktree: () => Worktree2,
+  WorktreeError: () => WorktreeError2,
+  node: () => node80
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Repository2 extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath2,
+  gitDirectory: AbsolutePath2,
+  commonDirectory: AbsolutePath2
+}) {
+}
+var snapshotConfigFile = "opencode.gitconfig";
+var snapshotConfigInclude = `[include]
+	path = ${snapshotConfigFile}
+`;
+var snapshotConfig = `[core]
+	autocrlf = false
+	longpaths = true
+	symlinks = true
+	fsmonitor = false
+	untrackedCache = true
+[feature]
+	manyFiles = true
+[index]
+	version = 4
+	threads = true
+`;
+var TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
+
+class OperationError3 extends Schema.TaggedError()("Git.OperationError", {
+  operation: Schema.Literals([
+    "clone",
+    "fetch",
+    "checkout",
+    "reset",
+    "create",
+    "refresh",
+    "write_tree",
+    "list_files",
+    "diff",
+    "restore"
+  ]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath2),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Worktree2 extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath2,
+  kind: Schema.Literals(["main", "linked"])
+}) {
+}
+
+class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
+  operation: Schema.Literals(["create", "remove", "list"]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath2),
+  forceRequired: Schema.optional(Schema.Boolean),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Service75 extends Context.Service()("@opencode/Git") {
+}
+var layer = Layer.effect(Service75, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const proc = yield* AppProcess.Service;
+  const locks = makeUnsafe2();
+  const locked = (repository, effect) => locks.withLock(repository.gitDirectory)(effect);
+  const discover = Effect.fn("Git.repo.discover")(function* (input) {
+    const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!dotgit)
+      return;
+    const cwd = path.dirname(dotgit);
+    const result = yield* run(cwd, proc, ["rev-parse", "--git-dir", "--git-common-dir", "--show-toplevel"]);
+    const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
+    if (!gitDir || !commonDir)
+      return;
+    return new Repository2({
+      worktree: AbsolutePath2.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
+      gitDirectory: AbsolutePath2.make(resolvePath(cwd, gitDir)),
+      commonDirectory: AbsolutePath2.make(resolvePath(cwd, commonDir))
+    });
+  });
+  const remote = Effect.fn("Git.remote.get")(function* (repository, name = "origin") {
+    const result = yield* run(repository.worktree, proc, ["remote", "get-url", name]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const roots = Effect.fn("Git.history.rootCommits")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["rev-list", "--max-parents=0", "HEAD"]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text.split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted();
+  });
+  const head = Effect.fn("Git.history.head")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["rev-parse", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const branch = Effect.fn("Git.history.branch")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const remoteHead = Effect.fn("Git.history.defaultRemoteBranch")(function* (repository, remoteName = "origin") {
+    const result = yield* run(repository.worktree, proc, ["symbolic-ref", `refs/remotes/${remoteName}/HEAD`]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
+  });
+  const operation = Effect.fnUntraced(function* (operation, directory, args) {
+    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError3({ operation, directory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return;
+    return yield* new OperationError3({
+      operation,
+      directory,
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
+    });
+  });
+  const clone = Effect.fn("Git.repo.clone")(function* (input) {
+    yield* operation("clone", AbsolutePath2.make(path.dirname(input.directory)), [
+      "clone",
+      "--depth",
+      String(input.depth ?? 100),
+      ...input.branch ? ["--branch", input.branch] : [],
+      "--",
+      input.remote,
+      input.directory
+    ]);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new OperationError3({
+      operation: "clone",
+      directory: input.directory,
+      message: "Cloned repository could not be opened"
+    });
+  });
+  const fetch = Effect.fn("Git.sync.fetchRemotes")(function* (repository, input = {}) {
+    yield* operation("fetch", repository.worktree, ["fetch", "--all", ...input.prune === false ? [] : ["--prune"]]);
+  });
+  const fetchBranch = Effect.fn("Git.sync.fetchBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    const spec = `refs/heads/${input.branch}:refs/remotes/${remoteName}/${input.branch}`;
+    yield* operation("fetch", repository.worktree, ["fetch", remoteName, input.force === false ? spec : `+${spec}`]);
+  });
+  const checkout = Effect.fn("Git.sync.checkoutRemoteBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    yield* operation("checkout", repository.worktree, [
+      "checkout",
+      ...input.reset === false ? [input.branch] : ["-B", input.branch, `${remoteName}/${input.branch}`]
+    ]);
+  });
+  const reset = Effect.fn("Git.sync.resetHard")(function* (repository, revision) {
+    yield* operation("reset", repository.worktree, ["reset", "--hard", revision]);
+  });
+  const repositoryArgs = (repository, args) => [
+    "--git-dir",
+    repository.gitDirectory,
+    "--work-tree",
+    repository.worktree,
+    ...args
+  ];
+  const repositoryOperation = Effect.fnUntraced(function* (operationName, repository, args, options) {
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(repository, args), {
+      cwd: repository.worktree,
+      env: options?.env,
+      extendEnv: true
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: operationName,
+      directory: repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    const text = result.stdout.toString("utf8");
+    if (result.exitCode === 0)
+      return { text, stderr: result.stderr.toString("utf8") };
+    return yield* new OperationError3({
+      operation: operationName,
+      directory: repository.worktree,
+      message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`
+    });
+  });
+  const create = Effect.fn("Git.repo.create")(function* (input) {
+    const operationError = (message) => (cause) => new OperationError3({ operation: "create", directory: input.gitDirectory, message, cause });
+    yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
+    const repository = new Repository2({
+      worktree: input.worktree,
+      gitDirectory: input.gitDirectory,
+      commonDirectory: input.gitDirectory
+    });
+    yield* repositoryOperation("create", repository, ["init"]);
+    yield* Effect.gen(function* () {
+      yield* fs.writeFileString(path.join(input.gitDirectory, snapshotConfigFile), snapshotConfig);
+      const config = path.join(input.gitDirectory, "config");
+      const current = yield* fs.readFileString(config);
+      if (current.includes(snapshotConfigInclude))
+        return;
+      yield* fs.writeFileString(config, `${current.endsWith(`
+`) ? `
+` : `
+
+`}${snapshotConfigInclude}`, {
+        flag: "a"
+      });
+    }).pipe(Effect.mapError(operationError("Failed to configure Git storage")));
+    if (!input.seed)
+      return repository;
+    yield* fs.ensureDir(path.join(input.gitDirectory, "objects", "info")).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
+    yield* fs.writeFileString(path.join(input.gitDirectory, "objects", "info", "alternates"), path.join(input.seed.commonDirectory, "objects") + `
+`).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
+    yield* fs.copyFile(path.join(input.seed.gitDirectory, "index"), path.join(input.gitDirectory, "index")).pipe(Effect.ignore);
+    return repository;
+  });
+  const refresh = Effect.fn("Git.index.refresh")(function* (input) {
+    const list = (args) => repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => result.text.split("\x00").filter(Boolean)));
+    const [tracked, untracked] = yield* Effect.all([
+      list(["diff-files", "--name-only", "-z", "--", input.scope]),
+      list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope])
+    ], { concurrency: 2 });
+    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath2.make(file));
+    if (!candidates.length)
+      return { skipped: [] };
+    const excluded = input.ignores ? yield* ignored({ repository: input.ignores, paths: candidates }) : new Set;
+    const allowed = candidates.filter((item) => !excluded.has(item));
+    const maximum = input.maximumUntrackedFileBytes;
+    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath2.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath2.make(item) : undefined), Effect.orElseSucceed(() => {
+      return;
+    })), { concurrency: 8 })).filter((item) => item !== undefined) : [];
+    const stage = allowed.filter((item) => !skipped.includes(item));
+    const remove = [...excluded, ...skipped];
+    if (remove.length)
+      yield* repositoryOperation("refresh", input.repository, ["rm", "--cached", "-f", "--ignore-unmatch", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: remove.join("\x00") + "\x00" });
+    if (stage.length)
+      yield* repositoryOperation("refresh", input.repository, ["add", "--all", "--sparse", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: stage.join("\x00") + "\x00" });
+    return { skipped };
+  });
+  const ignored = Effect.fn("Git.index.ignored")(function* (input) {
+    if (!input.paths.length)
+      return new Set;
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
+      cwd: input.repository.worktree,
+      extendEnv: true
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: "list_files",
+      directory: input.repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    if (result.exitCode !== 0 && result.exitCode !== 1)
+      return yield* new OperationError3({
+        operation: "list_files",
+        directory: input.repository.worktree,
+        message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
+      });
+    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath2.make(file)));
+  });
+  const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
+    return TreeID2.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+  });
+  const captureTree = Effect.fn("Git.tree.capture")((input) => locked(input.repository, Effect.gen(function* () {
+    yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true });
+    return yield* writeTree(input.repository);
+  })));
+  const treeFiles = Effect.fn("Git.tree.files")(function* (input) {
+    return (yield* repositoryOperation("list_files", input.repository, [
+      "diff",
+      "--name-only",
+      "--no-renames",
+      "-z",
+      input.from,
+      input.to
+    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath2.make(file));
+  });
+  const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
+    const paths = input.paths ?? (yield* treeFiles(input));
+    return yield* Effect.forEach(paths, (file) => Effect.gen(function* () {
+      const statusText = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--name-status",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.trim();
+      const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified";
+      const stats = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--numstat",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.split("\t");
+      const binary = stats[0] === "-" || stats[1] === "-";
+      const patch = binary ? "" : (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        `--unified=${input.context ?? 3}`,
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text;
+      return {
+        file,
+        status,
+        additions: binary ? 0 : Number(stats[0] ?? 0),
+        deletions: binary ? 0 : Number(stats[1] ?? 0),
+        patch
+      };
+    }));
+  });
+  const hasEntry = Effect.fnUntraced(function* (repository, tree, file) {
+    const text = (yield* repositoryOperation("restore", repository, [
+      "ls-tree",
+      "-z",
+      tree,
+      "--",
+      file
+    ])).text.replace(/\0$/, "");
+    if (!text)
+      return false;
+    if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
+      return yield* new OperationError3({
+        operation: "restore",
+        directory: repository.worktree,
+        message: `Invalid tree entry for ${file}`
+      });
+    return true;
+  });
+  const restore = Effect.fn("Git.tree.restore")((input) => locked(input.repository, Effect.forEach(input.files, ([file, tree]) => Effect.gen(function* () {
+    if (yield* hasEntry(input.repository, tree, file)) {
+      yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file]);
+      return;
+    }
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: "restore",
+      directory: input.repository.worktree,
+      message: `Failed to remove ${file}`,
+      cause
+    })));
+  }), { discard: true })));
+  const worktreeRun = Effect.fnUntraced(function* (operation, repository, args, worktreeDirectory, cwd = repository.worktree) {
+    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError2({ operation, directory: worktreeDirectory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return result.stdout.toString("utf8");
+    const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Git failed";
+    return yield* new WorktreeError2({
+      operation,
+      directory: worktreeDirectory,
+      message,
+      forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+    });
+  });
+  const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
+    yield* worktreeRun("create", input.repository, ["worktree", "add", "--detach", "--", input.directory, input.ref ?? "HEAD"], input.directory);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new WorktreeError2({
+      operation: "create",
+      directory: input.directory,
+      message: "Created worktree could not be opened"
+    });
+  });
+  const worktreeRemove = Effect.fn("Git.worktree.remove")(function* (input) {
+    yield* worktreeRun("remove", input.repository, ["worktree", "remove", ...input.force ? ["--force"] : [], input.directory], input.directory, input.repository.commonDirectory);
+  });
+  const worktreeList = Effect.fn("Git.worktree.list")(function* (repository) {
+    return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"])).split(`
+`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree2({
+      directory: AbsolutePath2.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+      kind: index === 0 ? "main" : "linked"
+    }));
+  });
+  return Service75.of({
+    repo: { discover, clone, create },
+    remote: { get: remote },
+    history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
+    sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
+    worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
+    index: { refresh, ignored },
+    tree: {
+      capture: captureTree,
+      write: writeTree,
+      files: treeFiles,
+      diff: treeDiff,
+      restore
+    }
+  });
+}));
+var node80 = makeGlobalNode({ service: Service75, layer, deps: [FSUtil.node, AppProcess.node] });
+function run(cwd, proc, args) {
+  return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
+}
+function execute(cwd, proc, args) {
+  return proc.run(ChildProcess.make("git", args, {
+    cwd,
+    extendEnv: true,
+    stdin: "ignore"
+  })).pipe(Effect.map((result) => ({
+    exitCode: result.exitCode,
+    text: result.stdout.toString("utf8"),
+    stderr: result.stderr.toString("utf8")
+  })));
+}
+function resolvePath(cwd, value) {
+  const trimmed = value.replace(/[\r\n]+$/, "");
+  if (!trimmed)
+    return cwd;
+  const normalized = FSUtil.windowsPath(trimmed);
+  if (path.isAbsolute(normalized))
+    return path.normalize(normalized);
+  return path.resolve(cwd, normalized);
+}
+
+export { Repository2, TreeID2, OperationError3, Worktree2, WorktreeError2, Service75, node80, exports_git3 };

package/dist/chunks/aisdk-native-81rrwt6s.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/instance/service.ts
+var exports_service2 = {};
+__export(exports_service2, {
+  Instance: () => exports_service2,
+  Service: () => Service42,
+  node: () => node45
+});
+import { Context } from "effect";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+
+class Service42 extends Context.Service()("@opencode/Instance") {
+}
+var node45 = LayerNode.unbound(Service42, Node.tags.values.global);
+
+export { Service42, node45, exports_service2 };

package/dist/chunks/aisdk-native-822emrt2.js

@@ -0,0 +1,31 @@
+// src/database/drizzle/sqlite-core/effect/raw.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+
+class SQLiteEffectRaw2 {
+  execute;
+  getSQL;
+  action;
+  dialect;
+  mapBatchResult;
+  static [entityKind] = "SQLiteEffectRaw";
+  constructor(execute, getSQL, action, dialect, mapBatchResult) {
+    this.execute = execute;
+    this.getSQL = getSQL;
+    this.action = action;
+    this.dialect = dialect;
+    this.mapBatchResult = mapBatchResult;
+  }
+  getQuery() {
+    return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.action };
+  }
+  mapResult(result, isFromBatch) {
+    return isFromBatch ? this.mapBatchResult(result) : result;
+  }
+  _prepare() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectRaw2);
+
+export { SQLiteEffectRaw2 };

package/dist/chunks/aisdk-native-82asvwff.js

@@ -0,0 +1,164 @@
+import {
+  ID9
+} from "./aisdk-native-x0v86zgp.js";
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Info7
+} from "./aisdk-native-p2fyeaa4.js";
+import {
+  migrateAgent2
+} from "./aisdk-native-pt1wzm9p.js";
+import {
+  latest2,
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  parseOption2
+} from "./aisdk-native-5daktx2q.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  ConfigAgentPlugin: () => exports_agent,
+  Plugin: () => Plugin2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Document, Info } from "@opencode/schema/config";
+import { ConfigAgent } from "@opencode/schema/config/agent";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var legacySources = [
+  { pattern: "{agent,agents}/**/*.md", primary: false },
+  { pattern: "{mode,modes}/*.md", primary: true }
+];
+var sourceDirectories = ["agent", "agents", "mode", "modes"];
+var decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info);
+var decodeLegacyAgent = Schema.decodeUnknownOption(Info7);
+var decodeConfig = Schema.decodeUnknownOption(Info);
+var pathActions = ["external_directory", "read", "edit"];
+var agentKeys = new Set(["variant", ...Object.keys(ConfigAgent.Info.fields)]);
+var Plugin2 = define({
+  id: "opencode.config.agent",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [entry];
+      if (entry.type !== "directory")
+        return [];
+      const files = yield* discover(fs, entry.path);
+      return yield* Effect.forEach(files, (file) => fs.readFileStringSafe(file.filepath).pipe(Effect.map((content) => content ? decode(file, content) : undefined), Effect.orElseSucceed(() => {
+        return;
+      }))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+    });
+    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.agent.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.agent.transform((editor) => {
+      const permissions = expandPermissions(loaded.documents.flatMap((document) => document.info.permissions ?? []), global.home);
+      const configuredDefault = latest2(loaded.documents, "default_agent");
+      if (configuredDefault !== undefined)
+        editor.default(ID9.make(configuredDefault));
+      for (const current of editor.list()) {
+        editor.update(current.id, (agent) => agent.permissions.push(...permissions));
+      }
+      for (const document of loaded.documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = ID9.make(id);
+          if (item.disabled) {
+            editor.remove(agentID);
+            continue;
+          }
+          const exists = editor.get(agentID) !== undefined;
+          editor.update(agentID, (agent) => {
+            if (!exists)
+              agent.permissions.push(...permissions);
+            if (item.model !== undefined)
+              agent.model = {
+                id: item.model.model,
+                providerID: item.model.providerID,
+                ...item.model.variant === undefined ? {} : { variant: item.model.variant }
+              };
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {});
+              Object.assign(agent.request.body, item.request.body ?? {});
+            }
+            if (item.system !== undefined)
+              agent.system = item.system;
+            if (item.description !== undefined)
+              agent.description = item.description;
+            if (item.mode !== undefined)
+              agent.mode = item.mode;
+            if (item.hidden !== undefined)
+              agent.hidden = item.hidden;
+            if (item.color !== undefined)
+              agent.color = item.color;
+            if (item.steps !== undefined)
+              agent.steps = item.steps;
+            if (item.permissions !== undefined) {
+              agent.permissions.push(...expandPermissions(item.permissions, global.home));
+            }
+          });
+        }
+      }
+    });
+  })
+});
+function isAgentSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function expandPermissions(rules, home) {
+  return rules.map((rule) => isPathAction(rule.action) ? { ...rule, resource: expandHome(rule.resource, home) } : rule);
+}
+function isPathAction(action) {
+  return pathActions.some((item) => item === action);
+}
+function expandHome(resource, home) {
+  if (resource === "~" || resource === "$HOME")
+    return home;
+  const relative = resource.startsWith("~/") ? resource.slice(2) : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\") ? resource.slice(6) : undefined;
+  if (relative !== undefined)
+    return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative);
+  return resource;
+}
+function discover(fs, directory) {
+  return Effect.forEach(legacySources, (source) => fs.scan(source.pattern, { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.map((files) => files.toSorted().map((filepath) => ({ directory, filepath, primary: source.primary }))))).pipe(Effect.map((files) => files.flat()), Effect.orElseSucceed(() => []));
+}
+function decode(file, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const name = path.relative(file.directory, file.filepath).replaceAll("\\", "/").replace(/^(agent|agents|mode|modes)\//, "").replace(/\.md$/, "");
+  const body = markdown.content.trim();
+  const legacy = Object.keys(markdown.data).some((key) => !agentKeys.has(key));
+  const data = typeof markdown.data.model === "string" && !markdown.data.model.includes("#") && typeof markdown.data.variant === "string" && /^[^#]+$/.test(markdown.data.variant) ? { ...markdown.data, model: `${markdown.data.model}#${markdown.data.variant}` } : markdown.data;
+  const agent = legacy ? Option.getOrUndefined(Option.map(decodeLegacyAgent({ name, ...markdown.data, prompt: body }, { errors: "all", propertyOrder: "original" }), migrateAgent2)) : Option.getOrUndefined(decodeAgent({ ...data, system: body }, { errors: "all", propertyOrder: "original" }));
+  if (!agent)
+    return;
+  const info = Option.getOrUndefined(decodeConfig({
+    agents: { [name]: file.primary ? { ...agent, mode: "primary" } : agent }
+  }));
+  if (!info)
+    return;
+  return new Document({ type: "document", path: AbsolutePath2.make(file.filepath), info });
+}
+
+export { Plugin2, exports_agent };