@relayfx/sdk 0.5.0 → 0.6.1

package/dist/{index-x32kbvxv.js → index-5vjhqzbk.js}

@@ -3,13 +3,12 @@ import {
   __export
 } from "./index-nb39b5ae.js";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/turn-policy.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/turn-policy.js
 var exports_turn_policy = {};
 __export(exports_turn_policy, {
   untilToolCall: () => untilToolCall,
   recurs: () => recurs,
   make: () => make,
-  fromLegacy: () => fromLegacy,
   forever: () => forever,
   defaultPolicy: () => defaultPolicy,
   decision: () => decision,
@@ -40,7 +39,6 @@ var decision = {
   stop: (reason) => ({ _tag: "Stop", reason })
 };
 var make = (decide) => ({ decide });
-var fromLegacy = (decide) => make((info) => decide(info).pipe(Effect.map((result) => result._tag === "Stop" ? decision.stop({ _tag: "Policy", detail: "Legacy policy stopped" }) : result)));
 var forever = {
   decide: () => Effect.succeed(decision.continue()),
   snapshot: { _tag: "Forever" }
@@ -74,7 +72,7 @@ var both = dual(2, (first, second) => ({
 }));
 var defaultPolicy = forever;
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-event.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-event.js
 var exports_agent_event = {};
 __export(exports_agent_event, {
   addUsage: () => addUsage,
@@ -83,14 +81,88 @@ __export(exports_agent_event, {
   ToolOrigin: () => ToolOrigin,
   ToolNameCollision: () => ToolNameCollision,
   ResumeMismatch: () => ResumeMismatch,
-  ProgressOverflowError: () => ProgressOverflowError,
+  ProgressOverflow: () => ProgressOverflow,
   MiddlewareViolation: () => MiddlewareViolation,
   DuplicateToolCallId: () => DuplicateToolCallId,
   AgentSuspended: () => AgentSuspended,
   AgentError: () => AgentError
 });
-import { Function, Schema as Schema2 } from "effect";
-import { Prompt as Prompt2, Response as Response2, Tool } from "effect/unstable/ai";
+import { Function, Schema as Schema3 } from "effect";
+import { Prompt as Prompt3, Response as Response2, Tool } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/session-sync.js
+import { Schema as Schema2 } from "effect";
+import { Prompt as Prompt2 } from "effect/unstable/ai";
+var Divergence = Schema2.Struct({
+  index: Schema2.Finite,
+  durableRole: Schema2.optionalKey(Schema2.String),
+  authoritativeRole: Schema2.optionalKey(Schema2.String),
+  durablePartTypes: Schema2.Array(Schema2.String),
+  authoritativePartTypes: Schema2.Array(Schema2.String),
+  durableDigest: Schema2.optionalKey(Schema2.String),
+  authoritativeDigest: Schema2.optionalKey(Schema2.String)
+});
+var Diagnostics = Schema2.Struct({
+  sessionId: Schema2.String,
+  ownerToken: Schema2.optionalKey(Schema2.String),
+  durableEntryCount: Schema2.Finite,
+  durableMessageCount: Schema2.Finite,
+  authoritativeMessageCount: Schema2.Finite,
+  alignmentCount: Schema2.Finite,
+  commonPrefixLength: Schema2.Finite,
+  lastDurableEntryTag: Schema2.optionalKey(Schema2.String),
+  firstDivergence: Schema2.optionalKey(Divergence)
+});
+var digest = (value) => {
+  let hash = 2166136261;
+  for (let index = 0;index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+};
+var partTypes = (message) => typeof message.content === "string" ? ["text"] : message.content.map((part) => part.type);
+var messageDigest = (message) => digest(JSON.stringify(message));
+var diagnose = (input) => {
+  const equals = Schema2.toEquivalence(Prompt2.Message);
+  let alignmentCount = 0;
+  if (input.projection.length === 0)
+    alignmentCount = 1;
+  else
+    for (let start = 0;start <= input.transcript.length - input.projection.length; start += 1) {
+      if (input.transcript.slice(0, start).every((message) => message.role === "system") && input.projection.every((message, index) => equals(message, input.transcript[start + index])))
+        alignmentCount += 1;
+    }
+  let commonPrefixLength = 0;
+  while (commonPrefixLength < input.projection.length && commonPrefixLength < input.transcript.length && equals(input.projection[commonPrefixLength], input.transcript[commonPrefixLength]))
+    commonPrefixLength += 1;
+  const durable = input.projection[commonPrefixLength];
+  const authoritative = input.transcript[commonPrefixLength];
+  const lastDurableEntryTag = input.durableEntryTags.at(-1);
+  return {
+    sessionId: input.sessionId,
+    ...input.ownerToken === undefined ? {} : { ownerToken: input.ownerToken },
+    durableEntryCount: input.durableEntryTags.length,
+    durableMessageCount: input.projection.length,
+    authoritativeMessageCount: input.transcript.length,
+    alignmentCount,
+    commonPrefixLength,
+    ...lastDurableEntryTag === undefined ? {} : { lastDurableEntryTag },
+    ...durable === undefined && authoritative === undefined ? {} : {
+      firstDivergence: {
+        index: commonPrefixLength,
+        ...durable === undefined ? {} : { durableRole: durable.role },
+        ...authoritative === undefined ? {} : { authoritativeRole: authoritative.role },
+        durablePartTypes: durable === undefined ? [] : partTypes(durable),
+        authoritativePartTypes: authoritative === undefined ? [] : partTypes(authoritative),
+        ...durable === undefined ? {} : { durableDigest: messageDigest(durable) },
+        ...authoritative === undefined ? {} : { authoritativeDigest: messageDigest(authoritative) }
+      }
+    }
+  };
+};
+
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-event.js
 var addUsageField = (left, right) => left === undefined && right === undefined ? undefined : (left ?? 0) + (right ?? 0);
 var addUsage = Function.dual(2, (left, right) => Response2.Usage.make({
   inputTokens: {
@@ -106,112 +178,111 @@ var addUsage = Function.dual(2, (left, right) => Response2.Usage.make({
   }
 }));
 
-class AgentError extends Schema2.TaggedErrorClass()("@batonfx/core/AgentError", {
-  message: Schema2.String,
-  turn: Schema2.Finite,
-  cause: Schema2.optionalKey(Schema2.Defect())
+class AgentError extends Schema3.TaggedErrorClass()("@batonfx/core/AgentError", {
+  message: Schema3.String,
+  turn: Schema3.Finite,
+  cause: Schema3.optionalKey(Schema3.Defect()),
+  diagnostics: Schema3.optionalKey(Diagnostics)
 }) {
 }
 
-class TurnLimitExceeded extends Schema2.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
-  turn: Schema2.Finite,
-  limit: Schema2.Finite,
-  pending: Schema2.Array(Schema2.Struct({
-    tool_call_id: Schema2.String,
-    tool_name: Schema2.String
+class TurnLimitExceeded extends Schema3.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
+  turn: Schema3.Finite,
+  limit: Schema3.Finite,
+  pending: Schema3.Array(Schema3.Struct({
+    tool_call_id: Schema3.String,
+    tool_name: Schema3.String
   }))
 }) {
 }
 
-class TurnPolicyStopped extends Schema2.TaggedErrorClass()("@batonfx/core/TurnPolicyStopped", {
-  turn: Schema2.Finite,
+class TurnPolicyStopped extends Schema3.TaggedErrorClass()("@batonfx/core/TurnPolicyStopped", {
+  turn: Schema3.Finite,
   reason: StopReason,
-  pending: Schema2.Array(Schema2.Struct({
-    tool_call_id: Schema2.String,
-    tool_name: Schema2.String
+  pending: Schema3.Array(Schema3.Struct({
+    tool_call_id: Schema3.String,
+    tool_name: Schema3.String
   }))
 }) {
 }
 
-class MiddlewareViolation extends Schema2.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
-  turn: Schema2.Finite,
-  detail: Schema2.String
+class MiddlewareViolation extends Schema3.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
+  turn: Schema3.Finite,
+  detail: Schema3.String
 }) {
 }
 
-class DuplicateToolCallId extends Schema2.TaggedErrorClass()("@batonfx/core/DuplicateToolCallId", {
-  id: Schema2.String,
-  firstIndex: Schema2.Finite,
-  duplicateIndex: Schema2.Finite
+class DuplicateToolCallId extends Schema3.TaggedErrorClass()("@batonfx/core/DuplicateToolCallId", {
+  id: Schema3.String,
+  firstIndex: Schema3.Finite,
+  duplicateIndex: Schema3.Finite
 }) {
 }
 
-class ProgressOverflowError extends Schema2.TaggedErrorClass()("@batonfx/core/ProgressOverflowError", {
-  turn: Schema2.Finite,
-  toolCallId: Schema2.String,
-  capacity: Schema2.Finite
+class ProgressOverflow extends Schema3.TaggedErrorClass()("@batonfx/core/ProgressOverflow", {
+  turn: Schema3.Finite,
+  toolCallId: Schema3.String,
+  capacity: Schema3.Finite
 }) {
 }
-var ToolOrigin = Schema2.Union([
-  Schema2.TaggedStruct("Static", { agent: Schema2.String }),
-  Schema2.TaggedStruct("Builtin", { builtin: Schema2.Literal("activate_skill") }),
-  Schema2.TaggedStruct("Skill", { skill: Schema2.String }),
-  Schema2.TaggedStruct("Handoff", { specialist: Schema2.String })
+var ToolOrigin = Schema3.Union([
+  Schema3.TaggedStruct("Static", { agent: Schema3.String }),
+  Schema3.TaggedStruct("Builtin", { builtin: Schema3.Literal("activate_skill") }),
+  Schema3.TaggedStruct("Skill", { skill: Schema3.String }),
+  Schema3.TaggedStruct("Handoff", { specialist: Schema3.String })
 ]);
 
-class ToolNameCollision extends Schema2.TaggedErrorClass()("@batonfx/core/ToolNameCollision", {
-  name: Schema2.String,
-  origins: Schema2.NonEmptyArray(ToolOrigin)
+class ToolNameCollision extends Schema3.TaggedErrorClass()("@batonfx/core/ToolNameCollision", {
+  name: Schema3.String,
+  origins: Schema3.NonEmptyArray(ToolOrigin)
 }) {
 }
 
-class AgentSuspended extends Schema2.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
-  token: Schema2.String,
-  reason: Schema2.Literals(["tool-wait", "approval"]),
-  authorization_stage: Schema2.optional(Schema2.Literals(["permission", "approval"])),
-  tool_call_index: Schema2.optional(Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0))),
-  tool_call_id: Schema2.String,
-  tool_name: Schema2.String,
-  tool_params: Schema2.Unknown,
-  tool_call_batch: Schema2.Array(Schema2.Struct({
-    type: Schema2.Literal("tool-call"),
-    id: Schema2.String,
-    name: Schema2.String,
-    params: Schema2.Unknown,
-    providerExecuted: Schema2.Boolean,
+class AgentSuspended extends Schema3.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
+  token: Schema3.String,
+  reason: Schema3.Literals(["tool-wait", "approval"]),
+  tool_call_index: Schema3.optional(Schema3.Int.check(Schema3.isGreaterThanOrEqualTo(0))),
+  tool_call_id: Schema3.String,
+  tool_name: Schema3.String,
+  tool_params: Schema3.Unknown,
+  tool_call_batch: Schema3.Array(Schema3.Struct({
+    type: Schema3.Literal("tool-call"),
+    id: Schema3.String,
+    name: Schema3.String,
+    params: Schema3.Unknown,
+    providerExecuted: Schema3.Boolean,
     metadata: Response2.ProviderMetadata
   })),
-  active_tools: Schema2.optional(Schema2.Array(Schema2.String)),
-  activated_skills: Schema2.optional(Schema2.Array(Schema2.String))
+  active_tools: Schema3.optional(Schema3.Array(Schema3.String)),
+  activated_skills: Schema3.optional(Schema3.Array(Schema3.String))
 }) {
 }
 
-class ResumeMismatch extends Schema2.TaggedErrorClass()("@batonfx/core/ResumeMismatch", {
-  reason: Schema2.Literals(["checkpoint-not-found", "identity-mismatch"]),
-  expected: Schema2.optional(AgentSuspended),
+class ResumeMismatch extends Schema3.TaggedErrorClass()("@batonfx/core/ResumeMismatch", {
+  reason: Schema3.Literals(["checkpoint-not-found", "identity-mismatch"]),
+  expected: Schema3.optional(AgentSuspended),
   received: AgentSuspended
 }) {
 }
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/memory.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/memory.js
 var exports_memory = {};
 __export(exports_memory, {
-  testLayer: () => testLayer,
   replaceRecalledMessage: () => replaceRecalledMessage,
   recalledMessageIdentity: () => recalledMessageIdentity,
   projectTranscript: () => projectTranscript,
-  noopLayer: () => noopLayer,
   messageFromRecall: () => messageFromRecall,
   merge: () => merge,
+  layerTest: () => layerTest,
   layerNoop: () => layerNoop,
   itemFromPromptPart: () => itemFromPromptPart,
   isMessageFromRecall: () => isMessageFromRecall,
   MemoryError: () => MemoryError,
   Memory: () => Memory
 });
-import { Context, Effect as Effect2, Layer as Layer2, Option, Schema as Schema3 } from "effect";
+import { Context, Effect as Effect2, Layer as Layer2, Option, Schema as Schema4 } from "effect";
 import { dual as dual2 } from "effect/Function";
-import { Prompt as Prompt3 } from "effect/unstable/ai";
+import { Prompt as Prompt4 } from "effect/unstable/ai";
 var provenanceOption = "@batonfx/core/memory";
 var recallLineage = new WeakMap;
 var itemFromPromptPart = Option.liftPredicate((part) => part.type === "text" || part.type === "file");
@@ -220,7 +291,7 @@ var isMessageFromRecall = (message) => {
   return typeof provenance === "object" && provenance !== null && !Array.isArray(provenance) && "origin" in provenance && provenance.origin === "memoryRecall";
 };
 var messageFromRecall = (content) => {
-  const message = Prompt3.makeMessage("user", {
+  const message = Prompt4.makeMessage("user", {
     content,
     options: { [provenanceOption]: { origin: "memoryRecall" } }
   });
@@ -229,7 +300,7 @@ var messageFromRecall = (content) => {
 };
 var replaceRecalledMessage = dual2(2, (message, content) => {
   const options = isMessageFromRecall(message) ? { ...message.options, [provenanceOption]: { origin: "memoryRecall" } } : { ...message.options };
-  const replacement = Prompt3.makeMessage("user", { content, options });
+  const replacement = Prompt4.makeMessage("user", { content, options });
   if (isMessageFromRecall(message))
     recallLineage.set(replacement, recallLineage.get(message) ?? message);
   return replacement;
@@ -237,15 +308,15 @@ var replaceRecalledMessage = dual2(2, (message, content) => {
 var recalledMessageIdentity = (message) => recallLineage.get(message) ?? message;
 var projectTranscript = (transcript) => {
   const content = transcript.content.filter((message) => !isMessageFromRecall(message));
-  return content.length === transcript.content.length ? transcript : Prompt3.fromMessages(content);
+  return content.length === transcript.content.length ? transcript : Prompt4.fromMessages(content);
 };
 
-class MemoryError extends Schema3.TaggedErrorClass()("@batonfx/core/MemoryError", {
-  message: Schema3.String
+class MemoryError extends Schema4.TaggedErrorClass()("@batonfx/core/MemoryError", {
+  message: Schema4.String
 }) {
 }
 
-class Memory extends Context.Service()("@batonfx/core/memory") {
+class Memory extends Context.Service()("@batonfx/core/Memory") {
 }
 var noop = {
   recall: () => Effect2.succeed([]),
@@ -258,29 +329,25 @@ var merge = dual2(2, (first, second) => ({
   forget: (input) => Effect2.all([first.forget(input), second.forget(input)], { discard: true })
 }));
 var layerNoop = Layer2.succeed(Memory, Memory.of(noop));
-var noopLayer = layerNoop;
-var testLayer = (implementation) => Layer2.succeed(Memory, Memory.of(implementation));
+var layerTest = (implementation) => Layer2.succeed(Memory, Memory.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-registry.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-registry.js
 var exports_model_registry = {};
 __export(exports_model_registry, {
-  testLayer: () => testLayer2,
   stream: () => stream,
   registrations: () => registrations,
-  registrationFromLayer: () => registrationFromLayer,
+  registration: () => registration,
   register: () => register,
-  provide: () => provide,
   operate: () => operate,
-  memoryLayer: () => memoryLayer,
+  layerTest: () => layerTest2,
   layerMemory: () => layerMemory,
-  layerFromRegistrationEffects: () => layerFromRegistrationEffects,
+  layerCombined: () => layerCombined,
   layer: () => layer,
-  combine: () => combine,
   classifyFailure: () => classifyFailure,
-  Service: () => Service,
+  ModelRegistry: () => ModelRegistry,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered
 });
-import { Chunk, Context as Context2, Effect as Effect3, Function as Function2, Layer as Layer3, Option as Option2, Ref, Schema as Schema4, Semaphore, Stream } from "effect";
+import { Context as Context2, Effect as Effect3, Fiber, Function as Function2, HashMap, Layer as Layer3, Option as Option2, Ref, Schema as Schema5, Scope, Semaphore, Stream } from "effect";
 import { LanguageModel as LanguageModel2, Model } from "effect/unstable/ai";
 var FailureClassifierTypeId = Symbol.for("@batonfx/core/model-registry/FailureClassifier");
 var classifyFailure = Function2.dual(2, (model, error) => model[FailureClassifierTypeId]?.(error) ?? "other");
@@ -295,28 +362,25 @@ var attachFailureClassifier = (registration, context) => {
   return Context2.add(context, LanguageModel2.LanguageModel, classified);
 };
 
-class LanguageModelNotRegistered extends Schema4.TaggedErrorClass()("LanguageModelNotRegistered", {
-  provider: Schema4.String,
-  model: Schema4.String,
-  registration_key: Schema4.optionalKey(Schema4.String)
+class LanguageModelNotRegistered extends Schema5.TaggedErrorClass()("@batonfx/core/LanguageModelNotRegistered", {
+  provider: Schema5.String,
+  model: Schema5.String,
+  registration_key: Schema5.optionalKey(Schema5.String)
 }) {
 }
 
-class Service extends Context2.Service()("@batonfx/core/model-registry/Service") {
+class ModelRegistry extends Context2.Service()("@batonfx/core/ModelRegistry") {
 }
-var registrationVariantKey = (value) => value.registrationKey ?? null;
-var selectionVariantKey = (selection) => selection.registrationKey ?? null;
-var registryIdentity = (registration) => JSON.stringify([registration.provider, registration.model, registrationVariantKey(registration)]);
-var matchesSelection = (selection) => (registration) => registration.provider === selection.provider && registration.model === selection.model && registrationVariantKey(registration) === selectionVariantKey(selection);
-var upsertRegistration = (registry, registration) => {
-  const key = registryIdentity(registration);
-  const exists = Option2.isSome(Chunk.findFirst(registry, (item) => registryIdentity(item) === key));
-  if (!exists)
-    return Chunk.append(registry, registration);
-  return Chunk.map(registry, (item) => registryIdentity(item) === key ? registration : item);
-};
-var findRegistration = (registry, selection) => Chunk.findFirst(registry, matchesSelection(selection)).pipe(Option2.getOrUndefined);
-var registrationFromLayer = (input) => Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect3.map((layer) => ({
+var selectionKey = (selection) => JSON.stringify([selection.provider, selection.model, selection.registrationKey ?? null]);
+var upsertRegistration = (registry, entry) => {
+  const key = selectionKey(entry.registration);
+  return {
+    byKey: HashMap.set(registry.byKey, key, entry),
+    keys: HashMap.has(registry.byKey, key) ? registry.keys : [...registry.keys, key]
+  };
+};
+var findRegistration = (registry, selection) => HashMap.get(registry.byKey, selectionKey(selection)).pipe(Option2.getOrUndefined);
+var registration = (input) => Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect3.map((layer) => ({
   provider: input.provider,
   model: input.model,
   layer,
@@ -324,30 +388,44 @@ var registrationFromLayer = (input) => Model.make(input.provider, input.model, i
   ...input.metadata === undefined ? {} : { metadata: input.metadata },
   ...input.classifyFailure === undefined ? {} : { classifyFailure: input.classifyFailure }
 })));
-var layer = Function2.dual((args) => args.length === 0 || args.length > 1 || Array.isArray(args[0]), (initialRegistrations = [], options) => Layer3.effect(Service, Effect3.gen(function* () {
-  const registry = yield* Ref.make(initialRegistrations.reduce(upsertRegistration, Chunk.empty()));
+var makeLayer = (initialRegistrations, options) => Layer3.effect(ModelRegistry, Effect3.gen(function* () {
+  const memoMap = yield* Layer3.makeMemoMap;
+  const scope = yield* Effect3.scope;
+  const makeEntry = Effect3.fnUntraced(function* (candidate) {
+    const fiber = yield* Effect3.cached(Effect3.forkIn(Layer3.buildWithMemoMap(candidate.layer, memoMap, scope), scope, {
+      startImmediately: true
+    }));
+    const context = Effect3.uninterruptible(fiber).pipe(Effect3.flatMap(Fiber.join));
+    return { registration: candidate, context };
+  });
+  const initialEntries = yield* Effect3.forEach(initialRegistrations, makeEntry);
+  const registry = yield* Ref.make(initialEntries.reduce(upsertRegistration, {
+    byKey: HashMap.empty(),
+    keys: []
+  }));
   const semaphore = options?.maxConcurrentModelCalls === undefined ? undefined : yield* Semaphore.make(options.maxConcurrentModelCalls);
   const register = Effect3.fn("ModelRegistry.register")(function* (input) {
-    yield* Ref.update(registry, (items) => upsertRegistration(items, input.registration));
+    const entry = yield* makeEntry(input.registration);
+    yield* Ref.update(registry, (items) => upsertRegistration(items, entry));
   });
-  const registrations = Ref.get(registry).pipe(Effect3.map(Chunk.toReadonlyArray));
+  const registrations = Ref.get(registry).pipe(Effect3.map((items) => items.keys.map((key) => HashMap.getUnsafe(items.byKey, key).registration)));
   const operate = Effect3.fn("ModelRegistry.operate")(function* (selection, effect) {
     const items = yield* Ref.get(registry);
-    const registration = findRegistration(items, selection);
-    if (registration === undefined) {
+    const entry = findRegistration(items, selection);
+    if (entry === undefined) {
       return yield* LanguageModelNotRegistered.make({
         provider: selection.provider,
         model: selection.model,
         ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
       });
     }
-    const provided = Effect3.scoped(Layer3.build(registration.layer).pipe(Effect3.flatMap((context) => effect.pipe(Effect3.provide(attachFailureClassifier(registration, context))))));
+    const provided = entry.context.pipe(Effect3.flatMap((context) => effect.pipe(Effect3.provide(attachFailureClassifier(entry.registration, context)))));
     return yield* semaphore === undefined ? provided : semaphore.withPermits(1)(provided);
   });
   const stream = (selection, operation) => Stream.unwrap(Effect3.gen(function* () {
     const items = yield* Ref.get(registry);
-    const registration = findRegistration(items, selection);
-    if (registration === undefined) {
+    const entry = findRegistration(items, selection);
+    if (entry === undefined) {
       return yield* LanguageModelNotRegistered.make({
         provider: selection.provider,
         model: selection.model,
@@ -357,82 +435,79 @@ var layer = Function2.dual((args) => args.length === 0 || args.length > 1 || Arr
     if (semaphore !== undefined) {
       yield* Effect3.acquireRelease(semaphore.take(1), () => semaphore.release(1), { interruptible: true });
     }
-    const context = attachFailureClassifier(registration, yield* Layer3.build(registration.layer));
+    const context = attachFailureClassifier(entry.registration, yield* entry.context);
     return operation.pipe(Stream.provideContext(context));
   }));
-  return Service.of({
+  return ModelRegistry.of({
     register,
     registrations,
     operate,
-    stream,
-    provide: operate
+    stream
   });
-})));
-var layerFromRegistrationEffects = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registrations, options) => Layer3.unwrap(Effect3.all(registrations).pipe(Effect3.map((items) => layer(items, options)))));
-var combine = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registries, options) => Layer3.unwrap(Effect3.forEach(registries, (registry) => Layer3.build(registry).pipe(Effect3.flatMap((context) => Context2.get(context, Service).registrations))).pipe(Effect3.map((groups) => layer(groups.flat(), options)))));
+}));
+var layer = Function2.dual((args) => args.length === 0 || args.length > 1 || Array.isArray(args[0]), (registrations = [], options) => Layer3.unwrap(Effect3.all(registrations).pipe(Effect3.map((initialRegistrations) => makeLayer(initialRegistrations, options)))));
+var layerCombined = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registries, options) => Layer3.unwrap(Effect3.forEach(registries, (registry) => Layer3.build(registry).pipe(Effect3.flatMap((context) => Context2.get(context, ModelRegistry).registrations))).pipe(Effect3.map((groups) => makeLayer(groups.flat(), options)))));
 var layerMemory = layer;
-var memoryLayer = layerMemory;
-var testLayer2 = (implementation) => Layer3.succeed(Service, Service.of(implementation));
+var layerTest2 = (implementation) => Layer3.succeed(ModelRegistry, ModelRegistry.of(implementation));
 var register = Effect3.fn("ModelRegistry.register.call")(function* (input) {
-  const service = yield* Service;
+  const service = yield* ModelRegistry;
   return yield* service.register(input);
 });
 var registrations = Effect3.fn("ModelRegistry.registrations.call")(function* () {
-  const service = yield* Service;
+  const service = yield* ModelRegistry;
   return yield* service.registrations;
 });
 var operate = Function2.dual(2, (selection, effect) => Effect3.gen(function* () {
-  const service = yield* Service;
+  const service = yield* ModelRegistry;
   return yield* service.operate(selection, effect);
 }));
-var stream = Function2.dual(2, (selection, operation) => Stream.unwrap(Service.pipe(Effect3.map((service) => service.stream(selection, operation)))));
-var provide = operate;
+var stream = Function2.dual(2, (selection, operation) => Stream.unwrap(ModelRegistry.pipe(Effect3.map((service) => service.stream(selection, operation)))));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-context.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-context.js
 var exports_tool_context = {};
 __export(exports_tool_context, {
-  testLayer: () => testLayer3,
+  layerTest: () => layerTest3,
   layerDefault: () => layerDefault,
   ToolContext: () => ToolContext
 });
 import { Context as Context3, Effect as Effect4, Layer as Layer4 } from "effect";
 
-class ToolContext extends Context3.Service()("@batonfx/core/tool-context/ToolContext") {
+class ToolContext extends Context3.Service()("@batonfx/core/ToolContext") {
 }
 var layerDefault = Layer4.sync(ToolContext, () => ToolContext.of({
   signal: new AbortController().signal,
   emit: () => Effect4.void,
   sessionId: "local"
 }));
-var testLayer3 = (implementation) => Layer4.succeed(ToolContext, ToolContext.of(implementation));
+var layerTest3 = (implementation) => Layer4.succeed(ToolContext, ToolContext.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-executor.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-executor.js
 var exports_tool_executor = {};
 __export(exports_tool_executor, {
-  testLayer: () => testLayer4,
   sandbox: () => sandbox,
-  router: () => router,
   routeToolkit: () => routeToolkit,
   route: () => route,
   remote: () => remote,
   mcp: () => mcp,
-  fromToolkit: () => fromToolkit,
+  layerToolkit: () => layerToolkit,
+  layerTest: () => layerTest4,
+  layerRouter: () => layerRouter,
   executeToolkit: () => executeToolkit,
   client: () => client,
   ToolExecutor: () => ToolExecutor,
-  RemoteRetryError: () => RemoteRetryError,
+  RemoteRetryMisconfigured: () => RemoteRetryMisconfigured,
   FrameworkStage: () => FrameworkStage,
   FrameworkFailure: () => FrameworkFailure
 });
-import { Context as Context4, Effect as Effect7, Layer as Layer5, Option as Option3, Schema as Schema6, Sink, Stream as Stream2 } from "effect";
+import { Context as Context4, Effect as Effect7, Layer as Layer5, Option as Option3, Schema as Schema7, Stream as Stream2 } from "effect";
 import { AiError as AiError2, Response as Response3, Tool as Tool4, Toolkit } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-placement.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-placement.js
 import { Effect as Effect6, Schedule } from "effect";
 import { Tool as Tool3 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-result-codec.js
-import { Effect as Effect5, Schema as Schema5 } from "effect";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-result-codec.js
+import { Effect as Effect5, Schema as Schema6 } from "effect";
 import { AiError, Tool as Tool2 } from "effect/unstable/ai";
 var resultMessage = (result) => {
   if (typeof result === "string")
@@ -450,20 +525,20 @@ var schemaMessage = (error) => error instanceof Error ? error.message : typeof e
 var frameworkFailure = (stage, tool, error) => FrameworkFailure.make({ stage, tool, message: schemaMessage(error) });
 var encodeSuccess = (tool, result) => {
   const schema = tool.successSchema;
-  return Schema5.encodeUnknownEffect(schema)(result).pipe(Effect5.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
+  return Schema6.encodeUnknownEffect(schema)(result).pipe(Effect5.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
 };
 var encodeDomainFailure = (tool, failure) => {
   const schema = tool.failureSchema;
-  return Schema5.encodeUnknownEffect(schema)(failure).pipe(Effect5.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect5.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
+  return Schema6.encodeUnknownEffect(schema)(failure).pipe(Effect5.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect5.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
 };
-var encodeDomainCandidate = (tool, failure) => !Schema5.is(tool.failureSchema)(failure) ? Effect5.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
+var encodeDomainCandidate = (tool, failure) => !Schema6.is(tool.failureSchema)(failure) ? Effect5.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
 var decodeInput = (tool, input) => {
   const schema = tool.parametersSchema;
-  return Schema5.decodeUnknownEffect(schema)(input).pipe(Effect5.asVoid, Effect5.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
+  return Schema6.decodeUnknownEffect(schema)(input).pipe(Effect5.asVoid, Effect5.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
 };
 var decodeSuccess = (tool, result) => {
   const schema = tool.successSchema;
-  return Schema5.decodeUnknownEffect(schema)(result).pipe(Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect5.flatMap((decoded) => encodeSuccess(tool, decoded)));
+  return Schema6.decodeUnknownEffect(schema)(result).pipe(Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect5.flatMap((decoded) => encodeSuccess(tool, decoded)));
 };
 var aiFrameworkFailure = (tool, error) => {
   switch (error.reason._tag) {
@@ -476,8 +551,8 @@ var aiFrameworkFailure = (tool, error) => {
     case "ToolResultEncodingError": {
       if (tool.failureMode === "error")
         return frameworkFailure("encode-success", tool.name, error);
-      const isSuccess = Schema5.isSchema(tool.successSchema) && Schema5.is(tool.successSchema)(error.reason.toolResult);
-      const isDomainFailure = Schema5.isSchema(tool.failureSchema) && Schema5.is(tool.failureSchema)(error.reason.toolResult);
+      const isSuccess = Schema6.isSchema(tool.successSchema) && Schema6.is(tool.successSchema)(error.reason.toolResult);
+      const isDomainFailure = Schema6.isSchema(tool.failureSchema) && Schema6.is(tool.failureSchema)(error.reason.toolResult);
       return frameworkFailure(isSuccess === isDomainFailure ? "handler" : isDomainFailure ? "encode-domain-failure" : "encode-success", tool.name, error);
     }
     default:
@@ -496,7 +571,7 @@ var toolResultCodec = {
   schemaMessage
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-placement.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-placement.js
 var placementOutcomeFromResponse = (placement, tool, response) => {
   if (typeof response !== "object" || response === null || !("_tag" in response)) {
     return Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an invalid response"));
@@ -514,8 +589,8 @@ var placementOutcomeFromResponse = (placement, tool, response) => {
 };
 var placementOutcome = { fromResponse: placementOutcomeFromResponse };
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-executor.js
-var FrameworkStage = Schema6.Literals([
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-executor.js
+var FrameworkStage = Schema7.Literals([
   "decode-input",
   "handler",
   "encode-success",
@@ -526,20 +601,20 @@ var FrameworkStage = Schema6.Literals([
   "authorization"
 ]);
 
-class FrameworkFailure extends Schema6.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
+class FrameworkFailure extends Schema7.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
   stage: FrameworkStage,
-  tool: Schema6.String,
-  message: Schema6.String
+  tool: Schema7.String,
+  message: Schema7.String
 }) {
 }
 
-class RemoteRetryError extends Schema6.TaggedErrorClass()("@batonfx/core/RemoteRetryError", {
-  reason: Schema6.Literals(["invalid-max-retries", "missing-operation-key", "changed-operation-key"]),
-  message: Schema6.String
+class RemoteRetryMisconfigured extends Schema7.TaggedErrorClass()("@batonfx/core/RemoteRetryMisconfigured", {
+  reason: Schema7.Literals(["invalid-max-retries", "missing-operation-key", "changed-operation-key"]),
+  message: Schema7.String
 }) {
 }
 
-class ToolExecutor extends Context4.Service()("@batonfx/core/tool-executor/ToolExecutor") {
+class ToolExecutor extends Context4.Service()("@batonfx/core/ToolExecutor") {
 }
 var findTool = (tools, name) => tools[name];
 var executeWithToolkit = (toolkit, request) => {
@@ -548,13 +623,13 @@ var executeWithToolkit = (toolkit, request) => {
     return Effect7.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
   }
   const handleFailure = (error) => {
-    if (Schema6.is(FrameworkFailure)(error))
+    if (Schema7.is(FrameworkFailure)(error))
       return Effect7.fail(error);
     if (AiError2.isAiError(error))
       return Effect7.fail(toolResultCodec.aiFrameworkFailure(tool, error));
     return toolResultCodec.encodeDomainCandidate(tool, error);
   };
-  return toolkit.handle(request.call.name, request.call.params).pipe(Effect7.flatMap((results) => results.pipe(Stream2.filter((item) => item.preliminary === false), Stream2.run(Sink.last()))), Effect7.flatMap((option) => {
+  return toolkit.handle(request.call.name, request.call.params).pipe(Effect7.flatMap((results) => results.pipe(Stream2.filter((item) => item.preliminary === false), Stream2.runLast)), Effect7.flatMap((option) => {
     if (Option3.isNone(option)) {
       return Effect7.fail(toolResultCodec.frameworkFailure("handler", tool.name, "Tool handler did not produce a final result"));
     }
@@ -576,7 +651,7 @@ function executeToolkit(toolkitOrRequest, request) {
   const toolkit = toolkitOrRequest;
   return ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.flatMap((handled) => executeWithToolkit(handled, request)));
 }
-function fromToolkit(toolkit) {
+function layerToolkit(toolkit) {
   return Layer5.effect(ToolExecutor, ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.map((handled) => ToolExecutor.of({
     execute: (request) => executeWithToolkit(handled, request)
   }))));
@@ -601,11 +676,11 @@ var placementRoute = (placement, options) => {
       return toolResultCodec.decodeInput(tool, request.call.params).pipe(Effect7.flatMap(() => {
         const effect = options.execute({ ...request, placement, tool });
         return effect;
-      }), Effect7.mapError((error) => Schema6.is(FrameworkFailure)(error) || Schema6.is(RemoteRetryError)(error) ? error : toolResultCodec.frameworkFailure("placement", request.call.name, error)), Effect7.flatMap((response) => placementOutcome.fromResponse(placement, tool, response)));
+      }), Effect7.mapError((error) => Schema7.is(FrameworkFailure)(error) || Schema7.is(RemoteRetryMisconfigured)(error) ? error : toolResultCodec.frameworkFailure("placement", request.call.name, error)), Effect7.flatMap((response) => placementOutcome.fromResponse(placement, tool, response)));
     }
   });
 };
-var remoteRetryError = (reason, message) => RemoteRetryError.make({ reason, message });
+var remoteRetryError = (reason, message) => RemoteRetryMisconfigured.make({ reason, message });
 var validateOperationKey = (operationKey) => typeof operationKey !== "string" || operationKey.trim().length === 0 ? Effect7.fail(remoteRetryError("missing-operation-key", "Remote retry operation key must be non-empty")) : Effect7.succeed(operationKey);
 var retryRemote = (options, request) => Effect7.suspend(() => {
   if (!Number.isFinite(options.maxRetries) || !Number.isInteger(options.maxRetries) || options.maxRetries < 0) {
@@ -625,12 +700,12 @@ var retryRemote = (options, request) => Effect7.suspend(() => {
     return Effect7.retry(executeAttempt, {
       schedule: options.schedule,
       times: options.maxRetries,
-      while: (error) => !Schema6.is(AgentError)(error) && !Schema6.is(FrameworkFailure)(error) && !Schema6.is(RemoteRetryError)(error)
-    }).pipe(Effect7.flatMap((result) => Schema6.is(RemoteRetryError)(result) ? Effect7.fail(result) : Effect7.succeed(result)));
+      while: (error) => !Schema7.is(AgentError)(error) && !Schema7.is(FrameworkFailure)(error) && !Schema7.is(RemoteRetryMisconfigured)(error)
+    }).pipe(Effect7.flatMap((result) => Schema7.is(RemoteRetryMisconfigured)(result) ? Effect7.fail(result) : Effect7.succeed(result)));
   }));
 });
 var client = (options) => placementRoute("client", options);
-var remote = (options) => options.retrySafe === true ? placementRoute("remote", {
+var remote = (options) => options.idempotent === true ? placementRoute("remote", {
   toolkit: options.toolkit,
   ...options.tools === undefined ? {} : { tools: options.tools },
   execute: (request) => retryRemote(options, request)
@@ -645,7 +720,7 @@ function routeToolkit(toolkit) {
   return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect7.map(makeRoute));
 }
 var routeInputEffect = (input) => Effect7.isEffect(input) ? input : Effect7.succeed(input);
-function router(routes) {
+function layerRouter(routes) {
   return Layer5.effect(ToolExecutor, Effect7.all(Array.from(routes, routeInputEffect)).pipe(Effect7.map((resolved) => ToolExecutor.of({
     execute: (request) => {
       const matched = resolved.find((candidate) => candidate.matches(request));
@@ -653,28 +728,28 @@ function router(routes) {
     }
   }))));
 }
-var testLayer4 = (implementation) => Layer5.succeed(ToolExecutor, ToolExecutor.of(implementation));
+var layerTest4 = (implementation) => Layer5.succeed(ToolExecutor, ToolExecutor.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/approvals.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/approvals.js
 var exports_approvals = {};
 __export(exports_approvals, {
-  testLayer: () => testLayer5,
-  denyAll: () => denyAll,
-  autoApprove: () => autoApprove,
+  layerTest: () => layerTest5,
+  layerDenyAll: () => layerDenyAll,
+  layerAutoApprove: () => layerAutoApprove,
   Approvals: () => Approvals
 });
 import { Context as Context5, Effect as Effect8, Layer as Layer6 } from "effect";
-class Approvals extends Context5.Service()("@batonfx/core/approvals") {
+
+class Approvals extends Context5.Service()("@batonfx/core/Approvals") {
 }
-var autoApprove = Layer6.succeed(Approvals, Approvals.of({ check: () => Effect8.succeed({ _tag: "Approved" }) }));
-var denyAll = Layer6.succeed(Approvals, Approvals.of({ check: () => Effect8.succeed({ _tag: "Denied" }) }));
-var testLayer5 = (implementation) => Layer6.succeed(Approvals, Approvals.of(implementation));
+var layerAutoApprove = Layer6.succeed(Approvals, Approvals.of({ resolve: () => Effect8.succeed({ _tag: "Approved" }) }));
+var layerDenyAll = Layer6.succeed(Approvals, Approvals.of({ resolve: () => Effect8.succeed({ _tag: "Denied" }) }));
+var layerTest5 = (implementation) => Layer6.succeed(Approvals, Approvals.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/session.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/session.js
 var exports_session = {};
 __export(exports_session, {
-  testLayer: () => testLayer6,
-  memoryLayer: () => memoryLayer2,
+  layerTest: () => layerTest6,
   layerMemory: () => layerMemory2,
   buildMemoryContext: () => buildMemoryContext,
   buildContext: () => buildContext,
@@ -682,23 +757,23 @@ __export(exports_session, {
   SessionStore: () => SessionStore,
   SessionConflict: () => SessionConflict
 });
-import { Context as Context6, Effect as Effect9, HashMap, Layer as Layer7, Option as Option4, Ref as Ref2, Schema as Schema7 } from "effect";
-import { Prompt as Prompt4 } from "effect/unstable/ai";
-class SessionStoreError extends Schema7.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
-  message: Schema7.String
+import { Context as Context6, Effect as Effect9, HashMap as HashMap2, Layer as Layer7, Option as Option4, Ref as Ref2, Schema as Schema8 } from "effect";
+import { Prompt as Prompt5 } from "effect/unstable/ai";
+class SessionStoreError extends Schema8.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
+  message: Schema8.String
 }) {
 }
 
-class SessionConflict extends Schema7.TaggedErrorClass()("@batonfx/core/SessionConflict", {
-  reason: Schema7.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path"]),
-  message: Schema7.String
+class SessionConflict extends Schema8.TaggedErrorClass()("@batonfx/core/SessionConflict", {
+  reason: Schema8.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]),
+  message: Schema8.String
 }) {
 }
 
-class SessionStore extends Context6.Service()("@batonfx/core/session/SessionStore") {
+class SessionStore extends Context6.Service()("@batonfx/core/SessionStore") {
 }
 var initialState = {
-  entries: HashMap.empty(),
+  entries: HashMap2.empty(),
   order: [],
   leaf: null,
   counter: 0
@@ -743,7 +818,7 @@ var pathFromState = (state, leaf) => {
   while (cursor !== null) {
     if (entries.length > state.order.length)
       return failure(`Session path for leaf ${leaf} contains a cycle`);
-    const entry = HashMap.get(state.entries, cursor);
+    const entry = HashMap2.get(state.entries, cursor);
     if (Option4.isNone(entry))
       return failure(`Session entry ${cursor} does not exist`);
     const value = entry.value;
@@ -783,17 +858,17 @@ var appendState = (state, input, options) => {
   return [
     success(entry),
     {
-      entries: HashMap.set(state.entries, id, entry),
+      entries: HashMap2.set(state.entries, id, entry),
       order: [...state.order, id],
       leaf: id,
       counter: state.counter + 1
     }
   ];
 };
-var promptEquivalence = Schema7.toEquivalence(Prompt4.Prompt);
+var promptEquivalence = Schema8.toEquivalence(Prompt5.Prompt);
 var checkpointMatches = (entry, prepared) => entry.parentId === prepared.parentId && entry.summary === prepared.summary && promptEquivalence(entry.projectedHistory, prepared.projectedHistory);
 var appendCheckpointState = (state, prepared) => {
-  const existing = HashMap.get(state.entries, prepared.id);
+  const existing = HashMap2.get(state.entries, prepared.id);
   if (Option4.isSome(existing)) {
     const entry = existing.value;
     if (entry._tag !== "Compaction" || entry.version !== 2 || !checkpointMatches(entry, prepared)) {
@@ -844,18 +919,18 @@ var appendCheckpointState = (state, prepared) => {
     { _tag: "Appended", checkpoint, leafId: checkpoint.id },
     {
       ...state,
-      entries: HashMap.set(state.entries, checkpoint.id, checkpoint),
+      entries: HashMap2.set(state.entries, checkpoint.id, checkpoint),
       order: [...state.order, checkpoint.id],
       leaf: checkpoint.id
     }
   ];
 };
 var setLeafState = (state, id) => {
-  if (id !== null && Option4.isNone(HashMap.get(state.entries, id)))
+  if (id !== null && Option4.isNone(HashMap2.get(state.entries, id)))
     return [failure(`Session entry ${id} does not exist`), state];
   return [success(undefined), { ...state, leaf: id }];
 };
-var messageFromText = (role, text) => role === "system" ? Prompt4.makeMessage("system", { content: text }) : Prompt4.makeMessage("user", { content: [Prompt4.makePart("text", { text })] });
+var messageFromText = (role, text) => role === "system" ? Prompt5.makeMessage("system", { content: text }) : Prompt5.makeMessage("user", { content: [Prompt5.makePart("text", { text })] });
 var checkpointMessage = (summary) => messageFromText("user", `<conversation-checkpoint>
 ${summary}
 </conversation-checkpoint>`);
@@ -887,10 +962,10 @@ var projectedMessages = (path) => {
         messages.push(entry.message);
         break;
       case "ToolCall":
-        messages.push(Prompt4.makeMessage("assistant", { content: [entry.part] }));
+        messages.push(Prompt5.makeMessage("assistant", { content: [entry.part] }));
         break;
       case "ToolResult":
-        messages.push(Prompt4.makeMessage("tool", { content: [entry.part] }));
+        messages.push(Prompt5.makeMessage("tool", { content: [entry.part] }));
         break;
       case "Memory":
         messages.push(memoryMessage(entry.items));
@@ -913,16 +988,16 @@ var projectedMessages = (path) => {
   }
   return messages;
 };
-var buildContext = (path) => Prompt4.fromMessages(projectedMessages(path));
+var buildContext = (path) => Prompt5.fromMessages(projectedMessages(path));
 var buildMemoryContext = (path) => {
   const messages = path.flatMap((entry) => {
     switch (entry._tag) {
       case "Message":
         return [entry.message];
       case "ToolCall":
-        return [Prompt4.makeMessage("assistant", { content: [entry.part] })];
+        return [Prompt5.makeMessage("assistant", { content: [entry.part] })];
       case "ToolResult":
-        return [Prompt4.makeMessage("tool", { content: [entry.part] })];
+        return [Prompt5.makeMessage("tool", { content: [entry.part] })];
       case "Steering":
         return [entry.message];
       case "Memory":
@@ -933,7 +1008,7 @@ var buildMemoryContext = (path) => {
         return [];
     }
   });
-  return projectTranscript(Prompt4.fromMessages(messages));
+  return projectTranscript(Prompt5.fromMessages(messages));
 };
 var layerMemory2 = Layer7.effect(SessionStore, Ref2.make(initialState).pipe(Effect9.map((state) => SessionStore.of({
   reserveEntryId: Ref2.modify(state, (current) => [
@@ -946,35 +1021,34 @@ var layerMemory2 = Layer7.effect(SessionStore, Ref2.make(initialState).pipe(Effe
   setLeaf: (id) => Ref2.modify(state, (current) => setLeafState(current, id)).pipe(Effect9.flatMap(effectFromResult)),
   leaf: Ref2.get(state).pipe(Effect9.map((current) => current.leaf))
 }))));
-var memoryLayer2 = layerMemory2;
-var testLayer6 = (implementation) => Layer7.succeed(SessionStore, SessionStore.of(implementation));
+var layerTest6 = (implementation) => Layer7.succeed(SessionStore, SessionStore.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-output.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-output.js
 var exports_tool_output = {};
 __export(exports_tool_output, {
-  testLayer: () => testLayer7,
+  layerTest: () => layerTest7,
   layerNoop: () => layerNoop2,
   layerMemory: () => layerMemory3,
   bound: () => bound,
   ToolOutputStore: () => ToolOutputStore,
   ToolOutputError: () => ToolOutputError
 });
-import { Cause, Context as Context7, Effect as Effect10, Function as Function3, HashMap as HashMap2, Layer as Layer8, Option as Option5, Ref as Ref3, Schema as Schema8 } from "effect";
-class ToolOutputStore extends Context7.Service()("@batonfx/core/tool-output/ToolOutputStore") {
+import { Cause, Context as Context7, Effect as Effect10, Function as Function3, HashMap as HashMap3, Layer as Layer8, Option as Option5, Ref as Ref3, Schema as Schema9 } from "effect";
+class ToolOutputStore extends Context7.Service()("@batonfx/core/ToolOutputStore") {
 }
 
-class ToolOutputError extends Schema8.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
-  message: Schema8.String
+class ToolOutputError extends Schema9.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
+  message: Schema9.String
 }) {
 }
 var layerNoop2 = Layer8.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect10.succeed(Option5.none()) }));
-var layerMemory3 = Layer8.effect(ToolOutputStore, Ref3.make({ next: 0, records: HashMap2.empty() }).pipe(Effect10.map((state) => ToolOutputStore.of({
+var layerMemory3 = Layer8.effect(ToolOutputStore, Ref3.make({ next: 0, records: HashMap3.empty() }).pipe(Effect10.map((state) => ToolOutputStore.of({
   put: (toolCallId, content) => Ref3.modify(state, ({ next, records }) => {
     const id = `mem:tool-output-${next + 1}`;
-    return [Option5.some(id), { next: next + 1, records: HashMap2.set(records, id, { toolCallId, content }) }];
+    return [Option5.some(id), { next: next + 1, records: HashMap3.set(records, id, { toolCallId, content }) }];
   })
 }))));
-var testLayer7 = (implementation) => Layer8.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
+var layerTest7 = (implementation) => Layer8.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
 var encoder = new TextEncoder;
 var decoder = new TextDecoder;
 var serialized = (value) => {
@@ -1025,15 +1099,15 @@ var bound = Function3.dual(2, (result, options) => Effect10.gen(function* () {
   return boundedFromOriginal(encoded, bytes, options.maxBytes, [path.value]);
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/compaction.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/compaction.js
 var exports_compaction = {};
 __export(exports_compaction, {
   truncate: () => truncate,
   toolOutputBound: () => toolOutputBound,
-  testLayer: () => testLayer8,
   structuredSummary: () => structuredSummary,
   strategy: () => strategy,
   make: () => make2,
+  layerTest: () => layerTest8,
   layer: () => layer2,
   keepRecent: () => keepRecent,
   defaultStrategy: () => defaultStrategy,
@@ -1044,8 +1118,35 @@ __export(exports_compaction, {
   Compaction: () => Compaction,
   AgentSummary: () => AgentSummary
 });
-import { Context as Context8, Effect as Effect11, Function as Function4, Layer as Layer9, Option as Option6, Schema as Schema9 } from "effect";
-import { LanguageModel as LanguageModel3, Prompt as Prompt5, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
+import { Context as Context9, Effect as Effect12, Function as Function4, Layer as Layer10, Option as Option6, Schema as Schema10 } from "effect";
+import { LanguageModel as LanguageModel4, Prompt as Prompt6, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/summary-model.js
+import { Context as Context8, Deferred, Effect as Effect11, Fiber as Fiber2, Layer as Layer9, Scope as Scope2 } from "effect";
+import { LanguageModel as LanguageModel3 } from "effect/unstable/ai";
+var makeSummaryModelProvider = (model) => {
+  const fibers = new WeakMap;
+  return (effect) => Effect11.contextWith((context) => {
+    const memoMap = Context8.getOrUndefined(context, Layer9.CurrentMemoMap);
+    const scope = Context8.getOrUndefined(context, Scope2.Scope);
+    if (memoMap === undefined || scope === undefined) {
+      return Effect11.scoped(Layer9.build(model).pipe(Effect11.flatMap((modelContext) => effect.pipe(Effect11.provide(modelContext)))));
+    }
+    const sharedFiber = Effect11.uninterruptible(Effect11.sync(() => {
+      const existing = fibers.get(scope);
+      if (existing !== undefined)
+        return [existing, false];
+      const created = Deferred.makeUnsafe();
+      fibers.set(scope, created);
+      return [created, true];
+    }).pipe(Effect11.flatMap(([deferred, start]) => start ? Effect11.forkIn(Layer9.buildWithMemoMap(model, memoMap, scope), scope, {
+      startImmediately: true
+    }).pipe(Effect11.tap((fiber) => Deferred.succeed(deferred, fiber)), Effect11.as(deferred)) : Effect11.succeed(deferred))));
+    return sharedFiber.pipe(Effect11.flatMap(Deferred.await), Effect11.flatMap(Fiber2.join), Effect11.flatMap((modelContext) => effect.pipe(Effect11.provide(modelContext))));
+  });
+};
+
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/compaction.js
 var DEFAULT_RESERVE_TOKENS = 16384;
 var DEFAULT_KEEP_RECENT_TOKENS = 20000;
 var SUMMARY_TEMPLATE = `Summarize the conversation so another agent can continue seamlessly.
@@ -1063,21 +1164,21 @@ Use Markdown with these sections:
 ## Critical Context
 
 Do not mention that context was compacted.`;
-var AgentSummary = Schema9.Struct({
-  goal: Schema9.String,
-  facts: Schema9.Array(Schema9.String),
-  decisions: Schema9.Array(Schema9.String),
-  openQuestions: Schema9.Array(Schema9.String),
-  toolFindings: Schema9.Array(Schema9.String)
+var AgentSummary = Schema10.Struct({
+  goal: Schema10.String,
+  facts: Schema10.Array(Schema10.String),
+  decisions: Schema10.Array(Schema10.String),
+  openQuestions: Schema10.Array(Schema10.String),
+  toolFindings: Schema10.Array(Schema10.String)
 });
 
-class CompactionError extends Schema9.TaggedErrorClass()("@batonfx/core/CompactionError", {
-  message: Schema9.String,
-  cause: Schema9.optionalKey(Schema9.Defect())
+class CompactionError extends Schema10.TaggedErrorClass()("@batonfx/core/CompactionError", {
+  message: Schema10.String,
+  cause: Schema10.optionalKey(Schema10.Defect())
 }) {
 }
 
-class Compaction extends Context8.Service()("@batonfx/core/compaction") {
+class Compaction extends Context9.Service()("@batonfx/core/Compaction") {
 }
 var serialized2 = (value) => {
   const json = JSON.stringify(value);
@@ -1108,12 +1209,12 @@ var APPROX_CHARS_PER_TOKEN = 4;
 var estimateTokens = (text) => Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
 var estimateEntryTokens = (entry) => estimateTokens(serialized2(entry));
 var estimatePromptTokens = (prompt) => estimateTokens(serialized2(prompt.content));
-var fits = (history, prompt, usage) => Number.isFinite(usage.contextWindow) && estimatePromptTokens(Prompt5.concat(history, prompt)) <= usage.contextWindow - usage.reserveTokens;
+var fits = (history, prompt, usage) => Number.isFinite(usage.contextWindow) && estimatePromptTokens(Prompt6.concat(history, prompt)) <= usage.contextWindow - usage.reserveTokens;
 var isPromptToolResult = (part) => part.type === "tool-result";
 var messageHasToolCall = (message) => typeof message.content !== "string" && message.content.some((part) => part.type === "tool-call");
 var isToolMessage = (entry) => entry?._tag === "Message" && entry.message.role === "tool";
 var isAssistantToolCallEntry = (entry) => entry?._tag === "Message" && entry.message.role === "assistant" && messageHasToolCall(entry.message);
-var compactToolPart = (part, maxBytes) => Effect11.gen(function* () {
+var compactToolPart = (part, maxBytes) => Effect12.gen(function* () {
   if (part.isFailure)
     return [part, false];
   const success2 = { _tag: "Success", result: part.result, encodedResult: part.result };
@@ -1121,7 +1222,7 @@ var compactToolPart = (part, maxBytes) => Effect11.gen(function* () {
   if (bounded2.encodedResult === success2.encodedResult)
     return [part, false];
   return [
-    Prompt5.makePart("tool-result", {
+    Prompt6.makePart("tool-result", {
       id: part.id,
       name: part.name,
       isFailure: false,
@@ -1130,7 +1231,7 @@ var compactToolPart = (part, maxBytes) => Effect11.gen(function* () {
     true
   ];
 });
-var microcompactPrompt = (prompt, maxBytes) => Effect11.gen(function* () {
+var microcompactPrompt = (prompt, maxBytes) => Effect12.gen(function* () {
   let changed = false;
   const messages = [];
   for (const message of prompt.content) {
@@ -1152,19 +1253,19 @@ var microcompactPrompt = (prompt, maxBytes) => Effect11.gen(function* () {
       messages.push(messageChanged ? { ...message, content } : message);
     }
   }
-  return [changed ? Prompt5.fromMessages(messages) : prompt, changed];
+  return [changed ? Prompt6.fromMessages(messages) : prompt, changed];
 });
-var checkpointMessage2 = (summary) => Prompt5.makeMessage("user", {
-  content: [Prompt5.makePart("text", { text: `<conversation-checkpoint>
+var checkpointMessage2 = (summary) => Prompt6.makeMessage("user", {
+  content: [Prompt6.makePart("text", { text: `<conversation-checkpoint>
 ${summary}
 </conversation-checkpoint>` })]
 });
-var summaryPrompt = (template, prompt) => Prompt5.make(`${template}
+var summaryPrompt = (template, prompt) => Prompt6.make(`${template}
 
 Conversation to summarize:
 ${serialized2(prompt.content)}`);
 var systemMessages = (entries) => entries.flatMap((entry) => entry._tag === "Message" && entry.message.role === "system" ? [entry.message] : []);
-var compactedHistory = (summary, head, recent) => Prompt5.concat(Prompt5.fromMessages([...systemMessages(head), checkpointMessage2(summary)]), recent);
+var compactedHistory = (summary, head, recent) => Prompt6.concat(Prompt6.fromMessages([...systemMessages(head), checkpointMessage2(summary)]), recent);
 var normalizeUsage = (usage, options) => ({
   contextTokens: Number.isFinite(usage.contextTokens) ? usage.contextTokens : 0,
   contextWindow: Number.isFinite(usage.contextWindow) ? usage.contextWindow : options.contextWindow ?? Number.POSITIVE_INFINITY,
@@ -1187,27 +1288,30 @@ var safeCutIndex = (entries, keepRecentTokens) => {
   }
   return index;
 };
-var defaultStrategy = (options = {}) => ({
-  shouldCompact: (usage) => Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens,
-  cut: (entries, keepRecentTokens) => {
-    const index = safeCutIndex(entries, keepRecentTokens);
-    if (index <= 0 || index >= entries.length)
-      return Option6.none();
-    const recent = entries.slice(index);
-    const first = recent[0];
-    return first === undefined ? Option6.none() : Option6.some({ firstKeptEntryId: first.id, head: entries.slice(0, index), recent });
-  },
-  summarize: (plan, request) => {
-    const effect = Effect11.gen(function* () {
-      const head = buildContext(plan.head);
-      const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
-      const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
-      const model = yield* LanguageModel3.LanguageModel;
-      return yield* model.generateText({ prompt, toolkit: Toolkit2.empty, toolChoice: "none" }).pipe(Effect11.map((response) => response.text), Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
-    });
-    return options.summaryModel === undefined ? effect : Effect11.scoped(Layer9.build(options.summaryModel).pipe(Effect11.flatMap((context) => effect.pipe(Effect11.provide(context)))));
-  }
-});
+var defaultStrategy = (options = {}) => {
+  const provideSummaryModel = options.summaryModel === undefined ? undefined : makeSummaryModelProvider(options.summaryModel);
+  return {
+    shouldCompact: (usage) => Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens,
+    cut: (entries, keepRecentTokens) => {
+      const index = safeCutIndex(entries, keepRecentTokens);
+      if (index <= 0 || index >= entries.length)
+        return Option6.none();
+      const recent = entries.slice(index);
+      const first = recent[0];
+      return first === undefined ? Option6.none() : Option6.some({ firstKeptEntryId: first.id, head: entries.slice(0, index), recent });
+    },
+    summarize: (plan, request) => {
+      const effect = Effect12.gen(function* () {
+        const head = buildContext(plan.head);
+        const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
+        const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
+        const model = yield* LanguageModel4.LanguageModel;
+        return yield* model.generateText({ prompt, toolkit: Toolkit2.empty, toolChoice: "none" }).pipe(Effect12.map((response) => response.text), Effect12.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+      });
+      return provideSummaryModel === undefined ? effect : provideSummaryModel(effect);
+    }
+  };
+};
 var strategy = Function4.dual((args) => args.length !== 1 || Array.isArray(args[0]), (parts, base = defaultStrategy()) => parts.reduce((current, part) => ({
   shouldCompact: part.shouldCompact ?? current.shouldCompact,
   cut: part.cut ?? current.cut,
@@ -1221,25 +1325,28 @@ var toolOutputBound = (options) => ({
 var keepRecent = (options) => ({
   keepRecentTokens: safeNonNegativeInteger("KeepRecentOptions.tokens", options.tokens)
 });
-var structuredSummary = (options = {}) => ({
-  summarize: (plan, request) => {
-    const effect = Effect11.gen(function* () {
-      const head = buildContext(plan.head);
-      const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
-      const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
-      const model = yield* LanguageModel3.LanguageModel;
-      return yield* model.generateObject({
-        prompt,
-        schema: AgentSummary,
-        objectName: options.objectName ?? "AgentSummary",
-        toolChoice: "none"
-      }).pipe(Effect11.map((response) => renderAgentSummary(response.value)), Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
-    });
-    return options.summaryModel === undefined ? effect : Effect11.scoped(Layer9.build(options.summaryModel).pipe(Effect11.flatMap((context) => effect.pipe(Effect11.provide(context)))));
-  }
-});
+var structuredSummary = (options = {}) => {
+  const provideSummaryModel = options.summaryModel === undefined ? undefined : makeSummaryModelProvider(options.summaryModel);
+  return {
+    summarize: (plan, request) => {
+      const effect = Effect12.gen(function* () {
+        const head = buildContext(plan.head);
+        const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
+        const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
+        const model = yield* LanguageModel4.LanguageModel;
+        return yield* model.generateObject({
+          prompt,
+          schema: AgentSummary,
+          objectName: options.objectName ?? "AgentSummary",
+          toolChoice: "none"
+        }).pipe(Effect12.map((response) => renderAgentSummary(response.value)), Effect12.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+      });
+      return provideSummaryModel === undefined ? effect : provideSummaryModel(effect);
+    }
+  };
+};
 var make2 = Function4.dual((args) => args.length !== 1 || ("shouldCompact" in args[0]), (compactionStrategy, options = {}) => ({
-  maybeCompact: (input) => Effect11.gen(function* () {
+  maybeCompact: (input) => Effect12.gen(function* () {
     const usage = normalizeUsage(input.usage, options);
     const shouldCompact = input.overflow || compactionStrategy.shouldCompact(usage);
     if (!shouldCompact)
@@ -1278,102 +1385,82 @@ var make2 = Function4.dual((args) => args.length !== 1 || ("shouldCompact" in ar
     });
   })
 }));
-var layer2 = Function4.dual((args) => args.length !== 1 || !("shouldCompact" in args[0]), (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer9.succeed(Compaction, Compaction.of(make2(providedStrategy, options))));
+var layer2 = Function4.dual((args) => args.length !== 1 || !("shouldCompact" in args[0]), (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer10.succeed(Compaction, Compaction.of(make2(providedStrategy, options))));
 var truncate = (maxTokens) => ({
-  maybeCompact: (input) => Effect11.gen(function* () {
+  maybeCompact: (input) => Effect12.gen(function* () {
     const usage = input.usage;
     if (!input.overflow && !(Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens)) {
       return Option6.none();
     }
-    const tokenizer = yield* Effect11.serviceOption(Tokenizer.Tokenizer);
+    const tokenizer = yield* Effect12.serviceOption(Tokenizer.Tokenizer);
     if (Option6.isNone(tokenizer))
       return Option6.none();
-    const prompt = yield* tokenizer.value.truncate(Prompt5.concat(input.history, input.prompt), maxTokens).pipe(Effect11.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
-    return Option6.some(makeMicrocompact(Prompt5.empty, prompt));
+    const prompt = yield* tokenizer.value.truncate(Prompt6.concat(input.history, input.prompt), maxTokens).pipe(Effect12.mapError((error) => CompactionError.make({ message: String(error), cause: error })));
+    return Option6.some(makeMicrocompact(Prompt6.empty, prompt));
   })
 });
-var testLayer8 = (implementation) => Layer9.succeed(Compaction, Compaction.of(implementation));
+var layerTest8 = (implementation) => Layer10.succeed(Compaction, Compaction.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/instructions.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/instructions.js
 var exports_instructions = {};
 __export(exports_instructions, {
-  testLayer: () => testLayer9,
   staticSource: () => staticSource,
-  renderUpdate: () => renderUpdate,
   openEpoch: () => openEpoch,
+  layerTest: () => layerTest9,
   layer: () => layer3,
   Instructions: () => Instructions
 });
-import { Context as Context9, Effect as Effect12, Layer as Layer10, Option as Option7 } from "effect";
+import { Context as Context10, Effect as Effect13, Layer as Layer11, Option as Option7 } from "effect";
 import { dual as dual3 } from "effect/Function";
-class Instructions extends Context9.Service()("@batonfx/core/instructions") {
+class Instructions extends Context10.Service()("@batonfx/core/Instructions") {
 }
 var staticSource = dual3(2, (id, text) => ({
   id,
-  cache: "baseline",
-  render: () => Effect12.succeed(text.length === 0 ? Option7.none() : Option7.some(text))
+  render: () => Effect13.succeed(text.length === 0 ? Option7.none() : Option7.some(text))
 }));
-var openEpoch = dual3(2, (instructions, context) => Effect12.gen(function* () {
+var openEpoch = dual3(2, (instructions, context) => Effect13.gen(function* () {
   const baseline = [];
-  const dynamic = [];
   for (const source of instructions.sources) {
-    if (source.cache === "dynamic") {
-      dynamic.push(source);
-    } else {
-      const rendered = yield* source.render(context);
-      if (Option7.isSome(rendered))
-        baseline.push(rendered.value);
-    }
-  }
-  return { baseline: baseline.join(`
-
-`), dynamic };
-}));
-var renderUpdate = dual3(2, (epoch, context) => Effect12.gen(function* () {
-  const fragments = [];
-  for (const source of epoch.dynamic) {
     const rendered = yield* source.render(context);
     if (Option7.isSome(rendered))
-      fragments.push(rendered.value);
+      baseline.push(rendered.value);
   }
-  return fragments.length === 0 ? Option7.none() : Option7.some(fragments.join(`
+  return baseline.join(`
 
-`));
+`);
 }));
-var layer3 = (sources) => Layer10.succeed(Instructions, Instructions.of({ sources: [...sources] }));
-var testLayer9 = (implementation) => Layer10.succeed(Instructions, Instructions.of(implementation));
+var layer3 = (sources) => Layer11.succeed(Instructions, Instructions.of({ sources: [...sources] }));
+var layerTest9 = (implementation) => Layer11.succeed(Instructions, Instructions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-middleware.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-middleware.js
 var exports_model_middleware = {};
 __export(exports_model_middleware, {
   layerIdentity: () => layerIdentity,
   layer: () => layer4,
-  identityLayer: () => identityLayer,
   ModelMiddleware: () => ModelMiddleware
 });
-import { Context as Context10, Effect as Effect13, Layer as Layer11, Option as Option8 } from "effect";
-import { Prompt as Prompt6, Response as Response4 } from "effect/unstable/ai";
-class ModelMiddleware extends Context10.Service()("@batonfx/core/model-middleware/ModelMiddleware") {
+import { Context as Context11, Effect as Effect14, Layer as Layer12, Option as Option8 } from "effect";
+import { Prompt as Prompt7, Response as Response4 } from "effect/unstable/ai";
+class ModelMiddleware extends Context11.Service()("@batonfx/core/ModelMiddleware") {
 }
-var layerIdentity = Layer11.succeed(ModelMiddleware, []);
-var identityLayer = layerIdentity;
-var layer4 = (middleware) => Layer11.succeed(ModelMiddleware, middleware);
+var layerIdentity = Layer12.succeed(ModelMiddleware, []);
+var layer4 = (middleware) => Layer12.succeed(ModelMiddleware, middleware);
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/model-resilience.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-resilience.js
 var exports_model_resilience = {};
 __export(exports_model_resilience, {
-  testLayer: () => testLayer10,
   none: () => none,
   make: () => make3,
+  layerTest: () => layerTest10,
   layer: () => layer5,
   defaultClassify: () => defaultClassify,
   apply: () => apply,
   ModelResilience: () => ModelResilience
 });
-import { Cause as Cause2, Context as Context11, Effect as Effect14, Function as Function5, Layer as Layer12, Result, Schedule as Schedule2, Schema as Schema10, Stream as Stream3 } from "effect";
-import { AiError as AiError3, LanguageModel as LanguageModel4, Response as Response5, Tool as Tool5 } from "effect/unstable/ai";
+import { Cause as Cause2, Context as Context12, Effect as Effect15, Function as Function5, Layer as Layer13, Result, Schedule as Schedule2, Schema as Schema11, Stream as Stream3 } from "effect";
+import { AiError as AiError3, LanguageModel as LanguageModel5, Response as Response5, Tool as Tool5 } from "effect/unstable/ai";
 
-class ModelResilience extends Context11.Service()("@batonfx/core/model-resilience/ModelResilience") {
+class ModelResilience extends Context12.Service()("@batonfx/core/ModelResilience") {
 }
 var defaultClassify = (error) => AiError3.isAiError(error) && error.isRetryable ? "transient" : "terminal";
 var none = { classify: () => "terminal", retrySchedule: Schedule2.recurs(0) };
@@ -1381,19 +1468,19 @@ var make3 = (input) => ({
   classify: input?.classify ?? defaultClassify,
   retrySchedule: input?.retrySchedule ?? none.retrySchedule
 });
-var layer5 = (input) => Layer12.succeed(ModelResilience, ModelResilience.of(make3(input)));
-var testLayer10 = (implementation) => Layer12.succeed(ModelResilience, ModelResilience.of(implementation));
-var retryEffect = (effect, resilience) => Effect14.suspend(effect).pipe(Effect14.map((value) => Result.succeed(value)), Effect14.catchCause((cause) => {
+var layer5 = (input) => Layer13.succeed(ModelResilience, ModelResilience.of(make3(input)));
+var layerTest10 = (implementation) => Layer13.succeed(ModelResilience, ModelResilience.of(implementation));
+var retryEffect = (effect, resilience) => Effect15.suspend(effect).pipe(Effect15.map((value) => Result.succeed(value)), Effect15.catchCause((cause) => {
   const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-  return reason === undefined || !Cause2.isFailReason(reason) ? Effect14.succeed(Result.fail(cause)) : Effect14.fail(reason.error);
-}), Effect14.retry({
+  return reason === undefined || !Cause2.isFailReason(reason) ? Effect15.succeed(Result.fail(cause)) : Effect15.fail(reason.error);
+}), Effect15.retry({
   schedule: resilience.retrySchedule,
   while: (error) => resilience.classify(error) === "transient"
-}), Effect14.flatMap((result) => Result.isFailure(result) ? Effect14.failCause(result.failure) : Effect14.succeed(result.success)));
+}), Effect15.flatMap((result) => Result.isFailure(result) ? Effect15.failCause(result.failure) : Effect15.succeed(result.success)));
 var retryStreamSchedule = (resilience) => resilience.retrySchedule.pipe(Schedule2.while(({ input }) => resilience.classify(input) === "transient"));
 var retryStream = (stream2, onEmittedFailure, resilience) => Stream3.suspend(() => {
   let emitted = false;
-  return stream2().pipe(Stream3.map((value) => Result.succeed(value)), Stream3.tap(() => Effect14.sync(() => {
+  return stream2().pipe(Stream3.map((value) => Result.succeed(value)), Stream3.tap(() => Effect15.sync(() => {
     emitted = true;
   })), Stream3.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
@@ -1412,34 +1499,34 @@ var apply = Function5.dual(2, (model, resilience) => ({
   streamText: (options) => retryStream(() => model.streamText(options), (error) => Response5.makePart("error", { error }), resilience)
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/permissions.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/permissions.js
 var exports_permissions = {};
 __export(exports_permissions, {
-  testLayer: () => testLayer11,
-  ruleStoreTestLayer: () => ruleStoreTestLayer,
-  ruleStoreMemory: () => ruleStoreMemory,
   matches: () => matches,
   matchRule: () => matchRule,
-  interactive: () => interactive,
-  fromRuleset: () => fromRuleset,
+  layerTest: () => layerTest11,
+  layerRuleset: () => layerRuleset,
+  layerRuleStoreTest: () => layerRuleStoreTest,
+  layerRuleStoreMemory: () => layerRuleStoreMemory,
+  layerAllowAll: () => layerAllowAll,
+  evaluateWithRules: () => evaluateWithRules,
   evaluate: () => evaluate,
-  allowAll: () => allowAll,
   RuleStore: () => RuleStore,
   Permissions: () => Permissions,
   PermissionError: () => PermissionError
 });
-import { Context as Context12, Effect as Effect15, Layer as Layer13, Option as Option9, Ref as Ref4, Schema as Schema11 } from "effect";
+import { Context as Context13, Effect as Effect16, Layer as Layer14, Option as Option9, Ref as Ref4, Schema as Schema12 } from "effect";
 import { dual as dual4 } from "effect/Function";
 
-class PermissionError extends Schema11.TaggedErrorClass()("@batonfx/core/PermissionError", {
-  message: Schema11.String
+class PermissionError extends Schema12.TaggedErrorClass()("@batonfx/core/PermissionError", {
+  message: Schema12.String
 }) {
 }
 
-class Permissions extends Context12.Service()("@batonfx/core/permissions") {
+class Permissions extends Context13.Service()("@batonfx/core/Permissions") {
 }
 
-class RuleStore extends Context12.Service()("@batonfx/core/permissions/RuleStore") {
+class RuleStore extends Context13.Service()("@batonfx/core/RuleStore") {
 }
 var escapeRegExp = (value) => value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 var glob = (pattern) => new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`);
@@ -1514,9 +1601,9 @@ var matchingRule = (ruleset, tool, params) => {
 };
 var matchRule = dual4(3, (ruleset, tool, params) => Option9.fromNullishOr(matchingRule(ruleset, tool, params)));
 var evaluate = dual4(3, (ruleset, tool, params) => matchingRule(ruleset, tool, params)?.level ?? ruleset.fallback ?? "ask");
-var tokenFor = (request) => `permission:${request.toolCallId ?? `${request.agentName}:${request.turn}:${request.tool}`}`;
+var tokenFor = (request) => `permission:${request.call.id}`;
 var decisionFor = (ruleset, request) => {
-  const rule = matchingRule(ruleset, request.tool, request.params);
+  const rule = matchingRule(ruleset, request.call.name, request.call.params);
   const level = rule?.level ?? ruleset.fallback ?? "ask";
   switch (level) {
     case "allow":
@@ -1527,65 +1614,93 @@ var decisionFor = (ruleset, request) => {
       return { _tag: "Ask", token: tokenFor(request) };
   }
 };
-var fromRuleset = (ruleset) => Layer13.succeed(Permissions, Permissions.of({
-  evaluate: (request) => Effect15.succeed(decisionFor(ruleset, request)),
-  await: () => Effect15.succeed(Option9.none())
+var evaluateWithRules = dual4(3, (base, store, request) => Effect16.gen(function* () {
+  const baseDecision = yield* base.evaluate(request);
+  if (baseDecision._tag === "Deny")
+    return baseDecision;
+  const rules = yield* store.rules;
+  const rule = matchingRule({ rules }, request.call.name, request.call.params);
+  if (rule === undefined)
+    return baseDecision;
+  switch (rule.level) {
+    case "allow":
+      return { _tag: "Allow" };
+    case "deny":
+      return { _tag: "Deny", ...rule.reason === undefined ? {} : { reason: rule.reason } };
+    case "ask":
+      return { _tag: "Ask", token: tokenFor(request) };
+  }
 }));
-var allowAll = Layer13.succeed(Permissions, Permissions.of({
-  evaluate: () => Effect15.succeed({ _tag: "Allow" }),
-  await: () => Effect15.succeed(Option9.none())
+var layerRuleset = (ruleset) => Layer14.succeed(Permissions, Permissions.of({
+  evaluate: (request) => Effect16.succeed(decisionFor(ruleset, request))
 }));
-var interactive = (options) => Layer13.succeed(Permissions, Permissions.of({
-  evaluate: (request) => Effect15.succeed(decisionFor(options.ruleset, request)),
-  await: (pending) => options.onAsk(pending).pipe(Effect15.map(Option9.some))
+var layerAllowAll = Layer14.succeed(Permissions, Permissions.of({
+  evaluate: () => Effect16.succeed({ _tag: "Allow" })
 }));
-var ruleStoreMemory = (initialRules = []) => Layer13.effect(RuleStore, Ref4.make(initialRules).pipe(Effect15.map((rules) => RuleStore.of({
+var layerRuleStoreMemory = (initialRules = []) => Layer14.effect(RuleStore, Ref4.make(initialRules).pipe(Effect16.map((rules) => RuleStore.of({
   remember: (rule) => Ref4.update(rules, (current) => [...current.filter((existing) => existing.pattern !== rule.pattern), rule]),
   rules: Ref4.get(rules)
 }))));
-var ruleStoreTestLayer = (implementation) => Layer13.succeed(RuleStore, RuleStore.of(implementation));
-var testLayer11 = (implementation) => Layer13.succeed(Permissions, Permissions.of(implementation));
+var layerRuleStoreTest = (implementation) => Layer14.succeed(RuleStore, RuleStore.of(implementation));
+var layerTest11 = (implementation) => Layer14.succeed(Permissions, Permissions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/skill-source.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/skill-source.js
 var exports_skill_source = {};
 __export(exports_skill_source, {
-  testLayer: () => testLayer12,
   selectListings: () => selectListings,
   merge: () => merge2,
   makeListing: () => makeListing,
+  layerTest: () => layerTest12,
+  layerSkills: () => layerSkills,
+  layerEmpty: () => layerEmpty,
   layer: () => layer6,
-  fromSkills: () => fromSkills,
-  empty: () => empty,
   SkillSourceError: () => SkillSourceError,
   SkillSource: () => SkillSource,
+  Frontmatter: () => Frontmatter,
   DESCRIPTION_CAP: () => DESCRIPTION_CAP
 });
-import { Context as Context13, Effect as Effect16, Function as Function6, Layer as Layer14, Schema as Schema12 } from "effect";
+import { Context as Context14, Effect as Effect17, Function as Function6, Layer as Layer15, Schema as Schema13 } from "effect";
 import { Tool as Tool6 } from "effect/unstable/ai";
-
-class SkillSourceError extends Schema12.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
-  source: Schema12.String,
-  message: Schema12.String,
-  cause: Schema12.optionalKey(Schema12.Defect())
+var DESCRIPTION_CAP = 1024;
+var Frontmatter = Schema13.Struct({
+  name: Schema13.String,
+  description: Schema13.String.pipe(Schema13.check(Schema13.isMinLength(1), Schema13.isMaxLength(DESCRIPTION_CAP))),
+  whenToUse: Schema13.optionalKey(Schema13.String),
+  allowedTools: Schema13.optionalKey(Schema13.Array(Schema13.String)),
+  disableModelInvocation: Schema13.optionalKey(Schema13.Boolean),
+  userInvocable: Schema13.optionalKey(Schema13.Boolean),
+  contextFork: Schema13.optionalKey(Schema13.Boolean),
+  agent: Schema13.optionalKey(Schema13.String),
+  model: Schema13.optionalKey(Schema13.String),
+  paths: Schema13.optionalKey(Schema13.Array(Schema13.String))
+});
+
+class SkillSourceError extends Schema13.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: Schema13.String,
+  message: Schema13.String,
+  cause: Schema13.optionalKey(Schema13.Defect())
 }) {
 }
-var DESCRIPTION_CAP = 1024;
 
-class SkillSource extends Context13.Service()("@batonfx/core/skill-source/SkillSource") {
+class SkillSource extends Context14.Service()("@batonfx/core/SkillSource") {
 }
 var makeListing = Function6.dual((args) => typeof args[0] !== "number", (frontmatter, descriptionCap = DESCRIPTION_CAP) => `- ${frontmatter.name}: ${frontmatter.description.slice(0, Math.max(0, descriptionCap))}`);
-var fromSkills = (skills) => {
+var layerSkills = (skills) => {
   const all = [...skills];
   const byName = new Map(all.map((skill) => [skill.frontmatter.name, skill]));
-  return Layer14.succeed(SkillSource, SkillSource.of({
-    all: Effect16.succeed(all),
-    get: (name) => Effect16.succeed(byName.get(name))
+  return Layer15.succeed(SkillSource, SkillSource.of({
+    all: Effect17.succeed(all),
+    get: (name) => Effect17.succeed(byName.get(name))
   }));
 };
-var empty = fromSkills([]);
-var testLayer12 = (implementation) => Layer14.succeed(SkillSource, SkillSource.of(implementation));
-var merge2 = (sources) => ({
-  all: Effect16.forEach(sources, (source) => source.all).pipe(Effect16.map((groups) => {
+var layerEmpty = layerSkills([]);
+var layerTest12 = (implementation) => Layer15.succeed(SkillSource, SkillSource.of(implementation));
+var emptySource = {
+  all: Effect17.succeed([]),
+  get: () => Effect17.void.pipe(Effect17.as(undefined))
+};
+var merge2 = Function6.dual(2, (first, second) => ({
+  all: Effect17.all([first.all, second.all]).pipe(Effect17.map((groups) => {
     const byName = new Map;
     for (const skills of groups) {
       for (const skill of skills)
@@ -1593,16 +1708,9 @@ var merge2 = (sources) => ({
     }
     return [...byName.values()];
   })),
-  get: (name) => Effect16.gen(function* () {
-    for (const source of sources.toReversed()) {
-      const found = yield* source.get(name);
-      if (found !== undefined)
-        return found;
-    }
-    return;
-  })
-});
-var layer6 = (sources) => Layer14.effect(SkillSource, Effect16.forEach(sources, (source) => source).pipe(Effect16.map((built) => SkillSource.of(merge2(built)))));
+  get: (name) => second.get(name).pipe(Effect17.flatMap((found) => found === undefined ? first.get(name) : Effect17.succeed(found)))
+}));
+var layer6 = (sources) => Layer15.effect(SkillSource, Effect17.forEach(sources, (source) => source).pipe(Effect17.map((built) => SkillSource.of(built.reduce((first, second) => merge2(first, second), emptySource)))));
 var estimatedTokens = (listing) => Math.ceil(listing.length / 4);
 var usageRank = (skill, recentlyUsed) => {
   const index = recentlyUsed.indexOf(skill.frontmatter.name);
@@ -1626,23 +1734,23 @@ var selectListings = Function6.dual(3, (skills, budgetTokens, recentlyUsed) => {
   return selected;
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/steering.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/steering.js
 var exports_steering = {};
 __export(exports_steering, {
-  testLayer: () => testLayer13,
+  layerTest: () => layerTest13,
   layer: () => layer7,
   SteeringQueueFull: () => SteeringQueueFull,
   Steering: () => Steering
 });
-import { Context as Context14, Effect as Effect17, Exit, Layer as Layer15, Queue, Schema as Schema13 } from "effect";
-import { Prompt as Prompt7 } from "effect/unstable/ai";
+import { Context as Context15, Effect as Effect18, Exit, Layer as Layer16, Queue, Schema as Schema14 } from "effect";
+import { Prompt as Prompt8 } from "effect/unstable/ai";
 
-class Steering extends Context14.Service()("@batonfx/core/steering") {
+class Steering extends Context15.Service()("@batonfx/core/Steering") {
 }
 
-class SteeringQueueFull extends Schema13.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
-  queue: Schema13.Literals(["steering", "followUp"]),
-  capacity: Schema13.Finite
+class SteeringQueueFull extends Schema14.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
+  queue: Schema14.Literals(["steering", "followUp"]),
+  capacity: Schema14.Finite
 }) {
 }
 var resolvePolicy = (policy, mode) => ({
@@ -1661,222 +1769,125 @@ var queueStrategy = (strategy2) => {
       return "suspend";
   }
 };
-var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect17.map((queue) => ({ name, queue, policy })));
-var offer = (runtime, message) => Queue.offer(runtime.queue, message).pipe(Effect17.flatMap((offered) => {
+var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect18.map((queue) => ({ name, queue, policy })));
+var offer = (runtime, input) => Queue.offer(runtime.queue, input).pipe(Effect18.flatMap((offered) => {
   if (offered || runtime.policy.capacity === undefined || runtime.policy.onFull !== "fail")
-    return Effect17.void;
+    return Effect18.void;
   return SteeringQueueFull.make({ queue: runtime.name, capacity: runtime.policy.capacity });
 }));
-var drainOne = (queue) => Effect17.sync(() => {
+var drainOne = (queue) => Effect18.sync(() => {
   const taken = Queue.takeUnsafe(queue);
   return taken === undefined || !Exit.isSuccess(taken) ? [] : [taken.value];
 });
 var drain = (queue, mode) => mode === "all" ? Queue.clear(queue) : drainOne(queue);
-var layer7 = (options = {}) => Layer15.effect(Steering, Effect17.gen(function* () {
+var layer7 = (options = {}) => Layer16.effect(Steering, Effect18.gen(function* () {
   const steeringQueue = yield* makeQueue("steering", resolvePolicy(options.steering, "all"));
   const followUpQueue = yield* makeQueue("followUp", resolvePolicy(options.followUp, "one-at-a-time"));
   return Steering.of({
-    steer: (message) => offer(steeringQueue, message),
-    followUp: (message) => offer(followUpQueue, message),
+    steer: (input) => offer(steeringQueue, input),
+    followUp: (input) => offer(followUpQueue, input),
     takeSteering: drain(steeringQueue.queue, steeringQueue.policy.mode),
     takeFollowUp: drain(followUpQueue.queue, followUpQueue.policy.mode)
   });
 }));
-var testLayer13 = (implementation) => Layer15.succeed(Steering, Steering.of(implementation));
+var layerTest13 = (implementation) => Layer16.succeed(Steering, Steering.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent.js
 var exports_agent = {};
 __export(exports_agent, {
   stream: () => stream2,
-  provideModel: () => provideModel,
   make: () => make5,
+  layerRuntime: () => layerRuntime,
   generate: () => generate,
-  defaultObjectPrompt: () => defaultObjectPrompt
+  defaultObjectPrompt: () => defaultObjectPrompt,
+  Runtime: () => Runtime
 });
-import { Effect as Effect22, Layer as Layer17, Option as Option15, Schema as Schema19, Stream as Stream5, Types } from "effect";
-import { dual as dual7 } from "effect/Function";
-import { AiError as AiError5, Chat as Chat3, LanguageModel as LanguageModel6, Prompt as Prompt12, Tool as Tool11, Toolkit as Toolkit5 } from "effect/unstable/ai";
+import { Effect as Effect24, Option as Option14, Schema as Schema20, Stream as Stream5, Types } from "effect";
+import { dual as dual6 } from "effect/Function";
+import { AiError as AiError5, Chat as Chat3, LanguageModel as LanguageModel7, Prompt as Prompt12, Tool as Tool10, Toolkit as Toolkit5 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-run.js
-import { Cause as Cause4, Channel, Effect as Effect21, Equal as Equal2, Exit as Exit2, Fiber, HashMap as HashMap5, Option as Option14, Queue as Queue2, Ref as Ref5, Schema as Schema18, Semaphore as Semaphore3, Stream as Stream4 } from "effect";
-import { AiError as AiError4, Chat as Chat2, LanguageModel as LanguageModel5, Prompt as Prompt11, Response as Response10, Telemetry, Tokenizer as Tokenizer2, Tool as Tool10, Toolkit as Toolkit4 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-run.js
+import { Cause as Cause4, Channel, Effect as Effect23, Equal as Equal2, Exit as Exit2, Fiber as Fiber3, HashMap as HashMap6, Option as Option13, Queue as Queue2, Ref as Ref5, Schema as Schema19, Semaphore as Semaphore3, Stream as Stream4 } from "effect";
+import { AiError as AiError4, Chat as Chat2, LanguageModel as LanguageModel6, Prompt as Prompt11, Response as Response9, Telemetry, Tokenizer as Tokenizer2, Tool as Tool9, Toolkit as Toolkit4 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-authorization.js
-import { Cause as Cause3, Context as Context15, Effect as Effect18, Layer as Layer16, Option as Option10, Schema as Schema14 } from "effect";
-import { dual as dual5 } from "effect/Function";
-import { Prompt as Prompt8, Response as Response6, Tool as Tool7 } from "effect/unstable/ai";
-class PermissionDenied extends Schema14.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
-  message: Schema14.String
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-authorization.js
+import { Cause as Cause3, Context as Context16, Effect as Effect19, Layer as Layer17, Schema as Schema15 } from "effect";
+import"effect/unstable/ai";
+class PermissionDenied extends Schema15.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
+  message: Schema15.String
 }) {
 }
 
-class AuthorizationError extends Schema14.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema14.String, cause: Schema14.optional(Schema14.Defect()) }) {
+class AuthorizationError extends Schema15.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema15.String, cause: Schema15.optional(Schema15.Defect()) }) {
 }
 
-class ToolAuthorizerService extends Context15.Service()("@batonfx/core/tool-authorization/ToolAuthorizerService") {
+class ToolAuthorizerService extends Context16.Service()("@batonfx/core/ToolAuthorizerService") {
 }
-var deny = (message) => ({
-  _tag: "Deny",
-  error: PermissionDenied.make({ message })
-});
-var suspension = (request, token, stage) => ({
+var deny = (message) => ({ _tag: "Deny", error: PermissionDenied.make({ message }) });
+var authorizationError = (error) => AuthorizationError.make({ message: error.message, cause: error });
+var approvalRequired = (request) => {
+  const needsApproval = request.tool?.needsApproval;
+  if (needsApproval === undefined)
+    return Effect19.succeed(false);
+  if (typeof needsApproval === "boolean")
+    return Effect19.succeed(needsApproval);
+  return Effect19.suspend(() => {
+    const result = needsApproval(request.call.params, {
+      toolCallId: request.call.id,
+      messages: request.messages
+    });
+    return Effect19.isEffect(result) ? result : Effect19.succeed(result);
+  }).pipe(Effect19.catchCause((cause) => Cause3.hasInterrupts(cause) ? Effect19.interrupt : Effect19.succeed(true)));
+};
+var suspend = (request, token) => ({
   _tag: "Suspend",
   suspension: AgentSuspended.make({
     token,
     reason: "approval",
-    authorization_stage: stage,
     tool_call_id: request.call.id,
     tool_name: request.call.name,
     tool_params: request.call.params,
-    tool_call_batch: request.execution.toolCallBatch.calls,
+    tool_call_batch: [request.call],
     active_tools: request.activeTools,
     activated_skills: request.activatedSkills
   })
 });
-var authorizationError = (error) => AuthorizationError.make({ message: error.message, cause: error });
-var approvalRequired = (request) => {
-  const needsApproval = request.tool?.needsApproval;
-  if (needsApproval === undefined)
-    return Effect18.succeed(false);
-  if (typeof needsApproval === "boolean")
-    return Effect18.succeed(needsApproval);
-  return Effect18.suspend(() => {
-    const result = needsApproval(request.call.params, {
-      toolCallId: request.call.id,
-      messages: request.messages
-    });
-    return Effect18.isEffect(result) ? result : Effect18.succeed(result);
-  }).pipe(Effect18.catchCause((cause) => Cause3.hasInterrupts(cause) ? Effect18.interrupt : Effect18.succeed(true)));
-};
-var evaluationRequest = (request) => ({
-  tool: request.call.name,
-  params: request.call.params,
-  agentName: request.execution.agentName,
-  turn: request.execution.turn,
-  toolCallId: request.call.id,
-  sessionId: request.execution.sessionId
-});
-var rememberedDecision = (request, ruleStore) => ruleStore?.rules === undefined ? Effect18.succeedNone : ruleStore.rules.pipe(Effect18.map((rules) => {
-  if (rules.length === 0)
-    return Option10.none();
-  const matched = matchRule({ rules }, request.call.name, request.call.params);
-  if (Option10.isNone(matched))
-    return Option10.none();
-  switch (matched.value.level) {
-    case "allow":
-      return Option10.some({ _tag: "Allow" });
-    case "deny":
-      return Option10.some({
-        _tag: "Deny",
-        ...matched.value.reason === undefined ? {} : { reason: matched.value.reason }
-      });
-    case "ask":
-      return Option10.some({ _tag: "Ask", token: `permission:${request.call.id}` });
-  }
-}), Effect18.mapError(authorizationError));
-var resolveRequiredApproval = (request, approvals) => Effect18.gen(function* () {
-  yield* request.onApprovalRequired;
-  if (approvals === undefined)
-    return deny("Approvals service is required for approval-gated tools");
-  const decision2 = yield* approvals.check(request.execution);
-  switch (decision2._tag) {
-    case "Approved":
+var make4 = (options) => ({
+  authorize: (request) => Effect19.gen(function* () {
+    if (!request.active || request.tool === undefined)
+      return deny(`Tool ${request.call.name} is not active for turn ${request.turn}`);
+    const decision2 = yield* evaluateWithRules(options.permissions, options.ruleStore, request).pipe(Effect19.mapError(authorizationError));
+    if (decision2._tag === "Deny")
+      return deny(decision2.reason ?? "Permission denied");
+    const required = decision2._tag === "Ask" || (yield* approvalRequired(request));
+    if (!required)
       return { _tag: "Execute" };
-    case "Denied":
-      return deny(decision2.reason ?? "Tool call denied");
-    case "Pending":
-      return suspension(request, decision2.token, "approval");
-  }
-});
-var finalApproval = (request, approvals) => approvalRequired(request).pipe(Effect18.flatMap((required) => {
-  if (!required)
-    return Effect18.succeed({ _tag: "Execute" });
-  return resolveRequiredApproval(request, approvals);
-}));
-var make4 = (options = {}) => ({
-  authorize: (request) => Effect18.gen(function* () {
-    if (!request.active || request.tool === undefined) {
-      return deny(`Tool ${request.call.name} is not active for turn ${request.execution.turn}`);
-    }
-    if (request.authorizationStage === "approval") {
-      return yield* resolveRequiredApproval(request, options.approvals);
-    }
-    const remembered = yield* rememberedDecision(request, options.ruleStore);
-    if (Option10.isSome(remembered) && remembered.value._tag === "Deny") {
-      return deny(remembered.value.reason ?? "Permission denied");
-    }
-    if (request.authorizationStage === "permission") {
-      const token = request.authorizationToken ?? `permission:${request.call.id}`;
-      if (options.permissions !== undefined) {
-        const current2 = yield* options.permissions.evaluate(evaluationRequest(request)).pipe(Effect18.mapError(authorizationError));
-        if (current2._tag === "Deny")
-          return deny(current2.reason ?? "Permission denied");
-      }
-      yield* request.onApprovalRequired;
-      if (options.permissions === undefined)
-        return suspension(request, token, "permission");
-      const answer2 = yield* options.permissions.await({
-        token,
-        tool: request.call.name,
-        params: request.call.params,
-        agentName: request.execution.agentName,
-        turn: request.execution.turn,
-        toolCallId: request.call.id
-      }).pipe(Effect18.mapError(authorizationError));
-      if (Option10.isNone(answer2))
-        return suspension(request, token, "permission");
-      if (answer2.value._tag === "Denied")
-        return deny(answer2.value.reason ?? "Permission denied");
-      if (answer2.value._tag === "Always" && options.ruleStore !== undefined) {
-        yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect18.mapError(authorizationError));
-      }
-      return yield* finalApproval(request, options.approvals);
-    }
-    if (options.permissions === undefined) {
-      if (Option10.isSome(remembered) && remembered.value._tag === "Ask") {
-        yield* request.onApprovalRequired;
-        return suspension(request, remembered.value.token, "permission");
-      }
-      return yield* finalApproval(request, options.approvals);
-    }
-    const permissions = options.permissions;
-    const current = yield* permissions.evaluate(evaluationRequest(request)).pipe(Effect18.mapError(authorizationError));
-    if (current._tag === "Deny")
-      return deny(current.reason ?? "Permission denied");
-    if (current._tag !== "Ask" || Option10.isSome(remembered) && remembered.value._tag === "Allow") {
-      return yield* finalApproval(request, options.approvals);
-    }
-    const pending = {
-      token: current.token,
-      tool: request.call.name,
-      params: request.call.params,
-      agentName: request.execution.agentName,
-      turn: request.execution.turn,
-      toolCallId: request.call.id
-    };
     yield* request.onApprovalRequired;
-    const answer = yield* permissions.await(pending).pipe(Effect18.mapError(authorizationError));
-    if (Option10.isNone(answer))
-      return suspension(request, current.token, "permission");
-    switch (answer.value._tag) {
-      case "Denied":
-        return deny(answer.value.reason ?? "Permission denied");
-      case "Always":
-        if (options.ruleStore !== undefined) {
-          yield* options.ruleStore.remember({ pattern: request.call.name, level: "allow" }).pipe(Effect18.mapError(authorizationError));
-        }
-        return yield* finalApproval(request, options.approvals);
+    const resolution = yield* options.approvals.resolve({
+      _tag: "Pending",
+      token: decision2._tag === "Ask" ? decision2.token : `approval:${request.call.id}`,
+      call: request.call,
+      agentName: request.agentName,
+      turn: request.turn,
+      ...request.sessionId === undefined ? {} : { sessionId: request.sessionId }
+    });
+    switch (resolution._tag) {
       case "Approved":
-        return yield* finalApproval(request, options.approvals);
+        if (resolution.remember !== undefined)
+          yield* options.ruleStore.remember(resolution.remember).pipe(Effect19.mapError(authorizationError));
+        return { _tag: "Execute" };
+      case "Denied":
+        return deny(resolution.reason ?? "Tool call denied");
+      case "Pending":
+        return suspend(request, resolution.token);
     }
   })
 });
-var fromPermissions = dual5((args) => args.length === 2 || args.length === 1 && ("evaluate" in args[0]), (permissions, options = {}) => make4({ ...options, permissions }));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/tool-registry.js
-import { Effect as Effect19, HashMap as HashMap3, Option as Option11 } from "effect";
-import { dual as dual6 } from "effect/Function";
-import { Tool as Tool8, Toolkit as Toolkit3 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-registry.js
+import { Array as Array2, Effect as Effect20, HashMap as HashMap4, Option as Option10 } from "effect";
+import { dual as dual5 } from "effect/Function";
+import { Tool as Tool7, Toolkit as Toolkit3 } from "effect/unstable/ai";
 var makeToolkit = (entries) => {
   const toolkit = Toolkit3.make(...entries.map((candidate) => candidate.tool));
   for (const entry of entries) {
@@ -1892,89 +1903,71 @@ var makeToolkit = (entries) => {
   return toolkit;
 };
 var assemble = (candidates) => {
-  const grouped = new Map;
-  for (const candidate of candidates) {
-    const existing = grouped.get(candidate.tool.name);
-    if (existing === undefined)
-      grouped.set(candidate.tool.name, [candidate]);
-    else
-      existing.push(candidate);
-  }
+  const grouped = Array2.groupBy(candidates, (candidate) => `tool:${candidate.tool.name}`);
   for (const candidate of candidates) {
-    const conflicts = grouped.get(candidate.tool.name);
+    const conflicts = grouped[`tool:${candidate.tool.name}`];
     if (conflicts !== undefined && conflicts.length > 1) {
-      return Effect19.fail(ToolNameCollision.make({
+      return Effect20.fail(ToolNameCollision.make({
         name: candidate.tool.name,
-        origins: [conflicts[0].origin, ...conflicts.slice(1).map((conflict) => conflict.origin)]
+        origins: Array2.map(conflicts, (conflict) => conflict.origin)
       }));
     }
   }
   const entries = [...candidates];
-  return Effect19.succeed({
+  return Effect20.succeed({
     entries,
-    byName: HashMap3.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
+    byName: HashMap4.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
     toolkit: makeToolkit(entries)
   });
 };
-var get = dual6(2, (registry, name) => Option11.getOrUndefined(HashMap3.get(registry.byName, name)));
-var select = dual6(2, (registry, names) => {
+var get = dual5(2, (registry, name) => Option10.getOrUndefined(HashMap4.get(registry.byName, name)));
+var select = dual5(2, (registry, names) => {
   const entries = registry.entries.filter((entry) => names.includes(entry.tool.name));
   return {
     entries,
-    byName: HashMap3.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
+    byName: HashMap4.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
     toolkit: makeToolkit(entries)
   };
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-persistence-lock.js
-import { Semaphore as Semaphore2 } from "effect";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-persistence-lock.js
+import { Context as Context17, Effect as Effect21, Layer as Layer18, RcMap, Scope as Scope3, Semaphore as Semaphore2 } from "effect";
 import { Chat } from "effect/unstable/ai";
-var persistenceLocks = new WeakMap;
-var reservePersistedChatLock = (persistence, chatId) => {
-  const locks = persistenceLocks.get(persistence) ?? new Map;
-  if (!persistenceLocks.has(persistence))
-    persistenceLocks.set(persistence, locks);
-  const existing = locks.get(chatId);
-  if (existing !== undefined) {
-    existing.users += 1;
-    return existing;
-  }
-  const created = { semaphore: Semaphore2.makeUnsafe(1), users: 1 };
-  locks.set(chatId, created);
-  return created;
-};
-var releasePersistedChatLock = (persistence, chatId, lock) => {
-  lock.users -= 1;
-  if (lock.users !== 0)
-    return;
-  const locks = persistenceLocks.get(persistence);
-  if (locks?.get(chatId) !== lock)
-    return;
-  locks.delete(chatId);
-  if (locks.size === 0)
-    persistenceLocks.delete(persistence);
-};
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-message.js
-import { Effect as Effect20, Option as Option12, Schema as Schema16 } from "effect";
-import { Prompt as Prompt9, Response as Response7 } from "effect/unstable/ai";
+class Runtime extends Context17.Service()("@batonfx/core/Runtime") {
+}
+var makeRuntime = Effect21.gen(function* () {
+  const persistenceLocks = yield* RcMap.make({
+    lookup: (_persistence) => RcMap.make({
+      lookup: (_chatId) => Semaphore2.make(1)
+    })
+  });
+  return Runtime.of({
+    persistenceSemaphore: (persistence, chatId) => RcMap.get(persistenceLocks, persistence).pipe(Effect21.flatMap((chatLocks) => RcMap.get(chatLocks, chatId)))
+  });
+});
+var layerRuntime = Layer18.effect(Runtime, makeRuntime);
+
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-message.js
+import { Effect as Effect22, Option as Option11, Schema as Schema17 } from "effect";
+import { Prompt as Prompt9, Response as Response6 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-skill-tool.js
-import { Schema as Schema15 } from "effect";
-import { Tool as Tool9 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-skill-tool.js
+import { Schema as Schema16 } from "effect";
+import { Tool as Tool8 } from "effect/unstable/ai";
 var skillListingBudgetTokens = 2048;
 var activateSkillToolName = "activate_skill";
-var activateSkillParameters = Schema15.Struct({ name: Schema15.String });
-var activateSkillSuccess = Schema15.Struct({
-  name: Schema15.String,
-  body: Schema15.String,
-  allowedTools: Schema15.Array(Schema15.String)
+var activateSkillParameters = Schema16.Struct({ name: Schema16.String });
+var activateSkillSuccess = Schema16.Struct({
+  name: Schema16.String,
+  body: Schema16.String,
+  allowedTools: Schema16.Array(Schema16.String)
 });
-var activateSkillFailure = Schema15.Struct({
-  reason: Schema15.Literals(["not-found", "not-model-invocable"]),
-  message: Schema15.String
+var activateSkillFailure = Schema16.Struct({
+  reason: Schema16.Literals(["not-found", "not-model-invocable"]),
+  message: Schema16.String
 });
-var activateSkillTool = Tool9.make(activateSkillToolName, {
+var activateSkillTool = Tool8.make(activateSkillToolName, {
   description: "Load the full body for one listed Baton skill by name before applying that skill.",
   parameters: activateSkillParameters,
   success: activateSkillSuccess,
@@ -1982,26 +1975,26 @@ var activateSkillTool = Tool9.make(activateSkillToolName, {
   failureMode: "return"
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-message.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-message.js
 var withSystem = (instructions, prompt) => Prompt9.fromMessages([Prompt9.makeMessage("system", { content: instructions }), ...prompt.content]);
 var skillListingsInstructions = (listings) => `Available skills:
 ${listings}
 
 Call ${activateSkillToolName} with a listed skill name to load its full body before using it.`;
 var recalledMessages = (prompt) => prompt.content.filter(isMessageFromRecall).map(recalledMessageIdentity);
-var messageJsonStringCodec = Schema16.fromJsonString(Schema16.toCodecJson(Prompt9.Message));
-var encodeMessage = Schema16.encodeEffect(messageJsonStringCodec);
-var decodeMessage = Schema16.decodeEffect(messageJsonStringCodec);
-var detachMessage = (message) => encodeMessage(message).pipe(Effect20.flatMap(decodeMessage), Effect20.map((detached) => isMessageFromRecall(message) && message.role === "user" && detached.role === "user" ? replaceRecalledMessage(message, detached.content) : detached));
-var detachPrompt = (prompt) => Effect20.forEach(prompt.content, detachMessage).pipe(Effect20.map(Prompt9.fromMessages));
-var detachEntry = (entry) => entry._tag === "Message" || entry._tag === "Steering" ? detachMessage(entry.message).pipe(Effect20.map((message) => ({ ...entry, message }))) : Effect20.succeed(entry);
+var messageJsonStringCodec = Schema17.fromJsonString(Schema17.toCodecJson(Prompt9.Message));
+var encodeMessage = Schema17.encodeEffect(messageJsonStringCodec);
+var decodeMessage = Schema17.decodeEffect(messageJsonStringCodec);
+var detachMessage = (message) => encodeMessage(message).pipe(Effect22.flatMap(decodeMessage), Effect22.map((detached) => isMessageFromRecall(message) && message.role === "user" && detached.role === "user" ? replaceRecalledMessage(message, detached.content) : detached));
+var detachPrompt = (prompt) => Effect22.forEach(prompt.content, detachMessage).pipe(Effect22.map(Prompt9.fromMessages));
+var detachEntry = (entry) => entry._tag === "Message" || entry._tag === "Steering" ? detachMessage(entry.message).pipe(Effect22.map((message) => ({ ...entry, message }))) : Effect22.succeed(entry);
 var preservesRecalledMessages = (allowed, required, transformed) => {
   const allowedSet = new Set(allowed);
   const transformedMessages = recalledMessages(transformed);
   const transformedSet = new Set(transformedMessages);
   return transformedSet.size === transformedMessages.length && transformedMessages.every((message) => allowedSet.has(message)) && required.every((message) => transformedSet.has(message));
 };
-var applyPromptChain = (chain, prompt, context) => Effect20.gen(function* () {
+var applyPromptChain = (chain, prompt, context) => Effect22.gen(function* () {
   let current = prompt;
   for (const middleware of chain) {
     if (middleware.transformPrompt !== undefined) {
@@ -2018,10 +2011,10 @@ var applyPromptChain = (chain, prompt, context) => Effect20.gen(function* () {
   }
   return current;
 });
-var applyPartChain = (chain, part, context) => Effect20.gen(function* () {
-  let current = Option12.some(part);
+var applyPartChain = (chain, part, context) => Effect22.gen(function* () {
+  let current = Option11.some(part);
   for (const middleware of chain) {
-    if (Option12.isNone(current))
+    if (Option11.isNone(current))
       break;
     if (middleware.transformPart !== undefined) {
       current = yield* middleware.transformPart(current.value, context);
@@ -2030,18 +2023,17 @@ var applyPartChain = (chain, part, context) => Effect20.gen(function* () {
   return current;
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-suspension.js
-import { Equal, Option as Option13, Schema as Schema17 } from "effect";
-import { Prompt as Prompt10, Response as Response8 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-suspension.js
+import { Equal, Option as Option12, Schema as Schema18 } from "effect";
+import { Prompt as Prompt10, Response as Response7 } from "effect/unstable/ai";
 var suspensionCheckpointOption = "@batonfx/core/suspension";
-var suspensionMetadata = Schema17.Struct({
-  token: Schema17.String,
-  reason: Schema17.Literals(["tool-wait", "approval"]),
-  authorization_stage: Schema17.optional(Schema17.Literals(["permission", "approval"])),
-  tool_call_index: Schema17.optional(Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(0))),
-  tool_call_batch_ids: Schema17.Array(Schema17.String),
-  active_tools: Schema17.optional(Schema17.Array(Schema17.String)),
-  activated_skills: Schema17.optional(Schema17.Array(Schema17.String))
+var suspensionMetadata = Schema18.Struct({
+  token: Schema18.String,
+  reason: Schema18.Literals(["tool-wait", "approval"]),
+  tool_call_index: Schema18.optional(Schema18.Int.check(Schema18.isGreaterThanOrEqualTo(0))),
+  tool_call_batch_ids: Schema18.Array(Schema18.String),
+  active_tools: Schema18.optional(Schema18.Array(Schema18.String)),
+  activated_skills: Schema18.optional(Schema18.Array(Schema18.String))
 });
 var unresolvedToolCall = (messages, toolCallId) => {
   const unpaired = new Map;
@@ -2072,36 +2064,51 @@ var unresolvedToolCall = (messages, toolCallId) => {
     }
   }
   const unresolved = [...unpaired.entries()].flatMap(([id, occurrences]) => ambiguous.has(id) ? [] : occurrences.filter(({ call }) => !call.providerExecuted));
-  const pending = toolCallId === undefined ? unresolved.find(({ call }) => Option13.isSome(Schema17.decodeUnknownOption(suspensionMetadata)(call.options[suspensionCheckpointOption]))) : unresolved.find(({ call }) => call.id === toolCallId);
+  const pending = toolCallId === undefined ? unresolved.find(({ call }) => Option12.isSome(Schema18.decodeUnknownOption(suspensionMetadata)(call.options[suspensionCheckpointOption]))) : unresolved.find(({ call }) => call.id === toolCallId);
   const pendingMessage = pending === undefined ? undefined : messages[pending.messageIndex];
+  const unresolvedParts = new Set(unresolved.filter(({ messageIndex }) => messageIndex === pending?.messageIndex).map(({ partIndex }) => partIndex));
   const toolCallBatch = pendingMessage?.role === "assistant" ? pendingMessage.content.flatMap((part) => part.type === "tool-call" && !part.providerExecuted ? [
-    Response8.makePart("tool-call", {
+    Response7.makePart("tool-call", {
       id: part.id,
       name: part.name,
       params: part.params,
       providerExecuted: false
     })
   ] : []) : [];
+  const unresolvedToolCallIndexes = pendingMessage?.role === "assistant" ? (() => {
+    const indexes = [];
+    let toolCallIndex = 0;
+    for (const [partIndex, part] of pendingMessage.content.entries()) {
+      if (part.type !== "tool-call" || part.providerExecuted)
+        continue;
+      if (unresolvedParts.has(partIndex))
+        indexes.push(toolCallIndex);
+      toolCallIndex += 1;
+    }
+    return indexes;
+  })() : [];
   return pending !== undefined ? {
     call: pending.call,
     messages: messages.slice(0, pending.messageIndex),
     messageIndex: pending.messageIndex,
     partIndex: pending.partIndex,
-    toolCallBatch
+    toolCallBatch,
+    unresolvedToolCallIndexes
   } : undefined;
 };
 var suspensionCheckpoint = (messages) => {
   const unresolved = unresolvedToolCall(messages);
   if (unresolved === undefined)
     return;
-  const metadata = Schema17.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
-  if (Option13.isNone(metadata))
+  const metadata = Schema18.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
+  if (Option12.isNone(metadata))
     return;
   if (!Equal.equals(metadata.value.tool_call_batch_ids, unresolved.toolCallBatch.map((call) => call.id)))
     return;
   return {
     call: unresolved.call,
     messages: unresolved.messages,
+    unresolvedToolCallIndexes: unresolved.unresolvedToolCallIndexes,
     suspension: AgentSuspended.make({
       ...metadata.value,
       tool_call_batch: unresolved.toolCallBatch,
@@ -2111,7 +2118,7 @@ var suspensionCheckpoint = (messages) => {
     })
   };
 };
-var sameSuspension = (left, right) => left.token === right.token && left.reason === right.reason && left.authorization_stage === right.authorization_stage && left.tool_call_index === right.tool_call_index && Equal.equals(left.tool_call_batch, right.tool_call_batch) && left.tool_call_id === right.tool_call_id && left.tool_name === right.tool_name && Equal.equals(left.tool_params, right.tool_params) && Equal.equals(left.active_tools, right.active_tools) && Equal.equals(left.activated_skills, right.activated_skills);
+var sameSuspension = (left, right) => left.token === right.token && left.reason === right.reason && left.tool_call_index === right.tool_call_index && Equal.equals(left.tool_call_batch, right.tool_call_batch) && left.tool_call_id === right.tool_call_id && left.tool_name === right.tool_name && Equal.equals(left.tool_params, right.tool_params) && Equal.equals(left.active_tools, right.active_tools) && Equal.equals(left.activated_skills, right.activated_skills);
 var suspended = (call, toolCallBatch, toolCallIndex, token, reason) => AgentSuspended.make({
   token,
   reason,
@@ -2122,10 +2129,10 @@ var suspended = (call, toolCallBatch, toolCallIndex, token, reason) => AgentSusp
   tool_call_batch: toolCallBatch.calls
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-tool-result.js
-import { HashMap as HashMap4 } from "effect";
-import { Response as Response9 } from "effect/unstable/ai";
-var successResult = (call, outcome) => Response9.toolResultPart({
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-tool-result.js
+import { HashMap as HashMap5 } from "effect";
+import { Response as Response8 } from "effect/unstable/ai";
+var successResult = (call, outcome) => Response8.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: false,
@@ -2134,7 +2141,7 @@ var successResult = (call, outcome) => Response9.toolResultPart({
   providerExecuted: false,
   preliminary: false
 });
-var domainFailureResult = (call, outcome) => Response9.toolResultPart({
+var domainFailureResult = (call, outcome) => Response8.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: true,
@@ -2144,19 +2151,18 @@ var domainFailureResult = (call, outcome) => Response9.toolResultPart({
   preliminary: false
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-run.js
-var ModelLayerTypeId = Symbol.for("@batonfx/core/Agent/ModelLayer");
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-run.js
 var classifyOtherFailure = () => "other";
 var defaultProgressOverflowPolicy = { _tag: "Backpressure", capacity: 64 };
-var progressCapacitySchema = Schema18.Finite.pipe(Schema18.check(Schema18.isInt(), Schema18.isGreaterThan(0)));
-var progressOverflowPolicySchema = Schema18.Union([
-  Schema18.TaggedStruct("Backpressure", { capacity: progressCapacitySchema }),
-  Schema18.TaggedStruct("Dropping", { capacity: progressCapacitySchema }),
-  Schema18.TaggedStruct("Sliding", { capacity: progressCapacitySchema }),
-  Schema18.TaggedStruct("Fail", { capacity: progressCapacitySchema })
+var progressCapacitySchema = Schema19.Finite.pipe(Schema19.check(Schema19.isInt(), Schema19.isGreaterThan(0)));
+var progressOverflowPolicySchema = Schema19.Union([
+  Schema19.TaggedStruct("Backpressure", { capacity: progressCapacitySchema }),
+  Schema19.TaggedStruct("Dropping", { capacity: progressCapacitySchema }),
+  Schema19.TaggedStruct("Sliding", { capacity: progressCapacitySchema }),
+  Schema19.TaggedStruct("Fail", { capacity: progressCapacitySchema })
 ]);
 var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-var isToolNameCollision = Schema18.is(ToolNameCollision);
+var isToolNameCollision = Schema19.is(ToolNameCollision);
 var appendInstructionFragment = (base, fragment) => {
   if (fragment === undefined || fragment.length === 0)
     return base;
@@ -2171,15 +2177,15 @@ var isTurnPolicyDecision = (input) => {
     return false;
   if (input._tag === "Continue")
     return true;
-  return input._tag === "Stop" && "reason" in input && Schema18.is(StopReason)(input.reason);
+  return input._tag === "Stop" && "reason" in input && Schema19.is(StopReason)(input.reason);
 };
-var steeringDrainedEvent = (turn, queue, messages) => ({
+var steeringDrainedEvent = (turn, queue, inputs) => ({
   _tag: "SteeringDrained",
   turn,
   queue,
-  count: messages.length
+  count: inputs.length
 });
-var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen(function* () {
+var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen(function* () {
   if (options.history !== undefined && options.persistence !== undefined) {
     return yield* AgentError.make({
       message: "RunOptions.history and RunOptions.persistence are mutually exclusive",
@@ -2188,39 +2194,47 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
   }
   const persistenceOptions = options.persistence;
   const resume = options.resume;
-  const persistenceService = yield* Effect21.serviceOption(Chat2.Persistence);
-  const compactionService = yield* Effect21.serviceOption(Compaction);
-  const sessionService = yield* Effect21.serviceOption(SessionStore);
-  const persisted = persistenceOptions === undefined ? undefined : yield* Option14.match(persistenceService, {
-    onNone: () => Effect21.fail(AgentError.make({
+  const persistenceService = yield* Effect23.serviceOption(Chat2.Persistence);
+  const runtimeService = yield* Effect23.serviceOption(Runtime);
+  const compactionService = yield* Effect23.serviceOption(Compaction);
+  const sessionService = yield* Effect23.serviceOption(SessionStore);
+  const persisted = persistenceOptions === undefined ? undefined : yield* Option13.match(persistenceService, {
+    onNone: () => Effect23.fail(AgentError.make({
       message: "RunOptions.persistence requires Chat.Persistence in context",
       turn: 0
     })),
-    onSome: (service) => Effect21.gen(function* () {
-      const lock = yield* Effect21.acquireRelease(Effect21.sync(() => reservePersistedChatLock(service, persistenceOptions.chatId)), (reserved) => Effect21.sync(() => releasePersistedChatLock(service, persistenceOptions.chatId, reserved)));
-      yield* Effect21.acquireRelease(lock.semaphore.take(1), () => lock.semaphore.release(1), {
+    onSome: (service) => Effect23.gen(function* () {
+      const runtime = yield* Option13.match(runtimeService, {
+        onNone: () => Effect23.fail(AgentError.make({
+          message: "RunOptions.persistence requires Agent.Runtime in context",
+          turn: 0
+        })),
+        onSome: Effect23.succeed
+      });
+      const semaphore = yield* runtime.persistenceSemaphore(service, persistenceOptions.chatId);
+      yield* Effect23.acquireRelease(semaphore.take(1), () => semaphore.release(1), {
         interruptible: true
       });
       const getOptions = persistenceOptions.timeToLive === undefined ? undefined : { timeToLive: persistenceOptions.timeToLive };
-      return yield* resume === undefined ? service.getOrCreate(persistenceOptions.chatId, getOptions).pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error }))) : service.get(persistenceOptions.chatId, getOptions).pipe(Effect21.mapError((error) => error._tag === "ChatNotFoundError" ? ResumeMismatch.make({
+      return yield* resume === undefined ? service.getOrCreate(persistenceOptions.chatId, getOptions).pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error }))) : service.get(persistenceOptions.chatId, getOptions).pipe(Effect23.mapError((error) => error._tag === "ChatNotFoundError" ? ResumeMismatch.make({
         reason: "checkpoint-not-found",
         received: resume.suspension
       }) : AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
     })
   });
   let recoveredHistory;
-  if (resume !== undefined && persisted !== undefined && Option14.isSome(compactionService) && Option14.isSome(sessionService)) {
-    yield* Effect21.gen(function* () {
+  if (resume !== undefined && persisted !== undefined && Option13.isSome(compactionService) && Option13.isSome(sessionService)) {
+    yield* Effect23.gen(function* () {
       const path = yield* sessionService.value.path();
       const checkpoint = path.at(-1);
       if (checkpoint?._tag !== "Compaction" || checkpoint.version !== 2)
         return;
       const history = yield* Ref5.get(persisted.history);
       const before = buildContext(path.slice(0, -1));
-      if (!Schema18.toEquivalence(Prompt11.Prompt)(before, history))
+      if (!Schema19.toEquivalence(Prompt11.Prompt)(before, history))
         return;
       recoveredHistory = buildContext(path);
-    }).pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+    }).pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
   }
   let resumeChat;
   let validatedResume;
@@ -2228,12 +2242,12 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     resumeChat = persisted ?? (yield* options.history === undefined ? Chat2.empty : Chat2.fromPrompt(options.history));
     const received = resume.suspension;
     const resumeHistory = recoveredHistory ?? (yield* Ref5.get(resumeChat.history));
-    validatedResume = yield* Effect21.succeed(resumeHistory).pipe(Effect21.flatMap((history) => {
+    validatedResume = yield* Effect23.succeed(resumeHistory).pipe(Effect23.flatMap((history) => {
       const expected = suspensionCheckpoint(history.content);
       if (expected === undefined) {
         return ResumeMismatch.make({ reason: "checkpoint-not-found", received });
       }
-      return sameSuspension(expected.suspension, received) ? Effect21.succeed(expected) : ResumeMismatch.make({
+      return sameSuspension(expected.suspension, received) ? Effect23.succeed(expected) : ResumeMismatch.make({
         reason: "identity-mismatch",
         expected: expected.suspension,
         received
@@ -2241,7 +2255,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     }));
     if (recoveredHistory !== undefined && persisted !== undefined) {
       yield* Ref5.set(persisted.history, recoveredHistory);
-      yield* persisted.save.pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+      yield* persisted.save.pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
     }
   }
   const staticCandidates = (agent.toolDeclarations ?? Object.values(agent.toolkit.tools).map((tool) => ({
@@ -2260,17 +2274,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       turn: 0
     });
   }
-  const executor = yield* Effect21.serviceOption(ToolExecutor);
-  const approvals = yield* Effect21.serviceOption(Approvals);
-  const chain = yield* Effect21.serviceOption(ModelMiddleware).pipe(Effect21.map(Option14.match({ onNone: () => [], onSome: (service) => service })));
+  const executor = yield* Effect23.serviceOption(ToolExecutor);
+  const approvals = yield* Effect23.serviceOption(Approvals);
+  const chain = yield* Effect23.serviceOption(ModelMiddleware).pipe(Effect23.map(Option13.match({ onNone: () => [], onSome: (service) => service })));
   if (options.toolOutputMaxBytes !== undefined && (!Number.isFinite(options.toolOutputMaxBytes) || options.toolOutputMaxBytes < 0)) {
     return yield* AgentError.make({
       message: "RunOptions.toolOutputMaxBytes must be a non-negative finite number",
       turn: 0
     });
   }
-  const decodedProgressPolicy = Schema18.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
-  if (Option14.isNone(decodedProgressPolicy)) {
+  const decodedProgressPolicy = Schema19.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
+  if (Option13.isNone(decodedProgressPolicy)) {
     return yield* AgentError.make({
       message: "RunOptions.toolProgress must select a supported policy with a positive safe-integer capacity",
       turn: 0
@@ -2290,11 +2304,13 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     });
   }
   const sessionId = options.sessionId ?? "local";
-  const instructionsService = yield* Effect21.serviceOption(Instructions);
-  const skillSourceService = yield* Effect21.serviceOption(SkillSource);
-  const skillRuntime = Option14.isNone(skillSourceService) ? undefined : {
+  const sessionOwnerToken = options.sessionOwnerToken;
+  const sessionAppendOptions = (expectedLeafId) => sessionOwnerToken === undefined ? { expectedLeafId } : { expectedLeafId, ownerToken: sessionOwnerToken };
+  const instructionsService = yield* Effect23.serviceOption(Instructions);
+  const skillSourceService = yield* Effect23.serviceOption(SkillSource);
+  const skillRuntime = Option13.isNone(skillSourceService) ? undefined : {
     source: skillSourceService.value,
-    skills: yield* skillSourceService.value.all.pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn: 0, cause: error })))
+    skills: yield* skillSourceService.value.all.pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn: 0, cause: error })))
   };
   const selectedSkills = skillRuntime === undefined ? [] : selectListings(skillRuntime.skills, skillListingBudgetTokens, []);
   const skillListings = selectedSkills.map((skill) => skill.listing).join(`
@@ -2310,75 +2326,90 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       }
     ] : []
   ]);
-  const instructionsEpoch = options.system === undefined && options.history === undefined && Option14.isSome(instructionsService) ? yield* openEpoch(instructionsService.value, { agentName: agent.name, turn: 0 }) : undefined;
-  const baseSystem = options.system ?? (instructionsEpoch === undefined ? agent.instructions : instructionsEpoch.baseline.length === 0 ? agent.instructions : instructionsEpoch.baseline);
+  const instructionsEpoch = options.system === undefined && options.history === undefined && Option13.isSome(instructionsService) ? yield* openEpoch(instructionsService.value, { agentName: agent.name, turn: 0 }) : undefined;
+  const baseSystem = options.system ?? (instructionsEpoch === undefined ? agent.instructions : instructionsEpoch.length === 0 ? agent.instructions : instructionsEpoch);
   const system = appendInstructionFragment(baseSystem, options.history === undefined && skillListings.length > 0 ? skillListingsInstructions(skillListings) : undefined);
-  const resilienceService = yield* Effect21.serviceOption(ModelResilience);
-  const modelRegistryService = yield* Effect21.serviceOption(Service);
-  const permissionsService = yield* Effect21.serviceOption(Permissions);
-  const ruleStoreService = yield* Effect21.serviceOption(RuleStore);
-  const authorizationService = yield* Effect21.serviceOption(ToolAuthorizerService);
-  const steeringService = yield* Effect21.serviceOption(Steering);
-  const memoryService = yield* Effect21.serviceOption(Memory);
-  const tokenizerService = yield* Effect21.serviceOption(Tokenizer2.Tokenizer);
-  const authorizer = agent.authorization ?? Option14.getOrElse(authorizationService, () => make4({
-    ...Option14.isNone(permissionsService) ? {} : { permissions: permissionsService.value },
-    ...Option14.isNone(approvals) ? {} : { approvals: approvals.value },
-    ...Option14.isNone(ruleStoreService) ? {} : { ruleStore: ruleStoreService.value }
+  const resilienceService = yield* Effect23.serviceOption(ModelResilience);
+  const modelRegistryService = yield* Effect23.serviceOption(ModelRegistry);
+  const permissionsService = yield* Effect23.serviceOption(Permissions);
+  const ruleStoreService = yield* Effect23.serviceOption(RuleStore);
+  const authorizationService = yield* Effect23.serviceOption(ToolAuthorizerService);
+  const steeringService = yield* Effect23.serviceOption(Steering);
+  const memoryService = yield* Effect23.serviceOption(Memory);
+  const tokenizerService = yield* Effect23.serviceOption(Tokenizer2.Tokenizer);
+  const defaultRules = yield* Ref5.make([]);
+  const authorizer = agent.authorization ?? Option13.getOrElse(authorizationService, () => make4({
+    permissions: Option13.getOrElse(permissionsService, () => Permissions.of({ evaluate: () => Effect23.succeed({ _tag: "Allow" }) })),
+    approvals: Option13.getOrElse(approvals, () => Approvals.of({ resolve: () => Effect23.succeed({ _tag: "Approved" }) })),
+    ruleStore: Option13.getOrElse(ruleStoreService, () => RuleStore.of({
+      rules: Ref5.get(defaultRules),
+      remember: (rule) => Ref5.update(defaultRules, (rules) => [
+        ...rules.filter((current) => current.pattern !== rule.pattern),
+        rule
+      ])
+    }))
   }));
   const memoryOptions = options.memory ?? (agent.memory === undefined ? undefined : { key: agent.memory });
   const agentModel = agent.model;
-  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option14.match(modelRegistryService, {
-    onNone: () => Effect21.fail(AgentError.make({
+  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option13.match(modelRegistryService, {
+    onNone: () => Effect23.fail(AgentError.make({
       message: "Agent.model requires ModelRegistry in context",
       turn: 0
     })),
-    onSome: Effect21.succeed
+    onSome: Effect23.succeed
   });
   const memoryRuntime = memoryOptions === undefined ? undefined : {
     key: memoryOptions.key,
-    service: yield* Option14.match(memoryService, {
-      onNone: () => Effect21.fail(AgentError.make({
+    service: yield* Option13.match(memoryService, {
+      onNone: () => Effect23.fail(AgentError.make({
         message: options.memory === undefined ? "Agent.memory requires Memory in context" : "RunOptions.memory requires Memory in context",
         turn: 0
       })),
-      onSome: Effect21.succeed
+      onSome: Effect23.succeed
     })
   };
   const seedSystem = persisted !== undefined && system !== undefined && (yield* Ref5.get(persisted.history)).content.length === 0 ? system : undefined;
   const freshChat = options.history !== undefined ? Chat2.fromPrompt(options.history) : system !== undefined ? Chat2.fromPrompt([Prompt11.makeMessage("system", { content: system })]) : Chat2.empty;
   const chat = resumeChat ?? persisted ?? (yield* freshChat);
-  const savePersisted = (turn) => persisted === undefined ? Effect21.void : persisted.save.pipe(Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })));
-  const appendPending = (turn, pending) => pending.length === 0 ? Ref5.get(chat.history) : Ref5.updateAndGet(chat.history, (history) => Prompt11.concat(history, Prompt11.fromResponseParts(pending))).pipe(Effect21.tap(() => savePersisted(turn)));
-  const checkpointSuspended = (turn, pending, suspension2) => Effect21.gen(function* () {
+  const savePersisted = (turn) => persisted === undefined ? Effect23.void : persisted.save.pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })));
+  const appendPending = (turn, pending) => pending.length === 0 ? Ref5.get(chat.history) : Ref5.updateAndGet(chat.history, (history) => Prompt11.concat(history, Prompt11.fromResponseParts(pending))).pipe(Effect23.tap(() => savePersisted(turn)));
+  const checkpointSuspended = (turn, pending, suspension) => Effect23.gen(function* () {
     const withPending = yield* appendPending(turn, pending);
-    const unresolved = unresolvedToolCall(withPending.content, suspension2.tool_call_id);
-    if (unresolved === undefined || unresolved.call.id !== suspension2.tool_call_id || unresolved.call.name !== suspension2.tool_name || !Equal2.equals(unresolved.call.params, suspension2.tool_params)) {
+    const unresolved = unresolvedToolCall(withPending.content, suspension.tool_call_id);
+    if (unresolved === undefined || unresolved.call.id !== suspension.tool_call_id || unresolved.call.name !== suspension.tool_name || !Equal2.equals(unresolved.call.params, suspension.tool_params)) {
       return yield* AgentError.make({
         message: "Suspension does not match the unresolved checkpoint call",
         turn
       });
     }
     const metadata = {
-      token: suspension2.token,
-      reason: suspension2.reason,
-      ...suspension2.authorization_stage === undefined ? {} : { authorization_stage: suspension2.authorization_stage },
-      ...suspension2.tool_call_index === undefined ? {} : { tool_call_index: suspension2.tool_call_index },
-      tool_call_batch_ids: suspension2.tool_call_batch.map((call) => call.id),
-      ...suspension2.active_tools === undefined ? {} : { active_tools: suspension2.active_tools },
-      ...suspension2.activated_skills === undefined ? {} : { activated_skills: suspension2.activated_skills }
+      token: suspension.token,
+      reason: suspension.reason,
+      ...suspension.tool_call_index === undefined ? {} : { tool_call_index: suspension.tool_call_index },
+      tool_call_batch_ids: suspension.tool_call_batch.map((call) => call.id),
+      ...suspension.active_tools === undefined ? {} : { active_tools: suspension.active_tools },
+      ...suspension.activated_skills === undefined ? {} : { activated_skills: suspension.activated_skills }
     };
     const messages = withPending.content.map((message, messageIndex) => {
-      if (messageIndex !== unresolved.messageIndex || message.role !== "assistant")
+      if (message.role !== "assistant")
         return message;
       return Prompt11.makeMessage("assistant", {
-        content: message.content.map((part, partIndex) => partIndex === unresolved.partIndex && part.type === "tool-call" ? Prompt11.makePart("tool-call", {
-          id: part.id,
-          name: part.name,
-          params: part.params,
-          providerExecuted: part.providerExecuted,
-          options: { ...part.options, [suspensionCheckpointOption]: metadata }
-        }) : part),
+        content: message.content.map((part, partIndex) => {
+          if (part.type !== "tool-call")
+            return part;
+          const partOptions = { ...part.options };
+          delete partOptions[suspensionCheckpointOption];
+          if (messageIndex === unresolved.messageIndex && partIndex === unresolved.partIndex) {
+            partOptions[suspensionCheckpointOption] = metadata;
+          }
+          return Prompt11.makePart("tool-call", {
+            id: part.id,
+            name: part.name,
+            params: part.params,
+            providerExecuted: part.providerExecuted,
+            options: partOptions
+          });
+        }),
         options: message.options
       });
     });
@@ -2386,32 +2417,32 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     const path = yield* syncSession(turn, withPending);
     const parentId = path.at(-1)?.id ?? null;
     yield* applyCompactionResult(turn, { _tag: "Microcompact", history: checkpoint, prompt: Prompt11.empty }, parentId);
-    if (Option14.isNone(activeSession))
+    if (Option13.isNone(activeSession))
       yield* savePersisted(turn);
     return yield* Ref5.get(chat.history);
   });
-  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect21.tap((checkpoint) => syncSession(turn, checkpoint)));
-  const failSuspended = (call, toolCallBatch, toolCallIndex, token, reason) => Stream4.fail(suspended(call, toolCallBatch, toolCallIndex, token, reason));
+  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect23.tap((checkpoint) => syncSession(turn, checkpoint)));
   const state = {
     text: "",
     turn: 0,
-    pending: [],
+    pending: new Map,
     finish: undefined,
     usage: undefined
   };
+  const pendingResults = () => [...state.pending.entries()].toSorted(([left], [right]) => left - right).map(([, result]) => result);
   const toolState = yield* Ref5.make({
     registry: initialRegistry,
     activatedSkillBodies: new Map
   });
-  const restoreActivatedSkills = (history) => Effect21.gen(function* () {
+  const restoreActivatedSkills = (history) => Effect23.gen(function* () {
     for (const message of history.content) {
       if (!Array.isArray(message.content))
         continue;
       for (const part of message.content) {
         if (String(part.type) !== "tool-result" || String(part.name) !== activateSkillToolName || part.isFailure === true)
           continue;
-        const activation = Schema18.decodeUnknownOption(activateSkillSuccess)(part.result);
-        if (Option14.isNone(activation))
+        const activation = Schema19.decodeUnknownOption(activateSkillSuccess)(part.result);
+        if (Option13.isNone(activation))
           continue;
         if (skillRuntime === undefined) {
           return yield* AgentError.make({
@@ -2442,10 +2473,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         yield* Ref5.set(toolState, { registry, activatedSkillBodies });
       }
     }
-  }).pipe(Effect21.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
+  }).pipe(Effect23.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
   if (validatedResume !== undefined)
-    yield* Ref5.get(chat.history).pipe(Effect21.flatMap(restoreActivatedSkills));
-  const activeSession = Option14.isSome(compactionService) ? sessionService : Option14.none();
+    yield* Ref5.get(chat.history).pipe(Effect23.flatMap(restoreActivatedSkills));
+  const activeSession = Option13.isSome(compactionService) ? sessionService : Option13.none();
   const sessionError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
   const compactionError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
   const memoryError = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
@@ -2459,33 +2490,33 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     const [first, ...rest] = prompt.content;
     return first?.role === "system" ? Prompt11.fromMessages([first, memoryMessage2, ...rest]) : Prompt11.fromMessages([memoryMessage2, ...prompt.content]);
   };
-  const recallInitialPrompt = (prompt) => memoryRuntime === undefined ? Effect21.succeed(prompt) : memoryRuntime.service.recall({ key: memoryRuntime.key, turn: 0, prompt }).pipe(Effect21.mapError((error) => memoryError(0, error)), Effect21.map((items) => insertRecalledItems(prompt, items)));
-  const rememberTurn = (turn, transcript, terminal, path) => memoryRuntime === undefined ? Effect21.void : memoryRuntime.service.remember({
+  const recallInitialPrompt = (prompt) => memoryRuntime === undefined ? Effect23.succeed(prompt) : memoryRuntime.service.recall({ key: memoryRuntime.key, turn: 0, prompt }).pipe(Effect23.mapError((error) => memoryError(0, error)), Effect23.map((items) => insertRecalledItems(prompt, items)));
+  const rememberTurn = (turn, transcript, terminal, path) => memoryRuntime === undefined ? Effect23.void : memoryRuntime.service.remember({
     key: memoryRuntime.key,
     turn,
-    transcript: Option14.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
+    transcript: Option13.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
     terminal
-  }).pipe(Effect21.mapError((error) => memoryError(turn, error)));
-  const messageEquivalence = Schema18.toEquivalence(Prompt11.Message);
-  const promptEquivalence2 = Schema18.toEquivalence(Prompt11.Prompt);
+  }).pipe(Effect23.mapError((error) => memoryError(turn, error)));
+  const messageEquivalence = Schema19.toEquivalence(Prompt11.Message);
+  const promptEquivalence2 = Schema19.toEquivalence(Prompt11.Prompt);
   const sessionTranscriptCursor = (projection, transcript) => {
     if (projection.length === 0)
-      return Option14.some(0);
+      return Option13.some(0);
     const matches2 = [];
     for (let start = 0;start <= transcript.length - projection.length; start += 1) {
       if (transcript.slice(0, start).every((message) => message.role === "system") && projection.every((message, index) => messageEquivalence(message, transcript[start + index]))) {
         matches2.push(start + projection.length);
       }
     }
-    return matches2.length === 1 ? Option14.some(matches2[0]) : Option14.none();
+    return matches2.length === 1 ? Option13.some(matches2[0]) : Option13.none();
   };
-  const syncSession = (turn, transcript) => Option14.match(activeSession, {
-    onNone: () => Effect21.succeed([]),
-    onSome: (session) => Effect21.gen(function* () {
+  const syncSession = (turn, transcript) => Option13.match(activeSession, {
+    onNone: () => Effect23.succeed([]),
+    onSome: (session) => Effect23.gen(function* () {
       let path = yield* session.path();
       const projection = buildContext(path);
       const cursor = sessionTranscriptCursor(projection.content, transcript.content);
-      if (Option14.isNone(cursor)) {
+      if (Option13.isNone(cursor)) {
         const checkpoint = path.at(-1);
         const before = buildContext(path.slice(0, -1));
         if (checkpoint?._tag === "Compaction" && checkpoint.version === 2 && promptEquivalence2(before, transcript)) {
@@ -2495,24 +2526,31 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         }
         return yield* AgentError.make({
           message: "Session projection is not a prefix of authoritative Chat history",
-          turn
+          turn,
+          diagnostics: diagnose({
+            sessionId,
+            ...sessionOwnerToken === undefined ? {} : { ownerToken: sessionOwnerToken },
+            durableEntryTags: path.map((entry) => entry._tag),
+            projection: projection.content,
+            transcript: transcript.content
+          })
         });
       }
       let expectedLeafId = path.at(-1)?.id ?? null;
       for (const message of transcript.content.slice(cursor.value)) {
-        const appended = yield* session.append({ _tag: "Message", message }, { expectedLeafId });
+        const appended = yield* session.append({ _tag: "Message", message }, sessionAppendOptions(expectedLeafId));
         expectedLeafId = appended.id;
       }
       if (expectedLeafId !== (path.at(-1)?.id ?? null))
         path = yield* session.path();
       return path;
-    }).pipe(Effect21.mapError((error) => Schema18.is(AgentError)(error) ? error : sessionError(turn, error)))
+    }).pipe(Effect23.mapError((error) => Schema19.is(AgentError)(error) ? error : sessionError(turn, error)))
   });
-  const countTokens = (turn, prompt) => Option14.match(tokenizerService, {
-    onNone: () => Effect21.succeed(Math.ceil(JSON.stringify(prompt.content).length / 4)),
-    onSome: (tokenizer) => tokenizer.tokenize(prompt).pipe(Effect21.map((tokens) => tokens.length), Effect21.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })))
+  const countTokens = (turn, prompt) => Option13.match(tokenizerService, {
+    onNone: () => Effect23.succeed(Math.ceil(JSON.stringify(prompt.content).length / 4)),
+    onSome: (tokenizer) => tokenizer.tokenize(prompt).pipe(Effect23.map((tokens) => tokens.length), Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })))
   });
-  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt11.concat(history, prompt)).pipe(Effect21.map((contextTokens) => ({
+  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt11.concat(history, prompt)).pipe(Effect23.map((contextTokens) => ({
     contextTokens,
     contextWindow: options.compaction?.contextWindow ?? Number.POSITIVE_INFINITY,
     reserveTokens: DEFAULT_RESERVE_TOKENS
@@ -2523,14 +2561,14 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     for (const message of Prompt11.concat(result.history, result.prompt).content) {
       if (typeof message.content === "string") {
         if (pending.size > 0) {
-          return Effect21.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+          return Effect23.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
         }
         optional.clear();
         continue;
       }
       const hasResult = message.content.some((part) => part.type === "tool-result");
       if (pending.size > 0 && !hasResult) {
-        return Effect21.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+        return Effect23.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
       }
       if (!hasResult)
         optional.clear();
@@ -2538,7 +2576,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       for (const part of message.content) {
         if (part.type === "tool-call") {
           if (responseCalls.has(part.id)) {
-            return Effect21.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
+            return Effect23.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
           }
           responseCalls.add(part.id);
           if (part.providerExecuted)
@@ -2548,38 +2586,39 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         }
         if (part.type === "tool-result") {
           if (!pending.delete(part.id) && !optional.delete(part.id)) {
-            return Effect21.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
+            return Effect23.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
           }
         }
       }
     }
-    return pending.size === 0 ? Effect21.void : Effect21.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
+    return pending.size === 0 ? Effect23.void : Effect23.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
   };
-  const applyCompactionResult = (turn, result, parentId) => Option14.match(activeSession, {
+  const applyCompactionResult = (turn, result, parentId) => Option13.match(activeSession, {
     onNone: () => Ref5.set(chat.history, result.history),
-    onSome: (session) => Effect21.gen(function* () {
+    onSome: (session) => Effect23.gen(function* () {
       const id = yield* session.reserveEntryId;
-      yield* Effect21.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
+      yield* Effect23.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
         id,
         parentId,
         projectedHistory: result.history,
-        ...result._tag === "Summarize" ? { summary: result.summary } : {}
-      })).pipe(Effect21.flatMap((appended) => restore(session.path(appended.leafId))), Effect21.map(buildContext), Effect21.tap((projection) => Ref5.set(chat.history, projection)), Effect21.andThen(restore(savePersisted(turn)))));
-    }).pipe(Effect21.mapError((error) => Schema18.is(AgentError)(error) ? error : sessionError(turn, error)))
+        ...result._tag === "Summarize" ? { summary: result.summary } : {},
+        ...sessionOwnerToken === undefined ? {} : { ownerToken: sessionOwnerToken }
+      })).pipe(Effect23.flatMap((appended) => restore(session.path(appended.leafId))), Effect23.map(buildContext), Effect23.tap((projection) => Ref5.set(chat.history, projection)), Effect23.andThen(restore(savePersisted(turn)))));
+    }).pipe(Effect23.mapError((error) => Schema19.is(AgentError)(error) ? error : sessionError(turn, error)))
   });
-  const preparePrompt = (turn, prompt, overflow) => Option14.match(compactionService, {
-    onNone: () => Effect21.succeed({ prompt, changed: false }),
-    onSome: (compaction) => Effect21.gen(function* () {
+  const preparePrompt = (turn, prompt, overflow) => Option13.match(compactionService, {
+    onNone: () => Effect23.succeed({ prompt, changed: false }),
+    onSome: (compaction) => Effect23.gen(function* () {
       const history = yield* Ref5.get(chat.history);
       const path = yield* syncSession(turn, history);
       const usage = yield* compactionUsage(turn, history, prompt);
       const historyRecalled = recalledMessages(history);
       const promptRecalled = recalledMessages(prompt);
-      const detachedHistory = yield* detachPrompt(history).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const detachedPrompt = yield* detachPrompt(prompt).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const originalHistory = yield* detachPrompt(detachedHistory).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const originalPrompt = yield* detachPrompt(detachedPrompt).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
-      const detachedPath = yield* Effect21.forEach(path, detachEntry).pipe(Effect21.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedHistory = yield* detachPrompt(history).pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPrompt = yield* detachPrompt(prompt).pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalHistory = yield* detachPrompt(detachedHistory).pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalPrompt = yield* detachPrompt(detachedPrompt).pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPath = yield* Effect23.forEach(path, detachEntry).pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
       const compacted = yield* compaction.maybeCompact({
         agentName: agent.name,
         sessionId,
@@ -2590,14 +2629,14 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         usage,
         overflow,
         ...options.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: options.toolOutputMaxBytes }
-      }).pipe(Effect21.mapError((error) => compactionError(turn, error)));
-      if (Option14.isNone(compacted))
+      }).pipe(Effect23.mapError((error) => compactionError(turn, error)));
+      if (Option13.isNone(compacted))
         return { prompt, changed: false };
       const changed = !Equal2.equals(originalHistory.content, compacted.value.history.content) || !Equal2.equals(originalPrompt.content, compacted.value.prompt.content);
       if (!changed)
         return { prompt, changed: false };
       const allowed = [...historyRecalled, ...promptRecalled];
-      const required = Option14.isSome(activeSession) ? promptRecalled : allowed;
+      const required = Option13.isSome(activeSession) ? promptRecalled : allowed;
       if (!preservesRecalledMessages(allowed, required, Prompt11.concat(compacted.value.history, compacted.value.prompt))) {
         return yield* MiddlewareViolation.make({
           turn,
@@ -2609,18 +2648,20 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       return { prompt: compacted.value.prompt, changed: true };
     })
   });
-  const boundedSuccessResult = (call, outcome) => options.toolOutputMaxBytes === undefined ? Effect21.succeed(successResult(call, outcome)) : bound(outcome, { toolCallId: call.id, maxBytes: options.toolOutputMaxBytes }).pipe(Effect21.map((bounded2) => successResult(call, bounded2)));
-  const outcomeEvents = (turn, toolCallBatch, toolCallIndex, call, outcome, droppedProgress, registry) => {
+  const boundedSuccessResult = (call, outcome) => options.toolOutputMaxBytes === undefined ? Effect23.succeed(successResult(call, outcome)) : bound(outcome, { toolCallId: call.id, maxBytes: options.toolOutputMaxBytes }).pipe(Effect23.map((bounded2) => successResult(call, bounded2)));
+  const outcomeEvent = (turn, toolCallBatch, toolCallIndex, call, outcome, droppedProgress, registry) => {
     const metadata = droppedProgress === 0 ? {} : { metadata: { toolProgress: { dropped: droppedProgress } } };
+    const completed = (result) => Effect23.sync(() => {
+      state.pending.set(toolCallIndex, result);
+      return { _tag: "ToolExecutionCompleted", turn, call, result, ...metadata };
+    });
     switch (outcome._tag) {
       case "Success":
-        return (isSkillActivationCall(call, registry) ? Effect21.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect21.map((result) => Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }])));
-      case "DomainFailure": {
-        const result = domainFailureResult(call, outcome);
-        return Effect21.succeed(Stream4.fromIterable([{ _tag: "ToolExecutionCompleted", turn, call, result, ...metadata }]));
-      }
+        return (isSkillActivationCall(call, registry) ? Effect23.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect23.flatMap(completed));
+      case "DomainFailure":
+        return completed(domainFailureResult(call, outcome));
       case "Suspend":
-        return Effect21.succeed(failSuspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
+        return Effect23.fail(suspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
     }
   };
   const defaultExecute = (request, registry) => {
@@ -2628,11 +2669,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     if (registered?.dispatch === "Static") {
       return executeToolkit(staticToolkit, request);
     }
-    return registered === undefined ? Effect21.fail(FrameworkFailure.make({
+    return registered === undefined ? Effect23.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Tool ${request.call.name} is not registered`
-    })) : Effect21.fail(FrameworkFailure.make({
+    })) : Effect23.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Activated skill tool ${request.call.name} requires ToolExecutor`
@@ -2649,11 +2690,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         return Queue2.sliding(progressPolicy.capacity);
     }
   };
-  const executeApproved = (turn, call, request, registry) => Stream4.concat(Stream4.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream4.unwrap(Effect21.gen(function* () {
-    const progressQueue = yield* Effect21.acquireRelease(makeProgressQueue(), Queue2.shutdown);
+  const executeApproved = (turn, call, request, registry) => Stream4.concat(Stream4.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream4.unwrap(Effect23.gen(function* () {
+    const progressQueue = yield* Effect23.acquireRelease(makeProgressQueue(), Queue2.shutdown);
     const droppedProgress = yield* Ref5.make(0);
     const emitSemaphore = yield* Semaphore3.make(1);
-    const signal = yield* Effect21.abortSignal;
+    const signal = yield* Effect23.abortSignal;
     const context = ToolContext.of({
       signal,
       sessionId,
@@ -2665,9 +2706,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
           ...progress.message === undefined ? {} : { message: progress.message },
           ...progress.data === undefined ? {} : { data: progress.data }
         };
-        return emitSemaphore.withPermit(Effect21.gen(function* () {
+        return emitSemaphore.withPermit(Effect23.gen(function* () {
           if (progressPolicy._tag === "Sliding") {
-            const dropped = yield* Effect21.sync(() => {
+            const dropped = yield* Effect23.sync(() => {
               const full = Queue2.isFullUnsafe(progressQueue);
               Queue2.offerUnsafe(progressQueue, event);
               return full;
@@ -2680,16 +2721,16 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
           if (progressPolicy._tag === "Dropping" && !offered) {
             yield* Ref5.update(droppedProgress, (count) => count + 1);
           } else if (progressPolicy._tag === "Fail" && !offered) {
-            yield* Queue2.fail(progressQueue, ProgressOverflowError.make({ turn, toolCallId: call.id, capacity: progressPolicy.capacity }));
+            yield* Queue2.fail(progressQueue, ProgressOverflow.make({ turn, toolCallId: call.id, capacity: progressPolicy.capacity }));
           }
         }));
       }
     });
-    const execution = isSkillActivationCall(call, registry) ? activateSkillOutcome(turn, call) : Option14.isNone(executor) ? defaultExecute(request, registry) : executor.value.execute(request).pipe(Effect21.mapError((error) => Schema18.is(RemoteRetryError)(error) ? AgentError.make({ message: error.message, turn, cause: error }) : error));
-    const fiber = yield* execution.pipe(Effect21.provideService(ToolContext, context), Effect21.ensuring(Queue2.end(progressQueue).pipe(Effect21.asVoid)), Effect21.forkScoped({ startImmediately: true }));
-    return Stream4.concat(Stream4.fromQueue(progressQueue), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((outcome) => Stream4.unwrap(Ref5.get(droppedProgress).pipe(Effect21.flatMap((dropped) => outcomeEvents(turn, request.toolCallBatch, request.toolCallIndex, call, outcome, dropped, registry)))))));
+    const execution = isSkillActivationCall(call, registry) ? activateSkillOutcome(turn, call) : Option13.isNone(executor) ? defaultExecute(request, registry) : executor.value.execute(request).pipe(Effect23.mapError((error) => Schema19.is(RemoteRetryMisconfigured)(error) ? AgentError.make({ message: error.message, turn, cause: error }) : error));
+    const fiber = yield* Effect23.uninterruptibleMask((restore) => restore(execution.pipe(Effect23.provideService(ToolContext, context))).pipe(Effect23.flatMap((outcome) => Ref5.get(droppedProgress).pipe(Effect23.flatMap((dropped) => outcomeEvent(turn, request.toolCallBatch, request.toolCallIndex, call, outcome, dropped, registry)))))).pipe(Effect23.ensuring(Queue2.end(progressQueue).pipe(Effect23.asVoid)), Effect23.forkScoped({ startImmediately: true }));
+    return Stream4.concat(Stream4.fromQueue(progressQueue), Stream4.fromEffect(Fiber3.join(fiber)));
   })));
-  const activateSkillOutcome = (turn, call) => Effect21.gen(function* () {
+  const activateSkillOutcome = (turn, call) => Effect23.gen(function* () {
     if (skillRuntime === undefined) {
       return yield* FrameworkFailure.make({
         stage: "missing-handler",
@@ -2697,8 +2738,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         message: "SkillSource is not available"
       });
     }
-    const params = Schema18.decodeUnknownOption(activateSkillParameters)(call.params);
-    if (Option14.isNone(params)) {
+    const params = Schema19.decodeUnknownOption(activateSkillParameters)(call.params);
+    if (Option13.isNone(params)) {
       return yield* FrameworkFailure.make({
         stage: "decode-input",
         tool: call.name,
@@ -2739,9 +2780,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       allowedTools: [...skill.frontmatter.allowedTools ?? []]
     };
     return { _tag: "Success", result: output, encodedResult: output };
-  }).pipe(Effect21.mapError((error) => isToolNameCollision(error) || Schema18.is(FrameworkFailure)(error) ? error : skillError(turn, error)));
+  }).pipe(Effect23.mapError((error) => isToolNameCollision(error) || Schema19.is(FrameworkFailure)(error) ? error : skillError(turn, error)));
   const authorizationError2 = (turn, error) => AgentError.make({ message: error.message, turn, cause: error });
-  const toolCallEvents = (turn, toolCallBatch, toolCallIndex, call, messages, registry, authorizationStage, authorizationToken) => {
+  const toolCallEvents = (turn, toolCallBatch, toolCallIndex, call, messages, registry) => {
     const request = { call, toolCallBatch, turn, toolCallIndex, agentName: agent.name, sessionId };
     const candidate = get(registry, call.name);
     if (candidate === undefined)
@@ -2751,22 +2792,22 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         message: `Tool ${call.name} is not active for turn ${turn}`
       }));
     const activeTools = registry.entries.map((entry) => entry.tool.name);
-    return Stream4.unwrap(Effect21.gen(function* () {
+    return Stream4.unwrap(Effect23.gen(function* () {
       const activatedSkills = [...(yield* Ref5.get(toolState)).activatedSkillBodies.keys()];
       const approvalEvents = yield* Queue2.bounded(1);
       const fiber = yield* authorizer.authorize({
         call,
+        agentName: agent.name,
+        turn,
+        sessionId,
         tool: candidate.tool,
         active: true,
         activeTools,
         activatedSkills,
-        ...authorizationStage === undefined ? {} : { authorizationStage },
-        ...authorizationToken === undefined ? {} : { authorizationToken },
         messages,
-        execution: request,
-        onApprovalRequired: Queue2.offer(approvalEvents, { _tag: "ApprovalRequested", turn, call }).pipe(Effect21.asVoid)
-      }).pipe(Effect21.mapError((error) => authorizationError2(turn, error)), Effect21.ensuring(Queue2.end(approvalEvents).pipe(Effect21.asVoid)), Effect21.forkScoped({ startImmediately: true }));
-      return Stream4.concat(Stream4.fromQueue(approvalEvents), Stream4.fromEffect(Fiber.join(fiber)).pipe(Stream4.flatMap((decision2) => {
+        onApprovalRequired: Queue2.offer(approvalEvents, { _tag: "ApprovalRequested", turn, call }).pipe(Effect23.asVoid)
+      }).pipe(Effect23.mapError((error) => authorizationError2(turn, error)), Effect23.ensuring(Queue2.end(approvalEvents).pipe(Effect23.asVoid)), Effect23.forkScoped({ startImmediately: true }));
+      return Stream4.concat(Stream4.fromQueue(approvalEvents), Stream4.fromEffect(Fiber3.join(fiber)).pipe(Stream4.flatMap((decision2) => {
         switch (decision2._tag) {
           case "Execute":
             return executeApproved(turn, call, request, registry);
@@ -2780,7 +2821,6 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
             return Stream4.fail(AgentSuspended.make({
               token: decision2.suspension.token,
               reason: "approval",
-              authorization_stage: decision2.suspension.authorization_stage ?? "approval",
               tool_call_index: toolCallIndex,
               tool_call_id: call.id,
               tool_name: call.name,
@@ -2793,8 +2833,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       })));
     }));
   };
-  const captureFinishPart = (part) => Effect21.gen(function* () {
-    const span = yield* Effect21.currentSpan;
+  const captureFinishPart = (part) => Effect23.gen(function* () {
+    const span = yield* Effect23.currentSpan;
     state.finish = {
       usage: state.finish === undefined ? part.usage : addUsage(state.finish.usage, part.usage),
       reason: part.reason
@@ -2808,9 +2848,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       },
       response: { finishReasons: [part.reason] }
     });
-  }).pipe(Effect21.orDie);
-  const captureStructuredUsage = (content) => Effect21.gen(function* () {
-    const span = yield* Effect21.currentSpan;
+  }).pipe(Effect23.orDie);
+  const captureStructuredUsage = (content) => Effect23.gen(function* () {
+    const span = yield* Effect23.currentSpan;
     for (const part of content) {
       if (part.type === "finish") {
         state.usage = state.usage === undefined ? part.usage : addUsage(state.usage, part.usage);
@@ -2824,17 +2864,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         });
       }
     }
-  }).pipe(Effect21.orDie);
-  const withModelResilience = (effect) => Option14.match(resilienceService, {
+  }).pipe(Effect23.orDie);
+  const withModelResilience = (effect) => Option13.match(resilienceService, {
     onNone: () => effect,
-    onSome: (resilience) => Effect21.flatMap(LanguageModel5.LanguageModel, (model) => effect.pipe(Effect21.provideService(LanguageModel5.LanguageModel, apply(model, {
+    onSome: (resilience) => Effect23.flatMap(LanguageModel6.LanguageModel, (model) => effect.pipe(Effect23.provideService(LanguageModel6.LanguageModel, apply(model, {
       ...resilience,
       classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
     }))))
   });
   const withAgentModel = (effect) => agentModelRegistry === undefined || agentModel === undefined ? effect : agentModelRegistry.operate(agentModel, effect);
   function provideAgentModel(stream2) {
-    return agentModelRegistry === undefined || agentModel === undefined ? stream2 : agentModelRegistry.stream(agentModel, stream2).pipe(Stream4.catchTag("LanguageModelNotRegistered", (error) => Stream4.fail(AgentError.make({ message: errorMessage(error), turn: state.turn, cause: error }))));
+    return agentModelRegistry === undefined || agentModel === undefined ? stream2 : agentModelRegistry.stream(agentModel, stream2).pipe(Stream4.catchTag("@batonfx/core/LanguageModelNotRegistered", (error) => Stream4.fail(AgentError.make({ message: errorMessage(error), turn: state.turn, cause: error }))));
   }
   const partEvents = (turn, part) => {
     if (part.type === "error") {
@@ -2851,33 +2891,29 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     }
     return modelPart;
   };
-  const recordPending = (event) => Effect21.sync(() => {
-    if (event._tag === "ToolExecutionCompleted")
-      state.pending.push(event.result);
-  });
-  const transformPart = (turn, part) => applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect21.flatMap(Option14.match({
-    onSome: (transformed) => Effect21.succeed(Option14.some(transformed)),
-    onNone: () => part.type === "tool-call" ? Effect21.fail(MiddlewareViolation.make({
+  const transformPart = (turn, part) => applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect23.flatMap(Option13.match({
+    onSome: (transformed) => Effect23.succeed(Option13.some(transformed)),
+    onNone: () => part.type === "tool-call" ? Effect23.fail(MiddlewareViolation.make({
       turn,
       detail: "ModelMiddleware dropped a tool-call part"
-    })) : Effect21.succeed(Option14.none())
+    })) : Effect23.succeed(Option13.none())
   })));
   const validateToolCallId = (idState, part) => {
     if (part.type !== "tool-call")
-      return Effect21.void;
+      return Effect23.void;
     return Ref5.modify(idState, (current) => {
-      const existingFirstIndex = HashMap5.get(current.firstIndexes, part.id);
-      const duplicate = Option14.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
+      const existingFirstIndex = HashMap6.get(current.firstIndexes, part.id);
+      const duplicate = Option13.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
       return [
         duplicate,
         {
           nextIndex: current.nextIndex + 1,
-          firstIndexes: Option14.isSome(existingFirstIndex) ? current.firstIndexes : HashMap5.set(current.firstIndexes, part.id, current.nextIndex)
+          firstIndexes: Option13.isSome(existingFirstIndex) ? current.firstIndexes : HashMap6.set(current.firstIndexes, part.id, current.nextIndex)
         }
       ];
-    }).pipe(Effect21.flatMap(Option14.match({
-      onNone: () => Effect21.void,
-      onSome: Effect21.fail
+    }).pipe(Effect23.flatMap(Option13.match({
+      onNone: () => Effect23.void,
+      onSome: Effect23.fail
     })));
   };
   const modelTurn = (turn, prompt, registry, overrides) => {
@@ -2889,32 +2925,35 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       let preparedState;
       const singleFailure = (cause) => {
         const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-        return reason !== undefined && Cause4.isFailReason(reason) ? Option14.some(reason.error) : Option14.none();
+        return reason !== undefined && Cause4.isFailReason(reason) ? Option13.some(reason.error) : Option13.none();
       };
       const retryableOverflow = (cause, hasEmitted) => {
         const failure2 = singleFailure(cause);
-        return retryOverflow && !hasEmitted && Option14.isSome(failure2) && classifyFailure2(failure2.value) === "context-overflow" && Option14.isSome(compactionService);
+        if (Option13.isNone(failure2))
+          return false;
+        const classifiedFailure = Schema19.is(AgentError)(failure2.value) && failure2.value.cause !== undefined ? failure2.value.cause : failure2.value;
+        return retryOverflow && !hasEmitted && Option13.isSome(compactionService) && classifyFailure2(classifiedFailure) === "context-overflow";
       };
       return Stream4.fromChannel(Channel.acquireUseRelease(Ref5.make({
         nextIndex: 0,
-        firstIndexes: HashMap5.empty()
-      }), (toolCallIds) => Stream4.unwrap(Effect21.gen(function* () {
-        const activeModel = yield* LanguageModel5.LanguageModel;
+        firstIndexes: HashMap6.empty()
+      }), (toolCallIds) => Stream4.unwrap(Effect23.gen(function* () {
+        const activeModel = yield* LanguageModel6.LanguageModel;
         classifyFailure2 = (error) => classifyFailure(activeModel, error);
         const prepared = yield* preparePrompt(turn, activePrompt, compactOverflow);
         if (compactOverflow && !prepared.changed && overflowCause !== undefined) {
-          return yield* Effect21.failCause(overflowCause);
+          return yield* Effect23.failCause(overflowCause);
         }
         const preparedPrompt = prepared.prompt;
         const history = yield* Ref5.get(chat.history);
         preparedState = { history, preparedPrompt };
         const responsePrompt = Prompt11.concat(history, preparedPrompt);
         const messages = responsePrompt.content;
-        const rawParts = LanguageModel5.streamText({
+        const rawParts = LanguageModel6.streamText({
           prompt: responsePrompt,
           toolkit: activeRegistry.toolkit,
           disableToolCallResolution: true
-        }).pipe(Stream4.tap(() => Effect21.sync(() => {
+        }).pipe(Stream4.mapEffect((part) => part.type === "error" ? Effect23.fail(isToolNameCollision(part.error) ? part.error : AgentError.make({ message: errorMessage(part.error), turn, cause: part.error })) : Effect23.succeed(part)), Stream4.tap(() => Effect23.sync(() => {
           emitted = true;
         })), Stream4.catchCause((cause) => {
           if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
@@ -2922,18 +2961,21 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
           if (retryableOverflow(cause, emitted))
             return Stream4.failCause(cause);
           const error = singleFailure(cause);
-          if (Option14.isNone(error))
+          if (Option13.isNone(error))
             return Stream4.failCause(cause);
-          return Stream4.make(Response10.makePart("error", { error: error.value }));
+          if (Schema19.is(AgentError)(error.value) || isToolNameCollision(error.value)) {
+            return Stream4.fail(error.value);
+          }
+          return Stream4.make(Response9.makePart("error", { error: error.value }));
         }));
-        return rawParts.pipe(Stream4.mapEffect((part) => transformPart(turn, part)), Stream4.flatMap(Option14.match({ onNone: () => Stream4.empty, onSome: Stream4.make })), Stream4.map((part) => ({
+        return rawParts.pipe(Stream4.mapEffect((part) => transformPart(turn, part)), Stream4.flatMap(Option13.match({ onNone: () => Stream4.empty, onSome: Stream4.make })), Stream4.map((part) => ({
           part,
           messages,
-          accept: validateToolCallId(toolCallIds, part).pipe(Effect21.andThen(Effect21.sync(() => {
+          accept: validateToolCallId(toolCallIds, part).pipe(Effect23.andThen(Effect23.sync(() => {
             transformedParts.push(part);
           })))
         })));
-      })).pipe(Stream4.toChannel), (_, exit) => preparedState === undefined || Exit2.isFailure(exit) && retryableOverflow(exit.cause, emitted) ? Effect21.void : Ref5.set(chat.history, Prompt11.concat(Prompt11.concat(preparedState.history, preparedState.preparedPrompt), Prompt11.fromResponseParts(transformedParts))).pipe(Effect21.andThen(persisted === undefined ? Effect21.void : persisted.save), Effect21.orDie, Effect21.asVoid))).pipe(Stream4.catchCause((cause) => {
+      })).pipe(Stream4.toChannel), (_, exit) => preparedState === undefined || Exit2.isFailure(exit) && retryableOverflow(exit.cause, emitted) ? Effect23.void : Ref5.set(chat.history, Prompt11.concat(Prompt11.concat(preparedState.history, preparedState.preparedPrompt), Prompt11.fromResponseParts(transformedParts))).pipe(Effect23.andThen(persisted === undefined ? Effect23.void : persisted.save), Effect23.orDie, Effect23.asVoid))).pipe(Stream4.catchCause((cause) => {
         if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
           return Stream4.failCause(cause);
         if (retryableOverflow(cause, emitted)) {
@@ -2942,15 +2984,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         return Stream4.failCause(cause);
       }), Stream4.catchCause((cause) => {
         const failure2 = singleFailure(cause);
-        return Option14.isSome(failure2) && AiError4.isAiError(failure2.value) ? Stream4.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream4.failCause(cause);
+        return Option13.isSome(failure2) && AiError4.isAiError(failure2.value) ? Stream4.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream4.failCause(cause);
       }));
     };
-    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt11.make(prompt), { agentName: agent.name, turn }).pipe(Effect21.map((transformedPrompt) => {
+    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt11.make(prompt), { agentName: agent.name, turn }).pipe(Effect23.map((transformedPrompt) => {
       let nextToolCallIndex = 0;
       const calls = new Array;
       const executions = new Array;
       const toolCallBatch = { calls };
-      const accepted = attempt(transformedPrompt, true).pipe(Stream4.mapEffect(({ accept, part, messages }) => accept.pipe(Effect21.as({ part, messages }))), Stream4.map(({ part, messages }) => {
+      const accepted = attempt(transformedPrompt, true).pipe(Stream4.mapEffect(({ accept, part, messages }) => accept.pipe(Effect23.as({ part, messages }))), Stream4.map(({ part, messages }) => {
         const toolCallIndex = nextToolCallIndex;
         if (part.type === "tool-call" && part.providerExecuted !== true) {
           const call = part;
@@ -2965,12 +3007,12 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         Object.freeze(toolCallBatch);
         const concurrency = agent.toolExecution?.concurrency ?? 1;
         const executionStreams = Stream4.fromIterable(executions);
-        return concurrency === 1 ? executionStreams.pipe(Stream4.flatMap(({ call, messages, toolCallIndex }) => toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), Stream4.tap(recordPending)) : executionStreams.pipe(Stream4.mapEffect(({ call, messages, toolCallIndex }) => Stream4.runCollect(toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), { concurrency }), Stream4.flatMap(Stream4.fromIterable), Stream4.tap(recordPending));
+        return concurrency === 1 ? executionStreams.pipe(Stream4.flatMap(({ call, messages, toolCallIndex }) => toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry))) : executionStreams.pipe(Stream4.mapEffect(({ call, messages, toolCallIndex }) => Stream4.runCollect(toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), { concurrency }), Stream4.flatMap(Stream4.fromIterable));
       }));
     })));
-    const resilientParts = Option14.match(resilienceService, {
+    const resilientParts = Option13.match(resilienceService, {
       onNone: () => parts,
-      onSome: (resilience) => Stream4.unwrap(LanguageModel5.LanguageModel.pipe(Effect21.map((model) => parts.pipe(Stream4.provideService(LanguageModel5.LanguageModel, apply(model, {
+      onSome: (resilience) => Stream4.unwrap(LanguageModel6.LanguageModel.pipe(Effect23.map((model) => parts.pipe(Stream4.provideService(LanguageModel6.LanguageModel, apply(model, {
         ...resilience,
         classify: (error) => classifyFailure(model, error) === "context-overflow" ? "terminal" : resilience.classify(error)
       }))))))
@@ -2990,30 +3032,30 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     transcript,
     ...state.usage === undefined ? {} : { usage: state.usage }
   });
-  const structuredFinalEvents = (structuredTurn, config) => Stream4.fromEffect(Effect21.gen(function* () {
+  const structuredFinalEvents = (structuredTurn, config) => Stream4.fromEffect(Effect23.gen(function* () {
     const transformedPrompt = yield* applyPromptChain(chain, Prompt11.make(config.objectPrompt), {
       agentName: agent.name,
       turn: structuredTurn
     });
     const history = yield* Ref5.get(chat.history);
-    const response = yield* LanguageModel5.generateObject({
+    const response = yield* LanguageModel6.generateObject({
       prompt: Prompt11.concat(history, transformedPrompt),
       schema: config.schema,
       objectName: config.objectName,
       toolChoice: "none"
-    }).pipe(withModelResilience, withAgentModel, Effect21.catchCause((cause) => {
+    }).pipe(withModelResilience, withAgentModel, Effect23.catchCause((cause) => {
       const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-      return reason !== undefined && Cause4.isFailReason(reason) ? Effect21.fail(AgentError.make({
+      return reason !== undefined && Cause4.isFailReason(reason) ? Effect23.fail(AgentError.make({
         message: errorMessage(reason.error),
         turn: structuredTurn,
         cause: reason.error
-      })) : Effect21.failCause(cause);
+      })) : Effect23.failCause(cause);
     }));
     yield* captureStructuredUsage(response.content);
     const transcript = Prompt11.concat(Prompt11.concat(history, transformedPrompt), Prompt11.fromResponseParts(response.content));
     const path = yield* syncSession(structuredTurn, history);
     yield* applyCompactionResult(structuredTurn, { _tag: "Microcompact", history: transcript, prompt: Prompt11.empty }, path.at(-1)?.id ?? null);
-    if (Option14.isNone(activeSession))
+    if (Option13.isNone(activeSession))
       yield* savePersisted(structuredTurn);
     const structuredOutput = {
       _tag: "StructuredOutput",
@@ -3023,17 +3065,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     };
     return [structuredOutput, terminalCompletedEvent(structuredTurn, transcript)];
   })).pipe(Stream4.flatMap((events) => Stream4.fromIterable(events)));
-  const promptFromSteeringMessages = (messages) => messages.reduce((prompt, message) => Prompt11.concat(prompt, message.prompt), Prompt11.empty);
-  const takeSteering = () => Option14.match(steeringService, {
-    onNone: () => Effect21.succeed([]),
+  const promptFromSteeringInputs = (inputs) => inputs.reduce((prompt, input) => Prompt11.concat(prompt, input.prompt), Prompt11.empty);
+  const takeSteering = () => Option13.match(steeringService, {
+    onNone: () => Effect23.succeed([]),
     onSome: (service) => service.takeSteering
   });
-  const takeFollowUp = () => Option14.match(steeringService, {
-    onNone: () => Effect21.succeed([]),
+  const takeFollowUp = () => Option13.match(steeringService, {
+    onNone: () => Effect23.succeed([]),
     onSome: (service) => service.takeFollowUp
   });
-  const afterTurn = (turn) => Effect21.gen(function* () {
-    const pending = state.pending;
+  const afterTurn = (turn) => Effect23.gen(function* () {
+    const pending = pendingResults();
     const transcript = yield* checkpointPending(turn, pending);
     const path = yield* syncSession(turn, transcript);
     yield* rememberTurn(turn, transcript, pending.length === 0, path);
@@ -3043,7 +3085,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
       if (followUp.length > 0) {
         return {
           events: Stream4.fromIterable([completed, steeringDrainedEvent(turn, "followUp", followUp)]),
-          next: { prompt: promptFromSteeringMessages(followUp) }
+          next: { prompt: promptFromSteeringInputs(followUp) }
         };
       }
       if (structured !== undefined) {
@@ -3064,7 +3106,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
     });
     if (!isTurnPolicyDecision(evaluated)) {
       return yield* TurnPolicyError.make({
-        message: "TurnPolicy returned an invalid decision; reasonless Stop decisions must be adapted with TurnPolicy.fromLegacy",
+        message: "TurnPolicy returned an invalid decision; Stop decisions must include a reason",
         cause: evaluated
       });
     }
@@ -3086,9 +3128,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         })))
       };
     }
-    state.pending = [];
+    state.pending.clear();
     const steering = yield* takeSteering();
-    const basePrompt = steering.length === 0 ? Prompt11.empty : promptFromSteeringMessages(steering);
+    const basePrompt = steering.length === 0 ? Prompt11.empty : promptFromSteeringInputs(steering);
     const prompt = decision2.overrides?.instructions === undefined ? basePrompt : withSystem(decision2.overrides.instructions, basePrompt);
     return {
       events: Stream4.fromIterable(steering.length === 0 ? [completed] : [completed, steeringDrainedEvent(turn, "steering", steering)]),
@@ -3102,7 +3144,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
   const runTurn = (turn, prompt, overrides) => {
     let next;
     let structuredTurn;
-    const currentTurn = Stream4.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream4.concat(resetTurnState(turn)), Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect21.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream4.concat(Stream4.unwrap(afterTurn(turn).pipe(Effect21.map((result) => {
+    const currentTurn = Stream4.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream4.concat(resetTurnState(turn)), Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect23.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream4.concat(Stream4.unwrap(afterTurn(turn).pipe(Effect23.map((result) => {
       next = result.next;
       structuredTurn = result.structuredTurn;
       return result.events;
@@ -3116,10 +3158,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
   };
   const resumeStream = (checkpoint) => {
     let next;
-    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect21.map((tools) => {
-      const suspension2 = checkpoint.suspension;
-      const registry = suspension2.authorization_stage === undefined && suspension2.active_tools === undefined ? tools.registry : select(tools.registry, suspension2.active_tools ?? []);
-      const calls = suspension2.tool_call_batch.map((call) => Response10.makePart("tool-call", {
+    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect23.map((tools) => {
+      const suspension = checkpoint.suspension;
+      const registry = suspension.active_tools === undefined ? tools.registry : select(tools.registry, suspension.active_tools);
+      const calls = suspension.tool_call_batch.map((call) => Response9.makePart("tool-call", {
         id: call.id,
         name: call.name,
         params: call.params,
@@ -3127,15 +3169,18 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
         metadata: call.metadata
       }));
       const toolCallBatch = { calls };
-      const startIndex = suspension2.tool_call_index ?? 0;
-      if (calls[startIndex] === undefined) {
+      const suspendedIndex = suspension.tool_call_index ?? 0;
+      if (calls[suspendedIndex] === undefined) {
         return Stream4.fail(AgentError.make({ message: "Suspension tool call index is outside its batch", turn: 0 }));
       }
-      const executions = Stream4.fromIterable(calls.slice(startIndex).map((call, offset) => ({ call, toolCallIndex: startIndex + offset })));
-      const execute = ({ call, toolCallIndex }) => toolCallEvents(0, toolCallBatch, toolCallIndex, call, checkpoint.messages, registry, toolCallIndex === startIndex ? suspension2.authorization_stage : undefined, toolCallIndex === startIndex ? suspension2.token : undefined);
+      const executions = Stream4.fromIterable(checkpoint.unresolvedToolCallIndexes.map((toolCallIndex) => ({
+        call: calls[toolCallIndex],
+        toolCallIndex
+      })));
+      const execute = ({ call, toolCallIndex }) => toolCallEvents(0, toolCallBatch, toolCallIndex, call, checkpoint.messages, registry);
       const concurrency = agent.toolExecution?.concurrency ?? 1;
-      return concurrency === 1 ? executions.pipe(Stream4.flatMap(execute), Stream4.tap(recordPending)) : executions.pipe(Stream4.mapEffect((execution) => Stream4.runCollect(execute(execution)), { concurrency }), Stream4.flatMap(Stream4.fromIterable), Stream4.tap(recordPending));
-    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect21.map((result) => {
+      return concurrency === 1 ? executions.pipe(Stream4.flatMap(execute)) : executions.pipe(Stream4.mapEffect((execution) => Stream4.runCollect(execute(execution)), { concurrency }), Stream4.flatMap(Stream4.fromIterable));
+    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect23.map((result) => {
       next = result.next;
       return result.events;
     })))), Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
@@ -3146,22 +3191,22 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect21.gen
   const runStream = validatedResume === undefined ? runTurn(0, initialPrompt) : resumeStream(validatedResume);
   return runStream.pipe(Stream4.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-    if (reason !== undefined && Cause4.isFailReason(reason) && Schema18.is(DuplicateToolCallId)(reason.error)) {
-      return Stream4.unwrap(checkpointPending(state.turn, state.pending).pipe(Effect21.map(() => Stream4.failCause(cause))));
+    if (reason !== undefined && Cause4.isFailReason(reason) && Schema19.is(DuplicateToolCallId)(reason.error)) {
+      return Stream4.unwrap(checkpointPending(state.turn, pendingResults()).pipe(Effect23.map(() => Stream4.failCause(cause))));
     }
-    if (reason !== undefined && Cause4.isFailReason(reason) && Schema18.is(AgentSuspended)(reason.error)) {
-      const suspension2 = reason.error;
-      return Stream4.unwrap(Effect21.gen(function* () {
-        const checkpoint = yield* checkpointSuspended(state.turn, state.pending, suspension2);
+    if (reason !== undefined && Cause4.isFailReason(reason) && Schema19.is(AgentSuspended)(reason.error)) {
+      const suspension = reason.error;
+      return Stream4.unwrap(Effect23.gen(function* () {
+        const checkpoint = yield* checkpointSuspended(state.turn, pendingResults(), suspension);
         yield* syncSession(state.turn, checkpoint);
         return Stream4.concat(Stream4.fromIterable([turnCompletedEvent(state.turn, checkpoint)]), Stream4.failCause(cause));
       }));
     }
     return Stream4.failCause(cause);
   }));
-})).pipe(Stream4.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }), (run) => agent[ModelLayerTypeId] === undefined ? run : run.pipe(Stream4.provide(agent[ModelLayerTypeId])));
+})).pipe(Stream4.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent.js
 var AgentTypeId = Symbol.for("@batonfx/core/Agent");
 function make5(options) {
   const declaredTools = "tools" in options && Array.isArray(options.tools) ? options.tools : undefined;
@@ -3199,32 +3244,20 @@ function make5(options) {
   };
 }
 var defaultObjectPrompt = "Return the final structured output for the task above.";
-var provideModel = dual7(2, (agent, layer8) => ({
-  ...agent,
-  policy: agent.policy,
-  ...agent.authorization === undefined ? {} : {
-    authorization: agent.authorization
-  },
-  [AgentTypeId]: {
-    tools: (value) => value,
-    requirements: (value) => value
-  },
-  [ModelLayerTypeId]: layer8
+var stream2 = dual6(2, (agent, options) => streamInternal(agent, options, options.output === undefined ? undefined : {
+  schema: options.output.schema,
+  objectName: options.output.name ?? "output",
+  objectPrompt: options.output.prompt ?? defaultObjectPrompt
 }));
-var stream2 = dual7(2, (agent, options) => streamInternal(agent, options, options.schema === undefined ? undefined : {
-  schema: options.schema,
-  objectName: options.objectName ?? "output",
-  objectPrompt: options.objectPrompt ?? defaultObjectPrompt
-}));
-var generateText = (agent, options) => Stream5.runLast(stream2(agent, options)).pipe(Effect22.flatMap(Option15.match({
-  onNone: () => Effect22.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
-  onSome: (event) => event._tag === "Completed" ? Effect22.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect22.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
+var generateText = (agent, options) => Stream5.runLast(streamInternal(agent, options, undefined)).pipe(Effect24.flatMap(Option14.match({
+  onNone: () => Effect24.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
+  onSome: (event) => event._tag === "Completed" ? Effect24.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect24.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
 })));
-var generateObjectResult = (agent, options) => Stream5.runFold(stream2(agent, options), () => ({ value: Option15.none(), completed: Option15.none() }), (acc, event) => event._tag === "StructuredOutput" ? { ...acc, value: Option15.some(event.value) } : event._tag === "Completed" ? { ...acc, completed: Option15.some(event) } : acc).pipe(Effect22.flatMap(({ value, completed }) => Option15.match(completed, {
-  onNone: () => Effect22.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
-  onSome: (event) => Option15.match(value, {
-    onNone: () => Effect22.fail(AgentError.make({ message: "Agent object run ended without a StructuredOutput event", turn: 0 })),
-    onSome: (typedValue) => Effect22.succeed({
+var generateObjectResult = (agent, options, structured) => Stream5.runFold(streamInternal(agent, options, structured), () => ({ value: Option14.none(), completed: Option14.none() }), (acc, event) => event._tag === "StructuredOutput" ? { ...acc, value: Option14.some(event.value) } : event._tag === "Completed" ? { ...acc, completed: Option14.some(event) } : acc).pipe(Effect24.flatMap(({ value, completed }) => Option14.match(completed, {
+  onNone: () => Effect24.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
+  onSome: (event) => Option14.match(value, {
+    onNone: () => Effect24.fail(AgentError.make({ message: "Agent object run ended without a StructuredOutput event", turn: 0 })),
+    onSome: (typedValue) => Effect24.succeed({
       text: event.text,
       turns: event.turns,
       transcript: event.transcript,
@@ -3232,42 +3265,46 @@ var generateObjectResult = (agent, options) => Stream5.runFold(stream2(agent, op
     })
   })
 })));
-var generate = dual7(2, (agent, options) => options.schema === undefined ? generateText(agent, options) : generateObjectResult(agent, options));
+var generate = dual6(2, (agent, options) => options.output === undefined ? generateText(agent, options) : generateObjectResult(agent, options, {
+  schema: options.output.schema,
+  objectName: options.output.name ?? "output",
+  objectPrompt: options.output.prompt ?? defaultObjectPrompt
+}));
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/agent-tool.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-tool.js
 var exports_agent_tool = {};
 __export(exports_agent_tool, {
   asTool: () => asTool
 });
-import { Cause as Cause5, Effect as Effect23, Function as Function7, Schema as Schema20 } from "effect";
-import { Prompt as Prompt13, Tool as Tool12, Toolkit as Toolkit6 } from "effect/unstable/ai";
-var defaultParameters = Schema20.Struct({ prompt: Schema20.String });
+import { Cause as Cause5, Effect as Effect25, Function as Function7, Schema as Schema21 } from "effect";
+import { Prompt as Prompt13, Tool as Tool11, Toolkit as Toolkit6 } from "effect/unstable/ai";
+var defaultParameters = Schema21.Struct({ prompt: Schema21.String });
 var errorMessage2 = (error) => {
-  if (Schema20.is(AgentSuspended)(error)) {
+  if (Schema21.is(AgentSuspended)(error)) {
     return `suspended on ${error.tool_name}: ${error.reason}`;
   }
-  if (Schema20.is(AgentError)(error)) {
+  if (Schema21.is(AgentError)(error)) {
     return `failed on turn ${error.turn}: ${error.message}`;
   }
-  if (Schema20.is(ResumeMismatch)(error)) {
+  if (Schema21.is(ResumeMismatch)(error)) {
     return `resume mismatch: ${error.reason}`;
   }
-  if (Schema20.is(TurnLimitExceeded)(error)) {
+  if (Schema21.is(TurnLimitExceeded)(error)) {
     return `turn limit exceeded at turn ${error.turn}`;
   }
-  if (Schema20.is(TurnPolicyStopped)(error)) {
+  if (Schema21.is(TurnPolicyStopped)(error)) {
     return `policy stopped at turn ${error.turn}: ${error.reason._tag}`;
   }
-  if (Schema20.is(TurnPolicyError)(error)) {
+  if (Schema21.is(TurnPolicyError)(error)) {
     return `turn policy failed: ${error.message}`;
   }
-  if (Schema20.is(MiddlewareViolation)(error)) {
+  if (Schema21.is(MiddlewareViolation)(error)) {
     return `middleware violation on turn ${error.turn}: ${error.detail}`;
   }
-  if (Schema20.is(DuplicateToolCallId)(error)) {
+  if (Schema21.is(DuplicateToolCallId)(error)) {
     return `duplicate tool-call ID '${error.id}' at position ${error.duplicateIndex} (first at ${error.firstIndex})`;
   }
-  if (Schema20.is(ToolNameCollision)(error)) {
+  if (Schema21.is(ToolNameCollision)(error)) {
     return `tool name collision: ${error.name} (${error.origins.map((origin) => origin._tag === "Static" ? `static:${origin.agent}` : origin._tag === "Builtin" ? `builtin:${origin.builtin}` : origin._tag === "Skill" ? `skill:${origin.skill}` : `handoff:${origin.specialist}`).join(", ")})`;
   }
   return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
@@ -3277,35 +3314,35 @@ var lazyHandled = (toolkit, name, handler) => ({
   tools: toolkit.tools,
   handle: (toolName, params) => toolkit.toHandlers({
     [name]: handler
-  }).pipe(Effect23.flatMap((handlers) => toolkit.pipe(Effect23.provide(handlers))), Effect23.flatMap((handled) => handled.handle(toolName, params)))
+  }).pipe(Effect25.flatMap((handlers) => toolkit.pipe(Effect25.provide(handlers))), Effect25.flatMap((handled) => handled.handle(toolName, params)))
 });
 var asTool = Function7.dual((args) => args.length !== 1 || ("name" in args[0]), (agent, options = {}) => {
   const name = options.name ?? agent.name;
   const parameters = options.parameters ?? defaultParameters;
-  const success2 = options.success ?? Schema20.String;
+  const success2 = options.success ?? Schema21.String;
   const toPrompt = options.toPrompt ?? ((params) => params.prompt);
   const fromResult = options.fromResult ?? ((result) => result.text);
-  const tool = Tool12.make(name, {
+  const tool = Tool11.make(name, {
     ...options.description === undefined ? {} : { description: options.description },
     parameters,
     success: success2,
-    failure: Schema20.String,
+    failure: Schema21.String,
     failureMode: "return"
   });
   const toolkit = Toolkit6.make(tool);
-  const handler = (params) => Effect23.gen(function* () {
-    const prompt = yield* Effect23.try({ try: () => toPrompt(params), catch: errorMessage2 });
-    const result = yield* generate(agent, { prompt }).pipe(Effect23.catchCause((cause) => {
+  const handler = (params) => Effect25.gen(function* () {
+    const prompt = yield* Effect25.try({ try: () => toPrompt(params), catch: errorMessage2 });
+    const result = yield* generate(agent, { prompt }).pipe(Effect25.catchCause((cause) => {
       if (Cause5.hasInterrupts(cause))
-        return Effect23.interrupt;
-      return Effect23.fail(causeMessage(agent.name, cause));
+        return Effect25.interrupt;
+      return Effect25.fail(causeMessage(agent.name, cause));
     }));
-    return yield* Effect23.try({ try: () => fromResult(result), catch: errorMessage2 });
+    return yield* Effect25.try({ try: () => fromResult(result), catch: errorMessage2 });
   });
   return lazyHandled(toolkit, name, handler);
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/guardrail.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/guardrail.js
 var exports_guardrail = {};
 __export(exports_guardrail, {
   validateInput: () => validateInput,
@@ -3313,8 +3350,8 @@ __export(exports_guardrail, {
   redactInput: () => redactInput,
   filterOutput: () => filterOutput
 });
-import { Effect as Effect24, Option as Option16 } from "effect";
-import { Prompt as Prompt14, Response as Response11 } from "effect/unstable/ai";
+import { Effect as Effect26, Option as Option15 } from "effect";
+import { Prompt as Prompt14, Response as Response10 } from "effect/unstable/ai";
 var replacement = (options) => options.replacement ?? "[redacted]";
 var redactText = (text, options) => text.replace(options.pattern, replacement(options));
 var redactUserPart = (part, options) => part.type === "text" ? Prompt14.makePart("text", { text: redactText(part.text, options), options: part.options }) : part;
@@ -3363,19 +3400,19 @@ var redactPromptText = (prompt, options) => Prompt14.fromMessages(prompt.content
   }
 }));
 var validateInput = (check) => ({
-  transformPrompt: (prompt, context) => check(prompt, context).pipe(Effect24.flatMap(Option16.match({
-    onNone: () => Effect24.succeed(prompt),
-    onSome: (reason) => Effect24.fail(AgentError.make({ message: `Input guardrail blocked: ${reason}`, turn: context.turn }))
+  transformPrompt: (prompt, context) => check(prompt, context).pipe(Effect26.flatMap(Option15.match({
+    onNone: () => Effect26.succeed(prompt),
+    onSome: (reason) => Effect26.fail(AgentError.make({ message: `Input guardrail blocked: ${reason}`, turn: context.turn }))
   })))
 });
 var redactInput = (options) => ({
-  transformPrompt: (prompt) => Effect24.succeed(redactPromptText(prompt, options))
+  transformPrompt: (prompt) => Effect26.succeed(redactPromptText(prompt, options))
 });
 var redactOutput = (options) => ({
   transformPart: (part) => {
     if (part.type !== "text-delta")
-      return Effect24.succeed(Option16.some(part));
-    return Effect24.succeed(Option16.some(Response11.makePart("text-delta", {
+      return Effect26.succeed(Option15.some(part));
+    return Effect26.succeed(Option15.some(Response10.makePart("text-delta", {
       id: part.id,
       delta: redactText(part.delta, options),
       metadata: part.metadata
@@ -3383,23 +3420,23 @@ var redactOutput = (options) => ({
   }
 });
 var filterOutput = (keep) => ({
-  transformPart: (part, context) => Effect24.succeed(part.type === "tool-call" || keep(part, context) ? Option16.some(part) : Option16.none())
+  transformPart: (part, context) => Effect26.succeed(part.type === "tool-call" || keep(part, context) ? Option15.some(part) : Option15.none())
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/handoff.js
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/handoff.js
 var exports_handoff = {};
 __export(exports_handoff, {
   transferTool: () => transferTool,
   supervisor: () => supervisor,
   fanOut: () => fanOut
 });
-import { Effect as Effect25, Function as Function8, Schema as Schema21 } from "effect";
-import { AiError as AiError6, LanguageModel as LanguageModel7, Prompt as Prompt15, Tool as Tool13, Toolkit as Toolkit7 } from "effect/unstable/ai";
-var defaultTransferParameters = Schema21.Struct({ prompt: Schema21.String });
+import { Array as Array3, Effect as Effect27, Function as Function8, Schema as Schema22 } from "effect";
+import { AiError as AiError6, LanguageModel as LanguageModel8, Prompt as Prompt15, Tool as Tool12, Toolkit as Toolkit7 } from "effect/unstable/ai";
+var defaultTransferParameters = Schema22.Struct({ prompt: Schema22.String });
 var transferName = (agentName) => `transfer_to_${agentName}`;
 var positiveConcurrency = (value) => {
   const concurrency = value ?? 4;
-  return Number.isInteger(concurrency) && concurrency > 0 ? Effect25.succeed(concurrency) : Effect25.fail(AgentError.make({
+  return Number.isInteger(concurrency) && concurrency > 0 ? Effect27.succeed(concurrency) : Effect27.fail(AgentError.make({
     message: "Handoff.fanOut concurrency must be a positive integer",
     turn: 0
   }));
@@ -3417,7 +3454,7 @@ var mergeHandled = (toolkits) => {
     tools,
     handle: (name, params) => {
       const entry = entries.get(String(name));
-      return entry === undefined ? Effect25.fail(AiError6.make({
+      return entry === undefined ? Effect27.fail(AiError6.make({
         module: "Handoff",
         method: `${String(name)}.handle`,
         reason: AiError6.ToolNotFoundError.make({
@@ -3437,7 +3474,7 @@ var transferTool = Function8.dual((args) => args.length !== 1 || ("name" in args
   ...options.toPrompt === undefined ? {} : { toPrompt: options.toPrompt },
   ...options.fromResult === undefined ? {} : { fromResult: options.fromResult }
 }));
-var fanOut = Function8.dual((args) => args.length !== 1 || Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect25.flatMap((concurrency) => Effect25.forEach(children, (child) => {
+var fanOut = Function8.dual((args) => args.length !== 1 || globalThis.Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect27.flatMap((concurrency) => Effect27.forEach(children, (child) => {
   const runOptions = {
     ...child.options,
     prompt: child.prompt
@@ -3457,16 +3494,16 @@ var supervisor = (options) => {
   return {
     agent: {
       ...agent,
-      toolDeclarations: transferTools.flatMap((transfer, index) => Object.values(transfer.tools).map((tool) => ({
+      toolDeclarations: Array3.zip(specialists, transferTools).flatMap(([specialist, transfer]) => Object.values(transfer.tools).map((tool) => ({
         tool,
-        origin: { _tag: "Handoff", specialist: options.specialists[index].name }
+        origin: { _tag: "Handoff", specialist: specialist.name }
       })))
     },
     toolkit
   };
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.7.0/node_modules/@batonfx/core/dist/index.js
-import { AiError as AiError7, Chat as Chat4, EmbeddingModel, IdGenerator, LanguageModel as LanguageModel8, Model as Model2, Prompt as Prompt16, Response as Response12, ResponseIdTracker, Telemetry as Telemetry2, Tokenizer as Tokenizer3, Tool as Tool14, Toolkit as Toolkit8 } from "effect/unstable/ai";
+// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/index.js
+import { AiError as AiError7, Chat as Chat4, EmbeddingModel, IdGenerator, LanguageModel as LanguageModel9, Model as Model2, Prompt as Prompt16, Response as Response11, ResponseIdTracker, Telemetry as Telemetry2, Tokenizer as Tokenizer3, Tool as Tool13, Toolkit as Toolkit8 } from "effect/unstable/ai";
 
-export { exports_turn_policy, exports_agent_event, exports_memory, exports_model_registry, exports_tool_context, exports_tool_executor, exports_approvals, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_model_middleware, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError7 as AiError, Chat4 as Chat, EmbeddingModel, IdGenerator, Model2 as Model, Prompt16 as Prompt, Response12 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool14 as Tool, Toolkit8 as Toolkit };
+export { exports_turn_policy, exports_agent_event, exports_memory, exports_model_registry, exports_tool_context, exports_tool_executor, exports_approvals, exports_session, exports_tool_output, exports_compaction, exports_instructions, exports_model_middleware, exports_model_resilience, exports_permissions, exports_skill_source, exports_steering, exports_agent, exports_agent_tool, exports_guardrail, exports_handoff, AiError7 as AiError, Chat4 as Chat, EmbeddingModel, IdGenerator, Model2 as Model, Prompt16 as Prompt, Response11 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool13 as Tool, Toolkit8 as Toolkit };