@sentry/junior 0.120.0 → 0.122.0

package/dist/app.js

@@ -50,7 +50,7 @@ import {
   startConversationWork,
   startSlackProcessingReaction,
   stripLeadingBotMention
-} from "./chunk-QOQPPRFS.js";
+} from "./chunk-4TGVC42X.js";
 import "./chunk-FA6POGLH.js";
 import {
   ConversationTurnLifecycleService,
@@ -65,13 +65,13 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-BHXW734F.js";
+} from "./chunk-V6XPIKYA.js";
 import {
   GET,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-Q3RL6A4E.js";
+} from "./chunk-BDE5RZVF.js";
 import "./chunk-4CODA7P5.js";
 import "./chunk-PE44LDDQ.js";
 import {
@@ -90,7 +90,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-YEAOUT5W.js";
+} from "./chunk-GFTZKOTP.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -123,7 +123,7 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-ERYVNWNE.js";
+} from "./chunk-NIJG6G6X.js";
 import "./chunk-DIB4GX3G.js";
 import {
   RetryableDeliveryError,
@@ -134,7 +134,7 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-TKUCRFNX.js";
+} from "./chunk-VCC7XFX2.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -148,12 +148,14 @@ import {
   clearPendingAuth,
   coerceThreadArtifactsState,
   coerceThreadConversationState,
+  commitAcceptedReply,
   commitMessages,
   completeDeliveredTurn,
   createConversationMemoryService,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
   getAgentTurnSessionRecordForResume,
+  getAssistantReplyText,
   getChannelConfigurationService,
   getChannelConfigurationServiceById,
   getConversationMessageSlackTs,
@@ -188,10 +190,10 @@ import {
   trimTrailingAssistantMessages,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-JQWP6V22.js";
+} from "./chunk-NNGYYGX5.js";
 import "./chunk-HDSDCEPK.js";
-import "./chunk-DJDGDJDF.js";
-import "./chunk-6WX5SPI3.js";
+import "./chunk-CYW4M6IV.js";
+import "./chunk-32FPGM2V.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -216,7 +218,7 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-24B5R6OU.js";
+} from "./chunk-USKP7IM2.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -227,7 +229,7 @@ import {
   instructionProvenanceFor,
   requireSlackDestination,
   withConversationEventLock
-} from "./chunk-M243JMZH.js";
+} from "./chunk-DOB5RVMH.js";
 import {
   juniorConversationEvents,
   juniorConversations
@@ -236,7 +238,7 @@ import {
   acquireActiveLock,
   getStateAdapter,
   sleep
-} from "./chunk-ALAKN7LR.js";
+} from "./chunk-TZVZCIYL.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -254,18 +256,18 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-VURFJVFH.js";
+} from "./chunk-2RFM7STT.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   parseSlackThreadId
-} from "./chunk-HDFGNU5E.js";
-import "./chunk-EIVE6GL4.js";
+} from "./chunk-S7G34U75.js";
+import "./chunk-E5SRLZQV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-GNNV3UTY.js";
-import "./chunk-XAI2HNAY.js";
+} from "./chunk-OKUZIXQM.js";
+import "./chunk-GN6WW7WR.js";
 import {
   credentialSubjectSchema
 } from "./chunk-W3U3YQYI.js";
@@ -290,8 +292,9 @@ import {
   setSpanStatus,
   setTags,
   withContext,
+  withLogContext,
   withSpan
-} from "./chunk-ALYQOZG7.js";
+} from "./chunk-4SPRQJOW.js";
 import {
   toOptionalString
 } from "./chunk-OB42YVAE.js";
@@ -306,10 +309,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-DWOH57FW.js";
+} from "./chunk-L2KJ2GNL.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-DMKHRBI6.js";
+} from "./chunk-ISQYBTPG.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -1109,13 +1112,9 @@ async function POST(request, waitUntil, options) {
         queue: options.conversationWorkQueue
       });
     })().catch((error) => {
-      logException(
-        error,
-        "agent_dispatch_callback_failed",
-        {},
-        { "app.dispatch.id": payload.id },
-        "Legacy dispatch callback failed"
-      );
+      logException(error, "agent.dispatch.callback.failed", {
+        "app.dispatch.id": payload.id
+      });
     })
   );
   return new Response("Accepted", { status: 202 });
@@ -1141,107 +1140,87 @@ async function recoverConversationWork(args) {
     state: args.state
   });
   for (const conversationId of ids) {
-    let work;
-    try {
-      work = await getConversationWorkState({
-        conversationId,
-        state: args.state
-      });
-    } catch (error) {
-      logException(
-        error,
-        "conversation_work_recovery_failed",
-        { conversationId },
-        {},
-        "Conversation work heartbeat recovery failed"
-      );
-      if (isInvalidConversationRecordError(error)) {
-        await removeActiveConversation({
-          conversationId,
-          state: args.state
-        });
-      }
-      continue;
-    }
-    try {
-      if (!work) {
-        await removeActiveConversation({
-          conversationId,
-          state: args.state
-        });
-        continue;
-      }
-      if (work.execution.status === "idle") {
-        await removeActiveConversation({
+    await withLogContext({ conversationId }, async () => {
+      let work;
+      try {
+        work = await getConversationWorkState({
           conversationId,
           state: args.state
         });
-        continue;
+      } catch (error) {
+        logException(error, "conversation.work.recovery.failed");
+        if (isInvalidConversationRecordError(error)) {
+          await removeActiveConversation({
+            conversationId,
+            state: args.state
+          });
+        }
+        return;
       }
-      if (work.execution.lease && work.execution.lease.expiresAtMs <= args.nowMs) {
-        const cleared = await clearExpiredConversationLease({
-          conversationId,
-          nowMs: args.nowMs,
-          state: args.state
-        });
-        if (!cleared) {
-          continue;
+      try {
+        if (!work) {
+          await removeActiveConversation({
+            conversationId,
+            state: args.state
+          });
+          return;
+        }
+        if (work.execution.status === "idle") {
+          await removeActiveConversation({
+            conversationId,
+            state: args.state
+          });
+          return;
+        }
+        if (work.execution.lease && work.execution.lease.expiresAtMs <= args.nowMs) {
+          const cleared = await clearExpiredConversationLease({
+            conversationId,
+            nowMs: args.nowMs,
+            state: args.state
+          });
+          if (!cleared) {
+            return;
+          }
+          const wake2 = await ensureConversationWake({
+            conversationId,
+            idempotencyKey: heartbeatIdempotencyKey(
+              "lease",
+              conversationId,
+              args.nowMs
+            ),
+            nowMs: args.nowMs,
+            queue: args.queue,
+            replaceExistingWake: true,
+            state: args.state
+          });
+          if (wake2.status === "enqueued") {
+            result.expiredLeaseCount += 1;
+            logInfo("conversation.work.lease_expired.requeued");
+          }
+          return;
+        }
+        if (work.execution.lease || !hasRunnableConversationWork(work)) {
+          return;
         }
-        const wake2 = await ensureConversationWake({
+        const wake = await ensureConversationWake({
           conversationId,
           idempotencyKey: heartbeatIdempotencyKey(
-            "lease",
+            "pending",
             conversationId,
             args.nowMs
           ),
           nowMs: args.nowMs,
           queue: args.queue,
-          replaceExistingWake: true,
           state: args.state
         });
-        if (wake2.status === "enqueued") {
-          result.expiredLeaseCount += 1;
-          logInfo(
-            "conversation_work_lease_expired_requeued",
-            { conversationId },
-            {},
-            "Heartbeat requeued expired conversation work lease"
-          );
+        if (wake.status === "enqueued") {
+          result.pendingCount += 1;
+          logInfo("conversation.work.pending.requeued");
         }
-        continue;
-      }
-      if (work.execution.lease || !hasRunnableConversationWork(work)) {
-        continue;
-      }
-      const wake = await ensureConversationWake({
-        conversationId,
-        idempotencyKey: heartbeatIdempotencyKey(
-          "pending",
-          conversationId,
-          args.nowMs
-        ),
-        nowMs: args.nowMs,
-        queue: args.queue,
-        state: args.state
-      });
-      if (wake.status === "enqueued") {
-        result.pendingCount += 1;
-        logInfo(
-          "conversation_work_pending_requeued",
-          { conversationId },
-          {},
-          "Heartbeat requeued pending conversation work"
-        );
+      } catch (error) {
+        logException(error, "conversation.work.recovery.failed");
       }
-    } catch (error) {
-      logException(
-        error,
-        "conversation_work_recovery_failed",
-        { conversationId },
-        {},
-        "Conversation work heartbeat recovery failed"
-      );
-    }
+    });
   }
   return result;
 }
@@ -1494,24 +1473,15 @@ async function runPluginHeartbeats(args) {
         PLUGIN_HEARTBEAT_TIMEOUT_MS
       );
       if (typeof result?.dispatchCount === "number" && result.dispatchCount > 0) {
-        logInfo(
-          "plugin_heartbeat_dispatched",
-          {},
-          {
-            "app.dispatch.count": result.dispatchCount,
-            "app.plugin.name": pluginName
-          },
-          "Plugin heartbeat dispatched agent work"
-        );
+        logInfo("plugin.heartbeat.dispatched", {
+          "app.dispatch.count": result.dispatchCount,
+          "app.plugin.name": pluginName
+        });
       }
     } catch (error) {
-      logException(
-        error,
-        "plugin_heartbeat_failed",
-        {},
-        { "app.plugin.name": pluginName },
-        "Plugin heartbeat failed"
-      );
+      logException(error, "plugin.heartbeat.failed", {
+        "app.plugin.name": pluginName
+      });
     }
   }
 }
@@ -1540,13 +1510,9 @@ async function recoverPendingDispatchMailboxAppends(args) {
         queue: args.conversationWorkQueue
       });
     } catch (error) {
-      logException(
-        error,
-        "dispatch_mailbox_append_recovery_failed",
-        {},
-        { "app.dispatch.id": id },
-        "Pending dispatch mailbox append recovery failed"
-      );
+      logException(error, "dispatch.mailbox.append_recovery.failed", {
+        "app.dispatch.id": id
+      });
     }
   }
 }
@@ -1593,13 +1559,9 @@ async function GET4(request, waitUntil, options = {}) {
       conversationWorkQueue: options.conversationWorkQueue,
       nowMs
     }).catch((error) => {
-      logException(
-        error,
-        "heartbeat_failed",
-        {},
-        { "app.heartbeat.now_ms": nowMs },
-        "Heartbeat failed"
-      );
+      logException(error, "heartbeat.failed", {
+        "app.heartbeat.now_ms": nowMs
+      });
     })
   );
   return new Response("Accepted", { status: 202 });
@@ -1820,42 +1782,33 @@ async function runRetentionPurge(executor, args) {
   let failed = 0;
   let conversations = 0;
   for (const root of roots) {
-    try {
-      const result = await purgeConversationTree(executor, {
-        rootConversationId: root.conversationId,
-        nowMs: args.nowMs,
-        retention: {
-          publicWindowMs: CONTENT_RETENTION_MS.public,
-          privateWindowMs: CONTENT_RETENTION_MS.private
+    await withLogContext({ conversationId: root.conversationId }, async () => {
+      try {
+        const result = await purgeConversationTree(executor, {
+          rootConversationId: root.conversationId,
+          nowMs: args.nowMs,
+          retention: {
+            publicWindowMs: CONTENT_RETENTION_MS.public,
+            privateWindowMs: CONTENT_RETENTION_MS.private
+          }
+        });
+        if (result.purged) {
+          purged += 1;
+          conversations += result.conversations;
         }
-      });
-      if (result.purged) {
-        purged += 1;
-        conversations += result.conversations;
+      } catch (error) {
+        failed += 1;
+        logException(error, "retention.purge.tree.failed");
       }
-    } catch (error) {
-      failed += 1;
-      logException(
-        error,
-        "retention_purge_tree_failed",
-        { conversationId: root.conversationId },
-        {},
-        "Retention purge failed for one conversation tree"
-      );
-    }
+    });
   }
-  logInfo(
-    "retention_purge_completed",
-    {},
-    {
-      "app.retention.scanned": roots.length,
-      "app.retention.purged": purged,
-      "app.retention.failed": failed,
-      "app.retention.conversations": conversations,
-      "app.retention.duration_ms": Date.now() - startedAtMs
-    },
-    "Retention purge batch completed"
-  );
+  logInfo("retention.purge.completed", {
+    "app.retention.scanned": roots.length,
+    "app.retention.purged": purged,
+    "app.retention.failed": failed,
+    "app.retention.conversations": conversations,
+    "app.retention.duration_ms": Date.now() - startedAtMs
+  });
   return { scanned: roots.length, purged, failed, conversations };
 }
 
@@ -1886,13 +1839,7 @@ async function GET5(request) {
     });
     return Response.json(result, { status: 200 });
   } catch (error) {
-    logException(
-      error,
-      "retention_run_failed",
-      {},
-      {},
-      "Retention purge run failed"
-    );
+    logException(error, "retention.run.failed");
     return new Response("Retention purge failed", { status: 500 });
   }
 }
@@ -2127,27 +2074,17 @@ async function proxySandboxEgressRequest(request, deps = {}) {
       oidcToken
     );
   } catch (error) {
-    logWarn(
-      "sandbox_egress_oidc_verification_failed",
-      {},
-      {
-        "app.sandbox.oidc_error": error instanceof Error ? error.message : String(error)
-      },
-      "Sandbox egress OIDC verification failed"
-    );
+    logWarn("sandbox.egress.oidc_verification.failed", {
+      "app.sandbox.oidc_error": error instanceof Error ? error.message : String(error)
+    });
     return jsonError("Invalid Vercel Sandbox OIDC token", 401);
   }
   const activeEgressId = sandboxIdFromPayload(oidcPayload);
   if (!activeEgressId) {
-    logWarn(
-      "sandbox_egress_oidc_session_missing",
-      {},
-      {
-        "http.request.method": request.method,
-        "url.path": redactedProxyPath(new URL(request.url).pathname)
-      },
-      "Sandbox egress OIDC payload did not include a VM session id"
-    );
+    logWarn("sandbox.egress.oidc_session.missing", {
+      "http.request.method": request.method,
+      "url.path": redactedProxyPath(new URL(request.url).pathname)
+    });
     return jsonError(
       "Vercel Sandbox OIDC token did not include sandbox_id",
       401
@@ -2155,62 +2092,47 @@ async function proxySandboxEgressRequest(request, deps = {}) {
   }
   const upstreamResult = buildUpstreamUrl(request);
   if (!upstreamResult.ok) {
-    logWarn(
-      "sandbox_egress_upstream_url_invalid",
-      {},
-      {
-        ...egressAttributes({
-          egressId: activeEgressId,
-          method: request.method,
-          path: redactedProxyPath(new URL(request.url).pathname),
-          status: 400
-        }),
-        ...routingAttributes(request)
-      },
-      "Sandbox egress forwarded request had invalid upstream routing headers"
-    );
+    logWarn("sandbox.egress.upstream_url.invalid", {
+      ...egressAttributes({
+        egressId: activeEgressId,
+        method: request.method,
+        path: redactedProxyPath(new URL(request.url).pathname),
+        status: 400
+      }),
+      ...routingAttributes(request)
+    });
     return jsonError(upstreamResult.error, 400);
   }
   const upstreamUrl = upstreamResult.url;
   const provider = resolveSandboxEgressProviderForHost(upstreamUrl.hostname);
   if (!provider) {
-    logWarn(
-      "sandbox_egress_provider_unresolved",
-      {},
-      {
-        ...egressAttributes({
-          egressId: activeEgressId,
-          host: upstreamUrl.hostname,
-          method: request.method,
-          path: upstreamUrl.pathname,
-          status: 403
-        }),
-        ...routingAttributes(request, upstreamUrl)
-      },
-      "Sandbox egress forwarded host is not owned by any credential provider"
-    );
+    logWarn("sandbox.egress.provider.unresolved", {
+      ...egressAttributes({
+        egressId: activeEgressId,
+        host: upstreamUrl.hostname,
+        method: request.method,
+        path: upstreamUrl.pathname,
+        status: 403
+      }),
+      ...routingAttributes(request, upstreamUrl)
+    });
     return jsonError("No provider owns forwarded host", 403);
   }
   const credentialContext = parseSandboxEgressCredentialToken(
     credentialTokenFromRequest(request)
   );
   if (!credentialContext || credentialContext.egressId !== activeEgressId) {
-    logWarn(
-      "sandbox_egress_credential_context_unauthorized",
-      {},
-      {
-        ...egressAttributes({
-          egressId: activeEgressId,
-          host: upstreamUrl.hostname,
-          method: request.method,
-          path: upstreamUrl.pathname,
-          provider,
-          status: 403
-        }),
-        ...routingAttributes(request, upstreamUrl)
-      },
-      "Sandbox egress request did not include a valid credential context for the VM session"
-    );
+    logWarn("sandbox.egress.credential_context.unauthorized", {
+      ...egressAttributes({
+        egressId: activeEgressId,
+        host: upstreamUrl.hostname,
+        method: request.method,
+        path: upstreamUrl.pathname,
+        provider,
+        status: 403
+      }),
+      ...routingAttributes(request, upstreamUrl)
+    });
     return jsonError(
       "Sandbox egress credential context is not authorized",
       403
@@ -2526,16 +2448,11 @@ async function lookupSlackUser(teamId, userId) {
       }
     );
     if (!response.ok) {
-      logWarn(
-        "slack_user_lookup_failed",
-        {},
-        {
-          "enduser.id": userId,
-          "app.slack.team_id": teamId,
-          "http.response.status_code": response.status
-        },
-        "Slack user lookup request failed"
-      );
+      logWarn("slack.user.lookup.failed", {
+        "enduser.id": userId,
+        "app.slack.team_id": teamId,
+        "http.response.status_code": response.status
+      });
       return null;
     }
     const parsed = slackUserInfoSchema.safeParse(await response.json());
@@ -2553,16 +2470,11 @@ async function lookupSlackUser(teamId, userId) {
     writeToCache(teamId, userId, result);
     return result;
   } catch (error) {
-    logWarn(
-      "slack_user_lookup_failed",
-      {},
-      {
-        "enduser.id": userId,
-        "app.slack.team_id": teamId,
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Slack user lookup failed with exception"
-    );
+    logWarn("slack.user.lookup.failed", {
+      "enduser.id": userId,
+      "app.slack.team_id": teamId,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return null;
   }
 }
@@ -3343,12 +3255,9 @@ async function handleUnlink(event, actorId, provider) {
   }
   const tokenStore = createUserTokenStore();
   await tokenStore.delete(actorId, provider);
-  logInfo(
-    "slash_command_unlink",
-    { userId: actorId },
-    { "app.credential.provider": provider },
-    `Unlinked ${formatProviderLabel(provider)} account via ${getCommandName()} slash command`
-  );
+  logInfo("slash_command.credential.unlinked", {
+    "app.credential.provider": provider
+  });
   await postEphemeral(
     event,
     `Your ${formatProviderLabel(provider)} account has been unlinked.`
@@ -3390,6 +3299,18 @@ async function unlinkProvider(userId, provider, userTokenStore) {
 }
 
 // src/chat/ingress/slack-webhook.ts
+function slackEventLogContext(event) {
+  const channelId = event?.channel?.trim() || void 0;
+  const threadTs = event?.thread_ts?.trim() || event?.ts?.trim() || void 0;
+  const conversationId = channelId && threadTs ? `slack:${channelId}:${threadTs}` : void 0;
+  return {
+    platform: "slack",
+    conversationId,
+    messageConversationId: conversationId,
+    destinationName: channelId,
+    userId: event?.user?.trim() || void 0
+  };
+}
 var IGNORED_MESSAGE_SUBTYPES = /* @__PURE__ */ new Set([
   "message_changed",
   "message_deleted",
@@ -3559,17 +3480,17 @@ async function handleSlackEvent(args) {
   const installation = installationFromEnvelope(args.body);
   const receivedAtMs = Date.now();
   async function publishAppHomeViewBestEffort(userId) {
-    try {
-      await publishAppHomeView(
-        getSlackClient(),
-        userId,
-        getUserTokenStore(args.services)
-      );
-    } catch (error) {
-      logException(error, "slack_app_home_publish_failed", {
-        userId
-      });
-    }
+    await withLogContext({ platform: "slack", userId }, async () => {
+      try {
+        await publishAppHomeView(
+          getSlackClient(),
+          userId,
+          getUserTokenStore(args.services)
+        );
+      } catch (error) {
+        logException(error, "slack.app_home.publish.failed");
+      }
+    });
   }
   await runWithWorkspaceTeamId(
     installation.teamId,
@@ -3722,22 +3643,16 @@ async function handleInteractivePayload(args) {
       try {
         await unlinkProvider(userId, provider, args.userTokenStore);
       } catch (error) {
-        logException(
-          error,
-          "app_home_disconnect_unlink_failed",
-          { userId },
-          { "app.credential.provider": provider }
-        );
+        logException(error, "app_home.disconnect_unlink.failed", {
+          "app.credential.provider": provider
+        });
       }
       try {
         await publishAppHomeView(getSlackClient(), userId, args.userTokenStore);
       } catch (error) {
-        logException(
-          error,
-          "app_home_disconnect_publish_failed",
-          { userId },
-          { "app.credential.provider": provider }
-        );
+        logException(error, "app_home.disconnect_publish.failed", {
+          "app.credential.provider": provider
+        });
       }
     }
   );
@@ -3764,23 +3679,27 @@ async function handleSlackForm(args) {
     const installation2 = installationFromForm(params);
     enqueue(
       args.waitUntil,
-      runWithWorkspaceTeamId(
-        installation2.teamId,
-        () => runWithSlackInstallation({
-          adapter,
-          installation: installation2,
-          state,
-          task: () => handleSlashCommandForm({
+      withLogContext(
+        {
+          platform: "slack",
+          userId: params.get("user_id")?.trim() || void 0
+        },
+        () => runWithWorkspaceTeamId(
+          installation2.teamId,
+          () => runWithSlackInstallation({
             adapter,
-            params,
-            state
+            installation: installation2,
+            state,
+            task: () => handleSlashCommandForm({
+              adapter,
+              params,
+              state
+            })
           })
+        ).catch((error) => {
+          logException(error, "slash_command.failed");
         })
-      ).catch((error) => {
-        logException(error, "slash_command_failed", {
-          userId: params.get("user_id") ?? void 0
-        });
-      })
+      )
     );
     return new Response("", { status: 200 });
   }
@@ -3795,22 +3714,26 @@ async function handleSlackForm(args) {
   const installation = installationFromInteractive(payload);
   enqueue(
     args.waitUntil,
-    runWithWorkspaceTeamId(
-      installation.teamId,
-      () => runWithSlackInstallation({
-        adapter,
-        installation,
-        state,
-        task: () => handleInteractivePayload({
-          payload,
-          userTokenStore: getUserTokenStore(args.services)
+    withLogContext(
+      {
+        platform: "slack",
+        userId: payload.user?.id?.trim() || void 0
+      },
+      () => runWithWorkspaceTeamId(
+        installation.teamId,
+        () => runWithSlackInstallation({
+          adapter,
+          installation,
+          state,
+          task: () => handleInteractivePayload({
+            payload,
+            userTokenStore: getUserTokenStore(args.services)
+          })
         })
+      ).catch((error) => {
+        logException(error, "slack.interactive.payload.failed");
       })
-    ).catch((error) => {
-      logException(error, "slack_interactive_payload_failed", {
-        userId: payload.user?.id?.trim() || void 0
-      });
-    })
+    )
   );
   return new Response("", { status: 200 });
 }
@@ -3837,27 +3760,42 @@ async function handleSlackWebhook(args) {
     return Response.json({ challenge });
   }
   if (parsed.type === "event_callback") {
-    const eventTask = handleSlackEvent({
-      body: parsed,
-      services: args.services
-    });
+    const eventLogContext = slackEventLogContext(parsed.event);
     if (shouldPersistBeforeAck(parsed)) {
-      try {
-        await eventTask;
-      } catch (error) {
-        if (error instanceof SlackEventPersistenceError) {
-          logException(error.cause, "slack_event_persist_failed");
-        } else {
-          logException(error, "slack_event_routing_failed");
+      const failureResponse = await withLogContext(
+        eventLogContext,
+        async () => {
+          try {
+            await handleSlackEvent({
+              body: parsed,
+              services: args.services
+            });
+          } catch (error) {
+            if (error instanceof SlackEventPersistenceError) {
+              logException(error.cause, "slack.event.persist.failed");
+            } else {
+              logException(error, "slack.event.routing.failed");
+            }
+            return new Response("Slack event handling failed", { status: 503 });
+          }
+          return void 0;
         }
-        return new Response("Slack event handling failed", { status: 503 });
+      );
+      if (failureResponse) {
+        return failureResponse;
       }
     } else {
       enqueue(
         args.waitUntil,
-        eventTask.catch((error) => {
-          logException(error, "slack_event_enqueue_failed");
-        })
+        withLogContext(
+          eventLogContext,
+          () => handleSlackEvent({
+            body: parsed,
+            services: args.services
+          }).catch((error) => {
+            logException(error, "slack.event.enqueue.failed");
+          })
+        )
       );
     }
   }
@@ -3887,17 +3825,12 @@ async function handleWebhookRequest(request, platform, run) {
               } catch {
                 responseBodySnippet = void 0;
               }
-              logWarn(
-                "webhook_non_success_response",
-                {},
-                {
-                  "http.response.status_code": response.status,
-                  "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
-                  "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
-                  ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
-                },
-                `Webhook ${platform} returned ${response.status}`
-              );
+              logWarn("webhook.response.unsuccessful", {
+                "http.response.status_code": response.status,
+                "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
+                "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
+                ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
+              });
             }
             setSpanAttributes({
               "http.response.status_code": response.status
@@ -3915,7 +3848,7 @@ async function handleWebhookRequest(request, platform, run) {
         }
       );
     } catch (error) {
-      logException(error, "webhook_handler_failed");
+      logException(error, "webhook.handler.failed");
       throw error;
     }
   });
@@ -4017,17 +3950,12 @@ async function recordFailedDeliveryAttempt(args) {
     state: args.options.state
   });
   for (const message of failure.deadLetteredMessages) {
-    logWarn(
-      "conversation_work_dead_lettered",
-      { conversationId: args.conversationId },
-      {
-        "app.conversation.source": message.source,
-        "app.inbound.attempt_count": message.attemptCount ?? 0,
-        "app.inbound.message_id": message.inboundMessageId,
-        "app.inbound.pending_count": failure.pendingCount
-      },
-      "Conversation work message consumed after exceeding the delivery attempt limit"
-    );
+    logWarn("conversation.work.dead_lettered", {
+      "app.conversation.source": message.source,
+      "app.inbound.attempt_count": message.attemptCount ?? 0,
+      "app.inbound.message_id": message.inboundMessageId,
+      "app.inbound.pending_count": failure.pendingCount
+    });
   }
   return failure;
 }
@@ -4047,22 +3975,11 @@ function startLeaseCheckIn(args) {
       (checkedIn) => {
         if (!checkedIn) {
           args.onLostLease();
-          logWarn(
-            "conversation_work_check_in_failed",
-            { conversationId: args.conversationId },
-            {},
-            "Conversation work check-in lost its lease"
-          );
+          logWarn("conversation.work.check_in.failed");
         }
       },
       (error) => {
-        logException(
-          error,
-          "conversation_work_check_in_failed",
-          { conversationId: args.conversationId },
-          {},
-          "Conversation work check-in failed"
-        );
+        logException(error, "conversation.work.check_in.failed");
       }
     );
   }, args.options.checkInIntervalMs ?? CONVERSATION_WORK_CHECK_IN_INTERVAL_MS);
@@ -4070,6 +3987,12 @@ function startLeaseCheckIn(args) {
   return timer;
 }
 async function processConversationWork(message, options) {
+  return withLogContext(
+    { conversationId: message.conversationId },
+    () => processConversationWorkInContext(message, options)
+  );
+}
+async function processConversationWorkInContext(message, options) {
   const conversationId = message.conversationId;
   let initial;
   try {
@@ -4133,14 +4056,9 @@ async function processConversationWork(message, options) {
       replaceExistingWake: true,
       state: options.state
     });
-    logInfo(
-      "conversation_work_nudge_deferred_for_active_lease",
-      { conversationId },
-      {
-        "app.lease.expires_at_ms": lease.leaseExpiresAtMs
-      },
-      "Conversation work nudge deferred for active lease"
-    );
+    logInfo("conversation.work.nudge.deferred", {
+      "app.lease.expires_at_ms": lease.leaseExpiresAtMs
+    });
     return { status: "active" };
   }
   const startedAtMs = now(options);
@@ -4158,15 +4076,10 @@ async function processConversationWork(message, options) {
     onLostLease: markLeaseLost,
     options
   });
-  logInfo(
-    "conversation_work_lease_acquired",
-    { conversationId },
-    {
-      "app.lease.expires_at_ms": lease.leaseExpiresAtMs,
-      "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-    },
-    "Conversation work lease acquired"
-  );
+  logInfo("conversation.work.lease.acquired", {
+    "app.lease.expires_at_ms": lease.leaseExpiresAtMs,
+    "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
+  });
   const drain = (handle) => drainConversationMailbox({
     conversationId,
     leaseToken: lease.leaseToken,
@@ -4218,15 +4131,10 @@ async function processConversationWork(message, options) {
     if (!released) {
       return { status: "lost_lease" };
     }
-    logInfo(
-      "conversation_work_cooperative_yield",
-      { conversationId },
-      {
-        "app.worker.elapsed_ms": now(options) - startedAtMs,
-        "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-      },
-      "Conversation work yielded cooperatively"
-    );
+    logInfo("conversation.work.yielded", {
+      "app.worker.elapsed_ms": now(options) - startedAtMs,
+      "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
+    });
     return { status: "yielded" };
   };
   try {
@@ -4439,14 +4347,9 @@ async function processConversationWork(message, options) {
       });
       return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
     }
-    logInfo(
-      "conversation_work_completed",
-      { conversationId },
-      {
-        "app.worker.elapsed_ms": now(options) - startedAtMs
-      },
-      "Conversation work completed"
-    );
+    logInfo("conversation.work.completed", {
+      "app.worker.elapsed_ms": now(options) - startedAtMs
+    });
     return { status: "completed" };
   } catch (error) {
     const errorNowMs = now(options);
@@ -4501,24 +4404,12 @@ async function processConversationWork(message, options) {
       }
       recoveryRecorded = true;
     } catch (recoveryError) {
-      logException(
-        recoveryError,
-        "conversation_work_requeue_failed",
-        { conversationId },
-        {},
-        "Conversation work recovery failed after runner error"
-      );
+      logException(recoveryError, "conversation.work.requeue.failed");
     }
     if (!isProviderRetryError(error)) {
-      logException(
-        error,
-        "conversation_work_failed",
-        { conversationId },
-        {
-          "app.worker.elapsed_ms": now(options) - startedAtMs
-        },
-        "Conversation work failed"
-      );
+      logException(error, "conversation.work.failed", {
+        "app.worker.elapsed_ms": now(options) - startedAtMs
+      });
     }
     if (!recoveryRecorded) {
       throw error;
@@ -4580,18 +4471,15 @@ async function handleConversationQueueMessage(message, metadata, options) {
   }
 }
 function logConversationQueueMessageRejected(reason, metadata, context = {}) {
-  logWarn(
-    "conversation_queue_message_rejected",
-    context.conversationId ? { conversationId: context.conversationId } : {},
-    {
+  withLogContext({ conversationId: context.conversationId }, () => {
+    logWarn("conversation.queue.message.rejected", {
       "app.queue.consumer_group": metadata.consumerGroup,
       "app.queue.delivery_count": metadata.deliveryCount,
       "app.queue.message_id": metadata.messageId,
       "app.queue.reject_reason": reason,
       "app.queue.topic_name": metadata.topicName
-    },
-    "Conversation queue message rejected without retry"
-  );
+    });
+  });
 }
 function handleConversationQueueRetry(error, metadata) {
   if (!isConversationQueueMessageRejectedError(error)) {
@@ -4633,18 +4521,13 @@ import {
 var PLUGIN_TASK_DEV_CONSUMER_GROUP = "junior_plugin_tasks_dev";
 var PLUGIN_TASK_MAX_DELIVERIES = 5;
 function logPluginTaskQueueMessageRejected(reason, metadata) {
-  logWarn(
-    "plugin_task_queue_message_rejected",
-    {},
-    {
-      "app.queue.consumer_group": metadata.consumerGroup,
-      "app.queue.delivery_count": metadata.deliveryCount,
-      "app.queue.message_id": metadata.messageId,
-      "app.queue.reject_reason": reason,
-      "app.queue.topic_name": metadata.topicName
-    },
-    "Plugin task queue message rejected without retry"
-  );
+  logWarn("plugin.task.queue_message.rejected", {
+    "app.queue.consumer_group": metadata.consumerGroup,
+    "app.queue.delivery_count": metadata.deliveryCount,
+    "app.queue.message_id": metadata.messageId,
+    "app.queue.reject_reason": reason,
+    "app.queue.topic_name": metadata.topicName
+  });
 }
 async function handlePluginTaskQueueMessage(message, metadata) {
   const verification = verifyPluginTaskQueueMessage(message);
@@ -5168,8 +5051,7 @@ function createSlackTurnRuntime(deps) {
         const started = await startSlackProcessingReaction({
           thread,
           message: targetMessage,
-          logException: deps.logException,
-          logContext: context
+          logException: deps.logException
         });
         processingReactions.push(started);
         if (reactionKey) {
@@ -5185,17 +5067,11 @@ function createSlackTurnRuntime(deps) {
     try {
       await args.thread.post(buildTurnFailureResponse(args.eventId));
     } catch (postError) {
-      deps.logException(
-        postError,
-        args.postFailureEventName,
-        args.errorContext,
-        {
-          "app.slack.reply_stage": "error_fallback_post",
-          "app.error.original_event_id": args.eventId,
-          ...getSlackErrorObservabilityAttributes(postError)
-        },
-        args.postFailureBody
-      );
+      deps.logException(postError, args.postFailureEventName, {
+        "app.slack.reply_stage": "error_fallback_post",
+        "app.error.original_event_id": args.eventId,
+        ...getSlackErrorObservabilityAttributes(postError)
+      });
       throw postError;
     }
   };
@@ -5233,8 +5109,7 @@ function createSlackTurnRuntime(deps) {
     };
   };
   const logSkippedSubscribedDecision = (args) => {
-    deps.logWarn(
-      "subscribed_message_reply_skipped",
+    withLogContext(
       logContext({
         threadId: args.context.threadId,
         actorId: args.context.actorId,
@@ -5242,10 +5117,11 @@ function createSlackTurnRuntime(deps) {
         channelId: args.context.channelId,
         runId: args.context.runId
       }),
-      {
-        "app.decision.reason": args.decision.reason
-      },
-      "Skipping subscribed message reply"
+      () => {
+        deps.logWarn("subscribed_message.reply.skipped", {
+          "app.decision.reason": args.decision.reason
+        });
+      }
     );
   };
   const skipSubscribedMessage = async (args) => {
@@ -5337,13 +5213,9 @@ function createSlackTurnRuntime(deps) {
         });
       }
     } catch (error) {
-      deps.logException(
-        error,
-        "skipped_steering_flush_failed",
-        args.context,
-        {},
-        "Failed to reapply skipped steering message records"
-      );
+      withLogContext(args.context, () => {
+        deps.logException(error, "agent.turn.steering_flush.failed");
+      });
     }
   };
   return {
@@ -5442,50 +5314,40 @@ function createSlackTurnRuntime(deps) {
           });
         });
       } catch (error) {
-        const classifiedFailure = getConversationTurnBoundaryError(error);
-        const failureCause = classifiedFailure?.cause ?? error;
-        if (shouldRethrowTurnControlError(failureCause)) {
-          throw failureCause;
-        }
-        const errorContext = logContext({
+        const failureLogContext = logContext({
           threadId: deps.getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
           channelId: deps.getChannelId(thread, message),
           runId: deps.getRunId(thread, message)
         });
+        const classifiedFailure = getConversationTurnBoundaryError(error);
+        const failureCause = classifiedFailure?.cause ?? error;
+        if (shouldRethrowTurnControlError(failureCause)) {
+          throw failureCause;
+        }
         if (failureCause instanceof AuthorizationFlowDisabledError) {
           return;
         }
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
-          deps.logWarn(
-            "mention_handler_read_only_channel",
-            logContext({
-              threadId: deps.getThreadId(thread, message),
-              actorId: message.author.userId,
-              actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
-            }),
-            {},
-            "Skipping reply to read-only channel"
-          );
+          withLogContext(failureLogContext, () => {
+            deps.logWarn("mention.handler.skipped", {
+              "app.decision.reason": "read_only_channel"
+            });
+          });
           return;
         }
-        const eventId = classifiedFailure?.eventId ?? deps.logException(
-          failureCause,
-          "mention_handler_failed",
-          errorContext,
-          {},
-          "onNewMention failed"
+        const eventId = classifiedFailure?.eventId ?? withLogContext(
+          failureLogContext,
+          () => deps.logException(failureCause, "mention.handler.failed")
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
         }
         if (!eventId) {
           throw new Error(
-            "Sentry did not return an event ID for mention_handler_failed"
+            "Sentry did not return an event ID for mention.handler.failed"
           );
         }
         let lifecycleError;
@@ -5502,10 +5364,8 @@ function createSlackTurnRuntime(deps) {
         await hooks.beforeFirstResponsePost?.();
         await postFallbackErrorReplyWithLogging({
           thread,
-          errorContext,
           eventId,
-          postFailureEventName: "mention_handler_failure_reply_post_failed",
-          postFailureBody: "Failed to post fallback error reply for mention handler"
+          postFailureEventName: "mention.handler.failure_reply_post.failed"
         });
         if (lifecycleError) throw lifecycleError;
       } finally {
@@ -5720,50 +5580,43 @@ function createSlackTurnRuntime(deps) {
           });
         });
       } catch (error) {
-        const classifiedFailure = getConversationTurnBoundaryError(error);
-        const failureCause = classifiedFailure?.cause ?? error;
-        if (shouldRethrowTurnControlError(failureCause)) {
-          throw failureCause;
-        }
-        const errorContext = logContext({
+        const failureLogContext = logContext({
           threadId: deps.getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
           channelId: deps.getChannelId(thread, message),
           runId: deps.getRunId(thread, message)
         });
+        const classifiedFailure = getConversationTurnBoundaryError(error);
+        const failureCause = classifiedFailure?.cause ?? error;
+        if (shouldRethrowTurnControlError(failureCause)) {
+          throw failureCause;
+        }
         if (failureCause instanceof AuthorizationFlowDisabledError) {
           return;
         }
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
-          deps.logWarn(
-            "subscribed_message_handler_read_only_channel",
-            logContext({
-              threadId: deps.getThreadId(thread, message),
-              actorId: message.author.userId,
-              actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
-            }),
-            {},
-            "Skipping reply to read-only channel"
-          );
+          withLogContext(failureLogContext, () => {
+            deps.logWarn("subscribed_message.handler.skipped", {
+              "app.decision.reason": "read_only_channel"
+            });
+          });
           return;
         }
-        const eventId = classifiedFailure?.eventId ?? deps.logException(
-          failureCause,
-          "subscribed_message_handler_failed",
-          errorContext,
-          {},
-          "onSubscribedMessage failed"
+        const eventId = classifiedFailure?.eventId ?? withLogContext(
+          failureLogContext,
+          () => deps.logException(
+            failureCause,
+            "subscribed_message.handler.failed"
+          )
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
         }
         if (!eventId) {
           throw new Error(
-            "Sentry did not return an event ID for subscribed_message_handler_failed"
+            "Sentry did not return an event ID for subscribed_message.handler.failed"
           );
         }
         let lifecycleError;
@@ -5780,10 +5633,8 @@ function createSlackTurnRuntime(deps) {
         await hooks.beforeFirstResponsePost?.();
         await postFallbackErrorReplyWithLogging({
           thread,
-          errorContext,
           eventId,
-          postFailureEventName: "subscribed_message_handler_failure_reply_post_failed",
-          postFailureBody: "Failed to post fallback error reply for subscribed message handler"
+          postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
         });
         if (lifecycleError) throw lifecycleError;
       } finally {
@@ -5806,52 +5657,46 @@ function createSlackTurnRuntime(deps) {
       }
     },
     async handleAssistantThreadStarted(event) {
-      try {
-        await deps.initializeAssistantThread({
+      await withLogContext(
+        logContext({
           threadId: event.threadId,
-          channelId: event.channelId,
-          threadTs: event.threadTs,
-          sourceChannelId: event.context?.channelId
-        });
-      } catch (error) {
-        deps.logException(
-          error,
-          "assistant_thread_started_handler_failed",
-          {
-            messageConversationId: event.threadId,
-            userId: event.userId,
-            destinationName: event.channelId,
-            assistantUserName: deps.assistantUserName,
-            modelId: deps.modelId
-          },
-          {},
-          "onAssistantThreadStarted failed"
-        );
-      }
+          actorId: event.userId,
+          channelId: event.channelId
+        }),
+        async () => {
+          try {
+            await deps.initializeAssistantThread({
+              threadId: event.threadId,
+              channelId: event.channelId,
+              threadTs: event.threadTs,
+              sourceChannelId: event.context?.channelId
+            });
+          } catch (error) {
+            deps.logException(error, "assistant.thread.initialization.failed");
+          }
+        }
+      );
     },
     async handleAssistantContextChanged(event) {
-      try {
-        await deps.refreshAssistantThreadContext({
+      await withLogContext(
+        logContext({
           threadId: event.threadId,
-          channelId: event.channelId,
-          threadTs: event.threadTs,
-          sourceChannelId: event.context?.channelId
-        });
-      } catch (error) {
-        deps.logException(
-          error,
-          "assistant_context_changed_handler_failed",
-          {
-            messageConversationId: event.threadId,
-            userId: event.userId,
-            destinationName: event.channelId,
-            assistantUserName: deps.assistantUserName,
-            modelId: deps.modelId
-          },
-          {},
-          "onAssistantContextChanged failed"
-        );
-      }
+          actorId: event.userId,
+          channelId: event.channelId
+        }),
+        async () => {
+          try {
+            await deps.refreshAssistantThreadContext({
+              threadId: event.threadId,
+              channelId: event.channelId,
+              threadTs: event.threadTs,
+              sourceChannelId: event.context?.channelId
+            });
+          } catch (error) {
+            deps.logException(error, "assistant.context.refresh.failed");
+          }
+        }
+      );
     }
   };
 }
@@ -5864,22 +5709,10 @@ function createSubscribedReplyPolicy(deps) {
       modelId: botConfig.fastModelId,
       input: args,
       completeObject: deps.completeObject,
-      logClassifierFailure: (error, input) => {
-        logWarn(
-          "subscribed_message_classifier_failed",
-          {
-            messageConversationId: input.context.threadId,
-            userId: input.context.actorId,
-            destinationName: input.context.channelId,
-            runId: input.context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: botConfig.fastModelId
-          },
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Subscribed-message classifier failed; skipping reply"
-        );
+      logClassifierFailure: (error) => {
+        logWarn("subscribed_message.classifier.failed", {
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
       }
     });
     const reason = decision.reasonDetail ? `${decision.reason}:${decision.reasonDetail}` : decision.reason;
@@ -5928,6 +5761,18 @@ function buildImageAttachmentPromptText(args) {
     "</image-attachment>"
   ].join("\n");
 }
+function buildImageAttachmentFailurePromptText(args) {
+  return [
+    "<image-attachment>",
+    `filename: ${args.filename ?? "unnamed"}`,
+    `media_type: ${args.mediaType}`,
+    "<analysis-error>",
+    args.message,
+    "The image contents are unavailable.",
+    "</analysis-error>",
+    "</image-attachment>"
+  ].join("\n");
+}
 async function summarizeImageWithVision(args) {
   const visionModelId = botConfig.visionModelId;
   if (!visionModelId) {
@@ -6076,22 +5921,10 @@ async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
       }
       if (!data) continue;
       if (data.byteLength > MAX_USER_ATTACHMENT_BYTES) {
-        logWarn(
-          "attachment_skipped_size_limit",
-          {
-            messageConversationId: context.threadId,
-            userId: context.actorId,
-            destinationName: context.channelId,
-            runId: context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: standardModelId(botConfig)
-          },
-          {
-            "file.size": data.byteLength,
-            "app.file.mime_type": mediaType
-          },
-          "Skipping user attachment that exceeds size limit"
-        );
+        logWarn("attachment.size_limit.skipped", {
+          "file.size": data.byteLength,
+          "app.file.mime_type": mediaType
+        });
         continue;
       }
       resolvedAttachment.data = data;
@@ -6101,41 +5934,26 @@ async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
         const attachmentError = error instanceof ImageAttachmentProcessingError ? error : createImageAttachmentProcessingError({
           filename: attachment.name
         });
-        logWarn(
-          "image_attachment_processing_failed",
-          {
-            messageConversationId: context.threadId,
-            userId: context.actorId,
-            destinationName: context.channelId,
-            runId: context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: botConfig.visionModelId ?? standardModelId(botConfig)
-          },
-          {
-            "exception.message": error instanceof Error ? error.message : String(error),
-            "app.file.mime_type": mediaType,
-            ...attachment.name ? { "file.name": attachment.name } : {}
-          },
-          "Image attachment processing failed"
-        );
-        throw attachmentError;
-      }
-      logWarn(
-        "attachment_resolution_failed",
-        {
-          messageConversationId: context.threadId,
-          userId: context.actorId,
-          destinationName: context.channelId,
-          runId: context.runId,
-          assistantUserName: botConfig.userName,
-          modelId: standardModelId(botConfig)
-        },
-        {
+        logWarn("image.attachment.processing.failed", {
           "exception.message": error instanceof Error ? error.message : String(error),
-          "app.file.mime_type": mediaType
-        },
-        "Failed to resolve user attachment"
-      );
+          "app.file.mime_type": mediaType,
+          ...attachment.name ? { "file.name": attachment.name } : {}
+        });
+        results.push({
+          mediaType,
+          filename: attachment.name,
+          promptText: buildImageAttachmentFailurePromptText({
+            filename: attachment.name,
+            mediaType,
+            message: attachmentError.message
+          })
+        });
+        continue;
+      }
+      logWarn("attachment.resolution.failed", {
+        "exception.message": error instanceof Error ? error.message : String(error),
+        "app.file.mime_type": mediaType
+      });
     }
   }
   return results;
@@ -6170,23 +5988,11 @@ async function summarizeConversationImage(args, deps) {
     }
     return truncateVisionSummary(summary);
   } catch (error) {
-    logWarn(
-      "conversation_image_vision_failed",
-      {
-        messageConversationId: args.context.threadId,
-        userId: args.context.actorId,
-        destinationName: args.context.channelId,
-        runId: args.context.runId,
-        assistantUserName: botConfig.userName,
-        modelId: visionModelId
-      },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error),
-        "app.file.id": args.fileId,
-        "app.file.mime_type": args.mimeType
-      },
-      "Image analysis failed while hydrating conversation context"
-    );
+    logWarn("conversation.image.vision.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error),
+      "app.file.id": args.fileId,
+      "app.file.mime_type": args.mimeType
+    });
     return void 0;
   }
 }
@@ -6226,21 +6032,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       targetMessageTs: [...messagesByTs.keys()]
     });
   } catch (error) {
-    logWarn(
-      "conversation_image_replies_fetch_failed",
-      {
-        messageConversationId: context.threadId,
-        userId: context.actorId,
-        destinationName: context.channelId,
-        runId: context.runId,
-        assistantUserName: botConfig.userName,
-        modelId: standardModelId(botConfig)
-      },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to fetch thread replies for image context hydration"
-    );
+    logWarn("conversation.image.replies_fetch.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
     return;
   }
   let cacheHits = 0;
@@ -6293,23 +6087,11 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       const mimeType = toOptionalString(file.mimetype) ?? "application/octet-stream";
       const fileSize = typeof file.size === "number" && Number.isFinite(file.size) ? file.size : void 0;
       if (fileSize && fileSize > MAX_USER_ATTACHMENT_BYTES) {
-        logWarn(
-          "conversation_image_skipped_size_limit",
-          {
-            messageConversationId: context.threadId,
-            userId: context.actorId,
-            destinationName: context.channelId,
-            runId: context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: standardModelId(botConfig)
-          },
-          {
-            "app.file.id": fileId,
-            "file.size": fileSize,
-            "app.file.mime_type": mimeType
-          },
-          "Skipping thread image that exceeds size limit"
-        );
+        logWarn("conversation.image.size_limit.skipped", {
+          "app.file.id": fileId,
+          "file.size": fileSize,
+          "app.file.mime_type": mimeType
+        });
         continue;
       }
       const downloadUrl = toOptionalString(file.url_private_download) ?? toOptionalString(file.url_private);
@@ -6320,43 +6102,19 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       try {
         imageData = await deps.downloadFile(downloadUrl);
       } catch (error) {
-        logWarn(
-          "conversation_image_download_failed",
-          {
-            messageConversationId: context.threadId,
-            userId: context.actorId,
-            destinationName: context.channelId,
-            runId: context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: standardModelId(botConfig)
-          },
-          {
-            "exception.message": error instanceof Error ? error.message : String(error),
-            "app.file.id": fileId,
-            "app.file.mime_type": mimeType
-          },
-          "Failed to download thread image for context hydration"
-        );
+        logWarn("conversation.image.download.failed", {
+          "exception.message": error instanceof Error ? error.message : String(error),
+          "app.file.id": fileId,
+          "app.file.mime_type": mimeType
+        });
         continue;
       }
       if (imageData.byteLength > MAX_USER_ATTACHMENT_BYTES) {
-        logWarn(
-          "conversation_image_skipped_size_limit",
-          {
-            messageConversationId: context.threadId,
-            userId: context.actorId,
-            destinationName: context.channelId,
-            runId: context.runId,
-            assistantUserName: botConfig.userName,
-            modelId: standardModelId(botConfig)
-          },
-          {
-            "app.file.id": fileId,
-            "file.size": imageData.byteLength,
-            "app.file.mime_type": mimeType
-          },
-          "Skipping downloaded thread image that exceeds size limit"
-        );
+        logWarn("conversation.image.size_limit.skipped", {
+          "app.file.id": fileId,
+          "file.size": imageData.byteLength,
+          "app.file.mime_type": mimeType
+        });
         continue;
       }
       const summary = await summarizeConversationImage(
@@ -6383,24 +6141,12 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
     updateConversationStats(conversation);
   }
   if (cacheHits > 0 || cacheMisses > 0 || analyzed > 0 || hydratedMessageIds.size > 0) {
-    logInfo(
-      "conversation_image_context_hydrated",
-      {
-        messageConversationId: context.threadId,
-        userId: context.actorId,
-        destinationName: context.channelId,
-        runId: context.runId,
-        assistantUserName: botConfig.userName,
-        modelId: standardModelId(botConfig)
-      },
-      {
-        "app.conversation_image.cache_hits": cacheHits,
-        "app.conversation_image.cache_misses": cacheMisses,
-        "app.conversation_image.analyzed": analyzed,
-        "app.conversation_image.messages_hydrated": hydratedMessageIds.size
-      },
-      "Hydrated conversation image context"
-    );
+    logInfo("conversation.image.context.hydrated", {
+      "app.conversation_image.cache_hits": cacheHits,
+      "app.conversation_image.cache_misses": cacheMisses,
+      "app.conversation_image.analyzed": analyzed,
+      "app.conversation_image.messages_hydrated": hydratedMessageIds.size
+    });
   }
   if (!conversation.vision.backfillCompletedAtMs) {
     conversation.vision.backfillCompletedAtMs = Date.now();
@@ -6508,21 +6254,9 @@ function maybeUpdateAssistantTitle(args) {
     try {
       title = await args.generateThreadTitle(titleSourceMessage.text);
     } catch (error) {
-      logWarn(
-        "thread_title_generation_failed",
-        {
-          messageConversationId: args.threadId,
-          userId: args.actorId,
-          destinationName: args.channelId,
-          runId: args.runId,
-          assistantUserName: args.assistantUserName,
-          modelId: args.modelId
-        },
-        {
-          "exception.message": error instanceof Error ? error.message : String(error)
-        },
-        "Thread title generation failed"
-      );
+      logWarn("thread.title.generation.failed", {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
       return void 0;
     }
     if (isDm) {
@@ -6543,34 +6277,13 @@ function maybeUpdateAssistantTitle(args) {
         if (isSlackTitlePermissionError(error)) {
           setSpanAttributes(assistantTitleErrorAttributes);
           logError(
-            "thread_title_generation_permission_denied",
-            {
-              messageConversationId: args.threadId,
-              userId: args.actorId,
-              destinationName: args.channelId,
-              runId: args.runId,
-              assistantUserName: args.assistantUserName,
-              modelId: args.modelId
-            },
-            assistantTitleErrorAttributes,
-            "Skipping Slack thread title update due to permission error"
+            "thread.title.generation_permission.denied",
+            assistantTitleErrorAttributes
           );
         } else {
-          logWarn(
-            "thread_title_slack_update_failed",
-            {
-              messageConversationId: args.threadId,
-              userId: args.actorId,
-              destinationName: args.channelId,
-              runId: args.runId,
-              assistantUserName: args.assistantUserName,
-              modelId: args.modelId
-            },
-            {
-              "exception.message": error instanceof Error ? error.message : String(error)
-            },
-            "Slack thread title update failed"
-          );
+          logWarn("thread.title.slack_update.failed", {
+            "exception.message": error instanceof Error ? error.message : String(error)
+          });
         }
       }
     }
@@ -6855,15 +6568,6 @@ function createReplyToThread(deps) {
         });
         const slackMessageTs = getSlackMessageTs(message);
         const turnId = options.execution?.turnId ?? buildDeterministicTurnId(message.id);
-        const turnTraceContext = {
-          conversationId,
-          messageConversationId: threadId,
-          userId: message.author.userId,
-          destinationName: channelId,
-          runId,
-          assistantUserName: botConfig.userName,
-          modelId: standardModelId(botConfig)
-        };
         let beforeFirstResponsePostCalled = false;
         const beforeFirstResponsePost = async () => {
           if (beforeFirstResponsePostCalled) {
@@ -6894,17 +6598,11 @@ function createReplyToThread(deps) {
               await thread.post(buildSlackOutputMessage(text));
             }
           } catch (error) {
-            logException(
-              error,
-              "slack_auth_pause_notice_post_failed",
-              turnTraceContext,
-              {
-                "app.slack.reply_stage": "thread_reply_auth_pause_notice",
-                ...messageTs ? { "messaging.message.id": messageTs } : {},
-                ...getSlackErrorObservabilityAttributes(error)
-              },
-              "Failed to post auth pause notice"
-            );
+            logException(error, "slack.auth_pause.notice_post.failed", {
+              "app.slack.reply_stage": "thread_reply_auth_pause_notice",
+              ...messageTs ? { "messaging.message.id": messageTs } : {},
+              ...getSlackErrorObservabilityAttributes(error)
+            });
           }
         };
         let activeTurnId = preparedState.conversation.processing.activeTurnId;
@@ -7027,17 +6725,11 @@ function createReplyToThread(deps) {
             try {
               await deps.services.scheduleAgentContinue(resumeRequest);
             } catch (error) {
-              logException(
-                error,
-                "agent_continue_schedule_failed",
-                turnTraceContext,
-                {
-                  "app.ai.resume_session_version": resumeRequest.expectedVersion,
-                  "app.ai.resume_session_id": resumeRequest.sessionId,
-                  ...messageTs ? { "messaging.message.id": messageTs } : {}
-                },
-                "Failed to reschedule active agent continuation"
-              );
+              logException(error, "agent.continue.schedule.failed", {
+                "app.ai.resume_session_version": resumeRequest.expectedVersion,
+                "app.ai.resume_session_id": resumeRequest.sessionId,
+                ...messageTs ? { "messaging.message.id": messageTs } : {}
+              });
               throw error;
             }
             await persistThreadState(thread, {
@@ -7157,28 +6849,19 @@ function createReplyToThread(deps) {
             source,
             traceId: getActiveTraceId()
           }).catch((error) => {
-            logException(
-              error,
-              "agent_turn_summary_record_failed",
-              turnTraceContext,
-              { "app.agent.turn.state": "running" },
-              "Failed to record running turn summary"
-            );
+            logException(error, "agent.turn.summary_record.failed", {
+              "app.agent.turn.state": "running"
+            });
           });
         }
         setTags({
           conversationId
         });
         if (shouldEmitDevAgentTrace()) {
-          logInfo(
-            "agent_turn_started",
-            turnTraceContext,
-            {
-              "app.message.id": message.id,
-              ...messageTs ? { "messaging.message.id": messageTs } : {}
-            },
-            "Agent turn started"
-          );
+          logInfo("agent.turn.started", {
+            "app.message.id": message.id,
+            ...messageTs ? { "messaging.message.id": messageTs } : {}
+          });
         }
         await persistThreadState(thread, {
           conversation: preparedState.conversation
@@ -7259,8 +6942,10 @@ function createReplyToThread(deps) {
           await options.onTurnCompleted?.();
           turnCompletionNotified = true;
         };
-        const deliverAssistantMessage = async (assistantMessage, terminalDispatchOutcome) => {
-          if (!assistantMessage.text.trim()) {
+        const deliverAssistantMessage = async (reply, terminalDispatchOutcome) => {
+          const agentMessage = typeof reply === "string" ? void 0 : reply;
+          const text = typeof reply === "string" ? reply : getAssistantReplyText(reply);
+          if (!text?.trim()) {
             return;
           }
           boundaryFailureCode = "delivery_failed";
@@ -7271,29 +6956,23 @@ function createReplyToThread(deps) {
               slackTs = await sendSlackReply({
                 channelId,
                 conversationId,
-                text: assistantMessage.text,
+                text,
                 ...threadTs ? { threadTs } : {}
               });
             } else {
-              for (const text of splitSlackReplyText(assistantMessage.text)) {
-                slackTs = (await thread.post(buildSlackOutputMessage(text))).id;
+              for (const part of splitSlackReplyText(text)) {
+                slackTs = (await thread.post(buildSlackOutputMessage(part))).id;
               }
             }
           } catch (error) {
             if (isRetryableSlackPostError(error)) {
               throw new RetryableDeliveryError(error);
             }
-            const eventId = logException(
-              error,
-              "slack_thread_post_failed",
-              turnTraceContext,
-              {
-                "app.slack.reply_stage": "thread_reply",
-                ...messageTs ? { "messaging.message.id": messageTs } : {},
-                ...getSlackErrorObservabilityAttributes(error)
-              },
-              "Failed to post Slack thread reply"
-            );
+            const eventId = logException(error, "slack.thread.post.failed", {
+              "app.slack.reply_stage": "thread_reply",
+              ...messageTs ? { "messaging.message.id": messageTs } : {},
+              ...getSlackErrorObservabilityAttributes(error)
+            });
             throw new ConversationTurnBoundaryError({
               cause: error,
               ...eventId ? { eventId } : {},
@@ -7306,7 +6985,7 @@ function createReplyToThread(deps) {
           const recordedMessageId = recordDeliveredAssistantMessage({
             conversation: preparedState.conversation,
             sessionId: turnId,
-            text: assistantMessage.text,
+            text,
             userMessageId: preparedState.userMessageId
           });
           if (slackTs) {
@@ -7318,7 +6997,12 @@ function createReplyToThread(deps) {
           }
           try {
             await persistWithRetry(
-              () => persistConversationMessages({
+              () => agentMessage && conversationId ? commitAcceptedReply({
+                agentMessage,
+                conversation: preparedState.conversation,
+                conversationMessageId: recordedMessageId,
+                conversationId
+              }) : persistConversationMessages({
                 conversation: preparedState.conversation,
                 conversationId
               })
@@ -7326,12 +7010,10 @@ function createReplyToThread(deps) {
           } catch (error) {
             logException(
               new Error("Accepted assistant message persistence failed"),
-              "slack_assistant_message_post_delivery_persist_failed",
-              turnTraceContext,
+              "slack.assistant.message_post_delivery_persist.failed",
               {
                 "error.type": error instanceof Error ? error.name : typeof error
-              },
-              "Failed to persist an accepted Slack assistant message"
+              }
             );
           }
           if (slackTs && options.execution?.dispatch?.id) {
@@ -7354,13 +7036,7 @@ function createReplyToThread(deps) {
                 })
               );
             } catch (error) {
-              logException(
-                error,
-                "agent_turn_delivery_receipt_persist_failed",
-                turnTraceContext,
-                {},
-                "Failed to persist accepted turn delivery receipt"
-              );
+              logException(error, "agent.turn.delivery_receipt_persist.failed");
             }
           }
           boundaryFailureCode = "agent_run_failed";
@@ -7454,13 +7130,7 @@ function createReplyToThread(deps) {
                   title: titleUpdateResult.title
                 });
               } catch (error) {
-                logException(
-                  error,
-                  "conversation_title_persist_failed",
-                  turnTraceContext,
-                  {},
-                  "Failed to persist generated conversation title"
-                );
+                logException(error, "conversation.title.persist.failed");
               }
             }
             try {
@@ -7468,22 +7138,10 @@ function createReplyToThread(deps) {
                 artifacts: latestArtifacts
               });
             } catch (error) {
-              logException(
-                error,
-                "assistant_title_artifact_persist_failed",
-                turnTraceContext,
-                {},
-                "Failed to persist async assistant title artifact state"
-              );
+              logException(error, "assistant.title.artifact_persist.failed");
             }
           }).catch((error) => {
-            logException(
-              error,
-              "assistant_title_task_failed",
-              turnTraceContext,
-              {},
-              "Async assistant title task failed"
-            );
+            logException(error, "assistant.title.task.failed");
           });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
           const activeInstructionAuthorId = actor?.userId ?? parseActorUserId(message.author.userId);
@@ -7548,9 +7206,7 @@ function createReplyToThread(deps) {
               onStatus: (nextStatus) => status.update(nextStatus),
               onToolInvocation: options.onToolInvocation
             },
-            delivery: {
-              onAssistantMessage: deliverAssistantMessage
-            },
+            delivery: deliverAssistantMessage,
             durability: {
               onInputCommitted: options.ack,
               drainSteeringMessages,
@@ -7585,13 +7241,11 @@ function createReplyToThread(deps) {
                 new Error(
                   `Subscribed Slack turn requires ${outcome.providerDisplayName} authorization`
                 ),
-                "slack_subscribed_turn_authorization_required",
-                turnTraceContext,
-                { "app.ai.failure_code": "agent_run_failed" },
-                "Subscribed Slack turn could not continue without user authorization"
+                "subscribed_message.authorization.required",
+                { "app.ai.failure_code": "agent_run_failed" }
               );
               const text = `I could not act on this subscribed event because ${outcome.providerDisplayName} needs user authorization. Ask me in this thread to connect ${outcome.providerDisplayName} before retrying.`;
-              await deliverAssistantMessage({ text });
+              await deliverAssistantMessage(text);
               markTurnClosed({
                 conversation: preparedState.conversation,
                 nowMs: Date.now(),
@@ -7650,16 +7304,10 @@ function createReplyToThread(deps) {
               });
               shouldPersistFailureState = false;
             } catch (scheduleError) {
-              logException(
-                scheduleError,
-                "agent_continue_schedule_failed",
-                turnTraceContext,
-                {
-                  ...messageTs ? { "messaging.message.id": messageTs } : {},
-                  "app.ai.resume_session_version": outcome.resumeVersion
-                },
-                "Failed to schedule agent continuation"
-              );
+              logException(scheduleError, "agent.continue.schedule.failed", {
+                ...messageTs ? { "messaging.message.id": messageTs } : {},
+                "app.ai.resume_session_version": outcome.resumeVersion
+              });
               shouldPersistFailureState = true;
               agentContinueScheduleError = scheduleError;
               throw scheduleError;
@@ -7667,25 +7315,17 @@ function createReplyToThread(deps) {
             return;
           }
           let reply = outcome.result;
-          const diagnosticsContext = {
-            messageConversationId: threadId,
-            userId: message.author.userId,
-            destinationName: channelId,
-            runId,
-            assistantUserName: botConfig.userName,
-            modelId: reply.diagnostics.modelId
-          };
+          setTags({ modelId: reply.diagnostics.modelId });
           const diagnosticsAttributes = getAgentTurnDiagnosticsAttributes(reply);
           setSpanAttributes(diagnosticsAttributes);
           if (reply.diagnostics.outcome !== "success") {
             const finalized = finalizeFailedTurnReplyWithEvent({
               reply,
-              logException,
-              context: diagnosticsContext
+              logException
             });
             reply = finalized.reply;
             finalizedFailureEventId = finalized.eventId;
-            await deliverAssistantMessage({ text: reply.text });
+            await deliverAssistantMessage(reply.text);
           }
           const turnResult = reply.diagnostics.outcome === "success" ? { outcome: "completed" } : {
             errorMessage: reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`,
@@ -7767,10 +7407,8 @@ function createReplyToThread(deps) {
           } catch (commitError) {
             const persistenceEventId = logException(
               commitError,
-              "slack_reply_post_delivery_commit_failed",
-              turnTraceContext,
-              messageTs ? { "messaging.message.id": messageTs } : {},
-              "Post-delivery turn state persistence failed after Slack accepted the reply"
+              "slack.reply.post_delivery_commit.failed",
+              messageTs ? { "messaging.message.id": messageTs } : {}
             );
             if (conversationId && !lifecycleTerminalized) {
               await deps.services.turnLifecycle.fail({
@@ -7806,16 +7444,11 @@ function createReplyToThread(deps) {
             lifecycleTerminalized = true;
           }
           if (shouldEmitDevAgentTrace()) {
-            logInfo(
-              "agent_turn_completed",
-              turnTraceContext,
-              {
-                "app.ai.outcome": reply.diagnostics.outcome,
-                "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
-                "app.ai.tool_error_results": reply.diagnostics.toolErrorCount
-              },
-              "Agent turn completed"
-            );
+            logInfo("agent.turn.completed", {
+              "app.ai.outcome": reply.diagnostics.outcome,
+              "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+              "app.ai.tool_error_results": reply.diagnostics.toolErrorCount
+            });
           }
           await notifyTurnCompleted();
           if (reply.diagnostics.outcome === "success" && conversationId) {
@@ -7827,10 +7460,7 @@ function createReplyToThread(deps) {
             } catch (error) {
               logException(
                 error,
-                "plugin_session_completed_task_schedule_failed",
-                turnTraceContext,
-                {},
-                "Plugin session.completed task scheduling failed"
+                "plugin.session.completed_task_schedule.failed"
               );
             }
           }
@@ -7839,20 +7469,16 @@ function createReplyToThread(deps) {
             shouldPersistFailureState = false;
             logException(
               error,
-              "slack_reply_post_delivery_commit_failed",
-              turnTraceContext,
-              messageTs ? { "messaging.message.id": messageTs } : {},
-              "Post-delivery turn work failed after Slack accepted the reply"
+              "slack.reply.post_delivery_commit.failed",
+              messageTs ? { "messaging.message.id": messageTs } : {}
             );
             try {
               await notifyTurnCompleted();
             } catch (completionError) {
               logException(
                 completionError,
-                "slack_reply_post_delivery_completion_callback_failed",
-                turnTraceContext,
-                messageTs ? { "messaging.message.id": messageTs } : {},
-                "Post-delivery turn completion callback failed after Slack accepted the reply"
+                "slack.reply.post_delivery_completion_callback.failed",
+                messageTs ? { "messaging.message.id": messageTs } : {}
               );
             }
             return;
@@ -7875,13 +7501,9 @@ function createReplyToThread(deps) {
             terminalDispatchFailureOutcome = "blocked";
           }
           const failureCode = classifiedFailure?.failureCode ?? boundaryFailureCode;
-          const failureEventId = classifiedFailure?.eventId ?? logException(
-            failureCause,
-            "slack_turn_execution_failed",
-            turnTraceContext,
-            { "app.ai.failure_code": failureCode },
-            "Slack turn failed at its reply execution boundary"
-          );
+          const failureEventId = classifiedFailure?.eventId ?? logException(failureCause, "slack.turn.execution.failed", {
+            "app.ai.failure_code": failureCode
+          });
           const createdCanvasUrl = getCurrentTurnCanvasUrl({
             before: preparedState.artifacts,
             after: latestArtifacts
@@ -7890,10 +7512,7 @@ function createReplyToThread(deps) {
             const dispatchOutcome = terminalDispatchFailureOutcome ?? "failed";
             const errorMessage = failureCause instanceof Error ? failureCause.message : "Agent turn failed after creating a canvas";
             const recoveryText = buildCanvasRecoveryReply(createdCanvasUrl);
-            await deliverAssistantMessage(
-              { text: recoveryText },
-              dispatchOutcome
-            );
+            await deliverAssistantMessage(recoveryText, dispatchOutcome);
             if (conversationId) {
               const sessionRecord = await getAgentTurnSessionRecord(
                 conversationId,
@@ -7988,10 +7607,7 @@ function createReplyToThread(deps) {
               } catch (recordError) {
                 logException(
                   recordError,
-                  "agent_turn_failed_session_record_persist_failed",
-                  turnTraceContext,
-                  {},
-                  "Failed to mark failed turn session record"
+                  "agent.turn.failed_session_record_persist.failed"
                 );
               }
             }
@@ -7999,12 +7615,7 @@ function createReplyToThread(deps) {
               conversation: preparedState.conversation
             });
             if (shouldEmitDevAgentTrace()) {
-              logWarn(
-                "agent_turn_failed",
-                turnTraceContext,
-                {},
-                "Agent turn failed"
-              );
+              logWarn("agent.turn.failed");
             }
           }
           await status.clear();
@@ -8553,13 +8164,11 @@ async function failSessionRecordBestEffort(args) {
   } catch (error) {
     logException(
       error,
-      "agent_continue_session_record_fail_persist_failed",
-      {},
+      "agent.continue.session_record.failure_persistence.failed",
       {
         "app.ai.conversation_id": args.sessionRecord.conversationId,
         "app.ai.session_id": args.sessionRecord.sessionId
-      },
-      "Failed to mark paused agent run session record failed"
+      }
     );
   }
 }
@@ -8599,13 +8208,11 @@ async function failContinuationStartup(args) {
     });
     logException(
       persistError,
-      "agent_continue_startup_failure_persist_failed",
-      {},
+      "agent.continue.startup_failure_persist.failed",
       {
         "app.ai.conversation_id": args.sessionRecord.conversationId,
         "app.ai.session_id": args.sessionRecord.sessionId
-      },
-      "Failed to persist paused agent run startup failure"
+      }
     );
   }
 }
@@ -8657,6 +8264,12 @@ async function failUnresumableContinuation(args) {
   }
 }
 async function continueSlackAgentRun(payload, options, runOptions = {}) {
+  return withLogContext(
+    { conversationId: payload.conversationId },
+    () => continueSlackAgentRunInContext(payload, options, runOptions)
+  );
+}
+async function continueSlackAgentRunInContext(payload, options, runOptions) {
   const thread = parseSlackThreadId(payload.conversationId);
   const destination = requireSlackDestination(
     payload.destination,
@@ -8845,15 +8458,10 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
               threadStateId: payload.conversationId
             });
             await recordDispatchOutcome("blocked");
-            logWarn(
-              "agent_continue_reparked_for_auth",
-              {},
-              {
-                "app.ai.conversation_id": payload.conversationId,
-                "app.ai.session_id": payload.sessionId
-              },
-              "Continued agent run parked for auth"
-            );
+            logWarn("agent.continue.reparked_for_auth", {
+              "app.ai.conversation_id": payload.conversationId,
+              "app.ai.session_id": payload.sessionId
+            });
           },
           onSuspend: async (resumeVersion) => {
             await scheduleAgentContinue2({
@@ -8914,17 +8522,11 @@ async function failStrandedSessionWithFallback(args) {
     updateConversationStats
   });
   await persistThreadStateById(args.conversationId, { conversation });
-  const eventName = "agent_turn_stranded_session_failed";
-  const eventId = logException(
-    new Error(args.errorMessage),
-    eventName,
-    { conversationId: args.conversationId },
-    {
-      "app.ai.conversation_id": args.conversationId,
-      "app.ai.session_id": args.sessionRecord.sessionId
-    },
-    "Stranded running agent session terminally failed"
-  );
+  const eventName = "agent.turn.stranded_session.failed";
+  const eventId = logException(new Error(args.errorMessage), eventName, {
+    "app.ai.conversation_id": args.conversationId,
+    "app.ai.session_id": args.sessionRecord.sessionId
+  });
   const thread = parseSlackThreadId(args.conversationId);
   const channelId = thread?.channelId ?? requireSlackDestination(
     args.sessionRecord.destination,
@@ -8967,7 +8569,6 @@ async function recoverStrandedRunningSession(args) {
     source: sessionRecord.source,
     messages: sessionRecord.piMessages,
     errorMessage: "Recovered running session after hard worker death",
-    logContext: {},
     modelId,
     actor: sessionRecord.actor,
     surface: sessionRecord.surface
@@ -9008,6 +8609,16 @@ async function recoverStrandedRunningSession(args) {
   return false;
 }
 async function resumeAwaitingSlackContinuation(conversationId, options, runOptions = {}) {
+  return withLogContext(
+    { conversationId },
+    () => resumeAwaitingSlackContinuationInContext(
+      conversationId,
+      options,
+      runOptions
+    )
+  );
+}
+async function resumeAwaitingSlackContinuationInContext(conversationId, options, runOptions) {
   const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
   const newest = summaries[0];
   if (newest?.state === "running") {
@@ -9047,6 +8658,12 @@ async function resumeAwaitingSlackContinuation(conversationId, options, runOptio
   return false;
 }
 async function continueSlackAgentRunWithLockRetry(payload, options, runOptions = {}) {
+  return withLogContext(
+    { conversationId: payload.conversationId },
+    () => continueSlackAgentRunWithLockRetryInContext(payload, options, runOptions)
+  );
+}
+async function continueSlackAgentRunWithLockRetryInContext(payload, options, runOptions) {
   const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
   for (const [attempt, delayMs] of [
     ...AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS,
@@ -9059,30 +8676,20 @@ async function continueSlackAgentRunWithLockRetry(payload, options, runOptions =
         throw error;
       }
       if (typeof delayMs !== "number") {
-        logWarn(
-          "agent_continue_lock_busy",
-          {},
-          {
-            "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId,
-            "app.ai.resume_lock_retry_count": attempt
-          },
-          "Rescheduling agent continuation because another run still owns the thread lock"
-        );
+        logWarn("agent.continue.lock.busy", {
+          "app.ai.conversation_id": payload.conversationId,
+          "app.ai.session_id": payload.sessionId,
+          "app.ai.resume_lock_retry_count": attempt
+        });
         await scheduleAgentContinue2(payload);
         return true;
       }
-      logWarn(
-        "agent_continue_lock_busy_retrying",
-        {},
-        {
-          "app.ai.conversation_id": payload.conversationId,
-          "app.ai.session_id": payload.sessionId,
-          "app.ai.resume_lock_retry_attempt": attempt + 1,
-          "app.ai.resume_lock_retry_delay_ms": delayMs
-        },
-        "Agent continuation lock was busy; retrying"
-      );
+      logWarn("agent.continue.lock.retrying", {
+        "app.ai.conversation_id": payload.conversationId,
+        "app.ai.session_id": payload.sessionId,
+        "app.ai.resume_lock_retry_attempt": attempt + 1,
+        "app.ai.resume_lock_retry_delay_ms": delayMs
+      });
       await sleep(delayMs);
     }
   }
@@ -9647,7 +9254,7 @@ async function createApp(options) {
   });
   const app = new Hono();
   app.onError((err, c) => {
-    logException(err, "unhandled_route_error");
+    logException(err, "route.unhandled.exception");
     return c.text("Internal Server Error", 500);
   });
   app.use("*", async (c, next) => {