@opencode-ai/core 0.0.0-beta-18999 → 0.0.0-beta-19086

package/dist/chunks/{model-resolver-r9d3d23r.js → schema-r9d3d23r.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./model-resolver-k3e42drn.js";
+} from "./schema-k3e42drn.js";
 
 // src/formatter/builtins.ts
 import { Effect } from "effect";

package/dist/chunks/{model-resolver-mvw9jqgs.js → schema-r9srg7kj.js}

@@ -1,39 +1,39 @@
 import {
   exports_runner
-} from "./model-resolver-0rz7yd7x.js";
-import {
-  toSessionError
-} from "./model-resolver-18medfkf.js";
+} from "./schema-0rz7yd7x.js";
 import {
   exports_run_coordinator
-} from "./model-resolver-f8wvq04h.js";
+} from "./schema-f8wvq04h.js";
 import {
   exports_inbox
-} from "./model-resolver-rmrmrh60.js";
+} from "./schema-3rcd4hwd.js";
+import {
+  toSessionError
+} from "./schema-d6pj50wp.js";
 import {
   exports_service
-} from "./model-resolver-6bxzghb6.js";
+} from "./schema-6bxzghb6.js";
+import {
+  exports_job
+} from "./schema-dt5yw4ma.js";
 import {
   exports_store
-} from "./model-resolver-wz5907jr.js";
+} from "./schema-a4wk7wxx.js";
 import {
   UserInterruptedError
-} from "./model-resolver-2sqw2jjm.js";
+} from "./schema-2sqw2jjm.js";
 import {
   SessionEvent
-} from "./model-resolver-a83yvq99.js";
-import {
-  exports_job
-} from "./model-resolver-hwtjfpwk.js";
+} from "./schema-a83yvq99.js";
 import {
   exports_bus
-} from "./model-resolver-b2mj9w79.js";
+} from "./schema-fjb24bmd.js";
 import {
   exports_database
-} from "./model-resolver-tn3vtv4h.js";
+} from "./schema-8scqw7rh.js";
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/session/execution.ts
 var exports_execution = {};

package/dist/chunks/{model-resolver-d88sh0qh.js → schema-ra2q36zd.js}

@@ -1,15 +1,15 @@
 import {
   exports_skill
-} from "./model-resolver-xghrvkpy.js";
+} from "./schema-tbzs2pmr.js";
 import {
   exports_config
-} from "./model-resolver-yt21b5ce.js";
+} from "./schema-jq0ga1pd.js";
 import {
   AbsolutePath
-} from "./model-resolver-j07kk359.js";
+} from "./schema-j07kk359.js";
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/plugin/skill.ts
 var exports_skill2 = {};

package/dist/chunks/{model-resolver-rahat93a.js → schema-rahat93a.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./model-resolver-k3e42drn.js";
+} from "./schema-k3e42drn.js";
 
 // src/ripgrep/binary.ts
 import path from "path";

package/dist/chunks/{model-resolver-cs1jwk5c.js → schema-rfxr8z2j.js}

@@ -1,22 +1,22 @@
 import {
   exports_host
-} from "./model-resolver-67ndm1z2.js";
+} from "./schema-1escsep2.js";
 import {
   Service,
   awaitActivation
-} from "./model-resolver-esv5q40e.js";
+} from "./schema-esv5q40e.js";
 import {
   exports_kv
-} from "./model-resolver-c8n0v0wx.js";
-import {
-  exports_bus
-} from "./model-resolver-b2mj9w79.js";
+} from "./schema-y2b04s9v.js";
 import {
   exports_state
-} from "./model-resolver-dyrfpcd0.js";
+} from "./schema-j6s3yjyb.js";
+import {
+  exports_bus
+} from "./schema-fjb24bmd.js";
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/plugin.ts
 var exports_plugin = {};
@@ -34,7 +34,7 @@ __export(exports_plugin, {
 import { Event, ID, Info, Source, State } from "@opencode-ai/schema/plugin";
 import { Plugin } from "@opencode-ai/schema/plugin";
 import { Node } from "@opencode-ai/util/effect/app-node";
-import { Cause, Context, Effect, Exit, Latch, Layer, Logger, References, Scope, Semaphore } from "effect";
+import { Cause, Context, Effect, Exit, Latch, Layer, Logger, Queue, References, Scope, Semaphore } from "effect";
 var layer = Layer.effect(Service, Effect.gen(function* () {
   const bus = yield* exports_bus.Service;
   const kv = yield* exports_kv.Service;
@@ -43,7 +43,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const lock = Semaphore.makeUnsafe(1);
   const ready = yield* Latch.make(true);
   const pending = new Set;
-  const hold = () => Effect.sync(() => {
+  let closed = false;
+  const holdUnsafe = () => {
+    if (closed)
+      return Effect.void;
     const token = {};
     pending.add(token);
     ready.closeUnsafe();
@@ -51,23 +54,40 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       if (pending.delete(token) && pending.size === 0)
         ready.openUnsafe();
     });
-  });
+  };
+  const hold = () => Effect.sync(holdUnsafe);
+  const pendingFailures = yield* Queue.unbounded();
+  let discovered = [];
   let inventory = [];
   const list = Effect.fn("Plugin.list")(function* () {
     return inventory;
   });
   const host = yield* exports_host.make({ list });
   const load = Effect.fnUntraced(function* (plugin) {
-    const child = yield* Scope.fork(scope);
+    const activation = { plugin, scope: yield* Scope.fork(scope) };
     const inherit = yield* exports_state.inherit();
-    const loaded = yield* Effect.suspend(() => plugin.effect({ ...host, storage: exports_host.storage(kv, plugin.id) })).pipe(inherit, Effect.updateContext((context) => Context.make(Scope.Scope, child).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void), Effect.exit);
-    if (Exit.isSuccess(loaded))
-      return { scope: child };
+    const grouped = exports_state.group((failure, refresh) => {
+      activation.failure = {
+        error: `Plugin disabled after ${failure.state}.transform failed. Check server logs for details.`,
+        ref: `err_${crypto.randomUUID().slice(0, 8)}`
+      };
+      Queue.offerUnsafe(pendingFailures, {
+        plugin,
+        scope: activation.scope,
+        failure,
+        refresh,
+        ref: activation.failure.ref,
+        release: holdUnsafe()
+      });
+    });
+    const exit = yield* Effect.suspend(() => plugin.effect({ ...host, storage: exports_host.storage(kv, plugin.id) })).pipe(grouped, inherit, Effect.updateContext((context) => Context.make(Scope.Scope, activation.scope).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.onExit((exit2) => Exit.isFailure(exit2) && !activation.failure ? Scope.close(activation.scope, exit2) : Effect.void), Effect.exit);
+    if (activation.failure || Exit.isSuccess(exit))
+      return { activation };
     yield* Effect.logWarning("failed to load plugin", {
       "plugin.id": plugin.id,
-      cause: loaded.cause
+      cause: exit.cause
     });
-    return { error: Cause.pretty(loaded.cause) };
+    return { error: Cause.pretty(exit.cause) };
   });
   const activate = Effect.fn("Plugin.activate")(function* (plugins, failures = []) {
     const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }));
@@ -78,6 +98,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       ids.add(definition.id);
     }
     yield* Effect.acquireUseRelease(hold(), () => lock.withPermit(Effect.gen(function* () {
+      if (closed)
+        return;
+      discovered = failures;
       const current = Array.from(active.values());
       const changed = definitions.findIndex((definition, index) => {
         const entry = current[index];
@@ -101,28 +124,33 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         const previous = new Map(Array.from(active.entries()).slice(prefix));
         yield* Effect.forEach(Array.from(previous.entries()).toReversed(), ([id, slot]) => Effect.gen(function* () {
           active.delete(id);
-          if (slot.loaded)
-            yield* Scope.close(slot.loaded.scope, Exit.void);
+          if (slot.activation && !slot.activation.failure)
+            yield* Scope.close(slot.activation.scope, Exit.void);
         }), { discard: true });
         for (const definition of definitions.slice(prefix)) {
-          const loaded = yield* load(definition);
-          if (loaded.scope !== undefined) {
+          const slot = previous.get(definition.id);
+          if (slot?.activation?.failure && slot.plugin.revision === definition.revision) {
+            active.set(definition.id, { ...slot, plugin: definition });
+            continue;
+          }
+          const result = yield* load(definition);
+          if (result.activation !== undefined) {
             active.set(definition.id, {
               plugin: definition,
-              loaded: { plugin: definition, scope: loaded.scope }
+              activation: result.activation
             });
             continue;
           }
-          active.set(definition.id, { plugin: definition, error: loaded.error });
-          const fallback = previous.get(definition.id)?.loaded;
-          if (!fallback)
+          active.set(definition.id, { plugin: definition, error: result.error });
+          const fallback = slot?.activation;
+          if (!fallback || fallback.failure)
             continue;
           const restored = yield* load(fallback.plugin);
-          if (restored.scope !== undefined) {
+          if (restored.activation !== undefined) {
             active.set(definition.id, {
               plugin: definition,
-              loaded: { plugin: fallback.plugin, scope: restored.scope },
-              error: loaded.error
+              activation: restored.activation,
+              error: result.error
             });
             continue;
           }
@@ -135,7 +163,39 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       yield* bus.publish(Plugin.Event.Updated, {});
     })), (release) => release);
   });
+  yield* Queue.take(pendingFailures).pipe(Effect.flatMap((item) => Effect.gen(function* () {
+    yield* Effect.logWarning("disabled plugin after transform failure", {
+      "plugin.id": item.plugin.id,
+      state: item.failure.state,
+      ref: item.ref,
+      cause: Cause.die(item.failure.cause)
+    });
+    yield* lock.withPermit(Effect.gen(function* () {
+      if (closed)
+        return;
+      inventory = [...Array.from(active.values()).map(slotInfo), ...discovered];
+      const refreshed = yield* exports_state.batch(item.refresh).pipe(Effect.exit);
+      yield* bus.publish(Plugin.Event.Updated, {});
+      if (Exit.isFailure(refreshed))
+        yield* Effect.logWarning("failed to refresh state after disabling plugin", {
+          "plugin.id": item.plugin.id,
+          ref: item.ref,
+          cause: refreshed.cause
+        });
+    }));
+  }).pipe(Effect.ensuring(Scope.close(item.scope, Exit.void).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to clean up disabled plugin", {
+    "plugin.id": item.plugin.id,
+    ref: item.ref,
+    cause
+  })), Effect.forkScoped({ startImmediately: true }))), Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("failed to report disabled plugin", {
+    "plugin.id": item.plugin.id,
+    ref: item.ref,
+    cause
+  })), Effect.ensuring(item.release))), Effect.forever, Effect.forkScoped);
   const close = (exit) => lock.withPermit(Effect.gen(function* () {
+    closed = true;
+    pending.clear();
+    ready.openUnsafe();
     active.clear();
     yield* exports_state.shutdown(Scope.close(scope, exit));
   }));
@@ -149,10 +209,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
 }));
 function slotInfo(slot) {
+  const failure = slot.activation?.failure ?? (slot.error === undefined ? undefined : { error: slot.error });
   return {
     id: Plugin.ID.make(slot.plugin.id),
     source: slot.plugin.source ?? { type: "builtin" },
-    state: slot.error === undefined ? { status: "active" } : { status: "failed", error: slot.error },
+    state: failure === undefined ? { status: "active" } : { status: "failed", ...failure },
     features: { server: true, ...slot.plugin.features }
   };
 }

package/dist/chunks/{model-resolver-eh2wdxrj.js → schema-rgnjkg8c.js}

@@ -1,33 +1,36 @@
 import {
-  exports_token
-} from "./model-resolver-z8c1ty6e.js";
+  exports_retry
+} from "./schema-aseryw3y.js";
 import {
   exports_usage
-} from "./model-resolver-nn16cgj7.js";
+} from "./schema-nn16cgj7.js";
+import {
+  exports_token
+} from "./schema-z8c1ty6e.js";
 import {
   toSessionError
-} from "./model-resolver-18medfkf.js";
+} from "./schema-d6pj50wp.js";
 import {
   exports_model_request
-} from "./model-resolver-ryxrw20d.js";
+} from "./schema-yp4wxmaw.js";
 import {
   toLLMMessages
-} from "./model-resolver-g23fad86.js";
-import {
-  SessionEvent
-} from "./model-resolver-a83yvq99.js";
+} from "./schema-g23fad86.js";
 import {
   llmClient
-} from "./model-resolver-326j4s6w.js";
+} from "./schema-326j4s6w.js";
 import {
-  exports_bus
-} from "./model-resolver-b2mj9w79.js";
+  SessionEvent
+} from "./schema-a83yvq99.js";
 import {
   exports_state
-} from "./model-resolver-dyrfpcd0.js";
+} from "./schema-j6s3yjyb.js";
+import {
+  exports_bus
+} from "./schema-fjb24bmd.js";
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/session/compaction.ts
 var exports_compaction = {};
@@ -41,7 +44,16 @@ __export(exports_compaction, {
   serializeToolContent: () => serializeToolContent,
   truncateToolOutput: () => truncateToolOutput
 });
-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 +76,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)"]
@@ -287,6 +299,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const chunks = [];
     let failure;
     let usage;
+    let providerState;
     const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent.UsageRecorded, {
       sessionID: context.session.id,
       source: "compaction",
@@ -300,6 +313,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"),
@@ -316,14 +330,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         ]
       }
     });
-    for (let attempt = 0;attempt < 2; attempt++) {
-      chunks.length = 0;
-      yield* llm.stream(attempt === 0 ? prepared.request : LLMRequest.update(prepared.request, {
+    const retry = yield* exports_retry.policy(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",
@@ -337,10 +359,46 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           });
         }
         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;
         }
+        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: toSessionError(cause),
+            agent: Agent.ID.make("compaction"),
+            model: context.model.ref,
+            hook: prepared.retry,
+            retry: exports_retry.isRetryable(cause)
+          });
+          if (!decision.retry)
+            return false;
+          yield* Effect.sleep(decision.delay);
+          return true;
+        })
       }), Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
         failure = toSessionError(error);
       })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(input.reason === "auto" ? failed({
@@ -369,6 +427,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     yield* bus.publish(SessionEvent.Compaction.Ended, {
       sessionID: context.session.id,
       reason: input.reason,
+      model: context.model.ref,
+      providerState,
       text: summary,
       recent: history.recent
     });

package/dist/chunks/{model-resolver-jr5m26np.js → schema-rpa95wsa.js}

@@ -1,9 +1,9 @@
 import {
   webSocketConstructor
-} from "./model-resolver-326j4s6w.js";
+} from "./schema-326j4s6w.js";
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/session/model-transport.ts
 var exports_model_transport = {};
@@ -80,7 +80,7 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
         operation: "read",
         code: "close",
         phase: "close",
-        delivery: channel.active.lifecycle.delivery === "queued" || channel.active.lifecycle.delivery === "connecting" || channel.active.lifecycle.delivery === "ready" ? "not-sent" : channel.active.lifecycle.delivery === "provider-observed" || channel.active.lifecycle.delivery === "terminal" ? "accepted" : "ambiguous"
+        delivery: channel.active.delivery === "provider-observed" || channel.active.delivery === "terminal" ? "accepted" : "ambiguous"
       })));
     yield* metric("close");
   });
@@ -123,7 +123,7 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
             code: "idle-data",
             phase: "receive"
           });
-        active.lifecycle.delivery = "provider-observed";
+        active.delivery = "provider-observed";
         if (typeof message !== "string")
           return yield* transportError("Unsupported binary WebSocket frame", {
             url: exchange.connect.url,
@@ -142,7 +142,7 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
         });
       })), Effect.catch((error) => channel.closing ? Effect.void : poison(owner, channel, annotate(error, {
         phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
-        delivery: channel.active?.lifecycle.delivery === "provider-observed" || channel.active?.lifecycle.delivery === "terminal" || error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "accepted" : error.reason._tag === "Transport" && error.reason.code === "1009" ? "rejected" : "ambiguous"
+        delivery: channel.active?.delivery === "provider-observed" || channel.active?.delivery === "terminal" || error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "accepted" : error.reason._tag === "Transport" && error.reason.code === "1009" ? "rejected" : "ambiguous"
       }))), Effect.forkIn(scope, { startImmediately: true }));
       yield* Effect.logDebug("session websocket connected", {
         sessionTransport: "websocket",
@@ -156,7 +156,7 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
     frames: exchange.fallback(),
     complete: Effect.void
   });
-  const start = Effect.fn("SessionModelTransport.start")(function* (owner, exchange, lifecycle) {
+  const start = Effect.fn("SessionModelTransport.start")(function* (owner, exchange) {
     if (owner.closed)
       return yield* transportError("Session WebSocket owner is closed", {
         operation: "request",
@@ -181,7 +181,6 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
       yield* metric("reconnect");
       yield* closeChannel(owner, current);
     }
-    lifecycle.delivery = owner.channel ? "ready" : "connecting";
     if (owner.channel)
       yield* Effect.logDebug("session websocket reused", {
         sessionTransport: "websocket",
@@ -197,7 +196,6 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
     }).pipe(Effect.andThen(metric("connect_failure")), Effect.andThen(metric("fallback")), Effect.as(undefined))));
     if (!channel)
       return fallback(exchange);
-    lifecycle.delivery = "ready";
     if (channel.pending) {
       channel.pending = undefined;
       channel.checkpoint = undefined;
@@ -205,9 +203,11 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
     const create = yield* exchange.driver.create(channel.checkpoint).pipe(Effect.tapError(() => closeChannel(owner, channel)), Effect.onInterrupt(() => closeChannel(owner, channel)));
     if (create.mode === "full")
       channel.checkpoint = undefined;
-    const active = { queue: yield* Queue.bounded(INBOUND_CAPACITY), lifecycle };
+    const active = {
+      queue: yield* Queue.bounded(INBOUND_CAPACITY),
+      delivery: "send-attempted"
+    };
     channel.active = active;
-    lifecycle.delivery = "send-attempted";
     const sent = yield* channel.connection.sendText(create.message).pipe(Effect.withSpan("SessionModelTransport.send"), Effect.onInterrupt(() => closeChannel(owner, channel)), Effect.result);
     if (sent._tag === "Failure") {
       const failure = new AIError({
@@ -237,13 +237,13 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
         operation: "read",
         code: "idle-timeout",
         phase: "receive",
-        delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous"
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
       }))
     }), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.tap((observation) => Effect.sync(() => {
       if (!observationTerminal(observation))
         return;
       terminal = observation;
-      lifecycle.delivery = "terminal";
+      active.delivery = "terminal";
       const staged = observation.type === "completed" ? observation.checkpoint : undefined;
       if (staged)
         channel.pending = { token, checkpoint: staged };
@@ -276,7 +276,7 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
         operation: "read",
         code: "incomplete",
         phase: "receive",
-        delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous"
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
       });
       yield* poison(owner, channel, error);
     })), Stream.catch((error) => {
@@ -301,13 +301,12 @@ var makeLayer = (connector) => Layer.effect(Service, Effect.gen(function* () {
   const bind = (sessionID) => ({
     execute: (exchange) => {
       const owner = state(sessionID);
-      const lifecycle = { delivery: "queued" };
       let execution;
       return Effect.succeed({
         get http() {
           return execution?.http;
         },
-        frames: Stream.unwrap(Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(Effect.andThen(start(owner, exchange, lifecycle)), Effect.tap((started) => Effect.sync(() => {
+        frames: Stream.unwrap(Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(Effect.andThen(start(owner, exchange)), Effect.tap((started) => Effect.sync(() => {
           execution = started;
         })), Effect.map((started) => started.frames))),
         complete: Effect.suspend(() => execution?.complete ?? Effect.void)

package/dist/chunks/{model-resolver-rr7wbarq.js → schema-rr7wbarq.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./model-resolver-vpjkya7h.js";
+} from "./schema-vpjkya7h.js";
 
 // src/codemode/catalog.ts
 var exports_catalog = {};