@sentry/junior 0.105.0 → 0.107.0

package/dist/{chunk-BCULHGZK.js → chunk-NVOTGWYX.js}

@@ -1,21 +1,18 @@
 import {
   getChatConfig,
-  getConnectedStateContext,
-  getStateAdapter,
   modelProfileSchema
-} from "./chunk-M3UAVLEN.js";
+} from "./chunk-SS67LUOK.js";
 import {
   juniorDestinations,
   timestamptz
-} from "./chunk-FXFQNHRU.js";
+} from "./chunk-VFUK3X5B.js";
 import {
   parseDestination,
   sameDestination
 } from "./chunk-B7PUBQQM.js";
 import {
-  normalizeIdentityEmail,
-  storedSlackActorSchema
-} from "./chunk-AEWZ7F65.js";
+  normalizeIdentityEmail
+} from "./chunk-O24R4DCK.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -25,15 +22,18 @@ import { and as and2, asc, desc, eq as eq2, isNull, sql as sql5 } from "drizzle-
 import { randomUUID } from "crypto";
 import { and, eq, sql as sql4 } from "drizzle-orm";
 
-// src/db/schema/agent-steps.ts
+// src/db/schema/conversation-events.ts
 import {
+  foreignKey,
   index as index3,
   integer as integer2,
   jsonb as jsonb3,
   pgTable as pgTable4,
   primaryKey,
-  text as text4
+  text as text4,
+  uniqueIndex as uniqueIndex3
 } from "drizzle-orm/pg-core";
+import { sql as sql3 } from "drizzle-orm";
 
 // src/db/schema/conversations.ts
 import { sql as sql2 } from "drizzle-orm";
@@ -183,62 +183,50 @@ var juniorConversations = pgTable3(
   ]
 );
 
-// src/db/schema/agent-steps.ts
-var juniorAgentSteps = pgTable4(
-  "junior_agent_steps",
+// src/db/schema/conversation-events.ts
+var juniorConversationEvents = pgTable4(
+  "junior_conversation_events",
   {
-    conversationId: text4("conversation_id").notNull().references(() => juniorConversations.conversationId),
+    conversationId: text4("conversation_id").notNull(),
     seq: integer2("seq").notNull(),
-    contextEpoch: integer2("context_epoch").notNull(),
+    historyVersion: integer2("history_version").notNull(),
+    schemaVersion: integer2("schema_version").default(1).notNull(),
+    idempotencyKey: text4("idempotency_key"),
     type: text4("type").notNull(),
-    role: text4("role"),
     payload: jsonb3("payload").$type().notNull(),
     createdAt: timestamptz("created_at").notNull()
   },
   (table) => [
-    primaryKey({ columns: [table.conversationId, table.seq] }),
-    index3("junior_agent_steps_epoch_idx").on(
+    primaryKey({
+      name: "junior_conversation_events_conversation_id_seq_pk",
+      columns: [table.conversationId, table.seq]
+    }),
+    foreignKey({
+      name: "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk",
+      columns: [table.conversationId],
+      foreignColumns: [juniorConversations.conversationId]
+    }),
+    index3("junior_conversation_events_history_version_idx").on(
       table.conversationId,
-      table.contextEpoch,
+      table.historyVersion,
       table.seq
-    )
-  ]
-);
-
-// src/db/schema/conversation-messages.ts
-import { sql as sql3 } from "drizzle-orm";
-import { index as index4, jsonb as jsonb4, pgTable as pgTable5, primaryKey as primaryKey2, text as text5 } from "drizzle-orm/pg-core";
-var juniorConversationMessages = pgTable5(
-  "junior_conversation_messages",
-  {
-    conversationId: text5("conversation_id").notNull().references(() => juniorConversations.conversationId),
-    messageId: text5("message_id").notNull(),
-    role: text5("role").$type().notNull(),
-    authorIdentityId: text5("author_identity_id").references(
-      () => juniorIdentities.id
     ),
-    text: text5("text").notNull(),
-    meta: jsonb4("meta").$type(),
-    repliedAt: timestamptz("replied_at"),
-    createdAt: timestamptz("created_at").notNull()
-  },
-  (table) => [
-    primaryKey2({ columns: [table.conversationId, table.messageId] }),
-    index4("junior_conversation_messages_activity_idx").on(
+    index3("junior_conversation_events_type_idx").on(
       table.conversationId,
-      table.createdAt
+      table.type,
+      table.seq
     ),
-    index4("junior_conversation_messages_search_idx").using(
-      "gin",
-      sql3`to_tsvector('english', ${table.text})`
+    index3("junior_conversation_events_message_search_idx").using("gin", sql3`to_tsvector('english', ${table.payload}->>'text')`).where(sql3`${table.type} = 'message'`),
+    uniqueIndex3("junior_conversation_events_idempotency_idx").on(
+      table.conversationId,
+      table.idempotencyKey
     )
   ]
 );
 
 // src/db/schema.ts
 var juniorSqlSchema = {
-  juniorAgentSteps,
-  juniorConversationMessages,
+  juniorConversationEvents,
   juniorConversations,
   juniorDestinations,
   juniorIdentities,
@@ -536,6 +524,11 @@ function conversationFromRow(readRow) {
     lastActivityAtMs: requiredMsFromDate(row.lastActivityAt),
     updatedAtMs: requiredMsFromDate(row.updatedAt),
     execution,
+    ...row.parentConversationId ? {
+      lineage: {
+        parentConversationId: row.parentConversationId
+      }
+    } : {},
     ...destination ? { destination } : {},
     ...actor ? { actor } : {},
     ...msFromDate(row.archivedAt) !== void 0 ? { archivedAtMs: msFromDate(row.archivedAt) } : {},
@@ -715,31 +708,6 @@ var SqlStore = class {
       }
     });
   }
-  async ensureChildConversation(args) {
-    const at = dateFromMs2(args.nowMs ?? now());
-    await this.executor.db().insert(juniorConversations).values({
-      conversationId: args.parentConversationId,
-      schemaVersion: 1,
-      createdAt: at,
-      lastActivityAt: at,
-      updatedAt: at,
-      executionStatus: "idle"
-    }).onConflictDoNothing({ target: juniorConversations.conversationId });
-    await this.executor.db().insert(juniorConversations).values({
-      conversationId: args.conversationId,
-      schemaVersion: 1,
-      parentConversationId: args.parentConversationId,
-      createdAt: at,
-      lastActivityAt: at,
-      updatedAt: at,
-      executionStatus: "idle"
-    }).onConflictDoUpdate({
-      target: juniorConversations.conversationId,
-      set: {
-        parentConversationId: sql5`coalesce(${juniorConversations.parentConversationId}, excluded.parent_conversation_id)`
-      }
-    });
-  }
   /** Copy one conversation record and retained metrics into SQL during backfill. */
   async backfillConversation(sourceConversation, metrics) {
     const { visibility: _visibility, ...conversation } = sourceConversation;
@@ -904,7 +872,8 @@ var SqlStore = class {
       executionStatus: conversation.execution.status,
       runId: conversation.execution.runId ?? null,
       lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastCheckpointAtMs),
-      lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs)
+      lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs),
+      parentConversationId: conversation.lineage?.parentConversationId ?? null
     }).onConflictDoUpdate({
       target: juniorConversations.conversationId,
       set: {
@@ -971,99 +940,115 @@ function createSqlStore(executor) {
 }
 
 // src/chat/conversations/sql/history.ts
-import { and as and3, asc as asc2, eq as eq3, isNotNull, sql as sql7 } from "drizzle-orm";
+import {
+  and as and3,
+  asc as asc2,
+  desc as desc2,
+  eq as eq3,
+  gte,
+  inArray,
+  isNotNull,
+  lte,
+  sql as sql7
+} from "drizzle-orm";
 
 // src/chat/conversations/history.ts
-import { z as z3 } from "zod";
-
-// 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
-import { isDeepStrictEqual } from "util";
 import { z as z2 } from "zod";
+
+// src/chat/conversations/provenance.ts
 import { actorSchema } from "@sentry/junior-plugin-api";
-var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
-var AGENT_SESSION_LOG_SCHEMA_VERSION = 2;
-var INITIAL_SESSION_ID = "session_0";
-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")
+import { z } from "zod";
+var conversationMessageAuthoritySchema = z.union([
+  z.literal("instruction"),
+  z.literal("context")
 ]);
-var piMessageProvenanceSchema = z2.object({
-  authority: piMessageAuthoritySchema,
+var conversationMessageProvenanceSchema = z.object({
+  authority: conversationMessageAuthoritySchema,
   actor: actorSchema.optional()
 }).strict();
-var unattributedContextProvenance = {
-  authority: "context"
-};
-function instructionProvenance(actor) {
+function instructionProvenanceFor(actor) {
   return actor ? { authority: "instruction", actor } : { authority: "instruction" };
 }
-function isDefaultContextProvenance(provenance) {
-  return provenance.authority === "context" && !provenance.actor;
+var contextProvenance = {
+  authority: "context"
+};
+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 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 } : {}
-    });
+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 unattributedContextProvenance;
+  return actors;
 }
-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()
+
+// src/chat/conversations/history.ts
+var handoffModelProfileSchema = modelProfileSchema.refine(
+  (profile) => profile !== "standard",
+  "handoff profile must not be standard"
+);
+var conversationAgentStepPayloadSchema = z2.object({ role: z2.string() }).passthrough().transform((value) => value);
+var conversationMessageDataSchema = z2.object({
+  message: conversationAgentStepPayloadSchema,
+  provenance: conversationMessageProvenanceSchema.optional()
+}).strict();
+var agentStepEventDataSchema = conversationMessageDataSchema.extend({
+  type: z2.literal("agent_step")
 });
-var actorRecordedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
-  type: z2.literal("actor_recorded"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
-  actor: storedSlackActorSchema
+var replacementHistoryMessageSchema = conversationMessageDataSchema.extend({
+  // Preserve the copied message's position when a turn resumes. Synthetic
+  // summary and handoff messages have no source event.
+  sourceEventSeq: z2.number().int().nonnegative().optional()
 });
-var mcpProviderConnectedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
+var replacementHistorySchema = z2.array(replacementHistoryMessageSchema);
+var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("handoff"),
+    modelProfile: handoffModelProfileSchema,
+    modelId: z2.string().min(1),
+    triggeringToolCallId: z2.string().min(1).optional(),
+    replacementHistory: replacementHistorySchema
+  }).strict(),
+  z2.object({
+    type: z2.literal("compaction"),
+    modelProfile: modelProfileSchema,
+    modelId: z2.string().min(1),
+    replacementHistory: replacementHistorySchema
+  }).strict()
+]);
+var legacyRollbackEventDataSchema = z2.object({
+  type: z2.literal("rollback"),
+  modelProfile: modelProfileSchema,
+  modelId: z2.string().min(1),
+  replacementHistory: replacementHistorySchema
+}).strict();
+var historyReplacementSchema = z2.object({
+  data: historyReplacementEventDataSchema,
+  createdAtMs: z2.number().finite()
+}).strict();
+var mcpProviderConnectedEventDataSchema = z2.object({
   type: z2.literal("mcp_provider_connected"),
-  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
   provider: z2.string().min(1)
-});
+}).strict();
 var authorizationKindSchema = z2.union([
   z2.literal("plugin"),
   z2.literal("mcp")
 ]);
-var authorizationRequestedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
+var authorizationRequestedEventDataSchema = z2.object({
   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),
@@ -1072,366 +1057,184 @@ var authorizationRequestedEntrySchema = z2.object({
     z2.literal("private_link_sent"),
     z2.literal("private_link_reused")
   ])
-});
-var authorizationCompletedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
+}).strict();
+var authorizationCompletedEventDataSchema = z2.object({
   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,
+}).strict();
+var toolExecutionStartedEventDataSchema = z2.object({
   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()
+  toolName: z2.string().min(1)
+}).strict();
+var conversationMessageRoleSchema = z2.union([
+  z2.literal("user"),
+  z2.literal("assistant"),
+  z2.literal("system")
+]);
+var messageEventDataSchema = z2.object({
+  type: z2.literal("message"),
+  messageId: z2.string().min(1),
+  role: conversationMessageRoleSchema,
+  text: z2.string(),
+  authorIdentityId: z2.string().min(1).optional(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var messageUpdatedEventDataSchema = messageEventDataSchema.extend({
+  type: z2.literal("message_updated")
 });
-var subagentStartedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
+var messageHandledEventDataSchema = z2.object({
+  type: z2.literal("message_handled"),
+  messageId: z2.string().min(1)
+}).strict();
+var messagesSummarizedEventDataSchema = z2.object({
+  type: z2.literal("messages_summarized"),
+  historyFromSeq: z2.number().int().nonnegative(),
+  compactions: z2.array(
+    z2.object({
+      coveredMessageCount: z2.number().int().nonnegative(),
+      createdAtMs: z2.number(),
+      id: z2.string().min(1),
+      summary: z2.string()
+    }).strict()
+  )
+}).strict();
+var conversationTurnSurfaceSchema = z2.enum([
+  "slack",
+  "api",
+  "scheduler",
+  "internal"
+]);
+var conversationTurnFailureCodeSchema = z2.enum([
+  "agent_run_failed",
+  "delivery_failed",
+  "model_execution_failed",
+  "persistence_failed"
+]);
+var turnStartedEventDataSchema = z2.object({
+  type: z2.literal("turn_started"),
+  turnId: z2.string().min(1),
+  inputMessageIds: z2.array(z2.string().min(1)).min(1),
+  surface: conversationTurnSurfaceSchema
+}).strict().refine(
+  (data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length,
+  "turn input message ids must be unique"
+);
+var turnCompletedEventDataSchema = z2.object({
+  type: z2.literal("turn_completed"),
+  turnId: z2.string().min(1),
+  outcome: z2.enum(["success", "no_reply"])
+}).strict();
+var turnFailedEventDataSchema = z2.object({
+  type: z2.literal("turn_failed"),
+  turnId: z2.string().min(1),
+  failureCode: conversationTurnFailureCodeSchema,
+  eventId: z2.string().regex(/^[a-f0-9]{32}$/i).optional()
+}).strict();
+var subagentStartedEventDataSchema = z2.object({
   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"),
   modelId: z2.string().min(1).optional(),
+  parentToolCallId: z2.string().min(1).optional(),
   reasoningLevel: z2.string().min(1).optional(),
-  createdAtMs: z2.number().int().nonnegative()
-});
-var subagentEndedEntrySchema = z2.object({
-  schemaVersion: schemaVersionSchema,
+  childConversationId: z2.string().min(1)
+}).strict();
+var subagentEndedEventDataSchema = z2.object({
   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 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 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 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 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 readSessionLogEntries(args) {
-  return loadEntries(args);
-}
-function instructionProvenanceFor(actor) {
-  return instructionProvenance(actor);
-}
-var contextProvenance = unattributedContextProvenance;
-
-// src/chat/conversations/history.ts
-var handoffModelProfileSchema = modelProfileSchema.refine(
-  (profile) => profile !== "standard",
-  "handoff profile must not be standard"
-);
-var piMessageStepEntrySchema = z3.object({
-  type: z3.literal("pi_message"),
-  schemaVersion: z3.number().int().optional(),
-  message: piMessageSchema,
-  provenance: piMessageProvenanceSchema.optional()
-});
-var contextEpochStartedEntrySchema = z3.union([
-  z3.object({
-    type: z3.literal("context_epoch_started"),
-    reason: z3.literal("initial"),
-    modelProfile: z3.literal("standard"),
-    modelId: z3.string().min(1)
-  }).strict(),
-  z3.object({
-    type: z3.literal("context_epoch_started"),
-    reason: z3.literal("handoff"),
-    modelProfile: handoffModelProfileSchema,
-    modelId: z3.string().min(1)
-  }).strict(),
-  z3.object({
-    type: z3.literal("context_epoch_started"),
-    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
-    // TODO(v0.97.0): Remove support for deployed compaction/rollback markers
-    // without model bindings after those rows pass the retention horizon.
-    modelProfile: z3.undefined().optional(),
-    modelId: z3.undefined().optional()
-  }).strict(),
-  z3.object({
-    type: z3.literal("context_epoch_started"),
-    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1)
-  }).strict()
-]);
-var piMessageStepSchema = z3.object({
-  message: piMessageSchema,
-  createdAtMs: z3.number().finite(),
-  provenance: piMessageProvenanceSchema.optional()
+  errorCode: z2.string().min(1).optional()
 }).strict();
-var contextEpochStartSchema = z3.discriminatedUnion("reason", [
-  z3.object({
-    reason: z3.literal("initial"),
-    modelProfile: z3.literal("standard"),
-    modelId: z3.string().min(1),
-    messages: z3.array(piMessageStepSchema)
-  }).strict(),
-  z3.object({
-    reason: z3.literal("handoff"),
-    modelProfile: handoffModelProfileSchema,
-    modelId: z3.string().min(1),
-    messages: z3.array(piMessageStepSchema)
-  }).strict(),
-  z3.object({
-    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1),
-    messages: z3.array(piMessageStepSchema)
-  }).strict()
+var appendableConversationEventDataSchema = z2.union([
+  messageEventDataSchema,
+  messageUpdatedEventDataSchema,
+  agentStepEventDataSchema,
+  mcpProviderConnectedEventDataSchema,
+  authorizationRequestedEventDataSchema,
+  authorizationCompletedEventDataSchema,
+  toolExecutionStartedEventDataSchema,
+  messageHandledEventDataSchema,
+  messagesSummarizedEventDataSchema,
+  turnStartedEventDataSchema,
+  turnCompletedEventDataSchema,
+  turnFailedEventDataSchema,
+  subagentStartedEventDataSchema,
+  subagentEndedEventDataSchema
 ]);
-var mcpProviderConnectedEntrySchema2 = z3.object({
-  type: z3.literal("mcp_provider_connected"),
-  provider: z3.string().min(1)
-});
-var authorizationKindSchema2 = z3.union([
-  z3.literal("plugin"),
-  z3.literal("mcp")
+var conversationEventDataSchema = z2.union([
+  appendableConversationEventDataSchema,
+  historyReplacementEventDataSchema,
+  legacyRollbackEventDataSchema
 ]);
-var authorizationRequestedEntrySchema2 = z3.object({
-  type: z3.literal("authorization_requested"),
-  kind: authorizationKindSchema2,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1),
-  delivery: z3.union([
-    z3.literal("private_link_sent"),
-    z3.literal("private_link_reused")
-  ])
-});
-var authorizationCompletedEntrySchema2 = z3.object({
-  type: z3.literal("authorization_completed"),
-  kind: authorizationKindSchema2,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1)
-});
-var toolExecutionStartedEntrySchema2 = z3.object({
-  type: z3.literal("tool_execution_started"),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  args: z3.unknown().optional()
-});
-var visibleContextCompactedEntrySchema = z3.object({
-  type: z3.literal("visible_context_compacted"),
-  compactions: z3.array(
-    z3.object({
-      coveredMessageIds: z3.array(z3.string()),
-      createdAtMs: z3.number(),
-      id: z3.string().min(1),
-      summary: z3.string()
-    })
-  )
-});
-var subagentStartedEntrySchema2 = z3.object({
-  type: z3.literal("subagent_started"),
-  subagentInvocationId: z3.string().min(1),
-  subagentKind: z3.string().min(1),
-  modelId: z3.string().min(1).optional(),
-  parentToolCallId: z3.string().min(1).optional(),
-  reasoningLevel: z3.string().min(1).optional(),
-  childConversationId: z3.string().min(1),
-  historyMode: z3.union([z3.literal("isolated"), z3.literal("shared")])
-}).strict();
-var subagentEndedEntrySchema2 = z3.object({
-  type: z3.literal("subagent_ended"),
-  subagentInvocationId: z3.string().min(1),
-  outcome: z3.union([
-    z3.literal("success"),
-    z3.literal("error"),
-    z3.literal("aborted")
-  ]),
-  errorCode: z3.string().min(1).optional()
-});
-var appendableAgentStepEntrySchema = z3.union([
-  piMessageStepEntrySchema,
-  mcpProviderConnectedEntrySchema2,
-  authorizationRequestedEntrySchema2,
-  authorizationCompletedEntrySchema2,
-  toolExecutionStartedEntrySchema2,
-  visibleContextCompactedEntrySchema,
-  subagentStartedEntrySchema2,
-  subagentEndedEntrySchema2
+var knownConversationEventTypeSchema = z2.enum([
+  "message",
+  "message_updated",
+  "agent_step",
+  "mcp_provider_connected",
+  "authorization_requested",
+  "authorization_completed",
+  "tool_execution_started",
+  "message_handled",
+  "messages_summarized",
+  "turn_started",
+  "turn_completed",
+  "turn_failed",
+  "subagent_started",
+  "subagent_ended",
+  "handoff",
+  "compaction",
+  "rollback"
 ]);
-var agentStepEntrySchema = z3.union([
-  appendableAgentStepEntrySchema,
-  contextEpochStartedEntrySchema
+var unknownConversationEventDataSchema = z2.object({
+  type: z2.literal("unknown"),
+  originalType: z2.string().min(1),
+  payload: z2.unknown()
+}).strict();
+var conversationEventEnvelopeSchema = z2.object({
+  schemaVersion: z2.number().int().nonnegative(),
+  seq: z2.number().int().nonnegative(),
+  historyVersion: z2.number().int().nonnegative(),
+  idempotencyKey: z2.string().min(1).optional(),
+  createdAtMs: z2.number().finite()
+}).strict();
+var conversationEventSchema = z2.union([
+  conversationEventEnvelopeSchema.extend({
+    schemaVersion: z2.literal(1),
+    data: conversationEventDataSchema
+  }),
+  conversationEventEnvelopeSchema.extend({
+    data: unknownConversationEventDataSchema
+  })
 ]);
-var newAgentStepSchema = z3.object({
-  entry: appendableAgentStepEntrySchema,
-  createdAtMs: z3.number().finite()
+var storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
+  type: z2.string().min(1),
+  payload: z2.unknown()
+});
+function decodeStoredConversationEvent(value) {
+  const stored = storedConversationEventSchema.parse(value);
+  const { type, payload, ...envelope } = stored;
+  const knownType = knownConversationEventTypeSchema.safeParse(type).success;
+  if (stored.schemaVersion === 1 && knownType) {
+    const data = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? { ...payload, type } : { type };
+    return conversationEventSchema.parse({ ...envelope, data });
+  }
+  return conversationEventSchema.parse({
+    ...envelope,
+    data: { type: "unknown", originalType: type, payload }
+  });
+}
+var newConversationEventSchema = z2.object({
+  data: appendableConversationEventDataSchema,
+  idempotencyKey: z2.string().min(1).optional(),
+  createdAtMs: z2.number().finite()
 }).strict();
 
 // src/chat/conversations/sql/conversation-row.ts
@@ -1470,66 +1273,92 @@ function sanitizePostgresJson(value) {
     return value;
   }
   return Object.fromEntries(
-    Object.entries(value).map(([key2, item]) => [
-      key2,
+    Object.entries(value).map(([key, item]) => [
+      key,
       sanitizePostgresJson(item)
     ])
   );
 }
 
-// src/chat/conversations/sql/history.ts
-function messageRole(entry) {
-  if (entry.type !== "pi_message") {
-    return null;
-  }
-  const role = entry.message.role;
-  return typeof role === "string" ? role : null;
+// src/chat/conversations/sql/event-lock.ts
+async function withConversationEventLock(executor, conversationId, callback) {
+  return executor.withLock(
+    `junior_conversation:event:${conversationId}`,
+    callback
+  );
 }
-function insertFromStep(conversationId, seq, contextEpoch, step) {
-  const { type, ...payload } = agentStepEntrySchema.parse(step.entry);
+
+// src/chat/conversations/sql/history.ts
+var messageHistoryEventTypes = [
+  "message",
+  "message_updated",
+  "message_handled"
+];
+function insertFromEvent(conversationId, seq, historyVersion, event) {
+  const { type, ...payload } = conversationEventDataSchema.parse(event.data);
   return {
     conversationId,
     seq,
-    contextEpoch,
+    historyVersion,
+    schemaVersion: 1,
+    idempotencyKey: event.idempotencyKey ?? null,
     type,
-    role: messageRole(step.entry),
     payload: sanitizePostgresJson(payload),
-    createdAt: new Date(step.createdAtMs)
+    createdAt: new Date(event.createdAtMs)
   };
 }
-function stepFromRow(row) {
-  const entry = agentStepEntrySchema.parse({ type: row.type, ...row.payload });
-  return {
+function eventFromRow(row) {
+  return decodeStoredConversationEvent({
+    schemaVersion: row.schemaVersion,
     seq: row.seq,
-    contextEpoch: row.contextEpoch,
+    historyVersion: row.historyVersion,
+    ...row.idempotencyKey ? { idempotencyKey: row.idempotencyKey } : {},
     createdAtMs: row.createdAt.getTime(),
-    entry
-  };
-}
-function piMessageStep(step) {
-  return {
-    entry: {
-      type: "pi_message",
-      message: step.message,
-      ...step.provenance ? { provenance: step.provenance } : {}
-    },
-    createdAtMs: step.createdAtMs
-  };
+    type: row.type,
+    payload: row.payload
+  });
 }
-var SqlAgentStepStore = class {
+var SqlConversationEventStore = class {
   constructor(executor) {
     this.executor = executor;
   }
   executor;
-  async append(conversationId, steps) {
-    const parsed = steps.map((step) => newAgentStepSchema.parse(step));
+  async append(conversationId, events) {
+    const parsed = events.map(
+      (event) => newConversationEventSchema.parse(event)
+    );
     if (parsed.length === 0) {
       return;
     }
-    const newestCreatedAtMs = Math.max(
-      ...parsed.map((step) => step.createdAtMs)
-    );
-    await this.executor.transaction(async () => {
+    await withConversationEventLock(this.executor, conversationId, async () => {
+      const existingKeys = parsed.map((event) => event.idempotencyKey).filter((key) => key !== void 0);
+      const persistedKeys = existingKeys.length === 0 ? /* @__PURE__ */ new Set() : new Set(
+        (await this.executor.db().select({ key: juniorConversationEvents.idempotencyKey }).from(juniorConversationEvents).where(
+          and3(
+            eq3(
+              juniorConversationEvents.conversationId,
+              conversationId
+            ),
+            inArray(
+              juniorConversationEvents.idempotencyKey,
+              existingKeys
+            )
+          )
+        )).flatMap((row) => row.key ? [row.key] : [])
+      );
+      const acceptedKeys = new Set(persistedKeys);
+      const pending = parsed.filter((event) => {
+        if (event.idempotencyKey === void 0) return true;
+        if (acceptedKeys.has(event.idempotencyKey)) return false;
+        acceptedKeys.add(event.idempotencyKey);
+        return true;
+      });
+      if (pending.length === 0) {
+        return;
+      }
+      const newestCreatedAtMs = Math.max(
+        ...pending.map((event) => event.createdAtMs)
+      );
       await ensureConversationRow(
         this.executor,
         conversationId,
@@ -1542,17 +1371,17 @@ var SqlAgentStepStore = class {
         )
       );
       const cursor = await this.readCursor(conversationId);
-      const contextEpoch = cursor.maxEpoch ?? 0;
+      const historyVersion = cursor.maxHistoryVersion ?? 0;
       let seq = cursor.nextSeq;
-      const rows = parsed.map(
-        (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
+      const rows = pending.map(
+        (event) => insertFromEvent(conversationId, seq++, historyVersion, event)
       );
-      await this.executor.db().insert(juniorAgentSteps).values(rows);
+      await this.executor.db().insert(juniorConversationEvents).values(rows);
     });
   }
-  async startEpoch(conversationId, opts) {
-    const parsed = contextEpochStartSchema.parse(opts);
-    await this.executor.transaction(async () => {
+  async replaceHistory(conversationId, replacement) {
+    const parsed = historyReplacementSchema.parse(replacement);
+    await withConversationEventLock(this.executor, conversationId, async () => {
       await ensureConversationRow(this.executor, conversationId, Date.now());
       await this.executor.db().update(juniorConversations).set({ archivedAt: null }).where(
         and3(
@@ -1561,140 +1390,89 @@ var SqlAgentStepStore = class {
         )
       );
       const cursor = await this.readCursor(conversationId);
-      const contextEpoch = parsed.reason === "initial" ? cursor.maxEpoch ?? 0 : (cursor.maxEpoch ?? -1) + 1;
-      let seq = cursor.nextSeq;
-      const { messages, ...binding } = parsed;
-      const marker = {
-        entry: { type: "context_epoch_started", ...binding },
-        createdAtMs: Date.now()
-      };
-      const rows = [marker, ...messages.map(piMessageStep)].map(
-        (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
+      const historyVersion = (cursor.maxHistoryVersion ?? 0) + 1;
+      await this.executor.db().insert(juniorConversationEvents).values(
+        insertFromEvent(
+          conversationId,
+          cursor.nextSeq,
+          historyVersion,
+          parsed
+        )
       );
-      await this.executor.db().insert(juniorAgentSteps).values(rows);
     });
   }
-  async loadCurrentEpoch(conversationId) {
+  async loadCurrentHistory(conversationId) {
     const cursor = await this.readCursor(conversationId);
-    if (cursor.maxEpoch === null) {
+    if (cursor.maxHistoryVersion === null) {
       return [];
     }
-    const rows = await this.executor.db().select().from(juniorAgentSteps).where(
+    const rows = await this.executor.db().select().from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.historyVersion, cursor.maxHistoryVersion)
+      )
+    ).orderBy(asc2(juniorConversationEvents.seq));
+    return rows.map(eventFromRow);
+  }
+  async loadHistoryContaining(conversationId, seq, throughSeq) {
+    const [boundary] = await this.executor.db().select({ historyVersion: juniorConversationEvents.historyVersion }).from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.seq, seq)
+      )
+    ).limit(1);
+    if (!boundary) return void 0;
+    const rows = await this.executor.db().select().from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.historyVersion, boundary.historyVersion),
+        throughSeq === void 0 ? void 0 : lte(juniorConversationEvents.seq, throughSeq)
+      )
+    ).orderBy(asc2(juniorConversationEvents.seq));
+    return rows.map(eventFromRow);
+  }
+  async loadMessageHistory(conversationId) {
+    const [compactionRow] = await this.executor.db().select().from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.type, "messages_summarized")
+      )
+    ).orderBy(desc2(juniorConversationEvents.seq)).limit(1);
+    const compaction = compactionRow ? eventFromRow(compactionRow) : void 0;
+    const historyFromSeq = compaction?.data.type === "messages_summarized" ? compaction.data.historyFromSeq : 0;
+    const rows = await this.executor.db().select().from(juniorConversationEvents).where(
       and3(
-        eq3(juniorAgentSteps.conversationId, conversationId),
-        eq3(juniorAgentSteps.contextEpoch, cursor.maxEpoch)
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        inArray(juniorConversationEvents.type, messageHistoryEventTypes),
+        gte(juniorConversationEvents.seq, historyFromSeq)
       )
-    ).orderBy(asc2(juniorAgentSteps.seq));
-    return rows.map(stepFromRow);
+    ).orderBy(asc2(juniorConversationEvents.seq));
+    return { events: rows.map(eventFromRow), compaction };
   }
   async loadHistory(conversationId) {
-    const rows = await this.executor.db().select().from(juniorAgentSteps).where(eq3(juniorAgentSteps.conversationId, conversationId)).orderBy(asc2(juniorAgentSteps.seq));
-    return rows.map(stepFromRow);
+    const rows = await this.executor.db().select().from(juniorConversationEvents).where(eq3(juniorConversationEvents.conversationId, conversationId)).orderBy(asc2(juniorConversationEvents.seq));
+    return rows.map(eventFromRow);
   }
-  /** Read the next `seq` and current highest epoch for one conversation. */
+  /** Read the next sequence and active model-history version. */
   async readCursor(conversationId) {
     const rows = await this.executor.db().select({
-      maxSeq: sql7`max(${juniorAgentSteps.seq})`,
-      maxEpoch: sql7`max(${juniorAgentSteps.contextEpoch})`
-    }).from(juniorAgentSteps).where(eq3(juniorAgentSteps.conversationId, conversationId));
+      maxSeq: sql7`max(${juniorConversationEvents.seq})`,
+      maxHistoryVersion: sql7`max(${juniorConversationEvents.historyVersion})`
+    }).from(juniorConversationEvents).where(eq3(juniorConversationEvents.conversationId, conversationId));
     const maxSeq = rows[0]?.maxSeq;
-    const maxEpoch = rows[0]?.maxEpoch;
+    const maxHistoryVersion = rows[0]?.maxHistoryVersion;
     return {
-      maxEpoch: maxEpoch === null || maxEpoch === void 0 ? null : Number(maxEpoch),
+      maxHistoryVersion: maxHistoryVersion === null || maxHistoryVersion === void 0 ? null : Number(maxHistoryVersion),
       nextSeq: maxSeq === null || maxSeq === void 0 ? 0 : Number(maxSeq) + 1
     };
   }
 };
-function createSqlAgentStepStore(executor) {
-  return new SqlAgentStepStore(executor);
-}
-
-// src/chat/conversations/sql/messages.ts
-import { and as and4, asc as asc3, eq as eq4, isNotNull as isNotNull2, isNull as isNull2, sql as sql8 } from "drizzle-orm";
-function messageFromRow(row) {
-  return {
-    conversationId: row.conversationId,
-    messageId: row.messageId,
-    role: row.role,
-    text: row.text,
-    createdAtMs: row.createdAt.getTime(),
-    ...row.authorIdentityId ? { authorIdentityId: row.authorIdentityId } : {},
-    ...row.meta ? { meta: row.meta } : {},
-    ...row.repliedAt ? { repliedAtMs: row.repliedAt.getTime() } : {}
-  };
-}
-var SqlConversationMessageStore = class {
-  constructor(executor) {
-    this.executor = executor;
-  }
-  executor;
-  async record(conversationId, messages) {
-    if (messages.length === 0) {
-      return;
-    }
-    const newestCreatedAtMs = Math.max(
-      ...messages.map((message) => message.createdAtMs)
-    );
-    await this.executor.transaction(async () => {
-      await ensureConversationRow(
-        this.executor,
-        conversationId,
-        newestCreatedAtMs
-      );
-      await this.executor.db().update(juniorConversations).set({ archivedAt: null }).where(
-        and4(
-          eq4(juniorConversations.conversationId, conversationId),
-          isNotNull2(juniorConversations.archivedAt)
-        )
-      );
-      await this.executor.db().insert(juniorConversationMessages).values(
-        messages.map((message) => ({
-          conversationId,
-          messageId: message.messageId,
-          role: message.role,
-          authorIdentityId: message.authorIdentityId ?? null,
-          text: message.text,
-          meta: message.meta ?? null,
-          repliedAt: null,
-          createdAt: new Date(message.createdAtMs)
-        }))
-      ).onConflictDoUpdate({
-        target: [
-          juniorConversationMessages.conversationId,
-          juniorConversationMessages.messageId
-        ],
-        set: {
-          meta: sql8`nullif(coalesce(${juniorConversationMessages.meta}, '{}'::jsonb) || coalesce(excluded.meta, '{}'::jsonb), '{}'::jsonb)`
-        }
-      });
-    });
-  }
-  async markReplied(conversationId, messageId, repliedAtMs) {
-    await this.executor.db().update(juniorConversationMessages).set({
-      repliedAt: sql8`coalesce(${juniorConversationMessages.repliedAt}, ${new Date(repliedAtMs)})`
-    }).where(
-      and4(
-        eq4(juniorConversationMessages.conversationId, conversationId),
-        eq4(juniorConversationMessages.messageId, messageId),
-        isNull2(juniorConversationMessages.repliedAt)
-      )
-    );
-  }
-  async list(conversationId, opts = {}) {
-    const query = this.executor.db().select().from(juniorConversationMessages).where(eq4(juniorConversationMessages.conversationId, conversationId)).orderBy(
-      asc3(juniorConversationMessages.createdAt),
-      asc3(juniorConversationMessages.messageId)
-    );
-    const rows = opts.limit === void 0 ? await query : await query.limit(Math.max(0, opts.limit));
-    return rows.map(messageFromRow);
-  }
-};
-function createSqlConversationMessageStore(executor) {
-  return new SqlConversationMessageStore(executor);
+function createSqlConversationEventStore(executor) {
+  return new SqlConversationEventStore(executor);
 }
 
 // src/chat/conversations/sql/search.ts
-import { and as and5, desc as desc2, eq as eq5, inArray, isNull as isNull3, ne, sql as sql9 } from "drizzle-orm";
+import { and as and4, desc as desc3, eq as eq4, isNull as isNull2, ne, sql as sql8 } from "drizzle-orm";
 var SqlConversationSearchStore = class {
   constructor(executor) {
     this.executor = executor;
@@ -1702,48 +1480,51 @@ var SqlConversationSearchStore = class {
   executor;
   async search(args) {
     const db = this.executor.db();
-    const tsquery = sql9`websearch_to_tsquery('english', ${args.query})`;
-    const rank = sql9`ts_rank_cd(to_tsvector('english', ${juniorConversationMessages.text}), ${tsquery})`;
-    const excerpt = sql9`ts_headline('english', ${juniorConversationMessages.text}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')`;
-    const role = sql9`${juniorConversationMessages.role}`;
+    const tsquery = sql8`websearch_to_tsquery('english', ${args.query})`;
+    const text5 = sql8`${juniorConversationEvents.payload}->>'text'`;
+    const rank = sql8`ts_rank_cd(to_tsvector('english', ${text5}), ${tsquery})`;
+    const excerpt = sql8`ts_headline('english', ${text5}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')`;
+    const role = sql8`${juniorConversationEvents.payload}->>'role'`;
+    const messageId = sql8`${juniorConversationEvents.payload}->>'messageId'`;
     const bestPerConversation = db.selectDistinctOn([juniorConversations.conversationId], {
       conversationId: juniorConversations.conversationId,
       excerpt: excerpt.as("excerpt"),
       lastActivityAt: juniorConversations.lastActivityAt,
-      messageCreatedAt: juniorConversationMessages.createdAt,
-      messageId: juniorConversationMessages.messageId,
+      messageCreatedAt: juniorConversationEvents.createdAt,
+      messageId: messageId.as("message_id"),
       providerDestinationId: juniorDestinations.providerDestinationId,
       rank: rank.as("rank"),
       role: role.as("role")
-    }).from(juniorConversationMessages).innerJoin(
+    }).from(juniorConversationEvents).innerJoin(
       juniorConversations,
-      eq5(
+      eq4(
         juniorConversations.conversationId,
-        juniorConversationMessages.conversationId
+        juniorConversationEvents.conversationId
       )
     ).innerJoin(
       juniorDestinations,
-      eq5(juniorDestinations.id, juniorConversations.destinationId)
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
     ).where(
-      and5(
-        eq5(juniorConversations.source, "slack"),
-        isNull3(juniorConversations.parentConversationId),
-        isNull3(juniorConversations.transcriptPurgedAt),
+      and4(
+        eq4(juniorConversations.source, "slack"),
+        isNull2(juniorConversations.parentConversationId),
+        isNull2(juniorConversations.transcriptPurgedAt),
         ne(juniorConversations.conversationId, args.currentConversationId),
-        eq5(juniorDestinations.provider, args.scope.provider),
-        eq5(juniorDestinations.providerTenantId, args.scope.providerTenantId),
-        eq5(juniorDestinations.visibility, "public"),
-        inArray(juniorConversationMessages.role, ["user", "assistant"]),
-        sql9`to_tsvector('english', ${juniorConversationMessages.text}) @@ ${tsquery}`
+        eq4(juniorDestinations.provider, args.scope.provider),
+        eq4(juniorDestinations.providerTenantId, args.scope.providerTenantId),
+        eq4(juniorDestinations.visibility, "public"),
+        eq4(juniorConversationEvents.type, "message"),
+        sql8`${role} in ('user', 'assistant')`,
+        sql8`to_tsvector('english', ${text5}) @@ ${tsquery}`
       )
     ).orderBy(
       juniorConversations.conversationId,
-      desc2(rank),
-      desc2(juniorConversationMessages.createdAt)
+      desc3(rank),
+      desc3(juniorConversationEvents.createdAt)
     ).as("best_conversation_matches");
     const rows = await db.select().from(bestPerConversation).orderBy(
-      desc2(bestPerConversation.rank),
-      desc2(bestPerConversation.lastActivityAt)
+      desc3(bestPerConversation.rank),
+      desc3(bestPerConversation.lastActivityAt)
     ).limit(args.limit);
     return rows.map((row) => ({
       conversationId: row.conversationId,
@@ -2014,24 +1795,23 @@ function createDb(args) {
   });
 }
 function getSqlExecutor() {
-  const { sql: sql10 } = getChatConfig();
-  if (current?.databaseUrl !== sql10.databaseUrl || current.driver !== sql10.driver) {
+  const { sql: sql9 } = getChatConfig();
+  if (current?.databaseUrl !== sql9.databaseUrl || current.driver !== sql9.driver) {
     if (current) {
       const previous = current;
       current = void 0;
       void previous.db.close().catch(() => void 0);
     }
     const db = createDb({
-      databaseUrl: sql10.databaseUrl,
-      driver: sql10.driver
+      databaseUrl: sql9.databaseUrl,
+      driver: sql9.driver
     });
     current = {
-      databaseUrl: sql10.databaseUrl,
-      driver: sql10.driver,
+      databaseUrl: sql9.databaseUrl,
+      driver: sql9.driver,
       db,
       store: createSqlStore(db),
-      stepStore: createSqlAgentStepStore(db),
-      messageStore: createSqlConversationMessageStore(db),
+      eventStore: createSqlConversationEventStore(db),
       searchStore: createSqlConversationSearchStore(db)
     };
   }
@@ -2044,13 +1824,9 @@ function getConversationStore() {
   getSqlExecutor();
   return current.store;
 }
-function getAgentStepStore() {
+function getConversationEventStore() {
   getSqlExecutor();
-  return current.stepStore;
-}
-function getConversationMessageStore() {
-  getSqlExecutor();
-  return current.messageStore;
+  return current.eventStore;
 }
 function getConversationSearchStore() {
   getSqlExecutor();
@@ -2066,25 +1842,23 @@ export {
   juniorUsers,
   juniorIdentities,
   juniorConversations,
-  juniorAgentSteps,
-  juniorConversationMessages,
+  juniorConversationEvents,
   createSqlStore,
-  piMessageSchema,
-  legacyActorProvenance,
-  instructionActors,
-  readSessionLogEntries,
+  conversationMessageProvenanceSchema,
   instructionProvenanceFor,
   contextProvenance,
-  agentStepEntrySchema,
+  instructionActors,
+  conversationEventDataSchema,
+  decodeStoredConversationEvent,
+  newConversationEventSchema,
   sanitizePostgresJson,
-  createSqlAgentStepStore,
-  createSqlConversationMessageStore,
+  withConversationEventLock,
+  createSqlConversationEventStore,
   createJuniorSqlExecutor,
   getSqlExecutor,
   getDb,
   getConversationStore,
-  getAgentStepStore,
-  getConversationMessageStore,
+  getConversationEventStore,
   getConversationSearchStore,
   closeDb
 };