@opencode-ai/core 0.0.0-dev-19200 → 0.0.0-dev-19203

package/dist/chunks/{config-75yf2d83.js → schema-97f5v037.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/instructions/index.ts
 var exports_instructions6 = {};
@@ -10,7 +10,7 @@ __export(exports_instructions6, {
   Hash: () => Hash2,
   InitializationBlocked: () => InitializationBlocked2,
   Instructions: () => exports_instructions6,
-  Key: () => Key4,
+  Key: () => Key3,
   Values: () => Values2,
   applyHashDelta: () => applyHashDelta2,
   combine: () => combine2,
@@ -18,7 +18,7 @@ __export(exports_instructions6, {
   diffByKey: () => diffByKey2,
   empty: () => empty3,
   hash: () => hash2,
-  make: () => make21,
+  make: () => make20,
   read: () => read3,
   removed: () => removed2,
   renderInitial: () => renderInitial2,
@@ -28,7 +28,7 @@ __export(exports_instructions6, {
 import { createHash } from "crypto";
 import { Instruction } from "@opencode-ai/schema/instruction";
 import { Data, Effect, Option, Schema } from "effect";
-var Key4 = Instruction.Key;
+var Key3 = Instruction.Key;
 var Hash2 = Instruction.Hash;
 var Values2 = Instruction.Values;
 var Delta2 = Instruction.Delta;
@@ -36,21 +36,21 @@ var NonValue = Data.taggedEnum();
 var unavailable3 = NonValue.Unavailable();
 var removed2 = NonValue.Removed();
 
-class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key4) }) {
+class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key3) }) {
   get message() {
     return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
   }
 }
 
 class DuplicateKeyError2 extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
-  key: Key4
+  key: Key3
 }) {
   get message() {
     return `Duplicate instruction key: ${this.key}`;
   }
 }
 var empty3 = [];
-function make21(source) {
+function make20(source) {
   const decode = Schema.decodeUnknownOption(source.codec);
   const encode = Schema.encodeSync(source.codec);
   const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
@@ -193,4 +193,4 @@ function requireText(key, kind, text) {
   return text;
 }
 
-export { Key4, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make21, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };
+export { Key3, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make20, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };

package/dist/chunks/{config-f6e7rem1.js → schema-9d0vwzx2.js}

@@ -1,33 +1,33 @@
 import {
-  Service79,
-  node84
-} from "./config-q4zymtb1.js";
+  Service78,
+  node83
+} from "./schema-9tphn1nx.js";
 import {
   create3
-} from "./config-kg06axw8.js";
+} from "./schema-kg06axw8.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/command.ts
 var exports_command4 = {};
 __export(exports_command4, {
   Command: () => exports_command4,
-  Event: () => Event6,
+  Event: () => Event7,
   ExecutionError: () => ExecutionError2,
-  Info: () => Info4,
-  NotFoundError: () => NotFoundError5,
-  Service: () => Service37,
-  layer: () => layer17,
-  node: () => node41
+  Info: () => Info7,
+  NotFoundError: () => NotFoundError6,
+  Service: () => Service39,
+  layer: () => layer15,
+  node: () => node43
 });
 import { Command } from "@opencode-ai/schema/command";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
-import { Event as Event6 } from "@opencode-ai/schema/command";
-var Info4 = Command.Info;
+import { Event as Event7 } from "@opencode-ai/schema/command";
+var Info7 = Command.Info;
 
-class NotFoundError5 extends Schema.TaggedError()("Command.NotFoundError", {
+class NotFoundError6 extends Schema.TaggedError()("Command.NotFoundError", {
   command: Schema.String,
   message: Schema.String
 }) {
@@ -39,10 +39,10 @@ class ExecutionError2 extends Schema.TaggedError()("Command.ExecutionError", {
 }) {
 }
 
-class Service37 extends Context.Service()("@opencode/Command") {
+class Service39 extends Context.Service()("@opencode/Command") {
 }
-var layer17 = Layer.effect(Service37, Effect.gen(function* () {
-  const bus = yield* Service79;
+var layer15 = Layer.effect(Service39, Effect.gen(function* () {
+  const bus = yield* Service78;
   const state = create3({
     name: "command",
     initial: () => new Map,
@@ -51,11 +51,11 @@ var layer17 = Layer.effect(Service37, Effect.gen(function* () {
     }),
     notify: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
   });
-  const info = (definition) => Info4.make({
+  const info = (definition) => Info7.make({
     name: definition.name,
     description: definition.description
   });
-  return Service37.of({
+  return Service39.of({
     reload: state.reload,
     transform: state.transform,
     get: Effect.fn("Command.get")((name) => Effect.sync(() => {
@@ -66,15 +66,15 @@ var layer17 = Layer.effect(Service37, Effect.gen(function* () {
     execute: Effect.fn("Command.execute")(function* (input) {
       const definition = state.get().get(input.name);
       if (!definition)
-        return yield* new NotFoundError5({ command: input.name, message: `Command not found: ${input.name}` });
+        return yield* new NotFoundError6({ command: input.name, message: `Command not found: ${input.name}` });
       return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError2({ command: input.name, message: errorMessage(error) })));
     })
   });
 }));
-var node41 = makeLocationNode({
-  service: Service37,
-  layer: layer17,
-  deps: [node84]
+var node43 = makeLocationNode({
+  service: Service39,
+  layer: layer15,
+  deps: [node83]
 });
 function errorMessage(error) {
   if (error instanceof Error)
@@ -86,4 +86,4 @@ function errorMessage(error) {
   return "Command execution failed";
 }
 
-export { Info4, NotFoundError5, ExecutionError2, Service37, layer17, node41, exports_command4, Event6 };
+export { Info7, NotFoundError6, ExecutionError2, Service39, layer15, node43, exports_command4, Event7 };

package/dist/chunks/{config-xc5n2mhq.js → schema-9d7a9gfd.js}

@@ -1,45 +1,45 @@
 import {
-  Service64
-} from "./config-6mjnften.js";
+  Service47
+} from "./schema-r5rd45ey.js";
 import {
   unavailable3
-} from "./config-75yf2d83.js";
+} from "./schema-97f5v037.js";
 import {
   AbsolutePath2
-} from "./config-p8qxwesx.js";
+} from "./schema-p8qxwesx.js";
 import {
   File2,
-  Service35
-} from "./config-wszjhsey.js";
+  Service45
+} from "./schema-h9wz0788.js";
 import {
-  Service76
-} from "./config-vhzdsqy0.js";
+  Service75
+} from "./schema-be2wa24j.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/config/plugin/instruction.ts
 var exports_instruction = {};
 __export(exports_instruction, {
   ConfigInstructionPlugin: () => exports_instruction,
-  Plugin: () => Plugin30
+  Plugin: () => Plugin34
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
 import { dirname, join } from "path";
 import { Effect, PubSub, Semaphore, Stream } from "effect";
-var Plugin30 = define({
+var Plugin34 = define({
   id: "opencode.config.instruction",
   effect: Effect.fn(function* () {
-    const discovery = yield* Service35;
+    const discovery = yield* Service45;
     if (!discovery.project && !discovery.global)
       return;
     yield* Effect.gen(function* () {
       const fs = yield* FSUtil.Service;
       const global = yield* Global.Service;
-      const location = yield* Service76;
-      const watcher = yield* Service64;
+      const location = yield* Service75;
+      const watcher = yield* Service47;
       const changes = yield* PubSub.sliding(1);
       const lock = Semaphore.makeUnsafe(1);
       const start = yield* fs.resolve(location.directory);
@@ -114,4 +114,4 @@ function ancestorDirectories(start, stop) {
   return [start, ...ancestorDirectories(dirname(start), stop)];
 }
 
-export { Plugin30, exports_instruction };
+export { Plugin34, exports_instruction };

package/dist/chunks/{config-n029d2mf.js → schema-9djsb1x8.js}

@@ -1,41 +1,41 @@
 import {
-  Service71
-} from "./config-7yygr4vw.js";
+  Service63
+} from "./schema-p234zevy.js";
 import {
-  ID4,
+  ID5,
   Name2,
   toModelOutput3,
   prepare3,
-  Service51
-} from "./config-06g3gz3d.js";
+  Service43
+} from "./schema-3eb7wbw0.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/tool/plugin/skill.ts
-var exports_skill3 = {};
-__export(exports_skill3, {
-  Input: () => Input2,
-  Output: () => Output2,
-  Plugin: () => Plugin32,
-  SkillTool: () => exports_skill3,
-  description: () => description2,
-  name: () => name2,
+var exports_skill2 = {};
+__export(exports_skill2, {
+  Input: () => Input8,
+  Output: () => Output5,
+  Plugin: () => Plugin22,
+  SkillTool: () => exports_skill2,
+  description: () => description4,
+  name: () => name8,
   toModelOutput: () => toModelOutput2
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var name2 = "skill";
-var Input2 = Schema.Struct({
-  id: ID4.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
+var name8 = "skill";
+var Input8 = Schema.Struct({
+  id: ID5.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
 });
-var Output2 = Schema.Struct({
+var Output5 = Schema.Struct({
   name: Name2,
   directory: Schema.String,
   output: Schema.String
 });
-var description2 = [
+var description4 = [
   "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
   "",
   "The skill ID must match an available skill or a skill explicitly referenced by the user."
@@ -43,25 +43,25 @@ var description2 = [
 `);
 var toModelOutput2 = toModelOutput3;
 var unableToLoad = (name, error) => new ToolFailure({ message: `Unable to load skill ${name}`, error });
-var Plugin32 = {
+var Plugin22 = {
   id: "opencode.tool.skill",
   effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
     const fs = yield* FSUtil.Service;
-    const skills = yield* Service51;
-    const permission = yield* Service71;
+    const skills = yield* Service43;
+    const permission = yield* Service63;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name2,
+      name: name8,
       options: { codemode: false },
-      description: description2,
-      input: Input2,
-      output: Output2,
+      description: description4,
+      input: Input8,
+      output: Output5,
       execute: (input, context) => Effect.gen(function* () {
         const skill = yield* skills.get(input.id);
         if (!skill)
           return yield* unableToLoad(input.id);
         return yield* Effect.gen(function* () {
           yield* permission.assert({
-            action: name2,
+            action: name8,
             resources: [skill.id],
             save: [skill.id],
             sessionID: context.sessionID,
@@ -79,4 +79,4 @@ var Plugin32 = {
   })
 };
 
-export { name2, Input2, Output2, description2, toModelOutput2, Plugin32, exports_skill3 };
+export { name8, Input8, Output5, description4, toModelOutput2, Plugin22, exports_skill2 };

package/dist/chunks/{config-511mjebb.js → schema-9efw28vt.js}

@@ -1,9 +1,9 @@
 import {
-  Service52
-} from "./config-d9rpbp5n.js";
+  Service55
+} from "./schema-nzvt3fe2.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};
@@ -19,7 +19,7 @@ var FORCE_KILL_AFTER = Duration.seconds(2);
 var OUTGOING_CAPACITY = 64;
 var MAX_FRAME_BYTES = 16 * 1024 * 1024;
 var make2 = Effect.fnUntraced(function* (options) {
-  const environment = yield* Service52;
+  const environment = yield* Service55;
   const scope = yield* Effect.scope;
   const outgoing = yield* Queue.bounded(OUTGOING_CAPACITY);
   const buffer = new ReadBuffer;

package/dist/chunks/{config-8rk43p0s.js → schema-9mqrsjz0.js}

@@ -1,18 +1,18 @@
 import {
-  Service69
-} from "./config-pwc5sxx6.js";
+  Service72
+} from "./schema-bewj0jz1.js";
 import {
-  Service71
-} from "./config-7yygr4vw.js";
+  Service63
+} from "./schema-p234zevy.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/tool/plugin/question.ts
 var exports_question = {};
 __export(exports_question, {
   CancelledError: () => CancelledError2,
-  Input: () => Input13,
+  Input: () => Input14,
   Output: () => Output9,
   Plugin: () => Plugin45,
   QuestionTool: () => exports_question,
@@ -34,7 +34,7 @@ Usage notes:
 - A "Type your own answer" option is added automatically; don't include a separate option for free form answers
 - Set \`multiple: true\` to allow selecting more than one option
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
-var Input13 = Schema.Struct({
+var Input14 = Schema.Struct({
   questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
 });
 var Output9 = Schema.Struct({
@@ -53,13 +53,13 @@ var toModelContent7 = (questions, answers) => {
 var Plugin45 = {
   id: "opencode.tool.question",
   effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
-    const forms = yield* Service69;
-    const permission = yield* Service71;
+    const forms = yield* Service72;
+    const permission = yield* Service63;
     yield* ctx.tool.transform((editor) => editor.add({
       name: name13,
       options: { codemode: false },
       description: description6,
-      input: Input13,
+      input: Input14,
       output: Output9,
       execute: (input, context) => permission.assert({
         action: "question",
@@ -115,4 +115,4 @@ function toField(question, index) {
   };
 }
 
-export { name13, description6, Input13, Output9, CancelledError2, toModelContent7, Plugin45, exports_question };
+export { name13, description6, Input14, Output9, CancelledError2, toModelContent7, Plugin45, exports_question };

package/dist/chunks/{config-9qm9egsn.js → schema-9qm9egsn.js}

@@ -1,10 +1,10 @@
 import {
   absoluteColumn2,
   absoluteArrayColumn2
-} from "./config-r8dhm0tv.js";
+} from "./schema-r8dhm0tv.js";
 import {
   Timestamps2
-} from "./config-qfa1cgps.js";
+} from "./schema-qfa1cgps.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/{config-q4zymtb1.js → schema-9tphn1nx.js}

@@ -1,30 +1,30 @@
 import {
   Service80,
   node85
-} from "./config-mdgebrj3.js";
+} from "./schema-sj2kvqyv.js";
 import {
   EventSequenceTable2,
   EventTable2
-} from "./config-2710q6r3.js";
+} from "./schema-2710q6r3.js";
 import {
   makeUnsafe2
-} from "./config-y71avatq.js";
+} from "./schema-y71avatq.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/bus.ts
 var exports_bus = {};
 __export(exports_bus, {
   Bus: () => exports_bus,
   InvalidDurableEventError: () => InvalidDurableEventError2,
-  Service: () => Service79,
+  Service: () => Service78,
   configured: () => configured12,
   durable: () => durable2,
   ephemeral: () => ephemeral2,
   isSynced: () => isSynced2,
   latestSequence: () => latestSequence2,
-  node: () => node84,
+  node: () => node83,
   reserveSequence: () => reserveSequence2,
   versionedType: () => versionedType2
 });
@@ -76,13 +76,13 @@ var ephemeral2 = Event.ephemeral;
 var isSynced2 = (item) => item.type === "log.synced";
 var isDefinition = (input) => !Array.isArray(input);
 
-class Service79 extends Context.Service()("@opencode/Bus") {
+class Service78 extends Context.Service()("@opencode/Bus") {
 }
 function configured12(options) {
   return makeGlobalNode({
-    service: Service79,
+    service: Service78,
     deps: [node85],
-    layer: Layer.effect(Service79, Effect.gen(function* () {
+    layer: Layer.effect(Service78, Effect.gen(function* () {
       const { Location } = yield* Effect.promise(() => import("../location.js"));
       const { SessionTable } = yield* Effect.promise(() => import("../session/sql.js"));
       const pubsub = {
@@ -525,7 +525,7 @@ function configured12(options) {
         list.push((event) => projector(event));
         projectors.set(key, list);
       });
-      return Service79.of({
+      return Service78.of({
         publish,
         publishAll,
         subscribe,
@@ -539,6 +539,6 @@ function configured12(options) {
     }))
   });
 }
-var node84 = configured12();
+var node83 = configured12();
 
-export { latestSequence2, reserveSequence2, InvalidDurableEventError2, versionedType2, durable2, ephemeral2, isSynced2, Service79, configured12, node84, exports_bus };
+export { latestSequence2, reserveSequence2, InvalidDurableEventError2, versionedType2, durable2, ephemeral2, isSynced2, Service78, configured12, node83, exports_bus };

package/dist/chunks/{config-8qxykv75.js → schema-9wjcq4df.js}

@@ -1,23 +1,23 @@
 import {
   AbsolutePath2
-} from "./config-p8qxwesx.js";
+} from "./schema-p8qxwesx.js";
 import {
-  Service78,
-  node83
-} from "./config-eg4pr325.js";
+  Service77,
+  node82
+} from "./schema-jasnfvjs.js";
 import {
   parse4,
   validateBranch3,
   cachePath2,
   same2
-} from "./config-2402vzrj.js";
+} from "./schema-2402vzrj.js";
 import {
-  Service66,
-  node71
-} from "./config-j5cvhpj6.js";
+  Service79,
+  node84
+} from "./schema-vg7tvm5c.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};
@@ -30,9 +30,9 @@ __export(exports_repository_cache, {
   LockFailedError: () => LockFailedError2,
   RepositoryCache: () => exports_repository_cache,
   ResetFailedError: () => ResetFailedError2,
-  Service: () => Service42,
+  Service: () => Service51,
   isError: () => isError2,
-  node: () => node46,
+  node: () => node56,
   validateBranch: () => validateBranch2
 });
 import path from "path";
@@ -90,7 +90,7 @@ class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperatio
 }) {
 }
 
-class Service42 extends Context.Service()("@opencode/RepositoryCache") {
+class Service51 extends Context.Service()("@opencode/RepositoryCache") {
 }
 function isError2(error) {
   return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
@@ -101,13 +101,13 @@ var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (bra
     catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
   });
 });
-var layer = Layer.effect(Service42, Effect.gen(function* () {
+var layer = Layer.effect(Service51, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* Service78;
+  const git = yield* Service77;
   const flock = yield* EffectFlock.Service;
   const global = yield* Global.Service;
-  const kv = yield* Service66;
-  return Service42.of({
+  const kv = yield* Service79;
+  return Service51.of({
     ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
       if (input.branch)
         yield* validateBranch2(input.branch);
@@ -167,10 +167,10 @@ var layer = Layer.effect(Service42, Effect.gen(function* () {
     })
   });
 }));
-var node46 = makeGlobalNode({
-  service: Service42,
+var node56 = makeGlobalNode({
+  service: Service51,
   layer,
-  deps: [EffectFlock.node, FSUtil.node, node83, Global.node, node71]
+  deps: [EffectFlock.node, FSUtil.node, node82, Global.node, node84]
 });
 function errorMessage(error) {
   return error instanceof globalThis.Error ? error.message : String(error);
@@ -179,4 +179,4 @@ function cacheOperation(effect, operation, target) {
   return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
 }
 
-export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service42, isError2, validateBranch2, node46, exports_repository_cache };
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service51, isError2, validateBranch2, node56, exports_repository_cache };