@sentry/junior 0.108.0 → 0.110.0

package/dist/{chunk-3RGQLX2F.js → chunk-C5XAFTHY.js}

@@ -1,20 +1,21 @@
 import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  abandonAgentTurnSessionRecord,
-  buildConversationStatePatch,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
-  upsertAgentTurnSessionRecord
-} from "./chunk-J3B3FPP2.js";
-import {
-  addAgentTurnUsage
+  addAgentTurnUsage,
+  agentTurnUsageSchema
 } from "./chunk-MU6HHZEN.js";
 import {
   getStateAdapter
-} from "./chunk-H3QYZL7K.js";
+} from "./chunk-GK47NBDE.js";
 import {
-  getConversationEventStore
-} from "./chunk-TE4QHJH4.js";
+  contextProvenance,
+  createSqlConversationEventStore,
+  getConversationEventStore,
+  getConversationStore,
+  getSqlExecutor,
+  instructionActors,
+  instructionProvenanceFor,
+  sanitizePostgresJson,
+  withConversationEventLock
+} from "./chunk-4QU44P7Q.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -23,22 +24,343 @@ import {
   escapeXml,
   getPiMessageRole,
   resolveGatewayModel,
+  retainRuntimeTurnContext,
   standardModelId,
+  stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-WNOVRQ67.js";
+import {
+  toStoredSlackActor
+} from "./chunk-C4MZ3GP5.js";
 import {
   getActiveTraceId,
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-IYKPU7H6.js";
 import {
   isRecord,
+  parseSlackMessageTs,
+  toOptionalNumber,
   toOptionalString
-} from "./chunk-OB42YVAE.js";
-import {
-  parseSlackMessageTs
-} from "./chunk-7FBGKXPE.js";
+} from "./chunk-42WRQLJ6.js";
+
+// src/chat/conversations/projection.ts
+import { isDeepStrictEqual } from "util";
+
+// src/chat/pi/messages.ts
+import { z } from "zod";
+var piMessageSchema = z.object({
+  role: z.string()
+}).passthrough().transform((value) => value);
+var piContentMessageSchema = z.object({
+  content: z.array(z.unknown()),
+  role: z.string().min(1)
+}).passthrough().transform((value) => value);
+
+// src/chat/pi/conversation-events.ts
+function authorizationObservationMessage(data, createdAtMs) {
+  const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
+  return piMessageSchema.parse({
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `${label} completed for provider "${data.provider}". Continue the blocked request and retry the provider operation if needed.`
+      }
+    ],
+    timestamp: createdAtMs
+  });
+}
+function messageEventProvenance(data) {
+  return data.provenance ?? contextProvenance;
+}
+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 event of events) {
+    if (options?.maxSeq !== void 0 && event.seq > options.maxSeq) break;
+    if (event.data.type === "unknown") {
+      throw new Error(
+        `Unsupported conversation event "${event.data.originalType}" at seq ${event.seq} (schema version ${event.schemaVersion})`
+      );
+    }
+    if (event.data.type === "compaction" || event.data.type === "handoff" || 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 (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 (event.data.type === "authorization_completed") {
+      messages.push(
+        authorizationObservationMessage(event.data, event.createdAtMs)
+      );
+      provenance.push(contextProvenance);
+      seqs.push(event.seq);
+    }
+  }
+  return { messages, provenance, seqs, modelProfile, modelId };
+}
+
+// src/chat/conversations/projection.ts
+function connectedMcpProvidersFromEvents(events) {
+  const providers = /* @__PURE__ */ new Set();
+  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));
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+function countMatchingPrefix(left, right) {
+  const limit = Math.min(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (!isDeepStrictEqual(left[index], right[index])) {
+      return index;
+    }
+  }
+  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) {
+      throw new Error("commit provenance must align one-to-one with messages");
+    }
+    return args.explicitProvenance;
+  }
+  const matchingPrefix = args.matchingPrefix;
+  const provenance = args.nextMessages.map(
+    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? contextProvenance : contextProvenance
+  );
+  if (args.newMessageProvenance) {
+    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
+      if (isUserMessage(args.nextMessages[index])) {
+        provenance[index] = args.newMessageProvenance;
+        break;
+      }
+    }
+  }
+  if (args.trailingMessageProvenance) {
+    if (args.trailingMessageProvenance.length > provenance.length) {
+      throw new Error(
+        "trailing commit provenance cannot exceed committed messages"
+      );
+    }
+    const newMessageCount = args.nextMessages.length - matchingPrefix;
+    if (args.trailingMessageProvenance.length > newMessageCount) {
+      throw new Error(
+        "trailing commit provenance must align to newly committed messages"
+      );
+    }
+    const start = provenance.length - args.trailingMessageProvenance.length;
+    args.trailingMessageProvenance.forEach((entry, offset) => {
+      provenance[start + offset] = entry;
+    });
+  }
+  return provenance;
+}
+async function loadProjection(args) {
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events).messages;
+}
+async function loadConversationProjection(args) {
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events);
+}
+async function openConversationProjection(args) {
+  const events = await getConversationEventStore().loadCurrentHistory(
+    args.conversationId
+  );
+  return projectConversationEvents(events);
+}
+async function loadTurnProjection(args) {
+  const eventStore = getConversationEventStore();
+  if (args.committedSeq < 0) {
+    return projectConversationEvents(
+      await eventStore.loadCurrentHistory(args.conversationId)
+    );
+  }
+  const historyEvents = await eventStore.loadHistoryContaining(
+    args.conversationId,
+    args.committedSeq,
+    args.includeTail ? void 0 : args.committedSeq
+  );
+  if (!historyEvents) {
+    return void 0;
+  }
+  return projectConversationEvents(historyEvents);
+}
+async function loadConnectedMcpProviders(args) {
+  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 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 (matchingPrefix === current.messages.length) {
+    const newMessages = nextLocalMessages.slice(matchingPrefix);
+    await eventStore.append(
+      args.conversationId,
+      newMessages.map((message, index) => ({
+        data: {
+          type: "agent_step",
+          message,
+          provenance: nextLocalProvenance[matchingPrefix + index]
+        },
+        createdAtMs: messageTimestamp(message)
+      }))
+    );
+  } else {
+    throw new Error(
+      `Agent history for ${args.conversationId} changed before its committed boundary`
+    );
+  }
+  const committedEvents = await eventStore.loadCurrentHistory(
+    args.conversationId
+  );
+  const committed = projectConversationEvents(committedEvents);
+  return {
+    committedSeq: committedEvents.at(-1)?.seq ?? -1,
+    historyVersion: committedEvents.at(-1)?.historyVersion ?? 0,
+    messageSeqs: committed.seqs,
+    messages: nextLocalMessages,
+    provenance: nextLocalProvenance
+  };
+}
+async function recordMcpProviderConnected(args) {
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (connectedMcpProvidersFromEvents(events).includes(args.provider)) {
+    return;
+  }
+  await eventStore.append(args.conversationId, [
+    {
+      data: { type: "mcp_provider_connected", provider: args.provider },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationRequested(args) {
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (events.some(
+    (event) => event.data.type === "authorization_requested" && event.data.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await eventStore.append(args.conversationId, [
+    {
+      data: {
+        type: "authorization_requested",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId,
+        delivery: args.delivery
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationCompleted(args) {
+  const eventStore = getConversationEventStore();
+  const events = await eventStore.loadCurrentHistory(args.conversationId);
+  if (events.some(
+    (event) => event.data.type === "authorization_completed" && event.data.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await eventStore.append(args.conversationId, [
+    {
+      data: {
+        type: "authorization_completed",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordToolExecutionStarted(args) {
+  await getConversationEventStore().append(args.conversationId, [
+    {
+      data: {
+        type: "tool_execution_started",
+        toolCallId: args.toolCallId,
+        toolName: args.toolName
+      },
+      createdAtMs: args.createdAtMs ?? Date.now()
+    }
+  ]);
+}
 
 // src/chat/state/turn-id.ts
 function buildDeterministicTurnId(messageId) {
@@ -145,6 +467,531 @@ async function persistWithRetry(persist) {
   throw lastError;
 }
 
+// src/chat/state/turn-session.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+import {
+  actorSchema,
+  destinationSchema,
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+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_TTL_MS = THREAD_STATE_TTL_MS;
+var agentTurnSessionStatusSchema = z2.enum([
+  "running",
+  "awaiting_resume",
+  "completed",
+  "failed",
+  "abandoned"
+]);
+var agentTurnSurfaceSchema = z2.enum([
+  "slack",
+  "api",
+  "scheduler",
+  "internal"
+]);
+var agentTurnResumeReasonSchema = z2.enum([
+  "timeout",
+  "auth",
+  "yield",
+  "retry"
+]);
+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: z2.array(z2.string()).optional(),
+  modelId: z2.string().min(1).optional(),
+  reasoningLevel: z2.string().min(1).optional(),
+  actor: actorSchema.optional(),
+  resumeReason: agentTurnResumeReasonSchema.optional(),
+  resumedFromSliceId: z2.number().int().nonnegative().optional(),
+  sessionId: z2.string().min(1),
+  sliceId: z2.number().int().nonnegative(),
+  startedAtMs: nonNegativeNumberSchema,
+  state: agentTurnSessionStatusSchema,
+  surface: agentTurnSurfaceSchema.optional(),
+  traceId: z2.string().optional(),
+  updatedAtMs: nonNegativeNumberSchema
+}).strict();
+var storedAgentTurnSessionRecordSchema = agentTurnSessionSummarySchema.extend({
+  actors: z2.array(actorSchema).optional(),
+  committedSeq: seqCursorSchema,
+  historyVersion: z2.number().int().nonnegative().optional(),
+  errorMessage: z2.string().optional(),
+  turnStartSeq: seqCursorSchema.optional(),
+  runtimeContext: z2.array(piMessageSchema).optional()
+}).strict();
+function conversationExecutionFromSummary(summary) {
+  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
+  return {
+    status,
+    runId: summary.sessionId,
+    updatedAtMs: summary.updatedAtMs
+  };
+}
+function sessionLogActor(actor) {
+  return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
+}
+function parseAgentTurnSessionRecord(value) {
+  return storedAgentTurnSessionRecordSchema.parse(value);
+}
+function parseAgentTurnSessionSummary(value) {
+  return agentTurnSessionSummarySchema.parse(value);
+}
+async function appendAgentTurnSessionSummary(summary, ttlMs) {
+  const stateAdapter = getStateAdapter();
+  await Promise.all([
+    stateAdapter.appendToList(AGENT_TURN_SESSION_INDEX_KEY, summary, {
+      maxLength: AGENT_TURN_SESSION_INDEX_MAX_LENGTH,
+      ttlMs
+    }),
+    stateAdapter.appendToList(
+      agentTurnSessionConversationIndexKey(summary.conversationId),
+      summary,
+      { ttlMs }
+    )
+  ]);
+}
+async function recordConversationActivityMetadata(args) {
+  const conversationStore = args.conversationStore ?? getConversationStore();
+  const source = args.summary.destination?.platform === "local" ? "local" : args.summary.surface;
+  await conversationStore.recordActivity({
+    activityAtMs: args.summary.updatedAtMs,
+    channelName: args.summary.channelName,
+    conversationId: args.summary.conversationId,
+    destination: args.summary.destination,
+    nowMs: args.nowMs,
+    actor: sessionLogActor(args.summary.actor),
+    source,
+    visibility: args.destinationVisibility
+  });
+  await conversationStore.recordExecution({
+    channelName: args.summary.channelName,
+    conversationId: args.summary.conversationId,
+    createdAtMs: args.summary.startedAtMs,
+    destination: args.summary.destination,
+    execution: conversationExecutionFromSummary(args.summary),
+    lastActivityAtMs: args.summary.updatedAtMs,
+    metrics: {
+      durationMs: args.summary.cumulativeDurationMs,
+      ...args.summary.cumulativeUsage ? { usage: args.summary.cumulativeUsage } : {}
+    },
+    actor: sessionLogActor(args.summary.actor),
+    source,
+    updatedAtMs: args.nowMs,
+    visibility: args.destinationVisibility
+  });
+}
+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 } : {},
+    conversationId: stored.conversationId,
+    sessionId: stored.sessionId,
+    sliceId: stored.sliceId,
+    state: stored.state,
+    startedAtMs: stored.startedAtMs,
+    lastProgressAtMs: stored.lastProgressAtMs,
+    updatedAtMs: stored.updatedAtMs,
+    piMessages,
+    piMessageProvenance: piProjection.provenance,
+    actors: stored.actors ?? instructionActors(piProjection.provenance),
+    cumulativeDurationMs: stored.cumulativeDurationMs,
+    ...stored.destination ? { destination: stored.destination } : {},
+    ...stored.source ? { source: stored.source } : {},
+    ...stored.cumulativeUsage ? { cumulativeUsage: stored.cumulativeUsage } : {},
+    ...stored.resumeReason ? { resumeReason: stored.resumeReason } : {},
+    ...stored.errorMessage ? { errorMessage: stored.errorMessage } : {},
+    ...stored.loadedSkillNames ? { loadedSkillNames: stored.loadedSkillNames } : {},
+    ...stored.modelId ? { modelId: stored.modelId } : {},
+    ...stored.reasoningLevel ? { reasoningLevel: stored.reasoningLevel } : {},
+    ...stored.actor ? { actor: stored.actor } : {},
+    ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
+    ...stored.surface ? { surface: stored.surface } : {},
+    ...stored.traceId ? { traceId: stored.traceId } : {},
+    ...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();
+  const value = await stateAdapter.get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
+  return value == null ? void 0 : parseAgentTurnSessionRecord(value);
+}
+async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId, followCurrentReplacement) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    conversationId,
+    sessionId
+  );
+  if (!parsed) {
+    return void 0;
+  }
+  const pinnedProjection = await loadTurnProjection({
+    conversationId,
+    committedSeq: parsed.committedSeq,
+    // Unfinished records include the current-epoch tail so parked input
+    // appended after the last safe boundary stays model-visible on resume.
+    includeTail: parsed.state === "running" || parsed.state === "awaiting_resume"
+  });
+  if (!pinnedProjection) {
+    return void 0;
+  }
+  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,
+    !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) {
+  const nowMs = Date.now();
+  return {
+    version: (args.previousVersion ?? 0) + 1,
+    ...args.channelName ? { channelName: args.channelName } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    startedAtMs: args.startedAtMs ?? nowMs,
+    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 } : {},
+    ...args.source ? { source: args.source } : {},
+    ...args.actor ? { actor: args.actor } : {},
+    ...args.actors ? { actors: args.actors } : {},
+    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+    ...args.modelId ? { modelId: args.modelId } : {},
+    ...args.reasoningLevel ? { reasoningLevel: args.reasoningLevel } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+    ...args.surface ? { surface: args.surface } : {},
+    ...args.traceId ? { traceId: args.traceId } : {}
+  };
+}
+async function setStoredRecord(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs: Date.now(),
+    summary: args.record
+  });
+  await stateAdapter.set(
+    agentTurnSessionKey(args.record.conversationId, args.record.sessionId),
+    args.record,
+    args.ttlMs
+  );
+  const {
+    actors: _actors,
+    committedSeq: _committedSeq,
+    historyVersion: _historyVersion,
+    errorMessage: _errorMessage,
+    turnStartSeq: _turnStartSeq,
+    runtimeContext: _runtimeContext,
+    ...summary
+  } = args.record;
+  await appendAgentTurnSessionSummary(summary, args.ttlMs);
+  return materializeAgentTurnSessionRecord(
+    args.record,
+    {
+      messages: [...args.piMessages],
+      provenance: [...args.piMessageProvenance]
+    },
+    args.turnStartMessageIndex
+  );
+}
+async function updateAgentTurnSessionState(args) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    args.existing.conversationId,
+    args.existing.sessionId
+  );
+  if (!parsed || parsed.version !== args.existing.version) {
+    return void 0;
+  }
+  return await setStoredRecord({
+    piMessages: args.existing.piMessages,
+    piMessageProvenance: args.existing.piMessageProvenance,
+    ttlMs: AGENT_TURN_SESSION_TTL_MS,
+    ...args.existing.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.existing.turnStartMessageIndex } : {},
+    record: buildStoredRecord({
+      conversationId: args.existing.conversationId,
+      sessionId: args.existing.sessionId,
+      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,
+      previousVersion: parsed.version,
+      cumulativeDurationMs: args.existing.cumulativeDurationMs,
+      ...args.existing.cumulativeUsage ? { cumulativeUsage: args.existing.cumulativeUsage } : {},
+      ...args.existing.destination ? { destination: args.existing.destination } : {},
+      ...args.existing.source ? { source: args.existing.source } : {},
+      ...args.existing.loadedSkillNames ? { loadedSkillNames: args.existing.loadedSkillNames } : {},
+      ...args.existing.modelId ? { modelId: args.existing.modelId } : {},
+      ...args.existing.reasoningLevel ? { reasoningLevel: args.existing.reasoningLevel } : {},
+      ...args.existing.actor ? { actor: args.existing.actor } : {},
+      actors: args.existing.actors,
+      ...args.existing.resumeReason ? { resumeReason: args.existing.resumeReason } : {},
+      ...args.existing.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.existing.resumedFromSliceId } : {},
+      ...args.existing.surface ? { surface: args.existing.surface } : {},
+      ...args.existing.traceId ? { traceId: args.existing.traceId } : {},
+      ...args.errorMessage ?? args.existing.errorMessage ? { errorMessage: args.errorMessage ?? args.existing.errorMessage } : {}
+    })
+  });
+}
+async function upsertAgentTurnSessionRecord(args) {
+  const existingRecord = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  const instructionActor = args.actor ?? existingRecord?.actor;
+  const commit = await commitMessages({
+    conversationId: args.conversationId,
+    messages: args.piMessages,
+    ...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : {},
+    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {}
+  });
+  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: commit.messages,
+    piMessageProvenance: commit.provenance,
+    ttlMs,
+    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
+    record: buildStoredRecord({
+      ...args.channelName ?? existingRecord?.channelName ? { channelName: args.channelName ?? existingRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: args.state,
+      ...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 } : {},
+      ...args.destination ?? existingRecord?.destination ? { destination: args.destination ?? existingRecord?.destination } : {},
+      ...args.source ?? existingRecord?.source ? { source: args.source ?? existingRecord?.source } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      modelId: args.modelId,
+      ...args.reasoningLevel ?? existingRecord?.reasoningLevel ? {
+        reasoningLevel: args.reasoningLevel ?? existingRecord?.reasoningLevel
+      } : {},
+      ...args.actor ?? existingRecord?.actor ? { actor: args.actor ?? existingRecord?.actor } : {},
+      actors: instructionActors([
+        ...(existingRecord?.actors ?? []).map(instructionProvenanceFor),
+        ...(args.actors ?? []).map(instructionProvenanceFor),
+        ...commit.provenance
+      ]),
+      ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+      ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+      ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+      ...args.surface ?? existingRecord?.surface ? { surface: args.surface ?? existingRecord?.surface } : {},
+      ...args.traceId ?? existingRecord?.traceId ? { traceId: args.traceId ?? existingRecord?.traceId } : {}
+    })
+  });
+}
+async function recordAgentTurnSessionSummary(args) {
+  const existing = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const nowMs = Date.now();
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  const summary = {
+    version: existing?.version ?? 0,
+    ...args.channelName ?? existing?.channelName ? { channelName: args.channelName ?? existing?.channelName } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    startedAtMs: existing?.startedAtMs ?? args.startedAtMs ?? nowMs,
+    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+    state: args.state,
+    updatedAtMs: nowMs,
+    cumulativeDurationMs: args.cumulativeDurationMs ?? existing?.cumulativeDurationMs ?? 0,
+    ...args.cumulativeUsage ?? existing?.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage ?? existing?.cumulativeUsage } : {},
+    ...args.destination ?? existing?.destination ? { destination: args.destination ?? existing?.destination } : {},
+    ...args.source ?? existing?.source ? { source: args.source ?? existing?.source } : {},
+    ...args.actor ?? existing?.actor ? { actor: args.actor ?? existing?.actor } : {},
+    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
+    ...args.modelId ?? existing?.modelId ? { modelId: args.modelId ?? existing?.modelId } : {},
+    ...args.reasoningLevel ?? existing?.reasoningLevel ? { reasoningLevel: args.reasoningLevel ?? existing?.reasoningLevel } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
+    ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
+  };
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs,
+    summary
+  });
+  await appendAgentTurnSessionSummary(summary, ttlMs);
+}
+async function readAgentTurnSessionSummariesFromIndex(key, stateAdapter) {
+  await stateAdapter.connect();
+  const values = await stateAdapter.getList(key);
+  const summaries = /* @__PURE__ */ new Map();
+  for (const value of [...values].reverse()) {
+    let summary;
+    try {
+      summary = parseAgentTurnSessionSummary(value);
+    } catch (error) {
+      logWarn(
+        "agent_turn_session_summary_parse_failed",
+        {},
+        {
+          "app.state.key": key,
+          "exception.message": error instanceof Error ? error.message : String(error)
+        },
+        "Skipping an invalid turn-session summary index entry"
+      );
+      continue;
+    }
+    const summaryKey = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(summaryKey)) {
+      summaries.set(summaryKey, summary);
+    }
+  }
+  return [...summaries.values()].sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+}
+async function listAgentTurnSessionSummariesForConversation(conversationId) {
+  const stateAdapter = getStateAdapter();
+  const summaries = await listBoundedAgentTurnSessionSummariesForConversation(conversationId);
+  if (summaries.length > 0) {
+    return summaries;
+  }
+  return (await readAgentTurnSessionSummariesFromIndex(
+    AGENT_TURN_SESSION_INDEX_KEY,
+    stateAdapter
+  )).filter((summary) => summary.conversationId === conversationId);
+}
+async function listBoundedAgentTurnSessionSummariesForConversation(conversationId) {
+  return readAgentTurnSessionSummariesFromIndex(
+    agentTurnSessionConversationIndexKey(conversationId),
+    getStateAdapter()
+  );
+}
+async function abandonAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "abandoned",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+async function failAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "failed",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+
 // src/chat/services/turn-limit.ts
 var TurnSliceLimitExceededError = class extends Error {
   constructor(maxSlices) {
@@ -162,9 +1009,9 @@ function logSessionRecordError(error, eventName, args, attributes, message) {
     error,
     eventName,
     {
-      slackThreadId: args.logContext.threadId,
-      slackUserId: args.logContext.actorId,
-      slackChannelId: args.logContext.channelId,
+      messageConversationId: args.logContext.threadId,
+      userId: args.logContext.actorId,
+      destinationName: args.logContext.channelId,
       runId: args.logContext.runId,
       assistantUserName: args.logContext.assistantUserName,
       modelId: args.modelId
@@ -319,7 +1166,6 @@ async function completeDeliveredTurn(args) {
     sliceId: args.sliceId,
     allMessages: args.messages,
     loadedSkillNames: args.loadedSkillNames,
-    logContext: args.logContext,
     modelId: args.modelId,
     actor: args.actor,
     reasoningLevel: args.reasoningLevel,
@@ -530,6 +1376,122 @@ async function persistYieldSessionRecord(args) {
   }
 }
 
+// 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 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 coerceThreadConversationState(value) {
+  if (!isRecord(value)) {
+    return defaultConversationState();
+  }
+  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
+    }
+  };
+}
+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()
+      }
+    }
+  };
+}
+
 // src/chat/services/context-budget.ts
 var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
 var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
@@ -804,9 +1766,9 @@ async function summarizeConversationChunk(messages, conversation, context, deps)
     logWarn(
       "conversation_compaction_summary_failed",
       {
-        slackThreadId: context.threadId,
-        slackUserId: context.actorId,
-        slackChannelId: context.channelId,
+        messageConversationId: context.threadId,
+        userId: context.actorId,
+        destinationName: context.channelId,
         runId: context.runId,
         assistantUserName: botConfig.userName,
         modelId: botConfig.fastModelId
@@ -923,10 +1885,10 @@ function getConversationMessageSlackTs(message) {
 
 // src/chat/conversations/messages.ts
 import { createHash } from "crypto";
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 
 // src/chat/conversations/message-summaries.ts
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function projectConversationMessageSummaries(events) {
   for (let index = events.length - 1; index >= 0; index -= 1) {
     const data = events[index]?.data;
@@ -940,7 +1902,7 @@ async function persistConversationMessageSummaries(args) {
   const eventStore = getConversationEventStore();
   const history = await eventStore.loadMessageHistory(args.conversationId);
   const existing = history.compaction ? projectConversationMessageSummaries([history.compaction]) : [];
-  if (isDeepStrictEqual(existing, args.conversation.compactions)) {
+  if (isDeepStrictEqual2(existing, args.conversation.compactions)) {
     return;
   }
   const liveMessageIds = new Set(
@@ -1078,7 +2040,7 @@ async function persistConversationMessages(args) {
   const events = args.conversation.messages.flatMap((message) => {
     const stored = toStoredConversationMessage(message);
     const existing = existingMessages.get(stored.messageId);
-    const changed = existing !== void 0 && !isDeepStrictEqual2(toStoredConversationMessage(existing), stored);
+    const changed = existing !== void 0 && !isDeepStrictEqual3(toStoredConversationMessage(existing), stored);
     const messageEvent = existing ? changed ? [
       {
         idempotencyKey: `message:${stored.messageId}:update:${messageStateKey(stored)}`,
@@ -1372,6 +2334,9 @@ function createChannelConfigurationService(storage) {
   };
 }
 
+// src/chat/state/ttl.ts
+var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
 // src/chat/runtime/thread-state.ts
 function threadStateKey(threadId) {
   return `thread-state:${threadId}`;
@@ -1565,6 +2530,15 @@ function isPendingAuthLatestRequest(conversation, pendingAuth) {
 }
 
 export {
+  loadProjection,
+  loadConversationProjection,
+  openConversationProjection,
+  loadConnectedMcpProviders,
+  commitMessages,
+  recordMcpProviderConnected,
+  recordAuthorizationRequested,
+  recordAuthorizationCompleted,
+  recordToolExecutionStarted,
   buildDeterministicTurnId,
   buildDeterministicAssistantMessageId,
   ConversationTurnBoundaryError,
@@ -1579,6 +2553,12 @@ export {
   markTurnClosed,
   markTurnCompleted,
   markTurnFailed,
+  getAgentTurnSessionRecord,
+  getAgentTurnSessionRecordForResume,
+  recordAgentTurnSessionSummary,
+  listAgentTurnSessionSummariesForConversation,
+  abandonAgentTurnSessionRecord,
+  failAgentTurnSessionRecord,
   persistWithRetry,
   TurnSliceLimitExceededError,
   buildTurnLimitResponse,
@@ -1590,11 +2570,13 @@ export {
   persistContinuationSessionRecord,
   persistYieldSessionRecord,
   getInterruptionMarker,
+  JUNIOR_THREAD_STATE_TTL_MS,
   canReusePendingAuthLink,
   getConversationPendingAuth,
   clearPendingAuth,
   abandonReplacedPendingAuth,
   isPendingAuthLatestRequest,
+  coerceThreadConversationState,
   persistConversationMessageSummaries,
   estimateTextTokens,
   getAgentContextCompactionTriggerTokens,