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

package/dist/chunks/{schema-x4jfk7d8.js → event-logger-q8ktfbaq.js}

@@ -1,48 +1,57 @@
 import {
-  exports_environment as exports_environment2
-} from "./schema-zn935gjz.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_tool_output
-} from "./schema-6b7ybj1y.js";
+  Service65,
+  node69
+} from "./event-logger-22drdanb.js";
 import {
-  exports_hooks
-} from "./schema-xws7arpm.js";
+  cleanup3
+} from "./event-logger-gd4qta3r.js";
 import {
-  SessionSchema
-} from "./schema-bjwj8hwv.js";
+  Service58,
+  args2,
+  node61
+} from "./event-logger-12m9a30f.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Service74,
+  node79
+} from "./event-logger-t00n1yfv.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service47,
+  node50
+} from "./event-logger-wf1mfr52.js";
 import {
-  exports_file_retention
-} from "./schema-p1m5qwvv.js";
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
 import {
-  exports_select
-} from "./schema-xvqr7khp.js";
+  latest2,
+  Service48,
+  node51
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  MAX_LINES2,
+  MAX_BYTES2
+} from "./event-logger-ecjyhxv0.js";
 import {
-  __export,
-  __require
-} from "./schema-vpjkya7h.js";
+  __export
+} from "./event-logger-9rqn6x4v.js";
 
 // src/shell.ts
-var exports_shell = {};
-__export(exports_shell, {
-  DIRECTORY: () => DIRECTORY,
-  NotFoundError: () => NotFoundError,
-  RETENTION: () => RETENTION,
-  Service: () => Service,
-  Shell: () => exports_shell,
-  cleanup: () => cleanup,
-  node: () => node
+var exports_shell4 = {};
+__export(exports_shell4, {
+  DIRECTORY: () => DIRECTORY2,
+  NotFoundError: () => NotFoundError5,
+  RETENTION: () => RETENTION2,
+  Service: () => Service46,
+  Shell: () => exports_shell4,
+  cleanup: () => cleanup2,
+  node: () => node49
 });
 import path from "path";
 import { Context, Deferred, Duration, Effect, Fiber, Latch, Layer, Schema, Schedule, Stream } from "effect";
@@ -53,44 +62,44 @@ import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-class NotFoundError extends Schema.TaggedError()("Shell.NotFoundError", {
+class NotFoundError5 extends Schema.TaggedError()("Shell.NotFoundError", {
   id: Shell.ID
 }) {
 }
 var EXITED_LIMIT = 25;
-var RETENTION = Duration.days(7);
-var DIRECTORY = "shell";
+var RETENTION2 = Duration.days(7);
+var DIRECTORY2 = "shell";
 
-class Service extends Context.Service()("@opencode/Shell") {
+class Service46 extends Context.Service()("@opencode/Shell") {
 }
-var cleanup = Effect.fn("Shell.cleanup")(function* () {
+var cleanup2 = Effect.fn("Shell.cleanup")(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
-  const directory = path.join(global.data, DIRECTORY);
+  const directory = path.join(global.data, DIRECTORY2);
   const projects = yield* fs.readDirectoryEntries(directory).pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "directory")), Effect.orElseSucceed(() => []));
   const files = yield* Effect.forEach(projects, (project) => fs.readDirectoryEntries(path.join(directory, project.name)).pipe(Effect.map((entries) => entries.flatMap((entry) => entry.type === "file" && /^sh_[0-9a-f]{12}.*\.out$/.test(entry.name) ? [path.join(directory, project.name, entry.name)] : [])), Effect.orElseSucceed(() => [])), { concurrency: 8 });
-  yield* exports_file_retention.cleanup(fs, files.flat(), RETENTION);
+  yield* cleanup3(fs, files.flat(), RETENTION2);
 });
-var cleanupLayer = Layer.effectDiscard(cleanup().pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped));
+var cleanupLayer = Layer.effectDiscard(cleanup2().pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped));
 var cleanupNode = makeGlobalNode({
   name: "shell-output-cleanup",
   layer: cleanupLayer,
   deps: [FSUtil.node, Global.node]
 });
-var layer = () => Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const location = yield* exports_location.Service;
+var layer = () => Layer.effect(Service46, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service75;
   const global = yield* Global.Service;
-  const shell = yield* exports_select.Service;
-  const environment = yield* exports_environment.Service;
-  const hooks = yield* exports_hooks.Service;
-  const environments = yield* exports_environment2.Service;
-  const config = yield* exports_config.Service;
+  const shell = yield* Service58;
+  const environment = yield* Service65;
+  const hooks = yield* Service74;
+  const environments = yield* Service47;
+  const config = yield* Service48;
   const context = yield* Effect.context();
   const runFork = Effect.runForkWith(context);
   const commands = new Map;
   const exitOrder = [];
-  const outputDir = path.join(global.data, DIRECTORY, location.project.id);
+  const outputDir = path.join(global.data, DIRECTORY2, location.project.id);
   const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"));
   const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"));
   yield* Effect.promise(() => mkdir(outputDir, { recursive: true }));
@@ -106,7 +115,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
   const require2 = Effect.fnUntraced(function* (id) {
     const command = commands.get(id);
     if (!command)
-      return yield* new NotFoundError({ id });
+      return yield* new NotFoundError5({ id });
     return command;
   });
   const removeCommand = Effect.fnUntraced(function* (id) {
@@ -119,7 +128,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
     commands.delete(id);
     if (command.timeoutFiber)
       yield* Fiber.interrupt(command.timeoutFiber);
-    yield* Deferred.fail(command.done, new NotFoundError({ id }));
+    yield* Deferred.fail(command.done, new NotFoundError5({ id }));
     yield* Effect.promise(() => unlink(command.file).catch(() => {}));
     yield* bus.publish(Shell.Event.Deleted, { id });
   });
@@ -173,9 +182,9 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
   const result = Effect.fn("Shell.result")(function* (started) {
     const info = yield* wait(started.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed({ ...started, status: "killed", time: { ...started.time, completed: Date.now() } })));
     const capture = yield* Effect.gen(function* () {
-      const limits = exports_config.latest(yield* config.entries(), "tool_output");
-      const maxLines = limits?.max_lines ?? exports_tool_output.MAX_LINES;
-      const maxBytes = limits?.max_bytes ?? exports_tool_output.MAX_BYTES;
+      const limits = latest2(yield* config.entries(), "tool_output");
+      const maxLines = limits?.max_lines ?? MAX_LINES2;
+      const maxBytes = limits?.max_bytes ?? MAX_BYTES2;
       const latest = yield* output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
       const page = yield* output(info.id, { cursor: Math.max(0, latest.size - maxBytes), limit: maxBytes });
       const lines = page.output.split(`
@@ -195,7 +204,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
   });
   const create = Effect.fn("Shell.create")(function* (input, before) {
     const sessionID = input.metadata?.sessionID;
-    const sessionEnvironment = location.workspaceID === undefined && Schema.is(SessionSchema.ID)(sessionID) ? yield* environments.get(sessionID) : undefined;
+    const sessionEnvironment = location.workspaceID === undefined && Schema.is(SessionSchema2.ID)(sessionID) ? yield* environments.get(sessionID) : undefined;
     const invocation = {
       command: input.command,
       cwd: input.cwd ?? location.directory,
@@ -211,7 +220,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
     if (before)
       yield* before(invocation);
     const id = Shell.ID.ascending();
-    const args = exports_select.args(invocation.shell, invocation.command);
+    const args = args2(invocation.shell, invocation.command);
     const file = path.join(outputDir, `${id}.out`);
     const info = {
       id,
@@ -232,7 +241,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         detached: process.platform !== "win32",
         forceKillAfter: Duration.seconds(3)
       })).pipe(Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })));
-      const command2 = {
+      const command = {
         info: produce(info, (draft) => {
           draft.pid = handle.pid;
         }),
@@ -240,12 +249,12 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         size: 0,
         done: Deferred.makeUnsafe()
       };
-      commands.set(id, command2);
+      commands.set(id, command);
       const stream = createWriteStream(file);
       const outputDone = Latch.makeUnsafe();
       const pump = handle.all.pipe(Stream.runForEach((chunk) => Effect.sync(() => {
         stream.write(chunk);
-        command2.size += chunk.length;
+        command.size += chunk.length;
       })));
       runFork(Effect.gen(function* () {
         yield* pump.pipe(Effect.catch(() => Effect.void));
@@ -259,9 +268,9 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         stream.once("error", () => resolve());
       }));
       const finish = (status, exit, beforeWait = Effect.void) => Effect.gen(function* () {
-        if (command2.info.status !== "running")
+        if (command.info.status !== "running")
           return;
-        command2.info = produce(command2.info, (draft) => {
+        command.info = produce(command.info, (draft) => {
           draft.status = status;
           if (exit !== undefined)
             draft.exit = exit;
@@ -269,7 +278,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
         });
         yield* beforeWait;
         yield* outputDone.await;
-        yield* Deferred.succeed(command2.done, command2.info);
+        yield* Deferred.succeed(command.done, command.info);
         yield* bus.publish(Shell.Event.Exited, {
           id,
           ...exit !== undefined ? { exit } : {},
@@ -282,45 +291,45 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
             break;
           yield* removeCommand(oldest);
         }
-        const timeoutFiber = command2.timeoutFiber;
-        command2.timeout = undefined;
-        command2.timeoutFiber = undefined;
+        const timeoutFiber = command.timeoutFiber;
+        command.timeout = undefined;
+        command.timeoutFiber = undefined;
         if (timeoutFiber)
           yield* Fiber.interrupt(timeoutFiber);
       });
-      command2.timeout = (duration) => Effect.gen(function* () {
-        if (command2.timeoutFiber)
-          yield* Fiber.interrupt(command2.timeoutFiber);
-        command2.timeoutFiber = undefined;
-        if (duration === 0 || command2.info.status !== "running")
+      command.timeout = (duration) => Effect.gen(function* () {
+        if (command.timeoutFiber)
+          yield* Fiber.interrupt(command.timeoutFiber);
+        command.timeoutFiber = undefined;
+        if (duration === 0 || command.info.status !== "running")
           return;
-        command2.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill({ forceKillAfter: Duration.seconds(3) }).pipe(Effect.catch(() => Effect.void))))));
+        command.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill({ forceKillAfter: Duration.seconds(3) }).pipe(Effect.catch(() => Effect.void))))));
       });
-      yield* command2.timeout(invocation.timeout);
+      yield* command.timeout(invocation.timeout);
       runFork(handle.exitCode.pipe(Effect.flatMap((code) => finish("exited", code)), Effect.catch(() => finish("exited"))));
       yield* bus.publish(Shell.Event.Created, { info });
-      yield* Deferred.succeed(ready, command2);
-      yield* Deferred.await(command2.done).pipe(Effect.catch(() => Effect.void));
+      yield* Deferred.succeed(ready, command);
+      yield* Deferred.await(command.done).pipe(Effect.catch(() => Effect.void));
     })).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))));
     const command = yield* Deferred.await(ready);
     return command.info;
   });
-  return Service.of({ create, list, get, wait, result, timeout, output, remove });
+  return Service46.of({ create, list, get, wait, result, timeout, output, remove });
 }));
-var node = makeLocationNode({
-  service: Service,
+var node49 = makeLocationNode({
+  service: Service46,
   layer: layer(),
   deps: [
-    exports_bus.node,
-    exports_location.node,
+    node84,
+    node80,
     Global.node,
-    exports_select.node,
-    exports_environment.node,
-    exports_hooks.node,
-    exports_environment2.node,
-    exports_config.node,
+    node61,
+    node69,
+    node79,
+    node50,
+    node51,
     cleanupNode
   ]
 });
 
-export { NotFoundError, RETENTION, DIRECTORY, Service, cleanup, node, exports_shell };
+export { NotFoundError5, RETENTION2, DIRECTORY2, Service46, cleanup2, node49, exports_shell4 };

package/dist/chunks/{schema-k3e42drn.js → event-logger-qaymkmh1.js}

@@ -1,7 +1,7 @@
 // src/util/which.ts
 import whichPkg from "which";
 import path from "path";
-function which(cmd, env, bin) {
+function which2(cmd, env, bin) {
   const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
   const full = base && bin ? base + path.delimiter + bin : base || bin;
   return whichPkg.sync(cmd, {
@@ -11,4 +11,4 @@ function which(cmd, env, bin) {
   });
 }
 
-export { which };
+export { which2 };

package/dist/chunks/{schema-sem2g21k.js → event-logger-qfa1cgps.js}

@@ -1,8 +1,8 @@
 // src/database/schema.sql.ts
 import { integer } from "drizzle-orm/sqlite-core";
-var Timestamps = {
+var Timestamps2 = {
   time_created: integer().notNull().$default(() => Date.now()),
   time_updated: integer().notNull().$onUpdate(() => Date.now())
 };
 
-export { Timestamps };
+export { Timestamps2 };

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

@@ -0,0 +1,38 @@
+import {
+  latest2,
+  Service48
+} from "./event-logger-47b3sbnz.js";
+import {
+  Service45
+} from "./event-logger-ah7grg4z.js";
+import {
+  observe2
+} from "./event-logger-qsdy395h.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/config/plugin/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  ConfigSnapshotPlugin: () => exports_snapshot,
+  Plugin: () => Plugin27
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin27 = define({
+  id: "opencode.config.snapshot",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service48;
+    const snapshot = yield* Service45;
+    const loaded = yield* observe2(config, ctx.event, snapshot.reload());
+    yield* snapshot.transform((editor) => {
+      const configured = latest2(loaded.entries, "snapshots");
+      if (configured === undefined)
+        return;
+      editor.configure(configured);
+    });
+  })
+});
+
+export { Plugin27, exports_snapshot };

package/dist/chunks/{schema-qf52r0wh.js → event-logger-qja7rspw.js}

@@ -1,32 +1,32 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/instance.ts
-var exports_instance = {};
-__export(exports_instance, {
-  InstancePlugins: () => exports_instance,
-  Service: () => Service,
-  bound: () => bound,
-  node: () => node
+var exports_instance2 = {};
+__export(exports_instance2, {
+  InstancePlugins: () => exports_instance2,
+  Service: () => Service3,
+  bound: () => bound2,
+  node: () => node6
 });
 import { Context, Layer } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 
-class Service extends Context.Service()("@opencode/InstancePlugins") {
+class Service3 extends Context.Service()("@opencode/InstancePlugins") {
 }
-var node = makeLocationNode({
-  service: Service,
-  layer: bound([]),
+var node6 = makeLocationNode({
+  service: Service3,
+  layer: bound2([]),
   deps: []
 });
-function bound(plugins) {
+function bound2(plugins) {
   const duplicates = plugins.filter((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index);
   if (duplicates.length > 0) {
     throw new Error(`duplicate instance plugin ids: ${duplicates.map((plugin) => plugin.id).join(", ")}`);
   }
   const stamped = plugins.map((plugin) => ({ ...plugin, revision: "instance", source: { type: "sdk" } }));
-  return Layer.succeed(Service, Service.of({ all: () => stamped }));
+  return Layer.succeed(Service3, Service3.of({ all: () => stamped }));
 }
 
-export { Service, node, bound, exports_instance };
+export { Service3, node6, bound2, exports_instance2 };

package/dist/chunks/{schema-7cnts1xz.js → event-logger-qk60q5g0.js}

@@ -1,44 +1,47 @@
 import {
-  exports_subagent_job
-} from "./schema-jfv5epsj.js";
+  ID18,
+  Service78
+} from "./event-logger-8ab07kvc.js";
 import {
-  exports_subagent_completion
-} from "./schema-hbtzhcxr.js";
+  latest2,
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_session
-} from "./schema-q1h731cc.js";
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
 import {
-  exports_job
-} from "./schema-dt5yw4ma.js";
+  Service44
+} from "./event-logger-c2khgprk.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  evaluate2,
+  Service71
+} from "./event-logger-yzjhj2th.js";
 import {
-  exports_agent
-} from "./schema-p6fb92cp.js";
+  Service23
+} from "./event-logger-f4kct4fj.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  NO_TEXT2
+} from "./event-logger-x1ezjp6w.js";
 import {
-  SessionSchema
-} from "./schema-bjwj8hwv.js";
+  make8
+} from "./event-logger-ppjnvzpn.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/plugin/subagent.ts
 var exports_subagent = {};
 __export(exports_subagent, {
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
+  Input: () => Input7,
+  Output: () => Output4,
+  Plugin: () => Plugin20,
   SubagentTool: () => exports_subagent,
-  description: () => description,
-  name: () => name
+  description: () => description4,
+  name: () => name7
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
-var name = "subagent";
+var name7 = "subagent";
 var backgroundResult = (sessionID) => ({
   sessionID,
   status: "running",
@@ -49,23 +52,23 @@ var backgroundResult = (sessionID) => ({
   ].join(`
 `)
 });
-var Input = Schema.Struct({
+var Input7 = Schema.Struct({
   agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
   description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
   prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
-  sessionID: Schema.optionalKey(SessionSchema.ID).annotate({
+  sessionID: Schema.optionalKey(SessionSchema2.ID).annotate({
     description: "Continue a specific previous subagent conversation by passing its sessionID. Calls without a sessionID start a new conversation."
   }),
   background: Schema.optionalKey(Schema.Boolean).annotate({
     description: "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress."
   })
 });
-var Output = Schema.Struct({
-  sessionID: SessionSchema.ID,
+var Output4 = Schema.Struct({
+  sessionID: SessionSchema2.ID,
   status: Schema.Literals(["completed", "running"]),
   output: Schema.String
 });
-var description = [
+var description4 = [
   "Spawns an agent in a child session to work on the specified task.",
   "The output includes a sessionID you can pass back later to continue that specific conversation with the subagent.",
   "New child sessions start with fresh context, so include all relevant context and instructions when you don't pass a sessionID.",
@@ -74,21 +77,21 @@ var description = [
   "Use background only for independent work that can run while you continue elsewhere."
 ].join(`
 `);
-var Plugin = {
+var Plugin20 = {
   id: "opencode.tool.subagent",
   effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
-    const sessions = yield* exports_session.Service;
-    const jobs = yield* exports_job.Service;
-    const agents = yield* exports_agent.Service;
-    const config = yield* exports_config.Service;
-    const permission = yield* exports_permission.Service;
-    const subagents = yield* exports_subagent_job.make;
+    const sessions = yield* Service23;
+    const jobs = yield* Service44;
+    const agents = yield* Service78;
+    const config = yield* Service48;
+    const permission = yield* Service71;
+    const subagents = yield* make8;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name7,
       options: { codemode: false },
-      description,
-      input: Input,
-      output: Output,
+      description: description4,
+      input: Input7,
+      output: Output4,
       execute: (input, context) => Effect.gen(function* () {
         const parent = yield* sessions.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
         let current = parent;
@@ -97,7 +100,7 @@ var Plugin = {
           depth++;
           current = yield* sessions.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
         }
-        const limit = exports_config.latest(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
+        const limit = latest2(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
         if (depth >= limit)
           return yield* new ToolFailure({
             message: `Subagent depth limit reached (${limit}). Increase "experimental.subagent_depth" to allow nested subagents.`
@@ -108,7 +111,7 @@ var Plugin = {
         if (agent.mode === "primary")
           return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` });
         yield* permission.assert({
-          action: name,
+          action: name7,
           resources: [agent.id],
           save: [agent.id],
           sessionID: context.sessionID,
@@ -131,7 +134,7 @@ var Plugin = {
         const child = existing ?? (yield* sessions.create({
           parentID: context.sessionID,
           title: input.description,
-          agent: exports_agent.ID.make(input.agent),
+          agent: ID18.make(input.agent),
           model
         }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }))));
         const background = input.background === true;
@@ -170,7 +173,7 @@ var Plugin = {
         return {
           sessionID: child.id,
           status: "completed",
-          output: result?.info.output ?? exports_subagent_completion.NO_TEXT
+          output: result?.info.output ?? NO_TEXT2
         };
       }).pipe(Effect.map((output) => ({
         output,
@@ -181,13 +184,13 @@ ${output.output}
       })))
     })).pipe(Effect.orDie);
     yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
-      const tool = event.tools[name];
+      const tool = event.tools[name7];
       if (!tool)
         return;
       const selected = yield* agents.resolve(event.agent);
       if (!selected)
         return;
-      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && exports_permission.evaluate(name, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
+      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && evaluate2(name7, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
       if (available.length === 0)
         return;
       tool.description = [
@@ -201,4 +204,4 @@ ${output.output}
   })
 };
 
-export { name, Input, Output, description, Plugin, exports_subagent };
+export { name7, Input7, Output4, description4, Plugin20, exports_subagent };

package/dist/chunks/{schema-mnyszbxc.js → event-logger-qsdy395h.js}

@@ -1,20 +1,20 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};
 __export(exports_entry_observer, {
   ConfigEntryObserver: () => exports_entry_observer,
-  observe: () => observe
+  observe: () => observe2
 });
 import { Effect, Stream } from "effect";
-var observe = Effect.fnUntraced(function* (config, event, reload) {
+var observe2 = Effect.fnUntraced(function* (config, event, reload) {
   const loaded = { entries: yield* config.entries() };
   const refresh = config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(reload));
-  yield* event.subscribe().pipe(Stream.filter((event2) => event2.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
+  yield* event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
   loaded.entries = yield* config.entries();
   return loaded;
 });
 
-export { observe, exports_entry_observer };
+export { observe2, exports_entry_observer };