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

package/dist/chunks/{schema-x4az4y7r.js → event-logger-k4bwy1x5.js}

@@ -1,15 +1,15 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/id/id.ts
 var exports_id = {};
 __export(exports_id, {
   Identifier: () => exports_id,
-  ascending: () => ascending,
+  ascending: () => ascending2,
   create: () => createID,
-  descending: () => descending,
-  timestamp: () => timestamp
+  descending: () => descending2,
+  timestamp: () => timestamp2
 });
 import { create } from "@opencode-ai/schema/identifier";
 var prefixes = {
@@ -24,10 +24,10 @@ var prefixes = {
   tool: "tool",
   workspace: "wrk"
 };
-function ascending(prefix, given) {
+function ascending2(prefix, given) {
   return generateID(prefix, "ascending", given);
 }
-function descending(prefix, given) {
+function descending2(prefix, given) {
   return generateID(prefix, "descending", given);
 }
 function generateID(prefix, direction, given) {
@@ -42,10 +42,10 @@ function generateID(prefix, direction, given) {
 function createID(prefix, direction, timestamp) {
   return prefix + "_" + create(direction === "descending", timestamp);
 }
-function timestamp(id) {
+function timestamp2(id) {
   const prefix = id.split("_")[0];
   const hex = id.slice(prefix.length + 1, prefix.length + 13);
   return Number(BigInt(`0x${hex}`) / 0x1000n);
 }
 
-export { ascending, descending, createID, timestamp, exports_id };
+export { ascending2, descending2, createID, timestamp2, exports_id };

package/dist/chunks/{schema-df3kvyqj.js → event-logger-kbg9q44r.js}

@@ -1,30 +1,30 @@
 import {
-  exports_entry_observer
-} from "./schema-mnyszbxc.js";
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_compaction
-} from "./schema-rgnjkg8c.js";
+  Service10
+} from "./event-logger-8xy158zb.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  observe2
+} from "./event-logger-qsdy395h.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/compaction.ts
-var exports_compaction2 = {};
-__export(exports_compaction2, {
-  ConfigCompactionPlugin: () => exports_compaction2,
-  Plugin: () => Plugin
+var exports_compaction = {};
+__export(exports_compaction, {
+  ConfigCompactionPlugin: () => exports_compaction,
+  Plugin: () => Plugin36
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin36 = define({
   id: "opencode.config.compaction",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const compaction = yield* exports_compaction.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, compaction.reload());
+    const config = yield* Service48;
+    const compaction = yield* Service10;
+    const loaded = yield* observe2(config, ctx.event, compaction.reload());
     yield* compaction.transform((editor) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document" || !entry.info.compaction)
@@ -39,4 +39,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_compaction2 as exports_compaction };
+export { Plugin36, exports_compaction };

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

@@ -0,0 +1,41 @@
+import {
+  latest2,
+  Service48
+} from "./event-logger-47b3sbnz.js";
+import {
+  Service54
+} from "./event-logger-ecjyhxv0.js";
+import {
+  observe2
+} from "./event-logger-qsdy395h.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/config/plugin/tool-output.ts
+var exports_tool_output = {};
+__export(exports_tool_output, {
+  ConfigToolOutputPlugin: () => exports_tool_output,
+  Plugin: () => Plugin42
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin42 = define({
+  id: "opencode.config.tool-output",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service48;
+    const output = yield* Service54;
+    const loaded = yield* observe2(config, ctx.event, output.reload());
+    yield* output.transform((editor) => {
+      const configured = latest2(loaded.entries, "tool_output");
+      if (!configured)
+        return;
+      editor.configure({
+        ...configured.max_lines === undefined ? {} : { maxLines: configured.max_lines },
+        ...configured.max_bytes === undefined ? {} : { maxBytes: configured.max_bytes }
+      });
+    });
+  })
+});
+
+export { Plugin42, exports_tool_output };

package/dist/chunks/{schema-2g4twk0n.js → event-logger-kfyw9f0s.js}

@@ -1,42 +1,50 @@
 import {
-  exports_schema
-} from "./schema-m7jtgrng.js";
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  WorktreeTable
-} from "./schema-gb1z7yet.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  ProjectTable,
-  upsertProject
-} from "./schema-c8ya26sa.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_git
-} from "./schema-qz5gwjr7.js";
+  Service77,
+  node82
+} from "./event-logger-jasnfvjs.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  ID17,
+  Current3,
+  Info31,
+  UpdateInput4,
+  Event19,
+  Vcs3
+} from "./event-logger-2cvfr09c.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  ProjectTable2,
+  upsertProject2
+} from "./event-logger-9qm9egsn.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  WorktreeTable2
+} from "./event-logger-ajtjthsy.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/project.ts
 var exports_project = {};
 __export(exports_project, {
-  Current: () => Current,
-  ID: () => ID,
-  Info: () => Info,
-  NotFoundError: () => NotFoundError,
+  Current: () => Current2,
+  ID: () => ID16,
+  Info: () => Info30,
+  NotFoundError: () => NotFoundError10,
   Project: () => exports_project,
-  Service: () => Service,
-  UpdateInput: () => UpdateInput,
-  Vcs: () => Vcs,
-  node: () => node,
-  root: () => root
+  Service: () => Service76,
+  UpdateInput: () => UpdateInput3,
+  Vcs: () => Vcs2,
+  node: () => node81,
+  root: () => root2
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -47,23 +55,23 @@ import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { Hash } from "@opencode-ai/util/hash";
-var ID = exports_schema.ID;
-var Vcs = exports_schema.Vcs;
-var Current = exports_schema.Current;
-var Info = exports_schema.Info;
-var UpdateInput = exports_schema.UpdateInput;
+var ID16 = ID17;
+var Vcs2 = Vcs3;
+var Current2 = Current3;
+var Info30 = Info31;
+var UpdateInput3 = UpdateInput4;
 
-class NotFoundError extends Schema.TaggedError()("Project.NotFoundError", {
-  projectID: ID
+class NotFoundError10 extends Schema.TaggedError()("Project.NotFoundError", {
+  projectID: ID16
 }) {
 }
-var root = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
-  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
+var root2 = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
+  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath2.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
     return;
   }));
 });
 
-class Service extends Context.Service()("@opencode/Project") {
+class Service76 extends Context.Service()("@opencode/Project") {
 }
 function fromRow(row) {
   const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
@@ -86,20 +94,20 @@ function fromRow(row) {
     sandboxes: row.sandboxes
   };
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service76, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service77;
   const proc = yield* AppProcess.Service;
-  const bus = yield* exports_bus.Service;
-  const db = (yield* exports_database.Service).db;
+  const bus = yield* Service79;
+  const db = (yield* Service80).db;
   const announcing = new Set;
   const persist = Effect.fnUntraced(function* (project) {
-    const previous = yield* db.select({ canonical: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, project.id)).get().pipe(Effect.orDie);
-    yield* upsertProject(db, project).pipe(Effect.orDie);
+    const previous = yield* db.select({ canonical: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, project.id)).get().pipe(Effect.orDie);
+    yield* upsertProject2(db, project).pipe(Effect.orDie);
     if (previous && previous.canonical !== project.canonical && !(yield* fs.exists(previous.canonical).pipe(Effect.orElseSucceed(() => true)))) {
-      const row = yield* db.update(ProjectTable).set({ worktree: project.canonical }).where(eq(ProjectTable.id, project.id)).returning().get().pipe(Effect.orDie);
+      const row = yield* db.update(ProjectTable2).set({ worktree: project.canonical }).where(eq(ProjectTable2.id, project.id)).returning().get().pipe(Effect.orDie);
       if (row)
-        yield* bus.publish(exports_schema.Event.Updated, fromRow(row));
+        yield* bus.publish(Event19.Updated, fromRow(row));
     }
     if (!project.vcs)
       return project;
@@ -118,11 +126,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         continue;
       announcing.add(key);
       yield* Effect.gen(function* () {
-        const stored = yield* db.select({ directory: WorktreeTable.directory }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, item.projectID), eq(WorktreeTable.directory, item.directory))).get().pipe(Effect.orDie);
+        const stored = yield* db.select({ directory: WorktreeTable2.directory }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, item.projectID), eq(WorktreeTable2.directory, item.directory))).get().pipe(Effect.orDie);
         if (stored)
           return;
-        const directory = AbsolutePath.make(yield* fs.resolve(item.directory));
-        const markerless = yield* db.select({ id: ProjectTable.id, directory: ProjectTable.worktree }).from(ProjectTable).where(and(isNull(ProjectTable.vcs), gte(ProjectTable.worktree, directory), lte(ProjectTable.worktree, AbsolutePath.make(directory + "￿")))).all().pipe(Effect.orDie);
+        const directory = AbsolutePath2.make(yield* fs.resolve(item.directory));
+        const markerless = yield* db.select({ id: ProjectTable2.id, directory: ProjectTable2.worktree }).from(ProjectTable2).where(and(isNull(ProjectTable2.vcs), gte(ProjectTable2.worktree, directory), lte(ProjectTable2.worktree, AbsolutePath2.make(directory + "￿")))).all().pipe(Effect.orDie);
         const adopted = yield* Effect.filter(markerless, (candidate) => Effect.gen(function* () {
           if (candidate.id === item.projectID)
             return false;
@@ -136,35 +144,35 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         yield* bus.publish(Worktree.Event.Resolved, {
           projectID: item.projectID,
           directory: item.directory,
-          previous: project.previous ?? ID.global,
+          previous: project.previous ?? ID16.global,
           ...adopted.length ? { adopted: adopted.map((candidate) => candidate.id) } : {}
         }, {
-          commit: () => db.insert(WorktreeTable).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
+          commit: () => db.insert(WorktreeTable2).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
         });
       }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))));
     }
     return project;
   });
   const list = Effect.fn("Project.list")(function* () {
-    const rows = yield* db.select().from(ProjectTable).orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id)).all().pipe(Effect.orDie);
+    const rows = yield* db.select().from(ProjectTable2).orderBy(desc(ProjectTable2.time_updated), asc(ProjectTable2.id)).all().pipe(Effect.orDie);
     return rows.map(fromRow);
   });
   const update = Effect.fn("Project.update")(function* (input) {
-    const row = yield* db.update(ProjectTable).set({
+    const row = yield* db.update(ProjectTable2).set({
       name: input.name === undefined ? undefined : input.name || null,
       icon_url_override: input.icon?.override === undefined ? undefined : input.icon.override || null,
       icon_color: input.icon?.color === undefined ? undefined : input.icon.color || null,
       commands: input.commands?.start === undefined ? undefined : input.commands.start ? { start: input.commands.start } : null,
       time_updated: Date.now()
-    }).where(eq(ProjectTable.id, input.projectID)).returning().get().pipe(Effect.orDie);
+    }).where(eq(ProjectTable2.id, input.projectID)).returning().get().pipe(Effect.orDie);
     if (!row)
-      return yield* new NotFoundError({ projectID: input.projectID });
+      return yield* new NotFoundError10({ projectID: input.projectID });
     const project = fromRow(row);
-    yield* bus.publish(exports_schema.Event.Updated, project);
+    yield* bus.publish(Event19.Updated, project);
     return project;
   });
   const cached = Effect.fnUntraced(function* (dir) {
-    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID.make(value) : undefined), Effect.orElseSucceed(() => {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID16.make(value) : undefined), Effect.orElseSucceed(() => {
       return;
     }));
   });
@@ -175,7 +183,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const normalized = url(origin);
     if (!normalized)
       return;
-    return ID.make(Hash.fast(`git-remote:${normalized}`));
+    return ID16.make(Hash.fast(`git-remote:${normalized}`));
   });
   function url(input) {
     const value = input.trim();
@@ -199,8 +207,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return `${host.toLowerCase()}/${pathname}`;
   }
   const rootCommit = Effect.fnUntraced(function* (repo) {
-    const root2 = (yield* git.history.rootCommits(repo))[0];
-    return root2 ? ID.make(root2) : undefined;
+    const root = (yield* git.history.rootCommits(repo))[0];
+    return root ? ID16.make(root) : undefined;
   });
   const hgRoot = Effect.fnUntraced(function* (worktree) {
     const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
@@ -216,39 +224,39 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     const node = result.stdout.toString("utf8").split(`
 `).map((item) => item.trim()).filter(Boolean).toSorted()[0];
-    return node ? ID.make(node) : undefined;
+    return node ? ID16.make(node) : undefined;
   });
   const hgDiscover = Effect.fnUntraced(function* (dotHg) {
-    const worktree = AbsolutePath.make(path.dirname(dotHg));
-    const store = AbsolutePath.make(dotHg);
+    const worktree = AbsolutePath2.make(path.dirname(dotHg));
+    const store = AbsolutePath2.make(dotHg);
     const previous = yield* cached(store);
     const id = previous ?? (yield* hgRoot(worktree));
     return {
       previous,
-      id: id ?? ID.global,
+      id: id ?? ID16.global,
       directory: worktree,
       vcs: { type: "hg", store }
     };
   });
   const resolve = Effect.fn("Project.resolve")(function* (input, _options) {
-    const directory = AbsolutePath.make(yield* fs.resolve(input));
+    const directory = AbsolutePath2.make(yield* fs.resolve(input));
     const native = yield* fs.up({ targets: [".git", ".hg"], start: directory, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
       return;
     }));
-    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath.make(path.dirname(native))) : undefined;
+    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath2.make(path.dirname(native))) : undefined;
     if (repo) {
       const previous = yield* cached(repo.commonDirectory);
       const id = (yield* remote(repo)) ?? previous ?? (yield* rootCommit(repo));
       const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.orElseSucceed(() => repo.worktree));
       return yield* persist({
         previous,
-        id: id ?? ID.global,
+        id: id ?? ID16.global,
         directory: repo.worktree,
         canonical,
         vcs: { type: "git", store: repo.commonDirectory }
       });
     }
-    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath.make(native)) : undefined;
+    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath2.make(native)) : undefined;
     if (hg) {
       return yield* persist({
         ...hg,
@@ -256,18 +264,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       });
     }
     return yield* persist({
-      id: ID.make(Hash.fast(`directory:${directory}`)),
+      id: ID16.make(Hash.fast(`directory:${directory}`)),
       directory,
       canonical: directory,
       vcs: undefined
     });
   });
-  return Service.of({ list, update, resolve });
+  return Service76.of({ list, update, resolve });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node81 = makeGlobalNode({
+  service: Service76,
   layer,
-  deps: [exports_bus.node, exports_database.node, FSUtil.node, exports_git.node, AppProcess.node]
+  deps: [node84, node85, FSUtil.node, node82, AppProcess.node]
 });
 
-export { ID, Vcs, Current, Info, UpdateInput, NotFoundError, root, Service, node, exports_project };
+export { ID16, Vcs2, Current2, Info30, UpdateInput3, NotFoundError10, root2, Service76, node81, exports_project };

package/dist/chunks/{schema-j6s3yjyb.js → event-logger-kg06axw8.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/state.ts
 var exports_state = {};
 __export(exports_state, {
   State: () => exports_state,
-  batch: () => batch,
-  create: () => create,
-  group: () => group,
-  inherit: () => inherit,
-  reconcile: () => reconcile,
-  shutdown: () => shutdown
+  batch: () => batch2,
+  create: () => create3,
+  group: () => group2,
+  inherit: () => inherit2,
+  reconcile: () => reconcile2,
+  shutdown: () => shutdown2
 });
 import { Cause, Context, Effect, Exit, Fiber, Scope } from "effect";
 var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
@@ -19,46 +19,46 @@ var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
     return;
   }
 });
-function group(report) {
-  const group2 = { failed: false, registrations: new Set, report };
-  return (effect) => Effect.provideService(effect, CurrentGroup, group2);
+function group2(report) {
+  const group = { failed: false, registrations: new Set, report };
+  return (effect) => Effect.provideService(effect, CurrentGroup, group);
 }
-function disable(group2, failure) {
-  if (group2.failed)
+function disable(group, failure) {
+  if (group.failed)
     return;
-  group2.failed = true;
+  group.failed = true;
   const notifications = new Set;
-  for (const registration of group2.registrations) {
+  for (const registration of group.registrations) {
     registration.remove();
     notifications.add(registration.notify);
   }
-  group2.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
+  group.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
 }
 var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
   defaultValue: () => {
     return;
   }
 });
-function batch(effect) {
+function batch2(effect) {
   return run(effect, false);
 }
-function shutdown(effect) {
+function shutdown2(effect) {
   return run(effect, true);
 }
-function run(effect, shutdown2) {
+function run(effect, shutdown) {
   return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
     const current = yield* CurrentBatch;
-    if (current?.active && !shutdown2)
+    if (current?.active && !shutdown)
       return yield* restore(effect);
-    const batch2 = { active: true, shutdown: shutdown2, notifications: new Set };
-    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch2))).pipe(Effect.exit);
-    batch2.active = false;
-    const notifications = yield* Effect.forEach(batch2.notifications, (notify) => restore(notify).pipe(Effect.exit));
+    const batch = { active: true, shutdown, notifications: new Set };
+    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch))).pipe(Effect.exit);
+    batch.active = false;
+    const notifications = yield* Effect.forEach(batch.notifications, (notify) => restore(notify).pipe(Effect.exit));
     yield* Exit.asVoidAll([exit, ...notifications]);
     return yield* exit;
   }));
 }
-function reconcile(root, fork, work) {
+function reconcile2(root, fork, work) {
   return Effect.gen(function* () {
     const exit = yield* Fiber.await(fork(work()));
     if (Exit.isFailure(exit) && root.state._tag === "Closed" && Cause.hasInterruptsOnly(exit.cause))
@@ -66,11 +66,11 @@ function reconcile(root, fork, work) {
     yield* exit;
   });
 }
-var inherit = Effect.fnUntraced(function* () {
-  const batch2 = yield* CurrentBatch;
-  return (effect) => Effect.provideService(effect, CurrentBatch, batch2);
+var inherit2 = Effect.fnUntraced(function* () {
+  const batch = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch);
 });
-function create(options) {
+function create3(options) {
   let state = options.initial();
   const transforms = new Set;
   let dirty = false;
@@ -116,13 +116,13 @@ function create(options) {
     if (closed)
       return;
     invalidate();
-    const batch2 = yield* CurrentBatch;
-    if (batch2?.active) {
-      if (batch2.shutdown) {
+    const batch = yield* CurrentBatch;
+    if (batch?.active) {
+      if (batch.shutdown) {
         closed = true;
         return;
       }
-      batch2.notifications.add(notify);
+      batch.notifications.add(notify);
       return;
     }
     yield* restore(notify);
@@ -132,16 +132,16 @@ function create(options) {
     transform: Effect.fn("State.transform")(function* (update) {
       yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
       const scope = yield* Scope.Scope;
-      const group2 = yield* CurrentGroup;
-      if (group2?.failed)
+      const group = yield* CurrentGroup;
+      if (group?.failed)
         return { dispose: Effect.void };
       return yield* Effect.uninterruptible(Effect.gen(function* () {
-        const transform = { run: update, group: group2 };
+        const transform = { run: update, group };
         const registration = {
           remove: () => {
             if (!transforms.delete(transform))
               return false;
-            group2?.registrations.delete(registration);
+            group?.registrations.delete(registration);
             invalidate();
             return true;
           },
@@ -149,7 +149,7 @@ function create(options) {
         };
         const dispose = Effect.uninterruptible(Effect.suspend(() => registration.remove() ? changed : Effect.void));
         transforms.add(transform);
-        group2?.registrations.add(registration);
+        group?.registrations.add(registration);
         yield* Scope.addFinalizer(scope, dispose);
         yield* changed;
         return { dispose };
@@ -159,4 +159,4 @@ function create(options) {
   };
 }
 
-export { group, batch, shutdown, reconcile, inherit, create, exports_state };
+export { group2, batch2, shutdown2, reconcile2, inherit2, create3, exports_state };

package/dist/chunks/{schema-a42y10z7.js → event-logger-kkxc5154.js}

@@ -1,26 +1,26 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/plugin/opencode.ts
 var exports_opencode = {};
 __export(exports_opencode, {
-  MoveInput: () => MoveInput,
+  MoveInput: () => MoveInput2,
   OpenCodeTools: () => exports_opencode,
-  Plugin: () => Plugin
+  Plugin: () => Plugin26
 });
 import { SystemPart, ToolFailure } from "@opencode-ai/ai";
 import { AbsolutePath } from "@opencode-ai/schema/schema";
 import { Session } from "@opencode-ai/schema/session";
 import { Effect, Schema } from "effect";
-var MoveInput = Schema.Struct({
+var MoveInput2 = Schema.Struct({
   sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to move the current session." }),
   directory: AbsolutePath.check(Schema.isMinLength(1)).annotate({
     description: "Destination directory, relative to the target session's directory or absolute. Supports ~."
   })
 });
 var MoveOutput = Schema.Struct({ sessionID: Session.ID, directory: AbsolutePath });
-var Plugin = {
+var Plugin26 = {
   id: "opencode.tools",
   effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
     yield* ctx.session.hook("context", (event) => Effect.sync(() => {
@@ -31,7 +31,7 @@ var Plugin = {
       draft.add({
         name: "session_move",
         description: "Move a session to another directory, or omit sessionID to move the current session. The current session moves at the next safe boundary; do not run destination-dependent tools in the same execute call.",
-        input: MoveInput,
+        input: MoveInput2,
         output: MoveOutput,
         options: { namespace: "opencode", codemode: true, pinned: true },
         execute: (input, context) => Effect.gen(function* () {
@@ -51,4 +51,4 @@ var Plugin = {
   })
 };
 
-export { MoveInput, Plugin, exports_opencode };
+export { MoveInput2, Plugin26, exports_opencode };