@sentry/junior 0.121.0 → 0.122.0

package/dist/{chunk-VWBKDPMQ.js → chunk-NIJG6G6X.js}

@@ -30,15 +30,18 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-3DBMANUI.js";
+} from "./chunk-VCC7XFX2.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
+  NO_REPLY_MARKER,
   TURN_CONTEXT_TAG,
   TurnInputCommitLostError,
   TurnSliceLimitExceededError,
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
+  containsNoReplyMarker,
+  decideReply,
   estimateTextTokens,
   extractAssistantText,
   getAgentContextCompactionTriggerTokens,
@@ -49,6 +52,7 @@ import {
   historyItemFromPiMessage,
   isAssistantMessage,
   isContinuablePiBoundary,
+  isNoReplyMarker,
   isToolResultError,
   isToolResultMessage,
   isTurnInputCommitLostError,
@@ -69,10 +73,11 @@ import {
   recordToolExecutionStarted,
   recordTurnRoute,
   retainRuntimeTurnContext,
+  sanitizeAssistantText,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-Z2XXPUZG.js";
+} from "./chunk-NNGYYGX5.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -96,10 +101,10 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-ITMEXX5H.js";
+} from "./chunk-CYW4M6IV.js";
 import {
   incrementStat
-} from "./chunk-XDRGYDED.js";
+} from "./chunk-32FPGM2V.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -121,7 +126,7 @@ import {
   normalizeSlackConversationId,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-7HYV7KFM.js";
+} from "./chunk-USKP7IM2.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -130,7 +135,7 @@ import {
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-254MFDOF.js";
+} from "./chunk-DOB5RVMH.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -140,7 +145,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-UURFXX66.js";
+} from "./chunk-TZVZCIYL.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -171,7 +176,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-IDXLBKPS.js";
+} from "./chunk-2RFM7STT.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
@@ -182,16 +187,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-HDFGNU5E.js";
+} from "./chunk-S7G34U75.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-TRECK7RV.js";
+} from "./chunk-E5SRLZQV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-WUP7NWMP.js";
+} from "./chunk-OKUZIXQM.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -199,7 +204,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-ET2SDCNV.js";
+} from "./chunk-GN6WW7WR.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -223,7 +228,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-JZ47AFSH.js";
+} from "./chunk-4SPRQJOW.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
@@ -320,7 +325,9 @@ function shouldPropagateSandboxEgressTrace(host, config = {}) {
 }
 
 // src/chat/agent/index.ts
-import { Agent } from "@earendil-works/pi-agent-core";
+import {
+  Agent
+} from "@earendil-works/pi-agent-core";
 
 // src/chat/sandbox/skill-sandbox.ts
 import fs from "fs/promises";
@@ -661,103 +668,6 @@ function shouldEmitDevAgentTrace() {
 
 // src/chat/services/turn-result.ts
 import { isRetryableAssistantError } from "@earendil-works/pi-ai";
-
-// src/chat/no-reply.ts
-var NO_REPLY_MARKER = "[[NO_REPLY]]";
-function isNoReplyMarker(text) {
-  return text.trim() === NO_REPLY_MARKER;
-}
-function containsNoReplyMarker(text) {
-  return text.includes(NO_REPLY_MARKER);
-}
-
-// src/chat/services/turn-result.ts
-function isExecutionDeferralResponse(text) {
-  return /\b(want me to proceed|do you want me to proceed|shall i proceed|can i proceed|should i proceed|let me do that now|give me a moment|tag me again|fresh invocation)\b/i.test(
-    text
-  );
-}
-function isToolAccessDisclaimerResponse(text) {
-  return /\b(i (don't|do not) have access to (active )?tool|tool results came back empty|prior results .* empty|cannot access .*tool|need to (run|load) .*tool .* first)\b/i.test(
-    text
-  );
-}
-function isExecutionEscapeResponse(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return false;
-  return isExecutionDeferralResponse(trimmed) || isToolAccessDisclaimerResponse(trimmed);
-}
-function parseJsonCandidate(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return void 0;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
-    if (!fenced) return void 0;
-    try {
-      return JSON.parse(fenced[1]);
-    } catch {
-      return void 0;
-    }
-  }
-}
-function isToolPayloadShape(payload) {
-  if (!payload || typeof payload !== "object") return false;
-  const record = payload;
-  const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
-  if (type.startsWith("tool-")) return true;
-  if (type === "tool_use" || type === "tool_call" || type === "tool_result" || type === "tool_error")
-    return true;
-  const hasToolName = typeof record.toolName === "string" || typeof record.name === "string";
-  const hasToolInput = Object.prototype.hasOwnProperty.call(record, "input") || Object.prototype.hasOwnProperty.call(record, "args");
-  if (hasToolName && hasToolInput) return true;
-  return false;
-}
-function isRawToolPayloadResponse(text) {
-  const parsed = parseJsonCandidate(text);
-  if (Array.isArray(parsed)) {
-    return parsed.some((entry) => isToolPayloadShape(entry));
-  }
-  if (isToolPayloadShape(parsed)) {
-    return true;
-  }
-  return false;
-}
-var THINKING_XML_BLOCK_PATTERN = /[ \t]*<thinking\b[^>]*>[\s\S]*?<\/thinking>[ \t]*(?:\r?\n)?/gi;
-var FENCED_CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
-function stripThinkingXmlBlocks(text) {
-  let result = "";
-  let cursor = 0;
-  for (const match of text.matchAll(FENCED_CODE_BLOCK_PATTERN)) {
-    const start = match.index;
-    if (start === void 0) {
-      continue;
-    }
-    result += text.slice(cursor, start).replace(THINKING_XML_BLOCK_PATTERN, "");
-    result += match[0];
-    cursor = start + match[0].length;
-  }
-  result += text.slice(cursor).replace(THINKING_XML_BLOCK_PATTERN, "");
-  return result;
-}
-function getVisibleAssistantText(rawText) {
-  const text = stripThinkingXmlBlocks(rawText).trim();
-  if (!text || isNoReplyMarker(text) || containsNoReplyMarker(text) || isRawToolPayloadResponse(text)) {
-    return void 0;
-  }
-  return text;
-}
-function getAssistantMessageText(message) {
-  if (message.content.some((part) => part.type === "toolCall")) {
-    return void 0;
-  }
-  const text = getVisibleAssistantText(extractAssistantText(message));
-  if (!text) {
-    return void 0;
-  }
-  return isExecutionEscapeResponse(text) ? void 0 : text;
-}
 function buildTurnResult(input) {
   const {
     newMessages,
@@ -766,74 +676,53 @@ function buildTurnResult(input) {
     sandboxRef,
     durationMs,
     shouldTrace,
-    spanContext,
     usage,
     executionProfile,
-    assistantUserName,
     modelId
   } = input;
   const toolResults = newMessages.filter(isToolResultMessage);
   const assistantMessages = newMessages.filter(isAssistantMessage);
   const terminalAssistantMessages = getTerminalAssistantMessages(newMessages);
-  const rawPrimaryText = stripThinkingXmlBlocks(
+  const rawPrimaryText = sanitizeAssistantText(
     terminalAssistantMessages.map((message) => extractAssistantText(message)).join("\n\n")
   ).trim();
   const exactNoReplyMarker = isNoReplyMarker(rawPrimaryText);
   const mixedNoReplyMarker = !exactNoReplyMarker && containsNoReplyMarker(rawPrimaryText);
   const noReplyRequested = exactNoReplyMarker || mixedNoReplyMarker;
-  const primaryText = noReplyRequested ? "" : terminalAssistantMessages.map((message) => getAssistantMessageText(message)).filter((text) => Boolean(text)).join("\n\n");
+  const primaryText = noReplyRequested ? "" : terminalAssistantMessages.map((message) => decideReply(message)).filter(
+    (output) => output.kind === "deliver"
+  ).map((output) => output.text).join("\n\n");
   const toolErrorCount = toolResults.filter((result) => result.isError).length;
   const reactionPerformed = toolResults.some(
     (result) => !isToolResultError(result) && normalizeToolNameFromResult(result) === "addReaction"
   );
   const completedWithoutTerminalText = noReplyRequested;
-  const resultLogContext = {
-    ...spanContext,
-    assistantUserName,
-    modelId
-  };
   const lastAssistant = terminalAssistantMessages.at(-1);
   const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
   const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
   const isProviderError = stopReason === "error";
   if (exactNoReplyMarker) {
     const markerCategory = reactionPerformed ? "reaction" : "none";
-    const markerContext = resultLogContext;
     const markerAttributes = {
       "app.ai.no_reply_marker": true,
       "app.ai.no_reply_marker_category": markerCategory,
       "app.ai.no_reply_marker_accepted": !isProviderError
     };
     if (!isProviderError) {
-      logInfo(
-        "ai_no_reply_marker_accepted",
-        markerContext,
-        markerAttributes,
-        "No-reply marker suppressed visible thread text"
-      );
+      logInfo("ai.no_reply_marker.accepted", markerAttributes);
     }
   } else if (mixedNoReplyMarker) {
-    logWarn(
-      "ai_no_reply_marker_mixed_text",
-      resultLogContext,
-      {
-        "app.ai.no_reply_marker": true,
-        "app.ai.no_reply_marker_mode": "mixed"
-      },
-      "No-reply marker appeared with visible assistant text"
-    );
+    logWarn("ai.no_reply_marker.mixed_text", {
+      "app.ai.no_reply_marker": true,
+      "app.ai.no_reply_marker_mode": "mixed"
+    });
   }
   if (!primaryText && !completedWithoutTerminalText && !isProviderError) {
-    logWarn(
-      "ai_model_response_empty",
-      resultLogContext,
-      {
-        "app.ai.tool_results": toolResults.length,
-        "app.ai.tool_error_results": toolErrorCount,
-        "app.ai.generated_files": input.generatedFileCount
-      },
-      "Model returned empty text response"
-    );
+    logWarn("ai.model_response.empty", {
+      "app.ai.tool_results": toolResults.length,
+      "app.ai.tool_error_results": toolErrorCount,
+      "app.ai.generated_files": input.generatedFileCount
+    });
   }
   const usedPrimaryText = Boolean(rawPrimaryText);
   let outcome;
@@ -844,24 +733,19 @@ function buildTurnResult(input) {
   } else {
     outcome = "execution_failure";
   }
-  const rejectedPrimaryText = Boolean(
+  const suppressedPrimaryText = Boolean(
     rawPrimaryText && !noReplyRequested && !primaryText
   );
-  const resolvedOutcome = rejectedPrimaryText ? "execution_failure" : outcome;
+  const resolvedOutcome = suppressedPrimaryText ? "execution_failure" : outcome;
   if (shouldTrace) {
-    logInfo(
-      "agent_message_out",
-      spanContext,
-      {
-        "app.message.kind": "assistant_outbound",
-        "app.message.length": primaryText.length,
-        "app.message.output": summarizeMessageText(primaryText),
-        "app.ai.outcome": resolvedOutcome,
-        "app.ai.assistant_messages": assistantMessages.length,
-        ...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : {}
-      },
-      "Agent message sent"
-    );
+    logInfo("agent.message.generated", {
+      "app.message.kind": "assistant_outbound",
+      "app.message.length": primaryText.length,
+      "app.message.output": summarizeMessageText(primaryText),
+      "app.ai.outcome": resolvedOutcome,
+      "app.ai.assistant_messages": assistantMessages.length,
+      ...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : {}
+    });
   }
   const resolvedDiagnostics = {
     outcome: resolvedOutcome,
@@ -924,6 +808,45 @@ function nextProviderRetry(args) {
   return { delayMs, messages };
 }
 
+// src/chat/services/empty-output-continuation.ts
+function nextEmptyOutputContinuation(args) {
+  if (!hasCompactedConversationContext(args.messages)) {
+    return { kind: "none" };
+  }
+  if (args.lastAssistant?.stopReason === "error" || args.lastAssistant?.stopReason === "aborted") {
+    return { kind: "none" };
+  }
+  if (args.lastAssistant && decideReply(args.lastAssistant).kind !== "empty") {
+    return { kind: "none" };
+  }
+  if (args.attempt > 0) {
+    return { kind: "exhausted" };
+  }
+  if (!args.lastAssistant) {
+    return isContinuablePiBoundary(args.messages) ? {
+      kind: "retry",
+      messages: [...args.messages]
+    } : { kind: "exhausted" };
+  }
+  if (args.messages.at(-1) !== args.lastAssistant) {
+    return { kind: "exhausted" };
+  }
+  const messages = args.messages.slice(0, -1);
+  return isContinuablePiBoundary(messages) ? { kind: "retry", messages } : { kind: "exhausted" };
+}
+
+// src/chat/agent/retry-usage.ts
+function getDiscardedRetryUsage(messages, retryMessages) {
+  const keepsExactPrefix = retryMessages.length <= messages.length && retryMessages.every((message, index) => message === messages[index]);
+  if (!keepsExactPrefix) {
+    throw new Error("Agent retry must retain an exact message prefix");
+  }
+  const usage = extractGenAiUsageSummary(
+    ...messages.slice(retryMessages.length).filter(isAssistantMessage)
+  );
+  return hasAgentTurnUsage(usage) ? usage : void 0;
+}
+
 // src/chat/tool-support/structured-result.ts
 import { z } from "zod";
 var juniorToolContinuationSchema = z.object({
@@ -1262,20 +1185,9 @@ async function classifyTurn(args) {
       source: "router"
     };
   } catch (error) {
-    logWarn(
-      "turn_router_classifier_failed",
-      {
-        messageConversationId: args.metadata.threadId,
-        destinationName: args.metadata.channelId,
-        userId: args.metadata.actorId,
-        runId: args.metadata.runId,
-        modelId: args.fastModelId
-      },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Turn router classifier failed; using the default route"
-    );
+    logWarn("turn.router.classifier.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return {
       profile: STANDARD_MODEL_PROFILE,
       reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
@@ -1509,18 +1421,13 @@ async function discoverRunSkills(args) {
     const roots = [
       ...new Set(availableSkills.map((skill) => skill.skillPath))
     ].sort();
-    logInfo(
-      "startup_discovery_summary",
-      args.spanContext,
-      {
-        "app.skill.count": availableSkills.length,
-        "app.skill.names": availableSkills.map((skill) => skill.name).sort(),
-        "app.file.directories": roots,
-        "app.plugin.count": plugins.length,
-        "app.plugin.names": plugins.map((plugin) => plugin.manifest.name).sort()
-      },
-      "Discovered startup SOUL/skills/plugins"
-    );
+    logInfo("startup.discovery.completed", {
+      "app.skill.count": availableSkills.length,
+      "app.skill.names": availableSkills.map((skill) => skill.name).sort(),
+      "app.file.directories": roots,
+      "app.plugin.count": plugins.length,
+      "app.plugin.names": plugins.map((plugin) => plugin.manifest.name).sort()
+    });
   }
   return availableSkills;
 }
@@ -1557,7 +1464,7 @@ function getLoggedMarkdownFiles() {
   globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
   return globalState.__juniorLoggedMarkdownFiles;
 }
-function loadOptionalMarkdownFile(candidates, fileName) {
+function loadOptionalMarkdownFile(candidates, fileName, loadedEventName) {
   for (const resolved of candidates) {
     try {
       const raw = fs2.readFileSync(resolved, "utf8").trim();
@@ -1566,14 +1473,9 @@ function loadOptionalMarkdownFile(candidates, fileName) {
         const logKey = `${fileName}:${resolved}`;
         if (!loggedMarkdownFiles.has(logKey)) {
           loggedMarkdownFiles.add(logKey);
-          logInfo(
-            `${fileName.toLowerCase()}_loaded`,
-            {},
-            {
-              "file.path": resolved
-            },
-            `Loaded ${fileName}`
-          );
+          logInfo(loadedEventName, {
+            "file.path": resolved
+          });
         }
         return raw;
       }
@@ -1584,35 +1486,33 @@ function loadOptionalMarkdownFile(candidates, fileName) {
   return null;
 }
 function loadSoul() {
-  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
+  const soul = loadOptionalMarkdownFile(
+    soulPathCandidates(),
+    "SOUL.md",
+    "soul.loaded"
+  );
   if (soul) {
     return soul;
   }
-  logWarn(
-    "soul_load_fallback",
-    {},
-    {
-      "app.file.candidates": soulPathCandidates()
-    },
-    "SOUL.md not found; using built-in default personality"
-  );
+  logWarn("soul.load.defaulted", {
+    "app.file.candidates": soulPathCandidates()
+  });
   return DEFAULT_SOUL;
 }
 function loadWorld() {
-  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+  return loadOptionalMarkdownFile(
+    worldPathCandidates(),
+    "WORLD.md",
+    "world.loaded"
+  );
 }
 var JUNIOR_PERSONALITY = (() => {
   try {
     return loadSoul();
   } catch (error) {
-    logWarn(
-      "soul_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load SOUL.md; using built-in default personality"
-    );
+    logWarn("soul.load.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return DEFAULT_SOUL;
   }
 })();
@@ -1620,14 +1520,9 @@ var JUNIOR_WORLD = (() => {
   try {
     return loadWorld();
   } catch (error) {
-    logWarn(
-      "world_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load WORLD.md; omitting world prompt context"
-    );
+    logWarn("world.load.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return null;
   }
 })();
@@ -1828,7 +1723,7 @@ var SAFETY_RULES = [
 var FAILURE_RULES = [
   "- For tool/runtime failures, run the named check before diagnosing and report the exact failed command plus stderr/exit code.",
   "- If a fact cannot be verified after focused checks, say what you checked and what blocked a stronger answer.",
-  "- Do not surface raw tool payloads, execution-escape text, or internal routing metadata as the final answer."
+  "- Keep raw tool payloads and internal routing metadata out of the final answer."
 ];
 function renderRuleSection(tag, lines) {
   return [`<${tag}>`, ...lines, `</${tag}>`].join("\n");
@@ -2559,17 +2454,12 @@ ${usage}
         updatedBy: deps.actorId,
         source: "jr-rpc"
       });
-      logInfo(
-        "jr_rpc_config_set",
-        {},
-        {
-          "app.config.key": entry.key,
-          "app.config.scope": entry.scope,
-          "app.config.source": entry.source ?? "jr-rpc",
-          ...deps.activeSkill?.name ? { "app.skill.name": deps.activeSkill.name } : {}
-        },
-        "Set channel configuration via jr-rpc"
-      );
+      logInfo("jr_rpc.config.updated", {
+        "app.config.key": entry.key,
+        "app.config.scope": entry.scope,
+        "app.config.source": entry.source ?? "jr-rpc",
+        ...deps.activeSkill?.name ? { "app.skill.name": deps.activeSkill.name } : {}
+      });
       deps.onConfigurationValueChanged?.(entry.key, entry.value);
       return commandResult({
         stdout: {
@@ -2604,15 +2494,10 @@ ${usage}
     }
     const deleted = await configuration.unset(key);
     if (deleted) {
-      logInfo(
-        "jr_rpc_config_unset",
-        {},
-        {
-          "app.config.key": key,
-          ...deps.activeSkill?.name ? { "app.skill.name": deps.activeSkill.name } : {}
-        },
-        "Unset channel configuration via jr-rpc"
-      );
+      logInfo("jr_rpc.config.removed", {
+        "app.config.key": key,
+        ...deps.activeSkill?.name ? { "app.skill.name": deps.activeSkill.name } : {}
+      });
       deps.onConfigurationValueChanged?.(key, void 0);
     }
     return commandResult({
@@ -3563,17 +3448,13 @@ function createSandboxRuntime(options) {
       } : {},
       ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
     });
-    logInfo(
-      "sandbox_hint_discarded_profile_mismatch",
-      traceContext,
-      {
-        ...sandboxRef.profileHash ? {
-          "app.sandbox.previous_profile_hash": sandboxRef.profileHash
-        } : {},
-        ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
-      },
-      "Dependency profile changed; discarding sandbox hint and creating fresh session"
-    );
+    logInfo("sandbox.hint.discarded", {
+      "app.decision.reason": "dependency_profile_mismatch",
+      ...sandboxRef.profileHash ? {
+        "app.sandbox.previous_profile_hash": sandboxRef.profileHash
+      } : {},
+      ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+    });
     sandboxRef = void 0;
   };
   const tryReuseCachedSandbox = async () => {
@@ -4294,6 +4175,19 @@ import { z as z3 } from "zod";
 function isContentOnlyToolResult(value) {
   return value !== null && typeof value === "object" && Array.isArray(value.content) && !("details" in value);
 }
+function isStructuredToolResultEnvelope(value) {
+  return value !== null && typeof value === "object" && Array.isArray(value.content) && "details" in value;
+}
+function parseToolContent(content) {
+  for (const item of content) {
+    if (!item || typeof item !== "object" || (item.type === "text" ? typeof item.text !== "string" : item.type === "image" ? typeof item.data !== "string" || typeof item.mimeType !== "string" : true)) {
+      throw new TypeError(
+        "zodTool() content must contain valid text or image items."
+      );
+    }
+  }
+  return content;
+}
 function formatZodPath(path9) {
   return path9.length > 0 ? path9.map(String).join(".") : "root";
 }
@@ -4356,6 +4250,14 @@ function zodTool(definition) {
             "zodTool() content-only tools must return { content } without details."
           );
         }
+        if (isStructuredToolResultEnvelope(result)) {
+          return {
+            content: parseToolContent(result.content),
+            details: outputSchema.parse(
+              juniorToolResultSchema.parse(result.details)
+            )
+          };
+        }
         return outputSchema.parse(juniorToolResultSchema.parse(result));
       }
     } : {}
@@ -5434,15 +5336,10 @@ function createSandbox(options) {
     if (runtime.sandboxRef()) {
       return;
     }
-    logInfo(
-      "sandbox_boot_requested",
-      traceContext,
-      {
-        "app.sandbox.boot.trigger": trigger,
-        ...details
-      },
-      "Sandbox boot requested"
-    );
+    logInfo("sandbox.boot.requested", {
+      "app.sandbox.boot.trigger": trigger,
+      ...details
+    });
   };
   const executeBashTool = async (rawInput, command, context) => {
     const env = parseEnv(rawInput.env);
@@ -6747,12 +6644,7 @@ var McpToolManager = class {
               };
               setSpanAttributes(errorAttributes);
               if (error instanceof McpToolError) {
-                logWarn(
-                  "mcp_tool_call_failed",
-                  {},
-                  errorAttributes,
-                  "MCP tool call failed"
-                );
+                logWarn("mcp.tool_call.failed", errorAttributes);
               }
               throw error;
             }
@@ -6908,22 +6800,16 @@ async function enrichImagePrompt(rawPrompt) {
       maxTokens: 1024
     });
     if (text && text.trim().length > 0) {
-      logInfo(
-        "image_prompt_enriched",
-        {},
-        { "app.image.enriched_prompt_length": text.trim().length },
-        "Image prompt enriched with persona"
-      );
+      logInfo("image.prompt.enriched", {
+        "app.image.enriched_prompt_length": text.trim().length
+      });
       return text.trim();
     }
     return rawPrompt;
   } catch (error) {
-    logWarn(
-      "image_prompt_enrichment_failed",
-      {},
-      { "exception.message": String(error) },
-      "Image prompt enrichment failed, using raw prompt"
-    );
+    logWarn("image.prompt.enrichment.failed", {
+      "exception.message": String(error)
+    });
     return rawPrompt;
   }
 }
@@ -9002,18 +8888,13 @@ async function grantChannelCanvasAccess(canvasId, channelId) {
         }
       }
     );
-  } catch (error) {
-    logWarn(
-      "slack_canvas_access_set_failed",
-      {},
-      {
-        "app.slack.action": "canvases.access.set",
-        "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
-        "app.slack.canvas.channel_id_prefix": channelId.slice(0, 1),
-        "app.slack.canvas.access_level": "write"
-      },
-      error instanceof Error ? error.message : "Failed to grant channel access to canvas"
-    );
+  } catch {
+    logWarn("slack.canvas.access_set.failed", {
+      "app.slack.action": "canvases.access.set",
+      "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
+      "app.slack.canvas.channel_id_prefix": channelId.slice(0, 1),
+      "app.slack.canvas.access_level": "write"
+    });
   }
 }
 async function writeCanvasMarkdown(input) {
@@ -9150,16 +9031,11 @@ function createSlackCanvasCreateTool(context, state) {
     execute: async ({ title, markdown }) => {
       const targetChannelId = context.destinationChannelId;
       if (!isConversationScopedChannel(targetChannelId)) {
-        logError(
-          "slack_canvas_create_invalid_context",
-          {},
-          {
-            "gen_ai.tool.name": "slackCanvasCreate",
-            "messaging.destination.name": targetChannelId ?? "none",
-            "app.slack.canvas.has_channel_context": Boolean(targetChannelId)
-          },
-          "Canvas create failed due to missing or invalid assistant channel context"
-        );
+        logError("slack.canvas.create.context_invalid", {
+          "gen_ai.tool.name": "slackCanvasCreate",
+          "messaging.destination.name": targetChannelId ?? "none",
+          "app.slack.canvas.has_channel_context": Boolean(targetChannelId)
+        });
         throw new Error(
           "Cannot create a canvas without an active assistant channel context (C/G/D)."
         );
@@ -9292,15 +9168,10 @@ function createSlackCanvasEditTool(state) {
         return response;
       } catch (error) {
         const message = error instanceof Error ? error.message : "canvas edit failed";
-        logWarn(
-          "slack_canvas_edit_failed",
-          {},
-          {
-            "gen_ai.tool.name": "slackCanvasEdit",
-            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
-          },
-          message
-        );
+        logWarn("slack.canvas.edit.failed", {
+          "gen_ai.tool.name": "slackCanvasEdit",
+          "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
+        });
         return {
           ok: false,
           status: "error",
@@ -9371,15 +9242,10 @@ function createSlackCanvasReadTool() {
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : "canvas read failed";
-        logWarn(
-          "slack_canvas_read_failed",
-          {},
-          {
-            "gen_ai.tool.name": "slackCanvasRead",
-            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
-          },
-          message
-        );
+        logWarn("slack.canvas.read.failed", {
+          "gen_ai.tool.name": "slackCanvasRead",
+          "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
+        });
         return {
           ok: false,
           status: "error",
@@ -9438,15 +9304,10 @@ function createSlackCanvasWriteTool(state) {
         return response;
       } catch (error) {
         const message = error instanceof Error ? error.message : "canvas write failed";
-        logWarn(
-          "slack_canvas_write_failed",
-          {},
-          {
-            "gen_ai.tool.name": "slackCanvasWrite",
-            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
-          },
-          message
-        );
+        logWarn("slack.canvas.write.failed", {
+          "gen_ai.tool.name": "slackCanvasWrite",
+          "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
+        });
         return {
           ok: false,
           status: "error",
@@ -10494,6 +10355,10 @@ function createSystemTimeTool() {
 import { z as z37 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
+var MAX_EVENT_DATA_BYTES = 4e3;
+var MAX_EVENTS_JSON_BYTES = 2e4;
+var MAX_IDENTITY_CHARS = 256;
+var textEncoder = new TextEncoder();
 var CONVERSATION_EVENTS_TOOL_SOURCE = {
   id: "conversation-events",
   description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
@@ -10507,7 +10372,7 @@ var projectedEventSchema = z37.object({
   created_at: z37.iso.datetime().describe("When the event was recorded."),
   idempotency_key: z37.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
   data: z37.record(z37.string(), z37.unknown()).describe(
-    "Event payload. The type field identifies the event; replacement-history events report replacement_history_count instead of replaying the full model context."
+    "Event data. Oversized payloads are replaced by identifying fields, payload_omitted, and payload_json_bytes."
   )
 }).strict();
 var queryConversationEventsOutputSchema = juniorToolResultSchema.extend({
@@ -10518,6 +10383,9 @@ var queryConversationEventsOutputSchema = juniorToolResultSchema.extend({
   ),
   has_newer: z37.boolean().describe(
     "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
+  ),
+  omitted_event_count: z37.number().int().nonnegative().optional().describe(
+    "Fetched events omitted to keep this response bounded. Continue with the pagination cursor for the omitted direction."
   )
 });
 function createQueryConversationEventsTool(context) {
@@ -10597,14 +10465,17 @@ function createQueryConversationEventsTool(context) {
         ...beforeSeq === void 0 ? {} : { beforeSeq },
         ...types === void 0 ? {} : { types }
       });
-      const events = projectEventsForTool(page);
+      const newestFirst = afterSeq === void 0;
+      const projected = projectEventsForTool(page, { newestFirst });
       return {
         ok: true,
         status: "success",
         conversation_id: conversationId,
-        events,
-        has_older: page.hasOlder,
-        has_newer: page.hasNewer
+        events: projected.events,
+        has_older: page.hasOlder || newestFirst && projected.omittedEventCount > 0,
+        has_newer: page.hasNewer || !newestFirst && projected.omittedEventCount > 0,
+        truncated: projected.omittedEventCount > 0,
+        ...projected.omittedEventCount > 0 ? { omitted_event_count: projected.omittedEventCount } : {}
       };
     }
   });
@@ -10689,11 +10560,30 @@ function assertCanQueryConversationEvents(args) {
     `Conversation events are not accessible: ${targetConversationId}`
   );
 }
-function projectEventsForTool(page) {
-  return page.events.map(projectEvent);
+function projectEventsForTool(page, options) {
+  const projected = page.events.map(projectEvent);
+  const events = [];
+  let jsonBytes = 2;
+  const candidates = options.newestFirst ? [...projected].reverse() : projected;
+  for (const event of candidates) {
+    const eventBytes = jsonByteLength(event);
+    const separatorBytes = events.length === 0 ? 0 : 1;
+    if (jsonBytes + separatorBytes + eventBytes > MAX_EVENTS_JSON_BYTES) {
+      break;
+    }
+    events.push(event);
+    jsonBytes += separatorBytes + eventBytes;
+  }
+  if (options.newestFirst) {
+    events.reverse();
+  }
+  return {
+    events,
+    omittedEventCount: projected.length - events.length
+  };
 }
 function projectEvent(event) {
-  const data = stripReplacementHistory(event.data);
+  const data = boundEventData(stripReplacementHistory(event.data));
   return {
     seq: event.seq,
     history_version: event.historyVersion,
@@ -10702,6 +10592,46 @@ function projectEvent(event) {
     data
   };
 }
+function boundEventData(data) {
+  const payloadJsonBytes = jsonByteLength(data);
+  if (payloadJsonBytes <= MAX_EVENT_DATA_BYTES) {
+    return data;
+  }
+  return {
+    ...eventIdentity(data),
+    payload_omitted: true,
+    payload_json_bytes: payloadJsonBytes
+  };
+}
+function jsonByteLength(value) {
+  return textEncoder.encode(JSON.stringify(value)).byteLength;
+}
+function eventIdentity(data) {
+  const identityKeys = [
+    "type",
+    "originalType",
+    "messageId",
+    "role",
+    "turnId",
+    "toolCallId",
+    "toolName",
+    "subagentInvocationId",
+    "subagentKind",
+    "childConversationId",
+    "outcome",
+    "failureCode",
+    "provider",
+    "kind",
+    "modelProfile",
+    "modelId"
+  ];
+  return Object.fromEntries(
+    identityKeys.flatMap((key) => {
+      const value = data[key];
+      return typeof value === "string" ? [[key, value.slice(0, MAX_IDENTITY_CHARS)]] : [];
+    })
+  );
+}
 function stripReplacementHistory(data) {
   if (data.type === "unknown") {
     return {
@@ -11368,18 +11298,12 @@ function createWebSearchTool(modelId, override) {
         const message = formatSearchFailure(error);
         const timeout = /timed out/i.test(message);
         const retryable = !isAuthFailure(message);
-        logException(
-          error,
-          "web_search_failed",
-          {},
-          {
-            "gen_ai.tool.name": "webSearch",
-            "app.web_search.timeout": timeout,
-            "app.web_search.retryable": retryable,
-            "app.web_search.query": query
-          },
-          message
-        );
+        logException(error, "web.search.failed", {
+          "gen_ai.tool.name": "webSearch",
+          "app.web_search.timeout": timeout,
+          "app.web_search.retryable": retryable,
+          "app.web_search.query": query
+        });
         return {
           ok: false,
           status: "error",
@@ -12097,7 +12021,7 @@ function getToolErrorAttributes(error) {
     ...error.detailRule ? { "app.slack.detail_rule": error.detailRule } : {}
   };
 }
-function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext, conversationPrivacy, setExecutionSpanAttributes) {
+function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conversationPrivacy, setExecutionSpanAttributes) {
   const errorType = getToolErrorType(error);
   const errorMessage = getMcpAwareTelemetryMessage(error, conversationPrivacy);
   const errorAttributes = {
@@ -12113,50 +12037,34 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
   }
   if (error instanceof PluginCredentialFailureError) {
     if (shouldTrace) {
-      logInfo(
-        "plugin_credential_rejected",
-        traceContext,
-        {
-          "app.credential.provider": error.provider,
-          "gen_ai.operation.name": "execute_tool",
-          "gen_ai.tool.name": toolName,
-          ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-          "error.type": errorType
-        },
-        "Plugin credentials were rejected during tool execution"
-      );
+      logInfo("plugin.credential.rejected", {
+        "app.credential.provider": error.provider,
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": toolName,
+        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        "error.type": errorType
+      });
     }
     throw error;
   }
   if (shouldTrace) {
-    logWarn(
-      "agent_tool_call_failed",
-      traceContext,
-      {
-        "gen_ai.operation.name": "execute_tool",
-        "gen_ai.tool.name": toolName,
-        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        ...errorAttributes,
-        "exception.message": errorMessage
-      },
-      "Agent tool call failed"
-    );
+    logWarn("agent.tool_call.failed", {
+      "gen_ai.operation.name": "execute_tool",
+      "gen_ai.tool.name": toolName,
+      ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+      ...errorAttributes,
+      "exception.message": errorMessage
+    });
   }
   const isExpectedToolFailure = error instanceof McpToolError || error instanceof ToolInputError || isPluginToolInputError(error);
   if (!isExpectedToolFailure) {
-    logException(
-      error,
-      "agent_tool_call_failed",
-      {},
-      {
-        "gen_ai.operation.name": "execute_tool",
-        "gen_ai.tool.name": toolName,
-        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        ...errorAttributes,
-        ...getToolErrorAttributes(error)
-      },
-      "Agent tool call failed"
-    );
+    logException(error, "agent.tool_call.failed", {
+      "gen_ai.operation.name": "execute_tool",
+      "gen_ai.tool.name": toolName,
+      ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+      ...errorAttributes,
+      ...getToolErrorAttributes(error)
+    });
   }
   throw error;
 }
@@ -12524,15 +12432,10 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
     try {
       await onToolResult?.(report);
     } catch (error) {
-      logWarn(
-        "tool_result_observer_failed",
-        spanContext,
-        {
-          "gen_ai.tool.name": report.toolName,
-          "exception.message": error instanceof Error ? error.message : String(error)
-        },
-        "Tool result observer failed"
-      );
+      logWarn("tool.result.observer.failed", {
+        "gen_ai.tool.name": report.toolName,
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
     }
   };
   const toolResultOk = (details) => {
@@ -12591,15 +12494,10 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
         projectedPrivateResult = toolDef.privateTraceResult(resultAttributeValue);
         hasProjectedPrivateResult = projectedPrivateResult !== void 0;
       } catch (error) {
-        logWarn(
-          "tool_private_trace_projection_failed",
-          spanContext,
-          {
-            "error.type": error instanceof Error ? error.name : typeof error,
-            "gen_ai.tool.name": toolName
-          },
-          "Tool private trace projection failed"
-        );
+        logWarn("tool.private.trace_projection.failed", {
+          "error.type": error instanceof Error ? error.name : typeof error,
+          "gen_ai.tool.name": toolName
+        });
       }
     }
     const toolResultAttribute = effectiveConversationPrivacy === "private" && toolDef.privateTraceResult && !hasProjectedPrivateResult ? void 0 : serializeToolPayload(
@@ -12713,7 +12611,6 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
               executionToolName,
               toolCallId,
               shouldTrace,
-              spanContext,
               effectiveConversationPrivacy,
               setSpanAttributes2
             );
@@ -13186,26 +13083,21 @@ function logSandboxEgressUpstreamRequest(input) {
   if (!shouldLogSandboxEgressInfo()) {
     return;
   }
-  logInfo(
-    "sandbox_egress_upstream_request",
-    {},
-    {
-      ...egressAttributes({
-        egressId: input.egressId,
-        grantAccess: input.grantAccess,
-        grantName: input.grantName,
-        grantReason: input.grantReason,
-        host: input.upstreamUrl.hostname,
-        method: input.request.method,
-        path: input.upstreamUrl.pathname,
-        provider: input.provider,
-        status: input.upstream.status
-      }),
-      ...routingAttributes(input.request, input.upstreamUrl),
-      "app.sandbox.egress.upstream_ok": input.upstream.ok
-    },
-    `Sandbox egress ${input.request.method} ${input.upstreamUrl.hostname}${displayedUpstreamPath(input.upstreamUrl)} -> ${input.upstream.status}`
-  );
+  logInfo("sandbox.egress.upstream.requested", {
+    ...egressAttributes({
+      egressId: input.egressId,
+      grantAccess: input.grantAccess,
+      grantName: input.grantName,
+      grantReason: input.grantReason,
+      host: input.upstreamUrl.hostname,
+      method: input.request.method,
+      path: input.upstreamUrl.pathname,
+      provider: input.provider,
+      status: input.upstream.status
+    }),
+    ...routingAttributes(input.request, input.upstreamUrl),
+    "app.sandbox.egress.upstream_ok": input.upstream.ok
+  });
 }
 async function requestBodyBytes(request) {
   if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
@@ -13402,22 +13294,18 @@ async function executeCredentialedEgressRequest(input) {
     });
   } catch (error) {
     if (isEgressPolicyDenied(error)) {
-      logWarn(
-        "sandbox_egress_policy_denied",
-        {},
-        {
-          ...egressAttributes({
-            egressId: activeEgressId,
-            host: upstreamUrl.hostname,
-            method: request.method,
-            path: upstreamUrl.pathname,
-            provider,
-            status: 403
-          }),
-          ...routingAttributes(request, upstreamUrl)
-        },
-        error.message
-      );
+      logWarn("sandbox.egress.policy.denied", {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          provider,
+          status: 403
+        }),
+        ...routingAttributes(request, upstreamUrl),
+        "app.sandbox.egress.policy.reason": error.message
+      });
       return policyDeniedResponse(error);
     }
     throw error;
@@ -13445,8 +13333,7 @@ async function executeCredentialedEgressRequest(input) {
       });
       const isAuthRequired = error.kind === "auth_required";
       logWarn(
-        isAuthRequired ? "sandbox_egress_credential_needed" : "sandbox_egress_credential_unavailable",
-        {},
+        isAuthRequired ? "sandbox.egress.credential.needed" : "sandbox.egress.credential.unavailable",
         {
           ...egressAttributes({
             egressId: activeEgressId,
@@ -13460,8 +13347,7 @@ async function executeCredentialedEgressRequest(input) {
             status: 401
           }),
           ...routingAttributes(request, upstreamUrl)
-        },
-        isAuthRequired ? "Sandbox egress grant needs user authorization before issuing a credential lease" : "Sandbox egress credential lease is unavailable for selected grant"
+        }
       );
       return authRequiredResponse({
         provider: error.provider,
@@ -13481,17 +13367,12 @@ async function executeCredentialedEgressRequest(input) {
     upstreamUrl
   });
   if (!hasSandboxEgressLeaseTransformForHost(lease, upstreamUrl.hostname)) {
-    logWarn(
-      "sandbox_egress_transform_missing",
-      {},
-      {
-        ...attributes(403),
-        "app.sandbox.egress.transform_domains": lease.headerTransforms.map(
-          (transform) => transform.domain
-        )
-      },
-      "Sandbox egress credential lease does not cover forwarded host"
-    );
+    logWarn("sandbox.egress.transform.missing", {
+      ...attributes(403),
+      "app.sandbox.egress.transform_domains": lease.headerTransforms.map(
+        (transform) => transform.domain
+      )
+    });
     return Response.json(
       { error: "Credential lease does not cover forwarded host" },
       { status: 403 }
@@ -13545,14 +13426,9 @@ async function executeCredentialedEgressRequest(input) {
         upstream,
         upstreamUrl
       });
-      logWarn(
-        "sandbox_egress_upstream_permission_classified",
-        {},
-        {
-          ...attributes(upstream.status, upstream)
-        },
-        "Sandbox egress plugin classified upstream response as permission denied"
-      );
+      logWarn("sandbox.egress.upstream_permission.classified", {
+        ...attributes(upstream.status, upstream)
+      });
     }
   } catch (error) {
     if (!isEgressAuthRequired(error)) {
@@ -13566,14 +13442,9 @@ async function executeCredentialedEgressRequest(input) {
       authorization: error.authorization ?? lease.authorization,
       message: error.message
     });
-    logWarn(
-      "sandbox_egress_upstream_auth_required_classified",
-      {},
-      {
-        ...attributes(upstream.status, upstream)
-      },
-      "Sandbox egress plugin classified upstream response as auth required"
-    );
+    logWarn("sandbox.egress.upstream_auth_requirement.classified", {
+      ...attributes(upstream.status, upstream)
+    });
     await upstream.body?.cancel().catch(() => void 0);
     return authRequiredResponse({
       provider,
@@ -13592,28 +13463,18 @@ async function executeCredentialedEgressRequest(input) {
     upstreamUrl
   });
   if (upstream.status >= 400) {
-    logWarn(
-      "sandbox_egress_upstream_error_response",
-      {},
-      {
-        ...attributes(upstream.status, upstream),
-        "error.type": `http_${upstream.status}`
-      },
-      `Sandbox egress upstream returned HTTP ${upstream.status}`
-    );
+    logWarn("sandbox.egress.upstream_response.failed", {
+      ...attributes(upstream.status, upstream),
+      "error.type": `http_${upstream.status}`
+    });
   }
   if (upstream.status === UPSTREAM_TOKEN_REJECTION_STATUS || upstream.status === UPSTREAM_PERMISSION_REJECTION_STATUS) {
-    logWarn(
-      "sandbox_egress_upstream_auth_rejected",
-      {},
-      {
-        ...attributes(upstream.status, upstream),
-        ...upstream.status === UPSTREAM_TOKEN_REJECTION_STATUS ? {
-          "app.sandbox.egress.www_authenticate": upstream.headers.get("www-authenticate") ?? void 0
-        } : {}
-      },
-      upstream.status === UPSTREAM_TOKEN_REJECTION_STATUS ? "Sandbox egress upstream auth rejected injected credential" : "Sandbox egress upstream permission denied"
-    );
+    logWarn("sandbox.egress.upstream_auth.rejected", {
+      ...attributes(upstream.status, upstream),
+      ...upstream.status === UPSTREAM_TOKEN_REJECTION_STATUS ? {
+        "app.sandbox.egress.www_authenticate": upstream.headers.get("www-authenticate") ?? void 0
+      } : {}
+    });
     if (upstream.status === UPSTREAM_TOKEN_REJECTION_STATUS) {
       await clearCredentialLease(provider, lease.grant, credentialContext);
       await recordAuthRequired({
@@ -13712,7 +13573,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/agent/tools.ts
-async function tryRecordSkillLoadStat(skill, spanContext) {
+async function tryRecordSkillLoadStat(skill) {
   if (!process.env.DATABASE_URL) return;
   try {
     await incrementStat({
@@ -13721,16 +13582,11 @@ async function tryRecordSkillLoadStat(skill, spanContext) {
       name: skill.name
     });
   } catch (error) {
-    logWarn(
-      "skill_load_stat_failed",
-      spanContext,
-      {
-        "app.skill.name": skill.name,
-        "app.plugin.name": skill.pluginProvider,
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to record skill load stat"
-    );
+    logWarn("skill.load.stat.failed", {
+      "app.skill.name": skill.name,
+      "app.plugin.name": skill.pluginProvider,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
   }
 }
 async function wireAgentTools(args) {
@@ -13890,7 +13746,7 @@ async function wireAgentTools(args) {
         if (await mcpToolManager.activateForSkill(effective)) {
           await args.recordConnectedMcpProvider(effective.pluginProvider);
         }
-        await tryRecordSkillLoadStat(effective, args.spanContext);
+        await tryRecordSkillLoadStat(effective);
         if (mcpAuth.getPendingPause()) {
           return void 0;
         }
@@ -13956,15 +13812,10 @@ async function wireAgentTools(args) {
         toolName
       });
     } catch (error) {
-      logWarn(
-        "tool_invocation_observer_failed",
-        args.spanContext,
-        {
-          "gen_ai.tool.name": toolName,
-          "exception.message": error instanceof Error ? error.message : String(error)
-        },
-        "Tool invocation observer failed"
-      );
+      logWarn("tool.invocation.observer.failed", {
+        "gen_ai.tool.name": toolName,
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
     }
   };
   const agentTools = createPiAgentTools(
@@ -13991,18 +13842,13 @@ async function wireAgentTools(args) {
       try {
         await mcpToolManager.close();
       } catch (closeError) {
-        logWarn(
-          "mcp_tool_manager_close_failed",
-          {},
-          {
-            ...getMcpProviderErrorAttributes(closeError),
-            "exception.message": getMcpAwareTelemetryMessage(
-              closeError,
-              args.conversationPrivacy
-            )
-          },
-          "Failed to close MCP tool manager"
-        );
+        logWarn("mcp.tool_manager.close.failed", {
+          ...getMcpProviderErrorAttributes(closeError),
+          "exception.message": getMcpAwareTelemetryMessage(
+            closeError,
+            args.conversationPrivacy
+          )
+        });
       }
     },
     toolGuidance,
@@ -14035,7 +13881,6 @@ function createResumeState(args) {
     source: args.runSource,
     sessionId: args.turnId,
     loadedSkillNames: args.getLoadedSkillNames(),
-    logContext: args.logContext,
     modelId: args.getModelId(),
     ...args.getReasoningLevel() ? { reasoningLevel: args.getReasoningLevel() } : {},
     actor: args.actor,
@@ -14216,6 +14061,7 @@ function createResumeState(args) {
 }
 
 // src/chat/services/context-compaction.ts
+import { estimateContextTokens } from "@earendil-works/pi-agent-core";
 var RETAINED_USER_MESSAGE_TOKENS = 2e4;
 var MAX_SUMMARY_INPUT_CHARS = 8e4;
 var MAX_VISIBLE_CONTEXT_CHARS = 2e4;
@@ -14409,10 +14255,7 @@ async function summarizeContext(args, deps) {
   return summary.slice(0, MAX_SUMMARY_CHARS);
 }
 function estimateHistoryTokens(messages) {
-  return messages.reduce(
-    (total, message) => total + estimateTextTokens(JSON.stringify(message) ?? ""),
-    0
-  );
+  return estimateContextTokens(messages).tokens;
 }
 function buildReplacementProvenance(args) {
   return [
@@ -14469,21 +14312,9 @@ async function maybeCompactWithDeps(args, deps) {
       deps
     );
   } catch (error) {
-    logWarn(
-      "context_compaction_summary_failed",
-      {
-        messageConversationId: args.metadata?.threadId,
-        userId: args.metadata?.actorId,
-        destinationName: args.metadata?.channelId,
-        runId: args.metadata?.runId,
-        assistantUserName: botConfig.userName,
-        modelId: botConfig.fastModelId
-      },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Context compaction failed; continuing with prior history"
-    );
+    logWarn("context_compaction.summary.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return { compacted: false, reason: "summary_failed" };
   }
   return await writeCompactedThreadContext(args, source.messages, summary, {
@@ -14623,23 +14454,11 @@ async function compactActiveContextIfNeeded(args, deps) {
         inputLimitTokens
       );
     }
-    logWarn(
-      "active_context_compaction_summary_failed",
-      {
-        messageConversationId: args.metadata?.threadId,
-        userId: args.metadata?.actorId,
-        destinationName: args.metadata?.channelId,
-        runId: args.metadata?.runId,
-        assistantUserName: botConfig.userName,
-        modelId: args.modelId
-      },
-      {
-        "app.context_input_limit_tokens": inputLimitTokens,
-        "app.context_tokens_estimated": source.estimatedTokens,
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Active context compaction failed below the hard input limit"
-    );
+    logWarn("context_compaction.active.summary.failed", {
+      "app.context_input_limit_tokens": inputLimitTokens,
+      "app.context_tokens_estimated": source.estimatedTokens,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return { compacted: false, reason: "summary_failed" };
   }
   const summaryMessage = userMessage(
@@ -14741,7 +14560,7 @@ function waitForAbortSettlement(promise, timeoutMs) {
     );
   });
 }
-async function executeAgentRun(request) {
+async function executeAgentRun(request, streamFn) {
   if (!request.routing.destination) {
     throw new TypeError("Assistant reply generation requires a destination");
   }
@@ -14776,12 +14595,13 @@ async function executeAgentRun(request) {
       () => executeAgentRunInPrivacyContext(
         request,
         conversationPrivacy,
-        runLogContext
+        runLogContext,
+        streamFn
       )
     )
   );
 }
-async function executeAgentRunInPrivacyContext(request, conversationPrivacy, runLogContext) {
+async function executeAgentRunInPrivacyContext(request, conversationPrivacy, runLogContext, streamFn) {
   const { conversationId, input, routing, runId, turnId } = request;
   const policy = request.policy ?? {};
   const signal = policy.signal;
@@ -14819,19 +14639,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
   const slackDestination = routing.destination.platform === "slack" ? routing.destination : void 0;
   const slackActor = actor?.platform === "slack" ? actor : void 0;
   const userInput = input.messageText;
-  const credentialActor = routing.credentialContext?.actor;
-  const credentialActorLogContext = credentialActor ? {
-    actorType: "type" in credentialActor ? credentialActor.type : "system",
-    actorId: "type" in credentialActor ? credentialActor.userId : credentialActor.name
-  } : {};
-  const sessionRecordLogContext = {
-    threadId: slackSource ? conversationId : void 0,
-    actorId: slackActor?.userId,
-    channelId: slackDestination?.channelId,
-    runId,
-    ...credentialActorLogContext,
-    assistantUserName: botConfig.userName
-  };
   const recordConnectedMcpProvider = async (provider) => {
     if (connectedMcpProviders.has(provider)) {
       return;
@@ -14858,27 +14665,21 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = { modelId: activeModelId };
     const availableSkills = await discoverRunSkills({
-      skillDirs: policy.skillDirs,
-      spanContext
+      skillDirs: policy.skillDirs
     });
     if (shouldTrace) {
       const inboundAttachmentCount = input.inboundAttachmentCount ?? 0;
       const promptAttachmentCount = input.userAttachments?.length ?? 0;
-      logInfo(
-        "agent_message_in",
-        spanContext,
-        {
-          "app.message.kind": "user_inbound",
-          "app.message.length": userInput.length,
-          "app.message.input": summarizeMessageText(userInput),
-          // Log both counts so image uploads filtered by vision/config do not
-          // look indistinguishable from Slack ingress dropping attachments.
-          "app.message.attachment_count": inboundAttachmentCount,
-          "app.message.prompt_attachment_count": promptAttachmentCount,
-          "messaging.message.id": slackSource?.messageTs ?? ""
-        },
-        "Agent message received"
-      );
+      logInfo("agent.message.received", {
+        "app.message.kind": "user_inbound",
+        "app.message.length": userInput.length,
+        "app.message.input": summarizeMessageText(userInput),
+        // Log both counts so image uploads filtered by vision/config do not
+        // look indistinguishable from Slack ingress dropping attachments.
+        "app.message.attachment_count": inboundAttachmentCount,
+        "app.message.prompt_attachment_count": promptAttachmentCount,
+        "messaging.message.id": slackSource?.messageTs ?? ""
+      });
     }
     const skillInvocation = parseSkillInvocation(userInput, availableSkills);
     const invokedSkill = skillInvocation ? findSkillByName(skillInvocation.skillName, availableSkills) : null;
@@ -14910,7 +14711,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       durability,
       getLoadedSkillNames: () => loadedSkillNamesForResume,
       getReasoningLevel: () => turnRoute?.reasoningLevel,
-      logContext: sessionRecordLogContext,
       getModelId: () => activeModelId,
       recordActiveMcpProviders,
       actor,
@@ -14930,15 +14730,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           toolName: event.toolName
         });
       } catch (error) {
-        logException(
-          error,
-          "agent_turn_session_log_append_failed",
-          spanContext,
-          {
-            "gen_ai.tool.name": event.toolName
-          },
-          "Failed to record host-only tool execution start"
-        );
+        logException(error, "agent.turn.session_log_append.failed", {
+          "gen_ai.tool.name": event.toolName
+        });
       }
     };
     const persistedConfigurationValues = policy.channelConfiguration ? await policy.channelConfiguration.resolveValues() : {};
@@ -15073,14 +14867,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       void (async () => {
         await observers.onStatus?.({ text: "Switching models" });
       })().catch((error) => {
-        logWarn(
-          "assistant_status_observer_failed",
-          {},
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to report assistant status"
-        );
+        logWarn("assistant.status.observer.failed", {
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
       });
       const handoffMessages = await compactContextForHandoff(
         {
@@ -15306,12 +15095,12 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     };
     let assistantMessageDeliveryError;
     const deliverAssistantMessage = async (message) => {
-      const text = getAssistantMessageText(message);
-      if (!text || !delivery) {
+      const decision = decideReply(message);
+      if (decision.kind !== "deliver" || !delivery) {
         return;
       }
       try {
-        await delivery.onAssistantMessage({ text });
+        await delivery(message);
       } catch (error) {
         assistantMessageDeliveryError = new AssistantMessageDeliveryError(
           error
@@ -15350,27 +15139,17 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           steeredMessageCount += piMessages.length;
         });
         if (steeredMessageCount > 0) {
-          logInfo(
-            "agent_turn_steering_messages_accepted",
-            spanContext,
-            {
-              "app.ai.steering_message_count": steeredMessageCount
-            },
-            "Agent turn steering messages accepted"
-          );
+          logInfo("agent.turn.steering_messages.accepted", {
+            "app.ai.steering_message_count": steeredMessageCount
+          });
         }
       } catch (error) {
         if (isTurnInputCommitLostError(error)) {
           throw error;
         }
-        logWarn(
-          "agent_turn_steering_messages_drain_failed",
-          spanContext,
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Agent turn steering message drain failed"
-        );
+        logWarn("agent.turn.steering_messages_drain.failed", {
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
       }
       return acceptedMessages;
     };
@@ -15378,7 +15157,10 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     let pendingPiHookError;
     agent = new Agent({
       ...apiKeyOverride ? { getApiKey: () => apiKeyOverride } : {},
-      streamFn: createTracedStreamFn({ conversationPrivacy }),
+      streamFn: createTracedStreamFn({
+        conversationPrivacy,
+        ...streamFn ? { base: streamFn } : {}
+      }),
       steeringMode: "all",
       beforeToolCall: async ({ assistantMessage }) => {
         const toolCalls2 = assistantMessage.content.filter(
@@ -15522,37 +15304,27 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
               );
             } catch (error) {
               if (runResume.timedOut) {
-                logWarn(
-                  "agent_turn_timeout",
-                  {},
-                  {
-                    "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                    "gen_ai.operation.name": "invoke_agent",
-                    "gen_ai.request.model": activeModelId,
-                    ...turnRoute ? {
-                      "gen_ai.request.reasoning.level": turnRoute.reasoningLevel
-                    } : {},
-                    "app.ai.turn_timeout_ms": turnTimeoutBudgetMs,
-                    "app.ai.turn_deadline_remaining_ms": Math.max(
-                      0,
-                      turnDeadlineAtMs - Date.now()
-                    )
-                  },
-                  "Agent turn timed out and was aborted"
-                );
+                logWarn("agent.turn.timed_out", {
+                  "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+                  "gen_ai.operation.name": "invoke_agent",
+                  "gen_ai.request.model": activeModelId,
+                  ...turnRoute ? {
+                    "gen_ai.request.reasoning.level": turnRoute.reasoningLevel
+                  } : {},
+                  "app.ai.turn_timeout_ms": turnTimeoutBudgetMs,
+                  "app.ai.turn_deadline_remaining_ms": Math.max(
+                    0,
+                    turnDeadlineAtMs - Date.now()
+                  )
+                });
                 const settled = await waitForAbortSettlement(
                   run2,
                   AGENT_ABORT_SETTLE_GRACE_MS
                 );
                 if (!settled) {
-                  logWarn(
-                    "agent_turn_abort_settle_timeout",
-                    {},
-                    {
-                      "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS
-                    },
-                    "Timed-out agent run did not settle after abort before resume snapshot"
-                  );
+                  logWarn("agent.turn.abort_settle.timed_out", {
+                    "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS
+                  });
                 }
                 runResume.captureResumeSnapshot(
                   runResume.getResumeSnapshot(currentAgentMessages())
@@ -15616,9 +15388,20 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
             ]);
           }
           run = shouldPromptAgent && !capacityUpdate ? agent.prompt(freshPromptMessage) : agent.continue();
-          let retryUsage;
+          let discardedRetryUsage;
+          let providerRetryAttempt = 0;
+          let emptyOutputAttempt = 0;
+          const prepareRetry = async (messages) => {
+            discardedRetryUsage = addAgentTurnUsage(
+              discardedRetryUsage,
+              getDiscardedRetryUsage(agent.state.messages, messages)
+            );
+            agent.state.messages = messages;
+            await runResume.persistSafeBoundary(messages);
+            signal?.throwIfAborted();
+          };
           try {
-            for (let attempt = 0; ; attempt += 1) {
+            for (; ; ) {
               await runAgentStep(run);
               if (assistantMessageDeliveryError) {
                 throw assistantMessageDeliveryError;
@@ -15635,7 +15418,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
               const usageSummary = extractGenAiUsageSummary(...outputMessages);
               const currentUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
               const currentPhaseUsage = addAgentTurnUsage(
-                retryUsage,
+                discardedRetryUsage,
                 currentUsage
               );
               turnUsage = addAgentTurnUsage(priorPhaseUsage, currentPhaseUsage);
@@ -15650,7 +15433,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
                     normalizeGenAiFinishReason(lastAssistant.stopReason)
                   ]
                 } : {},
-                ...extractGenAiUsageAttributes(usageSummary)
+                ...extractGenAiUsageAttributes(currentPhaseUsage)
               });
               const pendingAuthPause = getPendingAuthPause();
               if (pendingAuthPause) {
@@ -15659,25 +15442,37 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
                 );
                 throw pendingAuthPause;
               }
+              const emptyOutputContinuation = nextEmptyOutputContinuation({
+                attempt: emptyOutputAttempt,
+                lastAssistant,
+                messages: agent.state.messages
+              });
+              if (emptyOutputContinuation.kind === "retry") {
+                emptyOutputAttempt += 1;
+                await prepareRetry(emptyOutputContinuation.messages);
+                logWarn("agent.turn.empty_output.retrying", {
+                  "app.ai.empty_output.attempt": emptyOutputAttempt
+                });
+                run = agent.continue();
+                continue;
+              }
+              if (emptyOutputContinuation.kind === "exhausted") {
+                logWarn("agent.turn.empty_output.exhausted", {
+                  "app.ai.empty_output.attempt": emptyOutputAttempt
+                });
+              }
               const providerRetry = nextProviderRetry({
-                attempt,
+                attempt: providerRetryAttempt,
                 failure: lastAssistant,
                 messages: agent.state.messages
               });
               if (!providerRetry) {
                 break;
               }
-              retryUsage = currentPhaseUsage;
-              agent.state.messages = providerRetry.messages;
-              await runResume.persistSafeBoundary(providerRetry.messages);
-              logWarn(
-                "agent_turn_provider_retry",
-                spanContext,
-                {},
-                "Retrying transient provider failure"
-              );
+              providerRetryAttempt += 1;
+              await prepareRetry(providerRetry.messages);
+              logWarn("agent.turn.provider.retrying");
               await sleep(providerRetry.delayMs, signal);
-              signal?.throwIfAborted();
               run = agent.continue();
             }
           } catch (error) {
@@ -15722,7 +15517,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       durationMs: Date.now() - replyStartedAtMs,
       generatedFileCount: generatedFiles.length,
       shouldTrace,
-      spanContext,
       usage: turnUsage,
       executionProfile: turnRoute,
       assistantUserName: botConfig.userName,
@@ -15770,13 +15564,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     if (durability.onInputCommitted && !resume?.inputCommitted) {
       throw error;
     }
-    logException(
-      error,
-      "assistant_reply_generation_failed",
-      { modelId: activeModelId },
-      {},
-      "executeAgentRun failed"
-    );
+    logException(error, "assistant.reply.generation.failed");
     const message = error instanceof Error ? error.message : String(error);
     return {
       status: "completed",