@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-5PKWYPFT.js

@@ -1,2943 +0,0 @@
-import {
-  JUNIOR_NATIVE_EVENT_NAMESPACE,
-  ToolInputError,
-  addAgentTurnUsage,
-  agentsInstructionsUpdatedEvent,
-  authenticationLinkedEvent,
-  authenticationUnlinkedEvent,
-  fallbackShortTitle,
-  generateShortTitle
-} from "./chunk-7DHZP5KJ.js";
-import {
-  bindProviderConversation,
-  createSqlConversationEventStore,
-  getConversationEventStore,
-  getConversationStore,
-  getSqlExecutor,
-  sanitizePostgresJson,
-  withConversationEventLock
-} from "./chunk-M76HMB7M.js";
-import {
-  SANDBOX_REPOS_ROOT,
-  SANDBOX_WORKSPACE_ROOT,
-  sleep
-} from "./chunk-NSXKRGRT.js";
-import {
-  MUTATION_LOCK_TTL_MS,
-  fenceLock,
-  getStateAdapter,
-  withLock
-} from "./chunk-2MK3QBGA.js";
-import {
-  agentHistoryItemSchema,
-  contextProvenance,
-  instructionActors,
-  instructionProvenanceFor
-} from "./chunk-7NL7T6VU.js";
-import {
-  botConfig,
-  completeText,
-  escapeXml,
-  resolveGatewayModel,
-  unwrapCurrentInstruction
-} from "./chunk-63NKKFJL.js";
-import {
-  parseSlackMessageTs,
-  toStoredSlackActor
-} from "./chunk-N7TMSOZH.js";
-import {
-  buildTurnFailureResponse,
-  getActiveTraceId,
-  logException,
-  logWarn,
-  setSpanAttributes
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/turn-context-tag.ts
-var TURN_CONTEXT_TAG = "runtime-turn-context";
-
-// src/chat/pi/transcript.ts
-var RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
-var AGENTS_INSTRUCTIONS_START = "# AGENTS.md instructions";
-function userMessageContent(message) {
-  const record = message;
-  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
-}
-function isRuntimeTurnContextPart(part) {
-  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && (part.text.startsWith(RUNTIME_TURN_CONTEXT_START) || part.text.startsWith(AGENTS_INSTRUCTIONS_START));
-}
-function hasCurrentInstruction(message) {
-  return userMessageContent(message)?.some(
-    (part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.includes("<current-instruction")
-  ) ?? false;
-}
-function messageTimestamp(message) {
-  return message.timestamp;
-}
-function isStandaloneRuntimeContextMessage(messages, index) {
-  const message = messages[index];
-  const next = messages[index + 1];
-  return Boolean(
-    message && next && userMessageContent(message) && userMessageContent(next) && messageTimestamp(message) === messageTimestamp(next) && !hasCurrentInstruction(message) && hasCurrentInstruction(next)
-  );
-}
-var EMBEDDED_THREAD_CONTEXT_TAGS = [
-  "thread-context",
-  "recent-thread-messages",
-  "thread-compactions",
-  "thread-transcript",
-  "thread-background"
-];
-var EMBEDDED_THREAD_CONTEXT_PATTERN = new RegExp(
-  `<(${EMBEDDED_THREAD_CONTEXT_TAGS.join("|")})(?:\\s[^>]*)?>[\\s\\S]*</\\1>`,
-  "g"
-);
-function isAssistantMessage(value) {
-  return typeof value === "object" && value !== null && value.role === "assistant";
-}
-function isToolResultMessage(value) {
-  return typeof value === "object" && value !== null && value.role === "toolResult";
-}
-function isToolResultError(result) {
-  if (!result || typeof result !== "object") return false;
-  return Boolean(result.isError);
-}
-function normalizeToolNameFromResult(result) {
-  if (!result || typeof result !== "object") return void 0;
-  const record = result;
-  if (typeof record.toolName === "string" && record.toolName.length > 0) {
-    return record.toolName;
-  }
-  if (typeof record.name === "string" && record.name.length > 0) {
-    return record.name;
-  }
-  return void 0;
-}
-function getPiMessageRole(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const role = value.role;
-  return typeof role === "string" ? role : void 0;
-}
-function isContinuablePiBoundary(messages) {
-  const lastRole = getPiMessageRole(messages.at(-1));
-  return lastRole === "user" || lastRole === "toolResult";
-}
-function extractAssistantText(message) {
-  const content = message.content ?? [];
-  return content.filter(
-    (part) => part.type === "text" && typeof part.text === "string"
-  ).map((part) => part.text).join("\n");
-}
-function getTerminalAssistantMessages(messages) {
-  let lastNonAssistantIndex = -1;
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    if (!isAssistantMessage(messages[index])) {
-      lastNonAssistantIndex = index;
-      break;
-    }
-  }
-  return messages.slice(lastNonAssistantIndex + 1).filter(isAssistantMessage);
-}
-function trimTrailingAssistantMessages(messages) {
-  let end = messages.length;
-  while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") {
-    end -= 1;
-  }
-  return end === messages.length ? [...messages] : messages.slice(0, end);
-}
-function hasRuntimeTurnContext(messages) {
-  return messages.some(
-    (message, index) => isStandaloneRuntimeContextMessage(messages, index) || userMessageContent(message)?.some(isRuntimeTurnContextPart)
-  );
-}
-function retainRuntimeTurnContext(messages) {
-  return messages.flatMap((message, index) => {
-    if (isStandaloneRuntimeContextMessage(messages, index)) {
-      return [message];
-    }
-    const runtimeContent = userMessageContent(message)?.filter(isRuntimeTurnContextPart) ?? [];
-    return runtimeContent.length > 0 ? [{ ...message, content: runtimeContent }] : [];
-  });
-}
-function instructionTextForProjection(text) {
-  const withoutContext = text.replace(EMBEDDED_THREAD_CONTEXT_PATTERN, "").trim();
-  return unwrapCurrentInstruction(withoutContext) ?? withoutContext;
-}
-function getUserMessageInstructionText(message) {
-  if (getPiMessageRole(message) !== "user") {
-    return "";
-  }
-  const content = message.content;
-  const text = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap(
-    (part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" ? [part.text] : []
-  ).join("\n") : "";
-  return instructionTextForProjection(text).trim();
-}
-function stripRuntimeTurnContext(messages) {
-  return messages.flatMap((message, index) => {
-    if (isStandaloneRuntimeContextMessage(messages, index)) {
-      return [];
-    }
-    const content = userMessageContent(message);
-    if (!content) return [message];
-    const nextContent = content.filter(
-      (part) => !isRuntimeTurnContextPart(part)
-    );
-    if (nextContent.length === content.length) return [message];
-    if (nextContent.length === 0) return [];
-    return [{ ...message, content: nextContent }];
-  });
-}
-
-// src/chat/services/context-budget.ts
-var COMPACTION_TRIGGER_RATIO = 0.9;
-var CONTEXT_INPUT_LIMIT_RATIO = 0.95;
-var COMPACTION_TARGET_RATIO = 0.8;
-var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
-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
-  );
-  return Math.max(1, Math.floor(contextWindow * COMPACTION_TRIGGER_RATIO));
-}
-function calculateContextInputLimitTokens(model) {
-  const contextWindow = positiveInteger(
-    model.contextWindow,
-    FALLBACK_CONTEXT_WINDOW_TOKENS
-  );
-  return Math.max(1, Math.floor(contextWindow * CONTEXT_INPUT_LIMIT_RATIO));
-}
-function calculateContextCompactionTargetTokens(triggerTokens) {
-  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
-}
-function getModelContextBudget(modelId) {
-  const model = resolveGatewayModel(modelId);
-  const advertisedContextWindow = positiveInteger(
-    model.contextWindow,
-    FALLBACK_CONTEXT_WINDOW_TOKENS
-  );
-  return {
-    contextWindow: Math.min(
-      botConfig.contextWindowTokens,
-      advertisedContextWindow
-    )
-  };
-}
-function getAgentContextCompactionTriggerTokens(modelId) {
-  return calculateContextCompactionTriggerTokens(
-    getModelContextBudget(modelId)
-  );
-}
-function getAgentContextInputLimitTokens(modelId) {
-  return calculateContextInputLimitTokens(getModelContextBudget(modelId));
-}
-function getConversationContextCompactionTriggerTokens() {
-  return calculateContextCompactionTriggerTokens(
-    getModelContextBudget(botConfig.fastModelId)
-  );
-}
-
-// 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.replace(/\r\n?/g, "\n").trim();
-}
-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: ${escapeXml(summaries.join(" | "))}]`;
-}
-function renderConversationMessageLine(message, conversation) {
-  const displayName = escapeXml(conversationAuthorDisplayName(message));
-  const text = escapeXml(
-    message.text.replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS)
-  );
-  const markers = [];
-  if (message.meta?.replied === false) {
-    markers.push(
-      escapeXml(
-        `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}: ${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 estimateConversationContextTokens(conversation) {
-  return estimateTextTokens(buildConversationContext(conversation) ?? "");
-}
-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
-      }
-    };
-    return message.id;
-  }
-  conversation.messages.push(message);
-  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,
-      ...args.source ? { source: args.source } : void 0
-    }
-  });
-  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
-    }
-  };
-}
-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-context authority="evidence-only">');
-    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-context>");
-  }
-  return lines.join("\n");
-}
-var THREAD_CONTEXT_OPEN = '<thread-context authority="evidence-only">';
-var THREAD_CONTEXT_CLOSE = "</thread-context>";
-function appendThreadContextMessages(baseContext, messageLines) {
-  const base = baseContext?.trim();
-  if (messageLines.length === 0) {
-    return base || void 0;
-  }
-  const entryBlock = messageLines.join("\n");
-  if (!base) {
-    return [THREAD_CONTEXT_OPEN, entryBlock, THREAD_CONTEXT_CLOSE].join("\n");
-  }
-  const closeIdx = base.lastIndexOf(THREAD_CONTEXT_CLOSE);
-  if (closeIdx >= 0) {
-    const before = base.slice(0, closeIdx).replace(/\s*$/, "");
-    const after = base.slice(closeIdx);
-    return `${before}
-${entryBlock}
-${after}`;
-  }
-  return [base, "", THREAD_CONTEXT_OPEN, entryBlock, THREAD_CONTEXT_CLOSE].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,
-      promptName: "junior.thread_compaction",
-      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", {
-      "exception.message": error instanceof Error ? error.message : String(error),
-      "app.compaction_messages_covered": messages.length
-    });
-  }
-  return transcript.slice(0, 2800);
-}
-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) {
-  let estimatedTokens = estimateConversationContextTokens(conversation);
-  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);
-    estimatedTokens = estimateConversationContextTokens(conversation);
-    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)
-  };
-}
-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/services/conversation-title.ts
-var inFlightTitles = /* @__PURE__ */ new Map();
-async function ensureConversationTitle(args) {
-  const pending = inFlightTitles.get(args.conversationId);
-  if (pending) {
-    return pending;
-  }
-  const work = ensureConversationTitleOnce(args).finally(() => {
-    inFlightTitles.delete(args.conversationId);
-  });
-  inFlightTitles.set(args.conversationId, work);
-  return work;
-}
-async function ensureConversationTitleOnce(args) {
-  if (!args.conversation.messages.some(isHumanConversationMessage)) {
-    return void 0;
-  }
-  const store = args.conversationStore ?? getConversationStore();
-  try {
-    const stored = await store.get({ conversationId: args.conversationId });
-    if (stored?.title?.trim()) {
-      return void 0;
-    }
-    if (stored?.parentConversationId) {
-      return void 0;
-    }
-    const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
-    const sourceText = titleSourceMessage?.text.trim() ?? "";
-    if (!titleSourceMessage || !sourceText) {
-      return void 0;
-    }
-    let title;
-    try {
-      const generated = await generateShortTitle({
-        completeText,
-        kind: "conversation",
-        sourceText
-      });
-      title = generated ?? fallbackShortTitle(sourceText, "Conversation");
-    } catch (error) {
-      logWarn("conversation.title.generation.failed", {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      });
-      title = fallbackShortTitle(sourceText, "Conversation");
-    }
-    const normalized = title.trim();
-    if (!normalized) {
-      return void 0;
-    }
-    const activityAtMs = titleSourceMessage.createdAtMs;
-    const nowMs = args.nowMs ?? Date.now();
-    try {
-      await store.recordActivity({
-        activityAtMs,
-        conversationId: args.conversationId,
-        nowMs,
-        title: normalized
-      });
-    } catch (error) {
-      logException(error, "conversation.title.persist.failed");
-      return void 0;
-    }
-    return normalized;
-  } catch (error) {
-    logException(error, "conversation.title.ensure.failed");
-    return void 0;
-  }
-}
-function scheduleConversationTitle(args) {
-  if (!args.conversationId) {
-    return;
-  }
-  void ensureConversationTitle({
-    conversation: args.conversation,
-    conversationId: args.conversationId
-  }).catch((error) => {
-    logException(error, "conversation.title.task.failed");
-  });
-}
-async function resolveConversationTitle(args) {
-  const pending = inFlightTitles.get(args.conversationId);
-  if (pending) {
-    const generated = await pending;
-    if (generated?.trim()) {
-      return generated.trim();
-    }
-  }
-  const store = args.conversationStore ?? getConversationStore();
-  const stored = await store.get({ conversationId: args.conversationId });
-  return stored?.title?.trim() || void 0;
-}
-
-// 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.historyFromSeq, (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 } : void 0,
-    ...Object.keys(rest).length > 0 ? { meta: rest } : void 0
-  };
-}
-function missingBaselineError(event) {
-  return new Error(
-    `Message event ${event.data.type} at seq ${event.seq} references ${event.data.messageId} before message`
-  );
-}
-function projectConversationMessages(history) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const event of history.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 (history.historyFromSeq > 0) continue;
-        throw missingBaselineError(event);
-      }
-      byId.set(data.messageId, {
-        message: {
-          ...message,
-          createdAtMs: current?.message.createdAtMs ?? message.createdAtMs
-        },
-        ...current?.repliedAtMs === void 0 ? void 0 : { repliedAtMs: current.repliedAtMs }
-      });
-      continue;
-    }
-    if (!current) {
-      if (history.historyFromSeq > 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 } : void 0,
-    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]) : [];
-  args.conversation.messages = projectConversationMessages(history);
-}
-async function persistConversationMessages(args) {
-  if (!args.conversationId || args.conversation.messages.length === 0) return;
-  await appendConversationMessages(getConversationEventStore(), {
-    ...args,
-    conversationId: args.conversationId
-  });
-  scheduleConversationTitle({
-    conversation: args.conversation,
-    conversationId: args.conversationId
-  });
-}
-async function appendConversationMessages(eventStore, args) {
-  if (args.conversation.messages.length === 0) return;
-  const history = await eventStore.loadMessageHistory(args.conversationId);
-  const existingMessages = new Map(
-    projectConversationMessages(history).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 } : void 0,
-          ...stored.meta ? { meta: stored.meta } : void 0
-        }
-      }
-    ] : [] : [
-      {
-        idempotencyKey: `message:${stored.messageId}`,
-        createdAtMs: stored.createdAtMs,
-        data: {
-          type: "message",
-          messageId: stored.messageId,
-          role: stored.role,
-          text: stored.text,
-          ...stored.authorIdentityId ? { authorIdentityId: stored.authorIdentityId } : void 0,
-          ...stored.meta ? { meta: stored.meta } : void 0
-        }
-      }
-    ];
-    return [
-      ...messageEvent,
-      ...message.meta?.replied === true ? [
-        {
-          idempotencyKey: `message:${stored.messageId}:handled`,
-          createdAtMs: handledAtMs,
-          data: {
-            type: "message_handled",
-            messageId: stored.messageId
-          }
-        }
-      ] : []
-    ];
-  });
-  await eventStore.append(args.conversationId, events);
-}
-
-// src/chat/conversations/projection.ts
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
-
-// src/chat/pi/messages.ts
-import { z } from "zod";
-var piMessageSchema = z.object({
-  role: z.string()
-}).passthrough().transform((value) => value);
-var piContentMessageSchema = z.object({
-  content: z.array(z.unknown()),
-  role: z.string().min(1)
-}).passthrough().transform((value) => value);
-
-// src/chat/pi/conversation-events.ts
-function authorizationObservationMessage(data, createdAtMs) {
-  const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
-  return piMessageSchema.parse({
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: `${label} completed for provider "${data.provider}". Continue the blocked request and retry the provider operation if needed.`
-      }
-    ],
-    timestamp: createdAtMs
-  });
-}
-function durableMessages(message) {
-  return stripRuntimeTurnContext([message]);
-}
-function historyItemFromPiMessage(message, provenance) {
-  const parsed = piMessageSchema.parse(message);
-  const { role, ...fields } = parsed;
-  if (role === "user") {
-    return agentHistoryItemSchema.parse({
-      ...fields,
-      type: "user_message",
-      provenance
-    });
-  }
-  if (role === "assistant") {
-    return agentHistoryItemSchema.parse({
-      ...fields,
-      type: "assistant_message"
-    });
-  }
-  if (role === "toolResult") {
-    return agentHistoryItemSchema.parse({
-      ...fields,
-      type: "tool_result"
-    });
-  }
-  throw new Error(`Unsupported durable agent message role "${role}"`);
-}
-function piMessageFromHistoryItem(data) {
-  if (data.type === "user_message") {
-    const { type: _2, provenance: __, ...fields2 } = data;
-    return piMessageSchema.parse({ ...fields2, role: "user" });
-  }
-  if (data.type === "assistant_message") {
-    const { type: _2, ...fields2 } = data;
-    return piMessageSchema.parse({ ...fields2, role: "assistant" });
-  }
-  const { type: _, ...fields } = data;
-  return piMessageSchema.parse({ ...fields, role: "toolResult" });
-}
-function historyItemProvenance(data) {
-  return data.type === "user_message" ? data.provenance : contextProvenance;
-}
-function projectConversationEvents(events, options) {
-  const messages = [];
-  const provenance = [];
-  const seqs = [];
-  let modelProfile = options.defaultProfile;
-  let replacementSeq;
-  for (const event of events) {
-    if (options.maxSeq !== void 0 && event.seq > options.maxSeq) break;
-    if (event.data.type === "unknown") {
-      throw new Error(
-        `Unsupported conversation event "${event.data.originalType}" at seq ${event.seq} (schema version ${event.schemaVersion})`
-      );
-    }
-    if (event.data.type === "compaction" || event.data.type === "handoff") {
-      modelProfile = event.data.modelProfile;
-      replacementSeq = event.seq;
-      for (const replacement of event.data.replacementHistory) {
-        for (const message of durableMessages(
-          piMessageFromHistoryItem(replacement.item)
-        )) {
-          messages.push(message);
-          provenance.push(historyItemProvenance(replacement.item));
-          seqs.push(replacement.sourceEventSeq ?? event.seq);
-        }
-      }
-      continue;
-    }
-    if (event.data.type === "user_message" || event.data.type === "assistant_message" || event.data.type === "tool_result") {
-      for (const message of durableMessages(
-        piMessageFromHistoryItem(event.data)
-      )) {
-        messages.push(message);
-        provenance.push(historyItemProvenance(event.data));
-        seqs.push(event.seq);
-      }
-      continue;
-    }
-    if (event.data.type === "authorization_completed") {
-      messages.push(
-        authorizationObservationMessage(event.data, event.createdAtMs)
-      );
-      provenance.push(contextProvenance);
-      seqs.push(event.seq);
-    }
-  }
-  return {
-    messages,
-    provenance,
-    seqs,
-    modelProfile,
-    replacementSeq
-  };
-}
-
-// src/chat/conversations/projection.ts
-function connectedMcpProvidersFromEvents(events, credentialSubjectId) {
-  const providers = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    if (event.data.type === "mcp_provider_connected" && event.data.credentialSubjectId === credentialSubjectId) {
-      providers.add(event.data.provider);
-    }
-  }
-  return [...providers].sort((left, right) => left.localeCompare(right));
-}
-function isUserMessage(message) {
-  return message.role === "user";
-}
-var AgentHistoryBranchError = class extends Error {
-  constructor(conversationId) {
-    super(
-      `Agent history for ${conversationId} changed before its committed boundary`
-    );
-    this.name = "AgentHistoryBranchError";
-  }
-};
-function normalizeDurableMessage(message) {
-  return piMessageSchema.parse(
-    JSON.parse(JSON.stringify(sanitizePostgresJson(message)))
-  );
-}
-function durableMessageIdentity(message) {
-  const record = message;
-  if (record.role === "toolResult") {
-    return {
-      role: "toolResult",
-      timestamp: record.timestamp,
-      toolCallId: record.toolCallId,
-      toolName: record.toolName,
-      isError: record.isError,
-      content: record.content
-    };
-  }
-  return {
-    role: record.role,
-    timestamp: record.timestamp,
-    content: record.content
-  };
-}
-function countDurablePrefix(current, next) {
-  if (next.length < current.length) {
-    return countMatchingDeepPrefix(current, next);
-  }
-  for (let index = 0; index < current.length; index += 1) {
-    if (!isDeepStrictEqual3(
-      durableMessageIdentity(current[index]),
-      durableMessageIdentity(next[index])
-    )) {
-      return index;
-    }
-  }
-  return current.length;
-}
-function countMatchingDeepPrefix(left, right) {
-  const limit = Math.min(left.length, right.length);
-  for (let index = 0; index < limit; index += 1) {
-    if (!isDeepStrictEqual3(left[index], right[index])) {
-      return index;
-    }
-  }
-  return limit;
-}
-function resolveCommitProvenance(args) {
-  if (args.explicitProvenance) {
-    if (args.explicitProvenance.length !== args.nextMessages.length) {
-      throw new Error("commit provenance must align one-to-one with messages");
-    }
-    return args.explicitProvenance;
-  }
-  if (args.existing.provenance.length !== args.existing.messages.length) {
-    throw new Error("committed provenance must align one-to-one with messages");
-  }
-  const matchingPrefix = args.matchingPrefix;
-  const provenance = args.nextMessages.map(
-    (_, index) => index < matchingPrefix ? args.existing.provenance[index] : contextProvenance
-  );
-  if (args.newMessageProvenance) {
-    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
-      if (isUserMessage(args.nextMessages[index])) {
-        provenance[index] = args.newMessageProvenance;
-        break;
-      }
-    }
-  }
-  if (args.trailingMessageProvenance) {
-    if (args.trailingMessageProvenance.length > provenance.length) {
-      throw new Error(
-        "trailing commit provenance cannot exceed committed messages"
-      );
-    }
-    const newMessageCount = args.nextMessages.length - matchingPrefix;
-    if (args.trailingMessageProvenance.length > newMessageCount) {
-      throw new Error(
-        "trailing commit provenance must align to newly committed messages"
-      );
-    }
-    const start = provenance.length - args.trailingMessageProvenance.length;
-    args.trailingMessageProvenance.forEach((entry, offset) => {
-      provenance[start + offset] = entry;
-    });
-  }
-  return provenance;
-}
-async function loadProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events, {
-    defaultProfile: botConfig.defaultProfile
-  }).messages;
-}
-async function loadConversationProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events, {
-    defaultProfile: botConfig.defaultProfile
-  });
-}
-async function openConversationProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events, {
-    defaultProfile: botConfig.defaultProfile
-  });
-}
-async function loadTurnProjection(args) {
-  const eventStore = getConversationEventStore();
-  if (args.committedSeq < 0) {
-    return projectConversationEvents(
-      await eventStore.loadCurrentHistory(args.conversationId),
-      { defaultProfile: botConfig.defaultProfile }
-    );
-  }
-  const historyEvents = await eventStore.loadHistoryContaining(
-    args.conversationId,
-    args.committedSeq,
-    args.includeTail ? void 0 : args.committedSeq
-  );
-  if (!historyEvents) {
-    return void 0;
-  }
-  return projectConversationEvents(historyEvents, {
-    defaultProfile: botConfig.defaultProfile
-  });
-}
-async function loadConnectedMcpProviders(args) {
-  const events = await getConversationEventStore().loadHistory(
-    args.conversationId
-  );
-  return connectedMcpProvidersFromEvents(events, args.credentialSubjectId);
-}
-function messageTimestamp2(message) {
-  const timestamp = message.timestamp;
-  return typeof timestamp === "number" ? timestamp : Date.now();
-}
-async function commitMessages(args) {
-  const executor = args.executor ?? getSqlExecutor();
-  return await withConversationEventLock(
-    executor,
-    args.conversationId,
-    async () => executor.transaction(
-      async () => await commitMessagesLocked(args, executor)
-    )
-  );
-}
-async function commitAcceptedReply(args) {
-  const executor = getSqlExecutor();
-  await withConversationEventLock(
-    executor,
-    args.conversationId,
-    async () => executor.transaction(async () => {
-      if (args.agentMessage) {
-        const agentMessage = normalizeDurableMessage(args.agentMessage);
-        await createSqlConversationEventStore(executor).append(
-          args.conversationId,
-          [
-            {
-              idempotencyKey: `message:${args.conversationMessageId}:agent`,
-              data: historyItemFromPiMessage(agentMessage, contextProvenance),
-              createdAtMs: messageTimestamp2(agentMessage)
-            }
-          ]
-        );
-      }
-      await appendConversationMessages(
-        createSqlConversationEventStore(executor),
-        {
-          conversation: args.conversation,
-          conversationId: args.conversationId,
-          ...args.repliedAtMs === void 0 ? void 0 : { repliedAtMs: args.repliedAtMs }
-        }
-      );
-      for (const binding of args.providerConversationBindings ?? []) {
-        await bindProviderConversation(executor, {
-          conversationId: args.conversationId,
-          ...binding
-        });
-      }
-    })
-  );
-}
-async function commitMessagesLocked(args, executor) {
-  const eventStore = createSqlConversationEventStore(executor);
-  const currentEvents = await eventStore.loadCurrentHistory(
-    args.conversationId
-  );
-  const current = projectConversationEvents(currentEvents, {
-    defaultProfile: botConfig.defaultProfile
-  });
-  const nextLocalMessages = stripRuntimeTurnContext(args.messages).map(
-    normalizeDurableMessage
-  );
-  const matchingPrefix = countDurablePrefix(
-    current.messages,
-    nextLocalMessages
-  );
-  const nextLocalProvenance = resolveCommitProvenance({
-    existing: current,
-    nextMessages: nextLocalMessages,
-    matchingPrefix,
-    ...args.provenance ? { explicitProvenance: args.provenance } : void 0,
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : void 0,
-    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : void 0
-  });
-  if (matchingPrefix === current.messages.length) {
-    const newMessages = nextLocalMessages.slice(matchingPrefix);
-    const turnContext = args.turnContext;
-    const turnContextEvents = turnContext?.contexts.map((context, index) => ({
-      idempotencyKey: `turn:${turnContext.turnId}:context:${context.pluginName}:${index}`,
-      createdAtMs: context.loadedAtMs,
-      data: {
-        type: "turn_context",
-        turnId: turnContext.turnId,
-        pluginName: context.pluginName,
-        kind: context.kind,
-        version: context.version,
-        content: context.content
-      }
-    })) ?? [];
-    const appendedEvents = await eventStore.append(args.conversationId, [
-      ...newMessages.map((message, index) => ({
-        data: historyItemFromPiMessage(
-          message,
-          nextLocalProvenance[matchingPrefix + index]
-        ),
-        createdAtMs: messageTimestamp2(message)
-      })),
-      ...turnContextEvents
-    ]);
-    const cursor = appendedEvents.at(-1) ?? currentEvents.at(-1);
-    return {
-      committedSeq: cursor?.seq ?? -1,
-      historyVersion: cursor?.historyVersion ?? 0,
-      messageSeqs: [
-        ...current.seqs,
-        ...appendedEvents.slice(0, newMessages.length).map((event) => event.seq)
-      ],
-      messages: nextLocalMessages,
-      provenance: nextLocalProvenance
-    };
-  }
-  throw new AgentHistoryBranchError(args.conversationId);
-}
-async function recordMcpProviderConnected(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (connectedMcpProvidersFromEvents(events, args.credentialSubjectId).includes(
-    args.provider
-  )) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: {
-        type: "mcp_provider_connected",
-        provider: args.provider,
-        credentialSubjectId: args.credentialSubjectId
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationRequested(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (events.some(
-    (event) => event.data.type === "authorization_requested" && event.data.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: {
-        type: "authorization_requested",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId,
-        delivery: args.delivery
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationCompleted(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (events.some(
-    (event) => event.data.type === "authorization_completed" && event.data.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: {
-        type: "authorization_completed",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-function authenticationEventIdempotencyKey(args) {
-  if (args.authorizationId) {
-    return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:authentication_${args.action}:authorization:${args.authorizationId}`;
-  }
-  return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:authentication_${args.action}:${args.provider}:actor:${args.actorId}`;
-}
-async function recordAuthenticationAccountChange(action, args) {
-  const definition = action === "linked" ? authenticationLinkedEvent : authenticationUnlinkedEvent;
-  const content = definition.parse({
-    actorId: args.actorId,
-    provider: args.provider,
-    ...args.accountLabel ? { accountLabel: args.accountLabel } : void 0,
-    ...args.authorizationId ? { authorizationId: args.authorizationId } : void 0,
-    ...args.providerLabel ? { providerLabel: args.providerLabel } : void 0
-  });
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      createdAtMs: Date.now(),
-      idempotencyKey: authenticationEventIdempotencyKey({
-        action,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId,
-        provider: args.provider
-      }),
-      data: {
-        type: "structured_event",
-        namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
-        name: definition.eventName,
-        version: definition.version,
-        ...args.turnId ? { turnId: args.turnId } : void 0,
-        content
-      }
-    }
-  ]);
-}
-async function recordAuthenticationLinked(args) {
-  await recordAuthenticationAccountChange("linked", args);
-}
-async function loadAgentsEvent(conversationId) {
-  const event = await getConversationEventStore().loadLatestStructuredEvent(
-    conversationId,
-    JUNIOR_NATIVE_EVENT_NAMESPACE,
-    agentsInstructionsUpdatedEvent.eventName
-  );
-  if (!event || event.data.type !== "structured_event") return void 0;
-  return {
-    content: agentsInstructionsUpdatedEvent.parse(
-      event.data.content
-    ),
-    seq: event.seq
-  };
-}
-function agentsInstructionsIdempotencyKey(args) {
-  const previous = args.previousSeq ?? "none";
-  return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:agents_instructions_updated:${args.turnId}:${args.action}:${previous}->${args.fingerprint}`;
-}
-async function recordAgentsInstructionsUpdated(args) {
-  const previous = await loadAgentsEvent(args.conversationId);
-  const instructions = args.instructions;
-  if (previous && (!instructions && previous.content.action === "cleared" || instructions && previous.content.action !== "cleared" && previous.content.fingerprint === instructions.fingerprint && previous.content.directory === instructions.directory)) {
-    return;
-  }
-  const action = !instructions ? "cleared" : previous && previous.content.action !== "cleared" ? "replaced" : "loaded";
-  const fingerprint = instructions?.fingerprint ?? "cleared";
-  const content = agentsInstructionsUpdatedEvent.parse({
-    action,
-    fingerprint,
-    sources: instructions?.sources ?? [],
-    ...instructions ? { directory: instructions.directory } : void 0,
-    ...instructions ? { textBytes: Buffer.byteLength(instructions.text, "utf8") } : void 0
-  });
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      createdAtMs: Date.now(),
-      idempotencyKey: agentsInstructionsIdempotencyKey({
-        action,
-        fingerprint,
-        previousSeq: previous?.seq,
-        turnId: args.turnId
-      }),
-      data: {
-        type: "structured_event",
-        namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
-        name: agentsInstructionsUpdatedEvent.eventName,
-        version: agentsInstructionsUpdatedEvent.version,
-        turnId: args.turnId,
-        content
-      }
-    }
-  ]);
-}
-async function recordSubscribedReplyRoute(args) {
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      idempotencyKey: `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:passive_reply_routed:${args.runId}`,
-      createdAtMs: Date.now(),
-      data: {
-        type: "structured_event",
-        namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
-        name: "passive_reply_routed",
-        version: 1,
-        content: {
-          costUsd: args.costUsd,
-          reason: args.reason,
-          shouldReply: args.shouldReply,
-          ...args.shouldUnsubscribe !== void 0 ? { shouldUnsubscribe: args.shouldUnsubscribe } : void 0
-        }
-      }
-    }
-  ]);
-}
-async function loadTurnRoute(args) {
-  const event = await getConversationEventStore().loadByIdempotencyKey(
-    args.conversationId,
-    `turn:${args.turnId}:routed`
-  );
-  if (!event) {
-    return void 0;
-  }
-  if (event.data.type !== "turn_routed" || event.data.turnId !== args.turnId) {
-    throw new Error(`Turn route key for "${args.turnId}" has invalid data`);
-  }
-  return { ...event.data, seq: event.seq };
-}
-async function recordTurnRoute(args) {
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      idempotencyKey: `turn:${args.turnId}:routed`,
-      createdAtMs: Date.now(),
-      data: {
-        type: "turn_routed",
-        turnId: args.turnId,
-        modelProfile: args.modelProfile,
-        modelId: args.modelId,
-        ...args.costUsd !== void 0 ? { costUsd: args.costUsd } : void 0,
-        reasoningLevel: args.reasoningLevel,
-        ...args.confidence !== void 0 ? { confidence: args.confidence } : void 0,
-        source: args.source
-      }
-    }
-  ]);
-}
-async function recordToolExecutionStarted(args) {
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      data: {
-        type: "tool_execution_started",
-        toolCallId: args.toolCallId,
-        toolName: args.toolName
-      },
-      createdAtMs: args.createdAtMs ?? Date.now()
-    }
-  ]);
-}
-function attachmentsDeliveredIdempotencyKey(args) {
-  if (args.toolCallId) {
-    return `attachments_delivered:tool:${args.toolCallId}`;
-  }
-  if (args.turnId) {
-    return `attachments_delivered:turn:${args.turnId}:` + args.attachments.map((attachment) => attachment.id).sort().join(",");
-  }
-  return `attachments_delivered:${args.conversationId}:` + args.attachments.map((attachment) => attachment.id).sort().join(",");
-}
-async function recordAttachmentsDelivered(args) {
-  if (args.attachments.length === 0) return;
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      // Retries after a successful Slack upload must not create duplicate rows.
-      idempotencyKey: attachmentsDeliveredIdempotencyKey({
-        attachments: args.attachments,
-        conversationId: args.conversationId,
-        ...args.toolCallId ? { toolCallId: args.toolCallId } : void 0,
-        ...args.turnId ? { turnId: args.turnId } : void 0
-      }),
-      data: {
-        type: "attachments_delivered",
-        attachments: args.attachments.map((attachment) => ({
-          id: attachment.id,
-          filename: attachment.filename,
-          contentType: attachment.contentType,
-          bytes: attachment.bytes
-        })),
-        ...args.toolCallId ? { toolCallId: args.toolCallId } : void 0,
-        ...args.turnId ? { turnId: args.turnId } : void 0
-      },
-      createdAtMs: args.createdAtMs ?? Date.now()
-    }
-  ]);
-}
-async function recordGuardianActionReviewed(args) {
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      data: {
-        type: "guardian_action_reviewed",
-        turnId: args.turnId,
-        toolCallId: args.toolCallId,
-        toolName: args.toolName,
-        ...args.costUsd !== void 0 ? { costUsd: args.costUsd } : void 0,
-        decision: args.decision,
-        riskLevel: args.riskLevel,
-        userAuthorization: args.userAuthorization
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-
-// src/chat/services/persist-retry.ts
-var PERSIST_ATTEMPTS = 3;
-async function persistWithRetry(persist) {
-  let lastError;
-  for (let attempt = 1; attempt <= PERSIST_ATTEMPTS; attempt += 1) {
-    try {
-      await persist();
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt < PERSIST_ATTEMPTS) {
-        await sleep(attempt * 100);
-      }
-    }
-  }
-  throw lastError;
-}
-
-// src/chat/task-execution/turn-cursor.ts
-import {
-  actorSchema,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-
-// src/chat/repository-instructions.ts
-import { createHash as createHash2 } from "crypto";
-import path2 from "path";
-
-// src/chat/tools/sandbox/file-utils.ts
-import path from "path";
-var MAX_TEXT_CHARS = 6e4;
-var RIPGREP_EXCLUDED_GLOBS = [
-  "!**/.git/**",
-  "!**/node_modules/**"
-];
-var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
-var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-function positiveInteger2(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return void 0;
-  }
-  const integer = Math.floor(value);
-  return integer > 0 ? integer : void 0;
-}
-function normalizeToLf(value) {
-  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function truncateText(value, maxChars = MAX_TEXT_CHARS) {
-  if (value.length <= maxChars) {
-    return { content: value, truncated: false };
-  }
-  const removed = value.length - maxChars;
-  return {
-    content: `${value.slice(0, maxChars)}
-
-[output truncated: ${removed} characters removed]`,
-    truncated: true
-  };
-}
-function isMissingPathError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const candidate = error;
-  if (candidate.code === "ENOENT") {
-    return true;
-  }
-  return typeof candidate.message === "string" && candidate.message.startsWith("File not found:");
-}
-function missingPathSearchResult(params) {
-  const textPath = params.displayPath ?? params.missingPath ?? params.path;
-  throw new ToolInputError(`Path not found: ${textPath}`);
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function globToRegExp(pattern) {
-  let source = "";
-  for (let index = 0; index < pattern.length; index += 1) {
-    const char = pattern[index];
-    const next = pattern[index + 1];
-    if (char === "*" && next === "*") {
-      if (pattern[index + 2] === "/") {
-        source += "(?:.*/)?";
-        index += 2;
-        continue;
-      }
-      source += ".*";
-      index += 1;
-      continue;
-    }
-    if (char === "*") {
-      source += "[^/]*";
-      continue;
-    }
-    if (char === "?") {
-      source += "[^/]";
-      continue;
-    }
-    source += escapeRegExp(char);
-  }
-  return new RegExp(`^${source}$`);
-}
-function matchesGlob(relativePath, pattern) {
-  const matcher = globToRegExp(pattern);
-  if (matcher.test(relativePath)) {
-    return true;
-  }
-  if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) {
-    return true;
-  }
-  return !pattern.includes("/") && matcher.test(path.posix.basename(relativePath));
-}
-function resolveWorkspacePath(input, fallback = ".") {
-  const requested = (input ?? "").trim() || fallback;
-  const absolute = requested.startsWith("/") ? requested : path.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
-  const normalized = path.posix.normalize(absolute);
-  if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
-    throw new ToolInputError(
-      `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
-    );
-  }
-  return normalized;
-}
-function getRipgrepSearchLocation(root, rootIsDirectory) {
-  if (rootIsDirectory) {
-    return { cwd: root, target: "." };
-  }
-  return {
-    cwd: path.posix.dirname(root),
-    target: path.posix.basename(root)
-  };
-}
-async function collectFiles(params) {
-  const files = [];
-  let limitReached = false;
-  let missingPath;
-  const visit = async (dirPath) => {
-    if (missingPath) {
-      return;
-    }
-    let entries;
-    try {
-      entries = (await params.fs.readdir(dirPath)).sort(
-        (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-      );
-    } catch (error) {
-      if (isMissingPathError(error)) {
-        missingPath = dirPath;
-        return;
-      }
-      throw error;
-    }
-    for (const entry of entries) {
-      const fullPath = path.posix.join(dirPath, entry);
-      let stat2;
-      try {
-        stat2 = await params.fs.stat(fullPath);
-      } catch (error) {
-        if (isMissingPathError(error)) {
-          missingPath = fullPath;
-          return;
-        }
-        throw error;
-      }
-      if (stat2.isDirectory()) {
-        if (!SKIPPED_DIRECTORIES.has(entry)) {
-          await visit(fullPath);
-        }
-        if (limitReached) return;
-        continue;
-      }
-      const relativePath = path.posix.relative(params.root, fullPath);
-      if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
-        files.push(fullPath);
-        if (params.limit && files.length >= params.limit) {
-          limitReached = true;
-          return;
-        }
-      }
-    }
-  };
-  let stat;
-  try {
-    stat = await params.fs.stat(params.root);
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return {
-        files,
-        limitReached: false,
-        missingPath: params.root,
-        missingRoot: true
-      };
-    }
-    throw error;
-  }
-  if (!stat.isDirectory()) {
-    const relativePath = path.posix.basename(params.root);
-    return {
-      files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
-      limitReached: false,
-      missingRoot: false
-    };
-  }
-  await visit(params.root);
-  return {
-    files,
-    limitReached,
-    missingPath,
-    missingRoot: missingPath === params.root
-  };
-}
-
-// src/chat/repository-instructions.ts
-var AGENTS_FILENAME = "AGENTS.md";
-var MAX_REPOSITORY_INSTRUCTIONS_BYTES = 32 * 1024;
-var AGENTS_REPLACEMENT_NOTICE = "These AGENTS.md instructions replace all previously provided AGENTS.md instructions.";
-var AGENTS_REMOVAL_NOTICE = "The previously provided AGENTS.md instructions no longer apply.";
-async function pathExists(fs, target) {
-  try {
-    await fs.stat(target);
-    return true;
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return false;
-    }
-    throw error;
-  }
-}
-async function directoryExists(fs, target) {
-  try {
-    return (await fs.stat(target)).isDirectory();
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return false;
-    }
-    throw error;
-  }
-}
-async function findGitRoot(fs, cwd) {
-  let current = cwd;
-  for (; ; ) {
-    if (await pathExists(fs, path2.posix.join(current, ".git"))) {
-      return current;
-    }
-    if (current === SANDBOX_WORKSPACE_ROOT) {
-      return void 0;
-    }
-    const parent = path2.posix.dirname(current);
-    if (parent === current || parent !== SANDBOX_WORKSPACE_ROOT && !parent.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
-      return void 0;
-    }
-    current = parent;
-  }
-}
-async function listRepositoryDirectories(fs) {
-  if (!await directoryExists(fs, SANDBOX_REPOS_ROOT)) {
-    return [];
-  }
-  const entries = await fs.readdir(SANDBOX_REPOS_ROOT);
-  const repositories = [];
-  for (const entry of entries) {
-    const candidate = path2.posix.join(SANDBOX_REPOS_ROOT, entry);
-    if (await directoryExists(fs, candidate) && await pathExists(fs, path2.posix.join(candidate, ".git"))) {
-      repositories.push(candidate);
-    }
-  }
-  return repositories.sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  );
-}
-async function readInstructionFile(fs, filePath) {
-  try {
-    const content = await fs.readFile(filePath, { encoding: "utf8" });
-    return content.trim() ? content : void 0;
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return void 0;
-    }
-    throw error;
-  }
-}
-async function resolveRepositoryInstructions(args) {
-  const gitRoot = await findGitRoot(args.fs, args.cwd);
-  if (!gitRoot) {
-    return void 0;
-  }
-  const directories = [];
-  let current = args.cwd;
-  for (; ; ) {
-    directories.push(current);
-    if (current === gitRoot) {
-      break;
-    }
-    current = path2.posix.dirname(current);
-  }
-  directories.reverse();
-  const sources = [];
-  let remaining = Math.max(
-    0,
-    args.maxBytes ?? MAX_REPOSITORY_INSTRUCTIONS_BYTES
-  );
-  for (const directory of directories) {
-    if (remaining <= 0) {
-      break;
-    }
-    const filePath = path2.posix.join(directory, AGENTS_FILENAME);
-    const content = await readInstructionFile(args.fs, filePath);
-    if (!content) {
-      continue;
-    }
-    const bytes = Buffer.from(content, "utf8");
-    const bounded = bytes.length <= remaining ? content : bytes.subarray(0, remaining).toString("utf8");
-    sources.push({ content: bounded, path: filePath });
-    remaining -= Buffer.byteLength(bounded, "utf8");
-  }
-  if (sources.length === 0) {
-    return void 0;
-  }
-  const text = formatInstructionSources(sources);
-  const fingerprint = createHash2("sha256").update(JSON.stringify({ directory: args.cwd, sources })).digest("hex");
-  return { directory: args.cwd, fingerprint, sources, text };
-}
-function formatInstructionSources(sources) {
-  if (sources.length === 1) {
-    return sources[0].content;
-  }
-  return sources.map(
-    (source) => `## ${path2.posix.dirname(source.path)}
-
-${source.content}`
-  ).join("\n\n");
-}
-function mergeRepositoryInstructions(bundles) {
-  if (bundles.length === 0) {
-    return void 0;
-  }
-  if (bundles.length === 1) {
-    return bundles[0];
-  }
-  const sources = bundles.flatMap((bundle) => bundle.sources);
-  const text = formatInstructionSources(sources);
-  const fingerprint = createHash2("sha256").update(
-    JSON.stringify({
-      directories: bundles.map((bundle) => bundle.directory ?? null),
-      sources
-    })
-  ).digest("hex");
-  return { fingerprint, sources, text };
-}
-async function resolveRepositoryInstructionsForDirectories(args) {
-  const uniqueDirectories = [
-    ...new Set(
-      args.directories.filter(
-        (directory) => directory === SANDBOX_WORKSPACE_ROOT || directory.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)
-      )
-    )
-  ].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-  let remaining = MAX_REPOSITORY_INSTRUCTIONS_BYTES;
-  const bundles = [];
-  for (const directory of uniqueDirectories) {
-    if (remaining <= 0) {
-      break;
-    }
-    const instructions = await resolveRepositoryInstructions({
-      cwd: directory,
-      fs: args.fs,
-      maxBytes: remaining
-    });
-    if (!instructions) {
-      continue;
-    }
-    bundles.push(instructions);
-    remaining -= instructions.sources.reduce(
-      (total, source) => total + Buffer.byteLength(source.content, "utf8"),
-      0
-    );
-  }
-  return mergeRepositoryInstructions(bundles);
-}
-function renderAgentsInstructions(args) {
-  const directory = args.directory ? ` for ${args.directory}` : "";
-  return `# AGENTS.md instructions${directory}
-
-<INSTRUCTIONS>
-${args.text}
-</INSTRUCTIONS>`;
-}
-function buildAgentsInstructionsMessage(args) {
-  return {
-    role: "user",
-    content: [{ type: "text", text: renderAgentsInstructions(args) }],
-    timestamp: args.timestamp ?? Date.now()
-  };
-}
-function findVisibleAgentsInstructions(messages) {
-  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
-    const message = messages[messageIndex];
-    if (message.role !== "user" || !Array.isArray(message.content)) {
-      continue;
-    }
-    for (let partIndex = message.content.length - 1; partIndex >= 0; partIndex -= 1) {
-      const part = message.content[partIndex];
-      if (part.type !== "text" || typeof part.text !== "string" || !part.text.startsWith("# AGENTS.md instructions")) {
-        continue;
-      }
-      const match = part.text.match(
-        /^# AGENTS\.md instructions(?: for ([^\n]+))?\n\n<INSTRUCTIONS>\n([\s\S]*)\n<\/INSTRUCTIONS>$/
-      );
-      if (!match) {
-        continue;
-      }
-      let text = match[2];
-      if (text === AGENTS_REMOVAL_NOTICE) {
-        return { active: false };
-      }
-      if (text.startsWith(`${AGENTS_REPLACEMENT_NOTICE}
-
-`)) {
-        text = text.slice(AGENTS_REPLACEMENT_NOTICE.length + 2);
-      }
-      return {
-        active: true,
-        ...match[1] ? { directory: match[1] } : void 0,
-        text
-      };
-    }
-  }
-  return void 0;
-}
-function isAgentsInstructionsMessage(message) {
-  return Boolean(findVisibleAgentsInstructions([message]));
-}
-
-// src/chat/task-execution/turn-cursor-keys.ts
-var TURN_CURSOR_PREFIX = "junior:turn_cursor:v2";
-function turnCursorKey(conversationId, turnId) {
-  return `${TURN_CURSOR_PREFIX}:${conversationId}:${turnId}`;
-}
-function turnCursorIndexKey(conversationId) {
-  return `${TURN_CURSOR_PREFIX}:conversation:${conversationId}:index`;
-}
-function turnCursorMutationKey(conversationId, turnId) {
-  return `${TURN_CURSOR_PREFIX}:mutation:${conversationId}:${turnId}`;
-}
-
-// src/chat/task-execution/turn-cursor.ts
-var TURN_CURSOR_SCHEMA_VERSION = 2;
-var TURN_CURSOR_RESUME_TTL_MS = 24 * 60 * 60 * 1e3;
-var TURN_CURSOR_TERMINAL_TTL_MS = 60 * 60 * 1e3;
-var TURN_CURSOR_MUTATION_LOCK_WAIT_MS = 1e4;
-async function withTurnCursorMutation(conversationId, turnId, run) {
-  const state = getStateAdapter();
-  await state.connect();
-  const result = await withLock(
-    state,
-    turnCursorMutationKey(conversationId, turnId),
-    async (lock) => await run(async () => await fenceLock(state, lock)),
-    {
-      keepAlive: true,
-      ttlMs: MUTATION_LOCK_TTL_MS,
-      waitMs: TURN_CURSOR_MUTATION_LOCK_WAIT_MS
-    }
-  );
-  if (!result.acquired) {
-    throw new Error(`Could not acquire turn cursor lock for ${turnId}`);
-  }
-  return result.value;
-}
-function executionMetricsForTurn(conversation, turnId) {
-  return conversation?.executionMetrics?.runId === turnId ? conversation.executionMetrics : void 0;
-}
-function definedProps(values) {
-  return Object.fromEntries(
-    Object.entries(values).filter(([, value]) => value !== void 0)
-  );
-}
-var turnStatusSchema = z2.enum([
-  "running",
-  "paused",
-  "completed",
-  "failed",
-  "abandoned"
-]);
-var turnSurfaceSchema = z2.enum([
-  "slack",
-  "api",
-  "scheduler",
-  "internal"
-]);
-var turnPauseReasonSchema = z2.enum([
-  "timeout",
-  "auth",
-  "yield",
-  "retry"
-]);
-var nonNegativeNumberSchema = z2.number().finite().nonnegative();
-var seqCursorSchema = z2.number().int().min(-1);
-var storedTurnSummarySchema = z2.object({
-  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
-  version: z2.number().int().nonnegative(),
-  conversationId: z2.string().min(1),
-  dispatchId: z2.string().min(1).optional(),
-  dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
-  resultMessageId: z2.string().min(1).optional(),
-  resumeReason: turnPauseReasonSchema.optional(),
-  turnId: z2.string().min(1),
-  sliceId: z2.number().int().nonnegative(),
-  state: turnStatusSchema,
-  surface: turnSurfaceSchema.optional(),
-  updatedAtMs: nonNegativeNumberSchema
-}).strip();
-var storedTurnRecordSchema = z2.object({
-  // TODO(dcramer): Require Actor after no deployed Turn cursor can omit it.
-  actor: actorSchema.optional(),
-  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
-  version: z2.number().int().nonnegative(),
-  conversationId: z2.string().min(1),
-  dispatchId: z2.string().min(1).optional(),
-  dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
-  resultMessageId: z2.string().min(1).optional(),
-  lastProgressAtMs: nonNegativeNumberSchema,
-  resumeReason: turnPauseReasonSchema.optional(),
-  publishExternally: z2.boolean().optional(),
-  source: sourceSchema.optional(),
-  resumedFromSliceId: z2.number().int().nonnegative().optional(),
-  turnId: z2.string().min(1),
-  sliceId: z2.number().int().nonnegative(),
-  startedAtMs: nonNegativeNumberSchema,
-  state: turnStatusSchema,
-  surface: turnSurfaceSchema.optional(),
-  traceId: z2.string().optional(),
-  updatedAtMs: nonNegativeNumberSchema,
-  committedSeq: seqCursorSchema,
-  historyVersion: z2.number().int().nonnegative().optional(),
-  errorMessage: z2.string().optional(),
-  cumulativeToolCallCount: z2.number().int().nonnegative().optional(),
-  turnStartSeq: seqCursorSchema.optional(),
-  runtimeContext: z2.array(piMessageSchema).optional()
-}).strip();
-function conversationExecutionFromSummary(summary) {
-  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
-  return {
-    status,
-    runId: summary.turnId,
-    updatedAtMs: summary.updatedAtMs
-  };
-}
-function sessionLogActor(actor) {
-  return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
-}
-function parseTurnRecord(value) {
-  return storedTurnRecordSchema.parse(value);
-}
-function parseTurnSummary(value) {
-  return storedTurnSummarySchema.parse(value);
-}
-function storeTurnSummary(summary) {
-  return storedTurnSummarySchema.parse(summary);
-}
-function turnCursorTtlMs(state, ttlMs) {
-  if (ttlMs !== void 0) {
-    return Math.max(1, ttlMs);
-  }
-  return state === "running" || state === "paused" ? TURN_CURSOR_RESUME_TTL_MS : TURN_CURSOR_TERMINAL_TTL_MS;
-}
-function turnCursorIndexTtlMs(ttlMs) {
-  return Math.max(1, ttlMs ?? TURN_CURSOR_RESUME_TTL_MS);
-}
-function projectTurnSummary(record) {
-  return parseTurnSummary(record);
-}
-async function appendTurnSummary(summary, ttlMs) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.appendToList(
-    turnCursorIndexKey(summary.conversationId),
-    storeTurnSummary(summary),
-    { ttlMs }
-  );
-}
-async function recordConversationActivityMetadata(args) {
-  const conversationStore = args.conversationStore ?? getConversationStore();
-  const conversation = await conversationStore.get({
-    conversationId: args.summary.conversationId
-  });
-  const hasParent = Boolean(conversation?.parentConversationId);
-  const destination = hasParent ? void 0 : args.destination;
-  if (!hasParent && !destination && !conversation) {
-    return;
-  }
-  const activitySource = hasParent ? "internal" : args.source?.kind === "web" ? "web" : destination?.platform === "local" ? "local" : destination ? args.summary.surface : void 0;
-  await conversationStore.recordActivity({
-    activityAtMs: args.summary.updatedAtMs,
-    channelName: args.summary.channelName,
-    conversationId: args.summary.conversationId,
-    destination,
-    nowMs: args.nowMs,
-    actor: sessionLogActor(args.actor),
-    ...definedProps({ source: activitySource }),
-    ...args.source ? { sessionSource: args.source } : void 0,
-    visibility: hasParent ? void 0 : args.destinationVisibility
-  });
-  await conversationStore.recordExecution({
-    channelName: args.summary.channelName,
-    conversationId: args.summary.conversationId,
-    createdAtMs: args.summary.startedAtMs,
-    destination,
-    execution: conversationExecutionFromSummary(args.summary),
-    lastActivityAtMs: args.summary.updatedAtMs,
-    metrics: {
-      durationMs: args.summary.cumulativeDurationMs,
-      ...args.summary.cumulativeUsage ? { usage: args.summary.cumulativeUsage } : void 0
-    },
-    actor: sessionLogActor(args.actor),
-    ...definedProps({ source: activitySource }),
-    updatedAtMs: args.nowMs,
-    visibility: hasParent ? void 0 : args.destinationVisibility
-  });
-}
-function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true, runtimeMetrics) {
-  const restoredProjection = restoreVolatileContext && (stored.state === "running" || stored.state === "paused") ? restoreRuntimeContext(piProjection, stored.runtimeContext) : piProjection;
-  return {
-    ...definedProps({ actor: stored.actor }),
-    schemaVersion: stored.schemaVersion,
-    version: stored.version,
-    conversationId: stored.conversationId,
-    turnId: stored.turnId,
-    sliceId: stored.sliceId,
-    state: stored.state,
-    startedAtMs: stored.startedAtMs,
-    lastProgressAtMs: stored.lastProgressAtMs,
-    updatedAtMs: stored.updatedAtMs,
-    piMessages: restoredProjection.messages,
-    piMessageProvenance: restoredProjection.provenance,
-    actors: instructionActors(piProjection.provenance),
-    cumulativeDurationMs: runtimeMetrics?.cumulativeDurationMs ?? 0,
-    ...definedProps({
-      channelName: runtimeMetrics?.channelName,
-      cumulativeToolCallCount: stored.cumulativeToolCallCount,
-      cumulativeUsage: runtimeMetrics?.cumulativeUsage,
-      dispatchId: stored.dispatchId,
-      dispatchOutcome: stored.dispatchOutcome,
-      errorMessage: stored.errorMessage,
-      resumeReason: stored.resumeReason,
-      source: stored.source,
-      resultMessageId: stored.resultMessageId,
-      resumedFromSliceId: stored.resumedFromSliceId,
-      surface: stored.surface,
-      traceId: stored.traceId,
-      turnStartMessageIndex
-    })
-  };
-}
-function restoreRuntimeContext(projection, runtimeContext) {
-  if (!runtimeContext || runtimeContext.length === 0) return projection;
-  const restoredMessages = [...projection.messages];
-  const restoredProvenance = [...projection.provenance];
-  const unmatchedRuntimeContext = [];
-  for (const runtimeMessage of runtimeContext) {
-    const runtime = runtimeMessage;
-    const targetIndex = restoredMessages.findIndex((message) => {
-      const candidate = message;
-      return candidate.role === "user" && candidate.timestamp === runtime.timestamp;
-    });
-    if (targetIndex < 0) {
-      if (isAgentsInstructionsMessage(runtimeMessage)) {
-        const followingIndex = restoredMessages.findIndex((message) => {
-          const timestamp = message.timestamp;
-          return typeof runtime.timestamp === "number" && typeof timestamp === "number" && timestamp > runtime.timestamp;
-        });
-        const insertionIndex = followingIndex < 0 ? restoredMessages.length : followingIndex;
-        restoredMessages.splice(insertionIndex, 0, runtimeMessage);
-        restoredProvenance.splice(insertionIndex, 0, contextProvenance);
-      } else {
-        unmatchedRuntimeContext.push(runtimeMessage);
-      }
-      continue;
-    }
-    restoredMessages.splice(targetIndex, 0, runtimeMessage);
-    restoredProvenance.splice(targetIndex, 0, contextProvenance);
-  }
-  return {
-    messages: [...unmatchedRuntimeContext, ...restoredMessages],
-    provenance: [
-      ...unmatchedRuntimeContext.map(() => contextProvenance),
-      ...restoredProvenance
-    ]
-  };
-}
-async function getStoredTurnRecord(conversationId, turnId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(turnCursorKey(conversationId, turnId));
-  return value == null ? void 0 : parseTurnRecord(value);
-}
-async function materializeStoredTurnRecord(conversationId, turnId, followCurrentReplacement) {
-  const parsed = await getStoredTurnRecord(conversationId, turnId);
-  if (!parsed) {
-    return void 0;
-  }
-  const pinnedProjection = await loadTurnProjection({
-    conversationId,
-    committedSeq: parsed.committedSeq,
-    // Unfinished records include the current-epoch tail so parked input
-    // appended after the last safe boundary stays model-visible on resume.
-    includeTail: parsed.state === "running" || parsed.state === "paused"
-  });
-  if (!pinnedProjection) {
-    return void 0;
-  }
-  const eventStore = getConversationEventStore();
-  const currentHistoryVersion = await eventStore.loadCurrentHistoryVersion(conversationId);
-  const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "paused") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
-  const piProjection = followsReplacement ? projectConversationEvents(
-    await eventStore.loadCurrentHistory(conversationId),
-    { defaultProfile: botConfig.defaultProfile }
-  ) : pinnedProjection;
-  const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
-  const conversation = await getConversationStore().get({ conversationId });
-  const executionMetrics = executionMetricsForTurn(conversation, turnId);
-  return materializeTurnRecord(
-    parsed,
-    piProjection,
-    turnStartMessageIndex,
-    !followsReplacement && (parsed.historyVersion === void 0 || parsed.historyVersion === currentHistoryVersion),
-    {
-      channelName: conversation?.channelName,
-      cumulativeDurationMs: executionMetrics?.durationMs,
-      cumulativeUsage: executionMetrics?.usage
-    }
-  );
-}
-async function getTurnRecord(conversationId, turnId) {
-  return await materializeStoredTurnRecord(conversationId, turnId, false);
-}
-async function getTurnRecordForResume(conversationId, turnId) {
-  return await materializeStoredTurnRecord(conversationId, turnId, true);
-}
-function buildStoredRecord(args) {
-  const nowMs = Date.now();
-  return {
-    schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
-    version: (args.previousVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    turnId: args.turnId,
-    sliceId: args.sliceId,
-    state: args.state,
-    startedAtMs: args.startedAtMs ?? nowMs,
-    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
-    updatedAtMs: nowMs,
-    committedSeq: args.committedSeq,
-    ...definedProps({
-      actor: args.actor,
-      cumulativeToolCallCount: args.cumulativeToolCallCount,
-      dispatchId: args.dispatchId,
-      dispatchOutcome: args.dispatchOutcome,
-      errorMessage: args.errorMessage,
-      historyVersion: args.historyVersion,
-      resumeReason: args.resumeReason,
-      publishExternally: args.publishExternally,
-      source: args.source,
-      resultMessageId: args.resultMessageId,
-      resumedFromSliceId: args.resumedFromSliceId,
-      runtimeContext: args.runtimeContext && args.runtimeContext.length > 0 ? args.runtimeContext : void 0,
-      surface: args.surface,
-      traceId: args.traceId,
-      turnStartSeq: args.turnStartSeq
-    })
-  };
-}
-async function setStoredRecord(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const storedRecord = storedTurnRecordSchema.parse(args.record);
-  await args.fence();
-  await recordConversationActivityMetadata({
-    actor: args.actor,
-    conversationStore: args.conversationStore,
-    destination: args.destination,
-    destinationVisibility: args.destinationVisibility,
-    nowMs: Date.now(),
-    source: args.source,
-    summary: {
-      ...projectTurnSummary(storedRecord),
-      startedAtMs: storedRecord.startedAtMs,
-      ...args.runtimeMetrics
-    }
-  });
-  await args.fence();
-  await stateAdapter.set(
-    turnCursorKey(storedRecord.conversationId, storedRecord.turnId),
-    storedRecord,
-    args.ttlMs
-  );
-  await args.fence();
-  await appendTurnSummary(
-    projectTurnSummary(storedRecord),
-    turnCursorIndexTtlMs(args.indexTtlMs)
-  );
-  return materializeTurnRecord(
-    storedRecord,
-    {
-      messages: [...args.piMessages],
-      provenance: [...args.piMessageProvenance]
-    },
-    args.turnStartMessageIndex,
-    true,
-    args.runtimeMetrics
-  );
-}
-async function updateTurnState(args) {
-  const parsed = await getStoredTurnRecord(
-    args.existing.conversationId,
-    args.existing.turnId
-  );
-  if (!parsed || parsed.version !== args.existing.version) {
-    return void 0;
-  }
-  return await setStoredRecord({
-    actor: args.existing.actor,
-    fence: args.fence,
-    piMessages: args.existing.piMessages,
-    piMessageProvenance: args.existing.piMessageProvenance,
-    ttlMs: turnCursorTtlMs(args.state),
-    runtimeMetrics: {
-      cumulativeDurationMs: args.existing.cumulativeDurationMs,
-      ...definedProps({
-        channelName: args.existing.channelName,
-        cumulativeUsage: args.existing.cumulativeUsage
-      })
-    },
-    ...definedProps({
-      turnStartMessageIndex: args.existing.turnStartMessageIndex
-    }),
-    record: buildStoredRecord({
-      actor: args.existing.actor,
-      conversationId: args.existing.conversationId,
-      turnId: args.existing.turnId,
-      sliceId: args.existing.sliceId,
-      state: args.state,
-      committedSeq: parsed.committedSeq,
-      startedAtMs: parsed.startedAtMs,
-      lastProgressAtMs: parsed.lastProgressAtMs,
-      previousVersion: parsed.version,
-      ...definedProps({
-        cumulativeToolCallCount: args.existing.cumulativeToolCallCount,
-        dispatchId: args.existing.dispatchId,
-        dispatchOutcome: args.existing.dispatchOutcome,
-        errorMessage: args.errorMessage ?? args.existing.errorMessage,
-        historyVersion: parsed.historyVersion,
-        resumeReason: args.existing.resumeReason,
-        publishExternally: parsed.publishExternally,
-        source: args.existing.source,
-        resultMessageId: args.resultMessageId ?? args.existing.resultMessageId,
-        resumedFromSliceId: args.existing.resumedFromSliceId,
-        surface: args.existing.surface,
-        traceId: args.existing.traceId,
-        turnStartSeq: parsed.turnStartSeq
-      })
-    })
-  });
-}
-async function upsertTurnRecord(args) {
-  return await withTurnCursorMutation(
-    args.conversationId,
-    args.turnId,
-    async (fence) => await upsertTurnRecordLocked(args, fence)
-  );
-}
-async function upsertTurnRecordLocked(args, fence) {
-  const existingRecord = await getStoredTurnRecord(
-    args.conversationId,
-    args.turnId
-  );
-  const conversation = await (args.conversationStore ?? getConversationStore()).get({
-    conversationId: args.conversationId
-  });
-  const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
-  const existingDispatchId = existingRecord?.dispatchId ?? (await listTurnSummaries(args.conversationId)).find(
-    (summary) => summary.turnId === args.turnId
-  )?.dispatchId;
-  if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) {
-    throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
-  }
-  const ttlMs = turnCursorTtlMs(args.state, args.ttlMs);
-  const instructionActor = args.actor;
-  const commit = await commitMessages({
-    conversationId: args.conversationId,
-    messages: args.piMessages,
-    ...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : void 0,
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : void 0,
-    ...args.turnContexts && args.turnContexts.length > 0 ? {
-      turnContext: {
-        contexts: args.turnContexts,
-        turnId: args.turnId
-      }
-    } : void 0
-  });
-  const durableTurnStartMessageIndex = args.turnStartMessageIndex === void 0 ? void 0 : stripRuntimeTurnContext(
-    args.piMessages.slice(0, args.turnStartMessageIndex)
-  ).length;
-  const runtimeContext = retainRuntimeTurnContext(args.piMessages);
-  const retainedRuntimeContext = runtimeContext.length > 0 ? runtimeContext : existingRecord?.historyVersion === commit.historyVersion ? existingRecord.runtimeContext : void 0;
-  const turnStartSeq = durableTurnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : durableTurnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[durableTurnStartMessageIndex - 1] ?? commit.committedSeq;
-  const turnStartMessageIndex = durableTurnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
-  const turnSource = args.source ?? existingRecord?.source;
-  const dispatchId = args.dispatchId ?? existingRecord?.dispatchId;
-  const hasProviderLocation = Boolean(conversation?.location) || args.destination?.platform === "slack";
-  const publishExternally = dispatchId || turnSource ? hasProviderLocation && (Boolean(dispatchId) || turnSource?.kind === "slack" || turnSource?.kind === "resource_event") : existingRecord?.publishExternally ?? false;
-  return await setStoredRecord({
-    actor: existingRecord?.actor ?? args.actor,
-    fence,
-    conversationStore: args.conversationStore,
-    destination: args.destination,
-    destinationVisibility: args.destinationVisibility,
-    source: args.source,
-    piMessages: commit.messages,
-    piMessageProvenance: commit.provenance,
-    ttlMs,
-    // Checkpoint commit also updates conversation execution metrics in SQL.
-    // Channel/duration/usage are not Redis resume-cursor fields.
-    runtimeMetrics: {
-      channelName: args.channelName ?? conversation?.channelName,
-      cumulativeDurationMs: args.cumulativeDurationMs ?? executionMetrics?.durationMs ?? 0,
-      cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage
-    },
-    // Pass through only an explicit override so indexes stay on the resume window
-    // by default even when the record takes a short terminal TTL.
-    ...definedProps({ indexTtlMs: args.ttlMs }),
-    turnStartMessageIndex,
-    record: buildStoredRecord({
-      actor: existingRecord?.actor ?? args.actor,
-      conversationId: args.conversationId,
-      turnId: args.turnId,
-      sliceId: args.sliceId,
-      state: args.state,
-      committedSeq: commit.committedSeq,
-      historyVersion: commit.historyVersion,
-      previousVersion: existingRecord?.version,
-      ...definedProps({
-        cumulativeToolCallCount: args.cumulativeToolCallCount ?? existingRecord?.cumulativeToolCallCount,
-        dispatchId,
-        dispatchOutcome: args.dispatchOutcome ?? existingRecord?.dispatchOutcome,
-        errorMessage: args.errorMessage,
-        lastProgressAtMs: args.lastProgressAtMs,
-        resumeReason: args.resumeReason,
-        publishExternally,
-        source: args.source ?? existingRecord?.source,
-        resultMessageId: args.resultMessageId ?? existingRecord?.resultMessageId,
-        resumedFromSliceId: args.resumedFromSliceId,
-        runtimeContext: args.state === "running" || args.state === "paused" ? retainedRuntimeContext : void 0,
-        startedAtMs: existingRecord?.startedAtMs,
-        surface: args.surface ?? existingRecord?.surface,
-        traceId: args.traceId ?? existingRecord?.traceId,
-        turnStartSeq
-      })
-    })
-  });
-}
-async function recordTurnSummary(args) {
-  await withTurnCursorMutation(
-    args.conversationId,
-    args.turnId,
-    async (fence) => await recordTurnSummaryOwned(args, fence)
-  );
-}
-async function recordTurnSummaryOwned(args, fence) {
-  const stored = await getStoredTurnRecord(args.conversationId, args.turnId);
-  const conversationStore = args.conversationStore ?? getConversationStore();
-  const conversation = await conversationStore.get({
-    conversationId: args.conversationId
-  });
-  const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
-  const priorSummary = (await listTurnSummaries(args.conversationId)).find(
-    (summary2) => summary2.turnId === args.turnId
-  );
-  const terminalSummary = priorSummary && (priorSummary.state === "completed" || priorSummary.state === "failed" || priorSummary.state === "abandoned") ? priorSummary : void 0;
-  const terminalRecord = stored && (stored.state === "completed" || stored.state === "failed" || stored.state === "abandoned") ? stored : void 0;
-  const existing = terminalSummary ?? terminalRecord ?? stored ?? priorSummary;
-  if ((terminalSummary || terminalRecord) && (args.state === "running" || args.state === "paused")) {
-    return;
-  }
-  const existingDispatchId = existing?.dispatchId;
-  const existingDispatchOutcome = priorSummary?.dispatchOutcome ?? stored?.dispatchOutcome;
-  const existingResultMessageId = priorSummary?.resultMessageId ?? stored?.resultMessageId;
-  if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) {
-    throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
-  }
-  const nowMs = Date.now();
-  const ttlMs = turnCursorIndexTtlMs(args.ttlMs);
-  const summary = {
-    schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
-    version: existing?.version ?? 0,
-    conversationId: args.conversationId,
-    turnId: args.turnId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: nowMs,
-    ...definedProps({
-      dispatchId: args.dispatchId ?? existingDispatchId,
-      dispatchOutcome: args.dispatchOutcome ?? existingDispatchOutcome,
-      resumeReason: args.resumeReason,
-      resultMessageId: args.resultMessageId ?? existingResultMessageId,
-      surface: args.surface ?? existing?.surface
-    })
-  };
-  await fence();
-  await recordConversationActivityMetadata({
-    actor: args.actor,
-    conversationStore,
-    destination: args.destination,
-    destinationVisibility: args.destinationVisibility,
-    nowMs,
-    source: args.source,
-    summary: {
-      ...summary,
-      channelName: args.channelName ?? conversation?.channelName,
-      cumulativeDurationMs: args.cumulativeDurationMs ?? executionMetrics?.durationMs ?? 0,
-      cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage,
-      startedAtMs: stored?.startedAtMs ?? args.startedAtMs ?? nowMs
-    }
-  });
-  await fence();
-  await appendTurnSummary(summary, ttlMs);
-}
-async function readTurnSummaries(key) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const values = await stateAdapter.getList(key);
-  const summaries = /* @__PURE__ */ new Map();
-  for (const value of [...values].reverse()) {
-    let summary;
-    try {
-      summary = parseTurnSummary(value);
-    } catch {
-      continue;
-    }
-    const summaryKey = `${summary.conversationId}:${summary.turnId}`;
-    if (!summaries.has(summaryKey)) {
-      summaries.set(summaryKey, summary);
-    }
-  }
-  return [...summaries.values()].sort(
-    (left, right) => right.updatedAtMs - left.updatedAtMs
-  );
-}
-async function listTurnSummaries(conversationId) {
-  return readTurnSummaries(turnCursorIndexKey(conversationId));
-}
-async function abandonTurnRecord(args) {
-  return await withTurnCursorMutation(
-    args.conversationId,
-    args.turnId,
-    async (fence) => {
-      const existing = await getTurnRecord(args.conversationId, args.turnId);
-      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
-        return void 0;
-      }
-      return await updateTurnState({
-        existing,
-        fence,
-        state: "abandoned",
-        errorMessage: args.errorMessage ?? existing.errorMessage
-      });
-    }
-  );
-}
-async function completeTurnRecord(args) {
-  return await withTurnCursorMutation(
-    args.conversationId,
-    args.turnId,
-    async (fence) => {
-      const existing = await getTurnRecord(args.conversationId, args.turnId);
-      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
-        return void 0;
-      }
-      return await updateTurnState({
-        existing,
-        fence,
-        resultMessageId: args.resultMessageId,
-        state: "completed"
-      });
-    }
-  );
-}
-async function failTurnRecord(args) {
-  return await withTurnCursorMutation(
-    args.conversationId,
-    args.turnId,
-    async (fence) => {
-      const existing = await getTurnRecord(args.conversationId, args.turnId);
-      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
-        return void 0;
-      }
-      return await updateTurnState({
-        existing,
-        fence,
-        state: "failed",
-        errorMessage: args.errorMessage ?? existing.errorMessage
-      });
-    }
-  );
-}
-
-// src/chat/services/turn-limit.ts
-var TurnSliceLimitExceededError = class extends Error {
-  constructor(maxSlices) {
-    super(`Agent turn exceeded execution limit (${maxSlices} slices)`);
-    this.name = "TurnSliceLimitExceededError";
-  }
-};
-var TurnToolCallLimitExceededError = class extends Error {
-  constructor(maxToolCalls) {
-    super(`Agent turn exceeded execution limit (${maxToolCalls} tool calls)`);
-    this.name = "TurnToolCallLimitExceededError";
-  }
-};
-function isDirectTurnExecutionLimitError(error) {
-  return error instanceof TurnSliceLimitExceededError || error instanceof TurnToolCallLimitExceededError;
-}
-function isTurnExecutionLimitExceededError(error) {
-  if (isDirectTurnExecutionLimitError(error)) {
-    return true;
-  }
-  return error instanceof Error && isDirectTurnExecutionLimitError(error.cause);
-}
-function assertTurnToolCallLimit(toolCallCount, maxToolCalls) {
-  if (toolCallCount <= maxToolCalls) {
-    return;
-  }
-  throw new TurnToolCallLimitExceededError(maxToolCalls);
-}
-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}\`.`;
-}
-function buildTurnErrorResponse(error, eventId) {
-  return isTurnExecutionLimitExceededError(error) ? buildTurnLimitResponse(eventId) : buildTurnFailureResponse(eventId);
-}
-
-// src/chat/task-execution/checkpoint.ts
-function definedProps2(values) {
-  return Object.fromEntries(
-    Object.entries(values).filter(([, value]) => value !== void 0)
-  );
-}
-function addDurationMs(prior, current) {
-  const total = [prior, current].reduce((sum, value) => {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      return sum;
-    }
-    return (sum ?? 0) + Math.max(0, Math.floor(value));
-  }, void 0);
-  return total;
-}
-function continuableMessages(messages, fallback) {
-  const current = trimTrailingAssistantMessages(messages);
-  if (current.length > 0 && isContinuablePiBoundary(current)) {
-    return current;
-  }
-  return trimTrailingAssistantMessages(fallback ?? []);
-}
-async function loadTurnCheckpoint(args) {
-  const record = await getTurnRecordForResume(args.conversationId, args.turnId);
-  if (record?.state === "paused") {
-    return { resumed: true, sliceId: record.sliceId, record };
-  }
-  return { resumed: false, sliceId: 1, record };
-}
-async function saveTurnCheckpoint(args) {
-  if (args.mode === "running") {
-    return await saveRunning(args);
-  }
-  if (args.mode === "paused") {
-    return await savePaused(args);
-  }
-  await saveDone(args);
-  return void 0;
-}
-function sharedWrite(args, latest) {
-  return {
-    conversationId: args.conversationId,
-    turnId: args.turnId,
-    ...definedProps2({
-      actor: args.actor,
-      channelName: args.channelName ?? latest?.channelName,
-      destination: args.destination,
-      destinationVisibility: args.destinationVisibility,
-      dispatchId: args.dispatchId ?? latest?.dispatchId,
-      source: args.source,
-      surface: args.surface ?? latest?.surface,
-      traceId: getActiveTraceId() ?? latest?.traceId,
-      turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex,
-      cumulativeToolCallCount: args.cumulativeToolCallCount ?? latest?.cumulativeToolCallCount
-    })
-  };
-}
-async function saveRunning(args) {
-  if (args.messages.length === 0 || !isContinuablePiBoundary(args.messages)) {
-    return void 0;
-  }
-  try {
-    const latest = await getTurnRecord(args.conversationId, args.turnId);
-    return await upsertTurnRecord({
-      ...sharedWrite(args, latest),
-      ...definedProps2({
-        trailingMessageProvenance: args.trailingMessageProvenance,
-        turnContexts: args.turnContexts
-      }),
-      cumulativeDurationMs: latest?.cumulativeDurationMs,
-      cumulativeUsage: latest?.cumulativeUsage,
-      piMessages: args.messages,
-      sliceId: args.sliceId,
-      state: "running"
-    });
-  } catch (error) {
-    if (!(error instanceof AgentHistoryBranchError)) {
-      logException(error, "agent.turn.checkpoint.running.failed", {
-        "app.ai.resume_conversation_id": args.conversationId,
-        "app.ai.resume_session_id": args.turnId,
-        "app.ai.resume_slice_id": args.sliceId
-      });
-    }
-    return void 0;
-  }
-}
-async function savePaused(args) {
-  const keepSlice = args.reason === "yield";
-  const nextSliceId = keepSlice ? args.sliceId : args.sliceId + 1;
-  try {
-    const latest = await getTurnRecord(args.conversationId, args.turnId);
-    const messages = args.reason === "yield" ? [...args.messages] : continuableMessages(args.messages, latest?.piMessages);
-    if (args.reason === "auth") {
-      if (messages.length > 0 && !isContinuablePiBoundary(messages)) {
-        return void 0;
-      }
-    } else if (messages.length === 0 || !isContinuablePiBoundary(messages)) {
-      return void 0;
-    }
-    const base = {
-      ...sharedWrite(args, latest),
-      ...definedProps2({
-        cumulativeDurationMs: addDurationMs(
-          latest?.cumulativeDurationMs,
-          args.durationMs
-        ),
-        cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
-        errorMessage: args.errorMessage
-      }),
-      piMessages: messages,
-      resumeReason: args.reason
-    };
-    if (!keepSlice && nextSliceId > botConfig.maxSlicesPerTurn) {
-      const error = new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
-      await upsertTurnRecord({
-        ...base,
-        ...definedProps2({ resumedFromSliceId: latest?.resumedFromSliceId }),
-        errorMessage: error.message,
-        sliceId: args.sliceId,
-        state: "failed"
-      });
-      throw error;
-    }
-    return await upsertTurnRecord({
-      ...base,
-      ...definedProps2({
-        resumedFromSliceId: keepSlice ? latest?.resumedFromSliceId : args.sliceId
-      }),
-      sliceId: nextSliceId,
-      // Stored name is historical; means "paused, may continue".
-      state: "paused"
-    });
-  } catch (error) {
-    if (error instanceof TurnSliceLimitExceededError) {
-      throw error;
-    }
-    logException(error, "agent.turn.checkpoint.paused.failed", {
-      "app.ai.resume_conversation_id": args.conversationId,
-      "app.ai.resume_session_id": args.turnId,
-      "app.ai.resume_from_slice_id": args.sliceId,
-      "app.ai.resume_next_slice_id": nextSliceId,
-      "app.ai.resume_reason": args.reason
-    });
-    return void 0;
-  }
-}
-async function saveDone(args) {
-  let latest;
-  await persistWithRetry(async () => {
-    latest = await getTurnRecord(args.conversationId, args.turnId);
-  });
-  const sliceId = args.sliceId ?? latest?.sliceId;
-  if (sliceId === void 0) {
-    throw new Error(
-      "Completed turn checkpoint requires a slice id from the caller or the latest stored record"
-    );
-  }
-  await persistWithRetry(async () => {
-    await upsertTurnRecord({
-      ...sharedWrite(args, latest),
-      ...definedProps2({
-        cumulativeDurationMs: addDurationMs(
-          latest?.cumulativeDurationMs,
-          args.durationMs
-        ),
-        cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
-        dispatchOutcome: args.dispatchOutcome ?? latest?.dispatchOutcome,
-        errorMessage: args.errorMessage,
-        resultMessageId: args.resultMessageId ?? latest?.resultMessageId
-      }),
-      piMessages: args.messages,
-      sliceId,
-      state: args.mode
-    });
-  });
-}
-
-export {
-  TURN_CONTEXT_TAG,
-  isAssistantMessage,
-  isToolResultMessage,
-  isToolResultError,
-  normalizeToolNameFromResult,
-  getPiMessageRole,
-  isContinuablePiBoundary,
-  extractAssistantText,
-  getTerminalAssistantMessages,
-  trimTrailingAssistantMessages,
-  hasRuntimeTurnContext,
-  retainRuntimeTurnContext,
-  instructionTextForProjection,
-  getUserMessageInstructionText,
-  stripRuntimeTurnContext,
-  historyItemFromPiMessage,
-  piMessageFromHistoryItem,
-  estimateTextTokens,
-  getAgentContextCompactionTriggerTokens,
-  getAgentContextInputLimitTokens,
-  normalizeConversationText,
-  estimateConversationContextTokens,
-  upsertConversationMessage,
-  recordDeliveredAssistantMessage,
-  turnHasReply,
-  markConversationMessage,
-  buildConversationContext,
-  appendThreadContextMessages,
-  createConversationMemoryService,
-  isHumanConversationMessage,
-  getConversationMessageSlackTs,
-  resolveConversationTitle,
-  persistConversationMessageSummaries,
-  projectConversationMessages,
-  hydrateConversationMessages,
-  persistConversationMessages,
-  appendConversationMessages,
-  loadProjection,
-  loadConversationProjection,
-  openConversationProjection,
-  loadConnectedMcpProviders,
-  commitMessages,
-  commitAcceptedReply,
-  recordMcpProviderConnected,
-  recordAuthorizationRequested,
-  recordAuthorizationCompleted,
-  recordAuthenticationLinked,
-  recordAgentsInstructionsUpdated,
-  recordSubscribedReplyRoute,
-  loadTurnRoute,
-  recordTurnRoute,
-  recordToolExecutionStarted,
-  recordAttachmentsDelivered,
-  recordGuardianActionReviewed,
-  MAX_TEXT_CHARS,
-  RIPGREP_EXCLUDED_GLOBS,
-  DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
-  positiveInteger2 as positiveInteger,
-  normalizeToLf,
-  truncateText,
-  isMissingPathError,
-  missingPathSearchResult,
-  resolveWorkspacePath,
-  getRipgrepSearchLocation,
-  collectFiles,
-  AGENTS_REPLACEMENT_NOTICE,
-  AGENTS_REMOVAL_NOTICE,
-  listRepositoryDirectories,
-  resolveRepositoryInstructionsForDirectories,
-  renderAgentsInstructions,
-  buildAgentsInstructionsMessage,
-  findVisibleAgentsInstructions,
-  TurnSliceLimitExceededError,
-  isTurnExecutionLimitExceededError,
-  assertTurnToolCallLimit,
-  buildTurnErrorResponse,
-  persistWithRetry,
-  getTurnRecord,
-  getTurnRecordForResume,
-  recordTurnSummary,
-  listTurnSummaries,
-  abandonTurnRecord,
-  completeTurnRecord,
-  failTurnRecord,
-  continuableMessages,
-  loadTurnCheckpoint,
-  saveTurnCheckpoint
-};