@theokit/agents 7.3.1 → 7.4.1

package/dist/{chunk-7ECCHM4N.js → chunk-PHUNONZT.js}

@@ -1,30 +1,21 @@
-import {
-  __name
-} from "./chunk-Z4QWC7IK.js";
-
 // src/errors.ts
 import { ConfigurationError } from "@theokit/sdk/errors";
 
 // src/bridge/define-agent.ts
 var AGENT_BRAND = /* @__PURE__ */ Symbol.for("theokit.agent.definition");
 function defineAgent(config) {
-  return {
-    ...config,
-    [AGENT_BRAND]: true
-  };
+  return { ...config, [AGENT_BRAND]: true };
 }
-__name(defineAgent, "defineAgent");
 function isAgentDefinition(value) {
   return typeof value === "object" && value !== null && value[AGENT_BRAND] === true;
 }
-__name(isAgentDefinition, "isAgentDefinition");
 function toCompiledTool(tool) {
   const handler = tool.handler;
   const compiled = {
     name: tool.name,
     description: tool.description,
     inputSchema: tool.inputSchema,
-    handler: /* @__PURE__ */ __name((input, ctx) => handler(input, ctx), "handler")
+    handler: (input, ctx) => handler(input, ctx)
   };
   for (const sym of Object.getOwnPropertySymbols(tool)) {
     ;
@@ -32,7 +23,6 @@ function toCompiledTool(tool) {
   }
   return compiled;
 }
-__name(toCompiledTool, "toCompiledTool");
 function compileAgentDefinition(def) {
   return {
     model: def.model,
@@ -43,48 +33,33 @@ function compileAgentDefinition(def) {
     stream: true,
     // M7 — run-context flows to CompiledAgentOptions.runContext (distinct from the
     // context-window `context` field the decorator path uses); absent ⇒ no key.
-    ...def.context !== void 0 ? {
-      runContext: def.context
-    } : {},
+    ...def.context !== void 0 ? { runContext: def.context } : {},
     // M9 — guardrails flow through unchanged; the runner applies them at the input boundary.
-    ...def.guardrails !== void 0 ? {
-      guardrails: def.guardrails
-    } : {},
+    ...def.guardrails !== void 0 ? { guardrails: def.guardrails } : {},
     // M14 — HITL approvals compile into the same `hitl` map the decorator path produces.
-    ...def.approvals !== void 0 ? {
-      hitl: compileApprovals(def)
-    } : {},
+    ...def.approvals !== void 0 ? { hitl: compileApprovals(def) } : {},
     // M13 — skills: a static list → SDK skills.enabled; a resolver → carried for the request path.
     ...compileSkillsSelection(def.skills),
     // theokit-file-based-config — the declared `.theokit/` sources flow to the run path, which
     // projects them into `Agent.create({ local.settingSources })`; absent ⇒ inline config only.
-    ...def.settingSources !== void 0 ? {
-      settingSources: def.settingSources
-    } : {},
+    ...def.settingSources !== void 0 ? { settingSources: def.settingSources } : {},
     // M49 — memory flows to the projection layer; `assembleM8CreateOptions` forwards it to Agent.create.
-    ...def.memory !== void 0 ? {
-      memory: def.memory
-    } : {},
+    ...def.memory !== void 0 ? { memory: def.memory } : {},
     // Hooks are converted here — the layer EVERY path converges on — rather than on the builder, so
     // `defineAgent({ hooks })` cannot type-check and silently no-op. A lifecycle hook that is
     // declared but never registered is a security gate that does not gate.
     ...compileHooksAndPlugins(def),
     // MCP — builder/`defineAgent` servers converge on the same `mcpServers` field the `@MCP`
     // decorator path populates; the SDK adapter forwards it to `Agent.create({ mcpServers })`.
-    ...def.mcpServers !== void 0 ? {
-      mcpServers: def.mcpServers
-    } : {}
+    ...def.mcpServers !== void 0 ? { mcpServers: def.mcpServers } : {}
   };
 }
-__name(compileAgentDefinition, "compileAgentDefinition");
 function compileHooksAndPlugins(def) {
   const map = def.hooks;
   const entries = Object.entries(map ?? {}).filter(([, h]) => typeof h === "function");
   const explicit = def.plugins ?? [];
   if (entries.length === 0) {
-    return def.plugins !== void 0 ? {
-      plugins: def.plugins
-    } : {};
+    return def.plugins !== void 0 ? { plugins: def.plugins } : {};
   }
   const plugin = {
     name: "theokit-builder-hooks",
@@ -96,19 +71,11 @@ function compileHooksAndPlugins(def) {
       }
     }
   };
-  return {
-    plugins: [
-      ...explicit,
-      plugin
-    ]
-  };
+  return { plugins: [...explicit, plugin] };
 }
-__name(compileHooksAndPlugins, "compileHooksAndPlugins");
 function compileSkillsSelection(skills) {
   if (skills === void 0) return {};
-  if (typeof skills === "function") return {
-    skillsResolver: skills
-  };
+  if (typeof skills === "function") return { skillsResolver: skills };
   const enabled = [];
   const inline = [];
   for (const entry of skills) {
@@ -116,30 +83,22 @@ function compileSkillsSelection(skills) {
     else inline.push(entry);
   }
   return {
-    skills: {
-      enabled,
-      autoInject: true,
-      ...inline.length > 0 ? {
-        inline
-      } : {}
-    }
+    skills: { enabled, autoInject: true, ...inline.length > 0 ? { inline } : {} }
   };
 }
-__name(compileSkillsSelection, "compileSkillsSelection");
 function compileApprovals(def) {
   const toolNames = new Set((def.tools ?? []).map((t) => t.name));
   const gates = /* @__PURE__ */ new Map();
   for (const [toolName, options] of Object.entries(def.approvals ?? {})) {
     if (!toolNames.has(toolName)) {
-      throw new Error(`[@theokit/agents] defineAgent approval references unknown tool "${toolName}". Declared tools: ${[
-        ...toolNames
-      ].join(", ") || "(none)"}.`);
+      throw new Error(
+        `[@theokit/agents] defineAgent approval references unknown tool "${toolName}". Declared tools: ${[...toolNames].join(", ") || "(none)"}.`
+      );
     }
     gates.set(toolName, options);
   }
   return gates;
 }
-__name(compileApprovals, "compileApprovals");
 
 // src/bridge/compile-context-window.ts
 var STRATEGY_KNOBS = [
@@ -155,26 +114,16 @@ function compileContextWindow(options) {
   }
   const opts = options;
   const metadataOnlyKnobs = STRATEGY_KNOBS.filter((knob) => opts[knob] !== void 0);
-  return {
-    context,
-    metadataOnlyKnobs
-  };
+  return { context, metadataOnlyKnobs };
 }
-__name(compileContextWindow, "compileContextWindow");
 
 // src/bridge/compile-skills.ts
 function compileSkills(options) {
   if (options.autoDiscover) {
-    return {
-      autoInject: true
-    };
+    return { autoInject: true };
   }
-  return {
-    enabled: options.include,
-    autoInject: true
-  };
+  return { enabled: options.include, autoInject: true };
 }
-__name(compileSkills, "compileSkills");
 
 // src/bridge/agent-compiler.ts
 var SDK_TOOL_NAME = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
@@ -188,24 +137,27 @@ var SDK_RESERVED_TOOL_NAMES = /* @__PURE__ */ new Set([
 var SDK_RESERVED_TOOL_PREFIX = "mcp_";
 function toolRuntimeName(namespace, toolName) {
   if (toolName.trim().length === 0) {
-    const where = namespace ? ` no namespace "${namespace}"` : "";
-    throw new ConfigurationError(`tool: nome vazio${where} \u2014 declare um nome n\xE3o vazio para a tool`);
+    const where = namespace ? ` in namespace "${namespace}"` : "";
+    throw new ConfigurationError(`tool: empty name${where} \u2014 declare a non-empty name for the tool`);
   }
   const name = namespace ? `${namespace}_${toolName}` : toolName;
   if (!SDK_TOOL_NAME.test(name)) {
     if (SDK_TOOL_NAME_CHARSET.test(name)) {
-      throw new ConfigurationError(`tool: nome "${name}" tem comprimento ${name.length} \u2014 a composi\xE7\xE3o namespace + "_" + tool excede o m\xE1ximo de ${SDK_TOOL_NAME_MAX_LENGTH} que o SDK aceita`);
+      throw new ConfigurationError(
+        `tool: name "${name}" has length ${name.length} \u2014 the composition namespace + "_" + tool exceeds the maximum of ${SDK_TOOL_NAME_MAX_LENGTH} the SDK accepts`
+      );
     }
-    throw new ConfigurationError(`tool: nome inv\xE1lido "${name}" \u2014 deve casar ${String(SDK_TOOL_NAME)} (o SDK rejeita o resto; verifique o namespace e o nome da tool)`);
+    throw new ConfigurationError(
+      `tool: invalid name "${name}" \u2014 it must match ${String(SDK_TOOL_NAME)} (the SDK rejects the rest; check the namespace and the tool name)`
+    );
   }
   if (SDK_RESERVED_TOOL_NAMES.has(name) || name.startsWith(SDK_RESERVED_TOOL_PREFIX)) {
-    throw new ConfigurationError(`tool: nome reservado "${name}" \u2014 o SDK reserva ${[
-      ...SDK_RESERVED_TOOL_NAMES
-    ].join(", ")} e o prefixo "${SDK_RESERVED_TOOL_PREFIX}"`);
+    throw new ConfigurationError(
+      `tool: reserved name "${name}" \u2014 the SDK reserves ${[...SDK_RESERVED_TOOL_NAMES].join(", ")} and the prefix "${SDK_RESERVED_TOOL_PREFIX}"`
+    );
   }
   return name;
 }
-__name(toolRuntimeName, "toolRuntimeName");
 function compileHitlGates(toolboxes) {
   const gates = /* @__PURE__ */ new Map();
   for (const tb of toolboxes) {
@@ -217,50 +169,50 @@ function compileHitlGates(toolboxes) {
   }
   return gates;
 }
-__name(compileHitlGates, "compileHitlGates");
 function compileTools(toolboxes, toolboxInstances) {
   const tools = [];
   for (const tb of toolboxes) {
     const instance = toolboxInstances.get(tb.class);
     if (!instance) {
-      throw new ConfigurationError(`toolbox: ${tb.class.name} n\xE3o foi instanciado \u2014 passe a inst\xE2ncia em \`toolboxInstances\``);
+      throw new ConfigurationError(
+        `toolbox: ${tb.class.name} was not instantiated \u2014 pass the instance in \`toolboxInstances\``
+      );
     }
     for (const tool of tb.tools) {
       const handler = instance[tool.propertyKey];
       if (typeof handler !== "function") {
-        throw new ConfigurationError(`toolbox: ${tb.class.name}.${String(tool.propertyKey)} n\xE3o \xE9 um m\xE9todo (tool "${tool.config.name}")`);
+        throw new ConfigurationError(
+          `toolbox: ${tb.class.name}.${String(tool.propertyKey)} is not a method (tool "${tool.config.name}")`
+        );
       }
       const name = toolRuntimeName(tb.namespace, tool.config.name);
       tools.push({
         name,
         description: tool.config.description,
         inputSchema: tool.config.input,
-        handler: /* @__PURE__ */ __name((input) => handler.call(instance, input), "handler")
+        handler: (input) => handler.call(instance, input)
       });
     }
   }
   return tools;
 }
-__name(compileTools, "compileTools");
 
 // src/bridge/agent-execution-context.ts
 function createAgentExecutionContext(base, agent, run, toolCall) {
   return {
-    getRequest: /* @__PURE__ */ __name(() => base.getRequest(), "getRequest"),
-    getUrl: /* @__PURE__ */ __name(() => base.getUrl(), "getUrl"),
-    getClass: /* @__PURE__ */ __name(() => base.getClass(), "getClass"),
-    getMethodName: /* @__PURE__ */ __name(() => base.getMethodName(), "getMethodName"),
-    getAgent: /* @__PURE__ */ __name(() => agent, "getAgent"),
-    getRun: /* @__PURE__ */ __name(() => run, "getRun"),
-    getToolCall: /* @__PURE__ */ __name(() => toolCall ?? null, "getToolCall"),
-    isAgentContext: /* @__PURE__ */ __name(() => true, "isAgentContext")
+    getRequest: () => base.getRequest(),
+    getUrl: () => base.getUrl(),
+    getClass: () => base.getClass(),
+    getMethodName: () => base.getMethodName(),
+    getAgent: () => agent,
+    getRun: () => run,
+    getToolCall: () => toolCall ?? null,
+    isAgentContext: () => true
   };
 }
-__name(createAgentExecutionContext, "createAgentExecutionContext");
 function isAgentContext(ctx) {
   return "isAgentContext" in ctx && ctx.isAgentContext();
 }
-__name(isAgentContext, "isAgentContext");
 
 // src/bridge/compile-project-context.ts
 var UNMAPPED_KNOBS = [
@@ -274,7 +226,6 @@ function projectContextMetadataOnlyKnobs(options) {
   const opts = options;
   return UNMAPPED_KNOBS.filter((knob) => opts[knob] !== void 0);
 }
-__name(projectContextMetadataOnlyKnobs, "projectContextMetadataOnlyKnobs");
 function compileProjectContext(options, base) {
   return async (promptCtx) => {
     const resolvedBase = typeof base === "function" ? await base(promptCtx) : base;
@@ -285,24 +236,16 @@ function compileProjectContext(options, base) {
     const { buildEnvContext, buildRepoMap } = await import("@theokit/sdk-tools");
     const { readProjectInstructions } = await import("@theokit/sdk/project");
     const env = buildEnvContext(cwd);
-    const repoMap = buildRepoMap(cwd, {
-      ignore: options.ignorePatterns
-    });
+    const repoMap = buildRepoMap(cwd, { ignore: options.ignorePatterns });
     let instructions = "";
     try {
       instructions = (await readProjectInstructions(cwd)).content ?? "";
     } catch {
       instructions = "";
     }
-    return [
-      env,
-      repoMap,
-      instructions,
-      resolvedBase
-    ].filter(Boolean).join("\n\n");
+    return [env, repoMap, instructions, resolvedBase].filter(Boolean).join("\n\n");
   };
 }
-__name(compileProjectContext, "compileProjectContext");
 
 // src/bridge/agent-sse-handler.ts
 var encoder = new TextEncoder();
@@ -310,14 +253,14 @@ function streamAgentResponse(eventStream) {
   const stream = new ReadableStream({
     async start(controller) {
       let closed = false;
-      const safeEnqueue = /* @__PURE__ */ __name((chunk) => {
+      const safeEnqueue = (chunk) => {
         if (closed) return;
         try {
           controller.enqueue(chunk);
         } catch {
           closed = true;
         }
-      }, "safeEnqueue");
+      };
       try {
         for await (const event of eventStream) {
           if (closed) break;
@@ -332,9 +275,7 @@ data: ${data}
         if (!closed) {
           const errorEvent = {
             type: "error",
-            error: {
-              message: err instanceof Error ? err.message : "Internal agent error"
-            }
+            error: { message: err instanceof Error ? err.message : "Internal agent error" }
           };
           const frame = `event: error
 data: ${JSON.stringify(errorEvent)}
@@ -356,37 +297,29 @@ data: ${JSON.stringify(errorEvent)}
     }
   });
 }
-__name(streamAgentResponse, "streamAgentResponse");
 
 // src/bridge/agent-stream-events.ts
 function isTextDelta(e) {
   return e.type === "text_delta";
 }
-__name(isTextDelta, "isTextDelta");
 function isToolCall(e) {
   return e.type === "tool_call";
 }
-__name(isToolCall, "isToolCall");
 function isPartialToolCall(e) {
   return e.type === "partial_tool_call";
 }
-__name(isPartialToolCall, "isPartialToolCall");
 function isToolResult(e) {
   return e.type === "tool_result";
 }
-__name(isToolResult, "isToolResult");
 function isDone(e) {
   return e.type === "done";
 }
-__name(isDone, "isDone");
 function isError(e) {
   return e.type === "error";
 }
-__name(isError, "isError");
 function isApprovalRequired(e) {
   return e.type === "approval_required";
 }
-__name(isApprovalRequired, "isApprovalRequired");
 
 // src/bridge/agent-route-generator.ts
 function generateAgentRoutes(ctx) {
@@ -396,7 +329,7 @@ function generateAgentRoutes(ctx) {
   routes.push({
     method: "POST",
     path: `${basePath}/chat`,
-    handler: /* @__PURE__ */ __name(async (request) => {
+    handler: async (request) => {
       let body = null;
       try {
         body = await request.json();
@@ -404,92 +337,75 @@ function generateAgentRoutes(ctx) {
       }
       const message = body?.message;
       if (typeof message !== "string" || message.length === 0) {
-        return new Response(JSON.stringify({
-          error: {
-            code: "BAD_REQUEST",
-            message: "message field required"
-          }
-        }), {
-          status: 400,
-          headers: {
-            "content-type": "application/json"
-          }
-        });
+        return new Response(
+          JSON.stringify({ error: { code: "BAD_REQUEST", message: "message field required" } }),
+          { status: 400, headers: { "content-type": "application/json" } }
+        );
       }
       const rawSessionId = body?.sessionId;
       const sessionId = typeof rawSessionId === "string" ? rawSessionId : `session-${Date.now()}`;
       return streamAgentResponse(createRun(message, sessionId));
-    }, "handler")
+    }
   });
   if (getRun) {
     routes.push({
       method: "GET",
       path: `${basePath}/runs/:runId`,
-      handler: /* @__PURE__ */ __name(async (request) => {
+      handler: async (request) => {
         const url = new URL(request.url);
         const runId = url.pathname.split("/").pop() ?? "";
         const run = await getRun(runId);
         if (!run) {
-          return new Response(JSON.stringify({
-            error: {
-              code: "NOT_FOUND",
-              message: `Run ${runId} not found`
-            }
-          }), {
-            status: 404,
-            headers: {
-              "content-type": "application/json"
-            }
-          });
+          return new Response(
+            JSON.stringify({ error: { code: "NOT_FOUND", message: `Run ${runId} not found` } }),
+            { status: 404, headers: { "content-type": "application/json" } }
+          );
         }
         return new Response(JSON.stringify(run), {
           status: 200,
-          headers: {
-            "content-type": "application/json"
-          }
+          headers: { "content-type": "application/json" }
         });
-      }, "handler")
+      }
     });
   }
   return routes;
 }
-__name(generateAgentRoutes, "generateAgentRoutes");
 
 // src/guardrails/types.ts
 var GuardrailViolationError = class extends Error {
-  static {
-    __name(this, "GuardrailViolationError");
+  constructor(guardName, phase, reason) {
+    super(`Guardrail "${guardName}" blocked ${phase}: ${reason}`);
+    this.guardName = guardName;
+    this.phase = phase;
+    this.reason = reason;
+    this.name = "GuardrailViolationError";
   }
   guardName;
   phase;
   reason;
-  constructor(guardName, phase, reason) {
-    super(`Guardrail "${guardName}" blocked ${phase}: ${reason}`), this.guardName = guardName, this.phase = phase, this.reason = reason;
-    this.name = "GuardrailViolationError";
-  }
 };
 var CostBudgetExceededError = class extends Error {
-  static {
-    __name(this, "CostBudgetExceededError");
-  }
-  usedTokens;
-  maxTokens;
   constructor(usedTokens, maxTokens) {
-    super(`Cost budget exceeded: ${usedTokens} > ${maxTokens} tokens`), this.usedTokens = usedTokens, this.maxTokens = maxTokens;
+    super(`Cost budget exceeded: ${usedTokens} > ${maxTokens} tokens`);
+    this.usedTokens = usedTokens;
+    this.maxTokens = maxTokens;
     this.name = "CostBudgetExceededError";
   }
+  usedTokens;
+  maxTokens;
 };
 
 // src/guardrails/detectors.ts
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
-__name(estimateTokens, "estimateTokens");
 var INJECTION_PHRASES = [
   "previous instructions",
+  // "ignore/disregard [all|the] previous instructions"
   "disregard the above",
   "you are now dan",
   "system prompt",
+  // "reveal your/the system prompt"
   "no restrictions",
   "without restrictions",
   "no rules",
@@ -498,31 +414,21 @@ var INJECTION_PHRASES = [
 function normalizeForMatch(text) {
   return text.toLowerCase().replace(/\s+/g, " ");
 }
-__name(normalizeForMatch, "normalizeForMatch");
 function promptInjectionDetector(options = {}) {
-  const phrases = [
-    ...INJECTION_PHRASES,
-    ...(options.extra ?? []).map((p) => p.toLowerCase())
-  ];
+  const phrases = [...INJECTION_PHRASES, ...(options.extra ?? []).map((p) => p.toLowerCase())];
   return {
     name: "prompt-injection",
     checkInput(text) {
       const normalized = normalizeForMatch(text);
       for (const phrase of phrases) {
         if (normalized.includes(phrase)) {
-          return {
-            action: "block",
-            reason: `prompt injection phrase matched: "${phrase}"`
-          };
+          return { action: "block", reason: `prompt injection phrase matched: "${phrase}"` };
         }
       }
-      return {
-        action: "allow"
-      };
+      return { action: "allow" };
     }
   };
 }
-__name(promptInjectionDetector, "promptInjectionDetector");
 var CPF = /\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b/g;
 var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var PHONE = /\+?\d[\d\s()-]{7,13}\d/g;
@@ -535,36 +441,22 @@ function piiDetector(options = {}) {
       redacted = redacted.replace(EMAIL, placeholder);
       redacted = redacted.replace(CPF, placeholder);
       redacted = redacted.replace(PHONE, placeholder);
-      if (redacted === text) return {
-        action: "allow"
-      };
-      return {
-        action: "redact",
-        text: redacted,
-        reason: "PII detected and redacted"
-      };
+      if (redacted === text) return { action: "allow" };
+      return { action: "redact", text: redacted, reason: "PII detected and redacted" };
     }
   };
 }
-__name(piiDetector, "piiDetector");
 var OBFUSCATION_CHARS = /[\u200B-\u200D\uFEFF\u202A-\u202E\u2066-\u2069]/g;
 function unicodeNormalizer() {
   return {
     name: "unicode-normalizer",
     checkInput(text) {
       const cleaned = text.normalize("NFKC").replace(OBFUSCATION_CHARS, "");
-      if (cleaned === text) return {
-        action: "allow"
-      };
-      return {
-        action: "redact",
-        text: cleaned,
-        reason: "obfuscation characters normalized"
-      };
+      if (cleaned === text) return { action: "allow" };
+      return { action: "redact", text: cleaned, reason: "obfuscation characters normalized" };
     }
   };
 }
-__name(unicodeNormalizer, "unicodeNormalizer");
 function costGuard(options) {
   let used = 0;
   return {
@@ -576,28 +468,19 @@ function costGuard(options) {
       if (used > options.maxTokens) {
         return Promise.reject(new CostBudgetExceededError(used, options.maxTokens));
       }
-      return Promise.resolve({
-        action: "allow"
-      });
+      return Promise.resolve({ action: "allow" });
     }
   };
 }
-__name(costGuard, "costGuard");
 function outputModeration(options) {
   return {
     name: "output-moderation",
     async checkOutput(text) {
       const flagged = await options.moderate(text);
-      return flagged ? {
-        action: "block",
-        reason: "output flagged by moderation predicate"
-      } : {
-        action: "allow"
-      };
+      return flagged ? { action: "block", reason: "output flagged by moderation predicate" } : { action: "allow" };
     }
   };
 }
-__name(outputModeration, "outputModeration");
 
 // src/guardrails/pipeline.ts
 async function runInputGuards(text, guards) {
@@ -612,7 +495,6 @@ async function runInputGuards(text, guards) {
   }
   return current;
 }
-__name(runInputGuards, "runInputGuards");
 async function runOutputGuards(text, guards) {
   let current = text;
   for (const g of guards) {
@@ -625,7 +507,6 @@ async function runOutputGuards(text, guards) {
   }
   return current;
 }
-__name(runOutputGuards, "runOutputGuards");
 
 // src/guardrails/stream.ts
 async function* moderateOutputStream(inner, guards, extractText) {
@@ -645,7 +526,6 @@ async function* moderateOutputStream(inner, guards, extractText) {
   for (const event of buffered) yield event;
   return step.value;
 }
-__name(moderateOutputStream, "moderateOutputStream");
 
 // src/bridge/tool-hooks-plugin.ts
 function createToolHooksPlugin(hooks) {
@@ -658,30 +538,22 @@ function createToolHooksPlugin(hooks) {
     register(ctx) {
       const { beforeToolCall, afterToolCall, beforeLLMCall, afterLLMCall, processInput } = hooks;
       if (beforeToolCall) {
-        ctx.on("pre_tool_call", (c) => beforeToolCall({
-          name: c.name ?? "",
-          args: c.args ?? {}
-        }));
+        ctx.on("pre_tool_call", (c) => beforeToolCall({ name: c.name ?? "", args: c.args ?? {} }));
       }
       if (afterToolCall) {
-        ctx.on("post_tool_call", (c) => afterToolCall({
-          name: c.name ?? "",
-          result: c.result
-        }));
+        ctx.on("post_tool_call", (c) => afterToolCall({ name: c.name ?? "", result: c.result }));
       }
       if (beforeLLMCall) {
-        ctx.on("pre_llm_call", (c) => beforeLLMCall({
-          agentId: c.agentId,
-          runId: c.runId,
-          iteration: c.iteration
-        }));
+        ctx.on(
+          "pre_llm_call",
+          (c) => beforeLLMCall({ agentId: c.agentId, runId: c.runId, iteration: c.iteration })
+        );
       }
       if (afterLLMCall) {
-        ctx.on("post_llm_call", (c) => afterLLMCall({
-          agentId: c.agentId,
-          runId: c.runId,
-          iteration: c.iteration
-        }));
+        ctx.on(
+          "post_llm_call",
+          (c) => afterLLMCall({ agentId: c.agentId, runId: c.runId, iteration: c.iteration })
+        );
       }
       if (processInput) {
         ctx.on("pre_user_send", async (c) => {
@@ -690,49 +562,30 @@ function createToolHooksPlugin(hooks) {
             agentId: c.agentId,
             runId: c.runId
           });
-          return injected !== void 0 && injected.length > 0 ? {
-            recalledContext: injected
-          } : void 0;
+          return injected !== void 0 && injected.length > 0 ? { recalledContext: injected } : void 0;
         });
       }
     }
   };
 }
-__name(createToolHooksPlugin, "createToolHooksPlugin");
 
 // src/bridge/model-selection.ts
 var PARAM_THINKING = "thinking";
 function buildModelSelection(model, effort) {
-  const base = typeof model === "string" ? {
-    id: model
-  } : {
-    ...model
-  };
+  const base = typeof model === "string" ? { id: model } : { ...model };
   if (!effort) return base;
-  return {
-    ...base,
-    params: [
-      ...base.params ?? [],
-      {
-        id: PARAM_THINKING,
-        value: effort
-      }
-    ]
-  };
+  return { ...base, params: [...base.params ?? [], { id: PARAM_THINKING, value: effort }] };
 }
-__name(buildModelSelection, "buildModelSelection");
 function reasoningEffortOf(model) {
   const params = typeof model === "string" ? void 0 : model.params;
   return params?.find((p) => p.id === PARAM_THINKING)?.value;
 }
-__name(reasoningEffortOf, "reasoningEffortOf");
 
 // src/bridge/event-translator.ts
 function asString(value, fallback) {
   if (typeof value === "string") return value;
   return fallback;
 }
-__name(asString, "asString");
 function serializeToolOutput(value, fallback) {
   if (typeof value === "string") return value;
   if (value === void 0 || value === null) return fallback;
@@ -742,7 +595,6 @@ function serializeToolOutput(value, fallback) {
     return typeof value === "bigint" ? value.toString() : fallback;
   }
 }
-__name(serializeToolOutput, "serializeToolOutput");
 function translateSystemEvent(msg, runId) {
   return [
     {
@@ -753,7 +605,6 @@ function translateSystemEvent(msg, runId) {
     }
   ];
 }
-__name(translateSystemEvent, "translateSystemEvent");
 function translateAssistantEvent(msg) {
   const events = [];
   const message = msg.message;
@@ -762,18 +613,15 @@ function translateAssistantEvent(msg) {
   for (const block of content) {
     const b = block;
     if (b.type === "text" && b.text) {
-      events.push({
-        type: "text_delta",
-        content: b.text
-      });
+      events.push({ type: "text_delta", content: b.text });
     }
     if (b.type === "tool_use") {
       events.push({
         type: "tool_call",
-        // #138 — era `tc-${Date.now()}`. Um id novo a cada chamada NUNCA está no conjunto de
-        // dedup, então o fallback derrotava a dedup por construção — e ainda parecia um id de
-        // verdade para quem lê. String vazia é honesta: `isDuplicatedByDelta` a trata como
-        // "não sei identificar" e prefere um duplo-render visível a uma supressão silenciosa.
+        // #138 — this was `tc-${Date.now()}`. A fresh id on every call is NEVER in the dedup set, so
+        // the fallback defeated dedup by construction — and still looked like a real id to a reader.
+        // An empty string is honest: `isDuplicatedByDelta` treats it as "I cannot identify this" and
+        // prefers a visible double render to a silent suppression.
         callId: b.id ?? "",
         toolName: b.name ?? "unknown",
         input: b.input ?? {}
@@ -782,7 +630,6 @@ function translateAssistantEvent(msg) {
   }
   return events;
 }
-__name(translateAssistantEvent, "translateAssistantEvent");
 function translateToolCallEvent(msg) {
   const status = msg.status;
   const callId = asString(msg.call_id, "");
@@ -813,17 +660,11 @@ function translateToolCallEvent(msg) {
   }
   if (status === "running") {
     return [
-      {
-        type: "tool_call",
-        callId,
-        toolName,
-        input: msg.args ?? msg.input ?? msg.arguments ?? {}
-      }
+      { type: "tool_call", callId, toolName, input: msg.args ?? msg.input ?? msg.arguments ?? {} }
     ];
   }
   return [];
 }
-__name(translateToolCallEvent, "translateToolCallEvent");
 function translateStatusEvent(msg) {
   const s = msg.status;
   if (s === "FINISHED" || s === "CANCELLED") {
@@ -831,11 +672,7 @@ function translateStatusEvent(msg) {
       {
         type: "done",
         result: "",
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0
-        },
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
         durationMs: 0,
         cost: 0
       }
@@ -853,18 +690,16 @@ function translateStatusEvent(msg) {
   }
   return [];
 }
-__name(translateStatusEvent, "translateStatusEvent");
-var jaAvisados = /* @__PURE__ */ new Set();
-function avisarSeDesconhecido(tipo, ignoradosDeProposito) {
-  if (ignoradosDeProposito.has(tipo) || jaAvisados.has(tipo)) return;
-  jaAvisados.add(tipo);
-  console.warn(`[theokit] agents.bridge: evento "${tipo}" do SDK n\xE3o \xE9 traduzido e foi descartado. Se ele carrega informa\xE7\xE3o que a UI precisa, o tradutor precisa de um caso para ele (#141).`);
+var alreadyWarned = /* @__PURE__ */ new Set();
+function warnIfUnknown(type, deliberatelyIgnored) {
+  if (deliberatelyIgnored.has(type) || alreadyWarned.has(type)) return;
+  alreadyWarned.add(type);
+  console.warn(
+    `[theokit] agents.bridge: SDK event "${type}" is not translated and was discarded. If it carries information the UI needs, the translator needs a case for it (#141).`
+  );
 }
-__name(avisarSeDesconhecido, "avisarSeDesconhecido");
-var SDK_MESSAGE_IGNORADOS = /* @__PURE__ */ new Set([
-  "user"
-]);
-var INTERACTION_UPDATE_IGNORADOS = /* @__PURE__ */ new Set([
+var SDK_MESSAGE_IGNORED = /* @__PURE__ */ new Set(["user"]);
+var INTERACTION_UPDATE_IGNORED = /* @__PURE__ */ new Set([
   "thinking-completed",
   "token-delta",
   "step-started",
@@ -879,21 +714,11 @@ function translateSdkEvent(msg, runId) {
     case "tool_call":
       return translateToolCallEvent(msg);
     case "thinking":
-      return [
-        {
-          type: "thinking",
-          content: asString(msg.text, "")
-        }
-      ];
+      return [{ type: "thinking", content: asString(msg.text, "") }];
     case "status":
       return translateStatusEvent(msg);
     case "request":
-      return [
-        {
-          type: "input_requested",
-          requestId: asString(msg.request_id, "")
-        }
-      ];
+      return [{ type: "input_requested", requestId: asString(msg.request_id, "") }];
     case "task": {
       const status = typeof msg.status === "string" ? msg.status : void 0;
       const text = typeof msg.text === "string" ? msg.text : void 0;
@@ -901,37 +726,22 @@ function translateSdkEvent(msg, runId) {
       return [
         {
           type: "task_progress",
-          ...status !== void 0 ? {
-            status
-          } : {},
-          ...text !== void 0 ? {
-            text
-          } : {}
+          ...status !== void 0 ? { status } : {},
+          ...text !== void 0 ? { text } : {}
         }
       ];
     }
     default:
-      avisarSeDesconhecido(msg.type, SDK_MESSAGE_IGNORADOS);
+      warnIfUnknown(msg.type, SDK_MESSAGE_IGNORED);
       return [];
   }
 }
-__name(translateSdkEvent, "translateSdkEvent");
 function translateInteractionUpdate(update) {
   switch (update.type) {
     case "text-delta":
-      return update.text ? [
-        {
-          type: "text_delta",
-          content: update.text
-        }
-      ] : [];
+      return update.text ? [{ type: "text_delta", content: update.text }] : [];
     case "thinking-delta":
-      return update.text ? [
-        {
-          type: "thinking",
-          content: update.text
-        }
-      ] : [];
+      return update.text ? [{ type: "thinking", content: update.text }] : [];
     case "tool-call-started":
       return [
         {
@@ -962,18 +772,12 @@ function translateInteractionUpdate(update) {
         }
       ];
     case "shell-output-delta":
-      return [
-        {
-          type: "shell_output",
-          event: update.event
-        }
-      ];
+      return [{ type: "shell_output", event: update.event }];
     default:
-      avisarSeDesconhecido(update.type, INTERACTION_UPDATE_IGNORADOS);
+      warnIfUnknown(update.type, INTERACTION_UPDATE_IGNORED);
       return [];
   }
 }
-__name(translateInteractionUpdate, "translateInteractionUpdate");
 
 // src/bridge/think-tag-extractor.ts
 var TAG = "think";
@@ -986,11 +790,10 @@ function heldPrefixLength(s, delim) {
   }
   return 0;
 }
-__name(heldPrefixLength, "heldPrefixLength");
 function createThinkTagExtractor() {
   let mode = "text";
   let buffer = "";
-  const write = /* @__PURE__ */ __name((chunk) => {
+  const write = (chunk) => {
     buffer += chunk;
     const out = [];
     for (; ; ) {
@@ -998,52 +801,30 @@ function createThinkTagExtractor() {
       const idx = buffer.indexOf(delim);
       if (idx !== -1) {
         const content = buffer.slice(0, idx);
-        if (content) out.push({
-          kind: mode,
-          content
-        });
+        if (content) out.push({ kind: mode, content });
         buffer = buffer.slice(idx + delim.length);
         mode = mode === "text" ? "thinking" : "text";
         continue;
       }
       const keep = heldPrefixLength(buffer, delim);
       const emit = buffer.slice(0, buffer.length - keep);
-      if (emit) out.push({
-        kind: mode,
-        content: emit
-      });
+      if (emit) out.push({ kind: mode, content: emit });
       buffer = buffer.slice(buffer.length - keep);
       break;
     }
     return out;
-  }, "write");
-  const end = /* @__PURE__ */ __name(() => {
+  };
+  const end = () => {
     if (!buffer) return [];
-    const seg = {
-      kind: mode,
-      content: buffer
-    };
+    const seg = { kind: mode, content: buffer };
     buffer = "";
-    return [
-      seg
-    ];
-  }, "end");
-  return {
-    write,
-    end
+    return [seg];
   };
+  return { write, end };
 }
-__name(createThinkTagExtractor, "createThinkTagExtractor");
 function segmentToEvent(seg) {
-  return seg.kind === "thinking" ? {
-    type: "thinking",
-    content: seg.content
-  } : {
-    type: "text_delta",
-    content: seg.content
-  };
+  return seg.kind === "thinking" ? { type: "thinking", content: seg.content } : { type: "text_delta", content: seg.content };
 }
-__name(segmentToEvent, "segmentToEvent");
 async function* extractThinkTagStream(source) {
   const extractor = createThinkTagExtractor();
   try {
@@ -1058,7 +839,6 @@ async function* extractThinkTagStream(source) {
     for (const seg of extractor.end()) yield segmentToEvent(seg);
   }
 }
-__name(extractThinkTagStream, "extractThinkTagStream");
 
 // src/debug-log.ts
 function debugLog(marker, data) {
@@ -1067,7 +847,6 @@ function debugLog(marker, data) {
     console.debug(marker, data);
   }
 }
-__name(debugLog, "debugLog");
 
 // src/bridge/hitl-plugin.ts
 function createHitlPlugin(wiring) {
@@ -1091,96 +870,84 @@ function createHitlPlugin(wiring) {
           callbackUrl: `approve/${approvalId}`,
           timeoutMs: opts.timeout ?? 3e5,
           // M20 — carry the declared custom-payload schema so the UI knows what to collect.
-          ...opts.payloadSchema !== void 0 ? {
-            payloadSchema: opts.payloadSchema
-          } : {}
+          ...opts.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
         });
         const raw = await wiring.awaitApproval(approvalId, opts, c.name);
-        const decision = typeof raw === "boolean" ? {
-          approved: raw
-        } : raw;
+        const decision = typeof raw === "boolean" ? { approved: raw } : raw;
         if (decision.approved) return void 0;
         let message = `Tool '${c.name}' denied by human approver`;
         if (decision.reason) message += `: ${decision.reason}`;
         if (decision.payload !== void 0) {
           message += ` (payload: ${JSON.stringify(decision.payload)})`;
         }
-        return {
-          block: true,
-          message
-        };
+        return { block: true, message };
       });
     }
   };
 }
-__name(createHitlPlugin, "createHitlPlugin");
 
 // src/bridge/approval-posture.ts
-function razaoDe(postura) {
-  return postura.kind === "interactive" ? "human approver on this surface" : postura.reason;
-}
-__name(razaoDe, "razaoDe");
-function aplicarPostura(extra, m8, postura, gated) {
-  const daPostura = pluginsDaPostura(postura, gated);
-  if (daPostura.length === 0) return;
-  const atuais = extra.plugins ?? m8.plugins;
-  if (atuais !== void 0 && !Array.isArray(atuais)) {
-    throw new Error(`[@theokit/agents] approval posture "${postura.kind}" needs to install a plugin, but \`plugins\` was supplied in the legacy object form, which cannot carry both. Pass \`plugins\` as an array so the approval gate is not dropped.`);
-  }
-  extra.plugins = [
-    ...atuais ?? [],
-    ...daPostura
-  ];
+function reasonOf(posturePolicy) {
+  return posturePolicy.kind === "interactive" ? "human approver on this surface" : posturePolicy.reason;
+}
+function applyPosture(extra, m8, posturePolicy, gated) {
+  const ofThePosture = posturePlugins(posturePolicy, gated);
+  if (ofThePosture.length === 0) return;
+  const currentOnes = extra.plugins ?? m8.plugins;
+  if (currentOnes !== void 0 && !Array.isArray(currentOnes)) {
+    throw new Error(
+      `[@theokit/agents] approval posture "${posturePolicy.kind}" needs to install a plugin, but \`plugins\` was supplied in the legacy object form, which cannot carry both. Pass \`plugins\` as an array so the approval gate is not dropped.`
+    );
+  }
+  extra.plugins = [...currentOnes ?? [], ...ofThePosture];
 }
-__name(aplicarPostura, "aplicarPostura");
-function pluginsDaPostura(postura, gated) {
+function posturePlugins(posturePolicy, gated) {
   debugLog("[theokit] approval posture", {
-    kind: postura.kind,
-    reason: razaoDe(postura)
+    kind: posturePolicy.kind,
+    reason: reasonOf(posturePolicy)
   });
   if (gated === void 0 || gated.size === 0) return [];
-  switch (postura.kind) {
+  switch (posturePolicy.kind) {
     case "interactive":
       return [
         createHitlPlugin({
           gated,
-          emit: postura.emit,
-          awaitApproval: postura.awaitApproval
+          emit: posturePolicy.emit,
+          awaitApproval: posturePolicy.awaitApproval
         })
       ];
     case "auto-approve":
       return [
         createToolHooksPlugin({
-          beforeToolCall: /* @__PURE__ */ __name((ctx) => {
+          beforeToolCall: (ctx) => {
             if (gated.has(ctx.name)) {
               debugLog("[theokit] gated tool auto-approved", {
                 tool: ctx.name,
-                reason: postura.reason
+                reason: posturePolicy.reason
               });
             }
             return void 0;
-          }, "beforeToolCall")
+          }
         })
       ];
     case "auto-reject":
       return [
         createToolHooksPlugin({
-          // Só as tools GATEADAS são recusadas: a postura descreve o gate, não um bloqueio universal.
-          // Recusar tudo quebraria todo agente que tem uma tool livre ao lado de uma gateada.
-          beforeToolCall: /* @__PURE__ */ __name((ctx) => gated.has(ctx.name) ? {
+          // Only GATED tools are refused: the posture describes the gate, not a universal block.
+          // Refusing everything would break every agent with a free tool next to a gated one.
+          beforeToolCall: (ctx) => gated.has(ctx.name) ? {
             block: true,
-            message: `Tool '${ctx.name}' requires human approval, and this surface has no approver (approval posture: auto-reject \u2014 ${postura.reason}). Refused (fail-closed).`
-          } : void 0, "beforeToolCall")
+            message: `Tool '${ctx.name}' requires human approval, and this surface has no approver (approval posture: auto-reject \u2014 ${posturePolicy.reason}). Refused (fail-closed).`
+          } : void 0
         })
       ];
     case "owned-by-surface":
       return [];
   }
 }
-__name(pluginsDaPostura, "pluginsDaPostura");
 
-// src/bridge/definicao-ou-thunk.ts
-function projetar(def, overrides) {
+// src/bridge/definition-or-thunk.ts
+function project(def, overrides) {
   const compiled = compileAgentDefinition(def);
   return {
     compiled,
@@ -1189,29 +956,13 @@ function projetar(def, overrides) {
     runContext: overrides.runContext ?? compiled.runContext
   };
 }
-__name(projetar, "projetar");
-function resolverProjecao(def, overrides) {
+function resolveProjection(def, overrides) {
   if (typeof def === "function") {
-    return async (sessionId) => projetar(await def(sessionId), overrides);
+    return async (sessionId) => project(await def(sessionId), overrides);
   }
-  const eager = projetar(def, overrides);
+  const eager = project(def, overrides);
   return () => Promise.resolve(eager);
 }
-__name(resolverProjecao, "resolverProjecao");
-
-// src/bridge/erro-do-sdk.ts
-function eventoDeErroDoSdk(err) {
-  const sdkErr = err;
-  return {
-    type: "error",
-    code: sdkErr.code ?? "SDK_ERROR",
-    message: err instanceof Error ? err.message : "SDK agent error",
-    // O SDK computa `isRetryable` por classe de erro na construção; fixá-lo em `false` aqui
-    // contradizia o próprio erro.
-    retryable: sdkErr.isRetryable === true
-  };
-}
-__name(eventoDeErroDoSdk, "eventoDeErroDoSdk");
 
 // src/bridge/sdk-adapter-create-options.ts
 function assembleM8CreateOptions(compiled) {
@@ -1228,10 +979,7 @@ function assembleM8CreateOptions(compiled) {
   }
   const settingSources = resolveSettingSources(compiled);
   if (settingSources) {
-    options.local = {
-      ...options.local,
-      settingSources
-    };
+    options.local = { ...options.local, settingSources };
     applied.push("settingSources");
   }
   if (compiled.context) {
@@ -1254,32 +1002,23 @@ function assembleM8CreateOptions(compiled) {
     } else {
       const dropped = Object.keys(compiled.memory);
       if (dropped.length > 0) {
-        process.stderr.write(`[theokit-agents] @Memory decorator options not yet mapped to the SDK (${dropped.join(", ")}) \u2014 memory enabled with defaults
-`);
+        process.stderr.write(
+          `[theokit-agents] @Memory decorator options not yet mapped to the SDK (${dropped.join(", ")}) \u2014 memory enabled with defaults
+`
+        );
       }
-      options.memory = {
-        enabled: true
-      };
+      options.memory = { enabled: true };
     }
     applied.push("memory");
   }
-  return {
-    options,
-    applied
-  };
+  return { options, applied };
 }
-__name(assembleM8CreateOptions, "assembleM8CreateOptions");
 function resolveSettingSources(compiled) {
   const explicit = compiled.settingSources;
-  if (explicit && explicit.length > 0) return [
-    ...explicit
-  ];
-  if (compiled.skills) return [
-    "project"
-  ];
+  if (explicit && explicit.length > 0) return [...explicit];
+  if (compiled.skills) return ["project"];
   return void 0;
 }
-__name(resolveSettingSources, "resolveSettingSources");
 function realUsageDone(result, t0) {
   const u = result.usage;
   const inputTokens = u?.inputTokens ?? 0;
@@ -1301,7 +1040,19 @@ function realUsageDone(result, t0) {
     cost: result.cost?.amount ?? 0
   };
 }
-__name(realUsageDone, "realUsageDone");
+
+// src/bridge/sdk-error.ts
+function sdkErrorEvent(err) {
+  const sdkErr = err;
+  return {
+    type: "error",
+    code: sdkErr.code ?? "SDK_ERROR",
+    message: err instanceof Error ? err.message : "SDK agent error",
+    // The SDK computes `isRetryable` per error class at construction; pinning it to `false` here
+    // contradicted the error itself.
+    retryable: sdkErr.isRetryable === true
+  };
+}
 
 // src/bridge/sdk-timeline.ts
 function idsOf(e, raw) {
@@ -1312,13 +1063,11 @@ function idsOf(e, raw) {
   if (typeof model === "string" && model !== "" && model !== callId) ids.push(model);
   return ids;
 }
-__name(idsOf, "idsOf");
 function bucketFor(e, seen) {
   if (e.type === "tool_call") return seen.started;
   if (e.type === "tool_result") return seen.completed;
   return void 0;
 }
-__name(bucketFor, "bucketFor");
 function dedupeTools(events, raw, seen) {
   return events.filter((e) => {
     if (e.type === "thinking") {
@@ -1335,19 +1084,15 @@ function dedupeTools(events, raw, seen) {
     return true;
   });
 }
-__name(dedupeTools, "dedupeTools");
 function createToolSeen() {
-  return {
-    started: /* @__PURE__ */ new Set(),
-    completed: /* @__PURE__ */ new Set(),
-    sawThinkingDelta: false
-  };
+  return { started: /* @__PURE__ */ new Set(), completed: /* @__PURE__ */ new Set(), sawThinkingDelta: false };
 }
-__name(createToolSeen, "createToolSeen");
 function translateTimelineEvent(ev, runId, seen) {
   if (ev.kind === "delta") {
     if (ev.update === void 0) return [];
-    const events2 = translateInteractionUpdate(ev.update);
+    const events2 = translateInteractionUpdate(
+      ev.update
+    );
     return dedupeTools(events2, ev.update, seen);
   }
   if (ev.message === void 0) return [];
@@ -1355,7 +1100,6 @@ function translateTimelineEvent(ev, runId, seen) {
   const kept = ev.textAlreadyStreamed === true ? events.filter((e) => e.type !== "text_delta") : events;
   return dedupeTools(kept, ev.message, seen);
 }
-__name(translateTimelineEvent, "translateTimelineEvent");
 
 // src/bridge/tool-dialect-stripper.ts
 var OPEN2 = "<function=";
@@ -1367,12 +1111,11 @@ function heldPrefixLength2(s, delim) {
   }
   return 0;
 }
-__name(heldPrefixLength2, "heldPrefixLength");
 function createToolDialectStripper() {
   let mode = "text";
   let buffer = "";
   let pendingLeak = "";
-  const write = /* @__PURE__ */ __name((chunk) => {
+  const write = (chunk) => {
     buffer += chunk;
     const out = [];
     for (; ; ) {
@@ -1380,10 +1123,7 @@ function createToolDialectStripper() {
         const idx2 = buffer.indexOf(OPEN2);
         if (idx2 !== -1) {
           const content = buffer.slice(0, idx2);
-          if (content) out.push({
-            kind: "text",
-            content
-          });
+          if (content) out.push({ kind: "text", content });
           pendingLeak = OPEN2;
           buffer = buffer.slice(idx2 + OPEN2.length);
           mode = "stripping";
@@ -1391,10 +1131,7 @@ function createToolDialectStripper() {
         }
         const keep2 = heldPrefixLength2(buffer, OPEN2);
         const emit = buffer.slice(0, buffer.length - keep2);
-        if (emit) out.push({
-          kind: "text",
-          content: emit
-        });
+        if (emit) out.push({ kind: "text", content: emit });
         buffer = buffer.slice(buffer.length - keep2);
         break;
       }
@@ -1411,34 +1148,22 @@ function createToolDialectStripper() {
       break;
     }
     return out;
-  }, "write");
-  const end = /* @__PURE__ */ __name(() => {
+  };
+  const end = () => {
     const leftover = mode === "stripping" ? pendingLeak + buffer : buffer;
     buffer = "";
     pendingLeak = "";
-    return leftover ? [
-      {
-        kind: "text",
-        content: leftover
-      }
-    ] : [];
-  }, "end");
-  return {
-    write,
-    end
+    return leftover ? [{ kind: "text", content: leftover }] : [];
   };
+  return { write, end };
 }
-__name(createToolDialectStripper, "createToolDialectStripper");
 async function* stripToolDialectStream(source) {
   const stripper = createToolDialectStripper();
   try {
     for await (const event of source) {
       if (event.type === "text_delta" && typeof event.content === "string") {
         for (const seg of stripper.write(event.content)) {
-          yield {
-            type: "text_delta",
-            content: seg.content
-          };
+          yield { type: "text_delta", content: seg.content };
         }
       } else {
         yield event;
@@ -1446,37 +1171,26 @@ async function* stripToolDialectStream(source) {
     }
   } finally {
     for (const seg of stripper.end()) {
-      yield {
-        type: "text_delta",
-        content: seg.content
-      };
+      yield { type: "text_delta", content: seg.content };
     }
   }
 }
-__name(stripToolDialectStream, "stripToolDialectStream");
 
 // src/bridge/sdk-adapter.ts
 function withLeakedDialectRecovery(providers) {
   return {
     ...providers,
-    routes: providers.routes.map((route) => ({
-      ...route,
-      extractToolCallsFromContent: true
-    }))
+    routes: providers.routes.map((route) => ({ ...route, extractToolCallsFromContent: true }))
   };
 }
-__name(withLeakedDialectRecovery, "withLeakedDialectRecovery");
 function buildExtraCreateOptions(overrides, compiled) {
   const recoverLeakedToolCalls = overrides.recoverLeakedToolCalls ?? compiled.recoverLeakedToolCalls ?? false;
   const extra = {};
   if (overrides.plugins !== void 0) {
-    const asArray = /* @__PURE__ */ __name((v) => Array.isArray(v) ? v : void 0, "asArray");
+    const asArray = (v) => Array.isArray(v) ? v : void 0;
     const overrideList = asArray(overrides.plugins);
     const compiledList = asArray(compiled.plugins);
-    extra.plugins = overrideList !== void 0 && compiledList !== void 0 ? [
-      ...compiledList,
-      ...overrideList
-    ] : overrides.plugins;
+    extra.plugins = overrideList !== void 0 && compiledList !== void 0 ? [...compiledList, ...overrideList] : overrides.plugins;
   }
   if (overrides.providers !== void 0) {
     extra.providers = recoverLeakedToolCalls ? withLeakedDialectRecovery(overrides.providers) : overrides.providers;
@@ -1485,7 +1199,6 @@ function buildExtraCreateOptions(overrides, compiled) {
   if (overrides.budgetTracker !== void 0) extra.budgetTracker = overrides.budgetTracker;
   return extra;
 }
-__name(buildExtraCreateOptions, "buildExtraCreateOptions");
 async function loadSdkRuntime() {
   try {
     const sdk = await import("@theokit/sdk");
@@ -1495,40 +1208,30 @@ async function loadSdkRuntime() {
       // `.bind` keeps the static factory callable when detached from `sdk.Tool` (it takes no `this`,
       // but binding is explicit + satisfies unbound-method rather than relying on that).
       defineTool: sdk.Tool.create.bind(sdk.Tool),
-      ...skillReadTool ? {
-        defineSkillReadTool: /* @__PURE__ */ __name((skills) => skillReadTool.create(skills), "defineSkillReadTool")
-      } : {}
+      ...skillReadTool ? { defineSkillReadTool: (skills) => skillReadTool.create(skills) } : {}
     };
   } catch (err) {
     console.warn("[theokit] @theokit/sdk import failed:", err);
     return null;
   }
 }
-__name(loadSdkRuntime, "loadSdkRuntime");
 function resolveTextTransformFlags(compiled, overrides) {
   return {
     parseThinkTags: overrides.parseThinkTags ?? compiled.parseThinkTags ?? false,
     stripToolDialect: overrides.stripToolDialect ?? compiled.stripToolDialect ?? false
   };
 }
-__name(resolveTextTransformFlags, "resolveTextTransformFlags");
 function applyTextTransforms(events, opts) {
   let out = opts.parseThinkTags ? extractThinkTagStream(events) : events;
   if (opts.stripToolDialect) out = stripToolDialectStream(out);
   return out;
 }
-__name(applyTextTransforms, "applyTextTransforms");
 function hasZodInputSchema(schema) {
   return typeof schema?.parse === "function";
 }
-__name(hasZodInputSchema, "hasZodInputSchema");
 function withRunContext(handler, runContext) {
-  return (input, ctx) => handler(input, {
-    ...ctx,
-    context: runContext
-  });
+  return (input, ctx) => handler(input, { ...ctx, context: runContext });
 }
-__name(withRunContext, "withRunContext");
 function buildSdkTools(compiledTools, defineTool, extraSdkTools = [], runContext) {
   const has = runContext !== void 0;
   return [
@@ -1541,25 +1244,20 @@ function buildSdkTools(compiledTools, defineTool, extraSdkTools = [], runContext
           handler: has ? withRunContext(t.handler, runContext) : t.handler
         });
       }
-      return has ? {
-        ...t,
-        handler: withRunContext(t.handler, runContext)
-      } : t;
+      return has ? { ...t, handler: withRunContext(t.handler, runContext) } : t;
     }),
-    ...extraSdkTools.map((t) => has ? {
-      ...t,
-      handler: withRunContext(t.handler, runContext)
-    } : t)
+    ...extraSdkTools.map(
+      (t) => has ? { ...t, handler: withRunContext(t.handler, runContext) } : t
+    )
   ];
 }
-__name(buildSdkTools, "buildSdkTools");
-var resolverApiKey = /* @__PURE__ */ __name(async (k) => typeof k === "function" ? await k() : k, "resolverApiKey");
+var resolverApiKey = async (k) => typeof k === "function" ? await k() : k;
 function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
   const model = overrides.model ?? compiled.model ?? "openai/gpt-4o-mini";
   const reasoningEffort = overrides.reasoningEffort ?? compiled.reasoningEffort;
   const { parseThinkTags, stripToolDialect } = resolveTextTransformFlags(compiled, overrides);
   const runContext = overrides.runContext ?? compiled.runContext;
-  const factory = /* @__PURE__ */ __name((message, sessionId, factoryOpts) => ({
+  const factory = (message, sessionId, factoryOpts) => ({
     async *[Symbol.asyncIterator]() {
       const runId = `run-${Date.now()}`;
       const t0 = Date.now();
@@ -1605,27 +1303,30 @@ function createSdkAgentStream(compiled, compiledTools, apiKey, overrides = {}) {
           t0
         });
       } catch (err) {
-        yield eventoDeErroDoSdk(err);
+        yield sdkErrorEvent(err);
       }
     }
-  }), "factory");
-  return Object.assign(factory, {
-    resolvedModel: model
   });
+  return Object.assign(factory, { resolvedModel: model });
 }
-__name(createSdkAgentStream, "createSdkAgentStream");
 async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
   const { Agent } = rt;
-  const { apiKey, model, reasoningEffort, overrides, parseThinkTags, stripToolDialect, sessionId, message, factoryOpts, runId, t0 } = opts;
+  const {
+    apiKey,
+    model,
+    reasoningEffort,
+    overrides,
+    parseThinkTags,
+    stripToolDialect,
+    sessionId,
+    message,
+    factoryOpts,
+    runId,
+    t0
+  } = opts;
   const { options: m8, applied } = assembleM8CreateOptions(compiled);
-  if (overrides.cwd !== void 0) m8.local = {
-    ...m8.local,
-    cwd: overrides.cwd
-  };
-  if (overrides.baseDir !== void 0) m8.local = {
-    ...m8.local,
-    baseDir: overrides.baseDir
-  };
+  if (overrides.cwd !== void 0) m8.local = { ...m8.local, cwd: overrides.cwd };
+  if (overrides.baseDir !== void 0) m8.local = { ...m8.local, baseDir: overrides.baseDir };
   const extra = buildExtraCreateOptions(overrides, compiled);
   if (applied.length > 0) {
     debugLog("[THEO_AGENT_M8_RUNTIME_APPLIED]", {
@@ -1642,19 +1343,13 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
     ...extra
   });
   try {
-    const state = {
-      sawError: false,
-      lastEventType: ""
-    };
+    const state = { sawError: false, lastEventType: "" };
     const sendOptions = {};
     if (factoryOpts?.disableTools === true) sendOptions.toolChoice = "none";
     if (overrides.onRunEvent !== void 0) sendOptions.onRunEvent = overrides.onRunEvent;
-    const sendInput = overrides.images && overrides.images.length > 0 ? {
-      text: message,
-      images: overrides.images
-    } : message;
+    const sendInput = overrides.images && overrides.images.length > 0 ? { text: message, images: overrides.images } : message;
     const sendPromise = agent.send(sendInput, sendOptions);
-    const timeline = /* @__PURE__ */ __name(async function* () {
+    const timeline = async function* () {
       const run = await sendPromise;
       const seen = createToolSeen();
       for await (const ev of run.events()) {
@@ -1665,7 +1360,7 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
           yield event;
         }
       }
-    }, "timeline");
+    };
     for await (const event of applyTextTransforms(timeline(), {
       parseThinkTags,
       stripToolDialect
@@ -1677,7 +1372,7 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
         yield {
           type: "error",
           code: "RUN_FAILED",
-          message: "O turno terminou com erro; veja o evento `error` anterior.",
+          message: "The turn ended with an error; see the earlier `error` event.",
           retryable: false
         };
       }
@@ -1688,15 +1383,16 @@ async function* streamSdkAgent(rt, compiled, sdkTools, opts) {
     await agent.dispose();
   }
 }
-__name(streamSdkAgent, "streamSdkAgent");
 function toAgentFactory(def, opts) {
   const overrides = opts.overrides ?? {};
-  const projetarPorSessao = resolverProjecao(def, overrides);
+  const projectPerSession = resolveProjection(def, overrides);
   return async (sessionId) => {
-    const { compiled, model, reasoningEffort, runContext } = await projetarPorSessao(sessionId);
+    const { compiled, model, reasoningEffort, runContext } = await projectPerSession(sessionId);
     const rt = await loadSdkRuntime();
     if (!rt) {
-      throw new Error("[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk");
+      throw new Error(
+        "[@theokit/agents] @theokit/sdk is not installed \u2014 run: pnpm add @theokit/sdk"
+      );
     }
     const sdkTools = buildSdkTools(compiled.tools, rt.defineTool, overrides.sdkTools, runContext);
     const inlineSkills = compiled.skills?.inline;
@@ -1704,16 +1400,10 @@ function toAgentFactory(def, opts) {
       sdkTools.push(rt.defineSkillReadTool(inlineSkills));
     }
     const { options: m8 } = assembleM8CreateOptions(compiled);
-    if (overrides.cwd !== void 0) m8.local = {
-      ...m8.local,
-      cwd: overrides.cwd
-    };
-    if (overrides.baseDir !== void 0) m8.local = {
-      ...m8.local,
-      baseDir: overrides.baseDir
-    };
+    if (overrides.cwd !== void 0) m8.local = { ...m8.local, cwd: overrides.cwd };
+    if (overrides.baseDir !== void 0) m8.local = { ...m8.local, baseDir: overrides.baseDir };
     const extra = buildExtraCreateOptions(overrides, compiled);
-    aplicarPostura(extra, m8, opts.approvals, compiled.hitl);
+    applyPosture(extra, m8, opts.approvals, compiled.hitl);
     const agent = await rt.Agent.getOrCreate(sessionId, {
       apiKey: await resolverApiKey(opts.apiKey),
       model: buildModelSelection(model, reasoningEffort),
@@ -1724,53 +1414,37 @@ function toAgentFactory(def, opts) {
     return withGuardrails(agent, compiled.guardrails);
   };
 }
-__name(toAgentFactory, "toAgentFactory");
 function withGuardrails(handle, guardrails) {
   if (guardrails === void 0 || guardrails.length === 0) return handle;
   return {
     get agentId() {
       return handle.agentId;
     },
-    dispose: /* @__PURE__ */ __name(() => handle.dispose(), "dispose"),
-    send: /* @__PURE__ */ __name(async (msg, sendOpts) => {
+    dispose: () => handle.dispose(),
+    send: async (msg, sendOpts) => {
       const guarded = await runInputGuards(msg, guardrails);
       const turn = await handle.send(guarded, sendOpts);
       return {
-        wait: /* @__PURE__ */ __name(async () => {
+        wait: async () => {
           const out = await turn.wait();
           if (out.result === void 0) return out;
-          return {
-            ...out,
-            result: await runOutputGuards(out.result, guardrails)
-          };
-        }, "wait")
+          return { ...out, result: await runOutputGuards(out.result, guardrails) };
+        }
       };
-    }, "send")
+    }
   };
 }
-__name(withGuardrails, "withGuardrails");
 
 // src/bridge/present-ui-message-stream.ts
 import { UIMessageStreamPresenter } from "@theokit/presenter";
 function toAgentOutputEvent(e) {
   switch (e.type) {
     case "text_delta":
-      return {
-        type: "text",
-        text: e.content
-      };
+      return { type: "text", text: e.content };
     case "thinking":
-      return {
-        type: "reasoning",
-        text: e.content
-      };
+      return { type: "reasoning", text: e.content };
     case "tool_call":
-      return {
-        type: "tool-call",
-        callId: e.callId,
-        name: e.toolName,
-        input: e.input
-      };
+      return { type: "tool-call", callId: e.callId, name: e.toolName, input: e.input };
     case "tool_result":
       return {
         type: "tool-result",
@@ -1783,40 +1457,20 @@ function toAgentOutputEvent(e) {
       return null;
   }
 }
-__name(toAgentOutputEvent, "toAgentOutputEvent");
 function doneToMetadata(event) {
-  return event.cost === void 0 ? {
-    usage: event.usage,
-    durationMs: event.durationMs
-  } : {
-    usage: event.usage,
-    durationMs: event.durationMs,
-    cost: event.cost
-  };
+  return event.cost === void 0 ? { usage: event.usage, durationMs: event.durationMs } : { usage: event.usage, durationMs: event.durationMs, cost: event.cost };
 }
-__name(doneToMetadata, "doneToMetadata");
 var ERROR_CODE_DATA_PART = "data-error-code";
 var INPUT_REQUESTED_DATA_PART = "data-input-requested";
 var TASK_PROGRESS_DATA_PART = "data-task-progress";
 var SHELL_OUTPUT_DATA_PART = "data-shell-output";
 function dataPart(type, data) {
-  return {
-    type,
-    data,
-    transient: true
-  };
+  return { type, data, transient: true };
 }
-__name(dataPart, "dataPart");
 function* errorChunks(errorText, code) {
-  if (code !== void 0) yield dataPart(ERROR_CODE_DATA_PART, {
-    code
-  });
-  yield {
-    type: "error",
-    errorText
-  };
+  if (code !== void 0) yield dataPart(ERROR_CODE_DATA_PART, { code });
+  yield { type: "error", errorText };
 }
-__name(errorChunks, "errorChunks");
 function diagnosticDataPart(event) {
   switch (event.type) {
     case "checkpoint_saved":
@@ -1829,34 +1483,21 @@ function diagnosticDataPart(event) {
     // catch-all, which is the reported defect one layer down: translating an event and never
     // presenting it leaves the consumer just as blind, minus even the warning.
     case "input_requested":
-      return dataPart(INPUT_REQUESTED_DATA_PART, {
-        requestId: event.requestId
-      });
+      return dataPart(INPUT_REQUESTED_DATA_PART, { requestId: event.requestId });
     case "task_progress":
       return dataPart(TASK_PROGRESS_DATA_PART, {
-        ...event.status !== void 0 ? {
-          status: event.status
-        } : {},
-        ...event.text !== void 0 ? {
-          text: event.text
-        } : {}
+        ...event.status !== void 0 ? { status: event.status } : {},
+        ...event.text !== void 0 ? { text: event.text } : {}
       });
     case "shell_output":
-      return dataPart(SHELL_OUTPUT_DATA_PART, {
-        event: event.event
-      });
+      return dataPart(SHELL_OUTPUT_DATA_PART, { event: event.event });
     default:
       return null;
   }
 }
-__name(diagnosticDataPart, "diagnosticDataPart");
 async function* presentUIMessageStream(events, opts) {
-  const presenter = new UIMessageStreamPresenter({
-    textId: opts.textId
-  });
-  yield {
-    type: "start"
-  };
+  const presenter = new UIMessageStreamPresenter({ textId: opts.textId });
+  yield { type: "start" };
   let turnMetadata;
   try {
     for await (const event of events) {
@@ -1877,11 +1518,7 @@ async function* presentUIMessageStream(events, opts) {
             dynamic: true
           };
         }
-        yield {
-          type: "tool-approval-request",
-          approvalId: event.callId,
-          toolCallId: event.callId
-        };
+        yield { type: "tool-approval-request", approvalId: event.callId, toolCallId: event.callId };
         continue;
       }
       const diagnostic = diagnosticDataPart(event);
@@ -1905,105 +1542,46 @@ async function* presentUIMessageStream(events, opts) {
   }
   yield* presenter.finish(turnMetadata);
 }
-__name(presentUIMessageStream, "presentUIMessageStream");
 
 // src/bridge/agent-builder.ts
 var ContextualTool = {
   /**
-  * Tag a {@link CustomTool} with a literal name (so `.tool()` can accumulate the tool-name union)
-  * and, optionally, a required run-context type. The `requiredContext` argument is a type-only
-  * witness — pass `undefined as C` or a sample value; it is never read at runtime.
-  */
+   * Tag a {@link CustomTool} with a literal name (so `.tool()` can accumulate the tool-name union)
+   * and, optionally, a required run-context type. The `requiredContext` argument is a type-only
+   * witness — pass `undefined as C` or a sample value; it is never read at runtime.
+   */
   of(tool, _requiredContext) {
     return tool;
   }
 };
 function makeBuilder(config) {
   const runtime = {
-    input: /* @__PURE__ */ __name((schema) => makeBuilder({
-      ...config,
-      input: schema
-    }), "input"),
-    model: /* @__PURE__ */ __name((id) => makeBuilder({
-      ...config,
-      model: id
-    }), "model"),
-    system: /* @__PURE__ */ __name((prompt) => makeBuilder({
-      ...config,
-      system: prompt
-    }), "system"),
-    reasoningEffort: /* @__PURE__ */ __name((effort) => makeBuilder({
-      ...config,
-      reasoningEffort: effort
-    }), "reasoningEffort"),
-    context: /* @__PURE__ */ __name((value) => makeBuilder({
-      ...config,
-      context: value
-    }), "context"),
-    tool: /* @__PURE__ */ __name((tool) => makeBuilder({
-      ...config,
-      tools: [
-        ...config.tools ?? [],
-        tool
-      ]
-    }), "tool"),
-    guardrail: /* @__PURE__ */ __name((g) => makeBuilder({
-      ...config,
-      guardrails: [
-        ...config.guardrails ?? [],
-        g
-      ]
-    }), "guardrail"),
-    guardrails: /* @__PURE__ */ __name((gs) => makeBuilder({
-      ...config,
-      guardrails: gs
-    }), "guardrails"),
-    approval: /* @__PURE__ */ __name((toolName, options) => makeBuilder({
-      ...config,
-      approvals: {
-        ...config.approvals ?? {},
-        [toolName]: options
-      }
-    }), "approval"),
-    approvals: /* @__PURE__ */ __name((map) => makeBuilder({
-      ...config,
-      approvals: map
-    }), "approvals"),
-    skills: /* @__PURE__ */ __name((selection) => makeBuilder({
-      ...config,
-      skills: selection
-    }), "skills"),
-    settingSources: /* @__PURE__ */ __name((sources) => makeBuilder({
-      ...config,
-      settingSources: sources
-    }), "settingSources"),
-    memory: /* @__PURE__ */ __name((settings) => makeBuilder({
-      ...config,
-      memory: settings
-    }), "memory"),
-    hooks: /* @__PURE__ */ __name((map) => makeBuilder({
-      ...config,
-      hooks: map
-    }), "hooks"),
-    plugins: /* @__PURE__ */ __name((list) => makeBuilder({
-      ...config,
-      plugins: list
-    }), "plugins"),
-    mcp: /* @__PURE__ */ __name((servers) => makeBuilder({
-      ...config,
-      mcpServers: servers
-    }), "mcp"),
-    use: /* @__PURE__ */ __name((preset) => preset(runtime), "use"),
-    build: /* @__PURE__ */ __name(() => defineAgent(config), "build")
+    input: (schema) => makeBuilder({ ...config, input: schema }),
+    model: (id) => makeBuilder({ ...config, model: id }),
+    system: (prompt) => makeBuilder({ ...config, system: prompt }),
+    reasoningEffort: (effort) => makeBuilder({ ...config, reasoningEffort: effort }),
+    context: (value) => makeBuilder({ ...config, context: value }),
+    tool: (tool) => makeBuilder({ ...config, tools: [...config.tools ?? [], tool] }),
+    guardrail: (g) => makeBuilder({ ...config, guardrails: [...config.guardrails ?? [], g] }),
+    guardrails: (gs) => makeBuilder({ ...config, guardrails: gs }),
+    approval: (toolName, options) => makeBuilder({ ...config, approvals: { ...config.approvals ?? {}, [toolName]: options } }),
+    approvals: (map) => makeBuilder({ ...config, approvals: map }),
+    skills: (selection) => makeBuilder({ ...config, skills: selection }),
+    settingSources: (sources) => makeBuilder({ ...config, settingSources: sources }),
+    memory: (settings) => makeBuilder({ ...config, memory: settings }),
+    hooks: (map) => makeBuilder({ ...config, hooks: map }),
+    plugins: (list) => makeBuilder({ ...config, plugins: list }),
+    mcp: (servers) => makeBuilder({ ...config, mcpServers: servers }),
+    use: (preset) => preset(runtime),
+    build: () => defineAgent(config)
   };
   return runtime;
 }
-__name(makeBuilder, "makeBuilder");
 var AgentBuilder = {
   /**
-  * Start a fluent agent definition. Chain `.model()` (required) + `.context()` / `.system()` /
-  * `.input()` / `.tool()` / `.use()`, then `.build()` to get the branded {@link AgentDefinition}.
-  */
+   * Start a fluent agent definition. Chain `.model()` (required) + `.context()` / `.system()` /
+   * `.input()` / `.tool()` / `.use()`, then `.build()` to get the branded {@link AgentDefinition}.
+   */
   create() {
     return makeBuilder({});
   }
@@ -2011,11 +1589,10 @@ var AgentBuilder = {
 
 // src/bridge/agent-endpoint.ts
 var AgentDefinitionError = class extends Error {
-  static {
-    __name(this, "AgentDefinitionError");
-  }
   constructor(source) {
-    super(`[@theokit/agents] ${source}: an agents/ file must default-export a defineAgent(...) value or an @Agent-decorated class.`);
+    super(
+      `[@theokit/agents] ${source}: an agents/ file must default-export a defineAgent(...) value or an @Agent-decorated class.`
+    );
     this.name = "AgentDefinitionError";
   }
 };
@@ -2025,13 +1602,11 @@ function extractDefaultExport(mod) {
   }
   return mod;
 }
-__name(extractDefaultExport, "extractDefaultExport");
 function isCompiledAgentOptions(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
   return Array.isArray(v.tools) && typeof v.agents === "object" && v.agents !== null;
 }
-__name(isCompiledAgentOptions, "isCompiledAgentOptions");
 function compileAgentModule(mod, source = "agent module") {
   const def = extractDefaultExport(mod);
   if (isAgentDefinition(def)) {
@@ -2040,33 +1615,22 @@ function compileAgentModule(mod, source = "agent module") {
   if (isCompiledAgentOptions(def)) return def;
   throw new AgentDefinitionError(source);
 }
-__name(compileAgentModule, "compileAgentModule");
 async function* asAgentStream(events) {
   for await (const e of events) yield e;
 }
-__name(asAgentStream, "asAgentStream");
-var EventQueue = class EventQueue2 {
-  static {
-    __name(this, "EventQueue");
-  }
+var EventQueue = class {
   #items = [];
   #resolvers = [];
   #closed = false;
   push(item) {
     if (this.#closed) return;
     const r = this.#resolvers.shift();
-    if (r) r({
-      value: item,
-      done: false
-    });
+    if (r) r({ value: item, done: false });
     else this.#items.push(item);
   }
   close() {
     this.#closed = true;
-    for (const r of this.#resolvers.splice(0)) r({
-      value: void 0,
-      done: true
-    });
+    for (const r of this.#resolvers.splice(0)) r({ value: void 0, done: true });
   }
   async *drain() {
     for (; ; ) {
@@ -2083,12 +1647,12 @@ var EventQueue = class EventQueue2 {
 };
 async function* appendCheckpointSaved(source, sessionId) {
   let emitted = false;
-  const checkpoint = /* @__PURE__ */ __name(() => ({
+  const checkpoint = () => ({
     type: "checkpoint_saved",
     checkpointId: crypto.randomUUID(),
     step: 0,
     resumeToken: sessionId
-  }), "checkpoint");
+  });
   for await (const ev of source) {
     if (ev.type === "done" && !emitted) {
       emitted = true;
@@ -2098,7 +1662,6 @@ async function* appendCheckpointSaved(source, sessionId) {
   }
   if (!emitted) yield checkpoint();
 }
-__name(appendCheckpointSaved, "appendCheckpointSaved");
 function streamAgentUIMessages(compiled, apiKey, input) {
   const textId = crypto.randomUUID();
   const overrides = {};
@@ -2108,29 +1671,34 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   if (input.onRunEvent !== void 0) overrides.onRunEvent = input.onRunEvent;
   let source;
   if (!input.hitl || input.hitl.gated.size === 0) {
-    const events2 = createSdkAgentStream(compiled, compiled.tools, apiKey, overrides)(input.message, input.sessionId);
+    const events2 = createSdkAgentStream(
+      compiled,
+      compiled.tools,
+      apiKey,
+      overrides
+    )(input.message, input.sessionId);
     source = asAgentStream(events2);
   } else {
     const queue = new EventQueue();
-    input.signal?.addEventListener("abort", () => {
-      queue.close();
-    }, {
-      once: true
-    });
+    input.signal?.addEventListener(
+      "abort",
+      () => {
+        queue.close();
+      },
+      { once: true }
+    );
     const plugin = createHitlPlugin({
       gated: input.hitl.gated,
-      emit: /* @__PURE__ */ __name((e) => {
+      emit: (e) => {
         queue.push(e);
-      }, "emit"),
+      },
       awaitApproval: input.hitl.awaitApproval
     });
     const sdkStream = createSdkAgentStream(compiled, compiled.tools, apiKey, {
       ...overrides,
       // The HITL plugin is a structural @theokit/sdk Plugin (createHitlPlugin returns the
       // { name, register } shape); the RuntimeOverrides.plugins union is widened at the SDK edge.
-      plugins: [
-        plugin
-      ]
+      plugins: [plugin]
     })(input.message, input.sessionId);
     void (async () => {
       try {
@@ -2150,11 +1718,8 @@ function streamAgentUIMessages(compiled, apiKey, input) {
   }
   const durableCheckpoint = compiled.checkpoint?.storage === "filesystem";
   const events = durableCheckpoint ? appendCheckpointSaved(source, input.sessionId) : source;
-  return presentUIMessageStream(events, {
-    textId
-  });
+  return presentUIMessageStream(events, { textId });
 }
-__name(streamAgentUIMessages, "streamAgentUIMessages");
 
 // src/loop/compaction-strategy.ts
 import { compactTranscript } from "@theokit/sdk/compaction";
@@ -2165,73 +1730,56 @@ var compactionStrategyConfigSchema = z.object({
   keepTokens: z.number().int().positive()
 });
 function resolveCompactionStrategy(name, config) {
-  const cfg = compactionStrategyConfigSchema.parse({
-    name,
-    keepTokens: config.keepTokens
-  });
+  const cfg = compactionStrategyConfigSchema.parse({ name, keepTokens: config.keepTokens });
   return {
     name: cfg.name,
     keepTokens: cfg.keepTokens,
-    compact: /* @__PURE__ */ __name((messages, options) => compactTranscript(messages, {
+    compact: (messages, options) => compactTranscript(messages, {
       keepTokens: options?.keepTokens ?? cfg.keepTokens,
       summarize: options?.summarize,
       marker: options?.marker,
       summaryTemplate: options?.summaryTemplate,
       // Default-safe: a thrown summarize keeps the transcript (app opts out via failSafe:false).
       failSafe: options?.failSafe ?? true
-    }), "compact")
+    })
   };
 }
-__name(resolveCompactionStrategy, "resolveCompactionStrategy");
-var tokenBudgetCompactionStrategy = resolveCompactionStrategy("token-budget", {
-  keepTokens: DEFAULT_KEEP_TOKENS
-});
+var tokenBudgetCompactionStrategy = resolveCompactionStrategy("token-budget", { keepTokens: DEFAULT_KEEP_TOKENS });
 
 // src/loop/loop-strategy.ts
 import { z as z2 } from "zod";
 var DEFAULT_MAX_ITERATIONS = 8;
 var maxIterationsSchema = z2.number().int().min(1);
 var loopStrategyConfigSchema = z2.object({
-  name: z2.enum([
-    "simple-chat",
-    "plan-act-reflect",
-    "react"
-  ]),
+  name: z2.enum(["simple-chat", "plan-act-reflect", "react"]),
   maxIterations: maxIterationsSchema
 });
 function assertValidCustomLoopStrategy(strategy) {
   const result = maxIterationsSchema.safeParse(strategy.maxIterations);
   if (!result.success) {
-    throw new Error(`loopStrategy: maxIterations inv\xE1lido (${String(strategy.maxIterations)}) \u2014 deve ser um inteiro finito \u2265 1 (sen\xE3o o teto round < maxIterations nunca termina)`);
+    throw new Error(
+      `loopStrategy: invalid maxIterations (${String(strategy.maxIterations)}) \u2014 must be a finite integer \u2265 1 (otherwise the round < maxIterations ceiling never terminates)`
+    );
   }
 }
-__name(assertValidCustomLoopStrategy, "assertValidCustomLoopStrategy");
 function resolveLoopStrategy(strategy, maxIterations = DEFAULT_MAX_ITERATIONS) {
-  const cfg = loopStrategyConfigSchema.parse({
-    name: strategy,
-    maxIterations
-  });
+  const cfg = loopStrategyConfigSchema.parse({ name: strategy, maxIterations });
   if (cfg.name === "simple-chat") {
-    return {
-      name: cfg.name,
-      maxIterations: cfg.maxIterations,
-      shouldContinue: /* @__PURE__ */ __name(() => false, "shouldContinue")
-    };
+    return { name: cfg.name, maxIterations: cfg.maxIterations, shouldContinue: () => false };
   }
   if (cfg.name === "plan-act-reflect") {
     return {
       name: cfg.name,
       maxIterations: cfg.maxIterations,
-      shouldContinue: /* @__PURE__ */ __name((outcome) => outcome.round < cfg.maxIterations, "shouldContinue")
+      shouldContinue: (outcome) => outcome.round < cfg.maxIterations
     };
   }
   return {
     name: cfg.name,
     maxIterations: cfg.maxIterations,
-    shouldContinue: /* @__PURE__ */ __name((outcome) => outcome.finishReason === "tool-calls" && outcome.round < cfg.maxIterations, "shouldContinue")
+    shouldContinue: (outcome) => outcome.finishReason === "tool-calls" && outcome.round < cfg.maxIterations
   };
 }
-__name(resolveLoopStrategy, "resolveLoopStrategy");
 
 // src/loop/reflection-strategy.ts
 import { z as z3 } from "zod";
@@ -2247,55 +1795,52 @@ var ladderReflectionStrategy = {
         continue: true
       };
     }
-    return {
-      continue: false
-    };
+    return { continue: false };
   }
 };
 var noopReflectionStrategy = {
   name: "noop",
   reflect() {
-    return {
-      continue: true
-    };
+    return { continue: true };
   }
 };
 
 // src/bridge/delegation-types.ts
 var DelegationBudgetExceededError = class extends Error {
-  static {
-    __name(this, "DelegationBudgetExceededError");
+  constructor(agentName, actualCost, budgetLimit) {
+    super(
+      `Agent "${agentName}" exceeded budget: $${actualCost.toFixed(4)} > $${budgetLimit.toFixed(4)}`
+    );
+    this.agentName = agentName;
+    this.actualCost = actualCost;
+    this.budgetLimit = budgetLimit;
+    this.name = "DelegationBudgetExceededError";
   }
   agentName;
   actualCost;
   budgetLimit;
-  constructor(agentName, actualCost, budgetLimit) {
-    super(`Agent "${agentName}" exceeded budget: $${actualCost.toFixed(4)} > $${budgetLimit.toFixed(4)}`), this.agentName = agentName, this.actualCost = actualCost, this.budgetLimit = budgetLimit;
-    this.name = "DelegationBudgetExceededError";
-  }
 };
 var BudgetExceededError = DelegationBudgetExceededError;
 var DelegationError = class extends Error {
-  static {
-    __name(this, "DelegationError");
-  }
-  agentName;
-  cause;
   constructor(agentName, cause) {
-    super(`Delegation to agent "${agentName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`), this.agentName = agentName, this.cause = cause;
+    super(
+      `Delegation to agent "${agentName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+    this.agentName = agentName;
+    this.cause = cause;
     this.name = "DelegationError";
   }
+  agentName;
+  cause;
 };
 
 // src/loop/run-reflective-loop.ts
 function asString2(value, fallback) {
   return typeof value === "string" ? value : fallback;
 }
-__name(asString2, "asString");
 function asNumber(value, fallback) {
   return typeof value === "number" ? value : fallback;
 }
-__name(asNumber, "asNumber");
 var NO_PROGRESS_THRESHOLD = 2;
 var MAINLOOP_METRIC = "[THEO_AGENT_MAINLOOP_RUNTIME_APPLIED]";
 var TOOL_CALLS = "tool-calls";
@@ -2308,17 +1853,15 @@ function stableStringify(value) {
   const entries = Object.keys(obj).sort((a, b) => a.localeCompare(b)).map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
   return `{${entries.join(",")}}`;
 }
-__name(stableStringify, "stableStringify");
 function roundSignature(toolCalls) {
   return toolCalls.map((tc) => `${tc.name}:${stableStringify(tc.input)}`).sort((a, b) => a.localeCompare(b)).join(",");
 }
-__name(roundSignature, "roundSignature");
 function terminalReason(reflectionContinue, roundReason, round, maxIterations) {
-  if (reflectionContinue && roundReason === TOOL_CALLS && round >= maxIterations) return "step_limit";
+  if (reflectionContinue && roundReason === TOOL_CALLS && round >= maxIterations)
+    return "step_limit";
   if (roundReason === TOOL_CALLS) return "stop";
   return roundReason;
 }
-__name(terminalReason, "terminalReason");
 var CONTINUE_PROMPT = "Continue from the prior turns above; finish the task and give a final answer.";
 function buildPrompt(round, maxIterations, message, feedback) {
   const hint = round === maxIterations ? `${STEP_LIMIT_HINT}
@@ -2328,16 +1871,20 @@ function buildPrompt(round, maxIterations, message, feedback) {
   const body = round === 1 ? message : continuation;
   return hint + body;
 }
-__name(buildPrompt, "buildPrompt");
 async function* consumeRoundOrThrow(inputs, agentName) {
   try {
-    return yield* consumeOneRound(inputs.factory, inputs.prompt, inputs.sessionId, inputs.signal, inputs.retry);
+    return yield* consumeOneRound(
+      inputs.factory,
+      inputs.prompt,
+      inputs.sessionId,
+      inputs.signal,
+      inputs.retry
+    );
   } catch (err) {
     if (err instanceof DelegationBudgetExceededError || err instanceof DelegationError) throw err;
     throw new DelegationError(agentName, err);
   }
 }
-__name(consumeRoundOrThrow, "consumeRoundOrThrow");
 function accumulateUsage(acc, r) {
   acc.cost += r.cost;
   acc.tokens += r.tokens;
@@ -2347,25 +1894,18 @@ function accumulateUsage(acc, r) {
   acc.cacheReadTokens = (acc.cacheReadTokens ?? 0) + r.cacheReadTokens;
   acc.cacheWriteTokens = (acc.cacheWriteTokens ?? 0) + r.cacheWriteTokens;
 }
-__name(accumulateUsage, "accumulateUsage");
 function finalize(acc, round, reason, strategyName) {
   acc.rounds = round;
   acc.finishReason = reason;
-  debugLog(MAINLOOP_METRIC, {
-    strategy: strategyName,
-    rounds: round,
-    terminal: reason
-  });
+  debugLog(MAINLOOP_METRIC, { strategy: strategyName, rounds: round, terminal: reason });
   return acc;
 }
-__name(finalize, "finalize");
 function deriveFinishReason(signals) {
   if (signals.sawError) return "error";
   if (signals.sawDone && signals.doneFinishReason === TOOL_CALLS) return TOOL_CALLS;
   if (signals.sawToolResult) return TOOL_CALLS;
   return "stop";
 }
-__name(deriveFinishReason, "deriveFinishReason");
 function pushToolResult(event, r, callInputs) {
   const id = asString2(event.callId, "");
   const call = callInputs.get(id);
@@ -2378,7 +1918,6 @@ function pushToolResult(event, r, callInputs) {
     output: asString2(event.output, "")
   });
 }
-__name(pushToolResult, "pushToolResult");
 function applyDone(event, r) {
   r.cost = asNumber(event.cost, 0);
   const usage = event.usage;
@@ -2389,7 +1928,6 @@ function applyDone(event, r) {
   r.cacheReadTokens = usage?.cacheReadTokens ?? 0;
   r.cacheWriteTokens = usage?.cacheWriteTokens ?? 0;
 }
-__name(applyDone, "applyDone");
 function accumulateEvent(event, r, signals, callInputs) {
   if (event.type === "text_delta" && typeof event.content === "string") {
     r.responseText += event.content;
@@ -2410,28 +1948,20 @@ function accumulateEvent(event, r, signals, callInputs) {
     r.errorMessage = asString2(event.message, "Unknown agent error");
   }
 }
-__name(accumulateEvent, "accumulateEvent");
 async function startRound(factory, prompt, sessionId, signal, retry) {
-  const open = /* @__PURE__ */ __name(async () => {
+  const open = async () => {
     const it = factory(prompt, sessionId)[Symbol.asyncIterator]();
     try {
-      return {
-        it,
-        first: await it.next()
-      };
+      return { it, first: await it.next() };
     } catch (err) {
       await it.return?.(void 0);
       throw err;
     }
-  }, "open");
+  };
   if (!retry) return open();
   const { Retry } = await import("@theokit/sdk/retry");
-  return Retry.create(open, {
-    ...retry,
-    signal: retry.signal ?? signal
-  });
+  return Retry.create(open, { ...retry, signal: retry.signal ?? signal });
 }
-__name(startRound, "startRound");
 async function* consumeOneRound(factory, prompt, sessionId, signal, retry) {
   const r = {
     responseText: "",
@@ -2467,16 +1997,19 @@ async function* consumeOneRound(factory, prompt, sessionId, signal, retry) {
   r.finishReason = deriveFinishReason(signals);
   return r;
 }
-__name(consumeOneRound, "consumeOneRound");
 function ceilingRoundFactory(factory, round, maxIterations) {
   if (round !== maxIterations) return factory;
-  return (m, s) => factory(m, s, {
-    disableTools: true
-  });
+  return (m, s) => factory(m, s, { disableTools: true });
 }
-__name(ceilingRoundFactory, "ceilingRoundFactory");
 async function* runReflectiveLoopStream(factory, message, sessionId, config) {
-  const { loop, reflection, budget = Number.POSITIVE_INFINITY, signal, agentName = loop.name, retry } = config;
+  const {
+    loop,
+    reflection,
+    budget = Number.POSITIVE_INFINITY,
+    signal,
+    agentName = loop.name,
+    retry
+  } = config;
   const acc = {
     response: "",
     toolCalls: [],
@@ -2497,13 +2030,10 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
   while (!signal?.aborted) {
     const prompt = buildPrompt(round, loop.maxIterations, message, feedback);
     const roundFactory = ceilingRoundFactory(factory, round, loop.maxIterations);
-    const r = yield* consumeRoundOrThrow({
-      factory: roundFactory,
-      prompt,
-      sessionId,
-      signal,
-      retry
-    }, agentName);
+    const r = yield* consumeRoundOrThrow(
+      { factory: roundFactory, prompt, sessionId, signal, retry },
+      agentName
+    );
     acc.response += r.responseText;
     acc.toolCalls.push(...r.toolCalls);
     accumulateUsage(acc, r);
@@ -2525,7 +2055,12 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
     };
     const reflectionResult = reflection.reflect(outcome, reflectionContext);
     if (!(reflectionResult.continue && loop.shouldContinue(outcome) && round < loop.maxIterations)) {
-      const reason = terminalReason(reflectionResult.continue, r.finishReason, round, loop.maxIterations);
+      const reason = terminalReason(
+        reflectionResult.continue,
+        r.finishReason,
+        round,
+        loop.maxIterations
+      );
       return finalize(acc, round, reason, loop.name);
     }
     feedback = reflectionResult.feedback;
@@ -2534,20 +2069,15 @@ async function* runReflectiveLoopStream(factory, message, sessionId, config) {
   acc.rounds = round - 1;
   return acc;
 }
-__name(runReflectiveLoopStream, "runReflectiveLoopStream");
 async function runReflectiveLoop(factory, message, sessionId, config) {
   const gen = runReflectiveLoopStream(factory, message, sessionId, config);
   let res = await gen.next();
   while (!res.done) res = await gen.next();
   return res.value;
 }
-__name(runReflectiveLoop, "runReflectiveLoop");
 
 // src/loop/agent-runner.ts
 var AgentRunner = class {
-  static {
-    __name(this, "AgentRunner");
-  }
   compiled;
   agentName;
   /** The resolved terminal-decision strategy (parity with `delegate()`). */
@@ -2557,18 +2087,18 @@ var AgentRunner = class {
   /** The resolved between-round reflection (default or `.reflection(custom)` override). */
   reflectionStrategy;
   /**
-  * Recorded streaming preference. The reflective loop currently always streams via
-  * the SDK `Run.stream()`; a non-streaming collect mode is future work — the flag is
-  * captured + exposed here, not yet branched on (honest per G10: documented, not a
-  * silent no-op).
-  */
+   * Recorded streaming preference. The reflective loop currently always streams via
+   * the SDK `Run.stream()`; a non-streaming collect mode is future work — the flag is
+   * captured + exposed here, not yet branched on (honest per G10: documented, not a
+   * silent no-op).
+   */
   streamEnabled;
   /**
-  * V4-F: the resolved compaction strategy (from `@Compaction` or `.compaction()`),
-  * or `undefined` when neither is declared — compaction is opt-in (EC-4). CALLABLE
-  * by the app (ADR D1: `runner.compaction?.compact(messages, { summarize })`); the
-  * reflective loop does NOT auto-invoke it (the SDK owns per-turn context).
-  */
+   * V4-F: the resolved compaction strategy (from `@Compaction` or `.compaction()`),
+   * or `undefined` when neither is declared — compaction is opt-in (EC-4). CALLABLE
+   * by the app (ADR D1: `runner.compaction?.compact(messages, { summarize })`); the
+   * reflective loop does NOT auto-invoke it (the SDK owns per-turn context).
+   */
   compaction;
   constructor(state) {
     this.compiled = state.compiled;
@@ -2584,35 +2114,41 @@ var AgentRunner = class {
     return new AgentRunnerBuilder(spec);
   }
   /**
-  * V4-D-stream: stream the agent's events LIVE across the reflective loop, returning
-  * the aggregated {@link DelegationResult} as the generator's return value. This is the
-  * on-ramp for streaming-first apps (SSE) — `runReflectiveLoopStream` yields every
-  * round's events before the loop terminates. `streamEnabled` is honored: when the
-  * builder set `.stream(false)`, callers should use {@link run} instead.
-  */
+   * V4-D-stream: stream the agent's events LIVE across the reflective loop, returning
+   * the aggregated {@link DelegationResult} as the generator's return value. This is the
+   * on-ramp for streaming-first apps (SSE) — `runReflectiveLoopStream` yields every
+   * round's events before the loop terminates. `streamEnabled` is honored: when the
+   * builder set `.stream(false)`, callers should use {@link run} instead.
+   */
   stream(message, opts) {
     const guardrails = this.compiled.guardrails;
     if (guardrails && guardrails.length > 0) {
-      const runUnguarded = /* @__PURE__ */ __name((m) => this.streamUnguarded(m, opts), "runUnguarded");
-      return (/* @__PURE__ */ __name(async function* guarded() {
+      const runUnguarded = (m) => this.streamUnguarded(m, opts);
+      return (async function* guarded() {
         const safe = await runInputGuards(message, guardrails);
-        return yield* moderateOutputStream(runUnguarded(safe), guardrails, (e) => e.type === "text_delta" && typeof e.content === "string" ? e.content : void 0);
-      }, "guarded"))();
+        return yield* moderateOutputStream(
+          runUnguarded(safe),
+          guardrails,
+          (e) => e.type === "text_delta" && typeof e.content === "string" ? e.content : void 0
+        );
+      })();
     }
     return this.streamUnguarded(message, opts);
   }
   /** The core stream path, after input guardrails have run (M9). */
   streamUnguarded(message, opts) {
-    const tools = opts.tools ? [
-      ...opts.tools
-    ] : this.compiled.tools;
+    const tools = opts.tools ? [...opts.tools] : this.compiled.tools;
     const loop = this.resolvePerRunLoop(opts.maxIterations);
     const streamFactory = opts.streamFactory ?? createSdkAgentStream(this.compiled, tools, opts.apiKey, {
       model: opts.model,
       reasoningEffort: opts.reasoningEffort,
+      // M1: per-run extended-thinking effort
       parseThinkTags: opts.parseThinkTags,
+      // M2: per-run <think>-tag extraction opt-in
       stripToolDialect: opts.stripToolDialect,
+      // theocode#32: per-run tool-dialect strip opt-in
       recoverLeakedToolCalls: opts.recoverLeakedToolCalls,
+      // theokit#58: per-run leaked-dialect recovery opt-in
       cwd: opts.cwd,
       baseDir: opts.baseDir,
       plugins: opts.plugins,
@@ -2620,6 +2156,7 @@ var AgentRunner = class {
       agents: opts.agents,
       budgetTracker: opts.budgetTracker,
       sdkTools: opts.sdkTools
+      // V4-Q: pre-built SDK tools forwarded raw
     });
     const sessionId = opts.sessionId ?? `runner-${crypto.randomUUID()}`;
     return runReflectiveLoopStream(streamFactory, message, sessionId, {
@@ -2629,16 +2166,17 @@ var AgentRunner = class {
       agentName: this.agentName,
       signal: opts.signal,
       retry: opts.retry
+      // V4-P: per-round transient retry (opt-in)
     });
   }
   /** Run the agent to a terminal result via the shared reflective loop (collect mode). */
   /**
-  * Apply a per-call `maxIterations` override (M54 D4). A custom strategy must NOT be re-resolved by
-  * name — its name is outside the `z.enum`, which would throw — and its `shouldContinue` closure
-  * must survive; since the runner enforces the ceiling via `round < loop.maxIterations` (T1.1),
-  * overriding just that field bounds a custom without touching its logic. A built-in keeps the
-  * by-name re-resolution (zod fail-loud on `< 1`) — unchanged, zero-behavior.
-  */
+   * Apply a per-call `maxIterations` override (M54 D4). A custom strategy must NOT be re-resolved by
+   * name — its name is outside the `z.enum`, which would throw — and its `shouldContinue` closure
+   * must survive; since the runner enforces the ceiling via `round < loop.maxIterations` (T1.1),
+   * overriding just that field bounds a custom without touching its logic. A built-in keeps the
+   * by-name re-resolution (zod fail-loud on `< 1`) — unchanged, zero-behavior.
+   */
   resolvePerRunLoop(maxIterations) {
     if (maxIterations == null) return this.loopStrategy;
     if (this.loopStrategyIsCustom) {
@@ -2657,40 +2195,37 @@ var AgentRunner = class {
   }
 };
 var AgentRunnerBuilder = class {
-  static {
-    __name(this, "AgentRunnerBuilder");
+  constructor(spec) {
+    this.spec = spec;
   }
   spec;
   reflectionOverride;
   streamEnabled = true;
   compactionOverride;
   loopStrategyOverride;
-  constructor(spec) {
-    this.spec = spec;
-  }
   /** Override the default reflection strategy (OCP — plan Drawback #2). No arg ⇒ keep default. */
   reflection(strategy) {
     if (strategy) this.reflectionOverride = strategy;
     return this;
   }
   /**
-  * M54 — inject a custom terminal-decision strategy (the fourth OCP axis, alongside
-  * `.reflection()`/`.compaction()`/`streamFactory`). WINS over the strategy the spec's name would
-  * resolve to, exactly as `.compaction()` outranks the spec. The runner caps ANY strategy at
-  * `custom.maxIterations` (T1.1), so a `shouldContinue: () => true` still terminates — never an
-  * infinite loop.
-  *
-  * @example
-  * ```ts
-  * // Stop as soon as the confidence in the last round crosses 0.9, else run to the ceiling.
-  * const stopWhenConfident: LoopStrategy = {
-  *   name: 'confident',
-  *   maxIterations: 8,
-  *   shouldContinue: (o) => !o.responseText.includes('confidence: high'),
-  * }
-  * AgentRunner.fromSpec(spec).loopStrategy(stopWhenConfident).build()
-  * ```
-  */
+   * M54 — inject a custom terminal-decision strategy (the fourth OCP axis, alongside
+   * `.reflection()`/`.compaction()`/`streamFactory`). WINS over the strategy the spec's name would
+   * resolve to, exactly as `.compaction()` outranks the spec. The runner caps ANY strategy at
+   * `custom.maxIterations` (T1.1), so a `shouldContinue: () => true` still terminates — never an
+   * infinite loop.
+   *
+   * @example
+   * ```ts
+   * // Stop as soon as the confidence in the last round crosses 0.9, else run to the ceiling.
+   * const stopWhenConfident: LoopStrategy = {
+   *   name: 'confident',
+   *   maxIterations: 8,
+   *   shouldContinue: (o) => !o.responseText.includes('confidence: high'),
+   * }
+   * AgentRunner.fromSpec(spec).loopStrategy(stopWhenConfident).build()
+   * ```
+   */
   loopStrategy(custom) {
     assertValidCustomLoopStrategy(custom);
     this.loopStrategyOverride = custom;
@@ -2702,15 +2237,12 @@ var AgentRunnerBuilder = class {
     return this;
   }
   /**
-  * V4-F: declare the compaction strategy (e.g. `.compaction('token-budget', { keepTokens: 8000 })`).
-  * Resolved + validated at {@link build} (EC-5 — fail-fast there, not here). This builder
-  * call WINS over a `@Compaction` decorator on the same agent (EC-1 — explicit override).
-  */
+   * V4-F: declare the compaction strategy (e.g. `.compaction('token-budget', { keepTokens: 8000 })`).
+   * Resolved + validated at {@link build} (EC-5 — fail-fast there, not here). This builder
+   * call WINS over a `@Compaction` decorator on the same agent (EC-1 — explicit override).
+   */
   compaction(name, options = {}) {
-    this.compactionOverride = {
-      name,
-      keepTokens: options.keepTokens
-    };
+    this.compactionOverride = { name, keepTokens: options.keepTokens };
     return this;
   }
   /** Resolve strategies from the spec — the compile→execute boundary (no I/O). */
@@ -2721,9 +2253,7 @@ var AgentRunnerBuilder = class {
     const loopStrategy = this.loopStrategyOverride ?? resolveLoopStrategy(strategy, spec.maxIterations);
     const reflectionStrategy = this.reflectionOverride ?? (strategy === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
     const compactionDecl = this.compactionOverride ?? spec.compaction;
-    const compaction = compactionDecl ? resolveCompactionStrategy(compactionDecl.name, {
-      keepTokens: compactionDecl.keepTokens
-    }) : void 0;
+    const compaction = compactionDecl ? resolveCompactionStrategy(compactionDecl.name, { keepTokens: compactionDecl.keepTokens }) : void 0;
     return new AgentRunner({
       compiled: spec.compiled,
       agentName: spec.name,
@@ -2740,18 +2270,15 @@ var AgentRunnerBuilder = class {
 import { runGoalLoop } from "@theokit/sdk";
 import { JudgeCredentialError } from "@theokit/sdk";
 var GoalRunner = class {
-  static {
-    __name(this, "GoalRunner");
-  }
-  agent;
   constructor(agent) {
     this.agent = agent;
   }
+  agent;
   /**
-  * Drive `goal` to completion against the bound agent. Returns the SAME async generator `runGoalLoop`
-  * returns — yielding `GoalEvent`s, resolving a `GoalResult`. `deps` (judge/clock overrides) threads
-  * straight through; a test seam for the judge lives there, exactly as on the free function.
-  */
+   * Drive `goal` to completion against the bound agent. Returns the SAME async generator `runGoalLoop`
+   * returns — yielding `GoalEvent`s, resolving a `GoalResult`. `deps` (judge/clock overrides) threads
+   * straight through; a test seam for the judge lives there, exactly as on the free function.
+   */
   run(goal, options, deps) {
     return runGoalLoop(this.agent, goal, options, deps);
   }
@@ -2765,22 +2292,14 @@ function requireApiKey(opts, agentName) {
   }
   return apiKey;
 }
-__name(requireApiKey, "requireApiKey");
 function mergeTools(parentTools, subTools) {
   const subToolNames = new Set(subTools.map((t) => t.name));
   const inherited = parentTools.filter((t) => !subToolNames.has(t.name));
-  return [
-    ...inherited,
-    ...subTools
-  ];
+  return [...inherited, ...subTools];
 }
-__name(mergeTools, "mergeTools");
 async function delegate(spec, message, opts = {}) {
   const apiKey = requireApiKey(opts, spec.name);
-  const effectiveMessage = opts.onDelegationStart ? await opts.onDelegationStart({
-    subAgent: spec.name,
-    input: message
-  }) : message;
+  const effectiveMessage = opts.onDelegationStart ? await opts.onDelegationStart({ subAgent: spec.name, input: message }) : message;
   const { compiled } = spec;
   const allTools = mergeTools(opts.parentTools ?? [], compiled.tools);
   const budget = Math.min(opts.budget ?? Infinity, opts.parentBudgetRemaining ?? Infinity);
@@ -2794,7 +2313,10 @@ async function delegate(spec, message, opts = {}) {
     sdkTools: opts.sdkTools
   });
   const sessionId = opts.sessionId ?? `sub-${crypto.randomUUID()}`;
-  const loopStrategy = resolveLoopStrategy(spec.strategy ?? "simple-chat", opts.maxIterations ?? spec.maxIterations);
+  const loopStrategy = resolveLoopStrategy(
+    spec.strategy ?? "simple-chat",
+    opts.maxIterations ?? spec.maxIterations
+  );
   const reflection = opts.reflection ?? (loopStrategy.name === "plan-act-reflect" ? ladderReflectionStrategy : noopReflectionStrategy);
   const result = await runReflectiveLoop(streamFactory, effectiveMessage, sessionId, {
     loop: loopStrategy,
@@ -2803,16 +2325,13 @@ async function delegate(spec, message, opts = {}) {
     agentName: spec.name,
     signal: opts.signal,
     retry: opts.retry
+    // V4-T: per-round transient retry (V4-P) on the delegate path
   });
   if (opts.onDelegationComplete) {
-    return await opts.onDelegationComplete({
-      subAgent: spec.name,
-      result
-    });
+    return await opts.onDelegationComplete({ subAgent: spec.name, result });
   }
   return result;
 }
-__name(delegate, "delegate");
 
 // src/bridge/api-error-handler.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
@@ -2824,10 +2343,7 @@ async function runWithApiErrorHandling(thunk, policy) {
     try {
       return await thunk();
     } catch (error) {
-      const decision = await policy.processApiError({
-        error,
-        attempt
-      });
+      const decision = await policy.processApiError({ error, attempt });
       if (decision.retry && attempt < maxAttempts) continue;
       if (!decision.retry && "fallback" in decision && decision.fallback !== void 0) {
         return decision.fallback;
@@ -2836,11 +2352,9 @@ async function runWithApiErrorHandling(thunk, policy) {
     }
   }
 }
-__name(runWithApiErrorHandling, "runWithApiErrorHandling");
 function createApiErrorHandler(policy) {
   return (thunk) => runWithApiErrorHandling(thunk, policy);
 }
-__name(createApiErrorHandler, "createApiErrorHandler");
 
 // src/bridge/delegation-scoring.ts
 function delegateBackground(subAgent, message, opts = {}) {
@@ -2851,20 +2365,24 @@ function delegateBackground(subAgent, message, opts = {}) {
   });
   promise.catch(() => void 0);
   return {
-    wait: /* @__PURE__ */ __name(() => promise, "wait"),
-    settled: /* @__PURE__ */ __name(() => isSettled, "settled")
+    wait: () => promise,
+    settled: () => isSettled
   };
 }
-__name(delegateBackground, "delegateBackground");
 var DEFAULT_MAX_ROUNDS = 3;
 function defaultFeedbackTemplate(message, feedback) {
   return `${message}
 
 Feedback from the reviewer (address this): ${feedback}`;
 }
-__name(defaultFeedbackTemplate, "defaultFeedbackTemplate");
 async function delegateWithScoring(subAgent, message, opts) {
-  const { scorer, maxRounds: maxRoundsOpt = DEFAULT_MAX_ROUNDS, delegateFn = delegate, feedbackTemplate = defaultFeedbackTemplate, ...delegateOpts } = opts;
+  const {
+    scorer,
+    maxRounds: maxRoundsOpt = DEFAULT_MAX_ROUNDS,
+    delegateFn = delegate,
+    feedbackTemplate = defaultFeedbackTemplate,
+    ...delegateOpts
+  } = opts;
   const maxRounds = Math.max(1, maxRoundsOpt);
   const verdicts = [];
   let currentMessage = message;
@@ -2875,12 +2393,7 @@ async function delegateWithScoring(subAgent, message, opts) {
     const verdict = await scorer(result);
     verdicts.push(verdict);
     if (verdict.pass) {
-      return {
-        result,
-        rounds: round,
-        passed: true,
-        verdicts
-      };
+      return { result, rounds: round, passed: true, verdicts };
     }
     if (verdict.feedback) currentMessage = feedbackTemplate(message, verdict.feedback);
   }
@@ -2894,7 +2407,6 @@ async function delegateWithScoring(subAgent, message, opts) {
     verdicts
   };
 }
-__name(delegateWithScoring, "delegateWithScoring");
 
 // src/bridge/mcp-resolver.ts
 async function resolveMcpServers(selection, ctx) {
@@ -2906,7 +2418,6 @@ async function resolveMcpServers(selection, ctx) {
   }
   return resolved;
 }
-__name(resolveMcpServers, "resolveMcpServers");
 function mcpRegistry(config) {
   const registry = config.registry;
   if (registry === "composio") {
@@ -2914,17 +2425,8 @@ function mcpRegistry(config) {
     return {
       composio: {
         command: "npx",
-        args: [
-          "-y",
-          "@composio/mcp",
-          ...apps.length > 0 ? [
-            "--apps",
-            apps.join(",")
-          ] : []
-        ],
-        env: {
-          COMPOSIO_API_KEY: config.apiKey
-        }
+        args: ["-y", "@composio/mcp", ...apps.length > 0 ? ["--apps", apps.join(",")] : []],
+        env: { COMPOSIO_API_KEY: config.apiKey }
       }
     };
   }
@@ -2936,30 +2438,23 @@ function mcpRegistry(config) {
           "-y",
           "@mcp.run/cli",
           "serve",
-          ...config.profile ? [
-            "--profile",
-            config.profile
-          ] : []
+          ...config.profile ? ["--profile", config.profile] : []
         ],
-        env: {
-          MCP_RUN_API_KEY: config.apiKey
-        }
+        env: { MCP_RUN_API_KEY: config.apiKey }
       }
     };
   }
-  throw new Error(`mcpRegistry: unknown registry ${JSON.stringify(registry)} (supported: 'composio', 'mcp.run').`);
+  throw new Error(
+    `mcpRegistry: unknown registry ${JSON.stringify(registry)} (supported: 'composio', 'mcp.run').`
+  );
 }
-__name(mcpRegistry, "mcpRegistry");
 function mcpToolApprovals(specs) {
   const out = {};
   for (const [tool, spec] of Object.entries(specs)) {
-    out[tool] = typeof spec === "string" ? {
-      question: spec
-    } : spec;
+    out[tool] = typeof spec === "string" ? { question: spec } : spec;
   }
   return out;
 }
-__name(mcpToolApprovals, "mcpToolApprovals");
 
 // src/bridge/mcp-file.ts
 import { existsSync, readFileSync } from "fs";
@@ -2971,11 +2466,7 @@ function warningChannel(opts) {
 `);
   });
 }
-__name(warningChannel, "warningChannel");
 var McpFileError = class extends TheokitAgentError {
-  static {
-    __name(this, "McpFileError");
-  }
   name = "McpFileError";
   constructor(message) {
     super(`[@theokit/agents] ${message}`);
@@ -2989,17 +2480,16 @@ function loadMcpJson(cwd, opts = {}) {
   try {
     text = readFileSync(path, "utf8");
   } catch (err) {
-    throw new McpFileError(`failed to read ${path}: ${descrever(err)}`);
+    throw new McpFileError(`failed to read ${path}: ${describeIt(err)}`);
   }
   let parsed;
   try {
     parsed = JSON.parse(text);
   } catch (err) {
-    throw new McpFileError(`${path} is not valid JSON: ${descrever(err)}`);
+    throw new McpFileError(`${path} is not valid JSON: ${describeIt(err)}`);
   }
   return parseMcpJson(parsed, path, warningChannel(opts));
 }
-__name(loadMcpJson, "loadMcpJson");
 function parseMcpJson(raw, source, onWarn) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new McpFileError(`${source}: root must be a JSON object with an "mcpServers" key.`);
@@ -3011,91 +2501,82 @@ function parseMcpJson(raw, source, onWarn) {
   }
   const out = {};
   for (const [name, entryRaw] of Object.entries(serversRaw)) {
-    const motivo = validarEntrada(name, entryRaw);
-    if (motivo !== void 0) {
-      onWarn(`${source}: server "${name}" ignorado \u2014 ${motivo}`);
+    const reason = validateEntry(name, entryRaw);
+    if (reason !== void 0) {
+      onWarn(`${source}: server "${name}" ignored \u2014 ${reason}`);
       continue;
     }
     out[name] = buildEntry(entryRaw);
   }
   return out;
 }
-__name(parseMcpJson, "parseMcpJson");
-function validarEntrada(name, entryRaw) {
+function validateEntry(name, entryRaw) {
   if (typeof entryRaw !== "object" || entryRaw === null || Array.isArray(entryRaw)) {
-    return "a entrada deve ser um objeto.";
+    return "the entry must be an object.";
   }
   const entry = entryRaw;
-  const temUrl = entry.url !== void 0;
-  const temCommand = entry.command !== void 0;
-  if (temUrl && temCommand) return 'declara "command" e "url" ao mesmo tempo \u2014 escolha um transporte.';
-  if (!temUrl && !temCommand) return 'requer "command" (stdio) ou "url" (http/sse).';
-  return temUrl ? validarRemoto(entry) : validarStdio(entry);
-}
-__name(validarEntrada, "validarEntrada");
-function validarStdio(entry) {
+  const hasUrl = entry.url !== void 0;
+  const hasCommand = entry.command !== void 0;
+  if (hasUrl && hasCommand) return 'declares both "command" and "url" \u2014 pick one transport.';
+  if (!hasUrl && !hasCommand) return 'requires "command" (stdio) or "url" (http/sse).';
+  return hasUrl ? validateRemote(entry) : validateStdio(entry);
+}
+function validateStdio(entry) {
   if (typeof entry.command !== "string" || entry.command.length === 0) {
-    return 'campo "command" deve ser uma string n\xE3o vazia.';
-  }
-  if (entry.args !== void 0 && !isStringArray(entry.args)) return 'campo "args" deve ser array de strings.';
-  if (entry.env !== void 0 && !isStringRecord(entry.env)) return 'campo "env" deve ser um mapa de strings.';
-  if (entry.cwd !== void 0 && typeof entry.cwd !== "string") return 'campo "cwd" deve ser string.';
+    return 'field "command" must be a non-empty string.';
+  }
+  if (entry.args !== void 0 && !isStringArray(entry.args))
+    return 'field "args" must be an array of strings.';
+  if (entry.env !== void 0 && !isStringRecord(entry.env))
+    return 'field "env" must be a map of strings.';
+  if (entry.cwd !== void 0 && typeof entry.cwd !== "string")
+    return 'field "cwd" must be a string.';
   return void 0;
 }
-__name(validarStdio, "validarStdio");
-function validarRemoto(entry) {
+function validateRemote(entry) {
   if (typeof entry.url !== "string" || entry.url.length === 0) {
-    return 'campo "url" deve ser uma string n\xE3o vazia.';
+    return 'field "url" must be a non-empty string.';
   }
   try {
     new URL(entry.url);
   } catch {
-    return 'campo "url" n\xE3o \xE9 uma URL v\xE1lida.';
+    return 'field "url" is not a valid URL.';
   }
   if (entry.type !== void 0 && entry.type !== "http" && entry.type !== "sse") {
-    return 'campo "type" deve ser "http" ou "sse".';
+    return 'field "type" must be "http" or "sse".';
   }
   if (entry.headers !== void 0 && !isStringRecord(entry.headers)) {
-    return 'campo "headers" deve ser um mapa de strings.';
+    return 'field "headers" must be a map of strings.';
   }
   if (entry.requestTimeoutMs !== void 0 && typeof entry.requestTimeoutMs !== "number") {
-    return 'campo "requestTimeoutMs" deve ser n\xFAmero.';
+    return 'field "requestTimeoutMs" must be a number.';
   }
   return void 0;
 }
-__name(validarRemoto, "validarRemoto");
 function buildEntry(entry) {
   if (entry.url !== void 0) {
-    const remote = {
-      url: entry.url
-    };
+    const remote = { url: entry.url };
     if (entry.type !== void 0) remote.type = entry.type;
     if (entry.headers !== void 0) remote.headers = entry.headers;
     if (entry.auth !== void 0) remote.auth = entry.auth;
     if (entry.requestTimeoutMs !== void 0) remote.requestTimeoutMs = entry.requestTimeoutMs;
     return remote;
   }
-  const stdio = {
-    command: entry.command
-  };
+  const stdio = { command: entry.command };
   if (entry.args !== void 0) stdio.args = entry.args;
   if (entry.env !== void 0) stdio.env = entry.env;
   if (entry.cwd !== void 0) stdio.cwd = entry.cwd;
   return stdio;
 }
-__name(buildEntry, "buildEntry");
-function descrever(err) {
+function describeIt(err) {
   return err instanceof Error ? err.message : String(err);
 }
-__name(descrever, "descrever");
 function isStringArray(v) {
   return Array.isArray(v) && v.every((x) => typeof x === "string");
 }
-__name(isStringArray, "isStringArray");
 function isStringRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((x) => typeof x === "string");
 }
-__name(isStringRecord, "isStringRecord");
 
 // src/manifest/agent-manifest.ts
 function generateAgentManifest(sources) {
@@ -3113,15 +2594,17 @@ function generateAgentManifest(sources) {
       },
       guards: r.guards.map((g) => g.name),
       interceptors: r.interceptors.map((i) => i.name),
-      tools: r.toolboxes.flatMap((tb) => tb.tools.map((t) => ({
-        name: tb.namespace ? `${tb.namespace}.${t.config.name}` : t.config.name,
-        description: t.config.description,
-        risk: t.config.risk,
-        approval: t.approval !== void 0,
-        capabilities: t.capabilities,
-        trace: t.trace,
-        audit: t.audit
-      }))),
+      tools: r.toolboxes.flatMap(
+        (tb) => tb.tools.map((t) => ({
+          name: tb.namespace ? `${tb.namespace}.${t.config.name}` : t.config.name,
+          description: t.config.description,
+          risk: t.config.risk,
+          approval: t.approval !== void 0,
+          capabilities: t.capabilities,
+          trace: t.trace,
+          audit: t.audit
+        }))
+      ),
       gateway: r.gateway ? {
         platforms: r.gateway.platforms,
         sessionStrategy: r.gateway.sessionStrategy ?? "per-user"
@@ -3138,7 +2621,6 @@ function generateAgentManifest(sources) {
     }))
   };
 }
-__name(generateAgentManifest, "generateAgentManifest");
 
 // src/theokit-plugin.ts
 function validateUniqueRoutes(results) {
@@ -3146,12 +2628,13 @@ function validateUniqueRoutes(results) {
   for (const r of results) {
     const existing = seen.get(r.route);
     if (existing !== void 0) {
-      throw new Error(`[@theokit/agents] Duplicate agent route '${r.route}': both '${existing}' and '${r.agentConfig.name}' declare it.`);
+      throw new Error(
+        `[@theokit/agents] Duplicate agent route '${r.route}': both '${existing}' and '${r.agentConfig.name}' declare it.`
+      );
     }
     seen.set(r.route, r.agentConfig.name);
   }
 }
-__name(validateUniqueRoutes, "validateUniqueRoutes");
 function agentsPlugin(opts) {
   let routes = null;
   return {
@@ -3169,30 +2652,23 @@ function agentsPlugin(opts) {
     }
   };
 }
-__name(agentsPlugin, "agentsPlugin");
 function initRoutes(opts) {
   const allRoutes = [];
   const routeIdentities = [];
   for (const entry of opts.agents) {
-    routeIdentities.push({
-      route: entry.route,
-      agentConfig: {
-        name: entry.name
-      }
-    });
+    routeIdentities.push({ route: entry.route, agentConfig: { name: entry.name } });
     const createRun = opts.createRunFactory ? opts.createRunFactory(entry.compiled) : defaultCreateRun(entry.compiled);
-    allRoutes.push(...generateAgentRoutes({
-      walkResult: {
-        route: entry.route
-      },
-      compiledOptions: entry.compiled,
-      createRun
-    }));
+    allRoutes.push(
+      ...generateAgentRoutes({
+        walkResult: { route: entry.route },
+        compiledOptions: entry.compiled,
+        createRun
+      })
+    );
   }
   validateUniqueRoutes(routeIdentities);
   return compileRoutePatterns(allRoutes);
 }
-__name(initRoutes, "initRoutes");
 function defaultCreateRun(compiled) {
   return async function* (_message, _sessionId) {
     await Promise.resolve();
@@ -3209,18 +2685,13 @@ function defaultCreateRun(compiled) {
     };
   };
 }
-__name(defaultCreateRun, "defaultCreateRun");
 function compileRoutePatterns(routes) {
   return routes.map((r) => {
     if (!r.path.includes(":")) return r;
     const regexSource = r.path.replace(/:[^/]+/g, "[^/]+");
-    return {
-      ...r,
-      regex: RegExp(`^${regexSource}$`)
-    };
+    return { ...r, regex: RegExp(`^${regexSource}$`) };
   });
 }
-__name(compileRoutePatterns, "compileRoutePatterns");
 function matchRoute(routes, method, pathname) {
   return routes.find((r) => {
     if (r.method !== method) return false;
@@ -3228,7 +2699,6 @@ function matchRoute(routes, method, pathname) {
     return r.path === pathname;
   });
 }
-__name(matchRoute, "matchRoute");
 
 export {
   ConfigurationError,
@@ -3309,4 +2779,4 @@ export {
   generateAgentManifest,
   agentsPlugin
 };
-//# sourceMappingURL=chunk-7ECCHM4N.js.map
+//# sourceMappingURL=chunk-PHUNONZT.js.map