@sentry/junior 0.93.0 → 0.95.0

package/dist/chunk-QL66APYJ.js

@@ -1,1377 +0,0 @@
-import {
-  getConnectedStateContext,
-  getStateAdapter
-} from "./chunk-7STN2ZSK.js";
-import {
-  getConversationStore
-} from "./chunk-NFXSLTYG.js";
-import {
-  getChatConfig
-} from "./chunk-NAPITCZ6.js";
-import {
-  parseDestination
-} from "./chunk-GHGPTPBL.js";
-import {
-  logWarn,
-  parseActor,
-  storedSlackActorSchema,
-  toStoredSlackActor
-} from "./chunk-S6QKIGRM.js";
-import {
-  isRecord
-} from "./chunk-OB42YVAE.js";
-
-// src/chat/state/session-log.ts
-import { isDeepStrictEqual } from "util";
-import { z as z2 } from "zod";
-import { actorSchema } from "@sentry/junior-plugin-api";
-
-// 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/state/session-log.ts
-var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
-var AGENT_SESSION_LOG_SCHEMA_VERSION = 2;
-var INITIAL_SESSION_ID = "session_0";
-var SESSION_ID_PREFIX = "session_";
-var STATE_STORE_LOCK_TTL_MS = 5e3;
-var schemaVersionSchema = z2.union([z2.literal(1), z2.literal(2)]);
-var piMessageAuthoritySchema = z2.union([
-  z2.literal("instruction"),
-  z2.literal("context")
-]);
-var piMessageProvenanceSchema = z2.object({
-  authority: piMessageAuthoritySchema,
-  actor: actorSchema.optional()
-}).strict();
-var unattributedContextProvenance = {
-  authority: "context"
-};
-function instructionProvenance(actor) {
-  return actor ? { authority: "instruction", actor } : { authority: "instruction" };
-}
-function isDefaultContextProvenance(provenance) {
-  return provenance.authority === "context" && !provenance.actor;
-}
-function legacyActorProvenance(actor) {
-  if (actor.teamId && actor.slackUserId && actor.platform) {
-    return instructionProvenance({
-      platform: "slack",
-      teamId: actor.teamId,
-      userId: actor.slackUserId,
-      ...actor.slackUserName ? { userName: actor.slackUserName } : {},
-      ...actor.fullName ? { fullName: actor.fullName } : {},
-      ...actor.email ? { email: actor.email } : {}
-    });
-  }
-  return unattributedContextProvenance;
-}
-var piMessageEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("pi_message"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  message: piMessageSchema,
-  provenance: piMessageProvenanceSchema.optional(),
-  // Legacy v1 latest-wins actor, decoded into provenance on read.
-  actor: storedSlackActorSchema.optional()
-});
-var projectionResetEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("projection_reset"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  messages: z2.array(piMessageSchema),
-  provenance: z2.array(piMessageProvenanceSchema).optional(),
-  // Legacy v1 latest-wins actor; v1 resets carry no per-message provenance.
-  actor: storedSlackActorSchema.optional()
-});
-var actorRecordedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("actor_recorded"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  actor: storedSlackActorSchema
-});
-var mcpProviderConnectedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("mcp_provider_connected"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  provider: z2.string().min(1)
-});
-var authorizationKindSchema = z2.union([
-  z2.literal("plugin"),
-  z2.literal("mcp")
-]);
-var authorizationRequestedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("authorization_requested"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z2.number().int().nonnegative(),
-  kind: authorizationKindSchema,
-  provider: z2.string().min(1),
-  actorId: z2.string().min(1),
-  authorizationId: z2.string().min(1),
-  delivery: z2.union([
-    z2.literal("private_link_sent"),
-    z2.literal("private_link_reused")
-  ])
-});
-var authorizationCompletedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("authorization_completed"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z2.number().int().nonnegative(),
-  kind: authorizationKindSchema,
-  provider: z2.string().min(1),
-  actorId: z2.string().min(1),
-  authorizationId: z2.string().min(1)
-});
-var transcriptRefSchema = z2.object({
-  type: z2.literal("advisor_session"),
-  parentConversationId: z2.string().min(1),
-  key: z2.string().min(1)
-});
-var toolExecutionStartedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("tool_execution_started"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z2.number().int().nonnegative(),
-  toolCallId: z2.string().min(1),
-  toolName: z2.string().min(1),
-  args: z2.unknown().optional()
-});
-var subagentStartedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("subagent_started"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  subagentInvocationId: z2.string().min(1),
-  subagentKind: z2.string().min(1),
-  parentToolCallId: z2.string().min(1).optional(),
-  parentConversationId: z2.string().min(1),
-  parentSessionId: z2.string().min(1).optional(),
-  transcriptRef: transcriptRefSchema,
-  historyMode: z2.literal("shared"),
-  createdAtMs: z2.number().int().nonnegative()
-});
-var subagentEndedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("subagent_ended"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  subagentInvocationId: z2.string().min(1),
-  outcome: z2.union([
-    z2.literal("success"),
-    z2.literal("error"),
-    z2.literal("aborted")
-  ]),
-  errorCode: z2.string().min(1).optional(),
-  transcriptEndMessageIndex: z2.number().int().nonnegative().optional(),
-  transcriptStartMessageIndex: z2.number().int().nonnegative().optional(),
-  createdAtMs: z2.number().int().nonnegative()
-});
-var sessionLogEntrySchema = z2.discriminatedUnion("type", [
-  piMessageEntrySchema,
-  projectionResetEntrySchema,
-  actorRecordedEntrySchema,
-  mcpProviderConnectedEntrySchema,
-  authorizationRequestedEntrySchema,
-  authorizationCompletedEntrySchema,
-  toolExecutionStartedEntrySchema,
-  subagentStartedEntrySchema,
-  subagentEndedEntrySchema
-]);
-function key(scope) {
-  const prefix = getChatConfig().state.keyPrefix;
-  return [
-    ...prefix ? [prefix] : [],
-    AGENT_SESSION_LOG_PREFIX,
-    scope.conversationId
-  ].join(":");
-}
-function rawKey(scope) {
-  return [AGENT_SESSION_LOG_PREFIX, scope.conversationId].join(":");
-}
-function storedRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function migrateStoredEntry(value) {
-  const record = storedRecord(value);
-  if (!record) {
-    return value;
-  }
-  const migrated = { ...record };
-  if ("requester" in migrated && !("actor" in migrated)) {
-    migrated.actor = migrated.requester;
-  }
-  delete migrated.requester;
-  if (migrated.type === "requester_recorded") {
-    migrated.type = "actor_recorded";
-  }
-  if ("requesterId" in migrated && !("actorId" in migrated)) {
-    migrated.actorId = migrated.requesterId;
-  }
-  delete migrated.requesterId;
-  return migrated;
-}
-function normalizeMessageCount(value) {
-  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-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 entrySessionId(entry) {
-  return entry.sessionId ?? INITIAL_SESSION_ID;
-}
-function isActivityEntry(entry) {
-  return entry.type === "tool_execution_started" || entry.type === "subagent_started" || entry.type === "subagent_ended";
-}
-function latestProjectionResetIndex(entries) {
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    if (entries[index]?.type === "projection_reset") {
-      return index;
-    }
-  }
-  return -1;
-}
-function currentSessionId(entries) {
-  const resetIndex = latestProjectionResetIndex(entries);
-  if (resetIndex < 0) {
-    return INITIAL_SESSION_ID;
-  }
-  return entrySessionId(entries[resetIndex]);
-}
-function nextSessionId(entries) {
-  const resetCount = entries.filter(
-    (entry) => entry.type === "projection_reset"
-  ).length;
-  return `${SESSION_ID_PREFIX}${resetCount + 1}`;
-}
-function projectionEntries(entries, sessionId) {
-  if (sessionId) {
-    const sessionEntries = [];
-    let started = false;
-    for (const entry of entries) {
-      const entryId = entrySessionId(entry);
-      if (!started) {
-        if (entryId !== sessionId) {
-          continue;
-        }
-        started = true;
-      } else if (entry.type === "projection_reset" && entryId !== sessionId) {
-        break;
-      }
-      if (entryId === sessionId) {
-        sessionEntries.push(entry);
-      }
-    }
-    return sessionEntries;
-  }
-  const resetIndex = latestProjectionResetIndex(entries);
-  const startIndex = resetIndex < 0 ? 0 : resetIndex;
-  const currentId = resetIndex < 0 ? INITIAL_SESSION_ID : entrySessionId(entries[resetIndex]);
-  return entries.slice(startIndex).filter((entry) => entrySessionId(entry) === currentId);
-}
-function piEntry(message, sessionId, provenance) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "pi_message",
-    sessionId,
-    message,
-    // Ambient context is the decode default, so only attributed/instruction
-    // provenance needs to be persisted on the entry.
-    ...provenance && !isDefaultContextProvenance(provenance) ? { provenance } : {}
-  };
-}
-function resetEntry(messages, sessionId, provenance) {
-  if (provenance.length !== messages.length) {
-    throw new Error(
-      "projection_reset provenance must align one-to-one with messages"
-    );
-  }
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "projection_reset",
-    sessionId,
-    messages,
-    provenance
-  };
-}
-function mcpProviderConnectedEntry(provider, sessionId) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "mcp_provider_connected",
-    sessionId,
-    provider
-  };
-}
-function authorizationObservationMessage(entry) {
-  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
-  return {
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
-      }
-    ],
-    timestamp: entry.createdAtMs
-  };
-}
-function authorizationRequestedEntry(args) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "authorization_requested",
-    sessionId: args.sessionId,
-    createdAtMs: args.createdAtMs,
-    kind: args.kind,
-    provider: args.provider,
-    actorId: args.actorId,
-    authorizationId: args.authorizationId,
-    delivery: args.delivery
-  };
-}
-function authorizationCompletedEntry(args) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "authorization_completed",
-    sessionId: args.sessionId,
-    createdAtMs: args.createdAtMs,
-    kind: args.kind,
-    provider: args.provider,
-    actorId: args.actorId,
-    authorizationId: args.authorizationId
-  };
-}
-function toolExecutionStartedEntry(args) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "tool_execution_started",
-    sessionId: args.sessionId,
-    createdAtMs: args.createdAtMs,
-    toolCallId: args.toolCallId,
-    toolName: args.toolName,
-    ...args.args !== void 0 ? { args: args.args } : {}
-  };
-}
-function subagentStartedEntry(args) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "subagent_started",
-    sessionId: args.sessionId,
-    subagentInvocationId: args.subagentInvocationId,
-    subagentKind: args.subagentKind,
-    ...args.parentToolCallId ? { parentToolCallId: args.parentToolCallId } : {},
-    parentConversationId: args.parentConversationId,
-    ...args.parentSessionId ? { parentSessionId: args.parentSessionId } : {},
-    transcriptRef: args.transcriptRef,
-    historyMode: args.historyMode,
-    createdAtMs: args.createdAtMs
-  };
-}
-function subagentEndedEntry(args) {
-  return {
-    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
-    type: "subagent_ended",
-    sessionId: args.sessionId,
-    subagentInvocationId: args.subagentInvocationId,
-    outcome: args.outcome,
-    ...args.errorCode ? { errorCode: args.errorCode } : {},
-    ...args.transcriptEndMessageIndex !== void 0 ? { transcriptEndMessageIndex: args.transcriptEndMessageIndex } : {},
-    ...args.transcriptStartMessageIndex !== void 0 ? { transcriptStartMessageIndex: args.transcriptStartMessageIndex } : {},
-    createdAtMs: args.createdAtMs
-  };
-}
-function decode(value) {
-  if (typeof value === "string") {
-    return decode(JSON.parse(value));
-  }
-  const parsed = sessionLogEntrySchema.safeParse(migrateStoredEntry(value));
-  if (parsed.success) {
-    return parsed.data;
-  }
-  return piEntry(piMessageSchema.parse(value), INITIAL_SESSION_ID);
-}
-function piEntryProvenance(entry) {
-  if (entry.provenance) {
-    return entry.provenance;
-  }
-  if (entry.actor) {
-    return legacyActorProvenance(entry.actor);
-  }
-  return unattributedContextProvenance;
-}
-function project(entries, sessionId) {
-  let messages = [];
-  let provenance = [];
-  for (const entry of projectionEntries(entries, sessionId)) {
-    if (entry.type === "pi_message") {
-      messages.push(entry.message);
-      provenance.push(piEntryProvenance(entry));
-      continue;
-    }
-    if (entry.type === "authorization_completed") {
-      messages.push(authorizationObservationMessage(entry));
-      provenance.push(unattributedContextProvenance);
-      continue;
-    }
-    if (entry.type === "projection_reset") {
-      const resetProvenance = entry.provenance ?? entry.messages.map(() => unattributedContextProvenance);
-      if (resetProvenance.length !== entry.messages.length) {
-        throw new Error(
-          "projection_reset provenance must align one-to-one with messages"
-        );
-      }
-      messages = [...entry.messages];
-      provenance = [...resetProvenance];
-      continue;
-    }
-  }
-  return { messages, provenance };
-}
-function actorIdentityKey(actor) {
-  if (actor.platform === "system") {
-    return `system ${actor.name}`;
-  }
-  return actor.platform === "slack" ? `slack\0${actor.teamId}\0${actor.userId}` : `${actor.platform}\0${actor.userId}`;
-}
-function instructionActors(provenance) {
-  const seen = /* @__PURE__ */ new Set();
-  const actors = [];
-  for (const entry of provenance) {
-    if (entry.authority !== "instruction" || !entry.actor) {
-      continue;
-    }
-    const identity = actorIdentityKey(entry.actor);
-    if (seen.has(identity)) {
-      continue;
-    }
-    seen.add(identity);
-    actors.push(entry.actor);
-  }
-  return actors;
-}
-function connectedMcpProviders(entries, sessionId) {
-  const providers = /* @__PURE__ */ new Set();
-  for (const entry of projectionEntries(entries, sessionId)) {
-    if (entry.type === "mcp_provider_connected") {
-      providers.add(entry.provider);
-    }
-  }
-  return [...providers].sort((left, right) => left.localeCompare(right));
-}
-function isUserMessage(message) {
-  return message.role === "user";
-}
-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 = countMatchingPrefix(
-    args.existing.messages,
-    args.nextMessages
-  );
-  const provenance = args.nextMessages.map(
-    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? unattributedContextProvenance : unattributedContextProvenance
-  );
-  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;
-}
-function commitEntries(existing, nextMessages, nextProvenance, sessionId, entries) {
-  const matchingPrefix = countMatchingPrefix(existing.messages, nextMessages);
-  if (matchingPrefix === existing.messages.length) {
-    const newMessages = nextMessages.slice(matchingPrefix);
-    const newProvenance = nextProvenance.slice(matchingPrefix);
-    return {
-      entries: newMessages.map(
-        (message, index) => piEntry(message, sessionId, newProvenance[index])
-      ),
-      sessionId
-    };
-  }
-  const resetSessionId = nextSessionId(entries);
-  return {
-    entries: [resetEntry(nextMessages, resetSessionId, nextProvenance)],
-    sessionId: resetSessionId
-  };
-}
-function redisStore(redisStateAdapter) {
-  const client = redisStateAdapter.getClient();
-  return {
-    async append({ entries, scope, ttlMs }) {
-      const listKey = key(scope);
-      if (entries.length > 0) {
-        await client.rPush(
-          listKey,
-          entries.map((entry) => JSON.stringify(entry))
-        );
-      }
-      await client.pExpire(listKey, Math.max(1, ttlMs));
-    },
-    async read(scope) {
-      const values = await client.lRange(key(scope), 0, -1);
-      return values.map(decode);
-    }
-  };
-}
-function stateStore() {
-  const stateAdapter = getStateAdapter();
-  return {
-    async append({ entries, scope, ttlMs }) {
-      const listKey = rawKey(scope);
-      const lock = await stateAdapter.acquireLock(
-        `${listKey}:commit`,
-        STATE_STORE_LOCK_TTL_MS
-      );
-      if (!lock) {
-        throw new Error("Could not acquire session log commit lock");
-      }
-      try {
-        const existingValue = await stateAdapter.get(listKey);
-        const existingEntries = Array.isArray(existingValue) ? existingValue.map(decode) : (await stateAdapter.getList(listKey)).map(decode);
-        await stateAdapter.set(
-          listKey,
-          [...existingEntries, ...entries],
-          Math.max(1, ttlMs)
-        );
-      } finally {
-        await stateAdapter.releaseLock(lock);
-      }
-    },
-    async read(scope) {
-      const listKey = rawKey(scope);
-      const value = await stateAdapter.get(listKey);
-      if (Array.isArray(value)) {
-        return value.map(decode);
-      }
-      const values = await stateAdapter.getList(listKey);
-      return values.map(decode);
-    }
-  };
-}
-async function defaultStore() {
-  const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
-  if (redisStateAdapter) {
-    return redisStore(redisStateAdapter);
-  }
-  await stateAdapter.connect();
-  return stateStore();
-}
-async function loadEntries(args) {
-  const store = args.store ?? await defaultStore();
-  return (await store.read(args)).map(decode);
-}
-async function loadActivityEntries(args) {
-  const entries = await loadEntries(args);
-  return projectionEntries(entries, args.sessionId).filter(isActivityEntry);
-}
-async function loadMessagesWithProvenance(args) {
-  const messageCount = normalizeMessageCount(args.messageCount);
-  if (messageCount === 0) {
-    return { messages: [], provenance: [] };
-  }
-  const projection = project(await loadEntries(args), args.sessionId);
-  return projection.messages.length >= messageCount ? {
-    messages: projection.messages.slice(0, messageCount),
-    provenance: projection.provenance.slice(0, messageCount)
-  } : void 0;
-}
-async function loadProjection(args) {
-  return project(await loadEntries(args), args.sessionId).messages;
-}
-async function loadProjectionWithProvenance(args) {
-  return project(await loadEntries(args), args.sessionId);
-}
-async function loadConnectedMcpProviders(args) {
-  return connectedMcpProviders(await loadEntries(args));
-}
-async function recordMcpProviderConnected(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = currentSessionId(entries);
-  if (connectedMcpProviders(entries).includes(args.provider)) {
-    return;
-  }
-  await store.append({
-    scope: args,
-    entries: [mcpProviderConnectedEntry(args.provider, sessionId)],
-    ttlMs: args.ttlMs
-  });
-}
-async function recordAuthorizationRequested(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = currentSessionId(entries);
-  if (projectionEntries(entries).some(
-    (entry) => entry.type === "authorization_requested" && entry.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await store.append({
-    scope: args,
-    entries: [
-      authorizationRequestedEntry({
-        createdAtMs: Date.now(),
-        kind: args.kind,
-        sessionId,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId,
-        delivery: args.delivery
-      })
-    ],
-    ttlMs: args.ttlMs
-  });
-}
-async function recordAuthorizationCompleted(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = currentSessionId(entries);
-  if (projectionEntries(entries).some(
-    (entry) => entry.type === "authorization_completed" && entry.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await store.append({
-    scope: args,
-    entries: [
-      authorizationCompletedEntry({
-        createdAtMs: Date.now(),
-        kind: args.kind,
-        sessionId,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId
-      })
-    ],
-    ttlMs: args.ttlMs
-  });
-}
-async function recordToolExecutionStarted(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = args.sessionId ?? currentSessionId(entries);
-  await store.append({
-    scope: args,
-    entries: [
-      toolExecutionStartedEntry({
-        args: args.args,
-        createdAtMs: args.createdAtMs ?? Date.now(),
-        sessionId,
-        toolCallId: args.toolCallId,
-        toolName: args.toolName
-      })
-    ],
-    ttlMs: args.ttlMs
-  });
-}
-async function recordSubagentStarted(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = args.sessionId ?? currentSessionId(entries);
-  await store.append({
-    scope: args,
-    entries: [
-      subagentStartedEntry({
-        createdAtMs: args.createdAtMs ?? Date.now(),
-        historyMode: args.historyMode,
-        parentConversationId: args.parentConversationId,
-        parentSessionId: args.parentSessionId,
-        parentToolCallId: args.parentToolCallId,
-        sessionId,
-        subagentInvocationId: args.subagentInvocationId,
-        subagentKind: args.subagentKind,
-        transcriptRef: args.transcriptRef
-      })
-    ],
-    ttlMs: args.ttlMs
-  });
-}
-async function recordSubagentEnded(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const sessionId = args.sessionId ?? currentSessionId(entries);
-  await store.append({
-    scope: args,
-    entries: [
-      subagentEndedEntry({
-        createdAtMs: args.createdAtMs ?? Date.now(),
-        errorCode: args.errorCode,
-        outcome: args.outcome,
-        sessionId,
-        subagentInvocationId: args.subagentInvocationId,
-        transcriptEndMessageIndex: args.transcriptEndMessageIndex,
-        transcriptStartMessageIndex: args.transcriptStartMessageIndex
-      })
-    ],
-    ttlMs: args.ttlMs
-  });
-}
-async function commitMessages(args) {
-  const store = args.store ?? await defaultStore();
-  const entries = await store.read(args);
-  const existingProjection = project(entries);
-  const currentId = currentSessionId(entries);
-  const nextProvenance = resolveCommitProvenance({
-    existing: existingProjection,
-    nextMessages: args.messages,
-    ...args.provenance ? { explicitProvenance: args.provenance } : {},
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
-    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
-  });
-  const commit = commitEntries(
-    existingProjection,
-    args.messages,
-    nextProvenance,
-    currentId,
-    entries
-  );
-  await store.append({
-    scope: args,
-    entries: commit.entries,
-    ttlMs: args.ttlMs
-  });
-  return {
-    sessionId: commit.sessionId,
-    provenance: nextProvenance
-  };
-}
-function instructionProvenanceFor(actor) {
-  return instructionProvenance(actor);
-}
-var contextProvenance = unattributedContextProvenance;
-function parseStoredMessageProvenance(value, expectedLength) {
-  if (value === void 0) {
-    return Array.from(
-      { length: expectedLength },
-      () => unattributedContextProvenance
-    );
-  }
-  const parsed = z2.array(piMessageProvenanceSchema).safeParse(value);
-  if (!parsed.success || parsed.data.length !== expectedLength) {
-    return void 0;
-  }
-  return parsed.data;
-}
-
-// src/chat/state/turn-session.ts
-import { THREAD_STATE_TTL_MS } from "chat";
-import {
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-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;
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function agentTurnSessionConversationIndexKey(conversationId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
-}
-function toFiniteNonNegativeNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
-}
-function toNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
-}
-function parseAgentTurnUsage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const usage = {};
-  for (const field of [
-    "inputTokens",
-    "outputTokens",
-    "cachedInputTokens",
-    "cacheCreationTokens",
-    "totalTokens"
-  ]) {
-    const count = toFiniteNonNegativeNumber(value[field]);
-    if (count !== void 0) {
-      usage[field] = count;
-    }
-  }
-  return Object.keys(usage).length > 0 ? usage : void 0;
-}
-function parseStoredRecord(value) {
-  if (isRecord(value)) {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parseAgentTurnSessionStatus(parsed) {
-  const status = parsed.state;
-  if (status === "running" || status === "awaiting_resume" || status === "completed" || status === "failed" || status === "abandoned") {
-    return status;
-  }
-  return void 0;
-}
-function parseAgentTurnSurface(value) {
-  return value === "slack" || value === "api" || value === "scheduler" || value === "internal" ? value : void 0;
-}
-function conversationExecutionFromSummary(summary) {
-  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
-  return {
-    status,
-    runId: summary.sessionId,
-    updatedAtMs: summary.updatedAtMs
-  };
-}
-function parseSource(value) {
-  const result = sourceSchema.safeParse(value);
-  return result.success ? result.data : void 0;
-}
-function sessionLogActor(actor) {
-  return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
-}
-function parseAgentTurnSessionFields(parsed) {
-  const status = parseAgentTurnSessionStatus(parsed);
-  if (!status) {
-    return void 0;
-  }
-  const channelName = typeof parsed.channelName === "string" && parsed.channelName.trim() ? parsed.channelName.trim() : void 0;
-  const conversationId = parsed.conversationId;
-  const sessionId = parsed.sessionId;
-  const sliceId = toFiniteNonNegativeNumber(parsed.sliceId);
-  const version = toFiniteNonNegativeNumber(parsed.version);
-  const updatedAtMs = toFiniteNonNegativeNumber(parsed.updatedAtMs);
-  const cumulativeDurationMs = toFiniteNonNegativeNumber(parsed.cumulativeDurationMs) ?? 0;
-  const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
-  const lastProgressAtMs = toFiniteNonNegativeNumber(parsed.lastProgressAtMs);
-  const logSessionId = typeof parsed.logSessionId === "string" ? parsed.logSessionId : void 0;
-  const actorValue = parsed.actor !== void 0 ? parsed.actor : parsed.requester;
-  const actor = actorValue === void 0 ? void 0 : parseActor(actorValue);
-  const startedAtMs = toFiniteNonNegativeNumber(parsed.startedAtMs);
-  const surface = parseAgentTurnSurface(parsed.surface);
-  const turnStartMessageIndex = toNonNegativeInteger(
-    parsed.turnStartMessageIndex
-  );
-  const destination = parsed.destination === void 0 ? void 0 : parseDestination(parsed.destination);
-  const source = parsed.source === void 0 ? void 0 : parseSource(parsed.source);
-  if (typeof conversationId !== "string" || typeof sessionId !== "string" || sliceId === void 0 || version === void 0 || updatedAtMs === void 0 || parsed.destination !== void 0 && !destination || parsed.source !== void 0 && !source || actorValue !== void 0 && !actor) {
-    return void 0;
-  }
-  return {
-    version,
-    ...channelName ? { channelName } : {},
-    conversationId,
-    sessionId,
-    sliceId,
-    state: status,
-    startedAtMs: startedAtMs ?? updatedAtMs,
-    lastProgressAtMs: lastProgressAtMs ?? updatedAtMs,
-    updatedAtMs,
-    cumulativeDurationMs,
-    ...logSessionId ? { logSessionId } : {},
-    ...cumulativeUsage ? { cumulativeUsage } : {},
-    ...destination ? { destination } : {},
-    ...source ? { source } : {},
-    ...actor ? { actor } : {},
-    ...Array.isArray(parsed.loadedSkillNames) ? {
-      loadedSkillNames: parsed.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" || parsed.resumeReason === "yield" ? { resumeReason: parsed.resumeReason } : {},
-    ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-    ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {},
-    ...surface ? { surface } : {},
-    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
-    ...typeof parsed.traceId === "string" ? { traceId: parsed.traceId } : {}
-  };
-}
-function parseAgentTurnSessionRecord(value) {
-  const parsed = parseStoredRecord(value);
-  if (!parsed) {
-    return void 0;
-  }
-  const fields = parseAgentTurnSessionFields(parsed);
-  const committedMessageCount = toFiniteNonNegativeNumber(
-    parsed.committedMessageCount
-  );
-  if (!fields || committedMessageCount === void 0) {
-    return void 0;
-  }
-  const committedMessageProvenance = parseStoredMessageProvenance(
-    parsed.committedMessageProvenance,
-    committedMessageCount
-  );
-  if (!committedMessageProvenance) {
-    return void 0;
-  }
-  return {
-    ...fields,
-    committedMessageCount,
-    committedMessageProvenance
-  };
-}
-function parseAgentTurnSessionSummary(value) {
-  const stored = parseStoredRecord(value);
-  if (!stored) {
-    return void 0;
-  }
-  const parsed = parseAgentTurnSessionFields(stored);
-  if (!parsed) {
-    return void 0;
-  }
-  const {
-    errorMessage: _errorMessage,
-    logSessionId: _logSessionId,
-    turnStartMessageIndex: _turnStartMessageIndex,
-    ...summary
-  } = parsed;
-  return summary;
-}
-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;
-  try {
-    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,
-      actor: sessionLogActor(args.summary.actor),
-      source,
-      updatedAtMs: args.nowMs,
-      visibility: args.destinationVisibility
-    });
-  } catch (error) {
-    logWarn(
-      "conversation_activity_metadata_update_failed",
-      { conversationId: args.summary.conversationId },
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to update conversation activity metadata"
-    );
-  }
-}
-function materializePiProjection(committedMessageCount, includeProjectionTail, sessionMessages, sessionProjection) {
-  if (committedMessageCount === 0) {
-    return sessionProjection;
-  }
-  if (includeProjectionTail && sessionProjection.messages.length >= committedMessageCount) {
-    return sessionProjection;
-  }
-  if (sessionMessages) {
-    return sessionMessages;
-  }
-  if (sessionProjection.messages.length >= committedMessageCount) {
-    return {
-      messages: sessionProjection.messages.slice(0, committedMessageCount),
-      provenance: sessionProjection.provenance.slice(0, committedMessageCount)
-    };
-  }
-  return void 0;
-}
-function materializeAgentTurnSessionRecord(stored, piProjection) {
-  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: piProjection.messages,
-    piMessageProvenance: piProjection.provenance,
-    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.actor ? { actor: stored.actor } : {},
-    ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
-    ...stored.surface ? { surface: stored.surface } : {},
-    ...stored.traceId ? { traceId: stored.traceId } : {},
-    ...stored.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: stored.turnStartMessageIndex } : {}
-  };
-}
-async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return parseAgentTurnSessionRecord(value);
-}
-async function getAgentTurnSessionRecord(conversationId, sessionId) {
-  const parsed = await getStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId
-  );
-  if (!parsed) {
-    return void 0;
-  }
-  const sessionMessages = await loadMessagesWithProvenance({
-    conversationId,
-    messageCount: parsed.committedMessageCount,
-    ...parsed.logSessionId ? { sessionId: parsed.logSessionId } : {}
-  });
-  const sessionProjection = await loadProjectionWithProvenance({
-    conversationId,
-    ...parsed.logSessionId ? { sessionId: parsed.logSessionId } : {}
-  });
-  const piProjection = materializePiProjection(
-    parsed.committedMessageCount,
-    parsed.state === "running" || parsed.state === "awaiting_resume",
-    sessionMessages,
-    sessionProjection
-  );
-  if (!piProjection) {
-    return void 0;
-  }
-  return materializeAgentTurnSessionRecord(parsed, piProjection);
-}
-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,
-    committedMessageCount: args.committedMessageCount,
-    committedMessageProvenance: args.committedMessageProvenance,
-    ...args.logSessionId ? { logSessionId: args.logSessionId } : {},
-    cumulativeDurationMs: args.cumulativeDurationMs,
-    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
-    ...args.destination ? { destination: args.destination } : {},
-    ...args.source ? { source: args.source } : {},
-    ...args.actor ? { actor: args.actor } : {},
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {},
-    ...args.surface ? { surface: args.surface } : {},
-    ...args.traceId ? { traceId: args.traceId } : {},
-    ...args.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.turnStartMessageIndex } : {}
-  };
-}
-async function setStoredRecord(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  await stateAdapter.set(
-    agentTurnSessionKey(args.record.conversationId, args.record.sessionId),
-    args.record,
-    args.ttlMs
-  );
-  const {
-    committedMessageCount: _committedMessageCount,
-    committedMessageProvenance: _committedMessageProvenance,
-    errorMessage: _errorMessage,
-    logSessionId: _logSessionId,
-    turnStartMessageIndex: _turnStartMessageIndex,
-    ...summary
-  } = args.record;
-  await appendAgentTurnSessionSummary(summary, args.ttlMs);
-  await recordConversationActivityMetadata({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    nowMs: Date.now(),
-    summary
-  });
-  return materializeAgentTurnSessionRecord(args.record, {
-    messages: [...args.piMessages],
-    provenance: [...args.piMessageProvenance]
-  });
-}
-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,
-    record: buildStoredRecord({
-      conversationId: args.existing.conversationId,
-      sessionId: args.existing.sessionId,
-      sliceId: args.existing.sliceId,
-      state: args.state,
-      committedMessageCount: parsed.committedMessageCount,
-      committedMessageProvenance: parsed.committedMessageProvenance,
-      ...parsed.channelName ? { channelName: parsed.channelName } : {},
-      startedAtMs: parsed.startedAtMs,
-      lastProgressAtMs: parsed.lastProgressAtMs,
-      previousVersion: parsed.version,
-      ...parsed.logSessionId ? { logSessionId: parsed.logSessionId } : {},
-      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.actor ? { actor: args.existing.actor } : {},
-      ...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.existing.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.existing.turnStartMessageIndex } : {},
-      ...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 } : {},
-    ttlMs
-  });
-  return await setStoredRecord({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    piMessages: args.piMessages,
-    piMessageProvenance: commit.provenance,
-    ttlMs,
-    record: buildStoredRecord({
-      committedMessageProvenance: commit.provenance,
-      ...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 } : {},
-      committedMessageCount: args.piMessages.length,
-      logSessionId: commit.sessionId,
-      previousVersion: existingRecord?.version,
-      cumulativeDurationMs: toFiniteNonNegativeNumber(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 } : {},
-      ...args.actor ?? existingRecord?.actor ? { actor: args.actor ?? existingRecord?.actor } : {},
-      ...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 } : {},
-      ...(args.turnStartMessageIndex ?? existingRecord?.turnStartMessageIndex) !== void 0 ? {
-        turnStartMessageIndex: args.turnStartMessageIndex ?? existingRecord?.turnStartMessageIndex
-      } : {}
-    })
-  });
-}
-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: toFiniteNonNegativeNumber(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 } : {},
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
-    ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
-  };
-  await appendAgentTurnSessionSummary(summary, ttlMs);
-  await recordConversationActivityMetadata({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    nowMs,
-    summary
-  });
-}
-async function readAgentTurnSessionSummariesFromIndex(key2) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const values = await stateAdapter.getList(key2);
-  const summaries = /* @__PURE__ */ new Map();
-  for (const value of [...values].reverse()) {
-    const summary = parseAgentTurnSessionSummary(value);
-    if (!summary) {
-      continue;
-    }
-    const key3 = `${summary.conversationId}:${summary.sessionId}`;
-    if (!summaries.has(key3)) {
-      summaries.set(key3, summary);
-    }
-  }
-  return [...summaries.values()].sort(
-    (left, right) => right.updatedAtMs - left.updatedAtMs
-  );
-}
-async function listAgentTurnSessionSummariesForConversation(conversationId) {
-  const summaries = await readAgentTurnSessionSummariesFromIndex(
-    agentTurnSessionConversationIndexKey(conversationId)
-  );
-  if (summaries.length > 0) {
-    return summaries;
-  }
-  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).filter((summary) => summary.conversationId === conversationId);
-}
-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/interruption-marker.ts
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-function getInterruptionMarker() {
-  return INTERRUPTED_MARKER;
-}
-
-export {
-  piContentMessageSchema,
-  instructionActors,
-  loadActivityEntries,
-  loadProjection,
-  loadProjectionWithProvenance,
-  loadConnectedMcpProviders,
-  recordMcpProviderConnected,
-  recordAuthorizationRequested,
-  recordAuthorizationCompleted,
-  recordToolExecutionStarted,
-  recordSubagentStarted,
-  recordSubagentEnded,
-  commitMessages,
-  instructionProvenanceFor,
-  contextProvenance,
-  getAgentTurnSessionRecord,
-  upsertAgentTurnSessionRecord,
-  recordAgentTurnSessionSummary,
-  listAgentTurnSessionSummariesForConversation,
-  abandonAgentTurnSessionRecord,
-  failAgentTurnSessionRecord,
-  getInterruptionMarker
-};