@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-saecaj3m.js → event-logger-n600s6ej.js}

@@ -1,18 +1,20 @@
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  ID18,
+  Name3,
+  defaultID2
+} from "./event-logger-8ab07kvc.js";
 import {
-  exports_agent
-} from "./schema-p6fb92cp.js";
+  merge2
+} from "./event-logger-yzjhj2th.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/agent.ts
-var exports_agent2 = {};
-__export(exports_agent2, {
-  AgentPlugin: () => exports_agent2,
-  Plugin: () => Plugin
+var exports_agent = {};
+__export(exports_agent, {
+  AgentPlugin: () => exports_agent,
+  Plugin: () => Plugin12
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
@@ -88,29 +90,29 @@ Rules:
 - Never ask questions or add new questions
 - If the conversation ends with an unanswered question to the user, preserve that exact question
 - If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary`;
-var Plugin = define({
+var Plugin12 = define({
   id: "opencode.agent",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.agent.transform((editor) => {
-      editor.update(exports_agent.defaultID, (item) => {
-        item.name = exports_agent.Name.make("Build");
+      editor.update(defaultID2, (item) => {
+        item.name = Name3.make("Build");
         item.description = "The default agent. Executes tools based on configured permissions.";
         item.mode = "primary";
         item.permissions.push({ action: "question", resource: "*", effect: "allow" });
       });
-      editor.update(exports_agent.ID.make("general"), (item) => {
-        item.name = exports_agent.Name.make("General");
+      editor.update(ID18.make("general"), (item) => {
+        item.name = Name3.make("General");
         item.description = "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.";
         item.mode = "subagent";
         item.permissions.push({ action: "question", resource: "*", effect: "deny" }, { action: "subagent", resource: "*", effect: "deny" });
       });
-      editor.update(exports_agent.ID.make("explore"), (item) => {
+      editor.update(ID18.make("explore"), (item) => {
         const externalDirectories = item.permissions.filter((rule) => rule.action === "external_directory" && rule.effect === "allow");
-        item.name = exports_agent.Name.make("Explore");
+        item.name = Name3.make("Explore");
         item.description = 'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.';
         item.system = PROMPT_EXPLORE;
         item.mode = "subagent";
-        item.permissions.push(...exports_permission.merge([
+        item.permissions.push(...merge2([
           { action: "*", resource: "*", effect: "deny" },
           { action: "grep", resource: "*", effect: "allow" },
           { action: "glob", resource: "*", effect: "allow" },
@@ -123,20 +125,20 @@ var Plugin = define({
           { action: "subagent", resource: "*", effect: "deny" }
         ], [{ action: "external_directory", resource: "*", effect: "ask" }, ...externalDirectories]));
       });
-      editor.update(exports_agent.ID.make("compaction"), (item) => {
-        item.name = exports_agent.Name.make("Compaction");
+      editor.update(ID18.make("compaction"), (item) => {
+        item.name = Name3.make("Compaction");
         item.mode = "primary";
         item.hidden = true;
       });
-      editor.update(exports_agent.ID.make("title"), (item) => {
-        item.name = exports_agent.Name.make("Title");
+      editor.update(ID18.make("title"), (item) => {
+        item.name = Name3.make("Title");
         item.mode = "primary";
         item.hidden = true;
         item.system = PROMPT_TITLE;
         item.permissions.push({ action: "*", resource: "*", effect: "deny" });
       });
-      editor.update(exports_agent.ID.make("summary"), (item) => {
-        item.name = exports_agent.Name.make("Summary");
+      editor.update(ID18.make("summary"), (item) => {
+        item.name = Name3.make("Summary");
         item.mode = "primary";
         item.hidden = true;
         item.system = PROMPT_SUMMARY;
@@ -146,4 +148,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_agent2 as exports_agent };
+export { Plugin12, exports_agent };

package/dist/chunks/{schema-qc2gqwkb.js → event-logger-n6g7b5d4.js}

@@ -1,55 +1,56 @@
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_project
-} from "./schema-2g4twk0n.js";
+  root2
+} from "./event-logger-kfyw9f0s.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/location-mutation.ts
 var exports_location_mutation = {};
 __export(exports_location_mutation, {
-  Kind: () => Kind,
+  Kind: () => Kind2,
   LocationMutation: () => exports_location_mutation,
-  ResolveInput: () => ResolveInput,
-  Service: () => Service,
-  externalDirectoryPermission: () => externalDirectoryPermission,
-  node: () => node,
-  resolvePath: () => resolvePath
+  ResolveInput: () => ResolveInput2,
+  Service: () => Service13,
+  externalDirectoryPermission: () => externalDirectoryPermission2,
+  node: () => node16,
+  resolvePath: () => resolvePath2
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import path from "path";
 import { Context, Effect, Layer, Schema } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-var Kind = Schema.Literals(["file", "directory"]);
-var ResolveInput = Schema.Struct({
+var Kind2 = Schema.Literals(["file", "directory"]);
+var ResolveInput2 = Schema.Struct({
   path: Schema.String,
-  kind: Kind.pipe(Schema.optional)
+  kind: Kind2.pipe(Schema.optional)
 });
-var externalDirectoryPermission = (input) => ({
+var externalDirectoryPermission2 = (input) => ({
   action: input.action,
   resources: [input.resource],
   save: [input.save]
 });
-var resolvePath = (directory, input, home = Global.Path.home) => {
+var resolvePath2 = (directory, input, home = Global.Path.home) => {
   const normalized = FSUtil.windowsPath(input);
   return path.resolve(directory, normalized === "~" ? home : normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\") ? path.join(home, normalized.slice(2)) : normalized);
 };
 
-class Service extends Context.Service()("@opencode/LocationMutation") {
+class Service13 extends Context.Service()("@opencode/LocationMutation") {
 }
 var slash = (value) => value.replaceAll("\\", "/");
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service13, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const location = yield* exports_location.Service;
+  const location = yield* Service75;
   const resolve = Effect.fnUntraced(function* (input) {
-    const absolute = resolvePath(location.directory, input.path);
+    const absolute = resolvePath2(location.directory, input.path);
     const worktree = path.resolve(location.project.directory);
     const internal = FSUtil.contains(location.directory, absolute) || worktree !== path.parse(worktree).root && FSUtil.contains(worktree, absolute);
     if (internal) {
@@ -68,16 +69,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         action: "external_directory",
         directory: externalDirectory,
         resource: externalResource,
-        save: slash(path.join((yield* exports_project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"))
+        save: slash(path.join((yield* root2(fs, AbsolutePath2.make(externalDirectory))) ?? externalDirectory, "*"))
       }
     };
   });
-  return Service.of({ resolve });
+  return Service13.of({ resolve });
 }));
-var node = makeLocationNode({
-  service: Service,
+var node16 = makeLocationNode({
+  service: Service13,
   layer,
-  deps: [FSUtil.node, exports_location.node]
+  deps: [FSUtil.node, node80]
 });
 
-export { Kind, ResolveInput, externalDirectoryPermission, resolvePath, Service, node, exports_location_mutation };
+export { Kind2, ResolveInput2, externalDirectoryPermission2, resolvePath2, Service13, node16, exports_location_mutation };

package/dist/chunks/event-logger-n6wnzfnt.js

@@ -0,0 +1,147 @@
+import {
+  SessionMessage2
+} from "./event-logger-982e01ww.js";
+import {
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/session/error.ts
+var exports_error2 = {};
+__export(exports_error2, {
+  AgentNotFoundError: () => AgentNotFoundError2,
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  ForkEmptyError: () => ForkEmptyError2,
+  InboxConflictError: () => InboxConflictError2,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError9,
+  PromptConflictError: () => PromptConflictError2,
+  SessionErrors: () => exports_error2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  StepFailedError: () => StepFailedError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  UserInterruptedError: () => UserInterruptedError2
+});
+import { Schema } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Skill } from "@opencode-ai/schema/skill";
+import { SessionError } from "@opencode-ai/schema/session-error";
+
+class NotFoundError9 extends Schema.TaggedError()("Session.NotFoundError", {
+  sessionID: SessionSchema2.ID
+}) {
+}
+
+class MessageNotFoundError2 extends Schema.TaggedError()("Session.MessageNotFoundError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageNotAssistantError2 extends Schema.TaggedError()("Session.MessageNotAssistantError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageIncompleteError2 extends Schema.TaggedError()("Session.MessageIncompleteError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageToolIncompleteError2 extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class ForkEmptyError2 extends Schema.TaggedError()("Session.ForkEmptyError", {
+  sessionID: SessionSchema2.ID
+}) {
+  get message() {
+    return `Cannot fork empty session: ${this.sessionID}`;
+  }
+}
+
+class MessageDecodeError2 extends Schema.TaggedError()("Session.MessageDecodeError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+  get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`;
+  }
+}
+
+class AgentNotFoundError2 extends Schema.TaggedError()("Session.AgentNotFoundError", {
+  sessionID: SessionSchema2.ID,
+  agent: Agent.ID
+}) {
+  get message() {
+    return `Agent not found: "${this.agent}"`;
+  }
+}
+
+class StepFailedError2 extends Schema.TaggedError()("Session.StepFailedError", {
+  error: SessionError.Error
+}) {
+  get message() {
+    return this.error.message;
+  }
+}
+
+class UserInterruptedError2 extends Schema.TaggedError()("Session.UserInterruptedError", {}) {
+  get message() {
+    return "Session interrupted by user";
+  }
+}
+
+class PromptConflictError2 extends Schema.TaggedError()("Session.PromptConflictError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class SyntheticConflictError2 extends Schema.TaggedError()("Session.SyntheticConflictError", {
+  sessionID: SessionSchema2.ID,
+  inputID: SessionMessage2.ID
+}) {
+}
+
+class AttachmentError2 extends Schema.TaggedError()("Session.AttachmentError", {
+  uri: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CompactionConflictError2 extends Schema.TaggedError()("Session.CompactionConflictError", {
+  sessionID: SessionSchema2.ID,
+  inputID: SessionMessage2.ID
+}) {
+}
+
+class BusyError2 extends Schema.TaggedError()("Session.BusyError", {
+  sessionID: SessionSchema2.ID
+}) {
+}
+
+class InboxConflictError2 extends Schema.TaggedError()("Session.InboxConflictError", {
+  sessionID: SessionSchema2.ID,
+  inboxID: SessionMessage2.ID
+}) {
+}
+
+class SkillNotFoundError2 extends Schema.TaggedError()("Session.SkillNotFoundError", {
+  skill: Skill.ID
+}) {
+}
+
+export { NotFoundError9, MessageNotFoundError2, MessageNotAssistantError2, MessageIncompleteError2, MessageToolIncompleteError2, ForkEmptyError2, MessageDecodeError2, AgentNotFoundError2, StepFailedError2, UserInterruptedError2, PromptConflictError2, SyntheticConflictError2, AttachmentError2, CompactionConflictError2, BusyError2, InboxConflictError2, SkillNotFoundError2, exports_error2 };

package/dist/chunks/{schema-ycjmzejc.js → event-logger-n9s43yzq.js}

@@ -1,26 +1,27 @@
 import {
-  exports_wellknown
-} from "./schema-serjdnzw.js";
+  Service79
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service51,
+  Event10
+} from "./event-logger-yjj59j99.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/wellknown/plugin.ts
 var exports_plugin = {};
 __export(exports_plugin, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin43,
   WellKnownPlugin: () => exports_plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
-var Plugin = define({
+var Plugin43 = define({
   id: "opencode.wellknown",
   effect: Effect.fn(function* (ctx) {
-    const bus = yield* exports_bus.Service;
-    const wellknown = yield* exports_wellknown.Service;
+    const bus = yield* Service79;
+    const wellknown = yield* Service51;
     yield* wellknown.entries().pipe(Effect.orDie);
     yield* ctx.integration.transform((editor) => {
       wellknown.snapshot().forEach((entry) => {
@@ -40,8 +41,8 @@ var Plugin = define({
         });
       });
     });
-    yield* bus.subscribe(exports_wellknown.Event.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event10.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
   })
 });
 
-export { Plugin, exports_plugin };
+export { Plugin43, exports_plugin };

package/dist/chunks/{schema-63c3fvvm.js → event-logger-p08wj8bf.js}

@@ -1,20 +1,26 @@
 import {
-  exports_instance
-} from "./schema-600p3j5r.js";
+  Service50,
+  node53,
+  canonical3
+} from "./event-logger-5jayeb3j.js";
 import {
-  exports_location_service_map
-} from "./schema-bbd9spwe.js";
+  Service33,
+  node36
+} from "./event-logger-yhtqjkzd.js";
+import {
+  layer2
+} from "./event-logger-ze44yzpk.js";
 
 // src/location-services.ts
 import { Duration, Effect, Exit, Layer, LayerMap, MutableHashMap, Option } from "effect";
-function buildLocationServiceMap(replacements = []) {
-  return Layer.effect(exports_location_service_map.Service, Effect.gen(function* () {
+function buildLocationServiceMap2(replacements = []) {
+  return Layer.effect(Service50, Effect.gen(function* () {
     const owner = yield* Effect.scope;
     const booting = MutableHashMap.empty();
     const inner = yield* LayerMap.make((ref) => {
       const build = {};
       MutableHashMap.set(booting, ref, build);
-      return Layer.fromBuild((memoMap, scope) => Effect.suspend(() => Layer.buildWithMemoMap(exports_instance.layer(ref, { replacements: bindings }), memoMap, scope)).pipe(Effect.onExit((exit) => {
+      return Layer.fromBuild((memoMap, scope) => Effect.suspend(() => Layer.buildWithMemoMap(layer2(ref, { replacements: bindings }), memoMap, scope)).pipe(Effect.onExit((exit) => {
         const finish = Effect.suspend(() => {
           if (Option.getOrUndefined(MutableHashMap.get(booting, ref)) !== build)
             return Effect.void;
@@ -26,24 +32,24 @@ function buildLocationServiceMap(replacements = []) {
     }, { idleTimeToLive: Duration.infinity });
     const map = {
       ...inner,
-      get: (ref) => inner.get(exports_location_service_map.canonical(ref)),
-      contextEffect: (ref) => inner.contextEffect(exports_location_service_map.canonical(ref)),
-      contextEffectOption: (ref) => inner.contextEffectOption(exports_location_service_map.canonical(ref)),
+      get: (ref) => inner.get(canonical3(ref)),
+      contextEffect: (ref) => inner.contextEffect(canonical3(ref)),
+      contextEffectOption: (ref) => inner.contextEffectOption(canonical3(ref)),
       invalidate: (ref) => Effect.suspend(() => {
-        const key = exports_location_service_map.canonical(ref);
+        const key = canonical3(ref);
         MutableHashMap.remove(booting, key);
         return inner.invalidate(key);
       })
     };
     const bindings = [
-      exports_instance.node.replace(Layer.succeed(exports_instance.Service, {
+      node36.replace(Layer.succeed(Service33, {
         provide: (session) => Effect.provide(map.get(session.location))
       })),
       ...replacements,
-      exports_location_service_map.node.replace(Layer.succeed(exports_location_service_map.Service, map))
+      node53.replace(Layer.succeed(Service50, map))
     ];
     return map;
   }));
 }
 
-export { buildLocationServiceMap };
+export { buildLocationServiceMap2 };

package/dist/chunks/{schema-vytq6tc6.js → event-logger-p2k6rx42.js}

@@ -1,76 +1,83 @@
 import {
-  exports_location_mutation
-} from "./schema-qc2gqwkb.js";
+  typeFollowing2
+} from "./event-logger-2a5m3afh.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./schema-s5c7wyma.js";
+  Service75
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_ripgrep
-} from "./schema-bbwsb44a.js";
+  Service65
+} from "./event-logger-22drdanb.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Service18
+} from "./event-logger-dsf4qpn2.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry2
+} from "./event-logger-7vg7b77p.js";
 import {
-  RelativePath
-} from "./schema-j07kk359.js";
+  externalDirectoryPermission2,
+  Service13
+} from "./event-logger-n6g7b5d4.js";
+import {
+  Service71
+} from "./event-logger-yzjhj2th.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/plugin/glob.ts
 var exports_glob = {};
 __export(exports_glob, {
   GlobTool: () => exports_glob,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
-  name: () => name,
-  toModelContent: () => toModelContent
+  Input: () => Input5,
+  Output: () => Output2,
+  Plugin: () => Plugin18,
+  name: () => name5,
+  toModelContent: () => toModelContent3
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import path from "path";
-var name = "glob";
-var Input = Schema.Struct({
-  pattern: exports_filesystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
-  path: Schema.optionalKey(RelativePath).annotate({
+var name5 = "glob";
+var Input5 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
     description: "Directory to search. Defaults to the current working directory."
   }),
-  hidden: exports_filesystem.GlobInput.fields.hidden.annotate({
+  hidden: GlobInput2.fields.hidden.annotate({
     description: "Include hidden files and directories (default: false)."
   }),
-  limit: exports_filesystem.GlobInput.fields.limit.annotate({
-    description: `Maximum number of matching files to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
   })
 });
-var Output = Schema.Array(exports_filesystem.Entry);
-var toModelContent = (entries, truncated = false) => {
+var Output2 = Schema.Array(Entry2);
+var toModelContent3 = (entries, truncated = false) => {
   const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
   if (truncated)
     lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
   return lines.join(`
 `);
 };
-var Plugin = {
+var Plugin18 = {
   id: "opencode.tool.glob",
   effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
-    const environment = yield* exports_environment.Service;
-    const ripgrep = yield* exports_ripgrep.Service;
-    const location = yield* exports_location.Service;
-    const mutation = yield* exports_location_mutation.Service;
-    const permission = yield* exports_permission.Service;
+    const environment = yield* Service65;
+    const ripgrep = yield* Service18;
+    const location = yield* Service75;
+    const mutation = yield* Service13;
+    const permission = yield* Service71;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name5,
       options: { codemode: false },
       description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
-      input: Input,
-      output: Output,
+      input: Input5,
+      output: Output2,
       execute: (input, context) => Effect.gen(function* () {
         const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
         const source = { type: "tool", messageID: context.messageID, id: context.id };
@@ -78,13 +85,13 @@ var Plugin = {
         const external = target.externalDirectory;
         if (external)
           yield* permission.assert({
-            ...exports_location_mutation.externalDirectoryPermission(external),
+            ...externalDirectoryPermission2(external),
             sessionID: context.sessionID,
             agent: context.agent,
             source
           });
         yield* permission.assert({
-          action: name,
+          action: name5,
           resources: [input.pattern],
           save: ["*"],
           metadata: {
@@ -97,33 +104,33 @@ var Plugin = {
           agent: context.agent,
           source
         });
-        const type = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
         if (type !== "directory")
           return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
         const root = target.absolute;
-        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
         const entries = yield* ripgrep.glob({
           cwd: root,
           pattern: input.pattern,
           hidden: input.hidden,
           limit: limit + 1
         }).pipe(Effect.timeoutOrElse({
-          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
           orElse: () => Effect.fail(new ToolFailure({
-            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
           }))
-        }), Effect.map((result) => result.map((entry) => exports_filesystem.Entry.make({
+        }), Effect.map((result) => result.map((entry) => Entry2.make({
           ...entry,
-          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path)))
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
         }))));
         return { entries: entries.slice(0, limit), truncated: entries.length > limit };
       }).pipe(Effect.map((result) => ({
         output: result.entries,
-        content: toModelContent(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        content: toModelContent3(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
         metadata: { count: result.entries.length, truncated: result.truncated }
       })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
     })).pipe(Effect.orDie);
   })
 };
 
-export { name, Input, Output, toModelContent, Plugin, exports_glob };
+export { name5, Input5, Output2, toModelContent3, Plugin18, exports_glob };