@sentry/junior 0.93.0 → 0.95.0

package/dist/app.js

@@ -1,23 +1,11 @@
 import {
-  buildConversationContext,
   buildDeliveredTurnStatePatch,
-  createConversationMemoryService,
-  estimateTextTokens,
   finalizeFailedTurnReply,
-  generateConversationId,
-  getAgentContextCompactionTriggerTokens,
   getAgentTurnDiagnosticsAttributes,
-  getConversationMessageSlackTs,
-  getThreadTitleSourceMessage,
-  isHumanConversationMessage,
-  markConversationMessage,
-  normalizeConversationText,
   processPluginTask,
   requireTurnFailureEventId,
-  scheduleSessionCompletedPluginTasks,
-  updateConversationStats,
-  upsertConversationMessage
-} from "./chunk-MAVOJ54A.js";
+  scheduleSessionCompletedPluginTasks
+} from "./chunk-XX4N4E6C.js";
 import {
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -41,12 +29,12 @@ import {
   requestConversationContinuation,
   requestConversationWork,
   startConversationWork
-} from "./chunk-QGEWC27H.js";
+} from "./chunk-5XMNOD3S.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-NYWPISSO.js";
+} from "./chunk-2XXEKR44.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -56,15 +44,13 @@ import {
   GET,
   buildSentryConversationUrl,
   conversationVisibilityFromSlackChannelType,
-  initConversationContext,
   resolveSlackChannelTypeFromMessage,
-  resolveSlackConversationContext,
-  setConversationTitle
-} from "./chunk-LNCREA5Z.js";
+  resolveSlackConversationContext
+} from "./chunk-EKNJM5IG.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-MC4ZZE4Q.js";
+} from "./chunk-AYP4ERVZ.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -77,6 +63,7 @@ import {
   SANDBOX_EGRESS_PROXY_PATH,
   addReactionToMessage,
   appendSlackLegacyAttachmentText,
+  buildSlackOutputMessage,
   buildSteeringPiMessage,
   createAgentRunner,
   createUserTokenStore,
@@ -85,15 +72,18 @@ import {
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials,
   deliverResourceEventSubscription,
+  escapeSlackMrkdwnText,
   executeAgentRun,
   executeCredentialedEgressRequest,
   finalizeMcpAuthorization,
   findMatchingResourceEventSubscriptions,
   formatProviderLabel,
+  formatSlackLink,
   getConfigDefaults,
   getMcpStoredOAuthCredentials,
   listThreadReplies,
   normalizeSandboxEgressTracePropagationDomains,
+  normalizeSlackStatusText,
   parseOAuthStatePayload,
   parseSandboxEgressCredentialToken,
   postSlackMessage,
@@ -105,8 +95,10 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
-  startOAuthFlow
-} from "./chunk-JJUJ4CO2.js";
+  splitSlackReplyText,
+  startOAuthFlow,
+  truncateStatusText
+} from "./chunk-HCXXB35T.js";
 import {
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
@@ -129,37 +121,48 @@ import {
   markTurnFailed,
   mergeArtifactsState,
   persistCompletedSessionRecord,
+  persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById,
+  persistWithRetry,
   persistYieldSessionRecord,
   startActiveTurn
-} from "./chunk-HDNWZMUN.js";
+} from "./chunk-KDPCGVIT.js";
 import {
-  JUNIOR_THREAD_STATE_TTL_MS,
   coerceThreadConversationState
-} from "./chunk-PFXC67GJ.js";
-import "./chunk-6H4PP63X.js";
-import {
-  buildSlackOutputMessage,
-  escapeSlackMrkdwnText,
-  formatSlackLink,
-  normalizeSlackStatusText,
-  splitSlackReplyText,
-  truncateStatusText
-} from "./chunk-LE5ANBUZ.js";
+} from "./chunk-RAIB6WSG.js";
+import "./chunk-WCMQJE4F.js";
+import "./chunk-CM5EZD5F.js";
+import "./chunk-N4RNJ32C.js";
 import {
   abandonAgentTurnSessionRecord,
   commitMessages,
-  contextProvenance,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
-  instructionProvenanceFor,
   listAgentTurnSessionSummariesForConversation,
   loadProjection,
   loadProjectionWithProvenance,
   recordAgentTurnSessionSummary,
   recordAuthorizationCompleted
-} from "./chunk-QL66APYJ.js";
+} from "./chunk-WAGQ377B.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  buildConversationContext,
+  createConversationMemoryService,
+  estimateTextTokens,
+  generateConversationId,
+  getAgentContextCompactionTriggerTokens,
+  getConversationMessageSlackTs,
+  getThreadTitleSourceMessage,
+  hydrateConversationMessages,
+  isHumanConversationMessage,
+  markConversationMessage,
+  normalizeConversationText,
+  persistConversationCompactions,
+  persistConversationMessages,
+  updateConversationStats,
+  upsertConversationMessage
+} from "./chunk-CRRBJ3JP.js";
 import {
   SlackActionError,
   bindSlackDirectCredentialSubject,
@@ -178,22 +181,29 @@ import {
   setPlugins,
   validatePlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-UUB3D2XI.js";
+} from "./chunk-NSCHU54X.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-TNUUATT7.js";
-import "./chunk-G3E7SCME.js";
+} from "./chunk-E3E2XNCN.js";
 import {
-  acquireActiveLock,
-  getStateAdapter
-} from "./chunk-7STN2ZSK.js";
+  sleep
+} from "./chunk-CZEX6KIQ.js";
 import {
+  contextProvenance,
+  getAgentStepStore,
   getConversationStore,
-  getDb
-} from "./chunk-NFXSLTYG.js";
+  getDb,
+  getSqlExecutor,
+  instructionProvenanceFor,
+  juniorAgentSteps,
+  juniorConversationMessages,
+  juniorConversations,
+  juniorDestinations
+} from "./chunk-6ONME5IG.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
+  acquireActiveLock,
   botConfig,
   completeObject,
   completeText,
@@ -205,35 +215,36 @@ import {
   getSlackClientSecret,
   getSlackReactionConfig,
   getSlackSigningSecret,
+  getStateAdapter,
   isProviderRetryError,
   normalizeSlackEmojiName,
   setSlackReactionConfig,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   unwrapCurrentInstruction
-} from "./chunk-NAPITCZ6.js";
+} from "./chunk-GUE7HTNR.js";
 import {
   parseSlackThreadId,
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-YYBX2BD5.js";
+} from "./chunk-GY34VGP5.js";
 import {
   createSlackDestination,
   destinationKey,
   parseDestination,
   requireSlackDestination,
   sameDestination
-} from "./chunk-GHGPTPBL.js";
+} from "./chunk-B7PUBQQM.js";
 import {
   discoverSkills
-} from "./chunk-YTNPU7I2.js";
+} from "./chunk-HDTO3A74.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse,
   pluginCatalogRuntime
-} from "./chunk-BTH37NCU.js";
+} from "./chunk-GVOUCI2O.js";
 import {
   buildTurnFailureResponse,
   createActor,
@@ -253,10 +264,9 @@ import {
   setSpanAttributes,
   setSpanStatus,
   setTags,
-  toStoredSlackActor,
   withContext,
   withSpan
-} from "./chunk-S6QKIGRM.js";
+} from "./chunk-WPOJ443W.js";
 import {
   toOptionalString
 } from "./chunk-OB42YVAE.js";
@@ -270,7 +280,7 @@ import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
   parseSlackChannelId,
   parseSlackMessageTs
-} from "./chunk-LFLTJQVR.js";
+} from "./chunk-7FBGKXPE.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -449,27 +459,6 @@ async function postSlackApiReplyPosts(args) {
   return lastPostedMessageTs;
 }
 
-// src/chat/services/persist-retry.ts
-var PERSIST_ATTEMPTS = 3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-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/agent-dispatch/signing.ts
 import { createHmac, timingSafeEqual } from "crypto";
 var DISPATCH_CALLBACK_PATH = "/api/internal/agent-dispatch";
@@ -970,6 +959,7 @@ async function runAgentDispatchSlice(callback, deps) {
     dispatch = startedDispatch;
     const persisted = await getPersistedThreadState(conversationId);
     const conversation = coerceThreadConversationState(persisted);
+    await hydrateConversationMessages({ conversation, conversationId });
     const deliveredMessage = conversation.messages.find(
       (message) => message.id === getAssistantMessageId(dispatch) && message.meta?.replied === true && typeof message.meta.slackTs === "string"
     );
@@ -993,6 +983,7 @@ async function runAgentDispatchSlice(callback, deps) {
       dispatch,
       nowMs
     });
+    await persistConversationMessages({ conversation, conversationId });
     const conversationContext = buildConversationContext(conversation, {
       excludeMessageId: userMessageId
     });
@@ -1000,7 +991,9 @@ async function runAgentDispatchSlice(callback, deps) {
       input: {
         messageText: dispatch.input,
         conversationContext,
-        piMessages: conversation.piMessages
+        // Pi history for redelivered dispatch slices comes from the SQL
+        // step-store projection, not a thread-state mirror.
+        piMessages: await loadProjection({ conversationId })
       },
       routing: {
         credentialContext: {
@@ -1147,6 +1140,7 @@ async function runAgentDispatchSlice(callback, deps) {
         messages: reply.piMessages,
         durationMs: reply.diagnostics.durationMs,
         usage: reply.diagnostics.usage,
+        reasoningLevel: reply.diagnostics.thinkingLevel,
         destination: dispatch.destination,
         source: dispatch.source,
         actor: dispatch.actor,
@@ -1262,42 +1256,31 @@ function now() {
   return Date.now();
 }
 async function recordExecutionMetadata(args) {
-  try {
-    const conversation = await getConversation({
-      conversationId: args.conversationId,
-      state: args.state
-    });
-    if (!conversation) {
-      return;
-    }
-    await metadataStore(args).recordExecution({
-      channelName: conversation.channelName,
-      conversationId: conversation.conversationId,
-      createdAtMs: conversation.createdAtMs,
-      destination: conversation.destination,
-      execution: {
-        lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
-        lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-        runId: conversation.execution.runId,
-        status: conversation.execution.status,
-        updatedAtMs: conversation.execution.updatedAtMs
-      },
-      lastActivityAtMs: conversation.lastActivityAtMs,
-      actor: conversation.actor,
-      source: conversation.source,
-      title: conversation.title,
-      updatedAtMs: conversation.updatedAtMs
-    });
-  } catch (error) {
-    logWarn(
-      "conversation_execution_metadata_update_failed",
-      { conversationId: args.conversationId },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to update conversation execution metadata"
-    );
+  const conversation = await getConversation({
+    conversationId: args.conversationId,
+    state: args.state
+  });
+  if (!conversation) {
+    return;
   }
+  await metadataStore(args).recordExecution({
+    channelName: conversation.channelName,
+    conversationId: conversation.conversationId,
+    createdAtMs: conversation.createdAtMs,
+    destination: conversation.destination,
+    execution: {
+      lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
+      lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+      runId: conversation.execution.runId,
+      status: conversation.execution.status,
+      updatedAtMs: conversation.execution.updatedAtMs
+    },
+    lastActivityAtMs: conversation.lastActivityAtMs,
+    actor: conversation.actor,
+    source: conversation.source,
+    title: conversation.title,
+    updatedAtMs: conversation.updatedAtMs
+  });
 }
 async function getConversationWorkState2(args) {
   return await getConversationWorkState(args);
@@ -1354,13 +1337,26 @@ async function appendAndEnqueueInboundMessage(args) {
       conversationId: args.message.conversationId,
       state: args.state
     });
-    if (!conversation || hasRecentEnqueueMarker(conversation, nowMs)) {
+    if (!conversation) {
+      return appendResult;
+    }
+    if (hasRecentEnqueueMarker(conversation, nowMs)) {
+      await recordExecutionMetadata({
+        conversationId: args.message.conversationId,
+        conversationStore: args.conversationStore,
+        state: args.state
+      });
       return appendResult;
     }
     const duplicateStillPending = conversation.execution.pendingMessages.some(
       (message) => message.inboundMessageId === args.message.inboundMessageId
     );
     if (!duplicateStillPending) {
+      await recordExecutionMetadata({
+        conversationId: args.message.conversationId,
+        conversationStore: args.conversationStore,
+        state: args.state
+      });
       return appendResult;
     }
     idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
@@ -2184,6 +2180,7 @@ async function ingestResourceEvent(input, options) {
   });
   let enqueued = 0;
   const errors = [];
+  const waitDeadlineMs = Date.now() + 1e4;
   for (const subscription of subscriptions) {
     try {
       const delivered = await deliverResourceEventSubscription({
@@ -2194,6 +2191,7 @@ async function ingestResourceEvent(input, options) {
         nowMs,
         state: options.state,
         subscription,
+        waitDeadlineMs,
         deliver: async (current) => {
           const result = await enqueueResourceEventNotification({
             event,
@@ -3042,8 +3040,210 @@ async function GET2(request, waitUntil, options = {}) {
   return new Response("Accepted", { status: 202 });
 }
 
-// src/handlers/mcp-oauth-callback.ts
-import { THREAD_STATE_TTL_MS } from "chat";
+// src/handlers/retention.ts
+import { timingSafeEqual as timingSafeEqual4 } from "crypto";
+
+// src/chat/conversations/sql/purge.ts
+import { and, asc, eq, inArray, isNull, sql } from "drizzle-orm";
+async function conversationTreeIds(executor, rootConversationId) {
+  const all = /* @__PURE__ */ new Set([rootConversationId]);
+  let frontier = [rootConversationId];
+  while (frontier.length > 0) {
+    const children = await executor.db().select({ id: juniorConversations.conversationId }).from(juniorConversations).where(inArray(juniorConversations.parentConversationId, frontier));
+    frontier = [];
+    for (const child of children) {
+      if (!all.has(child.id)) {
+        all.add(child.id);
+        frontier.push(child.id);
+      }
+    }
+  }
+  return [...all];
+}
+async function selectExpiredRoots(executor, args) {
+  const publicCutoff = new Date(args.nowMs - args.publicWindowMs).toISOString();
+  const privateCutoff = new Date(
+    args.nowMs - args.privateWindowMs
+  ).toISOString();
+  const cutoff = sql`case when ${juniorDestinations.visibility} = 'public' then ${publicCutoff}::timestamptz else ${privateCutoff}::timestamptz end`;
+  const hasTreeWork = sql`exists (
+    with recursive conversation_tree(conversation_id) as (
+      select ${juniorConversations.conversationId}
+      union all
+      select child.conversation_id
+      from junior_conversations child
+      join conversation_tree parent on child.parent_conversation_id = parent.conversation_id
+    )
+    select 1
+    from conversation_tree tree
+    where exists (
+      select 1 from junior_agent_steps steps
+      where steps.conversation_id = tree.conversation_id
+    )
+      or exists (
+        select 1 from junior_conversation_messages messages
+        where messages.conversation_id = tree.conversation_id
+      )
+      or (
+        ${juniorDestinations.visibility} is distinct from 'public'
+        and exists (
+          select 1 from junior_conversations metadata
+          where metadata.conversation_id = tree.conversation_id
+            and (
+              metadata.title is not null
+              or metadata.channel_name is not null
+              or metadata.actor_json is not null
+            )
+        )
+      )
+  )`;
+  const rows = await executor.db().select({
+    conversationId: juniorConversations.conversationId,
+    visibility: juniorDestinations.visibility
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(
+    and(
+      isNull(juniorConversations.parentConversationId),
+      sql`${juniorConversations.lastActivityAt} < ${cutoff}`,
+      hasTreeWork
+    )
+  ).orderBy(
+    asc(juniorConversations.lastActivityAt),
+    asc(juniorConversations.conversationId)
+  ).limit(Math.max(0, args.limit));
+  return rows.map((row) => ({
+    conversationId: row.conversationId,
+    visibility: row.visibility
+  }));
+}
+async function purgeConversationTree(executor, args) {
+  return await executor.transaction(async () => {
+    const roots = await executor.db().select({
+      destinationId: juniorConversations.destinationId,
+      lastActivityAt: juniorConversations.lastActivityAt,
+      parentConversationId: juniorConversations.parentConversationId
+    }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.rootConversationId)).for("update");
+    const root = roots[0];
+    if (!root || args.retention && root.parentConversationId !== null) {
+      return { purged: false, conversations: 0 };
+    }
+    const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, root.destinationId)) : [];
+    const isPublic = destinations[0]?.visibility === "public";
+    if (args.retention) {
+      const windowMs = isPublic ? args.retention.publicWindowMs : args.retention.privateWindowMs;
+      if (root.lastActivityAt.getTime() >= args.nowMs - windowMs) {
+        return { purged: false, conversations: 0 };
+      }
+    }
+    const ids = await conversationTreeIds(executor, args.rootConversationId);
+    await executor.db().delete(juniorAgentSteps).where(inArray(juniorAgentSteps.conversationId, ids));
+    await executor.db().delete(juniorConversationMessages).where(inArray(juniorConversationMessages.conversationId, ids));
+    await executor.db().update(juniorConversations).set({
+      transcriptPurgedAt: new Date(args.nowMs),
+      ...(args.retention ? !isPublic : args.scrubMetadata) ? { title: null, channelName: null, actor: null } : {}
+    }).where(inArray(juniorConversations.conversationId, ids));
+    return { purged: true, conversations: ids.length };
+  });
+}
+
+// src/chat/conversations/retention.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var CONTENT_RETENTION_MS = {
+  public: 90 * DAY_MS,
+  private: 14 * DAY_MS
+};
+var RETENTION_BATCH_LIMIT = 200;
+async function runRetentionPurge(executor, args) {
+  const limit = args.limit ?? RETENTION_BATCH_LIMIT;
+  const startedAtMs = Date.now();
+  const roots = await selectExpiredRoots(executor, {
+    nowMs: args.nowMs,
+    publicWindowMs: CONTENT_RETENTION_MS.public,
+    privateWindowMs: CONTENT_RETENTION_MS.private,
+    limit
+  });
+  let purged = 0;
+  let failed = 0;
+  let conversations = 0;
+  for (const root of roots) {
+    try {
+      const result = await purgeConversationTree(executor, {
+        rootConversationId: root.conversationId,
+        nowMs: args.nowMs,
+        retention: {
+          publicWindowMs: CONTENT_RETENTION_MS.public,
+          privateWindowMs: CONTENT_RETENTION_MS.private
+        }
+      });
+      if (result.purged) {
+        purged += 1;
+        conversations += result.conversations;
+      }
+    } catch (error) {
+      failed += 1;
+      logException(
+        error,
+        "retention_purge_tree_failed",
+        { conversationId: root.conversationId },
+        {},
+        "Retention purge failed for one conversation tree"
+      );
+    }
+  }
+  logInfo(
+    "retention_purge_completed",
+    {},
+    {
+      "app.retention.scanned": roots.length,
+      "app.retention.purged": purged,
+      "app.retention.failed": failed,
+      "app.retention.conversations": conversations,
+      "app.retention.duration_ms": Date.now() - startedAtMs
+    },
+    "Retention purge batch completed"
+  );
+  return { scanned: roots.length, purged, failed, conversations };
+}
+
+// src/handlers/retention.ts
+function getRetentionSecret() {
+  return process.env.JUNIOR_SCHEDULER_SECRET?.trim() || process.env.CRON_SECRET?.trim();
+}
+function verifyRetentionRequest(request) {
+  const secret = getRetentionSecret();
+  if (!secret) {
+    return false;
+  }
+  const authorization = request.headers.get("authorization")?.trim();
+  if (!authorization?.startsWith("Bearer ")) {
+    return false;
+  }
+  const actual = Buffer.from(authorization.slice("Bearer ".length));
+  const expected = Buffer.from(secret);
+  return actual.length === expected.length && timingSafeEqual4(actual, expected);
+}
+async function GET3(request) {
+  if (!verifyRetentionRequest(request)) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  try {
+    const result = await runRetentionPurge(getSqlExecutor(), {
+      nowMs: Date.now()
+    });
+    return Response.json(result, { status: 200 });
+  } catch (error) {
+    logException(
+      error,
+      "retention_run_failed",
+      {},
+      {},
+      "Retention purge run failed"
+    );
+    return new Response("Retention purge failed", { status: 500 });
+  }
+}
 
 // src/chat/runtime/turn-user-message.ts
 function getTurnUserMessage(conversation, sessionId) {
@@ -3916,24 +4116,28 @@ async function resumeSlackTurn(args) {
     }
     const activeReplyContext = runArgs.replyContext;
     if (!activeReplyContext) {
-      throw new Error(
-        "Resumed turn requires replyContext.routing.actor.userId"
-      );
-    }
-    const resumeActor = activeReplyContext.routing.actor;
-    if (!isUserActor(resumeActor)) {
-      throw new Error(
-        "Resumed turn requires replyContext.routing.actor.userId"
-      );
+      throw new Error("Resumed turn requires replyContext");
     }
     const credentialContext = activeReplyContext.routing.credentialContext;
     if (!credentialContext) {
       throw new Error("Resumed turn requires replyContext.credentialContext");
     }
-    if (!("type" in credentialContext.actor) || credentialContext.actor.userId !== resumeActor.userId) {
-      throw new Error(
-        "Resumed turn credential actor must match replyContext.routing.actor.userId"
-      );
+    const routingActor = activeReplyContext.routing.actor;
+    let resumeActor;
+    if ("type" in credentialContext.actor) {
+      if (!isUserActor(routingActor) || credentialContext.actor.userId !== routingActor.userId) {
+        throw new Error(
+          "Resumed turn credential actor must match replyContext.routing.actor.userId"
+        );
+      }
+      resumeActor = routingActor;
+    } else {
+      if (routingActor && (routingActor.platform !== "system" || routingActor.name !== credentialContext.actor.name)) {
+        throw new Error(
+          "Resumed turn system credential actor must match replyContext.routing.actor"
+        );
+      }
+      resumeActor = credentialContext.actor;
     }
     if (runArgs.messageTs) {
       processingReaction = await startSlackProcessingReactionForMessage({
@@ -3975,7 +4179,7 @@ async function resumeSlackTurn(args) {
         deferredPauseKind = "auth";
         deferredAuthInfo = {
           providerDisplayName: outcome.providerDisplayName,
-          actorId: resumeActor.userId
+          actorId: isUserActor(resumeActor) ? resumeActor.userId : void 0
         };
         deferredPauseHandler = async () => {
           await onAuthPause({
@@ -4027,7 +4231,7 @@ async function resumeSlackTurn(args) {
           currentUsage: reply.diagnostics.usage,
           destination: replyContext.routing.destination,
           source: replyContext.routing.source,
-          actor: replyContext.routing.actor,
+          actor: resumeActor,
           surface: "slack",
           logContext: {
             threadId: replyContext.routing.correlation.threadId,
@@ -4180,6 +4384,10 @@ function completeAuthPauseTurn(args) {
 async function persistAuthPauseTurnState(args) {
   const currentState = await getPersistedThreadState(args.threadStateId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.threadStateId
+  });
   completeAuthPauseTurn({
     conversation,
     sessionId: args.sessionId
@@ -4288,6 +4496,7 @@ async function persistCompletedReplyState(channelId, threadTs, sessionId, reply)
   const threadId = `slack:${channelId}:${threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
   const artifacts = coerceThreadArtifactsState(currentState);
   const userMessage2 = getTurnUserMessage(conversation, sessionId);
   const statePatch = buildDeliveredTurnStatePatch({
@@ -4326,6 +4535,7 @@ async function persistFailedReplyState(channelId, threadTs, sessionId, expectedV
   const threadId = `slack:${channelId}:${threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
   clearPendingAuth(conversation, sessionId);
   markTurnFailed({
     conversation,
@@ -4357,6 +4567,7 @@ async function resumeAuthorizedMcpTurn(args) {
   const threadId = `slack:${authSession.channelId}:${authSession.threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
   const pendingAuth = getConversationPendingAuth({
     conversation,
     kind: "mcp",
@@ -4393,6 +4604,10 @@ async function resumeAuthorizedMcpTurn(args) {
     beforeStart: async () => {
       const lockedState = await getPersistedThreadState(threadId);
       const lockedConversation = coerceThreadConversationState(lockedState);
+      await hydrateConversationMessages({
+        conversation: lockedConversation,
+        conversationId: threadId
+      });
       const lockedArtifacts = coerceThreadArtifactsState(lockedState);
       const lockedPendingAuth = getConversationPendingAuth({
         conversation: lockedConversation,
@@ -4476,8 +4691,7 @@ async function resumeAuthorizedMcpTurn(args) {
         authorizationId: mcpAuthorizationId({
           provider,
           sessionId: lockedSessionId
-        }),
-        ttlMs: THREAD_STATE_TTL_MS
+        })
       });
       const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
       return {
@@ -4486,7 +4700,9 @@ async function resumeAuthorizedMcpTurn(args) {
         replyContext: {
           input: {
             conversationContext: lockedConversationContext,
-            piMessages: lockedConversation.piMessages,
+            // Pi history is SQL-authoritative: the resumed run reads its
+            // session record first and falls back to the step projection.
+            piMessages: await loadProjection({ conversationId: threadId }),
             ...getTurnUserReplyAttachmentContext(lockedUserMessage)
           },
           routing: {
@@ -4585,7 +4801,7 @@ async function resumeAuthorizedMcpTurn(args) {
     }
   });
 }
-async function GET3(request, provider, waitUntil, options) {
+async function GET4(request, provider, waitUntil, options) {
   const url = new URL(request.url);
   const state = url.searchParams.get("state")?.trim();
   const code = url.searchParams.get("code")?.trim();
@@ -4632,9 +4848,6 @@ async function GET3(request, provider, waitUntil, options) {
   }
 }
 
-// src/handlers/oauth-callback.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
-
 // src/chat/slack/app-home.ts
 import fs from "fs";
 import path from "path";
@@ -4797,6 +5010,10 @@ function htmlErrorResponse(title, message, status) {
 async function persistCompletedOAuthReplyState(args) {
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.conversationId
+  });
   const artifacts = coerceThreadArtifactsState(currentState);
   const userMessage2 = getTurnUserMessage(conversation, args.sessionId);
   const statePatch = buildDeliveredTurnStatePatch({
@@ -4837,6 +5054,10 @@ async function failSessionRecordBestEffort2(args) {
 async function persistFailedOAuthReplyState(args) {
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.conversationId
+  });
   clearPendingAuth(conversation, args.sessionId);
   markTurnFailed({
     conversation,
@@ -4868,6 +5089,10 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
     stored.resumeConversationId
   );
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: stored.resumeConversationId
+  });
   const pendingAuth = getConversationPendingAuth({
     conversation,
     kind: "plugin",
@@ -4923,6 +5148,10 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         stored.resumeConversationId
       );
       const lockedConversation = coerceThreadConversationState(lockedState);
+      await hydrateConversationMessages({
+        conversation: lockedConversation,
+        conversationId: stored.resumeConversationId
+      });
       const lockedArtifacts = coerceThreadArtifactsState(lockedState);
       const lockedPendingAuth = getConversationPendingAuth({
         conversation: lockedConversation,
@@ -5007,8 +5236,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         authorizationId: pluginAuthorizationId({
           provider: stored.provider,
           sessionId: lockedSessionId
-        }),
-        ttlMs: THREAD_STATE_TTL_MS2
+        })
       });
       const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
       return {
@@ -5017,7 +5245,11 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         replyContext: {
           input: {
             conversationContext: lockedConversationContext,
-            piMessages: lockedConversation.piMessages,
+            // Pi history is SQL-authoritative: the resumed run reads its
+            // session record first and falls back to the step projection.
+            piMessages: await loadProjection({
+              conversationId: stored.resumeConversationId
+            }),
             ...getTurnUserReplyAttachmentContext(lockedUserMessage)
           },
           routing: {
@@ -5120,6 +5352,7 @@ async function resumePendingOAuthMessage(stored, options) {
   const conversation = coerceThreadConversationState(
     await getPersistedThreadState(threadId)
   );
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
   const latestUserMessage = [...conversation.messages].reverse().find((message) => message.role === "user");
   const conversationContext = buildConversationContext(conversation, {
     excludeMessageId: latestUserMessage?.id
@@ -5140,7 +5373,8 @@ async function resumePendingOAuthMessage(stored, options) {
     replyContext: {
       input: {
         conversationContext,
-        piMessages: conversation.piMessages
+        // Pi history is SQL-authoritative via the step-store projection.
+        piMessages: await loadProjection({ conversationId: threadId })
       },
       routing: {
         credentialContext: {
@@ -5174,7 +5408,7 @@ async function resumePendingOAuthMessage(stored, options) {
     }
   });
 }
-async function GET4(request, provider, waitUntil, options) {
+async function GET5(request, provider, waitUntil, options) {
   const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
   if (!providerConfig) {
     return htmlErrorResponse(
@@ -8301,7 +8535,6 @@ function createSlackTurnRuntime(deps) {
 }
 
 // src/chat/services/context-compaction.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
 import {
   estimateContextTokens,
   estimateTokens
@@ -8359,6 +8592,10 @@ function userMessage(text) {
     timestamp: Date.now()
   };
 }
+function piMessageTimestamp(message) {
+  const timestamp = message.timestamp;
+  return typeof timestamp === "number" ? timestamp : Date.now();
+}
 function selectRetainedUserMessageEntries(messages, maxTokens = RETAINED_USER_MESSAGE_TOKENS) {
   const selected = [];
   let remaining = maxTokens;
@@ -8541,6 +8778,7 @@ async function maybeCompactWithDeps(args, deps) {
   });
 }
 async function writeCompactedThreadContext(args, sourceMessages, summary, context) {
+  const stepStore = getAgentStepStore();
   const sourceProjection = await loadProjectionWithProvenance({
     conversationId: args.conversationId
   });
@@ -8552,14 +8790,17 @@ async function writeCompactedThreadContext(args, sourceMessages, summary, contex
     userMessage(`${COMPACTION_SUMMARY_PREFIX}
 ${summary}`)
   ];
-  await commitMessages({
-    conversationId: args.conversationId,
-    messages: replacement,
-    provenance: buildReplacementProvenance({
-      retained,
-      sourceProvenance: sourceProjection.provenance
-    }),
-    ttlMs: THREAD_STATE_TTL_MS3
+  const replacementProvenance = buildReplacementProvenance({
+    retained,
+    sourceProvenance: sourceProjection.provenance
+  });
+  await stepStore.startEpoch(args.conversationId, {
+    reason: "compaction",
+    messages: replacement.map((message, index) => ({
+      message,
+      createdAtMs: piMessageTimestamp(message),
+      provenance: replacementProvenance[index]
+    }))
   });
   updateConversationStats(args.conversation);
   setSpanAttributes({
@@ -9179,7 +9420,6 @@ function createJuniorRuntimeServices(overrides = {}) {
 }
 
 // src/chat/runtime/reply-executor.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
 import { createSlackSource } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/message.ts
@@ -9307,8 +9547,8 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
 }
 
 // src/chat/runtime/reply-executor.ts
-async function persistThreadStateWithRetry(thread, patch) {
-  await persistWithRetry(() => persistThreadState(thread, patch));
+async function persistThreadRuntimeStateWithRetry(thread, patch) {
+  await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
 }
 function collectCanvasUrls(artifacts) {
   return new Set(
@@ -9318,9 +9558,6 @@ function collectCanvasUrls(artifacts) {
     ].filter((url) => typeof url === "string" && url !== "")
   );
 }
-function turnActor(actor) {
-  return toStoredSlackActor(actor);
-}
 function parkedInputKey(message) {
   if (message.role !== "user") {
     return void 0;
@@ -9433,9 +9670,8 @@ function collectTurnAttachments(message, queuedMessages) {
   ];
 }
 async function loadPiMessagesForTurn(args) {
-  const fallback = args.fallback.length > 0 ? [...args.fallback] : void 0;
   if (!args.conversationId) {
-    return { piMessages: fallback };
+    return {};
   }
   if (args.activeTurnId) {
     const sessionRecord = await getAgentTurnSessionRecord(
@@ -9459,7 +9695,7 @@ async function loadPiMessagesForTurn(args) {
       piMessages: projection
     };
   }
-  return { piMessages: fallback };
+  return {};
 }
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options) {
@@ -9536,7 +9772,6 @@ function createReplyToThread(deps) {
           deps.services.lookupSlackUser
         ) : void 0;
         const executionActor = "type" in credentialContext.actor ? actor : credentialContext.actor;
-        const storedActor = actor ? turnActor(actor) : void 0;
         const slackActorId = actor?.userId;
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
@@ -9672,8 +9907,7 @@ function createReplyToThread(deps) {
               provenance: [
                 ...projection.provenance,
                 ...missing.map((pair) => pair.provenance)
-              ],
-              ttlMs: THREAD_STATE_TTL_MS4
+              ]
             });
             return true;
           } finally {
@@ -9836,7 +10070,7 @@ function createReplyToThread(deps) {
             startedAtMs: turnStartedAtMs,
             state: "running",
             surface: "slack",
-            actor,
+            actor: executionActor,
             destination,
             destinationVisibility,
             source,
@@ -9850,37 +10084,6 @@ function createReplyToThread(deps) {
               "Failed to record running turn summary"
             );
           });
-          void initConversationContext(conversationId, {
-            channelName,
-            originSurface: "slack",
-            originActor: storedActor,
-            startedAtMs: turnStartedAtMs
-          }).catch((error) => {
-            logException(
-              error,
-              "conversation_details_context_init_failed",
-              turnTraceContext,
-              { "app.agent.turn.state": "running" },
-              "Failed to init conversation context at turn start"
-            );
-          });
-          const existingAssistantTitle = preparedState.artifacts.assistantTitle?.trim();
-          if (existingAssistantTitle) {
-            void setConversationTitle(conversationId, {
-              displayTitle: existingAssistantTitle,
-              ...preparedState.artifacts.assistantTitleSourceMessageId ? {
-                titleSourceMessageId: preparedState.artifacts.assistantTitleSourceMessageId
-              } : {}
-            }).catch((error) => {
-              logException(
-                error,
-                "conversation_details_title_refresh_failed",
-                turnTraceContext,
-                { "app.agent.turn.state": "running" },
-                "Failed to refresh conversation title from artifacts"
-              );
-            });
-          }
         }
         setTags({
           conversationId
@@ -9963,8 +10166,7 @@ function createReplyToThread(deps) {
         try {
           const loadedPiMessages = await loadPiMessagesForTurn({
             conversationId,
-            activeTurnId,
-            fallback: preparedState.conversation.piMessages
+            activeTurnId
           });
           let piMessages = loadedPiMessages.piMessages;
           if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
@@ -10039,17 +10241,19 @@ function createReplyToThread(deps) {
             };
             if (conversationId && titleUpdateResult.title) {
               try {
-                await setConversationTitle(conversationId, {
-                  displayTitle: titleUpdateResult.title,
-                  titleSourceMessageId: titleUpdateResult.sourceMessageId
+                await getConversationStore().recordActivity({
+                  activityAtMs: message.metadata.dateSent.getTime(),
+                  conversationId,
+                  nowMs: Date.now(),
+                  title: titleUpdateResult.title
                 });
               } catch (error) {
                 logException(
                   error,
-                  "conversation_details_title_set_failed",
+                  "conversation_title_persist_failed",
                   turnTraceContext,
                   {},
-                  "Failed to set conversation title in details record"
+                  "Failed to persist generated conversation title"
                 );
               }
             }
@@ -10365,6 +10569,7 @@ function createReplyToThread(deps) {
                 conversationId,
                 durationMs: reply.diagnostics.durationMs,
                 usage: reply.diagnostics.usage,
+                reasoningLevel: reply.diagnostics.thinkingLevel,
                 destination,
                 destinationVisibility,
                 source,
@@ -10399,11 +10604,15 @@ function createReplyToThread(deps) {
                 traceId: getActiveTraceId()
               });
             }
-            await persistThreadStateWithRetry(thread, {
-              ...completedState
-            });
+            await persistWithRetry(
+              () => persistConversationMessages({
+                conversation: completedState.conversation,
+                conversationId
+              })
+            );
+            await persistThreadRuntimeStateWithRetry(thread, completedState);
             if (completedState.artifacts && (assistantTitleArtifacts.assistantTitle !== void 0 || assistantTitleArtifacts.assistantTitleSourceMessageId !== void 0) && (completedState.artifacts.assistantTitle !== assistantTitleArtifacts.assistantTitle || completedState.artifacts.assistantTitleSourceMessageId !== assistantTitleArtifacts.assistantTitleSourceMessageId)) {
-              await persistThreadStateWithRetry(thread, {
+              await persistThreadRuntimeStateWithRetry(thread, {
                 artifacts: latestArtifacts
               });
             }
@@ -10751,6 +10960,8 @@ function createPrepareTurnState(deps) {
     ) : void 0;
     const artifacts = coerceThreadArtifactsState(existingState);
     const conversation = coerceThreadConversationState(existingState);
+    const conversationId = args.context.threadId ?? args.context.runId;
+    await hydrateConversationMessages({ conversation, conversationId });
     const channelConfiguration = getChannelConfigurationService(args.thread);
     const configuration = await channelConfiguration.resolveValues();
     await seedConversationBackfill(args.thread, conversation, {
@@ -10790,12 +11001,16 @@ function createPrepareTurnState(deps) {
         threadTs: getThreadTs(args.context.threadId)
       });
     }
+    await persistConversationMessages({ conversation, conversationId });
     await deps.compactConversationIfNeeded(conversation, {
       threadId: args.context.threadId,
       channelId: args.context.channelId,
       actorId: args.context.actorId,
       runId: args.context.runId
     });
+    if (conversationId) {
+      await persistConversationCompactions({ conversation, conversationId });
+    }
     const conversationContext = buildConversationContext(conversation, {
       excludeMessageId: userMessageId
     });
@@ -10990,14 +11205,15 @@ function createJuniorSlackAdapter(config) {
 
 // src/chat/runtime/agent-continue-runner.ts
 var AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 async function persistCompletedReplyState2(args) {
   const currentState = await getPersistedThreadState(
     args.sessionRecord.conversationId
   );
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.sessionRecord.conversationId
+  });
   const artifacts = coerceThreadArtifactsState(currentState);
   const userMessage2 = getTurnUserMessage(
     conversation,
@@ -11040,6 +11256,10 @@ async function persistFailedReplyState2(sessionRecord) {
     sessionRecord.conversationId
   );
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: sessionRecord.conversationId
+  });
   clearPendingAuth(conversation, sessionRecord.sessionId);
   markTurnFailed({
     conversation,
@@ -11141,6 +11361,10 @@ async function continueSlackAgentRun(payload, options) {
           payload.conversationId
         );
         const conversation = coerceThreadConversationState(currentState);
+        await hydrateConversationMessages({
+          conversation,
+          conversationId: payload.conversationId
+        });
         const artifacts = coerceThreadArtifactsState(currentState);
         const userMessage2 = getTurnUserMessage(conversation, payload.sessionId);
         if (!userMessage2?.author?.userId) {
@@ -11162,19 +11386,32 @@ async function continueSlackAgentRun(payload, options) {
           payload.destination,
           "Slack continuation"
         );
-        const actor = await resolveContinuationActor({
-          conversationId: payload.conversationId,
-          sessionRecordActor: activeSessionRecord.actor,
-          teamId: destination.teamId,
-          userId: userMessage2.author.userId
-        });
-        if (!actor) {
-          await failStrandedSessionWithFallback({
+        const systemActor = activeSessionRecord.actor?.platform === "system" ? activeSessionRecord.actor : void 0;
+        let actor;
+        let credentialContext;
+        if (systemActor) {
+          credentialContext = { actor: systemActor };
+        } else {
+          actor = await resolveContinuationActor({
             conversationId: payload.conversationId,
-            errorMessage: "Stored Slack actor missing for continuation",
-            sessionRecord: activeSessionRecord
+            sessionRecordActor: activeSessionRecord.actor,
+            teamId: destination.teamId,
+            userId: userMessage2.author.userId
           });
-          return false;
+          if (!actor) {
+            await failStrandedSessionWithFallback({
+              conversationId: payload.conversationId,
+              errorMessage: "Stored Slack actor missing for continuation",
+              sessionRecord: activeSessionRecord
+            });
+            return false;
+          }
+          credentialContext = {
+            actor: {
+              type: "user",
+              userId: actor.userId
+            }
+          };
         }
         if (!activeSessionRecord.source) {
           await failAgentTurnSessionRecord({
@@ -11191,17 +11428,16 @@ async function continueSlackAgentRun(payload, options) {
           replyContext: {
             input: {
               conversationContext,
-              piMessages: conversation.piMessages,
+              // Pi history is SQL-authoritative: the resumed run reads its
+              // session record first and falls back to the step projection.
+              piMessages: await loadProjection({
+                conversationId: payload.conversationId
+              }),
               ...getTurnUserReplyAttachmentContext(userMessage2)
             },
             routing: {
-              credentialContext: {
-                actor: {
-                  type: "user",
-                  userId: actor.userId
-                }
-              },
-              actor,
+              credentialContext,
+              ...actor ? { actor } : {},
               destination: payload.destination,
               source: activeSessionRecord.source,
               correlation: {
@@ -11209,7 +11445,7 @@ async function continueSlackAgentRun(payload, options) {
                 turnId: payload.sessionId,
                 channelId: thread.channelId,
                 threadTs: thread.threadTs,
-                actorId: actor.userId
+                ...actor ? { actorId: actor.userId } : {}
               },
               toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId
             },
@@ -11295,6 +11531,10 @@ async function failStrandedSessionWithFallback(args) {
   });
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.conversationId
+  });
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
@@ -11464,7 +11704,7 @@ async function continueSlackAgentRunWithLockRetry(payload, options) {
         },
         "Agent continuation lock was busy; retrying"
       );
-      await sleep2(delayMs);
+      await sleep(delayMs);
     }
   }
   return true;
@@ -11888,12 +12128,12 @@ async function createApp(options) {
   app.get("/", () => GET());
   app.get("/health", () => GET());
   app.get("/api/oauth/callback/mcp/:provider", (c) => {
-    return GET3(c.req.raw, c.req.param("provider"), waitUntil, {
+    return GET4(c.req.raw, c.req.param("provider"), waitUntil, {
       agentRunner
     });
   });
   app.get("/api/oauth/callback/:provider", (c) => {
-    return GET4(c.req.raw, c.req.param("provider"), waitUntil, {
+    return GET5(c.req.raw, c.req.param("provider"), waitUntil, {
       agentRunner
     });
   });
@@ -11928,6 +12168,9 @@ async function createApp(options) {
   app.get("/api/internal/heartbeat", (c) => {
     return GET2(c.req.raw, waitUntil);
   });
+  app.get("/api/internal/retention", (c) => {
+    return GET3(c.req.raw);
+  });
   app.post("/api/webhooks/slack", (c) => {
     return POST3(c.req.raw, waitUntil, slackWebhookServices);
   });