@sentry/junior 0.94.0 → 0.96.0

package/dist/chunk-5C6XTTFI.js

@@ -0,0 +1,1037 @@
+import {
+  agentStepEntrySchema,
+  contextProvenance,
+  createSqlAgentStepStore,
+  getAgentStepStore,
+  getConversationMessageStore,
+  getSqlExecutor,
+  juniorAgentSteps,
+  juniorConversationMessages,
+  juniorConversations,
+  legacyActorProvenance,
+  readSessionLogEntries
+} from "./chunk-RITD7E5L.js";
+import {
+  botConfig,
+  escapeXml,
+  getStateAdapter,
+  resolveGatewayModel
+} from "./chunk-YDVEH3SB.js";
+import {
+  logWarn,
+  setSpanAttributes
+} from "./chunk-I35CTGPO.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 } 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-VZ2MEGP7.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/state/ttl.ts
+var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// src/chat/tools/advisor/session-store.ts
+var ADVISOR_SESSION_TTL_MS = JUNIOR_THREAD_STATE_TTL_MS;
+function cloneMessages(messages) {
+  return structuredClone(messages);
+}
+function getAdvisorSessionKey(conversationId) {
+  return `junior:${conversationId}:advisor_session`;
+}
+function createStateAdvisorSessionStore() {
+  return {
+    load: async (conversationId) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      const messages = await stateAdapter.get(
+        getAdvisorSessionKey(conversationId)
+      ) ?? [];
+      return cloneMessages(messages);
+    },
+    save: async (conversationId, messages) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      await stateAdapter.set(
+        getAdvisorSessionKey(conversationId),
+        cloneMessages(messages),
+        ADVISOR_SESSION_TTL_MS
+      );
+    }
+  };
+}
+
+// src/chat/conversations/sql/legacy-history-import.ts
+import { eq, sql } from "drizzle-orm";
+var INITIAL_SESSION_ID = "session_0";
+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 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((message, seq) => ({
+    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,
+    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 = z.object({
+  id: z.string(),
+  role: z.enum(["user", "assistant", "system"]),
+  text: z.string(),
+  createdAtMs: z.number().finite(),
+  author: z.object({}).passthrough().optional(),
+  meta: z.object({}).passthrough().optional()
+});
+var legacyCompactionSchema = z.object({
+  coveredMessageIds: z.array(z.string()),
+  createdAtMs: z.number().finite(),
+  id: z.string(),
+  summary: z.string()
+});
+var legacyThreadStateSnapshotSchema = z.object({
+  conversation: z.object({
+    compactions: z.array(legacyCompactionSchema).optional(),
+    messages: z.array(legacyVisibleMessageSchema).optional(),
+    stats: z.object({ updatedAtMs: z.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 ?? createStateAdvisorSessionStore()).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(
+        ([key, value]) => isDeepStrictEqual2(existingMessage.meta?.[key], 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,
+  JUNIOR_THREAD_STATE_TTL_MS,
+  importConversationFromLegacy,
+  ensureLegacyConversationImport
+};