@relayfx/sdk 0.6.1 → 0.7.1

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

@@ -3,7 +3,7 @@ import {
   __export
 } from "./index-nb39b5ae.js";
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/turn-policy.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/turn-policy.js
 var exports_turn_policy = {};
 __export(exports_turn_policy, {
   untilToolCall: () => untilToolCall,
@@ -72,7 +72,7 @@ var both = dual(2, (first, second) => ({
 }));
 var defaultPolicy = forever;
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-event.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-event.js
 var exports_agent_event = {};
 __export(exports_agent_event, {
   addUsage: () => addUsage,
@@ -87,31 +87,289 @@ __export(exports_agent_event, {
   AgentSuspended: () => AgentSuspended,
   AgentError: () => AgentError
 });
-import { Function, Schema as Schema3 } from "effect";
-import { Prompt as Prompt3, Response as Response2, Tool } from "effect/unstable/ai";
+import { Function, Schema as Schema4 } from "effect";
+import { Prompt as Prompt3, Response as Response3, 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({
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-telemetry.js
+var exports_model_telemetry = {};
+__export(exports_model_telemetry, {
+  layerNoop: () => layerNoop,
+  generateId: () => generateId,
+  classifyFailureCategory: () => classifyFailureCategory,
+  ModelRetryScheduled: () => ModelRetryScheduled,
+  ModelRetryReason: () => ModelRetryReason,
+  ModelFirstOutputKind: () => ModelFirstOutputKind,
+  ModelFailureClassification: () => ModelFailureClassification,
+  ModelFailureCategory: () => ModelFailureCategory,
+  ModelCost: () => ModelCost,
+  ModelCallStarted: () => ModelCallStarted,
+  ModelCallPurpose: () => ModelCallPurpose,
+  ModelCallFailed: () => ModelCallFailed,
+  ModelCallCompleted: () => ModelCallCompleted,
+  ModelAttemptStarted: () => ModelAttemptStarted,
+  ModelAttemptFirstOutput: () => ModelAttemptFirstOutput,
+  ModelAttemptFailed: () => ModelAttemptFailed,
+  ModelAttemptCompleted: () => ModelAttemptCompleted,
+  Event: () => Event,
+  DeliveryFailed: () => DeliveryFailed,
+  DeliveryBatch: () => DeliveryBatch,
+  Delivery: () => Delivery,
+  CurrentSummaryCall: () => CurrentSummaryCall,
+  CurrentPurpose: () => CurrentPurpose,
+  CurrentInstrumentation: () => CurrentInstrumentation,
+  CurrentCompactionId: () => CurrentCompactionId,
+  CompactionTrigger: () => CompactionTrigger,
+  CompactionStarted: () => CompactionStarted,
+  CompactionKind: () => CompactionKind,
+  CompactionFailed: () => CompactionFailed,
+  CompactionCompleted: () => CompactionCompleted,
+  CompactionCommit: () => CompactionCommit
+});
+import { Cause, Context, Effect as Effect2, Layer as Layer2, Option, Schema as Schema2 } from "effect";
+import { AiError, IdGenerator, LanguageModel as LanguageModel2, Response as Response2 } from "effect/unstable/ai";
+var ModelCallPurpose = Schema2.Literals(["conversation", "structured-output", "compaction-summary"]);
+var ModelFailureCategory = Schema2.Literals([
+  "authentication",
+  "rate-limit",
+  "transport",
+  "provider-response",
+  "stream-decode",
+  "context-overflow",
+  "invalid-tool-call",
+  "token-budget",
+  "timeout",
+  "cancellation",
+  "unknown"
+]);
+var ModelFailureClassification = Schema2.Literals(["transient", "terminal"]);
+var ModelRetryReason = Schema2.Literals(["provider-resilience", "invalid-tool-call-correction"]);
+var ModelFirstOutputKind = Schema2.Literals(["reasoning", "text", "tool-call"]);
+var ModelCost = Schema2.Struct({
+  amount: Schema2.Finite,
+  currency: Schema2.String
+});
+var CompactionTrigger = Schema2.Literals(["threshold", "overflow"]);
+var CompactionKind = Schema2.Literals(["microcompact", "summarize", "unchanged"]);
+var attemptOrdinal = Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0));
+var ModelCallStarted = Schema2.Struct({
+  _tag: Schema2.tag("ModelCallStarted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  purpose: ModelCallPurpose,
+  provider: Schema2.optionalKey(Schema2.String),
+  model: Schema2.optionalKey(Schema2.String),
+  compactionId: Schema2.optionalKey(Schema2.String),
+  startedAt: Schema2.Finite
+});
+var ModelAttemptStarted = Schema2.Struct({
+  _tag: Schema2.tag("ModelAttemptStarted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  modelAttemptId: Schema2.String,
+  attempt: attemptOrdinal,
+  startedAt: Schema2.Finite
+});
+var ModelAttemptFirstOutput = Schema2.Struct({
+  _tag: Schema2.tag("ModelAttemptFirstOutput"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  modelAttemptId: Schema2.String,
+  attempt: attemptOrdinal,
+  kind: ModelFirstOutputKind,
+  at: Schema2.Finite
+});
+var ModelAttemptCompleted = Schema2.Struct({
+  _tag: Schema2.tag("ModelAttemptCompleted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  modelAttemptId: Schema2.String,
+  attempt: attemptOrdinal,
+  completedAt: Schema2.Finite,
+  usage: Schema2.optionalKey(Response2.Usage),
+  usageAt: Schema2.optionalKey(Schema2.Finite),
+  finishReason: Schema2.optionalKey(Response2.FinishReason),
+  requestId: Schema2.optionalKey(Schema2.String),
+  responseModel: Schema2.optionalKey(Schema2.String),
+  serviceTier: Schema2.optionalKey(Schema2.String),
+  cost: Schema2.optionalKey(ModelCost)
+});
+var ModelAttemptFailed = Schema2.Struct({
+  _tag: Schema2.tag("ModelAttemptFailed"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  modelAttemptId: Schema2.String,
+  attempt: attemptOrdinal,
+  failedAt: Schema2.Finite,
+  category: ModelFailureCategory,
+  classification: ModelFailureClassification
+});
+var ModelRetryScheduled = Schema2.Struct({
+  _tag: Schema2.tag("ModelRetryScheduled"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  attempt: attemptOrdinal,
+  reason: ModelRetryReason,
+  category: ModelFailureCategory,
+  delayMillis: Schema2.Finite,
+  at: Schema2.Finite
+});
+var ModelCallCompleted = Schema2.Struct({
+  _tag: Schema2.tag("ModelCallCompleted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  purpose: ModelCallPurpose,
+  attempts: attemptOrdinal,
+  completedAt: Schema2.Finite,
+  usage: Schema2.optionalKey(Response2.Usage),
+  finishReason: Schema2.optionalKey(Response2.FinishReason)
+});
+var ModelCallFailed = Schema2.Struct({
+  _tag: Schema2.tag("ModelCallFailed"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  modelCallId: Schema2.String,
+  purpose: ModelCallPurpose,
+  attempts: attemptOrdinal,
+  failedAt: Schema2.Finite,
+  category: ModelFailureCategory
+});
+var CompactionStarted = Schema2.Struct({
+  _tag: Schema2.tag("CompactionStarted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  compactionId: Schema2.String,
+  trigger: CompactionTrigger,
+  startedAt: Schema2.Finite,
+  contextTokensBefore: Schema2.optionalKey(Schema2.Finite),
+  entriesBefore: Schema2.optionalKey(Schema2.Finite)
+});
+var CompactionCompleted = Schema2.Struct({
+  _tag: Schema2.tag("CompactionCompleted"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  compactionId: Schema2.String,
+  kind: CompactionKind,
+  completedAt: Schema2.Finite,
+  summaryModelCallId: Schema2.optionalKey(Schema2.String)
+});
+var CompactionFailed = Schema2.Struct({
+  _tag: Schema2.tag("CompactionFailed"),
+  deliveryId: Schema2.String,
+  turn: Schema2.Finite,
+  compactionId: Schema2.String,
+  failedAt: Schema2.Finite
+});
+var Event = Schema2.Union([
+  ModelCallStarted,
+  ModelAttemptStarted,
+  ModelAttemptFirstOutput,
+  ModelAttemptCompleted,
+  ModelAttemptFailed,
+  ModelRetryScheduled,
+  ModelCallCompleted,
+  ModelCallFailed,
+  CompactionStarted,
+  CompactionCompleted,
+  CompactionFailed
+]);
+var DeliveryBatch = 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)
+  events: Schema2.Array(Event)
+});
+var CompactionCommit = Schema2.Struct({
+  compactionId: Schema2.String,
+  checkpointId: Schema2.String,
+  summaryModelCallId: Schema2.optionalKey(Schema2.String),
+  contextTokensBefore: Schema2.optionalKey(Schema2.Finite),
+  contextTokensAfter: Schema2.optionalKey(Schema2.Finite),
+  entriesBefore: Schema2.optionalKey(Schema2.Finite),
+  entriesAfter: Schema2.optionalKey(Schema2.Finite)
+});
+
+class DeliveryFailed extends Schema2.TaggedErrorClass()("@batonfx/core/DeliveryFailed", {
+  message: Schema2.String,
+  cause: Schema2.optionalKey(Schema2.Defect())
+}) {
+}
+
+class Delivery extends Context.Service()("@batonfx/core/Delivery") {
+}
+var layerNoop = Layer2.succeed(Delivery, Delivery.of({ deliver: () => Effect2.void }));
+var classifyFailureCategory = (error) => {
+  if (Cause.isTimeoutError(error))
+    return "timeout";
+  if (!AiError.isAiError(error))
+    return "unknown";
+  switch (error.reason._tag) {
+    case "AuthenticationError":
+      return "authentication";
+    case "RateLimitError":
+      return "rate-limit";
+    case "QuotaExhaustedError":
+      return "token-budget";
+    case "NetworkError":
+      return "transport";
+    case "ContentPolicyError":
+    case "InternalProviderError":
+    case "InvalidRequestError":
+    case "InvalidUserInputError":
+    case "UnsupportedSchemaError":
+      return "provider-response";
+    case "InvalidOutputError":
+    case "StructuredOutputError":
+      return "stream-decode";
+    case "InvalidToolResultError":
+    case "ToolConfigurationError":
+    case "ToolNotFoundError":
+    case "ToolParameterValidationError":
+    case "ToolResultEncodingError":
+    case "ToolkitRequiredError":
+      return "invalid-tool-call";
+    case "UnknownError":
+      return "unknown";
+  }
+};
+var CurrentInstrumentation = Context.Reference("@batonfx/core/ModelTelemetry/CurrentInstrumentation", { defaultValue: () => {
+  return;
+} });
+var CurrentPurpose = Context.Reference("@batonfx/core/ModelTelemetry/CurrentPurpose", { defaultValue: () => "conversation" });
+var CurrentCompactionId = Context.Reference("@batonfx/core/ModelTelemetry/CurrentCompactionId", { defaultValue: () => {
+  return;
+} });
+var CurrentSummaryCall = Context.Reference("@batonfx/core/ModelTelemetry/CurrentSummaryCall", { defaultValue: () => {
+  return;
+} });
+var generateId = Effect2.flatMap(Effect2.serviceOption(IdGenerator.IdGenerator), (service) => Option.getOrElse(service, () => IdGenerator.defaultIdGenerator).generateId());
+
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/session-sync.js
+import { Schema as Schema3 } from "effect";
+import { Prompt as Prompt2 } from "effect/unstable/ai";
+var Divergence = Schema3.Struct({
+  index: Schema3.Finite,
+  durableRole: Schema3.optionalKey(Schema3.String),
+  authoritativeRole: Schema3.optionalKey(Schema3.String),
+  durablePartTypes: Schema3.Array(Schema3.String),
+  authoritativePartTypes: Schema3.Array(Schema3.String),
+  durableDigest: Schema3.optionalKey(Schema3.String),
+  authoritativeDigest: Schema3.optionalKey(Schema3.String)
+});
+var Diagnostics = Schema3.Struct({
+  sessionId: Schema3.String,
+  ownerToken: Schema3.optionalKey(Schema3.String),
+  durableEntryCount: Schema3.Finite,
+  durableMessageCount: Schema3.Finite,
+  authoritativeMessageCount: Schema3.Finite,
+  alignmentCount: Schema3.Finite,
+  commonPrefixLength: Schema3.Finite,
+  lastDurableEntryTag: Schema3.optionalKey(Schema3.String),
+  firstDivergence: Schema3.optionalKey(Divergence)
 });
 var digest = (value) => {
   let hash = 2166136261;
@@ -122,9 +380,28 @@ var digest = (value) => {
   return (hash >>> 0).toString(16).padStart(8, "0");
 };
 var partTypes = (message) => typeof message.content === "string" ? ["text"] : message.content.map((part) => part.type);
+var sameOptions = (left, right) => JSON.stringify(left.options ?? {}) === JSON.stringify(right.options ?? {});
+var coalesceParts = (parts) => {
+  const merged = [];
+  for (const part of parts) {
+    const previous = merged[merged.length - 1];
+    if (part.type === "text" && previous !== undefined && previous.type === "text" && sameOptions(previous, part)) {
+      merged[merged.length - 1] = { ...previous, text: previous.text + part.text };
+      continue;
+    }
+    merged.push(part);
+  }
+  return merged;
+};
+var coalesceAdjacentText = (message) => {
+  if (typeof message.content === "string" || message.content.length < 2)
+    return message;
+  const coalesced = coalesceParts(message.content);
+  return coalesced.length === message.content.length ? message : { ...message, content: coalesced };
+};
 var messageDigest = (message) => digest(JSON.stringify(message));
 var diagnose = (input) => {
-  const equals = Schema2.toEquivalence(Prompt2.Message);
+  const equals = Schema3.toEquivalence(Prompt2.Message);
   let alignmentCount = 0;
   if (input.projection.length === 0)
     alignmentCount = 1;
@@ -162,9 +439,9 @@ var diagnose = (input) => {
   };
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-event.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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({
+var addUsage = Function.dual(2, (left, right) => Response3.Usage.make({
   inputTokens: {
     uncached: addUsageField(left.inputTokens.uncached, right.inputTokens.uncached),
     total: addUsageField(left.inputTokens.total, right.inputTokens.total),
@@ -178,94 +455,94 @@ var addUsage = Function.dual(2, (left, right) => Response2.Usage.make({
   }
 }));
 
-class AgentError extends Schema3.TaggedErrorClass()("@batonfx/core/AgentError", {
-  message: Schema3.String,
-  turn: Schema3.Finite,
-  cause: Schema3.optionalKey(Schema3.Defect()),
-  diagnostics: Schema3.optionalKey(Diagnostics)
+class AgentError extends Schema4.TaggedErrorClass()("@batonfx/core/AgentError", {
+  message: Schema4.String,
+  turn: Schema4.Finite,
+  cause: Schema4.optionalKey(Schema4.Defect()),
+  diagnostics: Schema4.optionalKey(Diagnostics)
 }) {
 }
 
-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 TurnLimitExceeded extends Schema4.TaggedErrorClass()("@batonfx/core/TurnLimitExceeded", {
+  turn: Schema4.Finite,
+  limit: Schema4.Finite,
+  pending: Schema4.Array(Schema4.Struct({
+    tool_call_id: Schema4.String,
+    tool_name: Schema4.String
   }))
 }) {
 }
 
-class TurnPolicyStopped extends Schema3.TaggedErrorClass()("@batonfx/core/TurnPolicyStopped", {
-  turn: Schema3.Finite,
+class TurnPolicyStopped extends Schema4.TaggedErrorClass()("@batonfx/core/TurnPolicyStopped", {
+  turn: Schema4.Finite,
   reason: StopReason,
-  pending: Schema3.Array(Schema3.Struct({
-    tool_call_id: Schema3.String,
-    tool_name: Schema3.String
+  pending: Schema4.Array(Schema4.Struct({
+    tool_call_id: Schema4.String,
+    tool_name: Schema4.String
   }))
 }) {
 }
 
-class MiddlewareViolation extends Schema3.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
-  turn: Schema3.Finite,
-  detail: Schema3.String
+class MiddlewareViolation extends Schema4.TaggedErrorClass()("@batonfx/core/MiddlewareViolation", {
+  turn: Schema4.Finite,
+  detail: Schema4.String
 }) {
 }
 
-class DuplicateToolCallId extends Schema3.TaggedErrorClass()("@batonfx/core/DuplicateToolCallId", {
-  id: Schema3.String,
-  firstIndex: Schema3.Finite,
-  duplicateIndex: Schema3.Finite
+class DuplicateToolCallId extends Schema4.TaggedErrorClass()("@batonfx/core/DuplicateToolCallId", {
+  id: Schema4.String,
+  firstIndex: Schema4.Finite,
+  duplicateIndex: Schema4.Finite
 }) {
 }
 
-class ProgressOverflow extends Schema3.TaggedErrorClass()("@batonfx/core/ProgressOverflow", {
-  turn: Schema3.Finite,
-  toolCallId: Schema3.String,
-  capacity: Schema3.Finite
+class ProgressOverflow extends Schema4.TaggedErrorClass()("@batonfx/core/ProgressOverflow", {
+  turn: Schema4.Finite,
+  toolCallId: Schema4.String,
+  capacity: Schema4.Finite
 }) {
 }
-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 })
+var ToolOrigin = Schema4.Union([
+  Schema4.TaggedStruct("Static", { agent: Schema4.String }),
+  Schema4.TaggedStruct("Builtin", { builtin: Schema4.Literal("activate_skill") }),
+  Schema4.TaggedStruct("Skill", { skill: Schema4.String }),
+  Schema4.TaggedStruct("Handoff", { specialist: Schema4.String })
 ]);
 
-class ToolNameCollision extends Schema3.TaggedErrorClass()("@batonfx/core/ToolNameCollision", {
-  name: Schema3.String,
-  origins: Schema3.NonEmptyArray(ToolOrigin)
+class ToolNameCollision extends Schema4.TaggedErrorClass()("@batonfx/core/ToolNameCollision", {
+  name: Schema4.String,
+  origins: Schema4.NonEmptyArray(ToolOrigin)
 }) {
 }
 
-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
+class AgentSuspended extends Schema4.TaggedErrorClass()("@batonfx/core/AgentSuspended", {
+  token: Schema4.String,
+  reason: Schema4.Literals(["tool-wait", "approval"]),
+  tool_call_index: Schema4.optional(Schema4.Int.check(Schema4.isGreaterThanOrEqualTo(0))),
+  tool_call_id: Schema4.String,
+  tool_name: Schema4.String,
+  tool_params: Schema4.Unknown,
+  tool_call_batch: Schema4.Array(Schema4.Struct({
+    type: Schema4.Literal("tool-call"),
+    id: Schema4.String,
+    name: Schema4.String,
+    params: Schema4.Unknown,
+    providerExecuted: Schema4.Boolean,
+    metadata: Response3.ProviderMetadata
   })),
-  active_tools: Schema3.optional(Schema3.Array(Schema3.String)),
-  activated_skills: Schema3.optional(Schema3.Array(Schema3.String))
+  active_tools: Schema4.optional(Schema4.Array(Schema4.String)),
+  activated_skills: Schema4.optional(Schema4.Array(Schema4.String))
 }) {
 }
 
-class ResumeMismatch extends Schema3.TaggedErrorClass()("@batonfx/core/ResumeMismatch", {
-  reason: Schema3.Literals(["checkpoint-not-found", "identity-mismatch"]),
-  expected: Schema3.optional(AgentSuspended),
+class ResumeMismatch extends Schema4.TaggedErrorClass()("@batonfx/core/ResumeMismatch", {
+  reason: Schema4.Literals(["checkpoint-not-found", "identity-mismatch"]),
+  expected: Schema4.optional(AgentSuspended),
   received: AgentSuspended
 }) {
 }
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/memory.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/memory.js
 var exports_memory = {};
 __export(exports_memory, {
   replaceRecalledMessage: () => replaceRecalledMessage,
@@ -274,18 +551,18 @@ __export(exports_memory, {
   messageFromRecall: () => messageFromRecall,
   merge: () => merge,
   layerTest: () => layerTest,
-  layerNoop: () => layerNoop,
+  layerNoop: () => layerNoop2,
   itemFromPromptPart: () => itemFromPromptPart,
   isMessageFromRecall: () => isMessageFromRecall,
   MemoryError: () => MemoryError,
   Memory: () => Memory
 });
-import { Context, Effect as Effect2, Layer as Layer2, Option, Schema as Schema4 } from "effect";
+import { Context as Context2, Effect as Effect3, Layer as Layer3, Option as Option2, Schema as Schema5 } from "effect";
 import { dual as dual2 } from "effect/Function";
 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");
+var itemFromPromptPart = Option2.liftPredicate((part) => part.type === "text" || part.type === "file");
 var isMessageFromRecall = (message) => {
   const provenance = message.options[provenanceOption];
   return typeof provenance === "object" && provenance !== null && !Array.isArray(provenance) && "origin" in provenance && provenance.origin === "memoryRecall";
@@ -311,27 +588,27 @@ var projectTranscript = (transcript) => {
   return content.length === transcript.content.length ? transcript : Prompt4.fromMessages(content);
 };
 
-class MemoryError extends Schema4.TaggedErrorClass()("@batonfx/core/MemoryError", {
-  message: Schema4.String
+class MemoryError extends Schema5.TaggedErrorClass()("@batonfx/core/MemoryError", {
+  message: Schema5.String
 }) {
 }
 
-class Memory extends Context.Service()("@batonfx/core/Memory") {
+class Memory extends Context2.Service()("@batonfx/core/Memory") {
 }
 var noop = {
-  recall: () => Effect2.succeed([]),
-  remember: () => Effect2.void,
-  forget: () => Effect2.void
+  recall: () => Effect3.succeed([]),
+  remember: () => Effect3.void,
+  forget: () => Effect3.void
 };
 var merge = dual2(2, (first, second) => ({
-  recall: (input) => Effect2.all([first.recall(input), second.recall(input)]).pipe(Effect2.map(([firstItems, secondItems]) => [...firstItems, ...secondItems])),
-  remember: (input) => Effect2.all([first.remember(input), second.remember(input)], { discard: true }),
-  forget: (input) => Effect2.all([first.forget(input), second.forget(input)], { discard: true })
+  recall: (input) => Effect3.all([first.recall(input), second.recall(input)]).pipe(Effect3.map(([firstItems, secondItems]) => [...firstItems, ...secondItems])),
+  remember: (input) => Effect3.all([first.remember(input), second.remember(input)], { discard: true }),
+  forget: (input) => Effect3.all([first.forget(input), second.forget(input)], { discard: true })
 }));
-var layerNoop = Layer2.succeed(Memory, Memory.of(noop));
-var layerTest = (implementation) => Layer2.succeed(Memory, Memory.of(implementation));
+var layerNoop2 = Layer3.succeed(Memory, Memory.of(noop));
+var layerTest = (implementation) => Layer3.succeed(Memory, Memory.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-registry.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-registry.js
 var exports_model_registry = {};
 __export(exports_model_registry, {
   stream: () => stream,
@@ -347,29 +624,73 @@ __export(exports_model_registry, {
   ModelRegistry: () => ModelRegistry,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered
 });
-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";
+import { Context as Context3, Effect as Effect4, Fiber, Function as Function2, HashMap, Layer as Layer4, Option as Option3, Ref, Schema as Schema6, Scope, Semaphore, Stream } from "effect";
+import { LanguageModel as LanguageModel3, Model } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/context-overflow.js
+var exports_context_overflow = {};
+__export(exports_context_overflow, {
+  classify: () => classify
+});
+import { AiError as AiError2 } from "effect/unstable/ai";
+var overflowEvidence = /context_length_exceeded|context_window_exceeded|context_window_overflow|input_too_long|maximum context length|context (?:window|length) (?:was |has been )?exceeded|exceeds? (?:the )?(?:context window|maximum number of tokens|model'?s? maximum context)|input (?:is )?too (?:long|large)|prompt is too long|too many (?:input )?tokens/i;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var overflowEligibleReasons = new Set(["InvalidRequestError", "UnknownError", "InvalidOutputError"]);
+var textFields = ["message", "description", "code", "errorCode", "errorType", "error_code", "error_type"];
+var nestedFields = ["error", "reason", "cause"];
+var evidence = (value, depth) => {
+  if (depth > 4 || value === null || value === undefined)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (AiError2.isAiError(value)) {
+    return overflowEligibleReasons.has(value.reason._tag) ? `${value.message} ${evidence(value.reason, depth + 1)}` : "";
+  }
+  if (!isRecord(value))
+    return "";
+  const parts = [];
+  for (const field of textFields) {
+    const candidate = value[field];
+    if (typeof candidate === "string")
+      parts.push(candidate);
+  }
+  for (const field of nestedFields) {
+    if (field in value)
+      parts.push(evidence(value[field], depth + 1));
+  }
+  if (isRecord(value.metadata)) {
+    for (const entry of Object.values(value.metadata))
+      parts.push(evidence(entry, depth + 1));
+  }
+  return parts.join(" ");
+};
+var classify = (error) => overflowEvidence.test(evidence(error, 0)) ? "context-overflow" : "other";
+
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-registry.js
 var FailureClassifierTypeId = Symbol.for("@batonfx/core/model-registry/FailureClassifier");
-var classifyFailure = Function2.dual(2, (model, error) => model[FailureClassifierTypeId]?.(error) ?? "other");
+var classifyFailure = Function2.dual(2, (model, error) => {
+  const classified = model[FailureClassifierTypeId]?.(error);
+  return classified !== undefined && classified !== "other" ? classified : classify(error);
+});
 var attachFailureClassifier = (registration, context) => {
   if (registration.classifyFailure === undefined)
     return context;
-  const model = Context2.get(context, LanguageModel2.LanguageModel);
+  const model = Context3.get(context, LanguageModel3.LanguageModel);
   const classified = {
     ...model,
     [FailureClassifierTypeId]: registration.classifyFailure
   };
-  return Context2.add(context, LanguageModel2.LanguageModel, classified);
+  return Context3.add(context, LanguageModel3.LanguageModel, classified);
 };
 
-class LanguageModelNotRegistered extends Schema5.TaggedErrorClass()("@batonfx/core/LanguageModelNotRegistered", {
-  provider: Schema5.String,
-  model: Schema5.String,
-  registration_key: Schema5.optionalKey(Schema5.String)
+class LanguageModelNotRegistered extends Schema6.TaggedErrorClass()("@batonfx/core/LanguageModelNotRegistered", {
+  provider: Schema6.String,
+  model: Schema6.String,
+  registration_key: Schema6.optionalKey(Schema6.String)
 }) {
 }
 
-class ModelRegistry extends Context2.Service()("@batonfx/core/ModelRegistry") {
+class ModelRegistry extends Context3.Service()("@batonfx/core/ModelRegistry") {
 }
 var selectionKey = (selection) => JSON.stringify([selection.provider, selection.model, selection.registrationKey ?? null]);
 var upsertRegistration = (registry, entry) => {
@@ -379,8 +700,8 @@ var upsertRegistration = (registry, 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) => ({
+var findRegistration = (registry, selection) => HashMap.get(registry.byKey, selectionKey(selection)).pipe(Option3.getOrUndefined);
+var registration = (input) => Model.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect4.map((layer) => ({
   provider: input.provider,
   model: input.model,
   layer,
@@ -388,28 +709,28 @@ var registration = (input) => Model.make(input.provider, input.model, input.laye
   ...input.metadata === undefined ? {} : { metadata: input.metadata },
   ...input.classifyFailure === undefined ? {} : { classifyFailure: input.classifyFailure }
 })));
-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, {
+var makeLayer = (initialRegistrations, options) => Layer4.effect(ModelRegistry, Effect4.gen(function* () {
+  const memoMap = yield* Layer4.makeMemoMap;
+  const scope = yield* Effect4.scope;
+  const makeEntry = Effect4.fnUntraced(function* (candidate) {
+    const fiber = yield* Effect4.cached(Effect4.forkIn(Layer4.buildWithMemoMap(candidate.layer, memoMap, scope), scope, {
       startImmediately: true
     }));
-    const context = Effect3.uninterruptible(fiber).pipe(Effect3.flatMap(Fiber.join));
+    const context = Effect4.uninterruptible(fiber).pipe(Effect4.flatMap(Fiber.join));
     return { registration: candidate, context };
   });
-  const initialEntries = yield* Effect3.forEach(initialRegistrations, makeEntry);
+  const initialEntries = yield* Effect4.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) {
+  const register = Effect4.fn("ModelRegistry.register")(function* (input) {
     const entry = yield* makeEntry(input.registration);
     yield* Ref.update(registry, (items) => upsertRegistration(items, entry));
   });
-  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 registrations = Ref.get(registry).pipe(Effect4.map((items) => items.keys.map((key) => HashMap.getUnsafe(items.byKey, key).registration)));
+  const operate = Effect4.fn("ModelRegistry.operate")(function* (selection, effect) {
     const items = yield* Ref.get(registry);
     const entry = findRegistration(items, selection);
     if (entry === undefined) {
@@ -419,10 +740,10 @@ var makeLayer = (initialRegistrations, options) => Layer3.effect(ModelRegistry,
         ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
       });
     }
-    const provided = entry.context.pipe(Effect3.flatMap((context) => effect.pipe(Effect3.provide(attachFailureClassifier(entry.registration, context)))));
+    const provided = entry.context.pipe(Effect4.flatMap((context) => effect.pipe(Effect4.provide(attachFailureClassifier(entry.registration, context)))));
     return yield* semaphore === undefined ? provided : semaphore.withPermits(1)(provided);
   });
-  const stream = (selection, operation) => Stream.unwrap(Effect3.gen(function* () {
+  const stream = (selection, operation) => Stream.unwrap(Effect4.gen(function* () {
     const items = yield* Ref.get(registry);
     const entry = findRegistration(items, selection);
     if (entry === undefined) {
@@ -433,7 +754,7 @@ var makeLayer = (initialRegistrations, options) => Layer3.effect(ModelRegistry,
       });
     }
     if (semaphore !== undefined) {
-      yield* Effect3.acquireRelease(semaphore.take(1), () => semaphore.release(1), { interruptible: true });
+      yield* Effect4.acquireRelease(semaphore.take(1), () => semaphore.release(1), { interruptible: true });
     }
     const context = attachFailureClassifier(entry.registration, yield* entry.context);
     return operation.pipe(Stream.provideContext(context));
@@ -445,43 +766,43 @@ var makeLayer = (initialRegistrations, options) => Layer3.effect(ModelRegistry,
     stream
   });
 }));
-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 layer = Function2.dual((args) => args.length === 0 || args.length > 1 || Array.isArray(args[0]), (registrations = [], options) => Layer4.unwrap(Effect4.all(registrations).pipe(Effect4.map((initialRegistrations) => makeLayer(initialRegistrations, options)))));
+var layerCombined = Function2.dual((args) => args.length !== 1 || Array.isArray(args[0]), (registries, options) => Layer4.unwrap(Effect4.forEach(registries, (registry) => Layer4.build(registry).pipe(Effect4.flatMap((context) => Context3.get(context, ModelRegistry).registrations))).pipe(Effect4.map((groups) => makeLayer(groups.flat(), options)))));
 var layerMemory = layer;
-var layerTest2 = (implementation) => Layer3.succeed(ModelRegistry, ModelRegistry.of(implementation));
-var register = Effect3.fn("ModelRegistry.register.call")(function* (input) {
+var layerTest2 = (implementation) => Layer4.succeed(ModelRegistry, ModelRegistry.of(implementation));
+var register = Effect4.fn("ModelRegistry.register.call")(function* (input) {
   const service = yield* ModelRegistry;
   return yield* service.register(input);
 });
-var registrations = Effect3.fn("ModelRegistry.registrations.call")(function* () {
+var registrations = Effect4.fn("ModelRegistry.registrations.call")(function* () {
   const service = yield* ModelRegistry;
   return yield* service.registrations;
 });
-var operate = Function2.dual(2, (selection, effect) => Effect3.gen(function* () {
+var operate = Function2.dual(2, (selection, effect) => Effect4.gen(function* () {
   const service = yield* ModelRegistry;
   return yield* service.operate(selection, effect);
 }));
-var stream = Function2.dual(2, (selection, operation) => Stream.unwrap(ModelRegistry.pipe(Effect3.map((service) => service.stream(selection, operation)))));
+var stream = Function2.dual(2, (selection, operation) => Stream.unwrap(ModelRegistry.pipe(Effect4.map((service) => service.stream(selection, operation)))));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-context.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-context.js
 var exports_tool_context = {};
 __export(exports_tool_context, {
   layerTest: () => layerTest3,
   layerDefault: () => layerDefault,
   ToolContext: () => ToolContext
 });
-import { Context as Context3, Effect as Effect4, Layer as Layer4 } from "effect";
+import { Context as Context4, Effect as Effect5, Layer as Layer5 } from "effect";
 
-class ToolContext extends Context3.Service()("@batonfx/core/ToolContext") {
+class ToolContext extends Context4.Service()("@batonfx/core/ToolContext") {
 }
-var layerDefault = Layer4.sync(ToolContext, () => ToolContext.of({
+var layerDefault = Layer5.sync(ToolContext, () => ToolContext.of({
   signal: new AbortController().signal,
-  emit: () => Effect4.void,
+  emit: () => Effect5.void,
   sessionId: "local"
 }));
-var layerTest3 = (implementation) => Layer4.succeed(ToolContext, ToolContext.of(implementation));
+var layerTest3 = (implementation) => Layer5.succeed(ToolContext, ToolContext.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-executor.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-executor.js
 var exports_tool_executor = {};
 __export(exports_tool_executor, {
   sandbox: () => sandbox,
@@ -499,16 +820,16 @@ __export(exports_tool_executor, {
   FrameworkStage: () => FrameworkStage,
   FrameworkFailure: () => FrameworkFailure
 });
-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";
+import { Context as Context5, Effect as Effect8, Layer as Layer6, Option as Option4, Schema as Schema8, Stream as Stream2 } from "effect";
+import { AiError as AiError4, Response as Response4, Tool as Tool4, Toolkit } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-placement.js
-import { Effect as Effect6, Schedule } from "effect";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-placement.js
+import { Effect as Effect7, Schedule } from "effect";
 import { Tool as Tool3 } from "effect/unstable/ai";
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-result-codec.js
+import { Effect as Effect6, Schema as Schema7 } from "effect";
+import { AiError as AiError3, Tool as Tool2 } from "effect/unstable/ai";
 var resultMessage = (result) => {
   if (typeof result === "string")
     return result;
@@ -525,20 +846,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 Schema6.encodeUnknownEffect(schema)(result).pipe(Effect5.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
+  return Schema7.encodeUnknownEffect(schema)(result).pipe(Effect6.map((encodedResult) => ({ _tag: "Success", result, encodedResult })), Effect6.mapError((error) => frameworkFailure("encode-success", tool.name, error)));
 };
 var encodeDomainFailure = (tool, failure) => {
   const schema = tool.failureSchema;
-  return Schema6.encodeUnknownEffect(schema)(failure).pipe(Effect5.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect5.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
+  return Schema7.encodeUnknownEffect(schema)(failure).pipe(Effect6.map((encodedFailure) => ({ _tag: "DomainFailure", failure, encodedFailure })), Effect6.mapError((error) => frameworkFailure("encode-domain-failure", tool.name, error)));
 };
-var encodeDomainCandidate = (tool, failure) => !Schema6.is(tool.failureSchema)(failure) ? Effect5.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
+var encodeDomainCandidate = (tool, failure) => !Schema7.is(tool.failureSchema)(failure) ? Effect6.fail(frameworkFailure("handler", tool.name, failure)) : encodeDomainFailure(tool, failure);
 var decodeInput = (tool, input) => {
   const schema = tool.parametersSchema;
-  return Schema6.decodeUnknownEffect(schema)(input).pipe(Effect5.asVoid, Effect5.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
+  return Schema7.decodeUnknownEffect(schema)(input).pipe(Effect6.asVoid, Effect6.mapError((error) => frameworkFailure("decode-input", tool.name, error)));
 };
 var decodeSuccess = (tool, result) => {
   const schema = tool.successSchema;
-  return Schema6.decodeUnknownEffect(schema)(result).pipe(Effect5.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect5.flatMap((decoded) => encodeSuccess(tool, decoded)));
+  return Schema7.decodeUnknownEffect(schema)(result).pipe(Effect6.mapError((error) => frameworkFailure("encode-success", tool.name, error)), Effect6.flatMap((decoded) => encodeSuccess(tool, decoded)));
 };
 var aiFrameworkFailure = (tool, error) => {
   switch (error.reason._tag) {
@@ -551,8 +872,8 @@ var aiFrameworkFailure = (tool, error) => {
     case "ToolResultEncodingError": {
       if (tool.failureMode === "error")
         return frameworkFailure("encode-success", tool.name, error);
-      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);
+      const isSuccess = Schema7.isSchema(tool.successSchema) && Schema7.is(tool.successSchema)(error.reason.toolResult);
+      const isDomainFailure = Schema7.isSchema(tool.failureSchema) && Schema7.is(tool.failureSchema)(error.reason.toolResult);
       return frameworkFailure(isSuccess === isDomainFailure ? "handler" : isDomainFailure ? "encode-domain-failure" : "encode-success", tool.name, error);
     }
     default:
@@ -571,26 +892,26 @@ var toolResultCodec = {
   schemaMessage
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-placement.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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"));
+    return Effect7.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an invalid response"));
   }
   switch (response._tag) {
     case "DomainFailure":
-      return "failure" in response ? toolResultCodec.encodeDomainFailure(tool, response.failure) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "DomainFailure response is missing failure"));
+      return "failure" in response ? toolResultCodec.encodeDomainFailure(tool, response.failure) : Effect7.fail(toolResultCodec.frameworkFailure("placement", tool.name, "DomainFailure response is missing failure"));
     case "Suspend":
-      return "token" in response && typeof response.token === "string" ? Effect6.succeed({ _tag: "Suspend", token: response.token }) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Suspend response is missing a string token"));
+      return "token" in response && typeof response.token === "string" ? Effect7.succeed({ _tag: "Suspend", token: response.token }) : Effect7.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Suspend response is missing a string token"));
     case "Success":
-      return "result" in response ? toolResultCodec.decodeSuccess(tool, response.result).pipe(Effect6.mapError((error) => FrameworkFailure.make({ ...error, message: `${placement} result: ${error.message}` }))) : Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Success response is missing result"));
+      return "result" in response ? toolResultCodec.decodeSuccess(tool, response.result).pipe(Effect7.mapError((error) => FrameworkFailure.make({ ...error, message: `${placement} result: ${error.message}` }))) : Effect7.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Success response is missing result"));
     default:
-      return Effect6.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an unknown response tag"));
+      return Effect7.fail(toolResultCodec.frameworkFailure("placement", tool.name, "Placement returned an unknown response tag"));
   }
 };
 var placementOutcome = { fromResponse: placementOutcomeFromResponse };
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-executor.js
-var FrameworkStage = Schema7.Literals([
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-executor.js
+var FrameworkStage = Schema8.Literals([
   "decode-input",
   "handler",
   "encode-success",
@@ -601,44 +922,44 @@ var FrameworkStage = Schema7.Literals([
   "authorization"
 ]);
 
-class FrameworkFailure extends Schema7.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
+class FrameworkFailure extends Schema8.TaggedErrorClass()("@batonfx/core/FrameworkFailure", {
   stage: FrameworkStage,
-  tool: Schema7.String,
-  message: Schema7.String
+  tool: Schema8.String,
+  message: Schema8.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 RemoteRetryMisconfigured extends Schema8.TaggedErrorClass()("@batonfx/core/RemoteRetryMisconfigured", {
+  reason: Schema8.Literals(["invalid-max-retries", "missing-operation-key", "changed-operation-key"]),
+  message: Schema8.String
 }) {
 }
 
-class ToolExecutor extends Context4.Service()("@batonfx/core/ToolExecutor") {
+class ToolExecutor extends Context5.Service()("@batonfx/core/ToolExecutor") {
 }
 var findTool = (tools, name) => tools[name];
 var executeWithToolkit = (toolkit, request) => {
   const tool = findTool(toolkit.tools, request.call.name);
   if (tool === undefined) {
-    return Effect7.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
+    return Effect8.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
   }
   const handleFailure = (error) => {
-    if (Schema7.is(FrameworkFailure)(error))
-      return Effect7.fail(error);
-    if (AiError2.isAiError(error))
-      return Effect7.fail(toolResultCodec.aiFrameworkFailure(tool, error));
+    if (Schema8.is(FrameworkFailure)(error))
+      return Effect8.fail(error);
+    if (AiError4.isAiError(error))
+      return Effect8.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.runLast)), Effect7.flatMap((option) => {
-    if (Option3.isNone(option)) {
-      return Effect7.fail(toolResultCodec.frameworkFailure("handler", tool.name, "Tool handler did not produce a final result"));
+  return toolkit.handle(request.call.name, request.call.params).pipe(Effect8.flatMap((results) => results.pipe(Stream2.filter((item) => item.preliminary === false), Stream2.runLast)), Effect8.flatMap((option) => {
+    if (Option4.isNone(option)) {
+      return Effect8.fail(toolResultCodec.frameworkFailure("handler", tool.name, "Tool handler did not produce a final result"));
     }
     const result = option.value;
     if (!result.isFailure) {
-      return Effect7.succeed({ _tag: "Success", result: result.result, encodedResult: result.encodedResult });
+      return Effect8.succeed({ _tag: "Success", result: result.result, encodedResult: result.encodedResult });
     }
-    return AiError2.isAiError(result.result) ? Effect7.fail(toolResultCodec.aiFrameworkFailure(tool, result.result)) : toolResultCodec.encodeDomainFailure(tool, result.result);
-  }), Effect7.catchIf(() => true, handleFailure, handleFailure));
+    return AiError4.isAiError(result.result) ? Effect8.fail(toolResultCodec.aiFrameworkFailure(tool, result.result)) : toolResultCodec.encodeDomainFailure(tool, result.result);
+  }), Effect8.catchIf(() => true, handleFailure, handleFailure));
 };
 function executeToolkit(toolkitOrRequest, request) {
   if (request === undefined) {
@@ -649,10 +970,10 @@ function executeToolkit(toolkitOrRequest, request) {
     return pipeable;
   }
   const toolkit = toolkitOrRequest;
-  return ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.flatMap((handled) => executeWithToolkit(handled, request)));
+  return ("handle" in toolkit ? Effect8.succeed(toolkit) : toolkit).pipe(Effect8.flatMap((handled) => executeWithToolkit(handled, request)));
 }
 function layerToolkit(toolkit) {
-  return Layer5.effect(ToolExecutor, ("handle" in toolkit ? Effect7.succeed(toolkit) : toolkit).pipe(Effect7.map((handled) => ToolExecutor.of({
+  return Layer6.effect(ToolExecutor, ("handle" in toolkit ? Effect8.succeed(toolkit) : toolkit).pipe(Effect8.map((handled) => ToolExecutor.of({
     execute: (request) => executeWithToolkit(handled, request)
   }))));
 }
@@ -671,37 +992,37 @@ var placementRoute = (placement, options) => {
     execute: (request) => {
       const tool = findTool(options.toolkit.tools, request.call.name);
       if (tool === undefined) {
-        return Effect7.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
+        return Effect8.fail(toolResultCodec.frameworkFailure("missing-handler", request.call.name, `Tool ${request.call.name} is not registered`));
       }
-      return toolResultCodec.decodeInput(tool, request.call.params).pipe(Effect7.flatMap(() => {
+      return toolResultCodec.decodeInput(tool, request.call.params).pipe(Effect8.flatMap(() => {
         const effect = options.execute({ ...request, placement, tool });
         return effect;
-      }), 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)));
+      }), Effect8.mapError((error) => Schema8.is(FrameworkFailure)(error) || Schema8.is(RemoteRetryMisconfigured)(error) ? error : toolResultCodec.frameworkFailure("placement", request.call.name, error)), Effect8.flatMap((response) => placementOutcome.fromResponse(placement, tool, response)));
     }
   });
 };
 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(() => {
+var validateOperationKey = (operationKey) => typeof operationKey !== "string" || operationKey.trim().length === 0 ? Effect8.fail(remoteRetryError("missing-operation-key", "Remote retry operation key must be non-empty")) : Effect8.succeed(operationKey);
+var retryRemote = (options, request) => Effect8.suspend(() => {
   if (!Number.isFinite(options.maxRetries) || !Number.isInteger(options.maxRetries) || options.maxRetries < 0) {
-    return Effect7.fail(remoteRetryError("invalid-max-retries", "Remote retry maxRetries must be a non-negative finite integer"));
+    return Effect8.fail(remoteRetryError("invalid-max-retries", "Remote retry maxRetries must be a non-negative finite integer"));
   }
   const operationKey = typeof options.operationKey === "function" ? options.operationKey(request) : undefined;
-  return validateOperationKey(operationKey).pipe(Effect7.flatMap((stableKey) => {
+  return validateOperationKey(operationKey).pipe(Effect8.flatMap((stableKey) => {
     let attempt = 0;
-    const executeAttempt = Effect7.suspend(() => {
+    const executeAttempt = Effect8.suspend(() => {
       const currentKey = attempt === 0 ? stableKey : options.operationKey(request);
       attempt += 1;
-      return validateOperationKey(currentKey).pipe(Effect7.match({
+      return validateOperationKey(currentKey).pipe(Effect8.match({
         onFailure: (error) => error,
         onSuccess: (validatedKey) => validatedKey
-      }), Effect7.flatMap((validatedKey) => typeof validatedKey !== "string" ? Effect7.succeed(validatedKey) : validatedKey === stableKey ? options.execute({ ...request, operationKey: stableKey }) : Effect7.succeed(remoteRetryError("changed-operation-key", "Remote retry operation key changed between attempts"))));
+      }), Effect8.flatMap((validatedKey) => typeof validatedKey !== "string" ? Effect8.succeed(validatedKey) : validatedKey === stableKey ? options.execute({ ...request, operationKey: stableKey }) : Effect8.succeed(remoteRetryError("changed-operation-key", "Remote retry operation key changed between attempts"))));
     });
-    return Effect7.retry(executeAttempt, {
+    return Effect8.retry(executeAttempt, {
       schedule: options.schedule,
       times: options.maxRetries,
-      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)));
+      while: (error) => !Schema8.is(AgentError)(error) && !Schema8.is(FrameworkFailure)(error) && !Schema8.is(RemoteRetryMisconfigured)(error)
+    }).pipe(Effect8.flatMap((result) => Schema8.is(RemoteRetryMisconfigured)(result) ? Effect8.fail(result) : Effect8.succeed(result)));
   }));
 });
 var client = (options) => placementRoute("client", options);
@@ -717,20 +1038,20 @@ function routeToolkit(toolkit) {
     tools: Object.keys(handled.tools),
     execute: (request) => executeWithToolkit(handled, request)
   });
-  return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect7.map(makeRoute));
+  return "handle" in toolkit ? makeRoute(toolkit) : toolkit.pipe(Effect8.map(makeRoute));
 }
-var routeInputEffect = (input) => Effect7.isEffect(input) ? input : Effect7.succeed(input);
+var routeInputEffect = (input) => Effect8.isEffect(input) ? input : Effect8.succeed(input);
 function layerRouter(routes) {
-  return Layer5.effect(ToolExecutor, Effect7.all(Array.from(routes, routeInputEffect)).pipe(Effect7.map((resolved) => ToolExecutor.of({
+  return Layer6.effect(ToolExecutor, Effect8.all(Array.from(routes, routeInputEffect)).pipe(Effect8.map((resolved) => ToolExecutor.of({
     execute: (request) => {
       const matched = resolved.find((candidate) => candidate.matches(request));
-      return matched === undefined ? Effect7.fail(toolResultCodec.frameworkFailure("route", request.call.name, `Tool ${request.call.name} has no matching route`)) : matched.execute(request);
+      return matched === undefined ? Effect8.fail(toolResultCodec.frameworkFailure("route", request.call.name, `Tool ${request.call.name} has no matching route`)) : matched.execute(request);
     }
   }))));
 }
-var layerTest4 = (implementation) => Layer5.succeed(ToolExecutor, ToolExecutor.of(implementation));
+var layerTest4 = (implementation) => Layer6.succeed(ToolExecutor, ToolExecutor.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/approvals.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/approvals.js
 var exports_approvals = {};
 __export(exports_approvals, {
   layerTest: () => layerTest5,
@@ -738,39 +1059,41 @@ __export(exports_approvals, {
   layerAutoApprove: () => layerAutoApprove,
   Approvals: () => Approvals
 });
-import { Context as Context5, Effect as Effect8, Layer as Layer6 } from "effect";
+import { Context as Context6, Effect as Effect9, Layer as Layer7 } from "effect";
 
-class Approvals extends Context5.Service()("@batonfx/core/Approvals") {
+class Approvals extends Context6.Service()("@batonfx/core/Approvals") {
 }
-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));
+var layerAutoApprove = Layer7.succeed(Approvals, Approvals.of({ resolve: () => Effect9.succeed({ _tag: "Approved" }) }));
+var layerDenyAll = Layer7.succeed(Approvals, Approvals.of({ resolve: () => Effect9.succeed({ _tag: "Denied" }) }));
+var layerTest5 = (implementation) => Layer7.succeed(Approvals, Approvals.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/session.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/session.js
 var exports_session = {};
 __export(exports_session, {
   layerTest: () => layerTest6,
   layerMemory: () => layerMemory2,
+  checkpointMatches: () => checkpointMatches,
   buildMemoryContext: () => buildMemoryContext,
   buildContext: () => buildContext,
   SessionStoreError: () => SessionStoreError,
   SessionStore: () => SessionStore,
   SessionConflict: () => SessionConflict
 });
-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 { Context as Context7, Effect as Effect10, HashMap as HashMap2, Layer as Layer8, Option as Option5, Ref as Ref2, Schema as Schema9 } from "effect";
+import { dual as dual3 } from "effect/Function";
 import { Prompt as Prompt5 } from "effect/unstable/ai";
-class SessionStoreError extends Schema8.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
-  message: Schema8.String
+class SessionStoreError extends Schema9.TaggedErrorClass()("@batonfx/core/SessionStoreError", {
+  message: Schema9.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 SessionConflict extends Schema9.TaggedErrorClass()("@batonfx/core/SessionConflict", {
+  reason: Schema9.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]),
+  message: Schema9.String
 }) {
 }
 
-class SessionStore extends Context6.Service()("@batonfx/core/SessionStore") {
+class SessionStore extends Context7.Service()("@batonfx/core/SessionStore") {
 }
 var initialState = {
   entries: HashMap2.empty(),
@@ -783,8 +1106,8 @@ var failure = (message) => ({
   _tag: "Failure",
   error: SessionStoreError.make({ message })
 });
-var effectFromResult = (result) => result._tag === "Failure" ? Effect9.fail(result.error) : Effect9.succeed(result.value);
-var effectFromAppendResult = (result) => result._tag === "@batonfx/core/SessionConflict" ? Effect9.fail(result) : effectFromResult(result);
+var effectFromResult = (result) => result._tag === "Failure" ? Effect10.fail(result.error) : Effect10.succeed(result.value);
+var effectFromAppendResult = (result) => result._tag === "@batonfx/core/SessionConflict" ? Effect10.fail(result) : effectFromResult(result);
 var entryFromInput = (input, id, parentId) => {
   const base = {
     id,
@@ -819,7 +1142,7 @@ var pathFromState = (state, leaf) => {
     if (entries.length > state.order.length)
       return failure(`Session path for leaf ${leaf} contains a cycle`);
     const entry = HashMap2.get(state.entries, cursor);
-    if (Option4.isNone(entry))
+    if (Option5.isNone(entry))
       return failure(`Session entry ${cursor} does not exist`);
     const value = entry.value;
     entries.push(value);
@@ -865,11 +1188,22 @@ var appendState = (state, input, options) => {
     }
   ];
 };
-var promptEquivalence = Schema8.toEquivalence(Prompt5.Prompt);
-var checkpointMatches = (entry, prepared) => entry.parentId === prepared.parentId && entry.summary === prepared.summary && promptEquivalence(entry.projectedHistory, prepared.projectedHistory);
+var promptEquivalence = Schema9.toEquivalence(Prompt5.Prompt);
+var telemetryEquivalence = Schema9.toEquivalence(Schema9.Array(Event));
+var commitEquivalence = Schema9.toEquivalence(CompactionCommit);
+var checkpointMatches = dual3(2, (entry, prepared) => entry.id === prepared.id && entry.parentId === prepared.parentId && entry.summary === prepared.summary && promptEquivalence(entry.projectedHistory, prepared.projectedHistory) && telemetryEquivalence(entry.telemetry, prepared.telemetry) && (entry.compactionCommit === undefined ? prepared.compactionCommit === undefined : prepared.compactionCommit !== undefined && commitEquivalence(entry.compactionCommit, prepared.compactionCommit)));
 var appendCheckpointState = (state, prepared) => {
+  if (prepared.compactionCommit !== undefined && prepared.compactionCommit.checkpointId !== prepared.id) {
+    return [
+      SessionConflict.make({
+        reason: "checkpoint-id-reused",
+        message: `Compaction commit checkpoint id ${prepared.compactionCommit.checkpointId} does not match ${prepared.id}`
+      }),
+      state
+    ];
+  }
   const existing = HashMap2.get(state.entries, prepared.id);
-  if (Option4.isSome(existing)) {
+  if (Option5.isSome(existing)) {
     const entry = existing.value;
     if (entry._tag !== "Compaction" || entry.version !== 2 || !checkpointMatches(entry, prepared)) {
       return [
@@ -913,6 +1247,8 @@ var appendCheckpointState = (state, prepared) => {
     id: prepared.id,
     parentId: prepared.parentId,
     projectedHistory: prepared.projectedHistory,
+    telemetry: prepared.telemetry,
+    ...prepared.compactionCommit === undefined ? {} : { compactionCommit: prepared.compactionCommit },
     ...prepared.summary === undefined ? {} : { summary: prepared.summary }
   };
   return [
@@ -926,7 +1262,7 @@ var appendCheckpointState = (state, prepared) => {
   ];
 };
 var setLeafState = (state, id) => {
-  if (id !== null && Option4.isNone(HashMap2.get(state.entries, id)))
+  if (id !== null && Option5.isNone(HashMap2.get(state.entries, id)))
     return [failure(`Session entry ${id} does not exist`), state];
   return [success(undefined), { ...state, leaf: id }];
 };
@@ -1010,45 +1346,45 @@ var buildMemoryContext = (path) => {
   });
   return projectTranscript(Prompt5.fromMessages(messages));
 };
-var layerMemory2 = Layer7.effect(SessionStore, Ref2.make(initialState).pipe(Effect9.map((state) => SessionStore.of({
+var layerMemory2 = Layer8.effect(SessionStore, Ref2.make(initialState).pipe(Effect10.map((state) => SessionStore.of({
   reserveEntryId: Ref2.modify(state, (current) => [
     String(current.counter),
     { ...current, counter: current.counter + 1 }
   ]),
-  append: (entry, options) => Ref2.modify(state, (current) => appendState(current, entry, options)).pipe(Effect9.flatMap(effectFromAppendResult)),
-  appendCheckpoint: (checkpoint) => Ref2.modify(state, (current) => appendCheckpointState(current, checkpoint)).pipe(Effect9.flatMap((result) => result._tag === "@batonfx/core/SessionConflict" ? Effect9.fail(result) : Effect9.succeed(result))),
-  path: (leaf) => Ref2.get(state).pipe(Effect9.flatMap((current) => leaf === undefined && current.leaf === null ? Effect9.succeed([]) : effectFromResult(pathFromState(current, leaf ?? current.leaf ?? "")))),
-  setLeaf: (id) => Ref2.modify(state, (current) => setLeafState(current, id)).pipe(Effect9.flatMap(effectFromResult)),
-  leaf: Ref2.get(state).pipe(Effect9.map((current) => current.leaf))
+  append: (entry, options) => Ref2.modify(state, (current) => appendState(current, entry, options)).pipe(Effect10.flatMap(effectFromAppendResult)),
+  appendCheckpoint: (checkpoint) => Ref2.modify(state, (current) => appendCheckpointState(current, checkpoint)).pipe(Effect10.flatMap((result) => result._tag === "@batonfx/core/SessionConflict" ? Effect10.fail(result) : Effect10.succeed(result))),
+  path: (leaf) => Ref2.get(state).pipe(Effect10.flatMap((current) => leaf === undefined && current.leaf === null ? Effect10.succeed([]) : effectFromResult(pathFromState(current, leaf ?? current.leaf ?? "")))),
+  setLeaf: (id) => Ref2.modify(state, (current) => setLeafState(current, id)).pipe(Effect10.flatMap(effectFromResult)),
+  leaf: Ref2.get(state).pipe(Effect10.map((current) => current.leaf))
 }))));
-var layerTest6 = (implementation) => Layer7.succeed(SessionStore, SessionStore.of(implementation));
+var layerTest6 = (implementation) => Layer8.succeed(SessionStore, SessionStore.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/tool-output.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-output.js
 var exports_tool_output = {};
 __export(exports_tool_output, {
   layerTest: () => layerTest7,
-  layerNoop: () => layerNoop2,
+  layerNoop: () => layerNoop3,
   layerMemory: () => layerMemory3,
   bound: () => bound,
   ToolOutputStore: () => ToolOutputStore,
   ToolOutputError: () => ToolOutputError
 });
-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") {
+import { Cause as Cause2, Context as Context8, Effect as Effect11, Function as Function3, HashMap as HashMap3, Layer as Layer9, Option as Option6, Ref as Ref3, Schema as Schema10 } from "effect";
+class ToolOutputStore extends Context8.Service()("@batonfx/core/ToolOutputStore") {
 }
 
-class ToolOutputError extends Schema9.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
-  message: Schema9.String
+class ToolOutputError extends Schema10.TaggedErrorClass()("@batonfx/core/ToolOutputError", {
+  message: Schema10.String
 }) {
 }
-var layerNoop2 = Layer8.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect10.succeed(Option5.none()) }));
-var layerMemory3 = Layer8.effect(ToolOutputStore, Ref3.make({ next: 0, records: HashMap3.empty() }).pipe(Effect10.map((state) => ToolOutputStore.of({
+var layerNoop3 = Layer9.succeed(ToolOutputStore, ToolOutputStore.of({ put: () => Effect11.succeed(Option6.none()) }));
+var layerMemory3 = Layer9.effect(ToolOutputStore, Ref3.make({ next: 0, records: HashMap3.empty() }).pipe(Effect11.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: HashMap3.set(records, id, { toolCallId, content }) }];
+    return [Option6.some(id), { next: next + 1, records: HashMap3.set(records, id, { toolCallId, content }) }];
   })
 }))));
-var layerTest7 = (implementation) => Layer8.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
+var layerTest7 = (implementation) => Layer9.succeed(ToolOutputStore, ToolOutputStore.of(implementation));
 var encoder = new TextEncoder;
 var decoder = new TextDecoder;
 var serialized = (value) => {
@@ -1073,11 +1409,11 @@ var bounded = (inline, outputPaths) => {
   return { _tag: "Success", result: output, encodedResult: output, outputPaths };
 };
 var boundedFromOriginal = (encoded, bytes, maxBytes, outputPaths) => bounded({ truncated: true, bytes, maxBytes, preview: preview(encoded, maxBytes) }, outputPaths);
-var optionalStore = (store, toolCallId, result) => store.put(toolCallId, { result: result.result, encodedResult: result.encodedResult }).pipe(Effect10.catchCause((cause) => {
-  const unrecoverable = cause.reasons.filter((reason) => Cause.isDieReason(reason) || Cause.isInterruptReason(reason));
-  return unrecoverable.length === 0 ? Effect10.succeed(Option5.none()) : Effect10.failCause(Cause.fromReasons(unrecoverable));
+var optionalStore = (store, toolCallId, result) => store.put(toolCallId, { result: result.result, encodedResult: result.encodedResult }).pipe(Effect11.catchCause((cause) => {
+  const unrecoverable = cause.reasons.filter((reason) => Cause2.isDieReason(reason) || Cause2.isInterruptReason(reason));
+  return unrecoverable.length === 0 ? Effect11.succeed(Option6.none()) : Effect11.failCause(Cause2.fromReasons(unrecoverable));
 }));
-var bound = Function3.dual(2, (result, options) => Effect10.gen(function* () {
+var bound = Function3.dual(2, (result, options) => Effect11.gen(function* () {
   if (isToolOutput(result.encodedResult)) {
     const output = result.encodedResult;
     const outputPaths = output.outputPaths ?? [];
@@ -1090,18 +1426,19 @@ var bound = Function3.dual(2, (result, options) => Effect10.gen(function* () {
   const bytes = encoder.encode(encoded).byteLength;
   if (bytes <= options.maxBytes)
     return { ...result, outputPaths: [] };
-  const maybeStore = yield* Effect10.serviceOption(ToolOutputStore);
-  if (Option5.isNone(maybeStore))
+  const maybeStore = yield* Effect11.serviceOption(ToolOutputStore);
+  if (Option6.isNone(maybeStore))
     return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
   const path = yield* optionalStore(maybeStore.value, options.toolCallId, result);
-  if (Option5.isNone(path))
+  if (Option6.isNone(path))
     return boundedFromOriginal(encoded, bytes, options.maxBytes, []);
   return boundedFromOriginal(encoded, bytes, options.maxBytes, [path.value]);
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/compaction.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/compaction.js
 var exports_compaction = {};
 __export(exports_compaction, {
+  withLifecycle: () => withLifecycle,
   truncate: () => truncate,
   toolOutputBound: () => toolOutputBound,
   structuredSummary: () => structuredSummary,
@@ -1118,35 +1455,71 @@ __export(exports_compaction, {
   Compaction: () => Compaction,
   AgentSummary: () => AgentSummary
 });
-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";
+import { Context as Context10, Effect as Effect14, Function as Function5, Layer as Layer11, Option as Option8, Schema as Schema11 } from "effect";
+import { LanguageModel as LanguageModel6, Prompt as Prompt6, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
+
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/compaction-telemetry.js
+import { Clock, Effect as Effect12, Exit, Function as Function4, Option as Option7 } from "effect";
+import { LanguageModel as LanguageModel4 } from "effect/unstable/ai";
+var resultKind = (result) => Option7.isNone(result) ? "unchanged" : result.value._tag === "Summarize" ? "summarize" : "microcompact";
+var withCompactionLifecycle = Function4.dual(3, (work, input, usage) => Effect12.gen(function* () {
+  const instrumentation = yield* CurrentInstrumentation;
+  if (instrumentation === undefined)
+    return yield* work;
+  const turn = input.turn;
+  const compactionId = input.compactionId;
+  const startedAt = yield* Clock.currentTimeMillis;
+  yield* instrumentation.emit({
+    _tag: "CompactionStarted",
+    turn,
+    compactionId,
+    trigger: input.overflow ? "overflow" : "threshold",
+    startedAt,
+    contextTokensBefore: usage.contextTokens,
+    entriesBefore: input.history.content.length + input.prompt.content.length
+  });
+  const summaryCell = { current: undefined };
+  return yield* work.pipe(Effect12.provideService(CurrentCompactionId, compactionId), Effect12.provideService(CurrentPurpose, "compaction-summary"), Effect12.provideService(CurrentSummaryCall, summaryCell), Effect12.onExit((exit) => Effect12.flatMap(Clock.currentTimeMillis, (at) => Exit.isSuccess(exit) ? instrumentation.emit({
+    _tag: "CompactionCompleted",
+    turn,
+    compactionId,
+    kind: resultKind(exit.value),
+    completedAt: at,
+    ...summaryCell.current === undefined ? {} : { summaryModelCallId: summaryCell.current }
+  }) : instrumentation.emit({ _tag: "CompactionFailed", turn, compactionId, failedAt: at }))));
+}));
+var summaryLanguageModel = Effect12.gen(function* () {
+  const instrumentation = yield* CurrentInstrumentation;
+  const model = yield* LanguageModel4.LanguageModel;
+  return instrumentation === undefined ? model : instrumentation.wrap(model);
+});
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/summary-model.js
+import { Context as Context9, Deferred, Effect as Effect13, Fiber as Fiber2, Layer as Layer10, Scope as Scope2 } from "effect";
+import { LanguageModel as LanguageModel5 } 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);
+  return (effect) => Effect13.contextWith((context) => {
+    const memoMap = Context9.getOrUndefined(context, Layer10.CurrentMemoMap);
+    const scope = Context9.getOrUndefined(context, Scope2.Scope);
     if (memoMap === undefined || scope === undefined) {
-      return Effect11.scoped(Layer9.build(model).pipe(Effect11.flatMap((modelContext) => effect.pipe(Effect11.provide(modelContext)))));
+      return Effect13.scoped(Layer10.build(model).pipe(Effect13.flatMap((modelContext) => effect.pipe(Effect13.provide(modelContext)))));
     }
-    const sharedFiber = Effect11.uninterruptible(Effect11.sync(() => {
+    const sharedFiber = Effect13.uninterruptible(Effect13.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, {
+    }).pipe(Effect13.flatMap(([deferred, start]) => start ? Effect13.forkIn(Layer10.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))));
+    }).pipe(Effect13.tap((fiber) => Deferred.succeed(deferred, fiber)), Effect13.as(deferred)) : Effect13.succeed(deferred))));
+    return sharedFiber.pipe(Effect13.flatMap(Deferred.await), Effect13.flatMap(Fiber2.join), Effect13.flatMap((modelContext) => effect.pipe(Effect13.provide(modelContext))));
   });
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/compaction.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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.
@@ -1164,21 +1537,22 @@ Use Markdown with these sections:
 ## Critical Context
 
 Do not mention that context was compacted.`;
-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)
+var AgentSummary = Schema11.Struct({
+  goal: Schema11.String,
+  facts: Schema11.Array(Schema11.String),
+  decisions: Schema11.Array(Schema11.String),
+  openQuestions: Schema11.Array(Schema11.String),
+  toolFindings: Schema11.Array(Schema11.String)
 });
+var withLifecycle = (request) => (work) => withCompactionLifecycle(work, request, request.usage);
 
-class CompactionError extends Schema10.TaggedErrorClass()("@batonfx/core/CompactionError", {
-  message: Schema10.String,
-  cause: Schema10.optionalKey(Schema10.Defect())
+class CompactionError extends Schema11.TaggedErrorClass()("@batonfx/core/CompactionError", {
+  message: Schema11.String,
+  cause: Schema11.optionalKey(Schema11.Defect())
 }) {
 }
 
-class Compaction extends Context9.Service()("@batonfx/core/Compaction") {
+class Compaction extends Context10.Service()("@batonfx/core/Compaction") {
 }
 var serialized2 = (value) => {
   const json = JSON.stringify(value);
@@ -1214,7 +1588,7 @@ 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) => Effect12.gen(function* () {
+var compactToolPart = (part, maxBytes) => Effect14.gen(function* () {
   if (part.isFailure)
     return [part, false];
   const success2 = { _tag: "Success", result: part.result, encodedResult: part.result };
@@ -1231,7 +1605,7 @@ var compactToolPart = (part, maxBytes) => Effect12.gen(function* () {
     true
   ];
 });
-var microcompactPrompt = (prompt, maxBytes) => Effect12.gen(function* () {
+var microcompactPrompt = (prompt, maxBytes) => Effect14.gen(function* () {
   let changed = false;
   const messages = [];
   for (const message of prompt.content) {
@@ -1295,24 +1669,24 @@ var defaultStrategy = (options = {}) => {
     cut: (entries, keepRecentTokens) => {
       const index = safeCutIndex(entries, keepRecentTokens);
       if (index <= 0 || index >= entries.length)
-        return Option6.none();
+        return Option8.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 });
+      return first === undefined ? Option8.none() : Option8.some({ firstKeptEntryId: first.id, head: entries.slice(0, index), recent });
     },
     summarize: (plan, request) => {
-      const effect = Effect12.gen(function* () {
+      const effect = Effect14.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 })));
+        const model = yield* summaryLanguageModel;
+        return yield* model.generateText({ prompt, toolkit: Toolkit2.empty, toolChoice: "none" }).pipe(Effect14.map((response) => response.text), Effect14.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) => ({
+var strategy = Function5.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,
   summarize: part.summarize ?? current.summarize,
@@ -1329,79 +1703,81 @@ var structuredSummary = (options = {}) => {
   const provideSummaryModel = options.summaryModel === undefined ? undefined : makeSummaryModelProvider(options.summaryModel);
   return {
     summarize: (plan, request) => {
-      const effect = Effect12.gen(function* () {
+      const effect = Effect14.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;
+        const model = yield* summaryLanguageModel;
         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 })));
+        }).pipe(Effect14.map((response) => renderAgentSummary(response.value)), Effect14.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) => Effect12.gen(function* () {
+var make2 = Function5.dual((args) => args.length !== 1 || ("shouldCompact" in args[0]), (compactionStrategy, options = {}) => ({
+  maybeCompact: (input) => Effect14.suspend(() => {
     const usage = normalizeUsage(input.usage, options);
     const shouldCompact = input.overflow || compactionStrategy.shouldCompact(usage);
     if (!shouldCompact)
-      return Option6.none();
-    let history = input.history;
-    let prompt = input.prompt;
-    let changed = false;
-    const toolOutputMaxBytes = input.toolOutputMaxBytes ?? compactionStrategy.toolOutputMaxBytes;
-    if (toolOutputMaxBytes !== undefined) {
-      const [compactedHistoryPrompt, historyChanged] = yield* microcompactPrompt(history, toolOutputMaxBytes);
-      const [compactedPrompt, promptChanged] = yield* microcompactPrompt(prompt, toolOutputMaxBytes);
-      history = compactedHistoryPrompt;
-      prompt = compactedPrompt;
-      changed = historyChanged || promptChanged;
-      if (changed && fits(history, prompt, usage))
-        return Option6.some(makeMicrocompact(history, prompt));
-    }
-    const plan = compactionStrategy.cut(input.path ?? [], compactionStrategy.keepRecentTokens ?? options.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS);
-    if (Option6.isNone(plan))
-      return changed ? Option6.some(makeMicrocompact(history, prompt)) : Option6.none();
-    const summary = yield* compactionStrategy.summarize(plan.value, {
-      ...input,
-      history,
-      prompt,
-      usage,
-      ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes }
-    });
-    const recent = buildContext(plan.value.recent);
-    const [compactedRecent] = toolOutputMaxBytes === undefined ? [recent, false] : yield* microcompactPrompt(recent, toolOutputMaxBytes);
-    return Option6.some({
-      _tag: "Summarize",
-      history: compactedHistory(summary, plan.value.head, compactedRecent),
-      prompt,
-      summary,
-      firstKeptEntryId: plan.value.firstKeptEntryId
-    });
+      return Effect14.succeed(Option8.none());
+    return withCompactionLifecycle(compact(compactionStrategy, input, usage, options), input, usage);
   })
 }));
-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 compact = (compactionStrategy, input, usage, options) => Effect14.gen(function* () {
+  let history = input.history;
+  let prompt = input.prompt;
+  let changed = false;
+  const toolOutputMaxBytes = input.toolOutputMaxBytes ?? compactionStrategy.toolOutputMaxBytes;
+  if (toolOutputMaxBytes !== undefined) {
+    const [compactedHistoryPrompt, historyChanged] = yield* microcompactPrompt(history, toolOutputMaxBytes);
+    const [compactedPrompt, promptChanged] = yield* microcompactPrompt(prompt, toolOutputMaxBytes);
+    history = compactedHistoryPrompt;
+    prompt = compactedPrompt;
+    changed = historyChanged || promptChanged;
+    if (changed && fits(history, prompt, usage))
+      return Option8.some(makeMicrocompact(history, prompt));
+  }
+  const plan = compactionStrategy.cut(input.path ?? [], compactionStrategy.keepRecentTokens ?? options.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS);
+  if (Option8.isNone(plan))
+    return changed ? Option8.some(makeMicrocompact(history, prompt)) : Option8.none();
+  const summary = yield* compactionStrategy.summarize(plan.value, {
+    ...input,
+    history,
+    prompt,
+    usage,
+    ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes }
+  });
+  const recent = buildContext(plan.value.recent);
+  const [compactedRecent] = toolOutputMaxBytes === undefined ? [recent, false] : yield* microcompactPrompt(recent, toolOutputMaxBytes);
+  return Option8.some({
+    _tag: "Summarize",
+    history: compactedHistory(summary, plan.value.head, compactedRecent),
+    prompt,
+    summary,
+    firstKeptEntryId: plan.value.firstKeptEntryId
+  });
+});
+var layer2 = Function5.dual((args) => args.length !== 1 || !("shouldCompact" in args[0]), (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer11.succeed(Compaction, Compaction.of(make2(providedStrategy, options))));
 var truncate = (maxTokens) => ({
-  maybeCompact: (input) => Effect12.gen(function* () {
+  maybeCompact: (input) => Effect14.gen(function* () {
     const usage = input.usage;
     if (!input.overflow && !(Number.isFinite(usage.contextWindow) && usage.contextTokens > usage.contextWindow - usage.reserveTokens)) {
-      return Option6.none();
+      return Option8.none();
     }
-    const tokenizer = yield* Effect12.serviceOption(Tokenizer.Tokenizer);
-    if (Option6.isNone(tokenizer))
-      return Option6.none();
-    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));
+    const tokenizer = yield* Effect14.serviceOption(Tokenizer.Tokenizer);
+    if (Option8.isNone(tokenizer))
+      return Option8.none();
+    return yield* tokenizer.value.truncate(Prompt6.concat(input.history, input.prompt), maxTokens).pipe(Effect14.map((prompt) => Option8.some(makeMicrocompact(Prompt6.empty, prompt))), Effect14.mapError((error) => CompactionError.make({ message: String(error), cause: error })), withCompactionLifecycle(input, usage));
   })
 });
-var layerTest8 = (implementation) => Layer10.succeed(Compaction, Compaction.of(implementation));
+var layerTest8 = (implementation) => Layer11.succeed(Compaction, Compaction.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/instructions.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/instructions.js
 var exports_instructions = {};
 __export(exports_instructions, {
   staticSource: () => staticSource,
@@ -1410,43 +1786,43 @@ __export(exports_instructions, {
   layer: () => layer3,
   Instructions: () => Instructions
 });
-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 Context10.Service()("@batonfx/core/Instructions") {
+import { Context as Context11, Effect as Effect15, Layer as Layer12, Option as Option9 } from "effect";
+import { dual as dual4 } from "effect/Function";
+class Instructions extends Context11.Service()("@batonfx/core/Instructions") {
 }
-var staticSource = dual3(2, (id, text) => ({
+var staticSource = dual4(2, (id, text) => ({
   id,
-  render: () => Effect13.succeed(text.length === 0 ? Option7.none() : Option7.some(text))
+  render: () => Effect15.succeed(text.length === 0 ? Option9.none() : Option9.some(text))
 }));
-var openEpoch = dual3(2, (instructions, context) => Effect13.gen(function* () {
+var openEpoch = dual4(2, (instructions, context) => Effect15.gen(function* () {
   const baseline = [];
   for (const source of instructions.sources) {
     const rendered = yield* source.render(context);
-    if (Option7.isSome(rendered))
+    if (Option9.isSome(rendered))
       baseline.push(rendered.value);
   }
   return baseline.join(`
 
 `);
 }));
-var layer3 = (sources) => Layer11.succeed(Instructions, Instructions.of({ sources: [...sources] }));
-var layerTest9 = (implementation) => Layer11.succeed(Instructions, Instructions.of(implementation));
+var layer3 = (sources) => Layer12.succeed(Instructions, Instructions.of({ sources: [...sources] }));
+var layerTest9 = (implementation) => Layer12.succeed(Instructions, Instructions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-middleware.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-middleware.js
 var exports_model_middleware = {};
 __export(exports_model_middleware, {
   layerIdentity: () => layerIdentity,
   layer: () => layer4,
   ModelMiddleware: () => 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") {
+import { Context as Context12, Effect as Effect16, Layer as Layer13, Option as Option10 } from "effect";
+import { Prompt as Prompt7, Response as Response5 } from "effect/unstable/ai";
+class ModelMiddleware extends Context12.Service()("@batonfx/core/ModelMiddleware") {
 }
-var layerIdentity = Layer12.succeed(ModelMiddleware, []);
-var layer4 = (middleware) => Layer12.succeed(ModelMiddleware, middleware);
+var layerIdentity = Layer13.succeed(ModelMiddleware, []);
+var layer4 = (middleware) => Layer13.succeed(ModelMiddleware, middleware);
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/model-resilience.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-resilience.js
 var exports_model_resilience = {};
 __export(exports_model_resilience, {
   none: () => none,
@@ -1457,49 +1833,49 @@ __export(exports_model_resilience, {
   apply: () => apply,
   ModelResilience: () => ModelResilience
 });
-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";
+import { Cause as Cause3, Context as Context13, Effect as Effect17, Function as Function6, Layer as Layer14, Result, Schedule as Schedule2, Schema as Schema12, Stream as Stream3 } from "effect";
+import { AiError as AiError5, LanguageModel as LanguageModel7, Response as Response6, Tool as Tool5 } from "effect/unstable/ai";
 
-class ModelResilience extends Context12.Service()("@batonfx/core/ModelResilience") {
+class ModelResilience extends Context13.Service()("@batonfx/core/ModelResilience") {
 }
-var defaultClassify = (error) => AiError3.isAiError(error) && error.isRetryable ? "transient" : "terminal";
+var defaultClassify = (error) => AiError5.isAiError(error) && error.isRetryable ? "transient" : "terminal";
 var none = { classify: () => "terminal", retrySchedule: Schedule2.recurs(0) };
 var make3 = (input) => ({
   classify: input?.classify ?? defaultClassify,
   retrySchedule: input?.retrySchedule ?? none.retrySchedule
 });
-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) => {
+var layer5 = (input) => Layer14.succeed(ModelResilience, ModelResilience.of(make3(input)));
+var layerTest10 = (implementation) => Layer14.succeed(ModelResilience, ModelResilience.of(implementation));
+var retryEffect = (effect, resilience) => Effect17.suspend(effect).pipe(Effect17.map((value) => Result.succeed(value)), Effect17.catchCause((cause) => {
   const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-  return reason === undefined || !Cause2.isFailReason(reason) ? Effect15.succeed(Result.fail(cause)) : Effect15.fail(reason.error);
-}), Effect15.retry({
+  return reason === undefined || !Cause3.isFailReason(reason) ? Effect17.succeed(Result.fail(cause)) : Effect17.fail(reason.error);
+}), Effect17.retry({
   schedule: resilience.retrySchedule,
   while: (error) => resilience.classify(error) === "transient"
-}), Effect15.flatMap((result) => Result.isFailure(result) ? Effect15.failCause(result.failure) : Effect15.succeed(result.success)));
+}), Effect17.flatMap((result) => Result.isFailure(result) ? Effect17.failCause(result.failure) : Effect17.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(() => Effect15.sync(() => {
+  return stream2().pipe(Stream3.map((value) => Result.succeed(value)), Stream3.tap(() => Effect17.sync(() => {
     emitted = true;
   })), Stream3.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-    if (reason === undefined || !Cause2.isFailReason(reason))
+    if (reason === undefined || !Cause3.isFailReason(reason))
       return Stream3.succeed(Result.fail(cause));
     return emitted ? Stream3.succeed(Result.succeed(onEmittedFailure(reason.error))) : Stream3.fail(reason.error);
   }));
 }).pipe(Stream3.retry(retryStreamSchedule(resilience)), Stream3.flatMap((result) => Result.isFailure(result) ? Stream3.failCause(result.failure) : Stream3.succeed(result.success)));
-var apply = Function5.dual(2, (model, resilience) => ({
+var apply = Function6.dual(2, (model, resilience) => ({
   ...model,
   generateText: (options) => retryEffect(() => model.generateText(options), resilience),
   generateObject: (options) => {
     const generate = model.generateObject;
     return retryEffect(() => generate(options), resilience);
   },
-  streamText: (options) => retryStream(() => model.streamText(options), (error) => Response5.makePart("error", { error }), resilience)
+  streamText: (options) => retryStream(() => model.streamText(options), (error) => Response6.makePart("error", { error }), resilience)
 }));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/permissions.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/permissions.js
 var exports_permissions = {};
 __export(exports_permissions, {
   matches: () => matches,
@@ -1515,18 +1891,18 @@ __export(exports_permissions, {
   Permissions: () => Permissions,
   PermissionError: () => PermissionError
 });
-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";
+import { Context as Context14, Effect as Effect18, Layer as Layer15, Option as Option11, Ref as Ref4, Schema as Schema13 } from "effect";
+import { dual as dual5 } from "effect/Function";
 
-class PermissionError extends Schema12.TaggedErrorClass()("@batonfx/core/PermissionError", {
-  message: Schema12.String
+class PermissionError extends Schema13.TaggedErrorClass()("@batonfx/core/PermissionError", {
+  message: Schema13.String
 }) {
 }
 
-class Permissions extends Context13.Service()("@batonfx/core/Permissions") {
+class Permissions extends Context14.Service()("@batonfx/core/Permissions") {
 }
 
-class RuleStore extends Context13.Service()("@batonfx/core/RuleStore") {
+class RuleStore extends Context14.Service()("@batonfx/core/RuleStore") {
 }
 var escapeRegExp = (value) => value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 var glob = (pattern) => new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`);
@@ -1589,7 +1965,7 @@ var matchesProjection = (pattern, tool, projection, failClosed) => {
   const paramsPattern = glob(pattern.slice(separator + 1));
   return projection.candidates.some((candidate) => paramsPattern.test(candidate));
 };
-var matches = dual4(3, (pattern, tool, params) => matchesProjection(pattern, tool, project(params), false));
+var matches = dual5(3, (pattern, tool, params) => matchesProjection(pattern, tool, project(params), false));
 var matchingRule = (ruleset, tool, params) => {
   const projection = project(params);
   let matched;
@@ -1599,8 +1975,8 @@ var matchingRule = (ruleset, tool, params) => {
   }
   return matched;
 };
-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 matchRule = dual5(3, (ruleset, tool, params) => Option11.fromNullishOr(matchingRule(ruleset, tool, params)));
+var evaluate = dual5(3, (ruleset, tool, params) => matchingRule(ruleset, tool, params)?.level ?? ruleset.fallback ?? "ask");
 var tokenFor = (request) => `permission:${request.call.id}`;
 var decisionFor = (ruleset, request) => {
   const rule = matchingRule(ruleset, request.call.name, request.call.params);
@@ -1614,7 +1990,7 @@ var decisionFor = (ruleset, request) => {
       return { _tag: "Ask", token: tokenFor(request) };
   }
 };
-var evaluateWithRules = dual4(3, (base, store, request) => Effect16.gen(function* () {
+var evaluateWithRules = dual5(3, (base, store, request) => Effect18.gen(function* () {
   const baseDecision = yield* base.evaluate(request);
   if (baseDecision._tag === "Deny")
     return baseDecision;
@@ -1631,20 +2007,20 @@ var evaluateWithRules = dual4(3, (base, store, request) => Effect16.gen(function
       return { _tag: "Ask", token: tokenFor(request) };
   }
 }));
-var layerRuleset = (ruleset) => Layer14.succeed(Permissions, Permissions.of({
-  evaluate: (request) => Effect16.succeed(decisionFor(ruleset, request))
+var layerRuleset = (ruleset) => Layer15.succeed(Permissions, Permissions.of({
+  evaluate: (request) => Effect18.succeed(decisionFor(ruleset, request))
 }));
-var layerAllowAll = Layer14.succeed(Permissions, Permissions.of({
-  evaluate: () => Effect16.succeed({ _tag: "Allow" })
+var layerAllowAll = Layer15.succeed(Permissions, Permissions.of({
+  evaluate: () => Effect18.succeed({ _tag: "Allow" })
 }));
-var layerRuleStoreMemory = (initialRules = []) => Layer14.effect(RuleStore, Ref4.make(initialRules).pipe(Effect16.map((rules) => RuleStore.of({
+var layerRuleStoreMemory = (initialRules = []) => Layer15.effect(RuleStore, Ref4.make(initialRules).pipe(Effect18.map((rules) => RuleStore.of({
   remember: (rule) => Ref4.update(rules, (current) => [...current.filter((existing) => existing.pattern !== rule.pattern), rule]),
   rules: Ref4.get(rules)
 }))));
-var layerRuleStoreTest = (implementation) => Layer14.succeed(RuleStore, RuleStore.of(implementation));
-var layerTest11 = (implementation) => Layer14.succeed(Permissions, Permissions.of(implementation));
+var layerRuleStoreTest = (implementation) => Layer15.succeed(RuleStore, RuleStore.of(implementation));
+var layerTest11 = (implementation) => Layer15.succeed(Permissions, Permissions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/skill-source.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/skill-source.js
 var exports_skill_source = {};
 __export(exports_skill_source, {
   selectListings: () => selectListings,
@@ -1659,48 +2035,48 @@ __export(exports_skill_source, {
   Frontmatter: () => Frontmatter,
   DESCRIPTION_CAP: () => DESCRIPTION_CAP
 });
-import { Context as Context14, Effect as Effect17, Function as Function6, Layer as Layer15, Schema as Schema13 } from "effect";
+import { Context as Context15, Effect as Effect19, Function as Function7, Layer as Layer16, Schema as Schema14 } from "effect";
 import { Tool as Tool6 } from "effect/unstable/ai";
 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 Frontmatter = Schema14.Struct({
+  name: Schema14.String,
+  description: Schema14.String.pipe(Schema14.check(Schema14.isMinLength(1), Schema14.isMaxLength(DESCRIPTION_CAP))),
+  whenToUse: Schema14.optionalKey(Schema14.String),
+  allowedTools: Schema14.optionalKey(Schema14.Array(Schema14.String)),
+  disableModelInvocation: Schema14.optionalKey(Schema14.Boolean),
+  userInvocable: Schema14.optionalKey(Schema14.Boolean),
+  contextFork: Schema14.optionalKey(Schema14.Boolean),
+  agent: Schema14.optionalKey(Schema14.String),
+  model: Schema14.optionalKey(Schema14.String),
+  paths: Schema14.optionalKey(Schema14.Array(Schema14.String))
+});
+
+class SkillSourceError extends Schema14.TaggedErrorClass()("@batonfx/core/SkillSourceError", {
+  source: Schema14.String,
+  message: Schema14.String,
+  cause: Schema14.optionalKey(Schema14.Defect())
 }) {
 }
 
-class SkillSource extends Context14.Service()("@batonfx/core/SkillSource") {
+class SkillSource extends Context15.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 makeListing = Function7.dual((args) => typeof args[0] !== "number", (frontmatter, descriptionCap = DESCRIPTION_CAP) => `- ${frontmatter.name}: ${frontmatter.description.slice(0, Math.max(0, descriptionCap))}`);
 var layerSkills = (skills) => {
   const all = [...skills];
   const byName = new Map(all.map((skill) => [skill.frontmatter.name, skill]));
-  return Layer15.succeed(SkillSource, SkillSource.of({
-    all: Effect17.succeed(all),
-    get: (name) => Effect17.succeed(byName.get(name))
+  return Layer16.succeed(SkillSource, SkillSource.of({
+    all: Effect19.succeed(all),
+    get: (name) => Effect19.succeed(byName.get(name))
   }));
 };
 var layerEmpty = layerSkills([]);
-var layerTest12 = (implementation) => Layer15.succeed(SkillSource, SkillSource.of(implementation));
+var layerTest12 = (implementation) => Layer16.succeed(SkillSource, SkillSource.of(implementation));
 var emptySource = {
-  all: Effect17.succeed([]),
-  get: () => Effect17.void.pipe(Effect17.as(undefined))
+  all: Effect19.succeed([]),
+  get: () => Effect19.void.pipe(Effect19.as(undefined))
 };
-var merge2 = Function6.dual(2, (first, second) => ({
-  all: Effect17.all([first.all, second.all]).pipe(Effect17.map((groups) => {
+var merge2 = Function7.dual(2, (first, second) => ({
+  all: Effect19.all([first.all, second.all]).pipe(Effect19.map((groups) => {
     const byName = new Map;
     for (const skills of groups) {
       for (const skill of skills)
@@ -1708,15 +2084,15 @@ var merge2 = Function6.dual(2, (first, second) => ({
     }
     return [...byName.values()];
   })),
-  get: (name) => second.get(name).pipe(Effect17.flatMap((found) => found === undefined ? first.get(name) : Effect17.succeed(found)))
+  get: (name) => second.get(name).pipe(Effect19.flatMap((found) => found === undefined ? first.get(name) : Effect19.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 layer6 = (sources) => Layer16.effect(SkillSource, Effect19.forEach(sources, (source) => source).pipe(Effect19.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);
   return index === -1 ? -1 : index;
 };
-var selectListings = Function6.dual(3, (skills, budgetTokens, recentlyUsed) => {
+var selectListings = Function7.dual(3, (skills, budgetTokens, recentlyUsed) => {
   if (budgetTokens <= 0)
     return [];
   const selected = skills.filter((skill) => skill.frontmatter.disableModelInvocation !== true && estimatedTokens(skill.listing) <= budgetTokens);
@@ -1734,7 +2110,7 @@ var selectListings = Function6.dual(3, (skills, budgetTokens, recentlyUsed) => {
   return selected;
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/steering.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/steering.js
 var exports_steering = {};
 __export(exports_steering, {
   layerTest: () => layerTest13,
@@ -1742,15 +2118,15 @@ __export(exports_steering, {
   SteeringQueueFull: () => SteeringQueueFull,
   Steering: () => Steering
 });
-import { Context as Context15, Effect as Effect18, Exit, Layer as Layer16, Queue, Schema as Schema14 } from "effect";
+import { Context as Context16, Effect as Effect20, Exit as Exit2, Layer as Layer17, Queue, Schema as Schema15 } from "effect";
 import { Prompt as Prompt8 } from "effect/unstable/ai";
 
-class Steering extends Context15.Service()("@batonfx/core/Steering") {
+class Steering extends Context16.Service()("@batonfx/core/Steering") {
 }
 
-class SteeringQueueFull extends Schema14.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
-  queue: Schema14.Literals(["steering", "followUp"]),
-  capacity: Schema14.Finite
+class SteeringQueueFull extends Schema15.TaggedErrorClass()("@batonfx/core/SteeringQueueFull", {
+  queue: Schema15.Literals(["steering", "followUp"]),
+  capacity: Schema15.Finite
 }) {
 }
 var resolvePolicy = (policy, mode) => ({
@@ -1769,18 +2145,18 @@ var queueStrategy = (strategy2) => {
       return "suspend";
   }
 };
-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) => {
+var makeQueue = (name, policy) => (policy.capacity === undefined ? Queue.unbounded() : Queue.make({ capacity: policy.capacity, strategy: queueStrategy(policy.onFull) })).pipe(Effect20.map((queue) => ({ name, queue, policy })));
+var offer = (runtime, input) => Queue.offer(runtime.queue, input).pipe(Effect20.flatMap((offered) => {
   if (offered || runtime.policy.capacity === undefined || runtime.policy.onFull !== "fail")
-    return Effect18.void;
+    return Effect20.void;
   return SteeringQueueFull.make({ queue: runtime.name, capacity: runtime.policy.capacity });
 }));
-var drainOne = (queue) => Effect18.sync(() => {
+var drainOne = (queue) => Effect20.sync(() => {
   const taken = Queue.takeUnsafe(queue);
-  return taken === undefined || !Exit.isSuccess(taken) ? [] : [taken.value];
+  return taken === undefined || !Exit2.isSuccess(taken) ? [] : [taken.value];
 });
 var drain = (queue, mode) => mode === "all" ? Queue.clear(queue) : drainOne(queue);
-var layer7 = (options = {}) => Layer16.effect(Steering, Effect18.gen(function* () {
+var layer7 = (options = {}) => Layer17.effect(Steering, Effect20.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({
@@ -1790,9 +2166,9 @@ var layer7 = (options = {}) => Layer16.effect(Steering, Effect18.gen(function* (
     takeFollowUp: drain(followUpQueue.queue, followUpQueue.policy.mode)
   });
 }));
-var layerTest13 = (implementation) => Layer16.succeed(Steering, Steering.of(implementation));
+var layerTest13 = (implementation) => Layer17.succeed(Steering, Steering.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent.js
 var exports_agent = {};
 __export(exports_agent, {
   stream: () => stream2,
@@ -1802,42 +2178,297 @@ __export(exports_agent, {
   defaultObjectPrompt: () => defaultObjectPrompt,
   Runtime: () => Runtime
 });
-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";
+import { Effect as Effect27, Option as Option17, Schema as Schema21, Stream as Stream6, Types } from "effect";
+import { dual as dual7 } from "effect/Function";
+import { AiError as AiError8, Chat as Chat3, LanguageModel as LanguageModel10, Prompt as Prompt12, Tool as Tool10, Toolkit as Toolkit5 } 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.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-run.js
+import { Cause as Cause6, Channel, Effect as Effect26, Equal as Equal2, Exit as Exit4, Fiber as Fiber3, HashMap as HashMap6, Option as Option16, Queue as Queue2, Ref as Ref5, Schema as Schema20, Semaphore as Semaphore3, Stream as Stream5 } from "effect";
+import { AiError as AiError7, Chat as Chat2, LanguageModel as LanguageModel9, Prompt as Prompt11, Response as Response11, Telemetry, Tokenizer as Tokenizer2, Tool as Tool9, Toolkit as Toolkit4 } from "effect/unstable/ai";
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/model-instrumentation.js
+import { Cause as Cause4, Clock as Clock2, Duration, Effect as Effect21, Exit as Exit3, Function as Function8, Option as Option12, Schedule as Schedule3, Stream as Stream4 } from "effect";
+import { AiError as AiError6, LanguageModel as LanguageModel8, Model as Model2, Response as Response7 } from "effect/unstable/ai";
+var makeIdentityCell = () => ({ current: undefined });
+var InstrumentedTypeId = Symbol.for("@batonfx/core/model-instrumentation/Instrumented");
+var memoized = (compute) => {
+  const cache = new Map;
+  return (error) => {
+    const cached = cache.get(error);
+    if (cached !== undefined)
+      return cached;
+    const result = compute(error);
+    cache.set(error, result);
+    return result;
+  };
+};
+var singleFailure = (cause) => {
+  const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
+  return reason !== undefined && Cause4.isFailReason(reason) ? Option12.some(reason.error) : Option12.none();
+};
+var firstOutputKind = (part) => {
+  switch (part.type) {
+    case "reasoning-start":
+    case "reasoning-delta":
+    case "reasoning":
+      return "reasoning";
+    case "text-start":
+    case "text-delta":
+    case "text":
+      return "text";
+    case "tool-params-start":
+    case "tool-call":
+      return "tool-call";
+    default:
+      return;
+  }
+};
+var recordResponsePart = (context, attempt, part) => {
+  if (part.type === "response-metadata") {
+    attempt.state.requestId = part.id;
+    attempt.state.responseModel = part.modelId;
+  }
+  if (part.type === "finish") {
+    attempt.state.usage = part.usage;
+    attempt.state.finishReason = part.reason;
+  }
+  if (part.type === "error") {
+    attempt.state.errorCategory = context.categorize(part.error);
+  }
+};
+var observeStreamPart = (context, attempt, part) => Effect21.gen(function* () {
+  recordResponsePart(context, attempt, part);
+  if (part.type === "finish") {
+    attempt.state.usageAt = yield* Clock2.currentTimeMillis;
+  }
+  const kind = firstOutputKind(part);
+  if (kind === undefined || attempt.state.firstOutputs.has(kind))
+    return;
+  attempt.state.firstOutputs.add(kind);
+  const at = yield* Clock2.currentTimeMillis;
+  yield* context.options.emit({
+    _tag: "ModelAttemptFirstOutput",
+    turn: context.options.turn,
+    modelCallId: context.modelCallId,
+    modelAttemptId: attempt.modelAttemptId,
+    attempt: attempt.attempt,
+    kind,
+    at
+  });
+});
+var attemptCompleted = (context, attempt) => Effect21.flatMap(Clock2.currentTimeMillis, (completedAt) => context.options.emit({
+  _tag: "ModelAttemptCompleted",
+  turn: context.options.turn,
+  modelCallId: context.modelCallId,
+  modelAttemptId: attempt.modelAttemptId,
+  attempt: attempt.attempt,
+  completedAt,
+  ...attempt.state.usage === undefined ? {} : { usage: attempt.state.usage },
+  ...attempt.state.usageAt === undefined ? {} : { usageAt: attempt.state.usageAt },
+  ...attempt.state.finishReason === undefined ? {} : { finishReason: attempt.state.finishReason },
+  ...attempt.state.requestId === undefined ? {} : { requestId: attempt.state.requestId },
+  ...attempt.state.responseModel === undefined ? {} : { responseModel: attempt.state.responseModel }
+}));
+var attemptFailed = (context, attempt, category, classification) => Effect21.flatMap(Clock2.currentTimeMillis, (failedAt) => context.options.emit({
+  _tag: "ModelAttemptFailed",
+  turn: context.options.turn,
+  modelCallId: context.modelCallId,
+  modelAttemptId: attempt.modelAttemptId,
+  attempt: attempt.attempt,
+  failedAt,
+  category,
+  classification
+}));
+var attemptExit = (context, attempt, exit) => {
+  if (attempt.state.errorCategory !== undefined) {
+    return attemptFailed(context, attempt, attempt.state.errorCategory, "terminal");
+  }
+  if (Exit3.isSuccess(exit)) {
+    context.state.usage = attempt.state.usage ?? context.state.usage;
+    context.state.finishReason = attempt.state.finishReason ?? context.state.finishReason;
+    return attemptCompleted(context, attempt);
+  }
+  if (Cause4.hasInterrupts(exit.cause))
+    return attemptFailed(context, attempt, "cancellation", "terminal");
+  const failure2 = singleFailure(exit.cause);
+  if (Option12.isNone(failure2))
+    return attemptFailed(context, attempt, "unknown", "terminal");
+  return attemptFailed(context, attempt, context.categorize(failure2.value), context.classify(failure2.value));
+};
+var beginAttempt = (context) => Effect21.gen(function* () {
+  const attempt = context.state.attempts;
+  context.state.attempts += 1;
+  const modelAttemptId = yield* generateId;
+  if (context.options.identity !== undefined) {
+    context.options.identity.current = { modelCallId: context.modelCallId, modelAttemptId, attempt };
+  }
+  const startedAt = yield* Clock2.currentTimeMillis;
+  yield* context.options.emit({
+    _tag: "ModelAttemptStarted",
+    turn: context.options.turn,
+    modelCallId: context.modelCallId,
+    modelAttemptId,
+    attempt,
+    startedAt
+  });
+  return {
+    modelAttemptId,
+    attempt,
+    state: {
+      firstOutputs: new Set,
+      usage: undefined,
+      usageAt: undefined,
+      finishReason: undefined,
+      requestId: undefined,
+      responseModel: undefined,
+      errorCategory: undefined
+    }
+  };
+});
+var attemptEffect = (context, run) => Effect21.flatMap(beginAttempt(context), (attempt) => run().pipe(Effect21.tap((response) => Effect21.forEach(response.content, (part) => observeStreamPart(context, attempt, part), { discard: true })), Effect21.onExit((exit) => attemptExit(context, attempt, exit))));
+var attemptStream = (context, run) => Stream4.unwrap(Effect21.map(beginAttempt(context), (attempt) => run().pipe(Stream4.tap((part) => observeStreamPart(context, attempt, part)), Stream4.onExit((exit) => attemptExit(context, attempt, exit)))));
+var attemptModel = (model, context) => ({
+  ...model,
+  generateText: (options) => attemptEffect(context, () => model.generateText(options)),
+  generateObject: (options) => attemptEffect(context, () => model.generateObject(options)),
+  streamText: (options) => attemptStream(context, () => model.streamText(options))
+});
+var tappedResilience = (context, resilience) => ({
+  classify: context.classify,
+  retrySchedule: resilience.retrySchedule.pipe(Schedule3.while(({ input }) => context.classify(input) === "transient"), Schedule3.tap((metadata) => Effect21.flatMap(Clock2.currentTimeMillis, (at) => context.options.emit({
+    _tag: "ModelRetryScheduled",
+    turn: context.options.turn,
+    modelCallId: context.modelCallId,
+    attempt: context.state.attempts - 1,
+    reason: "provider-resilience",
+    category: context.categorize(metadata.input),
+    delayMillis: Duration.toMillis(metadata.duration),
+    at
+  }))))
+});
+var beginCall = (model, options) => Effect21.gen(function* () {
+  const modelCallId = yield* generateId;
+  const purpose = yield* CurrentPurpose;
+  const compactionId = yield* CurrentCompactionId;
+  const provider = yield* Effect21.serviceOption(Model2.ProviderName);
+  const modelName = yield* Effect21.serviceOption(Model2.ModelName);
+  const startedAt = yield* Clock2.currentTimeMillis;
+  yield* options.emit({
+    _tag: "ModelCallStarted",
+    turn: options.turn,
+    modelCallId,
+    purpose,
+    ...Option12.isSome(provider) ? { provider: provider.value } : {},
+    ...Option12.isSome(modelName) ? { model: modelName.value } : {},
+    ...compactionId === undefined ? {} : { compactionId },
+    startedAt
+  });
+  if (compactionId !== undefined) {
+    const summaryCell = yield* CurrentSummaryCall;
+    if (summaryCell !== undefined) {
+      if (summaryCell.current !== undefined)
+        return yield* Effect21.die(new Error("A compaction pass issued multiple summary model calls"));
+      summaryCell.current = modelCallId;
+    }
+  }
+  const providerClassification = memoized((error) => classifyFailure(model, error));
+  const context = {
+    options,
+    modelCallId,
+    purpose,
+    categorize: memoized((error) => providerClassification(error) === "context-overflow" ? "context-overflow" : classifyFailureCategory(error)),
+    classify: memoized((error) => providerClassification(error) === "context-overflow" ? "terminal" : options.resilience === undefined ? "terminal" : options.resilience.classify(error)),
+    state: { attempts: 0, usage: undefined, finishReason: undefined, errorCategory: undefined }
+  };
+  const attempts = attemptModel(model, context);
+  const stack = options.resilience === undefined ? attempts : apply(attempts, tappedResilience(context, options.resilience));
+  return { context, stack };
+});
+var observeCallPart = (context, part) => {
+  if (part.type === "finish") {
+    context.state.usage = part.usage;
+    context.state.finishReason = part.reason;
+  }
+  if (part.type === "error") {
+    context.state.errorCategory = context.categorize(part.error);
+  }
+};
+var callCompleted = (context) => Effect21.flatMap(Clock2.currentTimeMillis, (completedAt) => context.options.emit({
+  _tag: "ModelCallCompleted",
+  turn: context.options.turn,
+  modelCallId: context.modelCallId,
+  purpose: context.purpose,
+  attempts: context.state.attempts,
+  completedAt,
+  ...context.state.usage === undefined ? {} : { usage: context.state.usage },
+  ...context.state.finishReason === undefined ? {} : { finishReason: context.state.finishReason }
+}));
+var callFailed = (context, category) => Effect21.flatMap(Clock2.currentTimeMillis, (failedAt) => context.options.emit({
+  _tag: "ModelCallFailed",
+  turn: context.options.turn,
+  modelCallId: context.modelCallId,
+  purpose: context.purpose,
+  attempts: context.state.attempts,
+  failedAt,
+  category
+}));
+var callExit = (context, exit) => {
+  if (context.state.errorCategory !== undefined)
+    return callFailed(context, context.state.errorCategory);
+  if (Exit3.isSuccess(exit))
+    return callCompleted(context);
+  if (Cause4.hasInterrupts(exit.cause))
+    return callFailed(context, "cancellation");
+  const failure2 = singleFailure(exit.cause);
+  return callFailed(context, Option12.isNone(failure2) ? "unknown" : context.categorize(failure2.value));
+};
+var callEffect = (model, options, invoke) => Effect21.flatMap(beginCall(model, options), ({ context, stack }) => invoke(stack).pipe(Effect21.tap((response) => Effect21.sync(() => {
+  for (const part of response.content)
+    observeCallPart(context, part);
+})), Effect21.onExit((exit) => callExit(context, exit))));
+var callStream = (model, options, invoke) => Stream4.unwrap(Effect21.map(beginCall(model, options), ({ context, stack }) => invoke(stack).pipe(Stream4.tap((part) => Effect21.sync(() => observeCallPart(context, part))), Stream4.onExit((exit) => callExit(context, exit)))));
+var instrument = Function8.dual(2, (model, options) => {
+  const marker = model[InstrumentedTypeId];
+  if (marker !== undefined) {
+    return marker.emit === options.emit ? model : instrument(marker.base, options);
+  }
+  return {
+    ...model,
+    [InstrumentedTypeId]: { emit: options.emit, base: model },
+    generateText: (generateOptions) => callEffect(model, options, (stack) => stack.generateText(generateOptions)),
+    generateObject: (generateOptions) => callEffect(model, options, (stack) => stack.generateObject(generateOptions)),
+    streamText: (streamOptions) => callStream(model, options, (stack) => stack.streamText(streamOptions))
+  };
+});
+
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-authorization.js
+import { Cause as Cause5, Context as Context17, Effect as Effect22, Layer as Layer18, Schema as Schema16 } from "effect";
 import"effect/unstable/ai";
-class PermissionDenied extends Schema15.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
-  message: Schema15.String
+class PermissionDenied extends Schema16.TaggedErrorClass()("@batonfx/core/PermissionDenied", {
+  message: Schema16.String
 }) {
 }
 
-class AuthorizationError extends Schema15.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema15.String, cause: Schema15.optional(Schema15.Defect()) }) {
+class AuthorizationError extends Schema16.TaggedErrorClass()("@batonfx/core/AuthorizationError", { message: Schema16.String, cause: Schema16.optional(Schema16.Defect()) }) {
 }
 
-class ToolAuthorizerService extends Context16.Service()("@batonfx/core/ToolAuthorizerService") {
+class ToolAuthorizerService extends Context17.Service()("@batonfx/core/ToolAuthorizerService") {
 }
 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);
+    return Effect22.succeed(false);
   if (typeof needsApproval === "boolean")
-    return Effect19.succeed(needsApproval);
-  return Effect19.suspend(() => {
+    return Effect22.succeed(needsApproval);
+  return Effect22.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)));
+    return Effect22.isEffect(result) ? result : Effect22.succeed(result);
+  }).pipe(Effect22.catchCause((cause) => Cause5.hasInterrupts(cause) ? Effect22.interrupt : Effect22.succeed(true)));
 };
 var suspend = (request, token) => ({
   _tag: "Suspend",
@@ -1853,10 +2484,10 @@ var suspend = (request, token) => ({
   })
 });
 var make4 = (options) => ({
-  authorize: (request) => Effect19.gen(function* () {
+  authorize: (request) => Effect22.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));
+    const decision2 = yield* evaluateWithRules(options.permissions, options.ruleStore, request).pipe(Effect22.mapError(authorizationError));
     if (decision2._tag === "Deny")
       return deny(decision2.reason ?? "Permission denied");
     const required = decision2._tag === "Ask" || (yield* approvalRequired(request));
@@ -1874,7 +2505,7 @@ var make4 = (options) => ({
     switch (resolution._tag) {
       case "Approved":
         if (resolution.remember !== undefined)
-          yield* options.ruleStore.remember(resolution.remember).pipe(Effect19.mapError(authorizationError));
+          yield* options.ruleStore.remember(resolution.remember).pipe(Effect22.mapError(authorizationError));
         return { _tag: "Execute" };
       case "Denied":
         return deny(resolution.reason ?? "Tool call denied");
@@ -1884,9 +2515,9 @@ var make4 = (options) => ({
   })
 });
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/tool-registry.js
+import { Array as Array2, Effect as Effect23, HashMap as HashMap4, Option as Option13 } from "effect";
+import { dual as dual6 } 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));
@@ -1907,21 +2538,21 @@ var assemble = (candidates) => {
   for (const candidate of candidates) {
     const conflicts = grouped[`tool:${candidate.tool.name}`];
     if (conflicts !== undefined && conflicts.length > 1) {
-      return Effect20.fail(ToolNameCollision.make({
+      return Effect23.fail(ToolNameCollision.make({
         name: candidate.tool.name,
         origins: Array2.map(conflicts, (conflict) => conflict.origin)
       }));
     }
   }
   const entries = [...candidates];
-  return Effect20.succeed({
+  return Effect23.succeed({
     entries,
     byName: HashMap4.fromIterable(entries.map((candidate) => [candidate.tool.name, candidate])),
     toolkit: makeToolkit(entries)
   });
 };
-var get = dual5(2, (registry, name) => Option10.getOrUndefined(HashMap4.get(registry.byName, name)));
-var select = dual5(2, (registry, names) => {
+var get = dual6(2, (registry, name) => Option13.getOrUndefined(HashMap4.get(registry.byName, name)));
+var select = dual6(2, (registry, names) => {
   const entries = registry.entries.filter((entry) => names.includes(entry.tool.name));
   return {
     entries,
@@ -1930,42 +2561,42 @@ var select = dual5(2, (registry, names) => {
   };
 });
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-persistence-lock.js
+import { Context as Context18, Effect as Effect24, Layer as Layer19, RcMap, Scope as Scope3, Semaphore as Semaphore2 } from "effect";
 import { Chat } from "effect/unstable/ai";
 
-class Runtime extends Context17.Service()("@batonfx/core/Runtime") {
+class Runtime extends Context18.Service()("@batonfx/core/Runtime") {
 }
-var makeRuntime = Effect21.gen(function* () {
+var makeRuntime = Effect24.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)))
+    persistenceSemaphore: (persistence, chatId) => RcMap.get(persistenceLocks, persistence).pipe(Effect24.flatMap((chatLocks) => RcMap.get(chatLocks, chatId)))
   });
 });
-var layerRuntime = Layer18.effect(Runtime, makeRuntime);
+var layerRuntime = Layer19.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.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-message.js
+import { Effect as Effect25, Option as Option14, Schema as Schema18 } from "effect";
+import { Prompt as Prompt9, Response as Response8 } 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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-skill-tool.js
+import { Schema as Schema17 } from "effect";
 import { Tool as Tool8 } from "effect/unstable/ai";
 var skillListingBudgetTokens = 2048;
 var activateSkillToolName = "activate_skill";
-var activateSkillParameters = Schema16.Struct({ name: Schema16.String });
-var activateSkillSuccess = Schema16.Struct({
-  name: Schema16.String,
-  body: Schema16.String,
-  allowedTools: Schema16.Array(Schema16.String)
-});
-var activateSkillFailure = Schema16.Struct({
-  reason: Schema16.Literals(["not-found", "not-model-invocable"]),
-  message: Schema16.String
+var activateSkillParameters = Schema17.Struct({ name: Schema17.String });
+var activateSkillSuccess = Schema17.Struct({
+  name: Schema17.String,
+  body: Schema17.String,
+  allowedTools: Schema17.Array(Schema17.String)
+});
+var activateSkillFailure = Schema17.Struct({
+  reason: Schema17.Literals(["not-found", "not-model-invocable"]),
+  message: Schema17.String
 });
 var activateSkillTool = Tool8.make(activateSkillToolName, {
   description: "Load the full body for one listed Baton skill by name before applying that skill.",
@@ -1975,26 +2606,26 @@ var activateSkillTool = Tool8.make(activateSkillToolName, {
   failureMode: "return"
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-message.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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 = 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 messageJsonStringCodec = Schema18.fromJsonString(Schema18.toCodecJson(Prompt9.Message));
+var encodeMessage = Schema18.encodeEffect(messageJsonStringCodec);
+var decodeMessage = Schema18.decodeEffect(messageJsonStringCodec);
+var detachMessage = (message) => encodeMessage(message).pipe(Effect25.flatMap(decodeMessage), Effect25.map((detached) => isMessageFromRecall(message) && message.role === "user" && detached.role === "user" ? replaceRecalledMessage(message, detached.content) : detached));
+var detachPrompt = (prompt) => Effect25.forEach(prompt.content, detachMessage).pipe(Effect25.map(Prompt9.fromMessages));
+var detachEntry = (entry) => entry._tag === "Message" || entry._tag === "Steering" ? detachMessage(entry.message).pipe(Effect25.map((message) => ({ ...entry, message }))) : Effect25.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) => Effect22.gen(function* () {
+var applyPromptChain = (chain, prompt, context) => Effect25.gen(function* () {
   let current = prompt;
   for (const middleware of chain) {
     if (middleware.transformPrompt !== undefined) {
@@ -2011,10 +2642,10 @@ var applyPromptChain = (chain, prompt, context) => Effect22.gen(function* () {
   }
   return current;
 });
-var applyPartChain = (chain, part, context) => Effect22.gen(function* () {
-  let current = Option11.some(part);
+var applyPartChain = (chain, part, context) => Effect25.gen(function* () {
+  let current = Option14.some(part);
   for (const middleware of chain) {
-    if (Option11.isNone(current))
+    if (Option14.isNone(current))
       break;
     if (middleware.transformPart !== undefined) {
       current = yield* middleware.transformPart(current.value, context);
@@ -2023,17 +2654,17 @@ var applyPartChain = (chain, part, context) => Effect22.gen(function* () {
   return current;
 });
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-suspension.js
+import { Equal, Option as Option15, Schema as Schema19 } from "effect";
+import { Prompt as Prompt10, Response as Response9 } from "effect/unstable/ai";
 var suspensionCheckpointOption = "@batonfx/core/suspension";
-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 suspensionMetadata = Schema19.Struct({
+  token: Schema19.String,
+  reason: Schema19.Literals(["tool-wait", "approval"]),
+  tool_call_index: Schema19.optional(Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(0))),
+  tool_call_batch_ids: Schema19.Array(Schema19.String),
+  active_tools: Schema19.optional(Schema19.Array(Schema19.String)),
+  activated_skills: Schema19.optional(Schema19.Array(Schema19.String))
 });
 var unresolvedToolCall = (messages, toolCallId) => {
   const unpaired = new Map;
@@ -2064,11 +2695,11 @@ 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 }) => Option12.isSome(Schema18.decodeUnknownOption(suspensionMetadata)(call.options[suspensionCheckpointOption]))) : unresolved.find(({ call }) => call.id === toolCallId);
+  const pending = toolCallId === undefined ? unresolved.find(({ call }) => Option15.isSome(Schema19.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 ? [
-    Response7.makePart("tool-call", {
+    Response9.makePart("tool-call", {
       id: part.id,
       name: part.name,
       params: part.params,
@@ -2100,8 +2731,8 @@ var suspensionCheckpoint = (messages) => {
   const unresolved = unresolvedToolCall(messages);
   if (unresolved === undefined)
     return;
-  const metadata = Schema18.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
-  if (Option12.isNone(metadata))
+  const metadata = Schema19.decodeUnknownOption(suspensionMetadata)(unresolved.call.options[suspensionCheckpointOption]);
+  if (Option15.isNone(metadata))
     return;
   if (!Equal.equals(metadata.value.tool_call_batch_ids, unresolved.toolCallBatch.map((call) => call.id)))
     return;
@@ -2129,10 +2760,10 @@ var suspended = (call, toolCallBatch, toolCallIndex, token, reason) => AgentSusp
   tool_call_batch: toolCallBatch.calls
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-tool-result.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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({
+import { Response as Response10 } from "effect/unstable/ai";
+var successResult = (call, outcome) => Response10.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: false,
@@ -2141,7 +2772,7 @@ var successResult = (call, outcome) => Response8.toolResultPart({
   providerExecuted: false,
   preliminary: false
 });
-var domainFailureResult = (call, outcome) => Response8.toolResultPart({
+var domainFailureResult = (call, outcome) => Response10.toolResultPart({
   id: call.id,
   name: call.name,
   isFailure: true,
@@ -2151,18 +2782,18 @@ var domainFailureResult = (call, outcome) => Response8.toolResultPart({
   preliminary: false
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent-run.js
-var classifyOtherFailure = () => "other";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-run.js
+var classifyOtherFailure = (error) => classify(error);
 var defaultProgressOverflowPolicy = { _tag: "Backpressure", capacity: 64 };
-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 progressCapacitySchema = Schema20.Finite.pipe(Schema20.check(Schema20.isInt(), Schema20.isGreaterThan(0)));
+var progressOverflowPolicySchema = Schema20.Union([
+  Schema20.TaggedStruct("Backpressure", { capacity: progressCapacitySchema }),
+  Schema20.TaggedStruct("Dropping", { capacity: progressCapacitySchema }),
+  Schema20.TaggedStruct("Sliding", { capacity: progressCapacitySchema }),
+  Schema20.TaggedStruct("Fail", { capacity: progressCapacitySchema })
 ]);
 var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-var isToolNameCollision = Schema19.is(ToolNameCollision);
+var isToolNameCollision = Schema20.is(ToolNameCollision);
 var appendInstructionFragment = (base, fragment) => {
   if (fragment === undefined || fragment.length === 0)
     return base;
@@ -2177,7 +2808,7 @@ var isTurnPolicyDecision = (input) => {
     return false;
   if (input._tag === "Continue")
     return true;
-  return input._tag === "Stop" && "reason" in input && Schema19.is(StopReason)(input.reason);
+  return input._tag === "Stop" && "reason" in input && Schema20.is(StopReason)(input.reason);
 };
 var steeringDrainedEvent = (turn, queue, inputs) => ({
   _tag: "SteeringDrained",
@@ -2185,7 +2816,7 @@ var steeringDrainedEvent = (turn, queue, inputs) => ({
   queue,
   count: inputs.length
 });
-var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen(function* () {
+var streamInternal = (agent, options, structured) => Stream5.unwrap(Effect26.gen(function* () {
   if (options.history !== undefined && options.persistence !== undefined) {
     return yield* AgentError.make({
       message: "RunOptions.history and RunOptions.persistence are mutually exclusive",
@@ -2194,47 +2825,47 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
   }
   const persistenceOptions = options.persistence;
   const resume = options.resume;
-  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({
+  const persistenceService = yield* Effect26.serviceOption(Chat2.Persistence);
+  const runtimeService = yield* Effect26.serviceOption(Runtime);
+  const compactionService = yield* Effect26.serviceOption(Compaction);
+  const sessionService = yield* Effect26.serviceOption(SessionStore);
+  const persisted = persistenceOptions === undefined ? undefined : yield* Option16.match(persistenceService, {
+    onNone: () => Effect26.fail(AgentError.make({
       message: "RunOptions.persistence requires Chat.Persistence in context",
       turn: 0
     })),
-    onSome: (service) => Effect23.gen(function* () {
-      const runtime = yield* Option13.match(runtimeService, {
-        onNone: () => Effect23.fail(AgentError.make({
+    onSome: (service) => Effect26.gen(function* () {
+      const runtime = yield* Option16.match(runtimeService, {
+        onNone: () => Effect26.fail(AgentError.make({
           message: "RunOptions.persistence requires Agent.Runtime in context",
           turn: 0
         })),
-        onSome: Effect23.succeed
+        onSome: Effect26.succeed
       });
       const semaphore = yield* runtime.persistenceSemaphore(service, persistenceOptions.chatId);
-      yield* Effect23.acquireRelease(semaphore.take(1), () => semaphore.release(1), {
+      yield* Effect26.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(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({
+      return yield* resume === undefined ? service.getOrCreate(persistenceOptions.chatId, getOptions).pipe(Effect26.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error }))) : service.get(persistenceOptions.chatId, getOptions).pipe(Effect26.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 && Option13.isSome(compactionService) && Option13.isSome(sessionService)) {
-    yield* Effect23.gen(function* () {
+  if (resume !== undefined && persisted !== undefined && Option16.isSome(compactionService) && Option16.isSome(sessionService)) {
+    yield* Effect26.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 (!Schema19.toEquivalence(Prompt11.Prompt)(before, history))
+      if (!Schema20.toEquivalence(Prompt11.Prompt)(before, history))
         return;
       recoveredHistory = buildContext(path);
-    }).pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+    }).pipe(Effect26.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
   }
   let resumeChat;
   let validatedResume;
@@ -2242,12 +2873,12 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.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* Effect23.succeed(resumeHistory).pipe(Effect23.flatMap((history) => {
+    validatedResume = yield* Effect26.succeed(resumeHistory).pipe(Effect26.flatMap((history) => {
       const expected = suspensionCheckpoint(history.content);
       if (expected === undefined) {
         return ResumeMismatch.make({ reason: "checkpoint-not-found", received });
       }
-      return sameSuspension(expected.suspension, received) ? Effect23.succeed(expected) : ResumeMismatch.make({
+      return sameSuspension(expected.suspension, received) ? Effect26.succeed(expected) : ResumeMismatch.make({
         reason: "identity-mismatch",
         expected: expected.suspension,
         received
@@ -2255,7 +2886,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     }));
     if (recoveredHistory !== undefined && persisted !== undefined) {
       yield* Ref5.set(persisted.history, recoveredHistory);
-      yield* persisted.save.pipe(Effect23.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
+      yield* persisted.save.pipe(Effect26.mapError((error) => AgentError.make({ message: errorMessage(error), turn: 0, cause: error })));
     }
   }
   const staticCandidates = (agent.toolDeclarations ?? Object.values(agent.toolkit.tools).map((tool) => ({
@@ -2274,17 +2905,17 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       turn: 0
     });
   }
-  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 })));
+  const executor = yield* Effect26.serviceOption(ToolExecutor);
+  const approvals = yield* Effect26.serviceOption(Approvals);
+  const chain = yield* Effect26.serviceOption(ModelMiddleware).pipe(Effect26.map(Option16.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 = Schema19.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
-  if (Option13.isNone(decodedProgressPolicy)) {
+  const decodedProgressPolicy = Schema20.decodeUnknownOption(progressOverflowPolicySchema)(options.toolProgress === undefined ? defaultProgressOverflowPolicy : options.toolProgress);
+  if (Option16.isNone(decodedProgressPolicy)) {
     return yield* AgentError.make({
       message: "RunOptions.toolProgress must select a supported policy with a positive safe-integer capacity",
       turn: 0
@@ -2306,11 +2937,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
   const sessionId = options.sessionId ?? "local";
   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 : {
+  const instructionsService = yield* Effect26.serviceOption(Instructions);
+  const skillSourceService = yield* Effect26.serviceOption(SkillSource);
+  const skillRuntime = Option16.isNone(skillSourceService) ? undefined : {
     source: skillSourceService.value,
-    skills: yield* skillSourceService.value.all.pipe(Effect23.mapError((error) => AgentError.make({ message: error.message, turn: 0, cause: error })))
+    skills: yield* skillSourceService.value.all.pipe(Effect26.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(`
@@ -2326,22 +2957,50 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       }
     ] : []
   ]);
-  const instructionsEpoch = options.system === undefined && options.history === undefined && Option13.isSome(instructionsService) ? yield* openEpoch(instructionsService.value, { agentName: agent.name, turn: 0 }) : undefined;
+  const instructionsEpoch = options.system === undefined && options.history === undefined && Option16.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* 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 resilienceService = yield* Effect26.serviceOption(ModelResilience);
+  const deliveryService = yield* Effect26.serviceOption(Delivery);
+  const telemetryRunId = yield* generateId;
+  let telemetrySequence = 0;
+  const pendingTelemetry = [];
+  const undeliveredTelemetry = [];
+  const emitTelemetry = (payload) => Effect26.sync(() => {
+    const event = { ...payload, deliveryId: `${telemetryRunId}:${telemetrySequence++}` };
+    pendingTelemetry.push(event);
+    undeliveredTelemetry.push(event);
+  });
+  const flushTelemetry = () => pendingTelemetry.splice(0, pendingTelemetry.length);
+  const deliverPending = () => {
+    if (Option16.isNone(deliveryService) || undeliveredTelemetry.length === 0)
+      return Effect26.void;
+    const snapshot = Object.freeze([...undeliveredTelemetry]);
+    return deliveryService.value.deliver({ sessionId, events: snapshot }).pipe(Effect26.onError(() => Effect26.sync(() => {
+      pendingTelemetry.splice(0, pendingTelemetry.length);
+    })), Effect26.tap(() => Effect26.sync(() => {
+      undeliveredTelemetry.splice(0, snapshot.length);
+    })));
+  };
+  const telemetryIdentity = makeIdentityCell();
+  const instrumentModel = (model, turn) => instrument(model, {
+    emit: emitTelemetry,
+    turn,
+    identity: telemetryIdentity,
+    ...Option16.isSome(resilienceService) ? { resilience: resilienceService.value } : {}
+  });
+  const modelRegistryService = yield* Effect26.serviceOption(ModelRegistry);
+  const permissionsService = yield* Effect26.serviceOption(Permissions);
+  const ruleStoreService = yield* Effect26.serviceOption(RuleStore);
+  const authorizationService = yield* Effect26.serviceOption(ToolAuthorizerService);
+  const steeringService = yield* Effect26.serviceOption(Steering);
+  const memoryService = yield* Effect26.serviceOption(Memory);
+  const tokenizerService = yield* Effect26.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({
+  const authorizer = agent.authorization ?? Option16.getOrElse(authorizationService, () => make4({
+    permissions: Option16.getOrElse(permissionsService, () => Permissions.of({ evaluate: () => Effect26.succeed({ _tag: "Allow" }) })),
+    approvals: Option16.getOrElse(approvals, () => Approvals.of({ resolve: () => Effect26.succeed({ _tag: "Approved" }) })),
+    ruleStore: Option16.getOrElse(ruleStoreService, () => RuleStore.of({
       rules: Ref5.get(defaultRules),
       remember: (rule) => Ref5.update(defaultRules, (rules) => [
         ...rules.filter((current) => current.pattern !== rule.pattern),
@@ -2351,29 +3010,29 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
   }));
   const memoryOptions = options.memory ?? (agent.memory === undefined ? undefined : { key: agent.memory });
   const agentModel = agent.model;
-  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option13.match(modelRegistryService, {
-    onNone: () => Effect23.fail(AgentError.make({
+  const agentModelRegistry = agentModel === undefined ? undefined : yield* Option16.match(modelRegistryService, {
+    onNone: () => Effect26.fail(AgentError.make({
       message: "Agent.model requires ModelRegistry in context",
       turn: 0
     })),
-    onSome: Effect23.succeed
+    onSome: Effect26.succeed
   });
   const memoryRuntime = memoryOptions === undefined ? undefined : {
     key: memoryOptions.key,
-    service: yield* Option13.match(memoryService, {
-      onNone: () => Effect23.fail(AgentError.make({
+    service: yield* Option16.match(memoryService, {
+      onNone: () => Effect26.fail(AgentError.make({
         message: options.memory === undefined ? "Agent.memory requires Memory in context" : "RunOptions.memory requires Memory in context",
         turn: 0
       })),
-      onSome: Effect23.succeed
+      onSome: Effect26.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 ? 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 savePersisted = (turn) => persisted === undefined ? Effect26.void : persisted.save.pipe(Effect26.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(Effect26.tap(() => savePersisted(turn)));
+  const checkpointSuspended = (turn, pending, suspension) => Effect26.gen(function* () {
     const withPending = yield* appendPending(turn, pending);
     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)) {
@@ -2417,11 +3076,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.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 (Option13.isNone(activeSession))
+    if (Option16.isNone(activeSession))
       yield* savePersisted(turn);
     return yield* Ref5.get(chat.history);
   });
-  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect23.tap((checkpoint) => syncSession(turn, checkpoint)));
+  const checkpointPending = (turn, pending) => appendPending(turn, pending).pipe(Effect26.tap((checkpoint) => syncSession(turn, checkpoint)));
   const state = {
     text: "",
     turn: 0,
@@ -2434,15 +3093,15 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     registry: initialRegistry,
     activatedSkillBodies: new Map
   });
-  const restoreActivatedSkills = (history) => Effect23.gen(function* () {
+  const restoreActivatedSkills = (history) => Effect26.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 = Schema19.decodeUnknownOption(activateSkillSuccess)(part.result);
-        if (Option13.isNone(activation))
+        const activation = Schema20.decodeUnknownOption(activateSkillSuccess)(part.result);
+        if (Option16.isNone(activation))
           continue;
         if (skillRuntime === undefined) {
           return yield* AgentError.make({
@@ -2473,10 +3132,10 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         yield* Ref5.set(toolState, { registry, activatedSkillBodies });
       }
     }
-  }).pipe(Effect23.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
+  }).pipe(Effect26.mapError((error) => isToolNameCollision(error) ? error : AgentError.make({ message: error.message, turn: 0, cause: error })));
   if (validatedResume !== undefined)
-    yield* Ref5.get(chat.history).pipe(Effect23.flatMap(restoreActivatedSkills));
-  const activeSession = Option13.isSome(compactionService) ? sessionService : Option13.none();
+    yield* Ref5.get(chat.history).pipe(Effect26.flatMap(restoreActivatedSkills));
+  const activeSession = Option16.isSome(compactionService) ? sessionService : Option16.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 });
@@ -2490,33 +3149,34 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.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 ? 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({
+  const recallInitialPrompt = (prompt) => memoryRuntime === undefined ? Effect26.succeed(prompt) : memoryRuntime.service.recall({ key: memoryRuntime.key, turn: 0, prompt }).pipe(Effect26.mapError((error) => memoryError(0, error)), Effect26.map((items) => insertRecalledItems(prompt, items)));
+  const rememberTurn = (turn, transcript, terminal, path) => memoryRuntime === undefined ? Effect26.void : memoryRuntime.service.remember({
     key: memoryRuntime.key,
     turn,
-    transcript: Option13.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
+    transcript: Option16.isSome(activeSession) ? buildMemoryContext(path) : projectTranscript(transcript),
     terminal
-  }).pipe(Effect23.mapError((error) => memoryError(turn, error)));
-  const messageEquivalence = Schema19.toEquivalence(Prompt11.Message);
-  const promptEquivalence2 = Schema19.toEquivalence(Prompt11.Prompt);
+  }).pipe(Effect26.mapError((error) => memoryError(turn, error)));
+  const messageEquivalence = Schema20.toEquivalence(Prompt11.Message);
+  const promptEquivalence2 = Schema20.toEquivalence(Prompt11.Prompt);
+  const canonicalEquivalence = (left, right) => messageEquivalence(coalesceAdjacentText(left), coalesceAdjacentText(right));
   const sessionTranscriptCursor = (projection, transcript) => {
     if (projection.length === 0)
-      return Option13.some(0);
+      return Option16.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]))) {
+      if (transcript.slice(0, start).every((message) => message.role === "system") && projection.every((message, index) => canonicalEquivalence(message, transcript[start + index]))) {
         matches2.push(start + projection.length);
       }
     }
-    return matches2.length === 1 ? Option13.some(matches2[0]) : Option13.none();
+    return matches2.length === 1 ? Option16.some(matches2[0]) : Option16.none();
   };
-  const syncSession = (turn, transcript) => Option13.match(activeSession, {
-    onNone: () => Effect23.succeed([]),
-    onSome: (session) => Effect23.gen(function* () {
+  const syncSession = (turn, transcript) => Option16.match(activeSession, {
+    onNone: () => Effect26.succeed([]),
+    onSome: (session) => Effect26.gen(function* () {
       let path = yield* session.path();
       const projection = buildContext(path);
       const cursor = sessionTranscriptCursor(projection.content, transcript.content);
-      if (Option13.isNone(cursor)) {
+      if (Option16.isNone(cursor)) {
         const checkpoint = path.at(-1);
         const before = buildContext(path.slice(0, -1));
         if (checkpoint?._tag === "Compaction" && checkpoint.version === 2 && promptEquivalence2(before, transcript)) {
@@ -2544,13 +3204,13 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       if (expectedLeafId !== (path.at(-1)?.id ?? null))
         path = yield* session.path();
       return path;
-    }).pipe(Effect23.mapError((error) => Schema19.is(AgentError)(error) ? error : sessionError(turn, error)))
+    }).pipe(Effect26.mapError((error) => Schema20.is(AgentError)(error) ? error : sessionError(turn, 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 countTokens = (turn, prompt) => Option16.match(tokenizerService, {
+    onNone: () => Effect26.succeed(Math.ceil(JSON.stringify(prompt.content).length / 4)),
+    onSome: (tokenizer) => tokenizer.tokenize(prompt).pipe(Effect26.map((tokens) => tokens.length), Effect26.mapError((error) => AgentError.make({ message: errorMessage(error), turn, cause: error })))
   });
-  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt11.concat(history, prompt)).pipe(Effect23.map((contextTokens) => ({
+  const compactionUsage = (turn, history, prompt) => countTokens(turn, Prompt11.concat(history, prompt)).pipe(Effect26.map((contextTokens) => ({
     contextTokens,
     contextWindow: options.compaction?.contextWindow ?? Number.POSITIVE_INFINITY,
     reserveTokens: DEFAULT_RESERVE_TOKENS
@@ -2561,14 +3221,14 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     for (const message of Prompt11.concat(result.history, result.prompt).content) {
       if (typeof message.content === "string") {
         if (pending.size > 0) {
-          return Effect23.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+          return Effect26.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 Effect23.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
+        return Effect26.fail(AgentError.make({ message: "Compaction projection separates a tool call from its result", turn }));
       }
       if (!hasResult)
         optional.clear();
@@ -2576,7 +3236,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       for (const part of message.content) {
         if (part.type === "tool-call") {
           if (responseCalls.has(part.id)) {
-            return Effect23.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
+            return Effect26.fail(AgentError.make({ message: `Compaction projection contains duplicate tool call ${part.id}`, turn }));
           }
           responseCalls.add(part.id);
           if (part.providerExecuted)
@@ -2586,40 +3246,69 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         }
         if (part.type === "tool-result") {
           if (!pending.delete(part.id) && !optional.delete(part.id)) {
-            return Effect23.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
+            return Effect26.fail(AgentError.make({ message: `Compaction projection contains orphan tool result ${part.id}`, turn }));
           }
         }
       }
     }
-    return pending.size === 0 ? Effect23.void : Effect23.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
+    return pending.size === 0 ? Effect26.void : Effect26.fail(AgentError.make({ message: "Compaction projection contains an unresolved tool call", turn }));
   };
-  const applyCompactionResult = (turn, result, parentId) => Option13.match(activeSession, {
-    onNone: () => Ref5.set(chat.history, result.history),
-    onSome: (session) => Effect23.gen(function* () {
+  const applyCompactionResult = (turn, result, parentId, commitData) => Option16.match(activeSession, {
+    onNone: () => deliverPending().pipe(Effect26.andThen(Ref5.set(chat.history, result.history))),
+    onSome: (session) => Effect26.gen(function* () {
       const id = yield* session.reserveEntryId;
-      yield* Effect23.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
+      const telemetry = Object.freeze([...undeliveredTelemetry]);
+      const completed = commitData === undefined ? undefined : telemetry.findLast((event) => event._tag === "CompactionCompleted" && event.compactionId === commitData.compactionId);
+      if (commitData !== undefined && completed === undefined) {
+        return yield* AgentError.make({
+          message: `Changed custom compaction ${commitData.compactionId} did not emit CompactionCompleted`,
+          turn
+        });
+      }
+      const compactionCommit = commitData === undefined ? undefined : {
+        ...commitData,
+        checkpointId: id,
+        ...completed?.summaryModelCallId === undefined ? {} : { summaryModelCallId: completed.summaryModelCallId }
+      };
+      yield* Effect26.uninterruptibleMask((restore) => restore(session.appendCheckpoint({
         id,
         parentId,
         projectedHistory: result.history,
+        telemetry,
+        ...compactionCommit === undefined ? {} : { compactionCommit },
         ...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)))
+      }).pipe(Effect26.filterOrFail((appended) => checkpointMatches(appended.checkpoint, {
+        id,
+        parentId,
+        projectedHistory: result.history,
+        telemetry,
+        ...compactionCommit === undefined ? {} : { compactionCommit },
+        ...result._tag === "Summarize" ? { summary: result.summary } : {}
+      }), () => SessionConflict.make({
+        reason: "checkpoint-id-reused",
+        message: `Session returned a non-matching checkpoint ${id}`
+      })))).pipe(Effect26.tap(() => Effect26.sync(() => {
+        undeliveredTelemetry.splice(0, telemetry.length);
+      })), Effect26.flatMap((appended) => restore(session.path(appended.leafId))), Effect26.map(buildContext), Effect26.tap((projection) => Ref5.set(chat.history, projection)), Effect26.andThen(restore(savePersisted(turn)))));
+    }).pipe(Effect26.mapError((error) => Schema20.is(AgentError)(error) ? error : sessionError(turn, error)))
   });
-  const preparePrompt = (turn, prompt, overflow) => Option13.match(compactionService, {
-    onNone: () => Effect23.succeed({ prompt, changed: false }),
-    onSome: (compaction) => Effect23.gen(function* () {
+  const preparePrompt = (turn, prompt, overflow) => Option16.match(compactionService, {
+    onNone: () => Effect26.succeed({ prompt, changed: false }),
+    onSome: (compaction) => Effect26.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(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({
+      const detachedHistory = yield* detachPrompt(history).pipe(Effect26.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPrompt = yield* detachPrompt(prompt).pipe(Effect26.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalHistory = yield* detachPrompt(detachedHistory).pipe(Effect26.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const originalPrompt = yield* detachPrompt(detachedPrompt).pipe(Effect26.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const detachedPath = yield* Effect26.forEach(path, detachEntry).pipe(Effect26.mapError((error) => AgentError.make({ message: error.message, turn, cause: error })));
+      const compactionId = yield* generateId;
+      const compacted = yield* Effect26.scoped(compaction.maybeCompact({
+        compactionId,
         agentName: agent.name,
         sessionId,
         turn,
@@ -2629,14 +3318,14 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         usage,
         overflow,
         ...options.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: options.toolOutputMaxBytes }
-      }).pipe(Effect23.mapError((error) => compactionError(turn, error)));
-      if (Option13.isNone(compacted))
+      })).pipe(Effect26.mapError((error) => compactionError(turn, error)));
+      if (Option16.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 = Option13.isSome(activeSession) ? promptRecalled : allowed;
+      const required = Option16.isSome(activeSession) ? promptRecalled : allowed;
       if (!preservesRecalledMessages(allowed, required, Prompt11.concat(compacted.value.history, compacted.value.prompt))) {
         return yield* MiddlewareViolation.make({
           turn,
@@ -2644,24 +3333,32 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         });
       }
       yield* validateCompactionProjection(turn, compacted.value);
-      yield* applyCompactionResult(turn, compacted.value, path.at(-1)?.id ?? null);
+      const after = Prompt11.concat(compacted.value.history, compacted.value.prompt);
+      const contextTokensAfter = yield* Effect26.option(countTokens(turn, after));
+      yield* applyCompactionResult(turn, compacted.value, path.at(-1)?.id ?? null, {
+        compactionId,
+        contextTokensBefore: usage.contextTokens,
+        ...Option16.isSome(contextTokensAfter) ? { contextTokensAfter: contextTokensAfter.value } : {},
+        entriesBefore: Prompt11.concat(history, prompt).content.length,
+        entriesAfter: after.content.length
+      });
       return { prompt: compacted.value.prompt, changed: true };
     })
   });
-  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 boundedSuccessResult = (call, outcome) => options.toolOutputMaxBytes === undefined ? Effect26.succeed(successResult(call, outcome)) : bound(outcome, { toolCallId: call.id, maxBytes: options.toolOutputMaxBytes }).pipe(Effect26.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(() => {
+    const completed = (result) => Effect26.sync(() => {
       state.pending.set(toolCallIndex, result);
       return { _tag: "ToolExecutionCompleted", turn, call, result, ...metadata };
     });
     switch (outcome._tag) {
       case "Success":
-        return (isSkillActivationCall(call, registry) ? Effect23.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect23.flatMap(completed));
+        return (isSkillActivationCall(call, registry) ? Effect26.succeed(successResult(call, outcome)) : boundedSuccessResult(call, outcome)).pipe(Effect26.flatMap(completed));
       case "DomainFailure":
         return completed(domainFailureResult(call, outcome));
       case "Suspend":
-        return Effect23.fail(suspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
+        return Effect26.fail(suspended(call, toolCallBatch, toolCallIndex, outcome.token, "tool-wait"));
     }
   };
   const defaultExecute = (request, registry) => {
@@ -2669,11 +3366,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     if (registered?.dispatch === "Static") {
       return executeToolkit(staticToolkit, request);
     }
-    return registered === undefined ? Effect23.fail(FrameworkFailure.make({
+    return registered === undefined ? Effect26.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Tool ${request.call.name} is not registered`
-    })) : Effect23.fail(FrameworkFailure.make({
+    })) : Effect26.fail(FrameworkFailure.make({
       stage: "missing-handler",
       tool: request.call.name,
       message: `Activated skill tool ${request.call.name} requires ToolExecutor`
@@ -2690,11 +3387,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         return Queue2.sliding(progressPolicy.capacity);
     }
   };
-  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 executeApproved = (turn, call, request, registry) => Stream5.concat(Stream5.fromIterable([{ _tag: "ToolExecutionStarted", turn, call }]), Stream5.unwrap(Effect26.gen(function* () {
+    const progressQueue = yield* Effect26.acquireRelease(makeProgressQueue(), Queue2.shutdown);
     const droppedProgress = yield* Ref5.make(0);
     const emitSemaphore = yield* Semaphore3.make(1);
-    const signal = yield* Effect23.abortSignal;
+    const signal = yield* Effect26.abortSignal;
     const context = ToolContext.of({
       signal,
       sessionId,
@@ -2706,9 +3403,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
           ...progress.message === undefined ? {} : { message: progress.message },
           ...progress.data === undefined ? {} : { data: progress.data }
         };
-        return emitSemaphore.withPermit(Effect23.gen(function* () {
+        return emitSemaphore.withPermit(Effect26.gen(function* () {
           if (progressPolicy._tag === "Sliding") {
-            const dropped = yield* Effect23.sync(() => {
+            const dropped = yield* Effect26.sync(() => {
               const full = Queue2.isFullUnsafe(progressQueue);
               Queue2.offerUnsafe(progressQueue, event);
               return full;
@@ -2726,11 +3423,11 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         }));
       }
     });
-    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 execution = isSkillActivationCall(call, registry) ? activateSkillOutcome(turn, call) : Option16.isNone(executor) ? defaultExecute(request, registry) : executor.value.execute(request).pipe(Effect26.mapError((error) => Schema20.is(RemoteRetryMisconfigured)(error) ? AgentError.make({ message: error.message, turn, cause: error }) : error));
+    const fiber = yield* Effect26.uninterruptibleMask((restore) => restore(execution.pipe(Effect26.provideService(ToolContext, context))).pipe(Effect26.flatMap((outcome) => Ref5.get(droppedProgress).pipe(Effect26.flatMap((dropped) => outcomeEvent(turn, request.toolCallBatch, request.toolCallIndex, call, outcome, dropped, registry)))))).pipe(Effect26.ensuring(Queue2.end(progressQueue).pipe(Effect26.asVoid)), Effect26.forkScoped({ startImmediately: true }));
+    return Stream5.concat(Stream5.fromQueue(progressQueue), Stream5.fromEffect(Fiber3.join(fiber)));
   })));
-  const activateSkillOutcome = (turn, call) => Effect23.gen(function* () {
+  const activateSkillOutcome = (turn, call) => Effect26.gen(function* () {
     if (skillRuntime === undefined) {
       return yield* FrameworkFailure.make({
         stage: "missing-handler",
@@ -2738,8 +3435,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         message: "SkillSource is not available"
       });
     }
-    const params = Schema19.decodeUnknownOption(activateSkillParameters)(call.params);
-    if (Option13.isNone(params)) {
+    const params = Schema20.decodeUnknownOption(activateSkillParameters)(call.params);
+    if (Option16.isNone(params)) {
       return yield* FrameworkFailure.make({
         stage: "decode-input",
         tool: call.name,
@@ -2780,19 +3477,19 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       allowedTools: [...skill.frontmatter.allowedTools ?? []]
     };
     return { _tag: "Success", result: output, encodedResult: output };
-  }).pipe(Effect23.mapError((error) => isToolNameCollision(error) || Schema19.is(FrameworkFailure)(error) ? error : skillError(turn, error)));
+  }).pipe(Effect26.mapError((error) => isToolNameCollision(error) || Schema20.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) => {
     const request = { call, toolCallBatch, turn, toolCallIndex, agentName: agent.name, sessionId };
     const candidate = get(registry, call.name);
     if (candidate === undefined)
-      return Stream4.fail(FrameworkFailure.make({
+      return Stream5.fail(FrameworkFailure.make({
         stage: "authorization",
         tool: call.name,
         message: `Tool ${call.name} is not active for turn ${turn}`
       }));
     const activeTools = registry.entries.map((entry) => entry.tool.name);
-    return Stream4.unwrap(Effect23.gen(function* () {
+    return Stream5.unwrap(Effect26.gen(function* () {
       const activatedSkills = [...(yield* Ref5.get(toolState)).activatedSkillBodies.keys()];
       const approvalEvents = yield* Queue2.bounded(1);
       const fiber = yield* authorizer.authorize({
@@ -2805,20 +3502,20 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         activeTools,
         activatedSkills,
         messages,
-        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) => {
+        onApprovalRequired: Queue2.offer(approvalEvents, { _tag: "ApprovalRequested", turn, call }).pipe(Effect26.asVoid)
+      }).pipe(Effect26.mapError((error) => authorizationError2(turn, error)), Effect26.ensuring(Queue2.end(approvalEvents).pipe(Effect26.asVoid)), Effect26.forkScoped({ startImmediately: true }));
+      return Stream5.concat(Stream5.fromQueue(approvalEvents), Stream5.fromEffect(Fiber3.join(fiber)).pipe(Stream5.flatMap((decision2) => {
         switch (decision2._tag) {
           case "Execute":
             return executeApproved(turn, call, request, registry);
           case "Deny":
-            return Stream4.fail(FrameworkFailure.make({
+            return Stream5.fail(FrameworkFailure.make({
               stage: "authorization",
               tool: call.name,
               message: decision2.error.message
             }));
           case "Suspend":
-            return Stream4.fail(AgentSuspended.make({
+            return Stream5.fail(AgentSuspended.make({
               token: decision2.suspension.token,
               reason: "approval",
               tool_call_index: toolCallIndex,
@@ -2833,8 +3530,8 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       })));
     }));
   };
-  const captureFinishPart = (part) => Effect23.gen(function* () {
-    const span = yield* Effect23.currentSpan;
+  const captureFinishPart = (part) => Effect26.gen(function* () {
+    const span = yield* Effect26.currentSpan;
     state.finish = {
       usage: state.finish === undefined ? part.usage : addUsage(state.finish.usage, part.usage),
       reason: part.reason
@@ -2848,9 +3545,9 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       },
       response: { finishReasons: [part.reason] }
     });
-  }).pipe(Effect23.orDie);
-  const captureStructuredUsage = (content) => Effect23.gen(function* () {
-    const span = yield* Effect23.currentSpan;
+  }).pipe(Effect26.orDie);
+  const captureStructuredUsage = (content) => Effect26.gen(function* () {
+    const span = yield* Effect26.currentSpan;
     for (const part of content) {
       if (part.type === "finish") {
         state.usage = state.usage === undefined ? part.usage : addUsage(state.usage, part.usage);
@@ -2864,135 +3561,147 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         });
       }
     }
-  }).pipe(Effect23.orDie);
-  const withModelResilience = (effect) => Option13.match(resilienceService, {
-    onNone: () => effect,
-    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)
-    }))))
-  });
+  }).pipe(Effect26.orDie);
+  const withModelTelemetry = (turn, purpose) => (effect) => Effect26.flatMap(LanguageModel9.LanguageModel, (model) => effect.pipe(Effect26.provideService(LanguageModel9.LanguageModel, instrumentModel(model, turn)), Effect26.provideService(CurrentPurpose, purpose)));
   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("@batonfx/core/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(Stream5.catchTag("@batonfx/core/LanguageModelNotRegistered", (error) => Stream5.fail(AgentError.make({ message: errorMessage(error), turn: state.turn, cause: error }))));
   }
   const partEvents = (turn, part) => {
     if (part.type === "error") {
       if (isToolNameCollision(part.error))
-        return Stream4.fail(part.error);
-      return Stream4.fail(AgentError.make({ message: errorMessage(part.error), turn, cause: part.error }));
+        return Stream5.fail(part.error);
+      return Stream5.fail(AgentError.make({ message: errorMessage(part.error), turn, cause: part.error }));
+    }
+    const identity = telemetryIdentity.current;
+    if (identity === undefined) {
+      return Stream5.fromEffect(Effect26.die(new Error("ModelPart produced outside an instrumented model attempt")));
     }
-    const modelPart = Stream4.fromIterable([{ _tag: "ModelPart", turn, part }]);
+    const modelPart = Stream5.fromIterable([
+      {
+        _tag: "ModelPart",
+        turn,
+        modelCallId: identity.modelCallId,
+        modelAttemptId: identity.modelAttemptId,
+        attempt: identity.attempt,
+        part
+      }
+    ]);
     if (part.type === "text-delta") {
       state.text = `${state.text}${part.delta}`;
     }
     if (part.type === "finish") {
-      return modelPart.pipe(Stream4.tap(() => captureFinishPart(part)));
+      return modelPart.pipe(Stream5.tap(() => captureFinishPart(part)));
     }
     return modelPart;
   };
-  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({
+  const transformPart = (turn, part) => applyPartChain(chain, part, { agentName: agent.name, turn }).pipe(Effect26.flatMap(Option16.match({
+    onSome: (transformed) => Effect26.succeed(Option16.some(transformed)),
+    onNone: () => part.type === "tool-call" ? Effect26.fail(MiddlewareViolation.make({
       turn,
       detail: "ModelMiddleware dropped a tool-call part"
-    })) : Effect23.succeed(Option13.none())
+    })) : Effect26.succeed(Option16.none())
   })));
   const validateToolCallId = (idState, part) => {
     if (part.type !== "tool-call")
-      return Effect23.void;
+      return Effect26.void;
     return Ref5.modify(idState, (current) => {
       const existingFirstIndex = HashMap6.get(current.firstIndexes, part.id);
-      const duplicate = Option13.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
+      const duplicate = Option16.map(existingFirstIndex, (index) => DuplicateToolCallId.make({ id: part.id, firstIndex: index, duplicateIndex: current.nextIndex }));
       return [
         duplicate,
         {
           nextIndex: current.nextIndex + 1,
-          firstIndexes: Option13.isSome(existingFirstIndex) ? current.firstIndexes : HashMap6.set(current.firstIndexes, part.id, current.nextIndex)
+          firstIndexes: Option16.isSome(existingFirstIndex) ? current.firstIndexes : HashMap6.set(current.firstIndexes, part.id, current.nextIndex)
         }
       ];
-    }).pipe(Effect23.flatMap(Option13.match({
-      onNone: () => Effect23.void,
-      onSome: Effect23.fail
+    }).pipe(Effect26.flatMap(Option16.match({
+      onNone: () => Effect26.void,
+      onSome: Effect26.fail
     })));
   };
   const modelTurn = (turn, prompt, registry, overrides) => {
     const activeRegistry = overrides?.activeTools === undefined ? registry : select(registry, overrides.activeTools);
+    const instrumentTurnStream = (stream2) => Stream5.unwrap(LanguageModel9.LanguageModel.pipe(Effect26.map((model) => stream2.pipe(Stream5.provideService(LanguageModel9.LanguageModel, instrumentModel(model, turn)), Stream5.provideService(CurrentInstrumentation, {
+      emit: emitTelemetry,
+      wrap: (summaryModel) => instrumentModel(summaryModel, turn)
+    })))));
     const attempt = (activePrompt, retryOverflow, compactOverflow = false, overflowCause) => {
       let emitted = false;
       let classifyFailure2 = classifyOtherFailure;
       const transformedParts = new Array;
       let preparedState;
-      const singleFailure = (cause) => {
+      const singleFailure2 = (cause) => {
         const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-        return reason !== undefined && Cause4.isFailReason(reason) ? Option13.some(reason.error) : Option13.none();
+        return reason !== undefined && Cause6.isFailReason(reason) ? Option16.some(reason.error) : Option16.none();
       };
       const retryableOverflow = (cause, hasEmitted) => {
-        const failure2 = singleFailure(cause);
-        if (Option13.isNone(failure2))
+        const failure2 = singleFailure2(cause);
+        if (Option16.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";
+        const classifiedFailure = Schema20.is(AgentError)(failure2.value) && failure2.value.cause !== undefined ? failure2.value.cause : failure2.value;
+        return retryOverflow && !hasEmitted && Option16.isSome(compactionService) && classifyFailure2(classifiedFailure) === "context-overflow";
       };
-      return Stream4.fromChannel(Channel.acquireUseRelease(Ref5.make({
+      return Stream5.fromChannel(Channel.acquireUseRelease(Ref5.make({
         nextIndex: 0,
         firstIndexes: HashMap6.empty()
-      }), (toolCallIds) => Stream4.unwrap(Effect23.gen(function* () {
-        const activeModel = yield* LanguageModel6.LanguageModel;
+      }), (toolCallIds) => Stream5.unwrap(Effect26.gen(function* () {
+        const activeModel = yield* LanguageModel9.LanguageModel;
         classifyFailure2 = (error) => classifyFailure(activeModel, error);
         const prepared = yield* preparePrompt(turn, activePrompt, compactOverflow);
         if (compactOverflow && !prepared.changed && overflowCause !== undefined) {
-          return yield* Effect23.failCause(overflowCause);
+          return yield* Effect26.failCause(overflowCause);
         }
-        const preparedPrompt = prepared.prompt;
+        const coalescedContent = prepared.prompt.content.map(coalesceAdjacentText);
+        const preparedPrompt = coalescedContent.some((message, index) => message !== prepared.prompt.content[index]) ? Prompt11.fromMessages(coalescedContent) : prepared.prompt;
         const history = yield* Ref5.get(chat.history);
         preparedState = { history, preparedPrompt };
         const responsePrompt = Prompt11.concat(history, preparedPrompt);
         const messages = responsePrompt.content;
-        const rawParts = LanguageModel6.streamText({
+        const rawParts = LanguageModel9.streamText({
           prompt: responsePrompt,
           toolkit: activeRegistry.toolkit,
           disableToolCallResolution: true
-        }).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(() => {
+        }).pipe(Stream5.mapEffect((part) => part.type === "error" ? Effect26.fail(isToolNameCollision(part.error) ? part.error : AgentError.make({ message: errorMessage(part.error), turn, cause: part.error })) : Effect26.succeed(part)), Stream5.tap(() => Effect26.sync(() => {
           emitted = true;
-        })), Stream4.catchCause((cause) => {
-          if (Cause4.hasInterrupts(cause) || Cause4.hasDies(cause))
-            return Stream4.failCause(cause);
+        })), Stream5.catchCause((cause) => {
+          if (Cause6.hasInterrupts(cause) || Cause6.hasDies(cause))
+            return Stream5.failCause(cause);
           if (retryableOverflow(cause, emitted))
-            return Stream4.failCause(cause);
-          const error = singleFailure(cause);
-          if (Option13.isNone(error))
-            return Stream4.failCause(cause);
-          if (Schema19.is(AgentError)(error.value) || isToolNameCollision(error.value)) {
-            return Stream4.fail(error.value);
+            return Stream5.failCause(cause);
+          const error = singleFailure2(cause);
+          if (Option16.isNone(error))
+            return Stream5.failCause(cause);
+          if (Schema20.is(AgentError)(error.value) || isToolNameCollision(error.value)) {
+            return Stream5.fail(error.value);
           }
-          return Stream4.make(Response9.makePart("error", { error: error.value }));
+          return Stream5.make(Response11.makePart("error", { error: error.value }));
         }));
-        return rawParts.pipe(Stream4.mapEffect((part) => transformPart(turn, part)), Stream4.flatMap(Option13.match({ onNone: () => Stream4.empty, onSome: Stream4.make })), Stream4.map((part) => ({
+        return rawParts.pipe(Stream5.mapEffect((part) => transformPart(turn, part)), Stream5.flatMap(Option16.match({ onNone: () => Stream5.empty, onSome: Stream5.make })), Stream5.map((part) => ({
           part,
           messages,
-          accept: validateToolCallId(toolCallIds, part).pipe(Effect23.andThen(Effect23.sync(() => {
+          accept: validateToolCallId(toolCallIds, part).pipe(Effect26.andThen(Effect26.sync(() => {
             transformedParts.push(part);
           })))
         })));
-      })).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);
+      })).pipe(Stream5.toChannel), (_, exit) => preparedState === undefined || Exit4.isFailure(exit) && retryableOverflow(exit.cause, emitted) ? Effect26.void : Ref5.set(chat.history, Prompt11.concat(Prompt11.concat(preparedState.history, preparedState.preparedPrompt), Prompt11.fromResponseParts(transformedParts))).pipe(Effect26.andThen(persisted === undefined ? Effect26.void : persisted.save), Effect26.orDie, Effect26.asVoid))).pipe(Stream5.catchCause((cause) => {
+        if (Cause6.hasInterrupts(cause) || Cause6.hasDies(cause))
+          return Stream5.failCause(cause);
         if (retryableOverflow(cause, emitted)) {
           return attempt(preparedState?.preparedPrompt ?? activePrompt, false, true, cause);
         }
-        return Stream4.failCause(cause);
-      }), Stream4.catchCause((cause) => {
-        const failure2 = singleFailure(cause);
-        return Option13.isSome(failure2) && AiError4.isAiError(failure2.value) ? Stream4.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream4.failCause(cause);
+        return Stream5.failCause(cause);
+      }), Stream5.catchCause((cause) => {
+        const failure2 = singleFailure2(cause);
+        return Option16.isSome(failure2) && AiError7.isAiError(failure2.value) ? Stream5.fail(AgentError.make({ message: errorMessage(failure2.value), turn, cause: failure2.value })) : Stream5.failCause(cause);
       }));
     };
-    const parts = Stream4.unwrap(applyPromptChain(chain, Prompt11.make(prompt), { agentName: agent.name, turn }).pipe(Effect23.map((transformedPrompt) => {
+    const parts = Stream5.unwrap(applyPromptChain(chain, Prompt11.make(prompt), { agentName: agent.name, turn }).pipe(Effect26.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(Effect23.as({ part, messages }))), Stream4.map(({ part, messages }) => {
+      const accepted = instrumentTurnStream(attempt(transformedPrompt, true)).pipe(Stream5.mapEffect(({ accept, part, messages }) => accept.pipe(Effect26.as({ part, messages }))), Stream5.map(({ part, messages }) => {
         const toolCallIndex = nextToolCallIndex;
         if (part.type === "tool-call" && part.providerExecuted !== true) {
           const call = part;
@@ -3001,23 +3710,16 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
           executions.push({ call, messages, toolCallIndex });
         }
         return { part, messages, toolCallIndex };
-      }), Stream4.flatMap(({ part }) => partEvents(turn, part)));
-      return Stream4.concat(accepted, Stream4.suspend(() => {
+      }), Stream5.flatMap(({ part }) => partEvents(turn, part)));
+      return Stream5.concat(accepted, Stream5.suspend(() => {
         Object.freeze(calls);
         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))) : executionStreams.pipe(Stream4.mapEffect(({ call, messages, toolCallIndex }) => Stream4.runCollect(toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), { concurrency }), Stream4.flatMap(Stream4.fromIterable));
+        const executionStreams = Stream5.fromIterable(executions);
+        return concurrency === 1 ? executionStreams.pipe(Stream5.flatMap(({ call, messages, toolCallIndex }) => toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry))) : executionStreams.pipe(Stream5.mapEffect(({ call, messages, toolCallIndex }) => Stream5.runCollect(toolCallEvents(turn, toolCallBatch, toolCallIndex, call, messages, activeRegistry)), { concurrency }), Stream5.flatMap(Stream5.fromIterable));
       }));
     })));
-    const resilientParts = Option13.match(resilienceService, {
-      onNone: () => parts,
-      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)
-      }))))))
-    });
-    return overrides?.model === undefined ? provideAgentModel(resilientParts) : resilientParts.pipe(Stream4.provide(overrides.model));
+    return overrides?.model === undefined ? provideAgentModel(parts) : parts.pipe(Stream5.provide(overrides.model));
   };
   const turnCompletedEvent = (turn, transcript) => ({
     _tag: "TurnCompleted",
@@ -3032,49 +3734,54 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     transcript,
     ...state.usage === undefined ? {} : { usage: state.usage }
   });
-  const structuredFinalEvents = (structuredTurn, config) => Stream4.fromEffect(Effect23.gen(function* () {
+  const structuredFinalEvents = (structuredTurn, config) => Stream5.fromEffect(Effect26.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* LanguageModel6.generateObject({
+    const response = yield* LanguageModel9.generateObject({
       prompt: Prompt11.concat(history, transformedPrompt),
       schema: config.schema,
       objectName: config.objectName,
       toolChoice: "none"
-    }).pipe(withModelResilience, withAgentModel, Effect23.catchCause((cause) => {
+    }).pipe(withModelTelemetry(structuredTurn, "structured-output"), withAgentModel, Effect26.catchCause((cause) => {
       const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-      return reason !== undefined && Cause4.isFailReason(reason) ? Effect23.fail(AgentError.make({
+      return reason !== undefined && Cause6.isFailReason(reason) ? Effect26.fail(AgentError.make({
         message: errorMessage(reason.error),
         turn: structuredTurn,
         cause: reason.error
-      })) : Effect23.failCause(cause);
+      })) : Effect26.failCause(cause);
     }));
     yield* captureStructuredUsage(response.content);
+    const structuredIdentity = telemetryIdentity.current;
+    if (structuredIdentity === undefined) {
+      return yield* Effect26.die(new Error("Structured output model attempt identity is missing"));
+    }
     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 (Option13.isNone(activeSession))
+    if (Option16.isNone(activeSession))
       yield* savePersisted(structuredTurn);
     const structuredOutput = {
       _tag: "StructuredOutput",
       turn: structuredTurn,
+      ...structuredIdentity,
       value: response.value,
       content: response.content
     };
     return [structuredOutput, terminalCompletedEvent(structuredTurn, transcript)];
-  })).pipe(Stream4.flatMap((events) => Stream4.fromIterable(events)));
+  })).pipe(Stream5.flatMap((events) => Stream5.fromIterable(events)));
   const promptFromSteeringInputs = (inputs) => inputs.reduce((prompt, input) => Prompt11.concat(prompt, input.prompt), Prompt11.empty);
-  const takeSteering = () => Option13.match(steeringService, {
-    onNone: () => Effect23.succeed([]),
+  const takeSteering = () => Option16.match(steeringService, {
+    onNone: () => Effect26.succeed([]),
     onSome: (service) => service.takeSteering
   });
-  const takeFollowUp = () => Option13.match(steeringService, {
-    onNone: () => Effect23.succeed([]),
+  const takeFollowUp = () => Option16.match(steeringService, {
+    onNone: () => Effect26.succeed([]),
     onSome: (service) => service.takeFollowUp
   });
-  const afterTurn = (turn) => Effect23.gen(function* () {
+  const afterTurn = (turn) => Effect26.gen(function* () {
     const pending = pendingResults();
     const transcript = yield* checkpointPending(turn, pending);
     const path = yield* syncSession(turn, transcript);
@@ -3084,19 +3791,19 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       const followUp = yield* takeFollowUp();
       if (followUp.length > 0) {
         return {
-          events: Stream4.fromIterable([completed, steeringDrainedEvent(turn, "followUp", followUp)]),
+          events: Stream5.fromIterable([completed, steeringDrainedEvent(turn, "followUp", followUp)]),
           next: { prompt: promptFromSteeringInputs(followUp) }
         };
       }
       if (structured !== undefined) {
         return {
-          events: Stream4.fromIterable([completed]),
+          events: Stream5.fromIterable([completed]),
           structuredTurn: turn + 1
         };
       }
       yield* savePersisted(turn);
       return {
-        events: Stream4.fromIterable([completed, terminalCompletedEvent(turn, transcript)])
+        events: Stream5.fromIterable([completed, terminalCompletedEvent(turn, transcript)])
       };
     }
     const evaluated = yield* agent.policy.decide({
@@ -3117,7 +3824,7 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
         tool_name: result.name
       }));
       return {
-        events: Stream4.concat(Stream4.fromIterable([completed]), Stream4.fail(decision2.reason._tag === "TurnLimit" ? TurnLimitExceeded.make({
+        events: Stream5.concat(Stream5.fromIterable([completed]), Stream5.fail(decision2.reason._tag === "TurnLimit" ? TurnLimitExceeded.make({
           turn: turn + 1,
           limit: decision2.reason.limit,
           pending: pendingCalls
@@ -3133,35 +3840,35 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
     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)]),
+      events: Stream5.fromIterable(steering.length === 0 ? [completed] : [completed, steeringDrainedEvent(turn, "steering", steering)]),
       next: { prompt, ...decision2.overrides === undefined ? {} : { overrides: decision2.overrides } }
     };
   });
-  const resetTurnState = (turn) => Stream4.sync(() => {
+  const resetTurnState = (turn) => Stream5.sync(() => {
     state.turn = turn;
     state.finish = undefined;
-  }).pipe(Stream4.drain);
+  }).pipe(Stream5.drain);
   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(Effect23.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream4.concat(Stream4.unwrap(afterTurn(turn).pipe(Effect23.map((result) => {
+    const currentTurn = Stream5.fromIterable([{ _tag: "TurnStarted", turn }]).pipe(Stream5.concat(resetTurnState(turn)), Stream5.concat(Stream5.unwrap(Ref5.get(toolState).pipe(Effect26.map(({ registry }) => modelTurn(turn, prompt, registry, overrides))))), Stream5.concat(Stream5.unwrap(afterTurn(turn).pipe(Effect26.map((result) => {
       next = result.next;
       structuredTurn = result.structuredTurn;
       return result.events;
-    })))), Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": turn } }));
-    return Stream4.concat(currentTurn, Stream4.suspend(() => {
+    })))), Stream5.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": turn } }));
+    return Stream5.concat(currentTurn, Stream5.suspend(() => {
       if (structuredTurn !== undefined && structured !== undefined) {
-        return structuredFinalEvents(structuredTurn, structured).pipe(Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": structuredTurn } }));
+        return structuredFinalEvents(structuredTurn, structured).pipe(Stream5.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": structuredTurn } }));
       }
-      return next === undefined ? Stream4.empty : runTurn(turn + 1, next.prompt, next.overrides);
+      return next === undefined ? Stream5.empty : runTurn(turn + 1, next.prompt, next.overrides);
     }));
   };
   const resumeStream = (checkpoint) => {
     let next;
-    const currentTurn = resetTurnState(0).pipe(Stream4.concat(Stream4.unwrap(Ref5.get(toolState).pipe(Effect23.map((tools) => {
+    const currentTurn = resetTurnState(0).pipe(Stream5.concat(Stream5.unwrap(Ref5.get(toolState).pipe(Effect26.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", {
+      const calls = suspension.tool_call_batch.map((call) => Response11.makePart("tool-call", {
         id: call.id,
         name: call.name,
         params: call.params,
@@ -3171,42 +3878,51 @@ var streamInternal = (agent, options, structured) => Stream4.unwrap(Effect23.gen
       const toolCallBatch = { calls };
       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 }));
+        return Stream5.fail(AgentError.make({ message: "Suspension tool call index is outside its batch", turn: 0 }));
       }
-      const executions = Stream4.fromIterable(checkpoint.unresolvedToolCallIndexes.map((toolCallIndex) => ({
+      const executions = Stream5.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)) : executions.pipe(Stream4.mapEffect((execution) => Stream4.runCollect(execute(execution)), { concurrency }), Stream4.flatMap(Stream4.fromIterable));
-    })))), Stream4.concat(Stream4.unwrap(afterTurn(0).pipe(Effect23.map((result) => {
+      return concurrency === 1 ? executions.pipe(Stream5.flatMap(execute)) : executions.pipe(Stream5.mapEffect((execution) => Stream5.runCollect(execute(execution)), { concurrency }), Stream5.flatMap(Stream5.fromIterable));
+    })))), Stream5.concat(Stream5.unwrap(afterTurn(0).pipe(Effect26.map((result) => {
       next = result.next;
       return result.events;
-    })))), Stream4.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
-    return Stream4.concat(currentTurn, Stream4.suspend(() => next === undefined ? Stream4.empty : runTurn(1, next.prompt, next.overrides)));
+    })))), Stream5.withSpan("Baton.Agent.turn", { attributes: { "baton.turn": 0 } }));
+    return Stream5.concat(currentTurn, Stream5.suspend(() => next === undefined ? Stream5.empty : runTurn(1, next.prompt, next.overrides)));
   };
   const baseInitialPrompt = seedSystem === undefined ? Prompt11.make(options.prompt) : withSystem(seedSystem, Prompt11.make(options.prompt));
   const initialPrompt = options.resume === undefined ? yield* recallInitialPrompt(baseInitialPrompt) : baseInitialPrompt;
   const runStream = validatedResume === undefined ? runTurn(0, initialPrompt) : resumeStream(validatedResume);
-  return runStream.pipe(Stream4.catchCause((cause) => {
+  const guardedStream = runStream.pipe(Stream5.catchCause((cause) => {
     const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
-    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 && Cause6.isFailReason(reason) && Schema20.is(DuplicateToolCallId)(reason.error)) {
+      return Stream5.unwrap(checkpointPending(state.turn, pendingResults()).pipe(Effect26.map(() => Stream5.failCause(cause))));
     }
-    if (reason !== undefined && Cause4.isFailReason(reason) && Schema19.is(AgentSuspended)(reason.error)) {
+    if (reason !== undefined && Cause6.isFailReason(reason) && Schema20.is(AgentSuspended)(reason.error)) {
       const suspension = reason.error;
-      return Stream4.unwrap(Effect23.gen(function* () {
+      return Stream5.unwrap(Effect26.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 Stream5.concat(Stream5.fromIterable([turnCompletedEvent(state.turn, checkpoint)]), Stream5.failCause(cause));
       }));
     }
-    return Stream4.failCause(cause);
+    return Stream5.failCause(cause);
+  }));
+  return guardedStream.pipe(Stream5.provideService(CurrentInstrumentation, undefined), Stream5.provideService(CurrentPurpose, "conversation"), Stream5.provideService(CurrentCompactionId, undefined), Stream5.provideService(CurrentSummaryCall, undefined), Stream5.mapEffect((event) => deliverPending().pipe(Effect26.map(() => [...flushTelemetry(), event]))), Stream5.flattenIterable, Stream5.concat(Stream5.unwrap(deliverPending().pipe(Effect26.map(() => Stream5.fromIterable(flushTelemetry()))))), Stream5.catchCause((cause) => {
+    if (Cause6.hasInterrupts(cause))
+      return Stream5.failCause(cause);
+    const reason = cause.reasons.length === 1 ? cause.reasons[0] : undefined;
+    if (reason !== undefined && Cause6.isFailReason(reason) && Schema20.is(DeliveryFailed)(reason.error)) {
+      return Stream5.failCause(cause);
+    }
+    return Stream5.unwrap(deliverPending().pipe(Effect26.map(() => Stream5.concat(Stream5.fromIterable(flushTelemetry()), Stream5.failCause(cause)))));
   }));
-})).pipe(Stream4.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }));
+})).pipe(Stream5.withSpan("Baton.Agent.run", { attributes: { "baton.agent.name": agent.name } }));
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/agent.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/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;
@@ -3244,20 +3960,20 @@ function make5(options) {
   };
 }
 var defaultObjectPrompt = "Return the final structured output for the task above.";
-var stream2 = dual6(2, (agent, options) => streamInternal(agent, options, options.output === undefined ? undefined : {
+var stream2 = dual7(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 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 generateText = (agent, options) => Stream6.runLast(streamInternal(agent, options, undefined)).pipe(Effect27.flatMap(Option17.match({
+  onNone: () => Effect27.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 })),
+  onSome: (event) => event._tag === "Completed" ? Effect27.succeed({ text: event.text, turns: event.turns, transcript: event.transcript }) : Effect27.fail(AgentError.make({ message: "Agent run ended without a Completed event", turn: 0 }))
 })));
-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({
+var generateObjectResult = (agent, options, structured) => Stream6.runFold(streamInternal(agent, options, structured), () => ({ value: Option17.none(), completed: Option17.none() }), (acc, event) => event._tag === "StructuredOutput" ? { ...acc, value: Option17.some(event.value) } : event._tag === "Completed" ? { ...acc, completed: Option17.some(event) } : acc).pipe(Effect27.flatMap(({ value, completed }) => Option17.match(completed, {
+  onNone: () => Effect27.fail(AgentError.make({ message: "Agent object run ended without a Completed event", turn: 0 })),
+  onSome: (event) => Option17.match(value, {
+    onNone: () => Effect27.fail(AgentError.make({ message: "Agent object run ended without a StructuredOutput event", turn: 0 })),
+    onSome: (typedValue) => Effect27.succeed({
       text: event.text,
       turns: event.turns,
       transcript: event.transcript,
@@ -3265,84 +3981,84 @@ var generateObjectResult = (agent, options, structured) => Stream5.runFold(strea
     })
   })
 })));
-var generate = dual6(2, (agent, options) => options.output === undefined ? generateText(agent, options) : generateObjectResult(agent, options, {
+var generate = dual7(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.9.1/node_modules/@batonfx/core/dist/agent-tool.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/agent-tool.js
 var exports_agent_tool = {};
 __export(exports_agent_tool, {
   asTool: () => asTool
 });
-import { Cause as Cause5, Effect as Effect25, Function as Function7, Schema as Schema21 } from "effect";
+import { Cause as Cause7, Effect as Effect28, Function as Function9, Schema as Schema22 } from "effect";
 import { Prompt as Prompt13, Tool as Tool11, Toolkit as Toolkit6 } from "effect/unstable/ai";
-var defaultParameters = Schema21.Struct({ prompt: Schema21.String });
+var defaultParameters = Schema22.Struct({ prompt: Schema22.String });
 var errorMessage2 = (error) => {
-  if (Schema21.is(AgentSuspended)(error)) {
+  if (Schema22.is(AgentSuspended)(error)) {
     return `suspended on ${error.tool_name}: ${error.reason}`;
   }
-  if (Schema21.is(AgentError)(error)) {
+  if (Schema22.is(AgentError)(error)) {
     return `failed on turn ${error.turn}: ${error.message}`;
   }
-  if (Schema21.is(ResumeMismatch)(error)) {
+  if (Schema22.is(ResumeMismatch)(error)) {
     return `resume mismatch: ${error.reason}`;
   }
-  if (Schema21.is(TurnLimitExceeded)(error)) {
+  if (Schema22.is(TurnLimitExceeded)(error)) {
     return `turn limit exceeded at turn ${error.turn}`;
   }
-  if (Schema21.is(TurnPolicyStopped)(error)) {
+  if (Schema22.is(TurnPolicyStopped)(error)) {
     return `policy stopped at turn ${error.turn}: ${error.reason._tag}`;
   }
-  if (Schema21.is(TurnPolicyError)(error)) {
+  if (Schema22.is(TurnPolicyError)(error)) {
     return `turn policy failed: ${error.message}`;
   }
-  if (Schema21.is(MiddlewareViolation)(error)) {
+  if (Schema22.is(MiddlewareViolation)(error)) {
     return `middleware violation on turn ${error.turn}: ${error.detail}`;
   }
-  if (Schema21.is(DuplicateToolCallId)(error)) {
+  if (Schema22.is(DuplicateToolCallId)(error)) {
     return `duplicate tool-call ID '${error.id}' at position ${error.duplicateIndex} (first at ${error.firstIndex})`;
   }
-  if (Schema21.is(ToolNameCollision)(error)) {
+  if (Schema22.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);
 };
-var causeMessage = (agentName, cause) => `sub-agent '${agentName}' could not complete: ${errorMessage2(Cause5.squash(cause))}`;
+var causeMessage = (agentName, cause) => `sub-agent '${agentName}' could not complete: ${errorMessage2(Cause7.squash(cause))}`;
 var lazyHandled = (toolkit, name, handler) => ({
   tools: toolkit.tools,
   handle: (toolName, params) => toolkit.toHandlers({
     [name]: handler
-  }).pipe(Effect25.flatMap((handlers) => toolkit.pipe(Effect25.provide(handlers))), Effect25.flatMap((handled) => handled.handle(toolName, params)))
+  }).pipe(Effect28.flatMap((handlers) => toolkit.pipe(Effect28.provide(handlers))), Effect28.flatMap((handled) => handled.handle(toolName, params)))
 });
-var asTool = Function7.dual((args) => args.length !== 1 || ("name" in args[0]), (agent, options = {}) => {
+var asTool = Function9.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 ?? Schema21.String;
+  const success2 = options.success ?? Schema22.String;
   const toPrompt = options.toPrompt ?? ((params) => params.prompt);
   const fromResult = options.fromResult ?? ((result) => result.text);
   const tool = Tool11.make(name, {
     ...options.description === undefined ? {} : { description: options.description },
     parameters,
     success: success2,
-    failure: Schema21.String,
+    failure: Schema22.String,
     failureMode: "return"
   });
   const toolkit = Toolkit6.make(tool);
-  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 Effect25.interrupt;
-      return Effect25.fail(causeMessage(agent.name, cause));
+  const handler = (params) => Effect28.gen(function* () {
+    const prompt = yield* Effect28.try({ try: () => toPrompt(params), catch: errorMessage2 });
+    const result = yield* generate(agent, { prompt }).pipe(Effect28.catchCause((cause) => {
+      if (Cause7.hasInterrupts(cause))
+        return Effect28.interrupt;
+      return Effect28.fail(causeMessage(agent.name, cause));
     }));
-    return yield* Effect25.try({ try: () => fromResult(result), catch: errorMessage2 });
+    return yield* Effect28.try({ try: () => fromResult(result), catch: errorMessage2 });
   });
   return lazyHandled(toolkit, name, handler);
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/guardrail.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/guardrail.js
 var exports_guardrail = {};
 __export(exports_guardrail, {
   validateInput: () => validateInput,
@@ -3350,8 +4066,8 @@ __export(exports_guardrail, {
   redactInput: () => redactInput,
   filterOutput: () => filterOutput
 });
-import { Effect as Effect26, Option as Option15 } from "effect";
-import { Prompt as Prompt14, Response as Response10 } from "effect/unstable/ai";
+import { Effect as Effect29, Option as Option18 } from "effect";
+import { Prompt as Prompt14, Response as Response12 } 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;
@@ -3400,19 +4116,19 @@ var redactPromptText = (prompt, options) => Prompt14.fromMessages(prompt.content
   }
 }));
 var validateInput = (check) => ({
-  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 }))
+  transformPrompt: (prompt, context) => check(prompt, context).pipe(Effect29.flatMap(Option18.match({
+    onNone: () => Effect29.succeed(prompt),
+    onSome: (reason) => Effect29.fail(AgentError.make({ message: `Input guardrail blocked: ${reason}`, turn: context.turn }))
   })))
 });
 var redactInput = (options) => ({
-  transformPrompt: (prompt) => Effect26.succeed(redactPromptText(prompt, options))
+  transformPrompt: (prompt) => Effect29.succeed(redactPromptText(prompt, options))
 });
 var redactOutput = (options) => ({
   transformPart: (part) => {
     if (part.type !== "text-delta")
-      return Effect26.succeed(Option15.some(part));
-    return Effect26.succeed(Option15.some(Response10.makePart("text-delta", {
+      return Effect29.succeed(Option18.some(part));
+    return Effect29.succeed(Option18.some(Response12.makePart("text-delta", {
       id: part.id,
       delta: redactText(part.delta, options),
       metadata: part.metadata
@@ -3420,23 +4136,23 @@ var redactOutput = (options) => ({
   }
 });
 var filterOutput = (keep) => ({
-  transformPart: (part, context) => Effect26.succeed(part.type === "tool-call" || keep(part, context) ? Option15.some(part) : Option15.none())
+  transformPart: (part, context) => Effect29.succeed(part.type === "tool-call" || keep(part, context) ? Option18.some(part) : Option18.none())
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.9.1/node_modules/@batonfx/core/dist/handoff.js
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/handoff.js
 var exports_handoff = {};
 __export(exports_handoff, {
   transferTool: () => transferTool,
   supervisor: () => supervisor,
   fanOut: () => fanOut
 });
-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 });
+import { Array as Array3, Effect as Effect30, Function as Function10, Schema as Schema23 } from "effect";
+import { AiError as AiError9, LanguageModel as LanguageModel11, Prompt as Prompt15, Tool as Tool12, Toolkit as Toolkit7 } from "effect/unstable/ai";
+var defaultTransferParameters = Schema23.Struct({ prompt: Schema23.String });
 var transferName = (agentName) => `transfer_to_${agentName}`;
 var positiveConcurrency = (value) => {
   const concurrency = value ?? 4;
-  return Number.isInteger(concurrency) && concurrency > 0 ? Effect27.succeed(concurrency) : Effect27.fail(AgentError.make({
+  return Number.isInteger(concurrency) && concurrency > 0 ? Effect30.succeed(concurrency) : Effect30.fail(AgentError.make({
     message: "Handoff.fanOut concurrency must be a positive integer",
     turn: 0
   }));
@@ -3454,10 +4170,10 @@ var mergeHandled = (toolkits) => {
     tools,
     handle: (name, params) => {
       const entry = entries.get(String(name));
-      return entry === undefined ? Effect27.fail(AiError6.make({
+      return entry === undefined ? Effect30.fail(AiError9.make({
         module: "Handoff",
         method: `${String(name)}.handle`,
-        reason: AiError6.ToolNotFoundError.make({
+        reason: AiError9.ToolNotFoundError.make({
           toolName: String(name),
           availableTools: Object.keys(tools)
         })
@@ -3466,7 +4182,7 @@ var mergeHandled = (toolkits) => {
   };
 };
 var toolkitFromHandled = (toolkit) => Toolkit7.make(...Object.values(toolkit.tools));
-var transferTool = Function8.dual((args) => args.length !== 1 || ("name" in args[0]), (target, options = {}) => asTool(target, {
+var transferTool = Function10.dual((args) => args.length !== 1 || ("name" in args[0]), (target, options = {}) => asTool(target, {
   name: options.nameOverride ?? transferName(target.name),
   description: options.description ?? `Transfer to ${target.name}`,
   ...options.parameters === undefined ? {} : { parameters: options.parameters },
@@ -3474,7 +4190,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 || globalThis.Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect27.flatMap((concurrency) => Effect27.forEach(children, (child) => {
+var fanOut = Function10.dual((args) => args.length !== 1 || globalThis.Array.isArray(args[0]), (children, options = {}) => positiveConcurrency(options.concurrency).pipe(Effect30.flatMap((concurrency) => Effect30.forEach(children, (child) => {
   const runOptions = {
     ...child.options,
     prompt: child.prompt
@@ -3503,7 +4219,7 @@ var supervisor = (options) => {
   };
 };
 
-// ../../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";
+// ../../node_modules/.bun/@batonfx+core@0.11.3+74997d64abff4185/node_modules/@batonfx/core/dist/index.js
+import { AiError as AiError10, Chat as Chat4, EmbeddingModel, IdGenerator as IdGenerator2, LanguageModel as LanguageModel12, Model as Model3, Prompt as Prompt16, Response as Response13, 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, Response11 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool13 as Tool, Toolkit8 as Toolkit };
+export { exports_model_telemetry, exports_turn_policy, exports_agent_event, exports_memory, exports_context_overflow, 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, AiError10 as AiError, Chat4 as Chat, EmbeddingModel, IdGenerator2 as IdGenerator, Model3 as Model, Prompt16 as Prompt, Response13 as Response, ResponseIdTracker, Telemetry2 as Telemetry, Tokenizer3 as Tokenizer, Tool13 as Tool, Toolkit8 as Toolkit };