@opencode-ai/core 0.0.0-beta-19234 → 0.0.0-beta-19266

package/dist/chunks/{worktree-tqmakht3.js → schema-8aw20fxv.js}

@@ -1,50 +1,65 @@
+import {
+  Service80,
+  node85
+} from "./schema-fv0bxyhd.js";
 import {
   Service79,
   node84
-} from "./worktree-dng5ka12.js";
+} from "./schema-6qptncg2.js";
 import {
   llmClient2
-} from "./worktree-0e0xafbb.js";
+} from "./schema-0e0xafbb.js";
 import {
   SessionEvent2
-} from "./worktree-mntxs535.js";
+} from "./schema-mntxs535.js";
+import {
+  provenance2,
+  compatible2,
+  isCheckpoint2,
+  encode2
+} from "./schema-rqdcv1n1.js";
+import {
+  load2
+} from "./schema-pe5crvt1.js";
 import {
   create3
-} from "./worktree-kg06axw8.js";
+} from "./schema-kg06axw8.js";
 import {
   toLLMMessages2
-} from "./worktree-zbjnn3ac.js";
+} from "./schema-v72m8j26.js";
 import {
   baseTranscript2,
-  unsupportedParts2
-} from "./worktree-nhfc898y.js";
-import {
-  isRetryable2,
-  policy2
-} from "./worktree-hnyf01b0.js";
+  unsupportedParts2,
+  boundImages2
+} from "./schema-q1nkzk48.js";
 import {
   toSessionError2
-} from "./worktree-b3kfkjj6.js";
+} from "./schema-xrtvrd4c.js";
+import {
+  policy2,
+  transient2
+} from "./schema-bnfahk6g.js";
 import {
   estimate2
-} from "./worktree-h6vf3j39.js";
+} from "./schema-h6vf3j39.js";
 import {
   record2,
   add2
-} from "./worktree-tjykrgmx.js";
+} from "./schema-tjykrgmx.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/session/compaction.ts
 var exports_compaction2 = {};
 __export(exports_compaction2, {
-  Service: () => Service9,
+  Service: () => Service4,
   SessionCompaction: () => exports_compaction2,
   buildPrompt: () => buildPrompt2,
   estimateTokens: () => estimateTokens2,
-  layer: () => layer7,
-  node: () => node12,
+  layer: () => layer6,
+  node: () => node7,
+  retainUsers: () => retainUsers2,
   serializeToolContent: () => serializeToolContent2,
   truncateToolOutput: () => truncateToolOutput2
 });
@@ -108,10 +123,11 @@ var SUMMARY_RULES = `Rules:
 var SUMMARY_HEADINGS = SUMMARY_TEMPLATE.split(`
 `).filter((line) => line.startsWith("##"));
 
-class Service9 extends Context.Service()("@opencode/SessionCompaction") {
+class Service4 extends Context.Service()("@opencode/SessionCompaction") {
 }
+var hasInputUsage = (message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0;
 var estimateTokens2 = (input) => {
-  const index = input.messages.findLastIndex((message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0);
+  const index = input.messages.findLastIndex(hasInputUsage);
   const last = input.messages[index];
   const added = unsupportedParts2(toLLMMessages2(input.messages.slice(Math.max(0, index)), input.resolved.ref), input.resolved.capabilities).filter((message) => message.role !== "assistant" || message.id !== last?.id).reduce((sum, message) => sum + message.content.reduce((sum, part) => sum + estimatePart(part), 0), 0);
   if (last?.type === "assistant" && last.tokens)
@@ -142,6 +158,19 @@ var estimatePart = (part) => {
     return part.result.value.reduce((sum, content) => sum + (content.type === "text" ? estimate2(content.text) : estimateMedia(content.mime)), 0);
   return estimate2(typeof part.result.value === "string" ? part.result.value : JSON.stringify(part.result.value) ?? "");
 };
+var retainUsers2 = (messages, model, keepTokens) => {
+  const users = boundImages2(unsupportedParts2(toLLMMessages2(messages.filter((message) => message.type === "user").map((message) => ({ ...message, skills: undefined })), model.ref), model.capabilities));
+  let tokens = 0;
+  let start = users.length;
+  for (let index = users.length - 1;index >= 0; index--) {
+    const size = users[index].content.reduce((sum, part) => sum + estimatePart(part), 0);
+    if (tokens + size > keepTokens)
+      break;
+    tokens += size;
+    start = index;
+  }
+  return users.slice(start);
+};
 var truncateToolOutput2 = (value) => {
   if (value.length <= TOOL_OUTPUT_MAX_CHARS)
     return value;
@@ -262,9 +291,10 @@ var buildPrompt2 = (update) => {
 };
 var hasSummarySection = (summary) => summary.split(`
 `).some((line) => SUMMARY_HEADINGS.includes(line.trim()));
-var layer7 = Layer.effect(Service9, Effect.gen(function* () {
+var layer6 = Layer.effect(Service4, Effect.gen(function* () {
   const bus = yield* Service79;
   const llm = yield* LLMClient.Service;
+  const db = (yield* Service80).db;
   const state = create3({
     name: "session-compaction",
     initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
@@ -283,40 +313,28 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     yield* bus.publish(SessionEvent2.Compaction.Failed, input);
     return { status: "failed", error: input.error };
   });
-  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+  const started = (input, recent) => input.started ? Effect.void : bus.publish(SessionEvent2.Compaction.Started, {
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    recent,
+    inputID: input.inputID
+  });
+  const interrupted = (input) => input.reason === "auto" ? failed({
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    inputID: input.inputID,
+    error: { type: "compaction.interrupted", message: "Compaction was interrupted" }
+  }).pipe(Effect.asVoid) : Effect.void;
+  const compactionRequest = (input, messages, prompt, webSocket) => {
     const context = input.context;
-    const history = splitHistory(context.messages, state.get().tokens);
-    if (!history)
-      return yield* failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-        inputID: input.inputID
-      });
-    if (!input.started)
-      yield* bus.publish(SessionEvent2.Compaction.Started, {
-        sessionID: context.session.id,
-        reason: input.reason,
-        recent: history.recent,
-        inputID: input.inputID
-      });
-    const chunks = [];
-    let failure;
-    let usage;
-    let providerState;
-    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
-      sessionID: context.session.id,
-      source: "compaction",
-      ...usage
-    }) : Effect.void);
     const transcript = baseTranscript2({
       agent: context.agent.info,
       model: context.model,
       tools: context.tools,
       initial: context.initial,
-      messages: history.messages
+      messages
     });
-    const prepared = yield* input.prepare({
+    return input.prepare({
       kind: "compaction",
       scope: {
         session: context.session,
@@ -330,11 +348,96 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
         messages: [
           ...transcript.messages,
           ...input.instructionUpdate ? [Message.system(input.instructionUpdate)] : [],
-          Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+          ...prompt
         ]
-      }
+      },
+      webSocket
+    });
+  };
+  const original = (sessionID) => load2(db, sessionID, "local").pipe(Effect.orDie);
+  const recoverLocally = (input) => original(input.context.session.id).pipe(Effect.flatMap((messages) => execute({ ...input, context: { ...input.context, messages } })));
+  const executeProvider = Effect.fn("SessionCompaction.executeProvider")(function* (input) {
+    const context = input.context;
+    const reject = (message) => failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: { type: "provider.unsupported-operation", message }
+    });
+    const prepared = yield* compactionRequest(input, context.messages, [], "session");
+    const request = prepared.request;
+    const provenance = provenance2(context.model);
+    if (!provenance)
+      return yield* reject("Provider compaction requires a stable, configured endpoint");
+    if (!compatible2(provenance, provenance2({ model: request.model, ref: context.model.ref })))
+      return yield* reject("Provider compaction requires the endpoint in provider/model settings, not a model.request rewrite");
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
+    });
+    yield* started(input, "");
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const result = yield* restore(Effect.gen(function* () {
+        if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
+          const retained = retainUsers2(yield* original(context.session.id), context.model, state.get().tokens);
+          const result = yield* llm.compact(request, { ...prepared.options, mechanism: "trigger" }).pipe(transient);
+          return { replacement: [...retained, Message.assistant(result.checkpoint)], usage: result.usage };
+        }
+        if (LLMClient.canCompact(request))
+          return yield* llm.compact(request, { mechanism: "endpoint", http: prepared.options.http }).pipe(transient);
+        return yield* Effect.die(new Error(`${request.model.provider}/${request.model.route.id} has no compaction operation`));
+      }));
+      if (result.usage)
+        yield* bus.publish(SessionEvent2.UsageRecorded, {
+          sessionID: context.session.id,
+          source: "compaction",
+          ...record2(result.usage, context.model.cost)
+        });
+      yield* bus.publish(SessionEvent2.Compaction.Ended, {
+        sessionID: context.session.id,
+        reason: input.reason,
+        model: context.model.ref,
+        text: "",
+        recent: "",
+        providerContext: encode2(provenance, result.replacement)
+      });
+      return { status: "completed" };
+    })).pipe(Effect.onInterrupt(() => interrupted(input)), Effect.catchTag("AI.Error", (cause) => input.reason === "auto" && isContextOverflowFailure(cause) ? recoverLocally({ ...input, started: true }).pipe(Effect.map((result) => result.status === "completed" ? { ...result, recoveredOverflow: true } : result)) : failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: toSessionError2(cause)
+    })));
+  });
+  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+    const context = input.context;
+    const history = splitHistory(context.messages, state.get().tokens);
+    if (!history)
+      return yield* failed({
+        sessionID: context.session.id,
+        reason: input.reason,
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+        inputID: input.inputID
+      });
+    yield* started(input, history.recent);
+    const chunks = [];
+    let failure;
+    let usage;
+    let providerState;
+    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
+      sessionID: context.session.id,
+      source: "compaction",
+      ...usage
+    }) : Effect.void);
+    const prepared = yield* compactionRequest(input, history.messages, [
+      Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+    ]);
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
     });
-    const retry = yield* policy2(context.session.id);
     for (const request of [
       prepared.request,
       LLMRequest.update(prepared.request, {
@@ -386,31 +489,9 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
             return Effect.fail(new AIError({ reason: new UnknownProviderError({ message: "Compaction generation failed" }) }));
         }
         return Effect.void;
-      }), Effect.retry({
-        while: (cause) => Effect.gen(function* () {
-          if (isContextOverflowFailure(cause))
-            return false;
-          const decision = yield* retry({
-            cause,
-            error: toSessionError2(cause),
-            agent: Agent.ID.make("compaction"),
-            model: context.model.ref,
-            hook: prepared.retry,
-            retry: isRetryable2(cause)
-          });
-          if (!decision.retry)
-            return false;
-          yield* Effect.sleep(decision.delay);
-          return true;
-        })
-      }), Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
+      }), transient, Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
         failure = toSessionError2(error);
-      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(input.reason === "auto" ? failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-        inputID: input.inputID
-      }).pipe(Effect.asVoid) : Effect.void))));
+      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(interrupted(input)))));
       if (failure || hasSummarySection(chunks.join("")))
         break;
     }
@@ -438,7 +519,14 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     });
     return { status: "completed" };
   });
-  const compact = (input) => execute({ ...input, reason: "auto" });
+  const compact = Effect.fn("SessionCompaction.compact")(function* (input) {
+    const request = { ...input, reason: "auto" };
+    if (input.overflow)
+      return yield* recoverLocally(request);
+    if (input.context.model.compaction?.mode !== "provider")
+      return yield* execute(request);
+    return yield* executeProvider(request);
+  });
   const required = (input) => {
     const config = state.get();
     if (!config.auto)
@@ -446,13 +534,17 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     const last = input.messages.at(-1);
     if (last?.type === "compaction" && last.status === "completed")
       return false;
+    if (input.messages.findLastIndex(hasInputUsage) < input.messages.findLastIndex(isCheckpoint2))
+      return false;
     const limit = input.resolved.limit;
     const context = limit.context;
     if (context <= 0)
       return false;
     const output = Math.min(limit.output, OUTPUT_TOKEN_MAX);
     const promptCeiling = Math.min(limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer, context - Math.max(output, config.buffer));
-    return estimateTokens2(input) >= promptCeiling;
+    const policy = input.resolved.compaction;
+    const threshold = policy?.mode === "provider" && policy.threshold !== undefined ? Math.min(policy.threshold, promptCeiling) : promptCeiling;
+    return estimateTokens2(input) >= threshold;
   };
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input) {
     if (findTailStart(input.messages, state.get().tokens) === undefined)
@@ -469,17 +561,20 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
         error: toSessionError2(cause),
         inputID: input.inputID
       }),
-      onSuccess: (context) => execute({
-        context,
-        instructionUpdate: context.instructionUpdate,
-        prepare: input.prepare,
-        reason: "manual",
-        inputID: input.inputID,
-        started: input.started
-      })
+      onSuccess: (context) => {
+        const request = {
+          context,
+          instructionUpdate: context.instructionUpdate,
+          prepare: input.prepare,
+          reason: "manual",
+          inputID: input.inputID,
+          started: input.started
+        };
+        return context.model.compaction?.mode === "provider" ? executeProvider(request) : execute(request);
+      }
     }));
   });
-  return Service9.of({
+  return Service4.of({
     transform: state.transform,
     reload: state.reload,
     enabled: () => state.get().auto,
@@ -488,10 +583,10 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     compactManual
   });
 }));
-var node12 = makeLocationNode({
-  service: Service9,
-  layer: layer7,
-  deps: [node84, llmClient2]
+var node7 = makeLocationNode({
+  service: Service4,
+  layer: layer6,
+  deps: [node84, node85, llmClient2]
 });
 
-export { Service9, estimateTokens2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer7, node12, exports_compaction2 };
+export { Service4, estimateTokens2, retainUsers2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer6, node7, exports_compaction2 };

package/dist/chunks/{worktree-7er3jcv0.js → schema-8ay24fmk.js}

@@ -1,41 +1,41 @@
 import {
-  Service48
-} from "./worktree-471a560f.js";
+  Service54
+} from "./schema-hsq9qkqb.js";
 import {
   ID5,
   Name2,
   toModelOutput3,
   prepare3,
-  Service47
-} from "./worktree-x4ndt50x.js";
+  Service40
+} from "./schema-e8qch614.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/tool/plugin/skill.ts
-var exports_skill = {};
-__export(exports_skill, {
-  Input: () => Input11,
-  Output: () => Output7,
-  Plugin: () => Plugin12,
-  SkillTool: () => exports_skill,
-  description: () => description5,
-  name: () => name11,
+var exports_skill3 = {};
+__export(exports_skill3, {
+  Input: () => Input5,
+  Output: () => Output4,
+  Plugin: () => Plugin36,
+  SkillTool: () => exports_skill3,
+  description: () => description2,
+  name: () => name5,
   toModelOutput: () => toModelOutput2
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var name11 = "skill";
-var Input11 = Schema.Struct({
+var name5 = "skill";
+var Input5 = Schema.Struct({
   id: ID5.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
 });
-var Output7 = Schema.Struct({
+var Output4 = Schema.Struct({
   name: Name2,
   directory: Schema.String,
   output: Schema.String
 });
-var description5 = [
+var description2 = [
   "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 description5 = [
 `);
 var toModelOutput2 = toModelOutput3;
 var unableToLoad = (name, error) => new ToolFailure({ message: `Unable to load skill ${name}`, error });
-var Plugin12 = {
+var Plugin36 = {
   id: "opencode.tool.skill",
   effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
     const fs = yield* FSUtil.Service;
-    const skills = yield* Service47;
-    const permission = yield* Service48;
+    const skills = yield* Service40;
+    const permission = yield* Service54;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name11,
+      name: name5,
       options: { codemode: false },
-      description: description5,
-      input: Input11,
-      output: Output7,
+      description: description2,
+      input: Input5,
+      output: Output4,
       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: name11,
+            action: name5,
             resources: [skill.id],
             save: [skill.id],
             sessionID: context.sessionID,
@@ -79,4 +79,4 @@ var Plugin12 = {
   })
 };
 
-export { name11, Input11, Output7, description5, toModelOutput2, Plugin12, exports_skill };
+export { name5, Input5, Output4, description2, toModelOutput2, Plugin36, exports_skill3 };

package/dist/chunks/{worktree-cnze8n7v.js → schema-8d0pmt0f.js}

@@ -1,12 +1,12 @@
 import {
-  ID13
-} from "./worktree-k3skpd5n.js";
+  ID16
+} from "./schema-yx2cz2pp.js";
 import {
-  Service62
-} from "./worktree-xpxmebhh.js";
+  Service66
+} from "./schema-vecstcyh.js";
 import {
   foldSettings2
-} from "./worktree-hevn35yy.js";
+} from "./schema-1s4vv42h.js";
 
 // src/plugin/provider/vllm.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -21,12 +21,12 @@ var RemoteModel = Schema.Struct({
 var Response = Schema.Struct({ data: Schema.Array(RemoteModel) });
 var discovery = new Map;
 var discoveryLock = Semaphore.makeUnsafe(1);
-function make8(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
+function make7(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
   return define({
     id: "opencode.provider.vllm",
     effect: Effect.fn(function* (ctx) {
       const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-      const config = yield* Service62;
+      const config = yield* Service66;
       const source = { current: configured(yield* config.entries(), origin) };
       const loaded = { models: [], hash: "[]" };
       yield* ctx.integration.transform((integrations) => {
@@ -53,7 +53,7 @@ function make8(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
         });
         for (const item of loaded.models) {
           catalog.model.update(providerID, item.id, (model) => {
-            model.modelID = ID13.make(item.id);
+            model.modelID = ID16.make(item.id);
             model.name = item.id;
             model.capabilities = { tools: false, input: ["text"], output: ["text"] };
             if (typeof item.max_model_len === "number" && item.max_model_len > 0)
@@ -112,7 +112,7 @@ ${current.modelsEndpoint}`;
     })
   });
 }
-var VLLMPlugin2 = make8();
+var VLLMPlugin2 = make7();
 function configured(entries, origin) {
   const settings = foldSettings2(entries, providerID, undefined);
   const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
@@ -134,4 +134,4 @@ function configured(entries, origin) {
   return { baseURL, apiKey, healthEndpoint: health.toString(), modelsEndpoint: models.toString() };
 }
 
-export { make8, VLLMPlugin2 };
+export { make7, VLLMPlugin2 };

package/dist/chunks/{worktree-vhjdrq5e.js → schema-8da146zc.js}

@@ -1,9 +1,9 @@
 import {
-  ID14
-} from "./worktree-zkj92s1w.js";
+  ID17
+} from "./schema-xfrwv263.js";
 import {
   loadSDKFactory2
-} from "./worktree-x1b8g1yb.js";
+} from "./schema-x1b8g1yb.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 !== ID14.make("sap-ai-core"))
+      if (evt.model.providerID !== ID17.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 !== ID14.make("sap-ai-core"))
+      if (evt.model.providerID !== ID17.make("sap-ai-core"))
         return;
       evt.language = evt.sdk(evt.model.modelID ?? evt.model.id);
     }));

package/dist/chunks/{worktree-mw548jxj.js → schema-8gsst550.js}

@@ -1,23 +1,23 @@
 import {
-  Service68,
-  node72
-} from "./worktree-58hqrsnb.js";
+  Service49,
+  node52
+} from "./schema-tnn3pxdz.js";
 import {
   Key3,
   removed2,
-  make17,
+  make19,
   diffByKey2
-} from "./worktree-28pcbh69.js";
+} from "./schema-6e958v7x.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./schema-9rqn6x4v.js";
 
 // src/reference/instructions.ts
-var exports_instructions2 = {};
-__export(exports_instructions2, {
-  ReferenceInstructions: () => exports_instructions2,
-  Service: () => Service28,
-  node: () => node32
+var exports_instructions3 = {};
+__export(exports_instructions3, {
+  ReferenceInstructions: () => exports_instructions3,
+  Service: () => Service34,
+  node: () => node38
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -57,18 +57,18 @@ var update = (previous, current) => {
 `);
 };
 
-class Service28 extends Context.Service()("@opencode/ReferenceInstructions") {
+class Service34 extends Context.Service()("@opencode/ReferenceInstructions") {
 }
-var layer = Layer.effect(Service28, Effect.gen(function* () {
-  const references = yield* Service68;
-  return Service28.of({
+var layer = Layer.effect(Service34, Effect.gen(function* () {
+  const references = yield* Service49;
+  return Service34.of({
     load: Effect.fn("ReferenceInstructions.load")(function* () {
       const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
         name: reference.name,
         path: reference.path,
         description: reference.description
       })).toSorted((a, b) => a.name.localeCompare(b.name));
-      return make17({
+      return make19({
         key: Key3.make("core/reference-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
         read: Effect.succeed(available.length === 0 ? removed2 : available),
@@ -81,6 +81,6 @@ var layer = Layer.effect(Service28, Effect.gen(function* () {
     })
   });
 }));
-var node32 = makeLocationNode({ service: Service28, layer, deps: [node72] });
+var node38 = makeLocationNode({ service: Service34, layer, deps: [node52] });
 
-export { Service28, node32, exports_instructions2 };
+export { Service34, node38, exports_instructions3 };