@sentry/junior 0.105.0 → 0.107.0

package/dist/{chunk-RMZ65YAA.js → chunk-YFQ7CQDE.js}

@@ -1,40 +1,73 @@
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
-  buildConversationStatePatch
-} from "./chunk-XIMUQ4IU.js";
-import {
   abandonAgentTurnSessionRecord,
-  addAgentTurnUsage,
+  buildConversationStatePatch,
   getAgentTurnSessionRecord,
+  getAgentTurnSessionRecordForResume,
   upsertAgentTurnSessionRecord
-} from "./chunk-QDKRE3LS.js";
+} from "./chunk-4YF7Z6IA.js";
+import {
+  addAgentTurnUsage
+} from "./chunk-MU6HHZEN.js";
+import {
+  getStateAdapter
+} from "./chunk-B2Z2H66D.js";
 import {
-  persistConversationMessages
-} from "./chunk-RYDF4GOX.js";
+  getConversationEventStore
+} from "./chunk-NVOTGWYX.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
 import {
+  botConfig,
+  escapeXml,
   getPiMessageRole,
-  getStateAdapter,
+  resolveGatewayModel,
+  standardModelId,
   trimTrailingAssistantMessages
-} from "./chunk-M3UAVLEN.js";
+} from "./chunk-SS67LUOK.js";
 import {
   getActiveTraceId,
-  logException
-} from "./chunk-AEWZ7F65.js";
+  logException,
+  logWarn,
+  setSpanAttributes
+} from "./chunk-O24R4DCK.js";
 import {
   isRecord,
   toOptionalString
 } from "./chunk-OB42YVAE.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-7FBGKXPE.js";
 
 // src/chat/state/turn-id.ts
 function buildDeterministicTurnId(messageId) {
   const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return `turn_${sanitized}`;
 }
+function buildDeterministicAssistantMessageId(turnId) {
+  return `${turnId}:assistant:1`;
+}
 
 // src/chat/runtime/turn.ts
+var ConversationTurnBoundaryError = class extends Error {
+  eventId;
+  failureCode;
+  constructor(args) {
+    super(
+      args.cause instanceof Error ? args.cause.message : String(args.cause),
+      {
+        cause: args.cause
+      }
+    );
+    this.name = "ConversationTurnBoundaryError";
+    this.eventId = args.eventId;
+    this.failureCode = args.failureCode;
+  }
+};
+function getConversationTurnBoundaryError(error) {
+  return error instanceof ConversationTurnBoundaryError ? error : void 0;
+}
 var CooperativeTurnYieldError = class extends Error {
   code = "cooperative_turn_yield";
   constructor(message = "Agent turn yielded at a safe boundary") {
@@ -112,8 +145,18 @@ async function persistWithRetry(persist) {
   throw lastError;
 }
 
+// src/chat/services/turn-limit.ts
+var TurnSliceLimitExceededError = class extends Error {
+  constructor(maxSlices) {
+    super(`Agent turn exceeded execution limit (${maxSlices} slices)`);
+    this.name = "TurnSliceLimitExceededError";
+  }
+};
+function buildTurnLimitResponse(eventId) {
+  return `I couldn't finish this request because this turn reached its execution limit. Please try again with a smaller or more specific request. Reference: \`event_id=${eventId}\`.`;
+}
+
 // src/chat/services/turn-session-record.ts
-var AGENT_CONTINUE_MAX_SLICES = 48;
 function logSessionRecordError(error, eventName, args, attributes, message) {
   logException(
     error,
@@ -155,13 +198,14 @@ function resumableBoundary(messages, fallbackMessages) {
   return trimTrailingAssistantMessages(fallbackMessages ?? []);
 }
 async function loadTurnSessionRecord(ctx) {
-  const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
-  const existingSessionRecord = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionRecord(ctx.conversationId, ctx.sessionId) : void 0;
+  const existingSessionRecord = await getAgentTurnSessionRecordForResume(
+    ctx.conversationId,
+    ctx.sessionId
+  );
   const hasAwaitingResumeRecord = Boolean(
     existingSessionRecord && existingSessionRecord.state === "awaiting_resume"
   );
   return {
-    canUseTurnSession,
     resumedFromSessionRecord: hasAwaitingResumeRecord,
     currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
     existingSessionRecord
@@ -340,7 +384,7 @@ async function persistAuthPauseSessionRecord(args) {
   }
   return void 0;
 }
-async function persistTimeoutSessionRecord(args) {
+async function persistContinuationSessionRecord(args) {
   const nextSliceId = args.currentSliceId + 1;
   try {
     const latestSessionRecord = await getAgentTurnSessionRecord(
@@ -362,7 +406,7 @@ async function persistTimeoutSessionRecord(args) {
       latestSessionRecord?.cumulativeUsage,
       args.currentUsage
     );
-    if (nextSliceId > AGENT_CONTINUE_MAX_SLICES) {
+    if (nextSliceId > botConfig.maxSlicesPerTurn) {
       return await upsertAgentTurnSessionRecord({
         ...args.channelName ?? latestSessionRecord?.channelName ? {
           channelName: args.channelName ?? latestSessionRecord?.channelName
@@ -384,9 +428,11 @@ async function persistTimeoutSessionRecord(args) {
         ...args.reasoningLevel ?? latestSessionRecord?.reasoningLevel ? {
           reasoningLevel: args.reasoningLevel ?? latestSessionRecord?.reasoningLevel
         } : {},
-        resumeReason: "timeout",
+        resumeReason: args.resumeReason,
         resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
-        errorMessage: `Agent continuation exceeded slice limit (${AGENT_CONTINUE_MAX_SLICES})`,
+        errorMessage: new TurnSliceLimitExceededError(
+          botConfig.maxSlicesPerTurn
+        ).message,
         ...args.actor ?? latestSessionRecord?.actor ? { actor: args.actor ?? latestSessionRecord?.actor } : {},
         ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
       });
@@ -408,7 +454,7 @@ async function persistTimeoutSessionRecord(args) {
       ...args.reasoningLevel ?? latestSessionRecord?.reasoningLevel ? {
         reasoningLevel: args.reasoningLevel ?? latestSessionRecord?.reasoningLevel
       } : {},
-      resumeReason: "timeout",
+      resumeReason: args.resumeReason,
       resumedFromSliceId: args.currentSliceId,
       errorMessage: args.errorMessage,
       ...args.actor ?? latestSessionRecord?.actor ? { actor: args.actor ?? latestSessionRecord?.actor } : {},
@@ -484,6 +530,605 @@ async function persistYieldSessionRecord(args) {
   }
 }
 
+// src/chat/services/context-budget.ts
+var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
+var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
+var COMPACTION_TARGET_RATIO = 0.8;
+var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+var FALLBACK_MAX_OUTPUT_TOKENS = 128e3;
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function calculateContextCompactionTriggerTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  const maxTokens = positiveInteger(
+    model.maxTokens,
+    FALLBACK_MAX_OUTPUT_TOKENS
+  );
+  const outputReserve = Math.min(
+    maxTokens,
+    Math.floor(contextWindow * COMPACTION_OUTPUT_RESERVE_RATIO)
+  );
+  const usableInputTokens = Math.max(1, contextWindow - outputReserve);
+  return Math.max(
+    1,
+    Math.floor(usableInputTokens * COMPACTION_TRIGGER_INPUT_RATIO)
+  );
+}
+function calculateContextCompactionTargetTokens(triggerTokens) {
+  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+function getAgentContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(standardModelId(botConfig));
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: botConfig.modelContextWindowTokens ?? model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+function getConversationContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(botConfig.fastModelId);
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+
+// src/chat/services/conversation-memory.ts
+var CONTEXT_MIN_LIVE_MESSAGES = 12;
+var CONTEXT_COMPACTION_BATCH_SIZE = 24;
+var CONTEXT_MAX_COMPACTIONS = 16;
+var CONTEXT_MAX_MESSAGE_CHARS = 3200;
+var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function generateConversationId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeConversationText(text) {
+  return text.trim().replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
+}
+function buildImageContextSuffix(message, conversation) {
+  const byFileId = conversation?.vision.byFileId;
+  const imageFileIds = message.meta?.imageFileIds ?? [];
+  if (!byFileId || imageFileIds.length === 0) {
+    return "";
+  }
+  const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
+  if (summaries.length === 0) {
+    return "";
+  }
+  return ` [image context: ${summaries.join(" | ")}]`;
+}
+function renderConversationMessageLine(message, conversation) {
+  const displayName = conversationAuthorDisplayName(message);
+  const markers = [];
+  if (message.meta?.replied === false) {
+    markers.push(
+      `assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`
+    );
+  }
+  if (message.meta?.explicitMention) {
+    markers.push("explicit mention");
+  }
+  const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
+  const imageContext = buildImageContextSuffix(message, conversation);
+  return `[${message.role}] ${displayName}: ${message.text}${imageContext}${markerSuffix}`;
+}
+function conversationAuthorDisplayName(message) {
+  const author = message.author;
+  const fullName = authorDisplayField(author?.fullName, author?.userId);
+  const userName = authorDisplayField(author?.userName, author?.userId);
+  return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
+}
+function authorDisplayField(value, userId) {
+  if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value;
+}
+function updateConversationStats(conversation) {
+  const contextText = buildConversationContext(conversation);
+  conversation.stats.estimatedContextTokens = estimateTextTokens(
+    contextText ?? ""
+  );
+  conversation.stats.totalMessageCount = conversation.messages.length;
+  conversation.stats.updatedAtMs = Date.now();
+}
+function upsertConversationMessage(conversation, message) {
+  const existingIndex = conversation.messages.findIndex(
+    (entry) => entry.id === message.id
+  );
+  if (existingIndex >= 0) {
+    conversation.messages[existingIndex] = {
+      ...conversation.messages[existingIndex],
+      ...message,
+      meta: {
+        ...conversation.messages[existingIndex]?.meta,
+        ...message.meta
+      }
+    };
+    updateConversationStats(conversation);
+    return message.id;
+  }
+  conversation.messages.push(message);
+  updateConversationStats(conversation);
+  return message.id;
+}
+function recordDeliveredAssistantMessage(args) {
+  const prefix = `${args.sessionId}:assistant:`;
+  const ordinal = args.conversation.messages.filter(
+    (message) => message.id.startsWith(prefix)
+  ).length + 1;
+  const messageId = `${prefix}${ordinal}`;
+  markConversationMessage(args.conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(args.conversation, {
+    id: messageId,
+    role: "assistant",
+    text: normalizeConversationText(args.text),
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true
+    }
+  });
+  return messageId;
+}
+function turnHasReply(conversation, turnId) {
+  const assistantPrefix = `${turnId}:assistant:`;
+  return conversation.messages.some(
+    (message) => message.role === "assistant" && message.id.startsWith(assistantPrefix)
+  );
+}
+function markConversationMessage(conversation, messageId, patch) {
+  if (!messageId) return;
+  const messageIndex = conversation.messages.findIndex(
+    (entry) => entry.id === messageId
+  );
+  if (messageIndex < 0) return;
+  const current = conversation.messages[messageIndex];
+  conversation.messages[messageIndex] = {
+    ...current,
+    meta: {
+      ...current.meta ?? {},
+      ...patch
+    }
+  };
+  updateConversationStats(conversation);
+}
+function buildConversationContext(conversation, options = {}) {
+  const messages = conversation.messages.filter(
+    (entry) => entry.id !== options.excludeMessageId
+  );
+  if (messages.length === 0 && conversation.compactions.length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  if (conversation.compactions.length > 0) {
+    lines.push("<thread-compactions>");
+    for (const [index, compaction] of conversation.compactions.entries()) {
+      lines.push(
+        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageCount}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
+        compaction.summary,
+        "  </compaction>"
+      );
+    }
+    lines.push("</thread-compactions>");
+  }
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(conversationAuthorDisplayName(message));
+      const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
+      const ts = new Date(message.createdAtMs).toISOString();
+      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+      lines.push(
+        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
+  }
+  return lines.join("\n");
+}
+function pruneCompactions(compactions) {
+  if (compactions.length <= CONTEXT_MAX_COMPACTIONS) {
+    return compactions;
+  }
+  const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
+  const merged = compactions.slice(0, overflowCount);
+  const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
+  const coveredMessageCount = merged.reduce(
+    (count, entry) => count + entry.coveredMessageCount,
+    0
+  );
+  const compacted = {
+    id: generateConversationId("compaction"),
+    createdAtMs: Date.now(),
+    summary: mergedSummary,
+    coveredMessageCount
+  };
+  return [compacted, ...compactions.slice(overflowCount)];
+}
+async function summarizeConversationChunk(messages, conversation, context, deps) {
+  const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
+  try {
+    const result = await deps.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            "Summarize the following older Slack thread transcript segment for future assistant turns.",
+            "Keep the summary factual and concise. Do not invent details.",
+            "",
+            "Output exactly three XML sections in this order:",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
+            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+            "",
+            "Do not output any text outside the three sections.",
+            "",
+            transcript
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId,
+        threadId: context.threadId ?? "",
+        channelId: context.channelId ?? "",
+        actorId: context.actorId ?? "",
+        runId: context.runId ?? ""
+      }
+    });
+    const summary = result.text.trim();
+    if (summary.length > 0) {
+      return summary.slice(0, 3500);
+    }
+  } catch (error) {
+    logWarn(
+      "conversation_compaction_summary_failed",
+      {
+        slackThreadId: context.threadId,
+        slackUserId: context.actorId,
+        slackChannelId: context.channelId,
+        runId: context.runId,
+        assistantUserName: botConfig.userName,
+        modelId: botConfig.fastModelId
+      },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error),
+        "app.compaction_messages_covered": messages.length
+      },
+      "Compaction summarization failed; using fallback summary"
+    );
+  }
+  return transcript.slice(0, 2800);
+}
+async function generateThreadTitleWithDeps(sourceText, deps) {
+  const result = await deps.completeText({
+    modelId: botConfig.fastModelId,
+    temperature: 0,
+    messages: [
+      {
+        role: "user",
+        content: [
+          "Generate a concise 5-8 word Slack conversation title from the first user message below.",
+          "Capture the user's main request.",
+          "Reply with ONLY the title, with no quotes or trailing punctuation.",
+          "",
+          `First user message: ${sourceText.slice(0, 500)}`
+        ].join("\n"),
+        timestamp: Date.now()
+      }
+    ],
+    metadata: {
+      modelId: botConfig.fastModelId
+    }
+  });
+  return result.text.trim().slice(0, 60);
+}
+function getThreadTitleSourceMessage(conversation) {
+  let firstMessage;
+  for (const message of conversation.messages) {
+    if (!isHumanConversationMessage(message)) {
+      continue;
+    }
+    if (!firstMessage) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs < firstMessage.createdAtMs) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
+      firstMessage = message;
+    }
+  }
+  return firstMessage;
+}
+async function compactConversationIfNeededWithDeps(conversation, context, deps) {
+  updateConversationStats(conversation);
+  let estimatedTokens = conversation.stats.estimatedContextTokens;
+  setSpanAttributes({
+    "app.context_tokens_estimated": estimatedTokens
+  });
+  const triggerTokens = getConversationContextCompactionTriggerTokens();
+  const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
+  while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+    const compactCount = Math.min(
+      CONTEXT_COMPACTION_BATCH_SIZE,
+      conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES
+    );
+    if (compactCount <= 0) {
+      break;
+    }
+    const compactedChunk = conversation.messages.slice(0, compactCount);
+    const summary = await summarizeConversationChunk(
+      compactedChunk,
+      conversation,
+      context,
+      deps
+    );
+    conversation.compactions.push({
+      id: generateConversationId("compaction"),
+      createdAtMs: Date.now(),
+      summary,
+      coveredMessageCount: compactedChunk.length
+    });
+    conversation.compactions = pruneCompactions(conversation.compactions);
+    conversation.messages = conversation.messages.slice(compactCount);
+    conversation.stats.compactedMessageCount += compactCount;
+    updateConversationStats(conversation);
+    estimatedTokens = conversation.stats.estimatedContextTokens;
+    setSpanAttributes({
+      "app.compaction_messages_covered": compactCount,
+      "app.compaction.trigger_tokens": triggerTokens,
+      "app.compaction.target_tokens": targetTokens,
+      "app.context_tokens_estimated": estimatedTokens
+    });
+    if (estimatedTokens <= targetTokens) {
+      break;
+    }
+  }
+}
+function createConversationMemoryService(deps) {
+  return {
+    compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps),
+    generateThreadTitle: async (sourceText) => await generateThreadTitleWithDeps(sourceText, deps)
+  };
+}
+function isHumanConversationMessage(message) {
+  return message.role === "user" && message.author?.isBot !== true;
+}
+function getConversationMessageSlackTs(message) {
+  return parseSlackMessageTs(message.meta?.slackTs);
+}
+
+// src/chat/conversations/messages.ts
+import { createHash } from "crypto";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+
+// src/chat/conversations/message-summaries.ts
+import { isDeepStrictEqual } from "util";
+function projectConversationMessageSummaries(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const data = events[index]?.data;
+    if (data?.type === "messages_summarized") {
+      return data.compactions;
+    }
+  }
+  return [];
+}
+async function persistConversationMessageSummaries(args) {
+  const eventStore = getConversationEventStore();
+  const history = await eventStore.loadMessageHistory(args.conversationId);
+  const existing = history.compaction ? projectConversationMessageSummaries([history.compaction]) : [];
+  if (isDeepStrictEqual(existing, args.conversation.compactions)) {
+    return;
+  }
+  const liveMessageIds = new Set(
+    args.conversation.messages.map((message) => message.id)
+  );
+  const historyFromSeq = history.events.find(
+    (event) => event.data.type === "message" && liveMessageIds.has(event.data.messageId)
+  )?.seq;
+  const nextHistoryFromSeq = historyFromSeq ?? Math.max(
+    history.compaction?.data.type === "messages_summarized" ? history.compaction.data.historyFromSeq : 0,
+    (history.events.at(-1)?.seq ?? -1) + 1
+  );
+  await eventStore.append(args.conversationId, [
+    {
+      data: {
+        type: "messages_summarized",
+        historyFromSeq: nextHistoryFromSeq,
+        compactions: args.conversation.compactions
+      },
+      createdAtMs: args.conversation.compactions.at(-1)?.createdAtMs ?? Date.now()
+    }
+  ]);
+}
+
+// src/chat/conversations/message-projection.ts
+function isMessageEvent(event) {
+  return event.data.type === "message" || event.data.type === "message_updated" || event.data.type === "message_handled";
+}
+function splitMeta(meta) {
+  const rest = { ...meta ?? {} };
+  const author = rest.author;
+  delete rest.author;
+  return {
+    ...author ? { author } : {},
+    ...Object.keys(rest).length > 0 ? { meta: rest } : {}
+  };
+}
+function missingBaselineError(event) {
+  return new Error(
+    `Message event ${event.data.type} at seq ${event.seq} references ${event.data.messageId} before message`
+  );
+}
+function projectConversationMessages(events, options = {}) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!isMessageEvent(event)) continue;
+    const data = event.data;
+    const current = byId.get(data.messageId);
+    if (data.type === "message" || data.type === "message_updated") {
+      const message = {
+        id: data.messageId,
+        role: data.role,
+        text: data.text,
+        createdAtMs: event.createdAtMs,
+        ...splitMeta(data.meta)
+      };
+      if (data.type === "message" && current)
+        throw new Error(
+          `Duplicate message event for ${data.messageId} at seq ${event.seq}`
+        );
+      if (data.type === "message_updated" && !current) {
+        if ((options.historyFromSeq ?? 0) > 0) continue;
+        throw missingBaselineError(event);
+      }
+      byId.set(data.messageId, {
+        message: {
+          ...message,
+          createdAtMs: current?.message.createdAtMs ?? message.createdAtMs
+        },
+        ...current?.repliedAtMs === void 0 ? {} : { repliedAtMs: current.repliedAtMs }
+      });
+      continue;
+    }
+    if (!current) {
+      if ((options.historyFromSeq ?? 0) > 0) continue;
+      throw missingBaselineError(event);
+    }
+    current.repliedAtMs ??= event.createdAtMs;
+  }
+  return [...byId.values()].map(({ message, repliedAtMs }) => {
+    if (repliedAtMs === void 0) return message;
+    return {
+      ...message,
+      meta: { ...message.meta ?? {}, replied: true }
+    };
+  });
+}
+
+// src/chat/conversations/messages.ts
+function toStoredConversationMessage(message) {
+  const meta = {};
+  if (message.author) meta.author = message.author;
+  const { replied, ...restMeta } = message.meta ?? {};
+  Object.assign(meta, restMeta);
+  if (replied === false) meta.replied = false;
+  return {
+    messageId: message.id,
+    role: message.role,
+    text: message.text,
+    ...Object.keys(meta).length > 0 ? { meta } : {},
+    createdAtMs: message.createdAtMs
+  };
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return value.map(canonicalJson);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)])
+  );
+}
+function messageStateKey(message) {
+  return createHash("sha256").update(JSON.stringify(canonicalJson(message))).digest("hex").slice(0, 32);
+}
+async function hydrateConversationMessages(args) {
+  if (!args.conversationId) {
+    args.conversation.messages = [];
+    return;
+  }
+  const history = await getConversationEventStore().loadMessageHistory(
+    args.conversationId
+  );
+  args.conversation.compactions = history.compaction ? projectConversationMessageSummaries([history.compaction]) : [];
+  const historyFromSeq = history.compaction?.data.type === "messages_summarized" ? history.compaction.data.historyFromSeq : 0;
+  args.conversation.messages = projectConversationMessages(history.events, {
+    historyFromSeq
+  });
+  updateConversationStats(args.conversation);
+}
+async function persistConversationMessages(args) {
+  if (!args.conversationId || args.conversation.messages.length === 0) return;
+  const history = await getConversationEventStore().loadMessageHistory(
+    args.conversationId
+  );
+  const existingMessages = new Map(
+    projectConversationMessages(history.events).map((message) => [
+      message.id,
+      message
+    ])
+  );
+  const handledAtMs = args.repliedAtMs ?? Date.now();
+  const events = args.conversation.messages.flatMap((message) => {
+    const stored = toStoredConversationMessage(message);
+    const existing = existingMessages.get(stored.messageId);
+    const changed = existing !== void 0 && !isDeepStrictEqual2(toStoredConversationMessage(existing), stored);
+    const messageEvent = existing ? changed ? [
+      {
+        idempotencyKey: `message:${stored.messageId}:update:${messageStateKey(stored)}`,
+        createdAtMs: handledAtMs,
+        data: {
+          type: "message_updated",
+          messageId: stored.messageId,
+          role: stored.role,
+          text: stored.text,
+          ...stored.authorIdentityId ? { authorIdentityId: stored.authorIdentityId } : {},
+          ...stored.meta ? { meta: stored.meta } : {}
+        }
+      }
+    ] : [] : [
+      {
+        idempotencyKey: `message:${stored.messageId}`,
+        createdAtMs: stored.createdAtMs,
+        data: {
+          type: "message",
+          messageId: stored.messageId,
+          role: stored.role,
+          text: stored.text,
+          ...stored.authorIdentityId ? { authorIdentityId: stored.authorIdentityId } : {},
+          ...stored.meta ? { meta: stored.meta } : {}
+        }
+      }
+    ];
+    return [
+      ...messageEvent,
+      ...message.meta?.replied === true ? [
+        {
+          idempotencyKey: `message:${stored.messageId}:handled`,
+          createdAtMs: handledAtMs,
+          data: {
+            type: "message_handled",
+            messageId: stored.messageId
+          }
+        }
+      ] : []
+    ];
+  });
+  await getConversationEventStore().append(args.conversationId, events);
+}
+
 // src/chat/state/artifacts.ts
 function coerceThreadArtifactsState(value) {
   if (!value || typeof value !== "object") {
@@ -927,6 +1572,9 @@ function isPendingAuthLatestRequest(conversation, pendingAuth) {
 
 export {
   buildDeterministicTurnId,
+  buildDeterministicAssistantMessageId,
+  ConversationTurnBoundaryError,
+  getConversationTurnBoundaryError,
   CooperativeTurnYieldError,
   isCooperativeTurnYieldError,
   TurnInputCommitLostError,
@@ -938,12 +1586,14 @@ export {
   markTurnCompleted,
   markTurnFailed,
   persistWithRetry,
+  TurnSliceLimitExceededError,
+  buildTurnLimitResponse,
   loadTurnSessionRecord,
   persistRunningSessionRecord,
   persistCompletedSessionRecord,
   completeDeliveredTurn,
   persistAuthPauseSessionRecord,
-  persistTimeoutSessionRecord,
+  persistContinuationSessionRecord,
   persistYieldSessionRecord,
   getInterruptionMarker,
   canReusePendingAuthLink,
@@ -951,6 +1601,22 @@ export {
   clearPendingAuth,
   abandonReplacedPendingAuth,
   isPendingAuthLatestRequest,
+  persistConversationMessageSummaries,
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
+  normalizeConversationText,
+  updateConversationStats,
+  upsertConversationMessage,
+  recordDeliveredAssistantMessage,
+  turnHasReply,
+  markConversationMessage,
+  buildConversationContext,
+  getThreadTitleSourceMessage,
+  createConversationMemoryService,
+  isHumanConversationMessage,
+  getConversationMessageSlackTs,
+  hydrateConversationMessages,
+  persistConversationMessages,
   coerceThreadArtifactsState,
   mergeArtifactsState,
   getPersistedSandboxState,