@sentry/junior 0.120.0 → 0.122.0

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

@@ -30,15 +30,18 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-TKUCRFNX.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-JQWP6V22.js";
+} from "./chunk-NNGYYGX5.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -96,10 +101,10 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-DJDGDJDF.js";
+} from "./chunk-CYW4M6IV.js";
 import {
   incrementStat
-} from "./chunk-6WX5SPI3.js";
+} from "./chunk-32FPGM2V.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -121,7 +126,7 @@ import {
   normalizeSlackConversationId,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-24B5R6OU.js";
+} from "./chunk-USKP7IM2.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -130,7 +135,7 @@ import {
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-M243JMZH.js";
+} from "./chunk-DOB5RVMH.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -140,7 +145,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-ALAKN7LR.js";
+} from "./chunk-TZVZCIYL.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -171,7 +176,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-VURFJVFH.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-EIVE6GL4.js";
+} from "./chunk-E5SRLZQV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-GNNV3UTY.js";
+} from "./chunk-OKUZIXQM.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -199,7 +204,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-XAI2HNAY.js";
+} from "./chunk-GN6WW7WR.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -223,7 +228,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-ALYQOZG7.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;
   }
 })();
@@ -1781,10 +1676,11 @@ var TOOL_POLICY_RULES = [
   "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
   "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
+  "- After changing files, name the changed paths and summarize the completed result in the final answer.",
   "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
   "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
   "- When a tool result includes a subscribable resource, use resource-event subscriptions for high-signal provider changes that serve the user's current intent; do not create scheduled polling tasks for events the subscription can deliver. Use the suggested events when they fit and write a concise intent summary.",
-  "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis when that tool is available.",
+  "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis only when it offers a profile that better matches the task. Do not switch merely because the task involves code.",
   "- Run `jr-rpc config get|set|unset|list` for provider defaults and `jr-rpc plugins list` for installed plugin introspection as standalone bash commands; do not chain them with `cd`, `&&`, pipes, or provider commands.",
   "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
 ];
@@ -1805,7 +1701,8 @@ var EXECUTION_CONTRACT_RULES = [
   "- Complete the full task, but report only the result and evidence the user needs; do not narrate every step, check, or detail.",
   "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
   "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
-  "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
+  "- Use `reportProgress` only for work with multiple substantive phases or a materially long wait. Skip short lookups and routine commands; after an initial update, call it again only when the major phase changes.",
+  "- When a tool outcome is unknown and may include side effects, inspect authoritative state before retrying. If state already reflects the intended result, do not repeat the mutation."
 ];
 var CONVERSATION_RULES = [
   "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
@@ -1826,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");
@@ -2557,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: {
@@ -2602,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({
@@ -3259,6 +3146,20 @@ var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
 var SANDBOX_NAME_PREFIX = "junior-";
 var MAX_KEEPALIVE_INTERVAL_MS = 3e4;
 var MIN_KEEPALIVE_INTERVAL_MS = 1e3;
+function sandboxFetchOptions(signal) {
+  if (!signal) {
+    return {};
+  }
+  return {
+    fetch: (input, init) => {
+      const requestSignal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+      return globalThis.fetch(input, {
+        ...init,
+        signal: requestSignal ? AbortSignal.any([requestSignal, signal]) : signal
+      });
+    }
+  };
+}
 function truncateOutput(output, maxLength) {
   if (output.length <= maxLength) {
     return { value: output, truncated: false };
@@ -3398,9 +3299,10 @@ function createSandboxRuntime(options) {
       }
     );
   };
-  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName) => {
+  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName, signal) => {
     const resources = getSandboxResources();
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
+      signal?.throwIfAborted();
       const sandboxName = attempt === 0 ? initialSandboxName : createSandboxName();
       const networkPolicy = preflightNetworkPolicy(sandboxName);
       try {
@@ -3413,14 +3315,15 @@ function createSandboxRuntime(options) {
               snapshotId
             },
             ...resources ? { resources } : {},
-            ...sandboxCredentials ?? {}
+            ...sandboxCredentials ?? {},
+            ...sandboxFetchOptions(signal)
           })
         );
       } catch (error) {
         if (!isSnapshottingError(error) || attempt === SNAPSHOT_BOOT_RETRY_COUNT - 1) {
           throw error;
         }
-        await sleep(SNAPSHOT_BOOT_RETRY_DELAY_MS);
+        await sleep(SNAPSHOT_BOOT_RETRY_DELAY_MS, signal);
       }
     }
     throw new Error(`Failed to boot sandbox from snapshot ${snapshotId}`);
@@ -3440,7 +3343,8 @@ function createSandboxRuntime(options) {
     });
   };
   const createSandboxFromResolvedSnapshot = async (params) => {
-    const { runtime, snapshot, sandboxCredentials, sandboxName } = params;
+    const { runtime, snapshot, sandboxCredentials, sandboxName, signal } = params;
+    signal?.throwIfAborted();
     if (!snapshot.snapshotId) {
       const networkPolicy = preflightNetworkPolicy(sandboxName);
       const resources = getSandboxResources();
@@ -3450,7 +3354,8 @@ function createSandboxRuntime(options) {
           runtime,
           ...networkPolicy ? { name: sandboxName, persistent: false, networkPolicy } : {},
           ...resources ? { resources } : {},
-          ...sandboxCredentials ?? {}
+          ...sandboxCredentials ?? {},
+          ...sandboxFetchOptions(signal)
         })
       );
     }
@@ -3458,7 +3363,8 @@ function createSandboxRuntime(options) {
       return await createSandboxFromSnapshot(
         snapshot.snapshotId,
         sandboxCredentials,
-        sandboxName
+        sandboxName,
+        signal
       );
     } catch (error) {
       if (!isMissingError(error)) {
@@ -3471,19 +3377,22 @@ function createSandboxRuntime(options) {
         runtime,
         timeoutMs,
         forceRebuild: true,
-        staleSnapshotId: snapshot.snapshotId
+        staleSnapshotId: snapshot.snapshotId,
+        signal
       });
       if (!rebuiltSnapshot.snapshotId) {
         throw error;
       }
+      signal?.throwIfAborted();
       return await createSandboxFromSnapshot(
         rebuiltSnapshot.snapshotId,
         sandboxCredentials,
-        sandboxName
+        sandboxName,
+        signal
       );
     }
   };
-  const createFreshSandbox = async () => {
+  const createFreshSandbox = async (signal) => {
     const runtime = SANDBOX_RUNTIME;
     const sandboxCredentials = getVercelSandboxCredentials();
     const sandboxName = createSandboxName();
@@ -3500,14 +3409,17 @@ function createSandboxRuntime(options) {
         async () => {
           const snapshot = await resolve({
             runtime,
-            timeoutMs
+            timeoutMs,
+            signal
           });
+          signal?.throwIfAborted();
           setSnapshotAttributes(snapshot);
           return await createSandboxFromResolvedSnapshot({
             runtime,
             snapshot,
             sandboxCredentials,
-            sandboxName
+            sandboxName,
+            signal
           });
         }
       );
@@ -3536,23 +3448,19 @@ 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 () => {
     return activeSandbox?.session ?? null;
   };
-  const tryRestoreHintedSandbox = async () => {
+  const tryRestoreHintedSandbox = async (signal) => {
     const ref = sandboxRef;
     if (!ref) {
       return null;
@@ -3571,7 +3479,8 @@ function createSandboxRuntime(options) {
           await Sandbox.get({
             name: ref.id,
             resume: true,
-            ...sandboxCredentials ?? {}
+            ...sandboxCredentials ?? {},
+            ...sandboxFetchOptions(signal)
           })
         )
       );
@@ -3599,7 +3508,7 @@ function createSandboxRuntime(options) {
       return failSetup(error);
     }
   };
-  const acquireSandbox = async () => {
+  const acquireSandbox = async (signal) => {
     return await withSandboxSpan(
       "sandbox.acquire",
       "sandbox.acquire",
@@ -3615,25 +3524,63 @@ function createSandboxRuntime(options) {
         if (cachedSandbox) {
           return cachedSandbox;
         }
-        const hintedSandbox = await tryRestoreHintedSandbox();
+        signal?.throwIfAborted();
+        const hintedSandbox = await tryRestoreHintedSandbox(signal);
         if (hintedSandbox) {
           return hintedSandbox;
         }
-        return await createFreshSandbox();
+        return await createFreshSandbox(signal);
       }
     );
   };
-  const getOrAcquireSandbox = async () => {
-    if (acquiringSandbox) {
-      return await acquiringSandbox;
-    }
-    const nextSandbox = acquireSandbox();
-    acquiringSandbox = nextSandbox;
-    try {
-      return await nextSandbox;
-    } finally {
-      if (acquiringSandbox === nextSandbox) {
-        acquiringSandbox = void 0;
+  const getOrAcquireSandbox = async (signal) => {
+    for (; ; ) {
+      signal?.throwIfAborted();
+      let acquisition = acquiringSandbox;
+      if (!acquisition) {
+        const controller = new AbortController();
+        const startedAcquisition = {
+          controller,
+          promise: acquireSandbox(signal ? controller.signal : void 0),
+          settled: false,
+          waiters: 0
+        };
+        const markSettled = () => {
+          startedAcquisition.settled = true;
+          if (acquiringSandbox === startedAcquisition) {
+            acquiringSandbox = void 0;
+          }
+        };
+        void startedAcquisition.promise.then(markSettled, markSettled);
+        acquiringSandbox = startedAcquisition;
+        acquisition = startedAcquisition;
+      }
+      acquisition.waiters += 1;
+      let removeAbortListener;
+      try {
+        if (!signal) {
+          return await acquisition.promise;
+        }
+        const aborted = new Promise((_resolve, reject) => {
+          const onAbort = () => reject(signal.reason);
+          signal.addEventListener("abort", onAbort, { once: true });
+          removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+        });
+        return await Promise.race([acquisition.promise, aborted]);
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (!acquisition.controller.signal.aborted) {
+          throw error;
+        }
+        if (acquiringSandbox === acquisition) {
+          acquiringSandbox = void 0;
+        }
+      } finally {
+        removeAbortListener?.();
+        acquisition.waiters -= 1;
+        if (acquisition.waiters === 0 && !acquisition.settled) {
+          acquisition.controller.abort(signal?.reason);
+        }
       }
     }
   };
@@ -3782,9 +3729,11 @@ function createSandboxRuntime(options) {
       runCommand: async (input) => await sandboxInstance.runCommand(input)
     };
   };
-  const ensureReadySandbox = async () => {
-    const activeSandbox2 = await getOrAcquireSandbox();
+  const ensureReadySandbox = async (signal) => {
+    const activeSandbox2 = await getOrAcquireSandbox(signal);
+    signal?.throwIfAborted();
     await probeSession(activeSandbox2);
+    signal?.throwIfAborted();
     await extendKeepAlive(activeSandbox2);
     startKeepAlive(activeSandbox2);
     return activeSandbox2;
@@ -3793,11 +3742,11 @@ function createSandboxRuntime(options) {
     sandboxRef() {
       return sandboxRef ? { ...sandboxRef } : void 0;
     },
-    async acquire() {
-      return await getOrAcquireSandbox();
+    async acquire(signal) {
+      return await getOrAcquireSandbox(signal);
     },
-    async tools() {
-      return createToolExecutors(await ensureReadySandbox());
+    async tools(signal) {
+      return createToolExecutors(await ensureReadySandbox(signal));
     },
     async refreshNetworkPolicy(traceHeaders) {
       const active = activeSandbox;
@@ -4226,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";
 }
@@ -4288,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));
       }
     } : {}
@@ -5319,14 +5289,14 @@ function createSandbox(options) {
       setToolCallSpanAttributes,
       fileSystem() {
         signal?.throwIfAborted();
-        return fileSystemPromise ??= runtime.tools().then(({ fs: fs5 }) => {
+        return fileSystemPromise ??= runtime.tools(signal).then(({ fs: fs5 }) => {
           signal?.throwIfAborted();
           return bindSandboxFileSystem(fs5, signal);
         });
       },
       commandRunner() {
         signal?.throwIfAborted();
-        return commandRunnerPromise ??= runtime.tools().then(({ runCommand }) => {
+        return commandRunnerPromise ??= runtime.tools(signal).then(({ runCommand }) => {
           signal?.throwIfAborted();
           return async (input) => await runCommand({
             ...input,
@@ -5366,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);
@@ -5382,7 +5347,7 @@ function createSandbox(options) {
     logSandboxBootRequest("tool.bash", {
       "app.sandbox.command_length": command.length
     });
-    const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools();
+    const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools(context.signal);
     await clearEgressSignals(activeSessionId);
     const result = await withSandboxToolSpan(
       "bash",
@@ -6679,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;
             }
@@ -6840,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;
   }
 }
@@ -7526,7 +7480,7 @@ function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
 import { z as z16 } from "zod";
 function createReportProgressTool() {
   return zodTool({
-    description: "Update the user-visible assistant loading message with a short progress phase. For every non-trivial turn, call this early with the initial major work phase, then call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks'). Skip trivial direct answers, generic filler, and minor substeps.",
+    description: "Update the user-visible assistant loading message with a short progress phase. Use this only for work with multiple substantive phases or a materially long wait. Skip short lookups, routine commands, generic filler, and minor substeps. After an initial update, call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks').",
     inputSchema: z16.object({
       message: z16.string().min(1).describe("Short user-facing progress message.")
     }),
@@ -8934,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) {
@@ -9082,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)."
         );
@@ -9224,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",
@@ -9303,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",
@@ -9370,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",
@@ -10426,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."
@@ -10439,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({
@@ -10450,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) {
@@ -10529,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 } : {}
       };
     }
   });
@@ -10621,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,
@@ -10634,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 {
@@ -10666,7 +10664,7 @@ var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
   const profileSchema = z38.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
-    model_profile: profileSchema
+    model_profile: modelProfileSchema
   });
   const profileNames = handoff.profiles.map((profile) => `\`${profile}\``).join(", ");
   return zodTool({
@@ -11300,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",
@@ -12029,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 = {
@@ -12045,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;
 }
@@ -12456,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) => {
@@ -12523,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(
@@ -12645,7 +12611,6 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
               executionToolName,
               toolCallId,
               shouldTrace,
-              spanContext,
               effectiveConversationPrivacy,
               setSpanAttributes2
             );
@@ -13118,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) {
@@ -13334,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;
@@ -13377,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,
@@ -13392,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,
@@ -13413,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 }
@@ -13477,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)) {
@@ -13498,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,
@@ -13524,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({
@@ -13644,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({
@@ -13653,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) {
@@ -13822,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;
         }
@@ -13888,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(
@@ -13923,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,
@@ -13967,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,
@@ -14148,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;
@@ -14341,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 [
@@ -14401,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, {
@@ -14555,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(
@@ -14673,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");
   }
@@ -14708,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;
@@ -14751,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;
@@ -14790,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;
@@ -14842,7 +14711,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       durability,
       getLoadedSkillNames: () => loadedSkillNamesForResume,
       getReasoningLevel: () => turnRoute?.reasoningLevel,
-      logContext: sessionRecordLogContext,
       getModelId: () => activeModelId,
       recordActiveMcpProviders,
       actor,
@@ -14862,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() : {};
@@ -15005,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(
         {
@@ -15051,15 +14908,21 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       activeModelProfile = args.profile;
       activeModelId = target.modelId;
     };
-    const requestHandoff = {
-      profiles: handoffProfiles,
-      execute: async (profile, options) => await scheduleHandoff({
-        profile,
-        signal: options.signal,
-        sourceMessages: [...agent.state.messages],
-        triggeringToolCallId: options.toolCallId
-      })
+    const handoffControlFor = (activeProfile) => {
+      const profiles = handoffProfiles.filter(
+        (profile) => profile !== activeProfile
+      );
+      return profiles.length > 0 ? {
+        profiles,
+        execute: async (profile, options) => await scheduleHandoff({
+          profile,
+          signal: options.signal,
+          sourceMessages: [...agent.state.messages],
+          triggeringToolCallId: options.toolCallId
+        })
+      } : void 0;
     };
+    const requestHandoff = handoffControlFor(activeModelProfile);
     setTags({
       ...runLogContext,
       modelId: activeModelId
@@ -15103,7 +14966,30 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     mcpToolManager = wiring.mcpToolManager;
     closeTools = wiring.close;
     const getPendingAuthPause = wiring.getPendingAuthPause;
-    const toolsAfterHandoff = wiring.agentTools;
+    const toolsWithoutHandoff = wiring.agentTools.filter(
+      (tool) => tool.name !== HANDOFF_TOOL_NAME
+    );
+    const handoffAgentTool = wiring.agentTools.find(
+      (tool) => tool.name === HANDOFF_TOOL_NAME
+    );
+    const toolsForActiveProfile = () => {
+      const handoff = handoffControlFor(activeModelProfile);
+      if (!handoff) {
+        return toolsWithoutHandoff;
+      }
+      if (!handoffAgentTool) {
+        throw new Error("Handoff control is missing its Pi tool");
+      }
+      const definition = createHandoffTool(handoff);
+      return wiring.agentTools.map(
+        (tool) => tool.name === HANDOFF_TOOL_NAME ? {
+          ...handoffAgentTool,
+          description: definition.description,
+          parameters: definition.inputSchema,
+          prepareArguments: definition.prepareArguments
+        } : tool
+      );
+    };
     const {
       baseInstructions,
       inputMessages,
@@ -15141,7 +15027,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       agent.state.messages = replacement;
       agent.state.model = model;
       agent.state.thinkingLevel = thinkingLevel;
-      agent.state.tools = toolsAfterHandoff;
+      const tools = toolsForActiveProfile();
+      agent.state.tools = tools;
       runResume.setBeforeMessageCount(replacement.length);
       runResume.setTurnStartMessageIndex(0);
       runResume.adoptCommittedBoundary(replacement);
@@ -15154,7 +15041,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         context: {
           systemPrompt: baseInstructions,
           messages: replacement,
-          tools: toolsAfterHandoff
+          tools
         },
         model,
         thinkingLevel
@@ -15208,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
@@ -15252,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;
     };
@@ -15280,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(
@@ -15424,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())
@@ -15518,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;
@@ -15537,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);
@@ -15552,7 +15433,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
                     normalizeGenAiFinishReason(lastAssistant.stopReason)
                   ]
                 } : {},
-                ...extractGenAiUsageAttributes(usageSummary)
+                ...extractGenAiUsageAttributes(currentPhaseUsage)
               });
               const pendingAuthPause = getPendingAuthPause();
               if (pendingAuthPause) {
@@ -15561,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) {
@@ -15624,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,
@@ -15672,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",