@opencode-ai/core 0.0.0-beta-19059 → 0.0.0-beta-19124

package/dist/chunks/{shell-b3v8bj34.js → event-logger-8xy158zb.js}

@@ -1,47 +1,63 @@
 import {
-  exports_usage
-} from "./shell-nn16cgj7.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_token
-} from "./shell-z8c1ty6e.js";
+  llmClient2
+} from "./event-logger-0e0xafbb.js";
 import {
-  exports_model_request
-} from "./shell-chwz5826.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
-  toLLMMessages
-} from "./shell-g23fad86.js";
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
-  toSessionError
-} from "./shell-0kfsnc8s.js";
+  toLLMMessages2
+} from "./event-logger-zbjnn3ac.js";
 import {
-  llmClient
-} from "./shell-326j4s6w.js";
+  baseTranscript2,
+  unsupportedParts2
+} from "./event-logger-0v1ejg55.js";
 import {
-  SessionEvent
-} from "./shell-a83yvq99.js";
+  isRetryable2,
+  policy2
+} from "./event-logger-bphmvjfp.js";
 import {
-  exports_state
-} from "./shell-j6s3yjyb.js";
+  toSessionError2
+} from "./event-logger-d3qtrs71.js";
 import {
-  exports_bus
-} from "./shell-07b0cypv.js";
+  estimate2
+} from "./event-logger-h6vf3j39.js";
+import {
+  record2,
+  add2
+} from "./event-logger-tjykrgmx.js";
 import {
   __export
-} from "./shell-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/compaction.ts
-var exports_compaction = {};
-__export(exports_compaction, {
-  Service: () => Service,
-  SessionCompaction: () => exports_compaction,
-  buildPrompt: () => buildPrompt,
-  estimateTokens: () => estimateTokens,
-  layer: () => layer,
-  node: () => node,
-  serializeToolContent: () => serializeToolContent,
-  truncateToolOutput: () => truncateToolOutput
+var exports_compaction2 = {};
+__export(exports_compaction2, {
+  Service: () => Service10,
+  SessionCompaction: () => exports_compaction2,
+  buildPrompt: () => buildPrompt2,
+  estimateTokens: () => estimateTokens2,
+  layer: () => layer6,
+  node: () => node13,
+  serializeToolContent: () => serializeToolContent2,
+  truncateToolOutput: () => truncateToolOutput2
 });
-import { LLMClient, LLMEvent, LLMRequest, Message } from "@opencode-ai/ai";
+import {
+  AIError,
+  InvalidProviderOutputError,
+  UnknownProviderError,
+  isContextOverflowFailure,
+  LLMClient,
+  LLMEvent,
+  LLMRequest,
+  Message
+} from "@opencode-ai/ai";
 import { Agent } from "@opencode-ai/schema/agent";
 import { Context, Effect, Layer, Stream } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
@@ -64,7 +80,7 @@ var SUMMARY_TEMPLATE = `You MUST use this format for your response (you may omit
 
 ## Work State
 ### Completed
-- [finished work, verified facts, or changes made; otherwise "(none)"]
+- [finished work or changes made; otherwise "(none)"]
 
 ### Active
 - [current work, partial changes, or investigation state; otherwise "(none)"]
@@ -92,22 +108,22 @@ var SUMMARY_RULES = `Rules:
 var SUMMARY_HEADINGS = SUMMARY_TEMPLATE.split(`
 `).filter((line) => line.startsWith("##"));
 
-class Service extends Context.Service()("@opencode/SessionCompaction") {
+class Service10 extends Context.Service()("@opencode/SessionCompaction") {
 }
-var estimateTokens = (input) => {
+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 last = input.messages[index];
-  const added = exports_model_request.unsupportedParts(toLLMMessages(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((sum2, part) => sum2 + estimatePart(part), 0), 0);
+  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)
     return added + last.tokens.input + last.tokens.cache.read + last.tokens.cache.write + last.tokens.output + last.tokens.reasoning;
-  const transcript = exports_model_request.baseTranscript({
+  const transcript = baseTranscript2({
     agent: input.context.agent.info,
     model: input.resolved,
     tools: input.context.tools,
     initial: input.context.initial,
     messages: []
   });
-  return added + transcript.system.reduce((sum, part) => sum + exports_token.estimate(part.text), 0) + input.context.tools.definitions.reduce((sum, tool) => sum + exports_token.estimate(tool.name + tool.description + JSON.stringify(tool.inputSchema)), 0);
+  return added + transcript.system.reduce((sum, part) => sum + estimate2(part.text), 0) + input.context.tools.definitions.reduce((sum, tool) => sum + estimate2(tool.name + tool.description + JSON.stringify(tool.inputSchema)), 0);
 };
 var estimateMedia = (mime) => {
   const type = mime.toLowerCase();
@@ -115,18 +131,18 @@ var estimateMedia = (mime) => {
 };
 var estimatePart = (part) => {
   if (part.type === "compaction")
-    return exports_token.estimate(part.text ?? "");
+    return estimate2(part.text ?? "");
   if (part.type === "text" || part.type === "reasoning")
-    return exports_token.estimate(part.text);
+    return estimate2(part.text);
   if (part.type === "media")
     return estimateMedia(part.mediaType);
   if (part.type === "tool-call")
-    return exports_token.estimate(part.name + (JSON.stringify(part.input) ?? ""));
+    return estimate2(part.name + (JSON.stringify(part.input) ?? ""));
   if (part.result.type === "content")
-    return part.result.value.reduce((sum, content) => sum + (content.type === "text" ? exports_token.estimate(content.text) : estimateMedia(content.mime)), 0);
-  return exports_token.estimate(typeof part.result.value === "string" ? part.result.value : JSON.stringify(part.result.value) ?? "");
+    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 truncateToolOutput = (value) => {
+var truncateToolOutput2 = (value) => {
   if (value.length <= TOOL_OUTPUT_MAX_CHARS)
     return value;
   let end = 0;
@@ -139,7 +155,7 @@ var truncateToolOutput = (value) => {
   return `${value.slice(0, end)}
 [truncated]`;
 };
-var serializeToolContent = (content) => content.map((item) => item.type === "text" ? item.text : `[Attached ${item.mime}${item.name === undefined ? "" : `: ${item.name}`}]`).join(`
+var serializeToolContent2 = (content) => content.map((item) => item.type === "text" ? item.text : `[Attached ${item.mime}${item.name === undefined ? "" : `: ${item.name}`}]`).join(`
 `);
 var serializeRecentMessage = (message) => {
   if (message.type === "compaction" || message.type === "system")
@@ -163,7 +179,7 @@ ${skill.text}`]) ?? [];
       if (part.state.status === "completed")
         return [
           `[Assistant tool call]: ${part.name}(${input})`,
-          `[Tool result]: ${truncateToolOutput(serializeToolContent(part.state.content))}`
+          `[Tool result]: ${truncateToolOutput2(serializeToolContent2(part.state.content))}`
         ];
       if (part.state.status === "error")
         return [`[Assistant tool call]: ${part.name}(${input})`, `[Tool error]: ${part.state.error.message}`];
@@ -178,7 +194,7 @@ ${skill.text}`]) ?? [];
 ${message.text}`;
   if (message.type === "shell")
     return message.metadata?.background === true ? "" : `[Shell]: ${message.command}
-${truncateToolOutput(message.output?.output ?? "")}`;
+${truncateToolOutput2(message.output?.output ?? "")}`;
   return "";
 };
 var splitHistory = (messages, keepTokens) => {
@@ -202,7 +218,7 @@ var findTailStart = (messages, keepTokens) => {
   let total = 0;
   let start = conversation.length;
   for (let index = conversation.length - 1;index >= 0; index--) {
-    const next = total + exports_token.estimate(conversation[index].text);
+    const next = total + estimate2(conversation[index].text);
     if (start < conversation.length && next > keepTokens)
       break;
     total = next;
@@ -218,7 +234,7 @@ var findTailStart = (messages, keepTokens) => {
   const previousSummary = messages.findLast((message) => message.type === "compaction" && message.status === "completed");
   return previousSummary?.recent ? conversation[0].index : messages.length;
 };
-var buildPrompt = (update) => {
+var buildPrompt2 = (update) => {
   const shared = [
     "Summarize only the history shown. More recent context may be retained and presented after this summary.",
     SUMMARY_TEMPLATE,
@@ -246,10 +262,10 @@ var buildPrompt = (update) => {
 };
 var hasSummarySection = (summary) => summary.split(`
 `).some((line) => SUMMARY_HEADINGS.includes(line.trim()));
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer6 = Layer.effect(Service10, Effect.gen(function* () {
+  const bus = yield* Service79;
   const llm = yield* LLMClient.Service;
-  const state = exports_state.create({
+  const state = create3({
     name: "session-compaction",
     initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
     editor: (editor) => ({
@@ -264,7 +280,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     })
   });
   const failed = Effect.fnUntraced(function* (input) {
-    yield* bus.publish(SessionEvent.Compaction.Failed, input);
+    yield* bus.publish(SessionEvent2.Compaction.Failed, input);
     return { status: "failed", error: input.error };
   });
   const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
@@ -278,7 +294,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         inputID: input.inputID
       });
     if (!input.started)
-      yield* bus.publish(SessionEvent.Compaction.Started, {
+      yield* bus.publish(SessionEvent2.Compaction.Started, {
         sessionID: context.session.id,
         reason: input.reason,
         recent: history.recent,
@@ -288,12 +304,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     let failure;
     let usage;
     let providerState;
-    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent.UsageRecorded, {
+    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
       sessionID: context.session.id,
       source: "compaction",
       ...usage
     }) : Effect.void);
-    const transcript = exports_model_request.baseTranscript({
+    const transcript = baseTranscript2({
       agent: context.agent.info,
       model: context.model,
       tools: context.tools,
@@ -301,6 +317,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       messages: history.messages
     });
     const prepared = yield* input.prepare({
+      kind: "compaction",
       scope: {
         session: context.session,
         agentID: Agent.ID.make("compaction"),
@@ -313,19 +330,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         messages: [
           ...transcript.messages,
           ...input.instructionUpdate ? [Message.system(input.instructionUpdate)] : [],
-          Message.user(buildPrompt(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+          Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
         ]
       }
     });
-    for (let attempt = 0;attempt < 2; attempt++) {
-      chunks.length = 0;
-      providerState = undefined;
-      yield* llm.stream(attempt === 0 ? prepared.request : LLMRequest.update(prepared.request, {
+    const retry = yield* policy2(context.session.id);
+    for (const request of [
+      prepared.request,
+      LLMRequest.update(prepared.request, {
         messages: [
           ...prepared.request.messages,
           Message.user("The previous response did not fill in the required summary template. Do not call tools. Return the summary as text using the exact section headings from the template.")
         ]
-      }), prepared.options).pipe(Stream.runForEach((event) => {
+      })
+    ]) {
+      yield* Stream.suspend(() => {
+        chunks.length = 0;
+        providerState = undefined;
+        failure = undefined;
+        return llm.stream(request, prepared.options);
+      }).pipe(Stream.runForEach((event) => {
         if (LLMEvent.is.providerError(event))
           failure = {
             type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
@@ -333,19 +357,54 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           };
         if (LLMEvent.is.textDelta(event)) {
           chunks.push(event.text);
-          return bus.publish(SessionEvent.Compaction.Delta, {
+          return bus.publish(SessionEvent2.Compaction.Delta, {
             sessionID: context.session.id,
             text: event.text
           });
         }
         if (LLMEvent.is.stepFinish(event)) {
           providerState = event.providerMetadata?.[context.model.model.route.providerMetadataKey ?? context.model.model.provider];
-          const step = exports_usage.record(event.usage, context.model.cost);
-          usage = usage ? exports_usage.add(usage, step) : step;
+          const step = record2(event.usage, context.model.cost);
+          usage = usage ? add2(usage, step) : step;
+        }
+        if (LLMEvent.is.finish(event)) {
+          if (event.reason.normalized === "length")
+            failure = { type: "compaction.failed", message: "Compaction summary reached the output token limit" };
+          if (event.reason.normalized === "content-filter")
+            failure = {
+              type: "provider.content-filter",
+              message: "Compaction summary was blocked by the provider"
+            };
+          if (event.reason.normalized === "unknown")
+            return Effect.fail(new AIError({
+              reason: new InvalidProviderOutputError({
+                message: "The provider response ended with an unknown finish reason.",
+                classification: "incomplete-stream"
+              })
+            }));
+          if (event.reason.normalized === "error")
+            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(() => {
-        failure = toSessionError(error);
+        failure = toSessionError2(error);
       })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(input.reason === "auto" ? failed({
         sessionID: context.session.id,
         reason: input.reason,
@@ -369,7 +428,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         inputID: input.inputID
       });
     }
-    yield* bus.publish(SessionEvent.Compaction.Ended, {
+    yield* bus.publish(SessionEvent2.Compaction.Ended, {
       sessionID: context.session.id,
       reason: input.reason,
       model: context.model.ref,
@@ -393,7 +452,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       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 estimateTokens(input) >= promptCeiling;
+    return estimateTokens2(input) >= promptCeiling;
   };
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input) {
     if (findTailStart(input.messages, state.get().tokens) === undefined)
@@ -407,7 +466,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       onFailure: (cause) => failed({
         sessionID: input.session.id,
         reason: "manual",
-        error: toSessionError(cause),
+        error: toSessionError2(cause),
         inputID: input.inputID
       }),
       onSuccess: (context) => execute({
@@ -420,7 +479,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       })
     }));
   });
-  return Service.of({
+  return Service10.of({
     transform: state.transform,
     reload: state.reload,
     enabled: () => state.get().auto,
@@ -429,10 +488,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     compactManual
   });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_bus.node, llmClient]
+var node13 = makeLocationNode({
+  service: Service10,
+  layer: layer6,
+  deps: [node84, llmClient2]
 });
 
-export { Service, estimateTokens, truncateToolOutput, serializeToolContent, buildPrompt, layer, node, exports_compaction };
+export { Service10, estimateTokens2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer6, node13, exports_compaction2 };

package/dist/chunks/{shell-vwsdy5q1.js → event-logger-92avn38j.js}

@@ -1,33 +1,33 @@
 import {
-  exports_entry_observer
-} from "./shell-mnyszbxc.js";
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_wildcard
-} from "./shell-edxnhgvj.js";
+  match2
+} from "./event-logger-y1fvbwt7.js";
 import {
-  exports_config
-} from "./shell-r8f3g7x9.js";
+  observe2
+} from "./event-logger-qsdy395h.js";
 import {
   __export
-} from "./shell-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/policy.ts
 var exports_policy = {};
 __export(exports_policy, {
   ConfigPolicyPlugin: () => exports_policy,
-  Plugin: () => Plugin
+  Plugin: () => Plugin28
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin28 = define({
   id: "opencode.config.policy",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, ctx.catalog.reload());
+    const config = yield* Service48;
+    const loaded = yield* observe2(config, ctx.event, ctx.catalog.reload());
     yield* ctx.catalog.transform((catalog) => {
       const policies = loaded.entries.filter((entry) => entry.type === "document").toReversed().flatMap((entry) => entry.info.experimental?.policies ?? []);
       for (const record of catalog.provider.list()) {
-        const policy = policies.findLast((policy2) => exports_wildcard.match(record.provider.id, policy2.resource));
+        const policy = policies.findLast((policy) => match2(record.provider.id, policy.resource));
         if (policy?.effect === "deny")
           catalog.provider.remove(record.provider.id);
       }
@@ -35,4 +35,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_policy };
+export { Plugin28, exports_policy };

package/dist/chunks/event-logger-92g85qkt.js

@@ -0,0 +1,115 @@
+import {
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
+import {
+  Key4,
+  removed2,
+  make20,
+  combine2
+} from "./event-logger-1z80kc63.js";
+import {
+  InstructionEntryTable2
+} from "./event-logger-hrvm11jt.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/session/instruction-entry.ts
+var exports_instruction_entry = {};
+__export(exports_instruction_entry, {
+  Info: () => Info5,
+  InstructionEntry: () => exports_instruction_entry,
+  Key: () => Key2,
+  MaxValueBytes: () => MaxValueBytes2,
+  Service: () => Service26,
+  Snapshot: () => Snapshot2,
+  ValueTooLargeError: () => ValueTooLargeError2,
+  initialize: () => initialize2,
+  node: () => node31,
+  snapshot: () => snapshot2
+});
+import { and, asc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { InstructionEntry } from "@opencode-ai/schema/instruction-entry";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var Key2 = InstructionEntry.Key;
+var Info5 = InstructionEntry.Info;
+var Snapshot2 = InstructionEntry.Snapshot;
+var MaxValueBytes2 = InstructionEntry.MaxValueBytes;
+var ValueTooLargeError2 = InstructionEntry.ValueTooLargeError;
+var InsertBatchSize = 10;
+var snapshot2 = Effect.fn("InstructionEntry.snapshot")(function* (db, sessionID) {
+  return yield* db.select({
+    key: InstructionEntryTable2.key,
+    value: InstructionEntryTable2.value,
+    removed: InstructionEntryTable2.removed
+  }).from(InstructionEntryTable2).where(eq(InstructionEntryTable2.session_id, sessionID)).orderBy(asc(InstructionEntryTable2.key)).all().pipe(Effect.orDie);
+});
+var initialize2 = Effect.fn("InstructionEntry.initialize")(function* (db, sessionID, entries, created) {
+  const batches = Array.from({ length: Math.ceil(entries.length / InsertBatchSize) }, (_, index) => entries.slice(index * InsertBatchSize, (index + 1) * InsertBatchSize));
+  yield* Effect.forEach(batches, (batch) => db.insert(InstructionEntryTable2).values(batch.map((entry) => ({
+    ...entry,
+    session_id: sessionID,
+    time_created: created,
+    time_updated: created
+  }))).run().pipe(Effect.orDie), { discard: true });
+});
+
+class Service26 extends Context.Service()("@opencode/InstructionEntry") {
+}
+var renderValue = (value) => typeof value === "string" ? value : JSON.stringify(value, null, 2);
+var renderBlock = (key, value) => [`<context key="${key}">`, renderValue(value), "</context>"].join(`
+`);
+var source = (entry) => make20({
+  key: Key4.make(`api/${entry.key}`),
+  codec: Schema.toCodecJson(Schema.Json),
+  read: Effect.succeed(entry.removed ? removed2 : entry.value),
+  render: {
+    initial: (value) => renderBlock(entry.key, value),
+    changed: (_previous, value) => [
+      `The context under "${entry.key}" changed and supersedes the previous value:`,
+      renderBlock(entry.key, value)
+    ].join(`
+`),
+    removed: () => `The context under "${entry.key}" no longer applies. Disregard it.`
+  }
+});
+var layer = Layer.effect(Service26, Effect.gen(function* () {
+  const { db } = yield* Service80;
+  const rows = Effect.fnUntraced(function* (sessionID, includeRemoved) {
+    return yield* db.select({
+      key: InstructionEntryTable2.key,
+      value: InstructionEntryTable2.value,
+      removed: InstructionEntryTable2.removed
+    }).from(InstructionEntryTable2).where(and(eq(InstructionEntryTable2.session_id, sessionID), includeRemoved ? undefined : eq(InstructionEntryTable2.removed, false))).orderBy(asc(InstructionEntryTable2.key)).all().pipe(Effect.orDie);
+  });
+  const list = Effect.fn("InstructionEntry.list")(function* (sessionID) {
+    return (yield* rows(sessionID, false)).map((row) => ({ key: row.key, value: row.value }));
+  });
+  const put = Effect.fn("InstructionEntry.put")(function* (input) {
+    const actualBytes = Buffer.byteLength(JSON.stringify(input.value), "utf8");
+    if (actualBytes > MaxValueBytes2)
+      yield* new ValueTooLargeError2({
+        actualBytes,
+        maxBytes: MaxValueBytes2,
+        message: `Instruction entry value is ${actualBytes} bytes; the limit is ${MaxValueBytes2} bytes`
+      });
+    const changed = input.value === null ? isNotNull(InstructionEntryTable2.value) : or(isNull(InstructionEntryTable2.value), ne(InstructionEntryTable2.value, input.value));
+    yield* db.insert(InstructionEntryTable2).values({ session_id: input.sessionID, key: input.key, value: input.value, removed: false }).onConflictDoUpdate({
+      target: [InstructionEntryTable2.session_id, InstructionEntryTable2.key],
+      set: { value: input.value, removed: false, time_updated: Date.now() },
+      setWhere: or(eq(InstructionEntryTable2.removed, true), changed)
+    }).run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("InstructionEntry.remove")(function* (input) {
+    yield* db.update(InstructionEntryTable2).set({ value: null, removed: true, time_updated: Date.now() }).where(and(eq(InstructionEntryTable2.session_id, input.sessionID), eq(InstructionEntryTable2.key, input.key), eq(InstructionEntryTable2.removed, false))).run().pipe(Effect.orDie);
+  });
+  const load = Effect.fn("InstructionEntry.load")(function* (sessionID) {
+    return combine2((yield* rows(sessionID, true)).map(source));
+  });
+  return Service26.of({ list, put, remove, load });
+}));
+var node31 = makeLocationNode({ service: Service26, layer, deps: [node85] });
+
+export { Key2, Info5, Snapshot2, MaxValueBytes2, ValueTooLargeError2, snapshot2, initialize2, Service26, node31, exports_instruction_entry };

package/dist/chunks/event-logger-93a8yfjt.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  WorktreeDirectory: () => exports_directory,
+  canonical: () => canonical2
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError2 extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath2 }) {
+}
+var canonical2 = Effect.fnUntraced(function* (fs, input) {
+  const resolved = AbsolutePath2.make(yield* fs.resolve(input));
+  if (!(yield* fs.isDir(resolved)))
+    return yield* new DirectoryUnavailableError2({ directory: input });
+  return resolved;
+});
+
+export { DirectoryUnavailableError2, canonical2, exports_directory };

package/dist/chunks/event-logger-982e01ww.js

@@ -0,0 +1,6 @@
+// src/session/message.ts
+import * as SessionMessage2 from "@opencode-ai/schema/session-message";
+
+export * from "@opencode-ai/schema/session-message";
+
+export { SessionMessage2 };