@opencode/core 0.0.0-dev-20791 → 0.0.0-dev-20792

package/dist/chunks/{provider-pt6k7v6r.js → git-r0wqwj5k.js}

@@ -1,28 +1,28 @@
 import {
-  Service62
-} from "./provider-p6hhy8bg.js";
+  Service46
+} from "./git-nn81w468.js";
 import {
   unavailable3
-} from "./provider-eaj1djv9.js";
+} from "./git-s8d7rejh.js";
 import {
   AbsolutePath2
-} from "./provider-z5v4ffb3.js";
+} from "./git-z5v4ffb3.js";
 import {
   File2,
-  Service43
-} from "./provider-047jqq3p.js";
+  Service40
+} from "./git-8af82va7.js";
 import {
-  Service81
-} from "./provider-bnhfyrbt.js";
+  Service78
+} from "./git-zknpef82.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/config/plugin/instruction.ts
 var exports_instruction = {};
 __export(exports_instruction, {
   ConfigInstructionPlugin: () => exports_instruction,
-  Plugin: () => Plugin34
+  Plugin: () => Plugin32
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
@@ -30,17 +30,17 @@ import { Global } from "@opencode/util/global";
 import { sameDirectory } from "@opencode/util/path";
 import { dirname, join } from "path";
 import { Effect, PubSub, Semaphore, Stream } from "effect";
-var Plugin34 = define({
+var Plugin32 = define({
   id: "opencode.config.instruction",
   effect: Effect.fn(function* () {
-    const discovery = yield* Service43;
+    const discovery = yield* Service40;
     if (!discovery.project && !discovery.global)
       return;
     yield* Effect.gen(function* () {
       const fs = yield* FSUtil.Service;
       const global = yield* Global.Service;
-      const location = yield* Service81;
-      const watcher = yield* Service62;
+      const location = yield* Service78;
+      const watcher = yield* Service46;
       const changes = yield* PubSub.sliding(1);
       const lock = Semaphore.makeUnsafe(1);
       const start = yield* fs.resolve(location.directory);
@@ -115,4 +115,4 @@ function ancestorDirectories(start, stop) {
   return [start, ...ancestorDirectories(dirname(start), stop)];
 }
 
-export { Plugin34, exports_instruction };
+export { Plugin32, exports_instruction };

package/dist/chunks/{provider-8r1jb4je.js → git-r17tmn3b.js}

@@ -1,6 +1,6 @@
 import {
-  ID6
-} from "./provider-mv3a9vfa.js";
+  ID12
+} from "./git-9vy95dxc.js";
 
 // src/plugin/provider/openrouter.ts
 import { Effect } from "effect";
@@ -21,7 +21,7 @@ var OpenRouterPlugin2 = define({
       for (const item of models.provider.list()) {
         if (item.provider.package !== "@opencode/ai/providers/openrouter")
           continue;
-        for (const modelID of [ID6.make("gpt-5-chat-latest"), ID6.make("openai/gpt-5-chat")]) {
+        for (const modelID of [ID12.make("gpt-5-chat-latest"), ID12.make("openai/gpt-5-chat")]) {
           if (!models.get(item.provider.id, modelID))
             continue;
           models.update(item.provider.id, modelID, (model) => {

package/dist/chunks/{provider-q5xvhvda.js → git-r1qq3cts.js}

@@ -1,21 +1,21 @@
 import {
   convertToOpenAICompatibleChatMessages2
-} from "./provider-fxgpk5d8.js";
+} from "./git-2bv980vf.js";
 import {
   getResponseMetadata2
-} from "./provider-g4wezp1m.js";
+} from "./git-g4wezp1m.js";
 import {
   mapOpenAICompatibleFinishReason2
-} from "./provider-x61499pn.js";
+} from "./git-x61499pn.js";
 import {
   openaiCompatibleProviderOptions2
-} from "./provider-af5trqkr.js";
+} from "./git-af5trqkr.js";
 import {
   defaultOpenAICompatibleErrorStructure2
-} from "./provider-afrmfg78.js";
+} from "./git-afrmfg78.js";
 import {
   prepareTools2
-} from "./provider-x0ckcb58.js";
+} from "./git-x0ckcb58.js";
 
 // src/github-copilot/chat/openai-compatible-chat-language-model.ts
 import {
@@ -332,15 +332,8 @@ class OpenAICompatibleChatLanguageModel2 {
             return;
           }
           const delta = choice.delta;
-          if (delta.reasoning_opaque) {
-            if (reasoningOpaque != null) {
-              throw new InvalidResponseDataError({
-                data: delta,
-                message: "Multiple reasoning_opaque values received in a single response. Only one thinking part per response is supported."
-              });
-            }
+          if (delta.reasoning_opaque)
             reasoningOpaque = delta.reasoning_opaque;
-          }
           const reasoningContent = delta.reasoning_text;
           if (reasoningContent) {
             if (!isActiveReasoning) {

package/dist/chunks/{provider-dtkcvn89.js → git-r95pf28y.js}

@@ -1,10 +1,10 @@
 import {
-  Service83,
-  node87
-} from "./provider-0vtm6bxs.js";
+  Service84,
+  node88
+} from "./git-4cj6mfq5.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/form.ts
 var exports_form = {};
@@ -12,40 +12,40 @@ __export(exports_form, {
   AlreadyExistsError: () => AlreadyExistsError2,
   AlreadySettledError: () => AlreadySettledError2,
   Answer: () => Answer2,
-  Event: () => Event18,
+  Event: () => Event19,
   Field: () => Field2,
   Fields: () => Fields2,
   Form: () => exports_form,
-  ID: () => ID10,
-  Info: () => Info20,
+  ID: () => ID16,
+  Info: () => Info25,
   InvalidAnswerError: () => InvalidAnswerError2,
   InvalidFormError: () => InvalidFormError2,
   NotFoundError: () => NotFoundError8,
-  Reply: () => Reply2,
-  Service: () => Service70,
+  Reply: () => Reply3,
+  Service: () => Service77,
   State: () => State3,
   When: () => When2,
-  layer: () => layer26,
-  node: () => node73,
+  layer: () => layer24,
+  node: () => node81,
   validateAnswer: () => validateAnswer2,
   validateFields: () => validateFields2
 });
 import { Form } from "@opencode/schema/form";
 import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
-import { Event as Event18 } from "@opencode/schema/form";
+import { Event as Event19 } from "@opencode/schema/form";
 var RETENTION = Duration.minutes(10);
-var ID10 = Form.ID;
-var Info20 = Form.Info;
+var ID16 = Form.ID;
+var Info25 = Form.Info;
 var Field2 = Form.Field;
 var Fields2 = Form.Fields;
 var When2 = Form.When;
 var State3 = Form.State;
 var Answer2 = Form.Answer;
-var Reply2 = Form.Reply;
+var Reply3 = Form.Reply;
 
 class NotFoundError8 extends Schema.TaggedError()("Form.NotFoundError", {
-  id: ID10
+  id: ID16
 }) {
   get message() {
     return `Form not found: ${this.id}`;
@@ -53,7 +53,7 @@ class NotFoundError8 extends Schema.TaggedError()("Form.NotFoundError", {
 }
 
 class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
-  id: ID10
+  id: ID16
 }) {
   get message() {
     return `Form already settled: ${this.id}`;
@@ -61,7 +61,7 @@ class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledErro
 }
 
 class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
-  id: ID10
+  id: ID16
 }) {
   get message() {
     return `Form already exists: ${this.id}`;
@@ -69,7 +69,7 @@ class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError"
 }
 
 class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
-  id: ID10,
+  id: ID16,
   message: Schema.String
 }) {
 }
@@ -79,10 +79,10 @@ class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
 }) {
 }
 
-class Service70 extends Context.Service()("@opencode/Form") {
+class Service77 extends Context.Service()("@opencode/Form") {
 }
-var layer26 = Layer.effect(Service70, Effect.gen(function* () {
-  const bus = yield* Service83;
+var layer24 = Layer.effect(Service77, Effect.gen(function* () {
+  const bus = yield* Service84;
   let closed = false;
   const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
     capacity: Number.MAX_SAFE_INTEGER,
@@ -90,7 +90,7 @@ var layer26 = Layer.effect(Service70, Effect.gen(function* () {
   });
   const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError8({ id })))));
   const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
-    const id = input.id ?? ID10.create();
+    const id = input.id ?? ID16.create();
     const existing = yield* Cache.getSuccess(forms, id);
     if (Option.isSome(existing))
       return yield* new AlreadyExistsError2({ id });
@@ -162,9 +162,9 @@ var layer26 = Layer.effect(Service70, Effect.gen(function* () {
     closed = true;
   }).pipe(Effect.andThen(Cache.values(forms)), Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true })));
   yield* Effect.addFinalizer(() => close);
-  return Service70.of({ create, ask, get, list, state, reply, cancel, close });
+  return Service77.of({ create, ask, get, list, state, reply, cancel, close });
 }));
-var node73 = makeLocationNode({ service: Service70, layer: layer26, deps: [node87] });
+var node81 = makeLocationNode({ service: Service77, layer: layer24, deps: [node88] });
 function validateAnswer2(form, answer) {
   const fields = new Map(form.map((field) => [field.key, field]));
   for (const key of Object.keys(answer)) {
@@ -316,4 +316,4 @@ function isDateTime(value) {
   return !Number.isNaN(new Date(value).getTime());
 }
 
-export { ID10, Info20, Field2, Fields2, When2, State3, Answer2, Reply2, NotFoundError8, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service70, layer26, node73, validateAnswer2, validateFields2, exports_form, Event18 };
+export { ID16, Info25, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError8, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service77, layer24, node81, validateAnswer2, validateFields2, exports_form, Event19 };

package/dist/chunks/{provider-fwwk8vbp.js → git-r9w3djhf.js}

@@ -1,30 +1,30 @@
 import {
   makeUnsafe2
-} from "./provider-dpkg50ah.js";
+} from "./git-dpkg50ah.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/plugin/update.ts
 var exports_update = {};
 __export(exports_update, {
   PluginUpdate: () => exports_update,
-  Service: () => Service7,
-  node: () => node9
+  Service: () => Service4,
+  node: () => node5
 });
 import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
 import { Npm } from "@opencode/util/npm";
 import { makeGlobalNode } from "@opencode/util/effect/app-node";
 var interval = 24 * 60 * 60 * 1000;
 
-class Service7 extends Context.Service()("@opencode/PluginUpdate") {
+class Service4 extends Context.Service()("@opencode/PluginUpdate") {
 }
-var layer = Layer.effect(Service7, Effect.gen(function* () {
+var layer = Layer.effect(Service4, Effect.gen(function* () {
   const npm = yield* Npm.Service;
   const locks = makeUnsafe2();
   const status = new Map;
   const changes = yield* PubSub.unbounded();
-  return Service7.of({
+  return Service4.of({
     check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
       const checkedAt = yield* Clock.currentTimeMillis;
       const current = status.get(target);
@@ -49,6 +49,6 @@ var layer = Layer.effect(Service7, Effect.gen(function* () {
     changes: () => Stream.fromPubSub(changes)
   });
 }));
-var node9 = makeGlobalNode({ service: Service7, layer, deps: [Npm.node] });
+var node5 = makeGlobalNode({ service: Service4, layer, deps: [Npm.node] });
 
-export { Service7, node9, exports_update };
+export { Service4, node5, exports_update };

package/dist/chunks/{provider-0hb4wmm5.js → git-ra4xyxax.js}

@@ -1,12 +1,12 @@
 import {
   jitCompatCheck2
-} from "./provider-emrn6kk6.js";
+} from "./git-emrn6kk6.js";
 import {
   SQLiteEffectDatabase2
-} from "./provider-dvf4d4yx.js";
+} from "./git-87r11qxp.js";
 import {
   EffectSQLiteSession2
-} from "./provider-9yq3t2hf.js";
+} from "./git-3d0jer83.js";
 
 // src/database/drizzle/effect-sqlite/driver.ts
 import * as Effect from "effect/Effect";

package/dist/chunks/{provider-rdw6cm16.js → git-rdw6cm16.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/state.ts
 var exports_state = {};

package/dist/chunks/{provider-9cppds89.js → git-rfx9ekrq.js}

@@ -1,24 +1,24 @@
 import {
   PositiveInt2
-} from "./provider-z5v4ffb3.js";
+} from "./git-z5v4ffb3.js";
 import {
   Action2
-} from "./provider-waskdk5r.js";
+} from "./git-sz15zhhw.js";
+import {
+  Info12
+} from "./git-npw39rc8.js";
 import {
   Info10
-} from "./provider-ebwxn0bv.js";
+} from "./git-edrmdtr5.js";
 import {
   Info11
-} from "./provider-ryr25ayn.js";
-import {
-  Info13
-} from "./provider-4xpgt2w9.js";
+} from "./git-g6yfr6ja.js";
 import {
   Spec2
-} from "./provider-fcrkznn8.js";
+} from "./git-0jwsre1p.js";
 import {
-  Info12
-} from "./provider-b674v2dg.js";
+  Info9
+} from "./git-ygdna4kr.js";
 import {
   normalizeAction2,
   migrateAgent2,
@@ -27,10 +27,10 @@ import {
   migrateMcp2,
   migrateProvider2,
   providerID2
-} from "./provider-6m6pfhdc.js";
+} from "./git-yvap468f.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/config/normalize.ts
 var exports_normalize = {};
@@ -97,12 +97,12 @@ function normalize2(input) {
   const legacyReferences = decodeMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics, decodeEncoded);
   const nativeReferences = decodeMap(input.references, ConfigReference.Entry, ["references"], diagnostics, decodeEncoded);
   mergeMap(encoded, "references", legacyReferences, nativeReferences, isRecord(input.reference) || isRecord(input.references), diagnostics);
-  const legacyCommands = decodeMap(input.command, Info11, ["command"], diagnostics, decodeValue);
+  const legacyCommands = decodeMap(input.command, Info10, ["command"], diagnostics, decodeValue);
   diagnoseSelectionMap(input.command, ["command"], diagnostics);
   const migratedCommands = mapValues(legacyCommands, (value) => canonical(ConfigCommand.Info, migrateCommand2(value)));
   const nativeCommands = decodeMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics, decodeEncoded);
   mergeMap(encoded, "commands", migratedCommands, nativeCommands, isRecord(input.command) || isRecord(input.commands), diagnostics);
-  const legacyAgents = mapValues(decodeMap(input.agent, Info10, ["agent"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2(value)));
+  const legacyAgents = mapValues(decodeMap(input.agent, Info12, ["agent"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2(value)));
   const legacySmallModel = own(input, "small_model") ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics) : undefined;
   const migratedSmallModel = modelSelection2(legacySmallModel);
   if (legacySmallModel && !migratedSmallModel)
@@ -116,7 +116,7 @@ function normalize2(input) {
       model: migratedSmallModel,
       ...legacyAgents.title
     };
-  const modeAgents = mapValues(decodeMap(input.mode, Info10, ["mode"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2({ ...value, mode: "primary" })));
+  const modeAgents = mapValues(decodeMap(input.mode, Info12, ["mode"], diagnostics, decodeValue), (value) => canonical(ConfigAgent.Info, migrateAgent2({ ...value, mode: "primary" })));
   const migratedAgents = mergeMaps(legacyAgents, modeAgents, ["agents"], diagnostics);
   const nativeAgents = decodeMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics, decodeEncoded);
   diagnoseAgentUnsupported(input.agent, ["agent"], diagnostics);
@@ -217,7 +217,7 @@ function normalizeMcp(input, encoded, diagnostics) {
           normalizeMcpTimeout(value, timeout, path, diagnostics);
           return;
         }
-        const server = decodeValue(Info13, value, path, diagnostics);
+        const server = decodeValue(Info11, value, path, diagnostics);
         if (server !== undefined)
           setOwn(legacyServers, name, canonical(ConfigMCP.Server, migrateMcp2(server)));
       });
@@ -413,7 +413,7 @@ function migrateProviders(value, diagnostics) {
     diagnoseProviderUnsupported(raw, path, diagnostics);
     if (invalidProviderOverlays(raw, path, diagnostics))
       return [];
-    const provider = decodeValue(Info12, raw, path, diagnostics);
+    const provider = decodeValue(Info9, raw, path, diagnostics);
     if (provider === undefined)
       return [];
     const destination = providerID2(name);

package/dist/chunks/{provider-8sze2n9a.js → git-rkprpv83.js}

@@ -1,9 +1,9 @@
 import {
   render3
-} from "./provider-xfkkasph.js";
+} from "./git-drwq78ky.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/plugin/optimize.ts
 var exports_optimize = {};
@@ -13,7 +13,7 @@ __export(exports_optimize, {
   ArceePlugin: () => ArceePlugin2,
   KimiPlugin: () => KimiPlugin2,
   MetaPlugin: () => MetaPlugin2,
-  OpenAIPlugin: () => OpenAIPlugin2,
+  OpenAIPlugin: () => OpenAIPlugin3,
   OpenAIToolsPlugin: () => OpenAIToolsPlugin2,
   OptimizePlugin: () => exports_optimize,
   Plugins: () => Plugins2
@@ -374,7 +374,7 @@ By default, match the surrounding comment density: where the code has none, add
 `;
 
 // src/plugin/optimize.ts
-var OpenAIPlugin2 = make("opencode.prompt.openai", (model) => {
+var OpenAIPlugin3 = make("opencode.prompt.openai", (model) => {
   const id = model.id.toLowerCase();
   if (!id.includes("gpt"))
     return;
@@ -409,7 +409,7 @@ var MetaPlugin2 = make("opencode.prompt.meta", (model) => {
     return;
   return meta_default.replaceAll("{{MODEL_NAME}}", model.name);
 });
-var Plugins2 = [OpenAIPlugin2, AnthropicPlugin2, KimiPlugin2, ArceePlugin2, MetaPlugin2];
+var Plugins2 = [OpenAIPlugin3, AnthropicPlugin2, KimiPlugin2, ArceePlugin2, MetaPlugin2];
 function make(id, optimize, mode = "override") {
   return define({
     id,
@@ -437,4 +437,4 @@ ${rendered}` : rendered;
   });
 }
 
-export { OpenAIPlugin2, AnthropicPlugin2, OpenAIToolsPlugin2, AnthropicToolsPlugin2, KimiPlugin2, ArceePlugin2, MetaPlugin2, Plugins2, exports_optimize };
+export { OpenAIPlugin3, AnthropicPlugin2, OpenAIToolsPlugin2, AnthropicToolsPlugin2, KimiPlugin2, ArceePlugin2, MetaPlugin2, Plugins2, exports_optimize };

package/dist/chunks/{provider-03g00rc2.js → git-rqk1fa9v.js}

@@ -1,29 +1,29 @@
 import {
-  Service61
-} from "./provider-32qtf6eh.js";
+  Service45
+} from "./git-mj33qvve.js";
 import {
-  Service9
-} from "./provider-dg0xkvw5.js";
+  Service13
+} from "./git-pfbtahck.js";
 import {
   observe2
-} from "./provider-qsdy395h.js";
+} from "./git-qsdy395h.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/config/plugin/compaction.ts
 var exports_compaction = {};
 __export(exports_compaction, {
   ConfigCompactionPlugin: () => exports_compaction,
-  Plugin: () => Plugin32
+  Plugin: () => Plugin39
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin32 = define({
+var Plugin39 = define({
   id: "opencode.config.compaction",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service61;
-    const compaction = yield* Service9;
+    const config = yield* Service45;
+    const compaction = yield* Service13;
     const loaded = yield* observe2(config, ctx.event, compaction.reload());
     yield* compaction.transform((editor) => {
       for (const entry of loaded.entries) {
@@ -39,4 +39,4 @@ var Plugin32 = define({
   })
 });
 
-export { Plugin32, exports_compaction };
+export { Plugin39, exports_compaction };

package/dist/chunks/{provider-xasyx0as.js → git-rx9ava5n.js}

@@ -5,17 +5,17 @@ import {
   renderInitial2,
   renderUpdate2,
   applyHashDelta2
-} from "./provider-eaj1djv9.js";
+} from "./git-s8d7rejh.js";
 import {
   SessionEvent2
-} from "./provider-ec1grn59.js";
+} from "./git-ec1grn59.js";
 import {
   InstructionBlobTable2,
   InstructionStateTable2
-} from "./provider-kb9j3d72.js";
+} from "./git-kb9j3d72.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/session/instruction-state.ts
 var exports_instruction_state = {};

package/dist/chunks/{provider-1sw2bjqg.js → git-s7d29e54.js}

@@ -1,36 +1,36 @@
 import {
-  Service75
-} from "./provider-2h977fq8.js";
+  Service66
+} from "./git-xerck34f.js";
 import {
-  ID5,
+  ID4,
   Name2,
   toModelOutput3,
   prepare3,
-  Service52
-} from "./provider-t91hcw5k.js";
+  Service41
+} from "./git-qp3kq2y9.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./git-9rqn6x4v.js";
 
 // src/tool/plugin/skill.ts
 var exports_skill = {};
 __export(exports_skill, {
-  Input: () => Input12,
-  Output: () => Output8,
-  Plugin: () => Plugin15,
+  Input: () => Input10,
+  Output: () => Output7,
+  Plugin: () => Plugin13,
   SkillTool: () => exports_skill,
   description: () => description5,
-  name: () => name12,
+  name: () => name10,
   toModelOutput: () => toModelOutput2
 });
 import { ToolFailure } from "@opencode/ai";
 import { Effect, Schema } from "effect";
 import { FSUtil } from "@opencode/util/fs-util";
-var name12 = "skill";
-var Input12 = Schema.Struct({
-  id: ID5.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
+var name10 = "skill";
+var Input10 = Schema.Struct({
+  id: ID4.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
 });
-var Output8 = Schema.Struct({
+var Output7 = Schema.Struct({
   name: Name2,
   directory: Schema.String,
   output: Schema.String
@@ -43,25 +43,25 @@ var description5 = [
 `);
 var toModelOutput2 = toModelOutput3;
 var unableToLoad = (name, error) => new ToolFailure({ message: `Unable to load skill ${name}`, error });
-var Plugin15 = {
+var Plugin13 = {
   id: "opencode.tool.skill",
   effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
     const fs = yield* FSUtil.Service;
-    const skills = yield* Service52;
-    const permission = yield* Service75;
+    const skills = yield* Service41;
+    const permission = yield* Service66;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name12,
+      name: name10,
       options: { codemode: false },
       description: description5,
-      input: Input12,
-      output: Output8,
+      input: Input10,
+      output: Output7,
       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: name12,
+            action: name10,
             resources: [skill.id],
             save: [skill.id],
             sessionID: context.sessionID,
@@ -79,4 +79,4 @@ var Plugin15 = {
   })
 };
 
-export { name12, Input12, Output8, description5, toModelOutput2, Plugin15, exports_skill };
+export { name10, Input10, Output7, description5, toModelOutput2, Plugin13, exports_skill };