@sentry/junior 0.106.0 → 0.107.0

package/dist/{chunk-DDRQ4U7I.js → chunk-4YF7Z6IA.js}

@@ -1,78 +1,119 @@
 import {
-  ensureLegacyConversationImport
-} from "./chunk-P4P7O5WG.js";
+  agentTurnUsageSchema
+} from "./chunk-MU6HHZEN.js";
 import {
-  usageSchema
-} from "./chunk-PDO5BLNM.js";
+  getStateAdapter
+} from "./chunk-B2Z2H66D.js";
 import {
   contextProvenance,
-  getAgentStepStore,
+  createSqlConversationEventStore,
+  getConversationEventStore,
   getConversationStore,
+  getSqlExecutor,
   instructionActors,
-  instructionProvenanceFor
-} from "./chunk-XTKJPSMF.js";
+  instructionProvenanceFor,
+  sanitizePostgresJson,
+  withConversationEventLock
+} from "./chunk-NVOTGWYX.js";
 import {
-  getStateAdapter
-} from "./chunk-4UYIRWDW.js";
+  retainRuntimeTurnContext,
+  stripRuntimeTurnContext
+} from "./chunk-SS67LUOK.js";
 import {
-  logWarn,
   toStoredSlackActor
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-VIXFG2VC.js";
+import {
+  logWarn
+} from "./chunk-O24R4DCK.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-OB42YVAE.js";
 
 // src/chat/conversations/projection.ts
 import { isDeepStrictEqual } from "util";
-function authorizationObservationMessage(entry, createdAtMs) {
-  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
-  return {
+
+// src/chat/pi/messages.ts
+import { z } from "zod";
+var piMessageSchema = z.object({
+  role: z.string()
+}).passthrough().transform((value) => value);
+var piContentMessageSchema = z.object({
+  content: z.array(z.unknown()),
+  role: z.string().min(1)
+}).passthrough().transform((value) => value);
+
+// src/chat/pi/conversation-events.ts
+function authorizationObservationMessage(data, createdAtMs) {
+  const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
+  return piMessageSchema.parse({
     role: "user",
     content: [
       {
         type: "text",
-        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
+        text: `${label} completed for provider "${data.provider}". Continue the blocked request and retry the provider operation if needed.`
       }
     ],
     timestamp: createdAtMs
-  };
+  });
 }
-function piEntryProvenance(entry) {
-  return entry.provenance ?? contextProvenance;
+function messageEventProvenance(data) {
+  return data.provenance ?? contextProvenance;
 }
-function projectSteps(steps, opts) {
+function durableMessages(message) {
+  return stripRuntimeTurnContext([piMessageSchema.parse(message)]);
+}
+function projectConversationEvents(events, options) {
   const messages = [];
   const provenance = [];
   const seqs = [];
   let modelProfile = "standard";
   let modelId;
-  for (const step of steps) {
-    if (opts?.maxSeq !== void 0 && step.seq > opts.maxSeq) {
-      break;
+  for (const event of events) {
+    if (options?.maxSeq !== void 0 && event.seq > options.maxSeq) break;
+    if (event.data.type === "unknown") {
+      throw new Error(
+        `Unsupported conversation event "${event.data.originalType}" at seq ${event.seq} (schema version ${event.schemaVersion})`
+      );
     }
-    if (step.entry.type === "context_epoch_started") {
-      modelProfile = step.entry.modelProfile ?? "standard";
-      modelId = step.entry.modelId;
+    if (event.data.type === "compaction" || event.data.type === "handoff" || event.data.type === "rollback") {
+      modelProfile = event.data.modelProfile;
+      modelId = event.data.modelId;
+      for (const replacement of event.data.replacementHistory) {
+        for (const message of durableMessages(replacement.message)) {
+          messages.push(message);
+          provenance.push(replacement.provenance ?? contextProvenance);
+          seqs.push(replacement.sourceEventSeq ?? event.seq);
+        }
+      }
       continue;
     }
-    if (step.entry.type === "pi_message") {
-      messages.push(step.entry.message);
-      provenance.push(piEntryProvenance(step.entry));
-      seqs.push(step.seq);
+    if (event.data.type === "agent_step") {
+      for (const message of durableMessages(event.data.message)) {
+        messages.push(message);
+        provenance.push(messageEventProvenance(event.data));
+        seqs.push(event.seq);
+      }
       continue;
     }
-    if (step.entry.type === "authorization_completed") {
+    if (event.data.type === "authorization_completed") {
       messages.push(
-        authorizationObservationMessage(step.entry, step.createdAtMs)
+        authorizationObservationMessage(event.data, event.createdAtMs)
       );
       provenance.push(contextProvenance);
-      seqs.push(step.seq);
+      seqs.push(event.seq);
     }
   }
   return { messages, provenance, seqs, modelProfile, modelId };
 }
-function connectedMcpProvidersFromSteps(steps) {
+
+// src/chat/conversations/projection.ts
+function connectedMcpProvidersFromEvents(events) {
   const providers = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    if (step.entry.type === "mcp_provider_connected") {
-      providers.add(step.entry.provider);
+  for (const event of events) {
+    if (event.data.type === "mcp_provider_connected") {
+      providers.add(event.data.provider);
     }
   }
   return [...providers].sort((left, right) => left.localeCompare(right));
@@ -89,6 +130,11 @@ function countMatchingPrefix(left, right) {
   }
   return limit;
 }
+function normalizeDurableMessage(message) {
+  return piMessageSchema.parse(
+    JSON.parse(JSON.stringify(sanitizePostgresJson(message)))
+  );
+}
 function resolveCommitProvenance(args) {
   if (args.explicitProvenance) {
     if (args.explicitProvenance.length !== args.nextMessages.length) {
@@ -127,150 +173,136 @@ function resolveCommitProvenance(args) {
   }
   return provenance;
 }
-async function importLegacyIfNeeded(args) {
-  await ensureLegacyConversationImport({ conversationId: args.conversationId });
-}
 async function loadProjection(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  return projectSteps(steps).messages;
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events).messages;
 }
 async function loadConversationProjection(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  const { messages, provenance, modelProfile, modelId } = projectSteps(steps);
-  return { messages, provenance, modelProfile, modelId };
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events);
 }
 async function openConversationProjection(args) {
-  await importLegacyIfNeeded(args);
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  const projection = projectSteps(steps);
-  if (steps.some(
-    (step) => step.entry.type === "context_epoch_started" || step.entry.type === "pi_message"
-  )) {
-    return projection;
-  }
-  await stepStore.startEpoch(args.conversationId, {
-    reason: "initial",
-    modelProfile: "standard",
-    modelId: args.modelId,
-    messages: []
-  });
-  return {
-    messages: projection.messages,
-    provenance: projection.provenance,
-    modelProfile: "standard",
-    modelId: args.modelId
-  };
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events);
 }
 async function loadTurnProjection(args) {
-  await importLegacyIfNeeded(args);
-  const stepStore = getAgentStepStore();
+  const eventStore = getConversationEventStore();
   if (args.committedSeq < 0) {
-    return projectSteps(await stepStore.loadCurrentEpoch(args.conversationId));
+    return projectConversationEvents(
+      await eventStore.loadCurrentHistory(args.conversationId)
+    );
   }
-  const history = await stepStore.loadHistory(args.conversationId);
-  const committedStep = history.find((step) => step.seq === args.committedSeq);
-  if (!committedStep) {
+  const historyEvents = await eventStore.loadHistoryContaining(
+    args.conversationId,
+    args.committedSeq,
+    args.includeTail ? void 0 : args.committedSeq
+  );
+  if (!historyEvents) {
     return void 0;
   }
-  const epochSteps = history.filter(
-    (step) => step.contextEpoch === committedStep.contextEpoch
-  );
-  return args.includeTail ? projectSteps(epochSteps) : projectSteps(epochSteps, { maxSeq: args.committedSeq });
+  return projectConversationEvents(historyEvents);
 }
 async function loadConnectedMcpProviders(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  return connectedMcpProvidersFromSteps(steps);
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return connectedMcpProvidersFromEvents(events);
 }
 function messageTimestamp(message) {
   const timestamp = message.timestamp;
   return typeof timestamp === "number" ? timestamp : Date.now();
 }
 async function commitMessages(args) {
-  const stepStore = getAgentStepStore();
-  const currentSteps = await stepStore.loadCurrentEpoch(args.conversationId);
-  const existing = projectSteps(currentSteps);
-  const matchingPrefix = countMatchingPrefix(existing.messages, args.messages);
-  const nextProvenance = resolveCommitProvenance({
-    existing,
-    nextMessages: args.messages,
+  const executor = args.executor ?? getSqlExecutor();
+  return await withConversationEventLock(
+    executor,
+    args.conversationId,
+    async () => executor.transaction(
+      async () => await commitMessagesLocked(args, executor)
+    )
+  );
+}
+async function commitMessagesLocked(args, executor) {
+  const eventStore = createSqlConversationEventStore(executor);
+  const currentEvents = await eventStore.loadCurrentHistory(
+    args.conversationId
+  );
+  const current = projectConversationEvents(currentEvents);
+  const nextLocalMessages = stripRuntimeTurnContext(args.messages).map(
+    normalizeDurableMessage
+  );
+  const matchingPrefix = countMatchingPrefix(
+    current.messages,
+    nextLocalMessages
+  );
+  const nextLocalProvenance = resolveCommitProvenance({
+    existing: current,
+    nextMessages: nextLocalMessages,
     matchingPrefix,
     ...args.provenance ? { explicitProvenance: args.provenance } : {},
     ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
     ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
   });
-  if (currentSteps.length === 0) {
-    await stepStore.startEpoch(args.conversationId, {
-      reason: "initial",
-      modelProfile: "standard",
-      modelId: args.modelId,
-      messages: args.messages.map((message, index) => ({
-        message,
-        createdAtMs: messageTimestamp(message),
-        provenance: nextProvenance[index]
-      }))
-    });
-  } else if (matchingPrefix === existing.messages.length) {
-    const newMessages = args.messages.slice(matchingPrefix);
-    await stepStore.append(
+  if (matchingPrefix === current.messages.length) {
+    const newMessages = nextLocalMessages.slice(matchingPrefix);
+    await eventStore.append(
       args.conversationId,
       newMessages.map((message, index) => ({
-        entry: {
-          type: "pi_message",
+        data: {
+          type: "agent_step",
           message,
-          provenance: nextProvenance[matchingPrefix + index]
+          provenance: nextLocalProvenance[matchingPrefix + index]
         },
         createdAtMs: messageTimestamp(message)
       }))
     );
   } else {
-    await stepStore.startEpoch(args.conversationId, {
-      reason: "rollback",
-      modelProfile: existing.modelProfile,
-      modelId: args.modelId,
-      messages: args.messages.map((message, index) => ({
-        message,
-        createdAtMs: messageTimestamp(message),
-        provenance: nextProvenance[index]
-      }))
-    });
+    throw new Error(
+      `Agent history for ${args.conversationId} changed before its committed boundary`
+    );
   }
-  const committed = projectSteps(
-    await stepStore.loadCurrentEpoch(args.conversationId)
+  const committedEvents = await eventStore.loadCurrentHistory(
+    args.conversationId
   );
+  const committed = projectConversationEvents(committedEvents);
   return {
-    committedSeq: committed.seqs.at(-1) ?? -1,
+    committedSeq: committedEvents.at(-1)?.seq ?? -1,
+    historyVersion: committedEvents.at(-1)?.historyVersion ?? 0,
     messageSeqs: committed.seqs,
-    provenance: nextProvenance
+    messages: nextLocalMessages,
+    provenance: nextLocalProvenance
   };
 }
 async function recordMcpProviderConnected(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (connectedMcpProvidersFromSteps(steps).includes(args.provider)) {
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (connectedMcpProvidersFromEvents(events).includes(args.provider)) {
     return;
   }
-  await stepStore.append(args.conversationId, [
+  await eventStore.append(args.conversationId, [
     {
-      entry: { type: "mcp_provider_connected", provider: args.provider },
+      data: { type: "mcp_provider_connected", provider: args.provider },
       createdAtMs: Date.now()
     }
   ]);
 }
 async function recordAuthorizationRequested(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (steps.some(
-    (step) => step.entry.type === "authorization_requested" && step.entry.authorizationId === args.authorizationId
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (events.some(
+    (event) => event.data.type === "authorization_requested" && event.data.authorizationId === args.authorizationId
   )) {
     return;
   }
-  await stepStore.append(args.conversationId, [
+  await eventStore.append(args.conversationId, [
     {
-      entry: {
+      data: {
         type: "authorization_requested",
         kind: args.kind,
         provider: args.provider,
@@ -283,16 +315,16 @@ async function recordAuthorizationRequested(args) {
   ]);
 }
 async function recordAuthorizationCompleted(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (steps.some(
-    (step) => step.entry.type === "authorization_completed" && step.entry.authorizationId === args.authorizationId
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (events.some(
+    (event) => event.data.type === "authorization_completed" && event.data.authorizationId === args.authorizationId
   )) {
     return;
   }
-  await stepStore.append(args.conversationId, [
+  await eventStore.append(args.conversationId, [
     {
-      entry: {
+      data: {
         type: "authorization_completed",
         kind: args.kind,
         provider: args.provider,
@@ -304,107 +336,132 @@ async function recordAuthorizationCompleted(args) {
   ]);
 }
 async function recordToolExecutionStarted(args) {
-  await getAgentStepStore().append(args.conversationId, [
+  await getConversationEventStore().append(args.conversationId, [
     {
-      entry: {
+      data: {
         type: "tool_execution_started",
         toolCallId: args.toolCallId,
-        toolName: args.toolName,
-        ...args.args !== void 0 ? { args: args.args } : {}
+        toolName: args.toolName
       },
       createdAtMs: args.createdAtMs ?? Date.now()
     }
   ]);
 }
 
-// src/chat/usage.ts
-var agentTurnUsageSchema = usageSchema;
-var COMPONENT_USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "cachedInputTokens",
-  "cacheCreationTokens"
-];
-var COST_COMPONENT_FIELDS = [
-  "input",
-  "output",
-  "cacheRead",
-  "cacheWrite"
-];
-function hasAgentTurnUsage(usage) {
-  return Boolean(
-    usage && (Object.entries(usage).some(
-      ([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)
-    ) || Object.values(usage.cost ?? {}).some(
-      (value) => typeof value === "number" && Number.isFinite(value)
-    ))
-  );
-}
-function getFiniteCount(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
-}
-function getFiniteCost(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+// src/chat/state/conversation.ts
+function defaultConversationState() {
+  const nowMs = Date.now();
+  return {
+    schemaVersion: 1,
+    messages: [],
+    compactions: [],
+    backfill: {},
+    processing: {},
+    stats: {
+      estimatedContextTokens: 0,
+      totalMessageCount: 0,
+      compactedMessageCount: 0,
+      updatedAtMs: nowMs
+    },
+    vision: {
+      byFileId: {}
+    }
+  };
 }
-function addCost(left, right) {
-  return Math.round(((left ?? 0) + right) * 1e12) / 1e12;
+function coercePendingAuthState(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const kind = value.kind;
+  const provider = toOptionalString(value.provider);
+  const actorId = toOptionalString(value.actorId);
+  const authSessionId = toOptionalString(value.authSessionId);
+  const scope = toOptionalString(value.scope);
+  const sessionId = toOptionalString(value.sessionId);
+  const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
+  if (kind !== "mcp" && kind !== "plugin" || !provider || !actorId || kind === "mcp" && !authSessionId || !sessionId || typeof linkSentAtMs !== "number") {
+    return void 0;
+  }
+  const base = {
+    provider,
+    actorId,
+    ...scope ? { scope } : {},
+    sessionId,
+    linkSentAtMs
+  };
+  return kind === "mcp" ? { ...base, authSessionId, kind } : { ...base, kind };
 }
-function getComponentTotal(usage) {
-  let total;
-  for (const field of COMPONENT_USAGE_FIELDS) {
-    const value = getFiniteCount(usage[field]);
-    if (value === void 0) continue;
-    total = (total ?? 0) + value;
+function coerceThreadConversationState(value) {
+  if (!isRecord(value)) {
+    return defaultConversationState();
   }
-  return total;
-}
-function addAgentTurnUsage(...usages) {
-  const components = {};
-  let componentTotal;
-  let totalOnlyTokens;
-  let reasoningTokens;
-  const cost = {};
-  for (const usage of usages) {
-    if (!usage) continue;
-    const reasoning = getFiniteCount(usage.reasoningTokens);
-    if (reasoning !== void 0) {
-      reasoningTokens = (reasoningTokens ?? 0) + reasoning;
-    }
-    if (usage.cost) {
-      for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
-        const value = getFiniteCost(usage.cost[field]);
-        if (value === void 0) continue;
-        cost[field] = addCost(cost[field], value);
-      }
+  const root = value;
+  const rawConversation = isRecord(root.conversation) ? root.conversation : {};
+  const base = defaultConversationState();
+  const messages = [];
+  const compactions = [];
+  const rawBackfill = isRecord(rawConversation.backfill) ? rawConversation.backfill : {};
+  const backfill = {
+    completedAtMs: toOptionalNumber(rawBackfill.completedAtMs),
+    source: rawBackfill.source === "recent_messages" || rawBackfill.source === "thread_fetch" ? rawBackfill.source : void 0
+  };
+  const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
+  const processing = {
+    activeTurnId: toOptionalString(rawProcessing.activeTurnId),
+    lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
+    pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
+  };
+  const rawStats = isRecord(rawConversation.stats) ? rawConversation.stats : {};
+  const stats = {
+    estimatedContextTokens: toOptionalNumber(rawStats.estimatedContextTokens) ?? base.stats.estimatedContextTokens,
+    totalMessageCount: toOptionalNumber(rawStats.totalMessageCount) ?? messages.length,
+    compactedMessageCount: toOptionalNumber(rawStats.compactedMessageCount) ?? 0,
+    updatedAtMs: toOptionalNumber(rawStats.updatedAtMs) ?? base.stats.updatedAtMs
+  };
+  const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
+  const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
+  const byFileId = {};
+  for (const [fileId, value2] of Object.entries(rawVisionByFileId)) {
+    if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
+    if (!isRecord(value2)) continue;
+    const summary = toOptionalString(value2.summary);
+    const analyzedAtMs = toOptionalNumber(value2.analyzedAtMs);
+    if (!summary || !analyzedAtMs) continue;
+    byFileId[fileId] = {
+      summary,
+      analyzedAtMs
+    };
+  }
+  return {
+    schemaVersion: 1,
+    messages,
+    compactions,
+    backfill,
+    processing,
+    stats,
+    vision: {
+      backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
+      byFileId
     }
-    const usageComponentTotal = getComponentTotal(usage);
-    if (usageComponentTotal !== void 0) {
-      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
-      for (const field of COMPONENT_USAGE_FIELDS) {
-        const value = getFiniteCount(usage[field]);
-        if (value === void 0) continue;
-        components[field] = (components[field] ?? 0) + value;
+  };
+}
+function buildConversationStatePatch(conversation) {
+  const {
+    compactions: _compactions,
+    messages: _messages,
+    ...scratch
+  } = conversation;
+  return {
+    conversation: {
+      ...scratch,
+      schemaVersion: 1,
+      stats: {
+        ...conversation.stats,
+        totalMessageCount: conversation.messages.length,
+        updatedAtMs: Date.now()
       }
-      continue;
-    }
-    const totalTokens = getFiniteCount(usage.totalTokens);
-    if (totalTokens !== void 0) {
-      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
     }
-  }
-  if (totalOnlyTokens !== void 0) {
-    return {
-      totalTokens: totalOnlyTokens + (componentTotal ?? 0),
-      ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
-      ...Object.keys(cost).length > 0 ? { cost } : {}
-    };
-  }
-  const result = {
-    ...components,
-    ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
-    ...Object.keys(cost).length > 0 ? { cost } : {}
   };
-  return hasAgentTurnUsage(result) ? result : void 0;
 }
 
 // src/chat/state/turn-session.ts
@@ -414,67 +471,74 @@ import {
   destinationSchema,
   sourceSchema
 } from "@sentry/junior-plugin-api";
-import { z } from "zod";
+import { z as z2 } from "zod";
+
+// src/chat/state/turn-session-keys.ts
 var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function agentTurnSessionConversationIndexKey(conversationId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
+}
+
+// src/chat/state/turn-session.ts
 var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
 var AGENT_TURN_SESSION_INDEX_MAX_LENGTH = 5e3;
 var AGENT_TURN_SESSION_INDEX_READ_CONCURRENCY = 25;
 var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS;
-var agentTurnSessionStatusSchema = z.enum([
+var agentTurnSessionStatusSchema = z2.enum([
   "running",
   "awaiting_resume",
   "completed",
   "failed",
   "abandoned"
 ]);
-var agentTurnSurfaceSchema = z.enum([
+var agentTurnSurfaceSchema = z2.enum([
   "slack",
   "api",
   "scheduler",
   "internal"
 ]);
-var agentTurnResumeReasonSchema = z.enum([
+var agentTurnResumeReasonSchema = z2.enum([
   "timeout",
   "auth",
-  "yield"
+  "yield",
+  "retry"
 ]);
-var nonNegativeNumberSchema = z.number().finite().nonnegative();
-var seqCursorSchema = z.number().int().min(-1);
-var agentTurnSessionSummarySchema = z.object({
-  channelName: z.string().min(1).optional(),
-  version: z.number().int().nonnegative(),
-  conversationId: z.string().min(1),
+var nonNegativeNumberSchema = z2.number().finite().nonnegative();
+var seqCursorSchema = z2.number().int().min(-1);
+var agentTurnSessionSummarySchema = z2.object({
+  channelName: z2.string().min(1).optional(),
+  version: z2.number().int().nonnegative(),
+  conversationId: z2.string().min(1),
   cumulativeDurationMs: nonNegativeNumberSchema,
   cumulativeUsage: agentTurnUsageSchema.optional(),
   destination: destinationSchema.optional(),
   source: sourceSchema.optional(),
   lastProgressAtMs: nonNegativeNumberSchema,
-  loadedSkillNames: z.array(z.string()).optional(),
-  modelId: z.string().min(1).optional(),
-  reasoningLevel: z.string().min(1).optional(),
+  loadedSkillNames: z2.array(z2.string()).optional(),
+  modelId: z2.string().min(1).optional(),
+  reasoningLevel: z2.string().min(1).optional(),
   actor: actorSchema.optional(),
   resumeReason: agentTurnResumeReasonSchema.optional(),
-  resumedFromSliceId: z.number().int().nonnegative().optional(),
-  sessionId: z.string().min(1),
-  sliceId: z.number().int().nonnegative(),
+  resumedFromSliceId: z2.number().int().nonnegative().optional(),
+  sessionId: z2.string().min(1),
+  sliceId: z2.number().int().nonnegative(),
   startedAtMs: nonNegativeNumberSchema,
   state: agentTurnSessionStatusSchema,
   surface: agentTurnSurfaceSchema.optional(),
-  traceId: z.string().optional(),
+  traceId: z2.string().optional(),
   updatedAtMs: nonNegativeNumberSchema
 }).strict();
 var storedAgentTurnSessionRecordSchema = agentTurnSessionSummarySchema.extend({
-  actors: z.array(actorSchema).optional(),
+  actors: z2.array(actorSchema).optional(),
   committedSeq: seqCursorSchema,
-  errorMessage: z.string().optional(),
-  turnStartSeq: seqCursorSchema.optional()
+  historyVersion: z2.number().int().nonnegative().optional(),
+  errorMessage: z2.string().optional(),
+  turnStartSeq: seqCursorSchema.optional(),
+  runtimeContext: z2.array(piMessageSchema).optional()
 }).strict();
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function agentTurnSessionConversationIndexKey(conversationId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
-}
 function conversationExecutionFromSummary(summary) {
   const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
   return {
@@ -490,13 +554,6 @@ function parseAgentTurnSessionRecord(value) {
   return storedAgentTurnSessionRecordSchema.parse(value);
 }
 function parseAgentTurnSessionSummary(value) {
-  if (typeof value === "object" && value !== null && !Array.isArray(value) && "requester" in value) {
-    const { requester, ...summary } = value;
-    return agentTurnSessionSummarySchema.parse({
-      ...summary,
-      ...summary.actor === void 0 ? { actor: requester } : {}
-    });
-  }
   return agentTurnSessionSummarySchema.parse(value);
 }
 async function appendAgentTurnSessionSummary(summary, ttlMs) {
@@ -543,7 +600,8 @@ async function recordConversationActivityMetadata(args) {
     visibility: args.destinationVisibility
   });
 }
-function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex) {
+function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true) {
+  const piMessages = restoreVolatileContext && (stored.state === "running" || stored.state === "awaiting_resume") ? restoreRuntimeContext(piProjection.messages, stored.runtimeContext) : piProjection.messages;
   return {
     version: stored.version,
     ...stored.channelName ? { channelName: stored.channelName } : {},
@@ -554,7 +612,7 @@ function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessag
     startedAtMs: stored.startedAtMs,
     lastProgressAtMs: stored.lastProgressAtMs,
     updatedAtMs: stored.updatedAtMs,
-    piMessages: piProjection.messages,
+    piMessages,
     piMessageProvenance: piProjection.provenance,
     actors: stored.actors ?? instructionActors(piProjection.provenance),
     cumulativeDurationMs: stored.cumulativeDurationMs,
@@ -573,6 +631,30 @@ function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessag
     ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
   };
 }
+function restoreRuntimeContext(messages, runtimeContext) {
+  if (!runtimeContext || runtimeContext.length === 0) return messages;
+  const restored = [...messages];
+  for (const runtimeMessage of runtimeContext) {
+    const runtime = runtimeMessage;
+    const targetIndex = restored.findIndex((message) => {
+      const candidate = message;
+      return candidate.role === "user" && candidate.timestamp === runtime.timestamp;
+    });
+    if (targetIndex < 0) {
+      restored.push(runtimeMessage);
+      continue;
+    }
+    const target = restored[targetIndex];
+    restored[targetIndex] = {
+      ...restored[targetIndex],
+      content: [
+        ...Array.isArray(runtime.content) ? runtime.content : [],
+        ...Array.isArray(target.content) ? target.content : []
+      ]
+    };
+  }
+  return restored;
+}
 async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
@@ -581,7 +663,7 @@ async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
   );
   return value == null ? void 0 : parseAgentTurnSessionRecord(value);
 }
-async function getAgentTurnSessionRecord(conversationId, sessionId) {
+async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId, followCurrentReplacement) {
   const parsed = await getStoredAgentTurnSessionRecord(
     conversationId,
     sessionId
@@ -589,21 +671,40 @@ async function getAgentTurnSessionRecord(conversationId, sessionId) {
   if (!parsed) {
     return void 0;
   }
-  const piProjection = await loadTurnProjection({
+  const pinnedProjection = await loadTurnProjection({
     conversationId,
     committedSeq: parsed.committedSeq,
     // Unfinished records include the current-epoch tail so parked input
     // appended after the last safe boundary stays model-visible on resume.
     includeTail: parsed.state === "running" || parsed.state === "awaiting_resume"
   });
-  if (!piProjection) {
+  if (!pinnedProjection) {
     return void 0;
   }
-  const turnStartMessageIndex = parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
+  const currentHistory = await getConversationEventStore().loadCurrentHistory(conversationId);
+  const currentHistoryVersion = currentHistory.at(-1)?.historyVersion ?? parsed.historyVersion ?? 0;
+  const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "awaiting_resume") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
+  const piProjection = followsReplacement ? projectConversationEvents(currentHistory) : pinnedProjection;
+  const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
   return materializeAgentTurnSessionRecord(
     parsed,
     piProjection,
-    turnStartMessageIndex
+    turnStartMessageIndex,
+    !followsReplacement && (parsed.historyVersion === void 0 || parsed.historyVersion === currentHistoryVersion)
+  );
+}
+async function getAgentTurnSessionRecord(conversationId, sessionId) {
+  return await materializeStoredAgentTurnSessionRecord(
+    conversationId,
+    sessionId,
+    false
+  );
+}
+async function getAgentTurnSessionRecordForResume(conversationId, sessionId) {
+  return await materializeStoredAgentTurnSessionRecord(
+    conversationId,
+    sessionId,
+    true
   );
 }
 function buildStoredRecord(args) {
@@ -619,7 +720,9 @@ function buildStoredRecord(args) {
     lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
     updatedAtMs: nowMs,
     committedSeq: args.committedSeq,
+    ...args.historyVersion !== void 0 ? { historyVersion: args.historyVersion } : {},
     ...args.turnStartSeq !== void 0 ? { turnStartSeq: args.turnStartSeq } : {},
+    ...args.runtimeContext && args.runtimeContext.length > 0 ? { runtimeContext: args.runtimeContext } : {},
     cumulativeDurationMs: args.cumulativeDurationMs,
     ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
     ...args.destination ? { destination: args.destination } : {},
@@ -653,8 +756,10 @@ async function setStoredRecord(args) {
   const {
     actors: _actors,
     committedSeq: _committedSeq,
+    historyVersion: _historyVersion,
     errorMessage: _errorMessage,
     turnStartSeq: _turnStartSeq,
+    runtimeContext: _runtimeContext,
     ...summary
   } = args.record;
   await appendAgentTurnSessionSummary(summary, args.ttlMs);
@@ -686,7 +791,9 @@ async function updateAgentTurnSessionState(args) {
       sliceId: args.existing.sliceId,
       state: args.state,
       committedSeq: parsed.committedSeq,
+      ...parsed.historyVersion !== void 0 ? { historyVersion: parsed.historyVersion } : {},
       ...parsed.turnStartSeq !== void 0 ? { turnStartSeq: parsed.turnStartSeq } : {},
+      ...parsed.runtimeContext ? { runtimeContext: parsed.runtimeContext } : {},
       ...parsed.channelName ? { channelName: parsed.channelName } : {},
       startedAtMs: parsed.startedAtMs,
       lastProgressAtMs: parsed.lastProgressAtMs,
@@ -717,17 +824,21 @@ async function upsertAgentTurnSessionRecord(args) {
   const instructionActor = args.actor ?? existingRecord?.actor;
   const commit = await commitMessages({
     conversationId: args.conversationId,
-    modelId: args.modelId,
     messages: args.piMessages,
     ...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : {},
     ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {}
   });
-  const turnStartSeq = args.turnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : args.turnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[args.turnStartMessageIndex - 1] ?? commit.committedSeq;
-  const turnStartMessageIndex = args.turnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
+  const durableTurnStartMessageIndex = args.turnStartMessageIndex === void 0 ? void 0 : stripRuntimeTurnContext(
+    args.piMessages.slice(0, args.turnStartMessageIndex)
+  ).length;
+  const runtimeContext = retainRuntimeTurnContext(args.piMessages);
+  const retainedRuntimeContext = runtimeContext.length > 0 ? runtimeContext : existingRecord?.historyVersion === commit.historyVersion ? existingRecord.runtimeContext : void 0;
+  const turnStartSeq = durableTurnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : durableTurnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[durableTurnStartMessageIndex - 1] ?? commit.committedSeq;
+  const turnStartMessageIndex = durableTurnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
   return await setStoredRecord({
     conversationStore: args.conversationStore,
     destinationVisibility: args.destinationVisibility,
-    piMessages: args.piMessages,
+    piMessages: commit.messages,
     piMessageProvenance: commit.provenance,
     ttlMs,
     ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
@@ -740,7 +851,9 @@ async function upsertAgentTurnSessionRecord(args) {
       ...existingRecord?.startedAtMs !== void 0 ? { startedAtMs: existingRecord.startedAtMs } : {},
       ...args.lastProgressAtMs !== void 0 ? { lastProgressAtMs: args.lastProgressAtMs } : {},
       committedSeq: commit.committedSeq,
+      historyVersion: commit.historyVersion,
       ...turnStartSeq !== void 0 ? { turnStartSeq } : {},
+      ...retainedRuntimeContext ? { runtimeContext: retainedRuntimeContext } : {},
       previousVersion: existingRecord?.version,
       cumulativeDurationMs: args.cumulativeDurationMs ?? existingRecord?.cumulativeDurationMs ?? 0,
       ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
@@ -917,8 +1030,11 @@ async function failAgentTurnSessionRecord(args) {
   });
 }
 
+// src/chat/state/ttl.ts
+var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
 export {
-  projectSteps,
+  piMessageSchema,
   loadProjection,
   loadConversationProjection,
   openConversationProjection,
@@ -928,14 +1044,18 @@ export {
   recordAuthorizationRequested,
   recordAuthorizationCompleted,
   recordToolExecutionStarted,
-  hasAgentTurnUsage,
-  addAgentTurnUsage,
+  AGENT_TURN_SESSION_PREFIX,
+  agentTurnSessionKey,
+  agentTurnSessionConversationIndexKey,
   getAgentTurnSessionRecord,
+  getAgentTurnSessionRecordForResume,
   upsertAgentTurnSessionRecord,
   recordAgentTurnSessionSummary,
   listAgentTurnSessionSummariesForConversation,
-  listBoundedAgentTurnSessionSummariesForConversation,
   listAgentTurnSessionSummariesForConversations,
   abandonAgentTurnSessionRecord,
-  failAgentTurnSessionRecord
+  failAgentTurnSessionRecord,
+  JUNIOR_THREAD_STATE_TTL_MS,
+  coerceThreadConversationState,
+  buildConversationStatePatch
 };