@opencode/core 2.0.8 → 2.0.10

package/dist/chunks/{provider-rj0ypf2k.js → instruction-discovery-358hwc82.js}

@@ -1,27 +1,27 @@
 import {
   ascending2
-} from "./provider-tvtrv512.js";
+} from "./instruction-discovery-tvtrv512.js";
 import {
-  Service70,
-  node73
-} from "./provider-8a7sh5jm.js";
+  Service62,
+  node65
+} from "./instruction-discovery-00f3x6kk.js";
 import {
   SessionMessage2
-} from "./provider-gftt206x.js";
+} from "./instruction-discovery-gftt206x.js";
 import {
   SessionSchema2
-} from "./provider-7w99qc9d.js";
+} from "./instruction-discovery-dm1py9b3.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/job.ts
 var exports_job = {};
 __export(exports_job, {
   Job: () => exports_job,
-  Service: () => Service50,
-  make: () => make18,
-  node: () => node52
+  Service: () => Service61,
+  make: () => make19,
+  node: () => node64
 });
 import { Array, Cause, Clock, Context, Deferred, Effect, Exit, Layer, Schema, Scope, SynchronizedRef } from "effect";
 import { makeGlobalNode } from "@opencode/util/effect/app-node";
@@ -49,8 +49,9 @@ var Background = Schema.Struct({
 });
 var decodeBackground = Schema.decodeUnknownResult(Background);
 var backgroundPrefix = "job.background/";
+var COMPLETED_LIMIT = 25;
 
-class Service50 extends Context.Service()("@opencode/Job") {
+class Service61 extends Context.Service()("@opencode/Job") {
 }
 function snapshot(job) {
   return {
@@ -85,12 +86,24 @@ function decrementSession(input, sessionID) {
     next.set(sessionID, count - 1);
   return next;
 }
-var make18 = Effect.gen(function* () {
-  const kv = yield* Service70;
+var make19 = Effect.gen(function* () {
+  const kv = yield* Service62;
   const state = {
     jobs: yield* SynchronizedRef.make(new Map),
     scope: yield* Scope.Scope
   };
+  const consume = (id, generation) => SynchronizedRef.update(state.jobs, (jobs) => {
+    const job = jobs.get(id);
+    if (!job || job.scope !== generation || job.info.status === "running" || job.consumed)
+      return jobs;
+    const next = new Map(jobs);
+    next.delete(id);
+    next.set(id, { ...job, consumed: true });
+    const completed = [...next].filter(([, job]) => job.consumed && !job.info.notificationID);
+    for (const [id] of completed.slice(0, -COMPLETED_LIMIT))
+      next.delete(id);
+    return next;
+  });
   const persistBackground = Effect.fnUntraced(function* (job) {
     if (!job.recovery || !job.info.notificationID)
       return;
@@ -169,6 +182,7 @@ var make18 = Effect.gen(function* () {
           scope,
           blockingSessions: new Map,
           isBackgrounded: false,
+          consumed: false,
           recovery: input.recovery
         };
         return [{ info: snapshot(job), scope }, new Map(jobs).set(id, job)];
@@ -182,16 +196,18 @@ var make18 = Effect.gen(function* () {
     const job = (yield* SynchronizedRef.get(state.jobs)).get(input.id);
     if (!job)
       return { timedOut: false };
-    if (job.info.status !== "running")
-      return { info: snapshot(job), timedOut: false };
-    if (input.timeout === undefined)
-      return { info: yield* Deferred.await(job.done), timedOut: false };
-    if (input.timeout <= 0)
+    return yield* Effect.gen(function* () {
+      if (job.info.status !== "running")
+        return { info: snapshot(job), timedOut: false };
+      if (input.timeout === undefined)
+        return { info: yield* Deferred.await(job.done), timedOut: false };
+      if (input.timeout <= 0)
+        return { info: snapshot(job), timedOut: true };
+      const info = yield* Deferred.await(job.done).pipe(Effect.timeoutOption(input.timeout));
+      if (info._tag === "Some")
+        return { info: info.value, timedOut: false };
       return { info: snapshot(job), timedOut: true };
-    const info = yield* Deferred.await(job.done).pipe(Effect.timeoutOption(input.timeout));
-    if (info._tag === "Some")
-      return { info: info.value, timedOut: false };
-    return { info: snapshot(job), timedOut: true };
+    }).pipe(Effect.tap((result) => result.info.status === "running" || job.recovery ? Effect.void : consume(input.id, job.scope)));
   });
   const removeBlock = Effect.fnUntraced(function* (input) {
     yield* SynchronizedRef.update(state.jobs, (jobs) => {
@@ -210,11 +226,11 @@ var make18 = Effect.gen(function* () {
       if (!job)
         return [{ type: "missing" }, jobs];
       if (job.info.status !== "running")
-        return [{ type: "finished", info: snapshot(job) }, jobs];
+        return [{ type: "finished", info: snapshot(job), generation: job.scope }, jobs];
       if (job.isBackgrounded)
         return [{ type: "backgrounded", info: snapshot(job) }, jobs];
       return [
-        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded } },
+        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded, generation: job.scope } },
         new Map(jobs).set(input.id, {
           ...job,
           blockingSessions: incrementSession(job.blockingSessions, input.sessionID)
@@ -223,11 +239,13 @@ var make18 = Effect.gen(function* () {
     });
     if (result.type === "missing")
       return;
-    if (result.type === "finished")
+    if (result.type === "finished") {
+      yield* consume(input.id, result.generation);
       return { type: "finished", info: result.info };
+    }
     if (result.type === "backgrounded")
       return { type: "backgrounded", info: result.info };
-    return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.ensuring(removeBlock(input)));
+    return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.tap((outcome) => outcome.type === "finished" ? consume(input.id, result.wait.generation) : Effect.void), Effect.ensuring(removeBlock(input)));
   });
   const markBackground = Effect.fnUntraced(function* (job) {
     const next = {
@@ -285,7 +303,7 @@ var make18 = Effect.gen(function* () {
       if (!job)
         return [{}, jobs];
       if (job.info.status !== "running")
-        return [{ info: snapshot(job) }, jobs];
+        return [{ info: snapshot(job), generation: job.scope }, jobs];
       const next = {
         ...job,
         blockingSessions: new Map,
@@ -296,12 +314,17 @@ var make18 = Effect.gen(function* () {
         }
       };
       yield* persistBackground(next);
-      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+      return [
+        { info: snapshot(next), done: job.done, scope: job.scope, generation: job.scope },
+        new Map(jobs).set(id, next)
+      ];
     }));
     if (result.info && result.done)
       yield* Deferred.succeed(result.done, result.info);
     if (result.scope)
       yield* Scope.close(result.scope, Exit.void);
+    if (result.generation)
+      yield* consume(id, result.generation);
     return result.info;
   });
   const pendingBackground = Effect.gen(function* () {
@@ -314,8 +337,16 @@ var make18 = Effect.gen(function* () {
     } while (after);
     return recovered;
   }).pipe(Effect.withSpan("Job.pendingBackground"));
-  const completeBackground = Effect.fn("Job.completeBackground")((notificationID) => kv.remove(`${backgroundPrefix}${notificationID}`));
-  return Service50.of({
+  const completeBackground = Effect.fn("Job.completeBackground")((notificationID) => SynchronizedRef.updateEffect(state.jobs, (jobs) => Effect.gen(function* () {
+    yield* kv.remove(`${backgroundPrefix}${notificationID}`);
+    const entry = [...jobs].find(([, job]) => job.info.notificationID === notificationID);
+    if (!entry || entry[1].info.status === "running")
+      return jobs;
+    const next = new Map(jobs);
+    next.delete(entry[0]);
+    return next;
+  })));
+  return Service61.of({
     get,
     start,
     wait,
@@ -327,7 +358,7 @@ var make18 = Effect.gen(function* () {
     completeBackground
   });
 });
-var layer = Layer.effect(Service50, make18);
-var node52 = makeGlobalNode({ service: Service50, layer, deps: [node73] });
+var layer = Layer.effect(Service61, make19);
+var node64 = makeGlobalNode({ service: Service61, layer, deps: [node65] });
 
-export { Service50, make18, node52, exports_job };
+export { Service61, make19, node64, exports_job };

package/dist/chunks/instruction-discovery-3bc8czyk.js

@@ -0,0 +1,123 @@
+import {
+  definition2
+} from "./instruction-discovery-3w5fmr99.js";
+import {
+  __export
+} from "./instruction-discovery-9rqn6x4v.js";
+
+// src/plugin/tool-input-repair.ts
+var exports_tool_input_repair = {};
+__export(exports_tool_input_repair, {
+  Plugin: () => Plugin25,
+  ToolInputRepairPlugin: () => exports_tool_input_repair
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Option, Predicate, Schema } from "effect";
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+var maxDepth = 6;
+var Plugin25 = define({
+  id: "opencode.tool.input.repair",
+  effect: (ctx) => ctx.tool.hook("execute.before", (event) => Effect.gen(function* () {
+    if (event.tool === "execute")
+      return;
+    const tool = (yield* ctx.tool.list()).find((tool) => tool.id === event.tool);
+    if (!tool)
+      return;
+    const schema = definition2(tool).inputSchema;
+    if (schema.type !== "object")
+      return;
+    event.input = repair(event.input, schema, schema, 0);
+  }))
+});
+function repair(value, schema, root, depth) {
+  if (depth > maxDepth)
+    return value;
+  if (typeof schema.$ref === "string") {
+    const definitions = /^#\/\$defs\/[^/]+$/.test(schema.$ref) ? root.$defs : /^#\/definitions\/[^/]+$/.test(schema.$ref) ? root.definitions : undefined;
+    if (!Predicate.isObject(definitions))
+      return value;
+    const target = Object.fromEntries(Object.entries(definitions).filter((entry) => Predicate.isObject(entry[1])))[schema.$ref.slice(schema.$ref.lastIndexOf("/") + 1).replaceAll("~1", "/").replaceAll("~0", "~")];
+    return target ? repair(value, target, root, depth + 1) : value;
+  }
+  if (Array.isArray(schema.type)) {
+    if (value === null && schema.type.includes("null"))
+      return value;
+    if (schema.type.includes(typeof value))
+      return value;
+    const types = schema.type.filter((type) => type !== "null");
+    return types.length === 1 ? repair(value, { ...schema, type: types[0] }, root, depth + 1) : value;
+  }
+  if (schema.type === undefined) {
+    if (Array.isArray(schema.anyOf) && Array.isArray(schema.oneOf))
+      return value;
+    const branches = Array.isArray(schema.anyOf) ? schema.anyOf : schema.oneOf;
+    if (!Array.isArray(branches) || value === null)
+      return value;
+    if (branches.some((branch) => !Predicate.isObject(branch) || branch.type === typeof value))
+      return value;
+    const candidates = branches.filter((branch) => Predicate.isObject(branch) && branch.type !== "null");
+    return candidates.length === 1 ? repair(value, candidates[0], root, depth + 1) : value;
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    if (typeof value !== "string" || value.trim() === "")
+      return value;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && (schema.type !== "integer" || Number.isSafeInteger(parsed)) ? parsed : value;
+  }
+  if (schema.type === "boolean")
+    return value === "true" ? true : value === "false" ? false : value;
+  if (schema.type === "object")
+    return repairObject(value, schema, root, depth);
+  if (schema.type === "array")
+    return repairArray(value, schema, root, depth);
+  return value;
+}
+function repairObject(value, schema, root, depth) {
+  const parsed = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value;
+  if (!Predicate.isObject(parsed))
+    return value;
+  const properties = Predicate.isObject(schema.properties) ? schema.properties : {};
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  const patterned = Predicate.isObject(schema.patternProperties);
+  const composed = Array.isArray(schema.allOf) || Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf);
+  return Object.keys(parsed).reduce((result, key) => {
+    const current = result[key];
+    const declared = Object.hasOwn(properties, key);
+    const property = declared ? properties[key] : !patterned ? schema.additionalProperties : undefined;
+    if (!declared && schema.additionalProperties === false && !patterned && !composed) {
+      const next = { ...result };
+      delete next[key];
+      return next;
+    }
+    if (!Predicate.isObject(property))
+      return result;
+    const plain = typeof property.type === "string" && property.type !== "null" && !composed && ["anyOf", "oneOf", "allOf", "enum", "const", "$ref", "nullable"].every((keyword) => !(keyword in property));
+    const placeholder = Predicate.isObject(current) && Object.keys(current).length === 0 && property.type !== "object";
+    if (declared && !required.includes(key) && plain && (current === null || placeholder)) {
+      const next = { ...result };
+      delete next[key];
+      return next;
+    }
+    const repaired = repair(current, property, root, depth + 1);
+    return repaired === current ? result : { ...result, [key]: repaired };
+  }, parsed);
+}
+function repairArray(value, schema, root, depth) {
+  const parsed = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value;
+  const tuple = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : undefined;
+  if (Array.isArray(parsed)) {
+    const repaired = parsed.map((item, index) => {
+      const member = tuple ? tuple[index] ?? (Array.isArray(schema.prefixItems) ? schema.items : schema.additionalItems) : schema.items;
+      return Predicate.isObject(member) ? repair(item, member, root, depth + 1) : item;
+    });
+    return repaired.every((item, index) => item === parsed[index]) ? parsed : repaired;
+  }
+  if (tuple || !Predicate.isObject(schema.items))
+    return value;
+  const repaired = repair(value, schema.items, root, depth + 1);
+  const type = schema.items.type;
+  const compatible = type === "object" ? Predicate.isObject(repaired) : type === "array" ? Array.isArray(repaired) : type === "integer" ? typeof repaired === "number" && Number.isSafeInteger(repaired) : type === "number" ? typeof repaired === "number" && Number.isFinite(repaired) : (type === "string" || type === "boolean") && typeof repaired === type;
+  return compatible ? [repaired] : value;
+}
+
+export { Plugin25, exports_tool_input_repair };

package/dist/chunks/{provider-3fc6dm20.js → instruction-discovery-3fc6dm20.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/codemode/catalog.ts
 var exports_catalog = {};

package/dist/chunks/{provider-f9y7tnx7.js → instruction-discovery-3gncs5t7.js}

@@ -1,12 +1,12 @@
 import {
   fromPromise2
-} from "./provider-zr2ceqn5.js";
+} from "./instruction-discovery-zr2ceqn5.js";
 import {
-  Service65
-} from "./provider-eg8s060n.js";
+  Service51
+} from "./instruction-discovery-9dz1p9rk.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/plugin/module.ts
 var exports_module = {};
@@ -23,7 +23,7 @@ import path from "path";
 import { stat } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "url";
 var make4 = Effect.fn("PluginModule.make")(function* () {
-  const watcher = yield* Service65;
+  const watcher = yield* Service51;
   const scope = yield* Effect.scope;
   const runPromise = yield* FiberSet.makeRuntimePromise();
   const changes = yield* PubSub.unbounded();

package/dist/chunks/{provider-mh1qkymb.js → instruction-discovery-3hdyanjz.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/tool/plugin/opencode.ts
 var exports_opencode = {};
@@ -8,7 +8,7 @@ __export(exports_opencode, {
   ModelsInput: () => ModelsInput2,
   MoveInput: () => MoveInput2,
   OpenCodeTools: () => exports_opencode,
-  Plugin: () => Plugin40,
+  Plugin: () => Plugin10,
   RenameInput: () => RenameInput2
 });
 import { SystemPart, ToolFailure } from "@opencode/ai";
@@ -64,7 +64,7 @@ var ModelsOutput = Schema.Struct({
   total: Schema.Int.annotate({ description: "Number of matching models across all pages." }),
   next: Schema.NullOr(Schema.Int).annotate({ description: "Offset of the next page, or null on the last page." })
 });
-var Plugin40 = {
+var Plugin10 = {
   id: "opencode.tools",
   effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
     const hook = (event) => Effect.sync(() => {
@@ -161,4 +161,4 @@ var Plugin40 = {
   })
 };
 
-export { RenameInput2, MoveInput2, ModelsInput2, Plugin40, exports_opencode };
+export { RenameInput2, MoveInput2, ModelsInput2, Plugin10, exports_opencode };

package/dist/chunks/{provider-3hepkmqq.js → instruction-discovery-3hepkmqq.js}

@@ -1,6 +1,6 @@
 import {
   Timestamps2
-} from "./provider-qfa1cgps.js";
+} from "./instruction-discovery-qfa1cgps.js";
 
 // src/kv/sql.ts
 import { sqliteTable, text } from "drizzle-orm/sqlite-core";

package/dist/chunks/{provider-pjbk54rp.js → instruction-discovery-3j8hfepr.js}

@@ -1,23 +1,23 @@
 import {
   AbsolutePath2
-} from "./provider-922hggd3.js";
+} from "./instruction-discovery-922hggd3.js";
 import {
-  Service81,
-  node85
-} from "./provider-76p4c97e.js";
+  Service78,
+  node82
+} from "./instruction-discovery-6t298p2h.js";
 import {
   parse4,
   validateBranch3,
   cachePath2,
   same2
-} from "./provider-2402vzrj.js";
+} from "./instruction-discovery-2402vzrj.js";
 import {
-  Service70,
-  node73
-} from "./provider-8a7sh5jm.js";
+  Service62,
+  node65
+} from "./instruction-discovery-00f3x6kk.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-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: () => Service53,
+  Service: () => Service48,
   isError: () => isError2,
-  node: () => node55,
+  node: () => node51,
   validateBranch: () => validateBranch2
 });
 import path from "path";
@@ -90,7 +90,7 @@ class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperatio
 }) {
 }
 
-class Service53 extends Context.Service()("@opencode/RepositoryCache") {
+class Service48 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(Service53, Effect.gen(function* () {
+var layer = Layer.effect(Service48, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* Service81;
+  const git = yield* Service78;
   const flock = yield* EffectFlock.Service;
   const global = yield* Global.Service;
-  const kv = yield* Service70;
-  return Service53.of({
+  const kv = yield* Service62;
+  return Service48.of({
     ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
       if (input.branch)
         yield* validateBranch2(input.branch);
@@ -167,10 +167,10 @@ var layer = Layer.effect(Service53, Effect.gen(function* () {
     })
   });
 }));
-var node55 = makeGlobalNode({
-  service: Service53,
+var node51 = makeGlobalNode({
+  service: Service48,
   layer,
-  deps: [EffectFlock.node, FSUtil.node, node85, Global.node, node73]
+  deps: [EffectFlock.node, FSUtil.node, node82, Global.node, node65]
 });
 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, Service53, isError2, validateBranch2, node55, exports_repository_cache };
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service48, isError2, validateBranch2, node51, exports_repository_cache };

package/dist/chunks/{provider-8xvmqg79.js → instruction-discovery-3k8qww1e.js}

@@ -1,9 +1,9 @@
 import {
-  ID12
-} from "./provider-3ck6fvg6.js";
+  ID9
+} from "./instruction-discovery-p9zrypfp.js";
 import {
   loadSDKFactory2
-} from "./provider-hjbc5kem.js";
+} from "./instruction-discovery-hjbc5kem.js";
 
 // src/plugin/provider/sap-ai-core.ts
 import { Effect } from "effect";
@@ -14,7 +14,7 @@ var SapAICorePlugin2 = define({
   effect: Effect.fn(function* (ctx) {
     const npm = yield* Npm.Service;
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID12.make("sap-ai-core"))
+      if (evt.model.providerID !== ID9.make("sap-ai-core"))
         return;
       const serviceKey = process.env.AICORE_SERVICE_KEY ?? (typeof evt.options.serviceKey === "string" ? evt.options.serviceKey : undefined);
       if (serviceKey && !process.env.AICORE_SERVICE_KEY)
@@ -25,7 +25,7 @@ var SapAICorePlugin2 = define({
       evt.sdk = factory(serviceKey ? { deploymentId: process.env.AICORE_DEPLOYMENT_ID, resourceGroup: process.env.AICORE_RESOURCE_GROUP } : {});
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID12.make("sap-ai-core"))
+      if (evt.model.providerID !== ID9.make("sap-ai-core"))
         return;
       evt.language = evt.sdk(evt.model.modelID ?? evt.model.id);
     }));

package/dist/chunks/{provider-zpx63w9z.js → instruction-discovery-3q5ajc3h.js}

@@ -1,45 +1,45 @@
 import {
-  Service65
-} from "./provider-eg8s060n.js";
+  Service51
+} from "./instruction-discovery-9dz1p9rk.js";
 import {
   unavailable3
-} from "./provider-t550f9t1.js";
+} from "./instruction-discovery-s8d7rejh.js";
 import {
   AbsolutePath2
-} from "./provider-922hggd3.js";
+} from "./instruction-discovery-922hggd3.js";
 import {
   File2,
-  Service41
-} from "./provider-ds9fva7f.js";
+  Service66
+} from "./instruction-discovery-nr56gd40.js";
 import {
-  Service79
-} from "./provider-6cdpcxhv.js";
+  Service76
+} from "./instruction-discovery-9cc9anwb.js";
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/config/plugin/instruction.ts
 var exports_instruction = {};
 __export(exports_instruction, {
   ConfigInstructionPlugin: () => exports_instruction,
-  Plugin: () => Plugin19
+  Plugin: () => Plugin32
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
 import { Global } from "@opencode/util/global";
 import { dirname, join } from "path";
 import { Effect, PubSub, Semaphore, Stream } from "effect";
-var Plugin19 = define({
+var Plugin32 = define({
   id: "opencode.config.instruction",
   effect: Effect.fn(function* () {
-    const discovery = yield* Service41;
+    const discovery = yield* Service66;
     if (!discovery.project && !discovery.global)
       return;
     yield* Effect.gen(function* () {
       const fs = yield* FSUtil.Service;
       const global = yield* Global.Service;
-      const location = yield* Service79;
-      const watcher = yield* Service65;
+      const location = yield* Service76;
+      const watcher = yield* Service51;
       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 { Plugin19, exports_instruction };
+export { Plugin32, exports_instruction };

package/dist/chunks/{provider-3smtnn6g.js → instruction-discovery-3smtnn6g.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/mime.ts
 var exports_mime = {};

package/dist/chunks/{provider-3tvqynh2.js → instruction-discovery-3tvqynh2.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./provider-9rqn6x4v.js";
+} from "./instruction-discovery-9rqn6x4v.js";
 
 // src/database/v1-migration.ts
 var exports_v1_migration = {};

package/dist/chunks/{provider-2sfvcfsn.js → instruction-discovery-3xkhh9p9.js}

@@ -1,17 +1,17 @@
 import {
   mergeOverlay2,
-  Service72
-} from "./provider-3ck6fvg6.js";
+  Service69
+} from "./instruction-discovery-p9zrypfp.js";
 import {
-  Service64
-} from "./provider-qq9garkb.js";
+  Service50
+} from "./instruction-discovery-q5gw3b6m.js";
 
 // src/plugin/provider/configured.ts
 import { Effect, Option } from "effect";
 var configuredSettings2 = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
-  const providers = yield* Service72;
+  const providers = yield* Service69;
   const current = (yield* providers.get(id))?.settings;
-  const service = yield* Effect.serviceOption(Service64);
+  const service = yield* Effect.serviceOption(Service50);
   const entries = Option.isSome(service) ? yield* service.value.entries() : [];
   return foldSettings2(entries, id, current);
 });