@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-snpn6bap.js → kv-x1b8g1yb.js}

@@ -1,7 +1,7 @@
 // src/plugin/provider/sdk-factory.ts
 import { Effect } from "effect";
 import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
-var loadSDKFactory = Effect.fnUntraced(function* (npm, packageName) {
+var loadSDKFactory2 = Effect.fnUntraced(function* (npm, packageName) {
   const installedPath = packageName.startsWith("file://") ? packageName : yield* npm.add(packageName).pipe(Effect.orDie, Effect.map((installed) => resolveModule(installed.name, installed.directory)));
   const mod = yield* Effect.promise(() => importModule(installedPath));
   const match = Object.keys(mod).find((name) => name.startsWith("create"));
@@ -10,4 +10,4 @@ var loadSDKFactory = Effect.fnUntraced(function* (npm, packageName) {
   return mod[match];
 });
 
-export { loadSDKFactory };
+export { loadSDKFactory2 };

package/dist/chunks/{instance-hbtzhcxr.js → kv-x1ezjp6w.js}

@@ -1,34 +1,34 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/session/subagent-completion.ts
 var exports_subagent_completion = {};
 __export(exports_subagent_completion, {
-  NO_TEXT: () => NO_TEXT,
+  NO_TEXT: () => NO_TEXT2,
   SubagentCompletion: () => exports_subagent_completion,
-  deliver: () => deliver,
-  text: () => text
+  deliver: () => deliver2,
+  text: () => text2
 });
 import { Effect } from "effect";
-var NO_TEXT = "Subagent completed without a text response.";
-function text(message) {
+var NO_TEXT2 = "Subagent completed without a text response.";
+function text2(message) {
   if (message?.type !== "assistant")
-    return NO_TEXT;
-  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT;
+    return NO_TEXT2;
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT2;
 }
-var deliver = Effect.fnUntraced(function* (sessions, jobs, input) {
+var deliver2 = Effect.fnUntraced(function* (sessions, jobs, input) {
   if (input.status === "running")
     return;
   const recovery = input.recovery;
-  const text2 = input.status === "completed" ? input.output ?? NO_TEXT : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
+  const text = input.status === "completed" ? input.output ?? NO_TEXT2 : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
   yield* sessions.synthetic({
     ...input.notificationID ? { id: input.notificationID } : {},
     sessionID: recovery.parentSessionID,
     ...input.resume === false ? { resume: false } : {},
     description: recovery.description,
     text: `<subagent sessionID="${recovery.childSessionID}" state="${input.status}" description="${recovery.description}">
-${text2}
+${text}
 </subagent>`,
     metadata: { source: "subagent", childID: recovery.childSessionID, agent: recovery.agent, state: input.status }
   });
@@ -36,4 +36,4 @@ ${text2}
     yield* jobs.completeBackground(input.notificationID);
 });
 
-export { NO_TEXT, text, deliver, exports_subagent_completion };
+export { NO_TEXT2, text2, deliver2, exports_subagent_completion };

package/dist/chunks/{instance-0cgt0xh2.js → kv-x61499pn.js}

@@ -1,5 +1,5 @@
 // src/github-copilot/chat/map-openai-compatible-finish-reason.ts
-function mapOpenAICompatibleFinishReason(finishReason) {
+function mapOpenAICompatibleFinishReason2(finishReason) {
   switch (finishReason) {
     case "stop":
       return "stop";
@@ -15,4 +15,4 @@ function mapOpenAICompatibleFinishReason(finishReason) {
   }
 }
 
-export { mapOpenAICompatibleFinishReason };
+export { mapOpenAICompatibleFinishReason2 };

package/dist/chunks/{instance-79khac0p.js → kv-x6560wra.js}

@@ -1,34 +1,39 @@
 import {
-  exports_repository
-} from "./instance-s32nnj3r.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_kv
-} from "./instance-qtvzgpey.js";
+  Service72,
+  node76
+} from "./kv-fw8cvjkv.js";
 import {
-  exports_git
-} from "./instance-qz5gwjr7.js";
+  parse4,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./kv-2402vzrj.js";
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  Service68,
+  node72
+} from "./kv-keptat7v.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};
 __export(exports_repository_cache, {
-  CacheOperationError: () => CacheOperationError,
-  CheckoutFailedError: () => CheckoutFailedError,
-  CloneFailedError: () => CloneFailedError,
-  FetchFailedError: () => FetchFailedError,
-  InvalidBranchError: () => InvalidBranchError,
-  LockFailedError: () => LockFailedError,
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
   RepositoryCache: () => exports_repository_cache,
-  ResetFailedError: () => ResetFailedError,
-  Service: () => Service,
-  isError: () => isError,
-  node: () => node,
-  validateBranch: () => validateBranch
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service45,
+  isError: () => isError2,
+  node: () => node48,
+  validateBranch: () => validateBranch2
 });
 import path from "path";
 import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
@@ -41,82 +46,82 @@ var Refresh = Schema.Struct({
 });
 var refreshInterval = Duration.toMillis(Duration.days(1));
 
-class InvalidBranchError extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CloneFailedError extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class FetchFailedError extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CheckoutFailedError extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
   repository: Schema.String,
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class ResetFailedError extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class LockFailedError extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
   localPath: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CacheOperationError extends Schema.TaggedError()("RepositoryCacheOperationError", {
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
   operation: Schema.String,
   path: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/RepositoryCache") {
+class Service45 extends Context.Service()("@opencode/RepositoryCache") {
 }
-function isError(error) {
-  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+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;
 }
-var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
   return yield* Effect.try({
-    try: () => exports_repository.validateBranch(branch),
-    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
   });
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service45, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service72;
   const flock = yield* EffectFlock.Service;
   const global = yield* Global.Service;
-  const kv = yield* exports_kv.Service;
-  return Service.of({
+  const kv = yield* Service68;
+  return Service45.of({
     ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
       if (input.branch)
-        yield* validateBranch(input.branch);
+        yield* validateBranch2(input.branch);
       const repository = input.reference.label;
-      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
       const key = `repository-cache:${localPath}`;
-      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      const cloneTarget = parse4(input.reference.remote) ?? input.reference;
       return yield* flock.withLock(Effect.gen(function* () {
         yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
-        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const existing = yield* git.repo.discover(AbsolutePath2.make(localPath));
         const origin = existing ? yield* git.remote.get(existing) : undefined;
-        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const originReference = origin ? parse4(origin) : undefined;
         const worktree = existing ? yield* fs.resolve(localPath) : undefined;
-        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
         if (!reuse && (yield* fs.existsSafe(localPath))) {
           yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
         }
@@ -129,26 +134,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           if (status === "cloned") {
             yield* git.repo.clone({
               remote: input.reference.remote,
-              directory: AbsolutePath.make(localPath),
+              directory: AbsolutePath2.make(localPath),
               branch: input.branch
-            }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
           }
           if (status === "refreshed") {
             if (!existing)
-              return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
-            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             if (input.branch) {
-              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             }
             const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
             if (branch) {
-              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError2({ repository, branch, message: error.message })));
             }
             const target = branch ?? (yield* git.history.branch(existing));
-            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError2({ repository, message: error.message })));
           }
         }
-        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const checkout = yield* git.repo.discover(AbsolutePath2.make(localPath));
         return {
           repository,
           host: input.reference.host,
@@ -158,20 +163,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           head: checkout ? yield* git.history.head(checkout) : undefined,
           branch: checkout ? yield* git.history.branch(checkout) : undefined
         };
-      }), key).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
     })
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node48 = makeGlobalNode({
+  service: Service45,
   layer,
-  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node, exports_kv.node]
+  deps: [EffectFlock.node, FSUtil.node, node76, Global.node, node72]
 });
 function errorMessage(error) {
   return error instanceof globalThis.Error ? error.message : String(error);
 }
 function cacheOperation(effect, operation, target) {
-  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
 }
 
-export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service45, isError2, validateBranch2, node48, exports_repository_cache };

package/dist/chunks/{instance-nq32axp3.js → kv-x7a9f5qc.js}

@@ -1,30 +1,30 @@
 import {
-  exports_compaction
-} from "./instance-kfgn6n4e.js";
+  Service50
+} from "./kv-7m27rx9w.js";
 import {
-  exports_entry_observer
-} from "./instance-mnyszbxc.js";
+  Service8
+} from "./kv-pmqshxn9.js";
 import {
-  exports_config
-} from "./instance-rksay3ym.js";
+  observe2
+} from "./kv-qsdy395h.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-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: () => Plugin28
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin28 = 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* Service50;
+    const compaction = yield* Service8;
+    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 { Plugin28, exports_compaction };

package/dist/chunks/{instance-n3w3s70a.js → kv-xdvenhre.js}

@@ -1,26 +1,32 @@
 import {
-  exports_mcp as exports_mcp2
-} from "./instance-jb524syp.js";
+  Key3,
+  removed2,
+  empty3,
+  make19,
+  diffByKey2
+} from "./kv-6e958v7x.js";
 import {
-  exports_mcp
-} from "./instance-yrcc2tj9.js";
+  evaluate2
+} from "./kv-nsdz1sxb.js";
 import {
-  exports_permission
-} from "./instance-enjmckgs.js";
+  Service35,
+  node38
+} from "./kv-g12117d9.js";
 import {
-  exports_instructions
-} from "./instance-c54e84vp.js";
+  namespace2,
+  name13
+} from "./kv-dec85aak.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/mcp/instructions.ts
 var exports_instructions2 = {};
 __export(exports_instructions2, {
   McpInstructions: () => exports_instructions2,
-  Service: () => Service,
-  layer: () => layer,
-  node: () => node
+  Service: () => Service27,
+  layer: () => layer12,
+  node: () => node30
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -32,7 +38,7 @@ var Summary = Schema.Struct({
 var entries = (servers) => servers.flatMap((server) => {
   const result = [`  <server name="${server.server}">`];
   if (server.codemode !== false)
-    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(exports_mcp2.namespace(server.server))}]\`.`);
+    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(namespace2(server.server))}]\`.`);
   result.push(...server.instructions.split(`
 `).map((line) => `    ${line}`), "  </server>");
   return result;
@@ -40,7 +46,7 @@ var entries = (servers) => servers.flatMap((server) => {
 var render = (servers) => ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join(`
 `);
 var update = (previous, current) => {
-  const diff = exports_instructions.diffByKey(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
+  const diff = diffByKey2(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
   if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
     return [
       "The available MCP server instructions have changed. This list supersedes the previous one.",
@@ -56,17 +62,17 @@ var update = (previous, current) => {
 `);
 };
 
-class Service extends Context.Service()("@opencode/McpInstructions") {
+class Service27 extends Context.Service()("@opencode/McpInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const mcp = yield* exports_mcp.Service;
-  return Service.of({
+var layer12 = Layer.effect(Service27, Effect.gen(function* () {
+  const mcp = yield* Service35;
+  return Service27.of({
     load: Effect.fn("McpInstructions.load")(function* (selection) {
       const agent = selection.info;
       if (!agent)
-        return exports_instructions.empty;
-      const source = (value) => exports_instructions.make({
-        key: exports_instructions.Key.make("core/mcp-guidance"),
+        return empty3;
+      const source = (value) => make19({
+        key: Key3.make("core/mcp-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
         read: Effect.succeed(value),
         render: {
@@ -78,22 +84,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
         concurrency: "unbounded"
       });
-      const canExecute = exports_permission.evaluate("execute", "*", agent.permissions).effect !== "deny";
+      const canExecute = evaluate2("execute", "*", agent.permissions).effect !== "deny";
       const visible = instructions.flatMap((item) => {
         const owned = tools.filter((tool) => tool.server === item.server);
         const codemode = owned[0]?.codemode !== false;
         if (codemode && !canExecute)
           return [];
-        if (!owned.some((tool) => exports_permission.evaluate(exports_mcp2.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
+        if (!owned.some((tool) => evaluate2(name13(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
           return [];
         return [
           codemode ? { server: item.server, instructions: item.instructions } : { server: item.server, instructions: item.instructions, codemode: false }
         ];
       }).toSorted((a, b) => a.server.localeCompare(b.server));
-      return source(visible.length === 0 ? exports_instructions.removed : visible);
+      return source(visible.length === 0 ? removed2 : visible);
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_mcp.node] });
+var node30 = makeLocationNode({ service: Service27, layer: layer12, deps: [node38] });
 
-export { Service, layer, node, exports_instructions2 as exports_instructions };
+export { Service27, layer12, node30, exports_instructions2 };

package/dist/chunks/kv-xzjsw50f.js

@@ -0,0 +1,38 @@
+import {
+  ephemeral2,
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/plugin/sdk.ts
+var exports_sdk = {};
+__export(exports_sdk, {
+  SdkPlugins: () => exports_sdk,
+  Service: () => Service10,
+  Updated: () => Updated2,
+  layer: () => layer7,
+  node: () => node12
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Updated2 = ephemeral2({ type: "sdk.plugin.updated", schema: {} });
+
+class Service10 extends Context.Service()("@opencode/SdkPlugins") {
+}
+var layer7 = Layer.effect(Service10, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const plugins = new Map;
+  let revision = 0;
+  return Service10.of({
+    register: (plugin) => Effect.sync(() => {
+      plugins.set(plugin.id, { ...plugin, revision: String(++revision), source: { type: "sdk" } });
+    }).pipe(Effect.andThen(bus.publish(Updated2, {})), Effect.asVoid),
+    all: () => [...plugins.values()]
+  });
+}));
+var node12 = makeGlobalNode({ service: Service10, layer: layer7, deps: [node83] });
+
+export { Updated2, Service10, layer7, node12, exports_sdk };

package/dist/chunks/kv-y0bse006.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  App: () => exports_app,
+  Metadata: () => Metadata2,
+  configured: () => configured5,
+  layer: () => layer18,
+  make: () => make18,
+  node: () => node45,
+  useragent: () => useragent2
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Metadata2 = Context.Reference("@opencode/App", {
+  defaultValue: () => make18()
+});
+function make18(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent2(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer18 = (input) => Layer.succeed(Metadata2, make18(input));
+var configured5 = (input) => makeGlobalNode({ service: Metadata2, layer: layer18(input), deps: [] });
+var node45 = configured5();
+
+export { Metadata2, make18, useragent2, layer18, configured5, node45, exports_app };

package/dist/chunks/{instance-edxnhgvj.js → kv-y1fvbwt7.js}

@@ -1,14 +1,14 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/util/wildcard.ts
 var exports_wildcard = {};
 __export(exports_wildcard, {
   Wildcard: () => exports_wildcard,
-  match: () => match
+  match: () => match2
 });
-function match(input, pattern) {
+function match2(input, pattern) {
   const normalized = input.replaceAll("\\", "/");
   let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   if (escaped.endsWith(" .*"))
@@ -16,4 +16,4 @@ function match(input, pattern) {
   return new RegExp("^" + escaped + "$", process.platform === "win32" ? "si" : "s").test(normalized);
 }
 
-export { match, exports_wildcard };
+export { match2, exports_wildcard };

package/dist/chunks/{instance-qaarhjrp.js → kv-y44na4kk.js}

@@ -1,5 +1,5 @@
 // src/session/runner/max-steps.ts
-var MAX_STEPS_PROMPT = `CRITICAL - MAXIMUM STEPS REACHED
+var MAX_STEPS_PROMPT2 = `CRITICAL - MAXIMUM STEPS REACHED
 
 The maximum number of steps allowed for this task has been reached. Tools are disabled until next user input. Respond with text only.
 
@@ -16,4 +16,4 @@ Response must include:
 
 Any attempt to use tools is a critical violation. Respond with text ONLY.`;
 
-export { MAX_STEPS_PROMPT };
+export { MAX_STEPS_PROMPT2 };