@sentry/junior 0.105.0 → 0.107.0

package/dist/chunk-RYDF4GOX.js

@@ -1,1072 +0,0 @@
-import {
-  agentStepEntrySchema,
-  contextProvenance,
-  createSqlAgentStepStore,
-  getAgentStepStore,
-  getConversationMessageStore,
-  getSqlExecutor,
-  juniorAgentSteps,
-  juniorConversationMessages,
-  juniorConversations,
-  legacyActorProvenance,
-  piMessageSchema,
-  readSessionLogEntries,
-  sanitizePostgresJson
-} from "./chunk-BCULHGZK.js";
-import {
-  botConfig,
-  escapeXml,
-  getStateAdapter,
-  resolveGatewayModel,
-  unescapeXml
-} from "./chunk-M3UAVLEN.js";
-import {
-  logWarn,
-  setSpanAttributes
-} from "./chunk-AEWZ7F65.js";
-import {
-  parseSlackMessageTs
-} from "./chunk-7FBGKXPE.js";
-
-// src/chat/conversations/legacy-import.ts
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-import { eq as eq2 } from "drizzle-orm";
-import { z as z2 } from "zod";
-
-// src/chat/conversations/visible-compactions.ts
-import { isDeepStrictEqual } from "util";
-function latestSnapshot(steps) {
-  for (let index = steps.length - 1; index >= 0; index -= 1) {
-    const entry = steps[index]?.entry;
-    if (entry?.type === "visible_context_compacted") {
-      return entry.compactions;
-    }
-  }
-  return [];
-}
-async function hydrateConversationCompactions(args) {
-  const steps = await getAgentStepStore().loadHistory(args.conversationId);
-  args.conversation.compactions = latestSnapshot(steps);
-}
-async function persistConversationCompactions(args) {
-  const stepStore = getAgentStepStore();
-  const existing = latestSnapshot(
-    await stepStore.loadHistory(args.conversationId)
-  );
-  if (isDeepStrictEqual(existing, args.conversation.compactions)) {
-    return;
-  }
-  await stepStore.append(args.conversationId, [
-    {
-      entry: {
-        type: "visible_context_compacted",
-        compactions: args.conversation.compactions
-      },
-      createdAtMs: args.conversation.compactions.at(-1)?.createdAtMs ?? Date.now()
-    }
-  ]);
-}
-
-// src/chat/services/context-budget.ts
-var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
-var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
-var COMPACTION_TARGET_RATIO = 0.8;
-var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
-var FALLBACK_MAX_OUTPUT_TOKENS = 128e3;
-function positiveInteger(value, fallback) {
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-function estimateTextTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function calculateContextCompactionTriggerTokens(model) {
-  const contextWindow = positiveInteger(
-    model.contextWindow,
-    FALLBACK_CONTEXT_WINDOW_TOKENS
-  );
-  const maxTokens = positiveInteger(
-    model.maxTokens,
-    FALLBACK_MAX_OUTPUT_TOKENS
-  );
-  const outputReserve = Math.min(
-    maxTokens,
-    Math.floor(contextWindow * COMPACTION_OUTPUT_RESERVE_RATIO)
-  );
-  const usableInputTokens = Math.max(1, contextWindow - outputReserve);
-  return Math.max(
-    1,
-    Math.floor(usableInputTokens * COMPACTION_TRIGGER_INPUT_RATIO)
-  );
-}
-function calculateContextCompactionTargetTokens(triggerTokens) {
-  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
-}
-function getAgentContextCompactionTriggerTokens() {
-  const model = resolveGatewayModel(botConfig.modelId);
-  return calculateContextCompactionTriggerTokens({
-    contextWindow: botConfig.modelContextWindowTokens ?? model.contextWindow,
-    maxTokens: model.maxTokens
-  });
-}
-function getConversationContextCompactionTriggerTokens() {
-  const model = resolveGatewayModel(botConfig.fastModelId);
-  return calculateContextCompactionTriggerTokens({
-    contextWindow: model.contextWindow,
-    maxTokens: model.maxTokens
-  });
-}
-
-// src/chat/services/conversation-memory.ts
-var CONTEXT_MIN_LIVE_MESSAGES = 12;
-var CONTEXT_COMPACTION_BATCH_SIZE = 24;
-var CONTEXT_MAX_COMPACTIONS = 16;
-var CONTEXT_MAX_MESSAGE_CHARS = 3200;
-var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
-function generateConversationId(prefix) {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function normalizeConversationText(text) {
-  return text.trim().replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
-}
-function buildImageContextSuffix(message, conversation) {
-  const byFileId = conversation?.vision.byFileId;
-  const imageFileIds = message.meta?.imageFileIds ?? [];
-  if (!byFileId || imageFileIds.length === 0) {
-    return "";
-  }
-  const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
-  if (summaries.length === 0) {
-    return "";
-  }
-  return ` [image context: ${summaries.join(" | ")}]`;
-}
-function renderConversationMessageLine(message, conversation) {
-  const displayName = conversationAuthorDisplayName(message);
-  const markers = [];
-  if (message.meta?.replied === false) {
-    markers.push(
-      `assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`
-    );
-  }
-  if (message.meta?.explicitMention) {
-    markers.push("explicit mention");
-  }
-  const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
-  const imageContext = buildImageContextSuffix(message, conversation);
-  return `[${message.role}] ${displayName}: ${message.text}${imageContext}${markerSuffix}`;
-}
-function conversationAuthorDisplayName(message) {
-  const author = message.author;
-  const fullName = authorDisplayField(author?.fullName, author?.userId);
-  const userName = authorDisplayField(author?.userName, author?.userId);
-  return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
-}
-function authorDisplayField(value, userId) {
-  if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) {
-    return void 0;
-  }
-  return value;
-}
-function updateConversationStats(conversation) {
-  const contextText = buildConversationContext(conversation);
-  conversation.stats.estimatedContextTokens = estimateTextTokens(
-    contextText ?? ""
-  );
-  conversation.stats.totalMessageCount = conversation.messages.length;
-  conversation.stats.updatedAtMs = Date.now();
-}
-function upsertConversationMessage(conversation, message) {
-  const existingIndex = conversation.messages.findIndex(
-    (entry) => entry.id === message.id
-  );
-  if (existingIndex >= 0) {
-    conversation.messages[existingIndex] = {
-      ...conversation.messages[existingIndex],
-      ...message,
-      meta: {
-        ...conversation.messages[existingIndex]?.meta,
-        ...message.meta
-      }
-    };
-    updateConversationStats(conversation);
-    return message.id;
-  }
-  conversation.messages.push(message);
-  updateConversationStats(conversation);
-  return message.id;
-}
-function markConversationMessage(conversation, messageId, patch) {
-  if (!messageId) return;
-  const messageIndex = conversation.messages.findIndex(
-    (entry) => entry.id === messageId
-  );
-  if (messageIndex < 0) return;
-  const current = conversation.messages[messageIndex];
-  conversation.messages[messageIndex] = {
-    ...current,
-    meta: {
-      ...current.meta ?? {},
-      ...patch
-    }
-  };
-  updateConversationStats(conversation);
-}
-function buildConversationContext(conversation, options = {}) {
-  const messages = conversation.messages.filter(
-    (entry) => entry.id !== options.excludeMessageId
-  );
-  if (messages.length === 0 && conversation.compactions.length === 0) {
-    return void 0;
-  }
-  const lines = [];
-  if (conversation.compactions.length > 0) {
-    lines.push("<thread-compactions>");
-    for (const [index, compaction] of conversation.compactions.entries()) {
-      lines.push(
-        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageIds.length}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
-        compaction.summary,
-        "  </compaction>"
-      );
-    }
-    lines.push("</thread-compactions>");
-  }
-  if (messages.length > 0) {
-    if (lines.length > 0) {
-      lines.push("");
-    }
-    lines.push("<thread-transcript>");
-    for (const [index, message] of messages.entries()) {
-      const author = escapeXml(conversationAuthorDisplayName(message));
-      const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
-      const ts = new Date(message.createdAtMs).toISOString();
-      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
-      lines.push(
-        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`,
-        renderConversationMessageLine(message, conversation),
-        "  </message>"
-      );
-    }
-    lines.push("</thread-transcript>");
-  }
-  return lines.join("\n");
-}
-function pruneCompactions(compactions) {
-  if (compactions.length <= CONTEXT_MAX_COMPACTIONS) {
-    return compactions;
-  }
-  const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
-  const merged = compactions.slice(0, overflowCount);
-  const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
-  const mergedIds = merged.flatMap((entry) => entry.coveredMessageIds).slice(0, 500);
-  const compacted = {
-    id: generateConversationId("compaction"),
-    createdAtMs: Date.now(),
-    summary: mergedSummary,
-    coveredMessageIds: mergedIds
-  };
-  return [compacted, ...compactions.slice(overflowCount)];
-}
-async function summarizeConversationChunk(messages, conversation, context, deps) {
-  const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
-  try {
-    const result = await deps.completeText({
-      modelId: botConfig.fastModelId,
-      temperature: 0,
-      messages: [
-        {
-          role: "user",
-          content: [
-            "Summarize the following older Slack thread transcript segment for future assistant turns.",
-            "Keep the summary factual and concise. Do not invent details.",
-            "",
-            "Output exactly three XML sections in this order:",
-            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
-            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
-            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
-            "",
-            "Do not output any text outside the three sections.",
-            "",
-            transcript
-          ].join("\n"),
-          timestamp: Date.now()
-        }
-      ],
-      metadata: {
-        modelId: botConfig.fastModelId,
-        threadId: context.threadId ?? "",
-        channelId: context.channelId ?? "",
-        actorId: context.actorId ?? "",
-        runId: context.runId ?? ""
-      }
-    });
-    const summary = result.text.trim();
-    if (summary.length > 0) {
-      return summary.slice(0, 3500);
-    }
-  } catch (error) {
-    logWarn(
-      "conversation_compaction_summary_failed",
-      {
-        slackThreadId: context.threadId,
-        slackUserId: context.actorId,
-        slackChannelId: context.channelId,
-        runId: context.runId,
-        assistantUserName: botConfig.userName,
-        modelId: botConfig.fastModelId
-      },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error),
-        "app.compaction_messages_covered": messages.length
-      },
-      "Compaction summarization failed; using fallback summary"
-    );
-  }
-  return transcript.slice(0, 2800);
-}
-async function generateThreadTitleWithDeps(sourceText, deps) {
-  const result = await deps.completeText({
-    modelId: botConfig.fastModelId,
-    temperature: 0,
-    messages: [
-      {
-        role: "user",
-        content: [
-          "Generate a concise 5-8 word Slack conversation title from the first user message below.",
-          "Capture the user's main request.",
-          "Reply with ONLY the title, with no quotes or trailing punctuation.",
-          "",
-          `First user message: ${sourceText.slice(0, 500)}`
-        ].join("\n"),
-        timestamp: Date.now()
-      }
-    ],
-    metadata: {
-      modelId: botConfig.fastModelId
-    }
-  });
-  return result.text.trim().slice(0, 60);
-}
-function getThreadTitleSourceMessage(conversation) {
-  let firstMessage;
-  for (const message of conversation.messages) {
-    if (!isHumanConversationMessage(message)) {
-      continue;
-    }
-    if (!firstMessage) {
-      firstMessage = message;
-      continue;
-    }
-    if (message.createdAtMs < firstMessage.createdAtMs) {
-      firstMessage = message;
-      continue;
-    }
-    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
-      firstMessage = message;
-    }
-  }
-  return firstMessage;
-}
-async function compactConversationIfNeededWithDeps(conversation, context, deps) {
-  updateConversationStats(conversation);
-  let estimatedTokens = conversation.stats.estimatedContextTokens;
-  setSpanAttributes({
-    "app.context_tokens_estimated": estimatedTokens
-  });
-  const triggerTokens = getConversationContextCompactionTriggerTokens();
-  const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
-  while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
-    const compactCount = Math.min(
-      CONTEXT_COMPACTION_BATCH_SIZE,
-      conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES
-    );
-    if (compactCount <= 0) {
-      break;
-    }
-    const compactedChunk = conversation.messages.slice(0, compactCount);
-    const summary = await summarizeConversationChunk(
-      compactedChunk,
-      conversation,
-      context,
-      deps
-    );
-    conversation.compactions.push({
-      id: generateConversationId("compaction"),
-      createdAtMs: Date.now(),
-      summary,
-      coveredMessageIds: compactedChunk.map((entry) => entry.id)
-    });
-    conversation.compactions = pruneCompactions(conversation.compactions);
-    conversation.messages = conversation.messages.slice(compactCount);
-    conversation.stats.compactedMessageCount += compactCount;
-    updateConversationStats(conversation);
-    estimatedTokens = conversation.stats.estimatedContextTokens;
-    setSpanAttributes({
-      "app.compaction_messages_covered": compactCount,
-      "app.compaction.trigger_tokens": triggerTokens,
-      "app.compaction.target_tokens": targetTokens,
-      "app.context_tokens_estimated": estimatedTokens
-    });
-    if (estimatedTokens <= targetTokens) {
-      break;
-    }
-  }
-}
-function createConversationMemoryService(deps) {
-  return {
-    compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps),
-    generateThreadTitle: async (sourceText) => await generateThreadTitleWithDeps(sourceText, deps)
-  };
-}
-function isHumanConversationMessage(message) {
-  return message.role === "user" && message.author?.isBot !== true;
-}
-function getConversationMessageSlackTs(message) {
-  return parseSlackMessageTs(message.meta?.slackTs);
-}
-
-// src/chat/conversations/visible-messages.ts
-function toStoredConversationMessage(message) {
-  const meta = {};
-  if (message.author) {
-    meta.author = message.author;
-  }
-  const { replied, ...restMeta } = message.meta ?? {};
-  Object.assign(meta, restMeta);
-  if (replied === false) {
-    meta.replied = false;
-  }
-  return {
-    messageId: message.id,
-    role: message.role,
-    text: message.text,
-    ...Object.keys(meta).length > 0 ? { meta } : {},
-    createdAtMs: message.createdAtMs
-  };
-}
-function fromStoredMessage(row) {
-  const rawMeta = { ...row.meta ?? {} };
-  const author = rawMeta.author;
-  delete rawMeta.author;
-  const meta = { ...rawMeta };
-  if (row.repliedAtMs !== void 0) {
-    meta.replied = true;
-  }
-  return {
-    id: row.messageId,
-    role: row.role,
-    text: row.text,
-    createdAtMs: row.createdAtMs,
-    ...author ? { author } : {},
-    ...Object.keys(meta).length > 0 ? { meta } : {}
-  };
-}
-async function hydrateConversationMessages(args) {
-  if (!args.conversationId) {
-    args.conversation.messages = [];
-    return;
-  }
-  const { ensureLegacyConversationImport: ensureLegacyConversationImport2 } = await import("./legacy-import-G333RHJZ.js");
-  await ensureLegacyConversationImport2({ conversationId: args.conversationId });
-  await hydrateConversationCompactions({
-    conversation: args.conversation,
-    conversationId: args.conversationId
-  });
-  const store = getConversationMessageStore();
-  const rows = await store.list(args.conversationId);
-  const coveredIds = new Set(
-    args.conversation.compactions.flatMap(
-      (compaction) => compaction.coveredMessageIds
-    )
-  );
-  args.conversation.messages = rows.filter((row) => !coveredIds.has(row.messageId)).map(fromStoredMessage);
-  updateConversationStats(args.conversation);
-}
-async function persistConversationMessages(args) {
-  if (!args.conversationId || args.conversation.messages.length === 0) {
-    return;
-  }
-  const store = getConversationMessageStore();
-  await store.record(
-    args.conversationId,
-    args.conversation.messages.map(toStoredConversationMessage)
-  );
-  const repliedAtMs = args.repliedAtMs ?? Date.now();
-  for (const message of args.conversation.messages) {
-    if (message.meta?.replied === true) {
-      await store.markReplied(args.conversationId, message.id, repliedAtMs);
-    }
-  }
-}
-
-// src/chat/conversations/legacy-advisor-session.ts
-import { z } from "zod";
-var legacyAdvisorMessagesSchema = z.array(piMessageSchema);
-function key(conversationId) {
-  return `junior:${conversationId}:advisor_session`;
-}
-function createLegacyAdvisorSessionReader() {
-  return {
-    load: async (conversationId) => {
-      const stateAdapter = getStateAdapter();
-      await stateAdapter.connect();
-      return legacyAdvisorMessagesSchema.parse(
-        structuredClone(
-          await stateAdapter.get(key(conversationId)) ?? []
-        )
-      );
-    }
-  };
-}
-
-// src/chat/conversations/sql/legacy-history-import.ts
-import { eq, sql } from "drizzle-orm";
-var INITIAL_SESSION_ID = "session_0";
-var ADVISOR_TASK_OPEN = "<advisor-task>\n";
-var ADVISOR_TASK_CLOSE = "\n</advisor-task>";
-var ADVISOR_CONTEXT_OPEN = "<executor-context>\n";
-var ADVISOR_CONTEXT_CLOSE = "\n</executor-context>";
-function importedAdvisorChildConversationId(parentConversationId) {
-  return `advisor:${parentConversationId}`;
-}
-function epochFromSessionId(sessionId) {
-  const match = /^session_(\d+)$/.exec(sessionId);
-  return match ? Number(match[1]) : 0;
-}
-function messageTimestampMs(message) {
-  const timestamp = message.timestamp;
-  return typeof timestamp === "number" ? timestamp : void 0;
-}
-function readAdvisorRequest(text) {
-  if (!text.startsWith(ADVISOR_TASK_OPEN) || !text.endsWith(ADVISOR_CONTEXT_CLOSE)) {
-    return void 0;
-  }
-  const taskEnd = text.indexOf(ADVISOR_TASK_CLOSE, ADVISOR_TASK_OPEN.length);
-  if (taskEnd < 0) {
-    return void 0;
-  }
-  const contextStart = taskEnd + ADVISOR_TASK_CLOSE.length + 2;
-  if (!text.startsWith(ADVISOR_CONTEXT_OPEN, contextStart)) {
-    return void 0;
-  }
-  const task = text.slice(ADVISOR_TASK_OPEN.length, taskEnd);
-  const context = text.slice(
-    contextStart + ADVISOR_CONTEXT_OPEN.length,
-    -ADVISOR_CONTEXT_CLOSE.length
-  );
-  return `${unescapeXml(task)}
-
-Executor context:
-${unescapeXml(context)}`;
-}
-function normalizeAdvisorMessage(message) {
-  const record = message;
-  if (record.role !== "user" || !Array.isArray(record.content)) {
-    return message;
-  }
-  let changed = false;
-  const content = record.content.map((part) => {
-    if (!part || typeof part !== "object" || part.type !== "text" || typeof part.text !== "string") {
-      return part;
-    }
-    const text = readAdvisorRequest(part.text);
-    if (text === void 0) {
-      return part;
-    }
-    changed = true;
-    return { ...part, text };
-  });
-  return changed ? { ...record, content } : message;
-}
-function piEntryProvenance(entry) {
-  if (entry.provenance) {
-    return entry.provenance;
-  }
-  if (entry.actor) {
-    return legacyActorProvenance(entry.actor);
-  }
-  return contextProvenance;
-}
-function convertLegacySessionLog(args) {
-  const steps = [];
-  const fallback = args.fallbackCreatedAtMs;
-  let advisorChildConversationId;
-  let seq = 0;
-  const push = (contextEpoch, entry, createdAtMs) => {
-    steps.push({ seq, contextEpoch, entry, createdAtMs });
-    seq += 1;
-  };
-  for (const entry of args.entries) {
-    const epoch = epochFromSessionId(entry.sessionId ?? INITIAL_SESSION_ID);
-    switch (entry.type) {
-      case "pi_message": {
-        push(
-          epoch,
-          {
-            type: "pi_message",
-            message: entry.message,
-            provenance: piEntryProvenance(entry)
-          },
-          messageTimestampMs(entry.message) ?? fallback
-        );
-        break;
-      }
-      case "projection_reset": {
-        const provenance = entry.provenance ?? entry.messages.map(() => contextProvenance);
-        if (provenance.length !== entry.messages.length) {
-          throw new Error(
-            "projection_reset provenance must align one-to-one with messages"
-          );
-        }
-        push(
-          epoch,
-          { type: "context_epoch_started", reason: "compaction" },
-          fallback
-        );
-        entry.messages.forEach((message, index) => {
-          push(
-            epoch,
-            {
-              type: "pi_message",
-              message,
-              provenance: provenance[index]
-            },
-            messageTimestampMs(message) ?? fallback
-          );
-        });
-        break;
-      }
-      case "mcp_provider_connected": {
-        push(
-          epoch,
-          { type: "mcp_provider_connected", provider: entry.provider },
-          fallback
-        );
-        break;
-      }
-      case "authorization_requested": {
-        push(
-          epoch,
-          {
-            type: "authorization_requested",
-            kind: entry.kind,
-            provider: entry.provider,
-            actorId: entry.actorId,
-            authorizationId: entry.authorizationId,
-            delivery: entry.delivery
-          },
-          entry.createdAtMs
-        );
-        break;
-      }
-      case "authorization_completed": {
-        push(
-          epoch,
-          {
-            type: "authorization_completed",
-            kind: entry.kind,
-            provider: entry.provider,
-            actorId: entry.actorId,
-            authorizationId: entry.authorizationId
-          },
-          entry.createdAtMs
-        );
-        break;
-      }
-      case "tool_execution_started": {
-        push(
-          epoch,
-          {
-            type: "tool_execution_started",
-            toolCallId: entry.toolCallId,
-            toolName: entry.toolName,
-            ...entry.args !== void 0 ? { args: entry.args } : {}
-          },
-          entry.createdAtMs
-        );
-        break;
-      }
-      case "subagent_started": {
-        const childConversationId = importedAdvisorChildConversationId(
-          args.conversationId
-        );
-        advisorChildConversationId = childConversationId;
-        push(
-          epoch,
-          {
-            type: "subagent_started",
-            subagentInvocationId: entry.subagentInvocationId,
-            subagentKind: entry.subagentKind,
-            ...entry.parentToolCallId ? { parentToolCallId: entry.parentToolCallId } : {},
-            childConversationId,
-            historyMode: "shared"
-          },
-          entry.createdAtMs
-        );
-        break;
-      }
-      case "subagent_ended": {
-        push(
-          epoch,
-          {
-            type: "subagent_ended",
-            subagentInvocationId: entry.subagentInvocationId,
-            outcome: entry.outcome,
-            ...entry.errorCode ? { errorCode: entry.errorCode } : {}
-          },
-          entry.createdAtMs
-        );
-        break;
-      }
-      case "actor_recorded": {
-        break;
-      }
-    }
-  }
-  return {
-    steps,
-    ...advisorChildConversationId ? { advisorChildConversationId } : {}
-  };
-}
-function convertAdvisorMessages(messages, fallbackCreatedAtMs) {
-  return messages.map((sourceMessage, seq) => {
-    const message = normalizeAdvisorMessage(sourceMessage);
-    return {
-      seq,
-      contextEpoch: 0,
-      entry: { type: "pi_message", message, provenance: contextProvenance },
-      createdAtMs: messageTimestampMs(message) ?? fallbackCreatedAtMs
-    };
-  });
-}
-function messageRole(entry) {
-  if (entry.type !== "pi_message") {
-    return null;
-  }
-  const role = entry.message.role;
-  return typeof role === "string" ? role : null;
-}
-function insertRow(conversationId, step) {
-  const { type, ...payload } = agentStepEntrySchema.parse(step.entry);
-  return {
-    conversationId,
-    seq: step.seq,
-    contextEpoch: step.contextEpoch,
-    type,
-    role: messageRole(step.entry),
-    payload: sanitizePostgresJson(payload),
-    createdAt: new Date(step.createdAtMs)
-  };
-}
-async function writeLegacyImport(executor, args) {
-  return executor.withLock(
-    `junior_conversation:legacy-import:${args.conversationId}`,
-    () => executor.transaction(async () => {
-      const db = executor.db();
-      const conversations = await db.select({
-        transcriptPurgedAt: juniorConversations.transcriptPurgedAt
-      }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.conversationId)).for("update");
-      if (conversations[0]?.transcriptPurgedAt) {
-        return false;
-      }
-      const existing = await db.select({ seq: juniorAgentSteps.seq }).from(juniorAgentSteps).where(eq(juniorAgentSteps.conversationId, args.conversationId)).limit(1);
-      if (existing.length > 0) {
-        return false;
-      }
-      const createdAt = new Date(args.fallbackCreatedAtMs);
-      await ensureConversationRow(
-        executor,
-        args.conversationId,
-        createdAt,
-        new Date(args.lastActivityAtMs)
-      );
-      if (args.messages && args.messages.length > 0) {
-        await db.insert(juniorConversationMessages).values(
-          args.messages.map((message) => ({
-            conversationId: args.conversationId,
-            messageId: message.messageId,
-            role: message.role,
-            authorIdentityId: message.authorIdentityId ?? null,
-            text: message.text,
-            meta: message.meta ?? null,
-            repliedAt: message.repliedAtMs === void 0 ? null : new Date(message.repliedAtMs),
-            createdAt: new Date(message.createdAtMs)
-          }))
-        ).onConflictDoUpdate({
-          target: [
-            juniorConversationMessages.conversationId,
-            juniorConversationMessages.messageId
-          ],
-          set: {
-            meta: sql`nullif(coalesce(${juniorConversationMessages.meta}, '{}'::jsonb) || coalesce(excluded.meta, '{}'::jsonb), '{}'::jsonb)`,
-            repliedAt: sql`coalesce(${juniorConversationMessages.repliedAt}, excluded.replied_at)`
-          }
-        });
-      }
-      if (args.steps.length > 0) {
-        await db.insert(juniorAgentSteps).values(
-          args.steps.map((step) => insertRow(args.conversationId, step))
-        );
-      }
-      if (args.child) {
-        const childCreatedAtMs = args.child.steps.length > 0 ? Math.min(...args.child.steps.map((step) => step.createdAtMs)) : args.fallbackCreatedAtMs;
-        const childLastActivityAtMs = args.child.steps.length > 0 ? Math.max(...args.child.steps.map((step) => step.createdAtMs)) : childCreatedAtMs;
-        await ensureChildConversationRow(
-          executor,
-          args.child.conversationId,
-          args.conversationId,
-          new Date(childCreatedAtMs),
-          new Date(childLastActivityAtMs)
-        );
-        if (args.child.steps.length > 0) {
-          await db.insert(juniorAgentSteps).values(
-            args.child.steps.map(
-              (step) => insertRow(args.child.conversationId, step)
-            )
-          );
-        }
-      }
-      return true;
-    })
-  );
-}
-async function ensureConversationRow(executor, conversationId, createdAt, lastActivityAt) {
-  await executor.db().insert(juniorConversations).values({
-    conversationId,
-    schemaVersion: 1,
-    createdAt,
-    lastActivityAt,
-    updatedAt: lastActivityAt,
-    executionStatus: "idle"
-  }).onConflictDoUpdate({
-    target: juniorConversations.conversationId,
-    set: {
-      createdAt: sql`least(${juniorConversations.createdAt}, excluded.created_at)`,
-      lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-      updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`
-    }
-  });
-}
-async function ensureChildConversationRow(executor, childConversationId, parentConversationId, createdAt, lastActivityAt) {
-  await ensureConversationRow(
-    executor,
-    parentConversationId,
-    createdAt,
-    lastActivityAt
-  );
-  await executor.db().insert(juniorConversations).values({
-    conversationId: childConversationId,
-    schemaVersion: 1,
-    parentConversationId,
-    createdAt,
-    lastActivityAt,
-    updatedAt: lastActivityAt,
-    executionStatus: "idle"
-  }).onConflictDoUpdate({
-    target: juniorConversations.conversationId,
-    set: {
-      parentConversationId: sql`coalesce(${juniorConversations.parentConversationId}, excluded.parent_conversation_id)`,
-      createdAt: sql`least(${juniorConversations.createdAt}, excluded.created_at)`,
-      lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-      updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`
-    }
-  });
-}
-
-// src/chat/conversations/legacy-import.ts
-var legacyVisibleMessageSchema = z2.object({
-  id: z2.string(),
-  role: z2.enum(["user", "assistant", "system"]),
-  text: z2.string(),
-  createdAtMs: z2.number().finite(),
-  author: z2.object({}).passthrough().optional(),
-  meta: z2.object({}).passthrough().optional()
-});
-var legacyCompactionSchema = z2.object({
-  coveredMessageIds: z2.array(z2.string()),
-  createdAtMs: z2.number().finite(),
-  id: z2.string(),
-  summary: z2.string()
-});
-var legacyThreadStateSnapshotSchema = z2.object({
-  conversation: z2.object({
-    compactions: z2.array(legacyCompactionSchema).optional(),
-    messages: z2.array(legacyVisibleMessageSchema).optional(),
-    stats: z2.object({ updatedAtMs: z2.number().finite().optional() }).passthrough().optional()
-  }).passthrough().optional()
-});
-async function loadThreadStateSnapshot(conversationId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const raw = await stateAdapter.get(`thread-state:${conversationId}`);
-  if (!raw) {
-    return { compactions: [], messages: [] };
-  }
-  const conversation = legacyThreadStateSnapshotSchema.parse(raw).conversation;
-  return {
-    compactions: conversation?.compactions ?? [],
-    messages: conversation?.messages ?? [],
-    ...conversation?.stats?.updatedAtMs !== void 0 ? { lastActivityAtMs: conversation.stats.updatedAtMs } : {}
-  };
-}
-function intrinsicTimestamps(entries, visible, compactions) {
-  const candidates = [];
-  const pushMessageTs = (message) => {
-    const timestamp = message.timestamp;
-    if (typeof timestamp === "number") {
-      candidates.push(timestamp);
-    }
-  };
-  for (const entry of entries) {
-    if (entry.type === "pi_message") {
-      pushMessageTs(entry.message);
-    } else if (entry.type === "projection_reset") {
-      entry.messages.forEach(pushMessageTs);
-    } else if ("createdAtMs" in entry) {
-      candidates.push(entry.createdAtMs);
-    }
-  }
-  for (const message of visible) {
-    candidates.push(message.createdAtMs);
-  }
-  for (const compaction of compactions) {
-    candidates.push(compaction.createdAtMs);
-  }
-  return candidates;
-}
-async function importConversationFromLegacy(conversationId, deps) {
-  const stepStore = createSqlAgentStepStore(deps.executor);
-  const existing = await stepStore.loadCurrentEpoch(conversationId);
-  if (existing.length > 0) {
-    return { imported: false };
-  }
-  const entries = deps.sessionLogStore ? await deps.sessionLogStore.read({ conversationId }) : await readSessionLogEntries({ conversationId });
-  const snapshot = deps.loadVisibleMessages ? {
-    compactions: deps.legacyCompactions ?? [],
-    messages: await deps.loadVisibleMessages(conversationId)
-  } : await loadThreadStateSnapshot(conversationId);
-  const { compactions, messages: visible } = snapshot;
-  if (entries.length === 0 && visible.length === 0 && compactions.length === 0) {
-    return { imported: false };
-  }
-  const hasAdvisor = entries.some((entry) => entry.type === "subagent_started");
-  const advisorMessages = hasAdvisor ? await (deps.advisorSessionStore ?? createLegacyAdvisorSessionReader()).load(conversationId) : [];
-  const intrinsic = intrinsicTimestamps(entries, visible, compactions);
-  for (const message of advisorMessages) {
-    const timestamp = message.timestamp;
-    if (typeof timestamp === "number") {
-      intrinsic.push(timestamp);
-    }
-  }
-  const fallbackCreatedAtMs = deps.conversationRecord?.createdAtMs ?? (intrinsic.length > 0 ? Math.min(...intrinsic) : void 0) ?? 0;
-  const lastActivityAtMs = Math.max(
-    fallbackCreatedAtMs,
-    deps.conversationRecord?.lastActivityAtMs ?? 0,
-    deps.legacyLastActivityAtMs ?? 0,
-    intrinsic.length > 0 ? Math.max(...intrinsic) : 0
-  );
-  const converted = convertLegacySessionLog({
-    conversationId,
-    entries,
-    fallbackCreatedAtMs
-  });
-  if (compactions.length > 0) {
-    converted.steps.push({
-      seq: converted.steps.length,
-      contextEpoch: converted.steps.at(-1)?.contextEpoch ?? 0,
-      entry: { type: "visible_context_compacted", compactions },
-      createdAtMs: compactions.at(-1)?.createdAtMs ?? fallbackCreatedAtMs
-    });
-  }
-  if (converted.steps.length === 0 && visible.length > 0) {
-    const existingMessages = new Map(
-      (await deps.messageStore.list(conversationId)).map((message) => [
-        message.messageId,
-        message
-      ])
-    );
-    const fullyImported = visible.every((message) => {
-      const existingMessage = existingMessages.get(message.id);
-      const projected = toStoredConversationMessage(message);
-      return existingMessage !== void 0 && Object.entries(projected.meta ?? {}).every(
-        ([key2, value]) => isDeepStrictEqual2(existingMessage.meta?.[key2], value)
-      ) && (message.meta?.replied !== true || existingMessage.repliedAtMs !== void 0);
-    });
-    if (fullyImported) {
-      await writeLegacyImport(deps.executor, {
-        conversationId,
-        fallbackCreatedAtMs,
-        lastActivityAtMs,
-        steps: []
-      });
-      return { imported: false };
-    }
-  }
-  let child;
-  if (converted.advisorChildConversationId) {
-    child = {
-      conversationId: converted.advisorChildConversationId,
-      steps: convertAdvisorMessages(advisorMessages, fallbackCreatedAtMs)
-    };
-  }
-  const messages = visible.map((message) => ({
-    ...toStoredConversationMessage(message),
-    ...message.meta?.replied ? { repliedAtMs: message.createdAtMs } : {}
-  }));
-  const imported = await writeLegacyImport(deps.executor, {
-    conversationId,
-    fallbackCreatedAtMs,
-    lastActivityAtMs,
-    ...messages.length > 0 ? { messages } : {},
-    steps: converted.steps,
-    ...child ? { child } : {}
-  });
-  return { imported };
-}
-async function ensureLegacyConversationImport(args) {
-  const stepStore = getAgentStepStore();
-  if ((await stepStore.loadCurrentEpoch(args.conversationId)).length > 0) {
-    return;
-  }
-  const entries = await readSessionLogEntries({
-    conversationId: args.conversationId
-  });
-  const snapshot = await loadThreadStateSnapshot(args.conversationId);
-  const visible = snapshot.messages;
-  if (entries.length === 0 && visible.length === 0 && snapshot.compactions.length === 0) {
-    return;
-  }
-  const executor = getSqlExecutor();
-  const purged = await executor.db().select({ transcriptPurgedAt: juniorConversations.transcriptPurgedAt }).from(juniorConversations).where(eq2(juniorConversations.conversationId, args.conversationId));
-  if (purged[0]?.transcriptPurgedAt) {
-    return;
-  }
-  await importConversationFromLegacy(args.conversationId, {
-    executor,
-    messageStore: getConversationMessageStore(),
-    sessionLogStore: { read: async () => entries, append: async () => {
-    } },
-    loadVisibleMessages: async () => visible,
-    legacyCompactions: snapshot.compactions,
-    ...snapshot.lastActivityAtMs === void 0 ? {} : { legacyLastActivityAtMs: snapshot.lastActivityAtMs }
-  });
-}
-
-export {
-  persistConversationCompactions,
-  estimateTextTokens,
-  getAgentContextCompactionTriggerTokens,
-  generateConversationId,
-  normalizeConversationText,
-  updateConversationStats,
-  upsertConversationMessage,
-  markConversationMessage,
-  buildConversationContext,
-  getThreadTitleSourceMessage,
-  createConversationMemoryService,
-  isHumanConversationMessage,
-  getConversationMessageSlackTs,
-  hydrateConversationMessages,
-  persistConversationMessages,
-  importConversationFromLegacy,
-  ensureLegacyConversationImport
-};