@sentry/junior 0.106.0 → 0.107.1

package/dist/cli/upgrade.js

@@ -4,7 +4,7 @@ import {
   recordConversationActivity,
   recordConversationExecution,
   requestConversationWork
-} from "../chunk-3OUSJPR7.js";
+} from "../chunk-YNP2ATQX.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -12,16 +12,17 @@ import {
   pluginRuntimeRegistrationsFromPluginSet
 } from "../chunk-SG5WAA7H.js";
 import {
+  AGENT_TURN_SESSION_PREFIX,
   JUNIOR_THREAD_STATE_TTL_MS,
-  coerceThreadConversationState
-} from "../chunk-XIMUQ4IU.js";
+  agentTurnSessionConversationIndexKey,
+  agentTurnSessionKey,
+  coerceThreadConversationState,
+  listAgentTurnSessionSummariesForConversations,
+  piMessageSchema
+} from "../chunk-4YF7Z6IA.js";
 import {
-  addAgentTurnUsage,
-  listAgentTurnSessionSummariesForConversations
-} from "../chunk-DDRQ4U7I.js";
-import {
-  importConversationFromLegacy
-} from "../chunk-P4P7O5WG.js";
+  addAgentTurnUsage
+} from "../chunk-MU6HHZEN.js";
 import "../chunk-PDO5BLNM.js";
 import {
   loadAppPluginSet
@@ -29,19 +30,37 @@ import {
 import {
   createPluginLogger,
   createPluginState
-} from "../chunk-AZ5OMSN5.js";
+} from "../chunk-AUUOHQAT.js";
+import {
+  disconnectStateAdapter,
+  getConnectedStateContext,
+  getStateAdapter
+} from "../chunk-B2Z2H66D.js";
 import {
+  contextProvenance,
+  conversationEventDataSchema,
+  conversationMessageProvenanceSchema,
   createJuniorSqlExecutor,
-  createSqlConversationMessageStore,
   createSqlStore,
-  getDb
-} from "../chunk-XTKJPSMF.js";
+  getDb,
+  instructionProvenanceFor,
+  juniorConversationEvents,
+  juniorConversations,
+  newConversationEventSchema,
+  sanitizePostgresJson,
+  withConversationEventLock
+} from "../chunk-NVOTGWYX.js";
 import {
-  disconnectStateAdapter,
+  COMPACTION_SUMMARY_PREFIX,
   getChatConfig,
-  getConnectedStateContext
-} from "../chunk-4UYIRWDW.js";
-import "../chunk-FXFQNHRU.js";
+  isCompactionSummaryText,
+  modelIdForProfile,
+  modelProfileSchema,
+  standardModelId,
+  unescapeXml,
+  unwrapCurrentInstruction
+} from "../chunk-SS67LUOK.js";
+import "../chunk-VFUK3X5B.js";
 import "../chunk-RT5BUHR5.js";
 import {
   parseDestination,
@@ -49,8 +68,11 @@ import {
 } from "../chunk-B7PUBQQM.js";
 import {
   pluginCatalogRuntime
-} from "../chunk-77LHNQK4.js";
-import "../chunk-AEWZ7F65.js";
+} from "../chunk-YIPD3L6L.js";
+import {
+  storedSlackActorSchema
+} from "../chunk-VIXFG2VC.js";
+import "../chunk-O24R4DCK.js";
 import {
   isRecord,
   toOptionalNumber,
@@ -65,16 +87,13 @@ import "../chunk-MLKGABMK.js";
 // src/cli/upgrade.ts
 import { createJiti } from "jiti";
 
-// src/chat/conversations/state.ts
+// src/cli/upgrade/migrations/conversation-history/state-conversation-store.ts
 function createStateConversationStore(state) {
   return {
     get: (args) => getConversation({ ...args, state }),
     // Task-execution state has no destination records, so visibility is never
     // source-confirmed here and cross-context reads fail closed to private.
     getDestinationVisibility: async () => void 0,
-    // Child conversations are a SQL-only concept and never use this legacy
-    // metadata path.
-    ensureChildConversation: async () => void 0,
     recordActivity: (args) => recordConversationActivity({ ...args, state }),
     recordExecution: (args) => recordConversationExecution({ ...args, state }),
     listByActivity: (args) => listConversationsByActivity({ ...args, state })
@@ -88,10 +107,10 @@ async function migrateConversationsToSql(context, options = {}) {
   let target = options.target;
   let closeTarget;
   if (!target) {
-    const { sql } = getChatConfig();
+    const { sql: sql2 } = getChatConfig();
     const executor = createJuniorSqlExecutor({
-      connectionString: sql.databaseUrl,
-      driver: sql.driver
+      connectionString: sql2.databaseUrl,
+      driver: sql2.driver
     });
     target = createSqlStore(executor);
     closeTarget = () => executor.close();
@@ -172,6 +191,14 @@ var LEGACY_CORE_MIGRATION_IDS = [
   "0005_conversation_transcripts"
 ];
 var LEGACY_METRICS_MIGRATION_ID = "0006_conversation_metrics";
+var LEGACY_CORE_MIGRATION_CHECKSUMS = {
+  "0001_conversation_core": "78fe050d8bec8ba18e2e3192497b3d8ad6b45fbb66ad4859377fb2202ed57651",
+  "0002_slack_destination_visibility_backfill": "fb590a09fa51db471a748e3d7abb4137f521ee8df97f6e9ef5563121be98c394",
+  "0003_user_identities": "67d9c9c26cbd76213614eb6d7a7cc7e2501fc20e92321eb5176a08ce39cd2efb",
+  "0004_actor_cutover": "d41b8bfa66b8a88d69e84af38950025ba4c9be56341565cbe1411f0ca50c1dc2",
+  "0005_conversation_transcripts": "add299d1b254e023f89b5993c417dd2248dc009e874efdeaf31ec0732e0d4fb4",
+  "0006_conversation_metrics": "7c7ca5c9e11ed4b0e14737fd90d3348ea46e306c88fdf31199b7afb2a11c6a41"
+};
 var MIGRATIONS_TABLE = "__drizzle_junior_core";
 function migrationFolder() {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -189,7 +216,7 @@ SELECT
   }
   const migrations = readMigrationFiles({ migrationsFolder });
   const [metrics] = await executor.query(`
-SELECT count(*) = 4 AS complete
+SELECT count(*)::integer AS "columnCount"
 FROM information_schema.columns
 WHERE table_schema = 'public'
   AND table_name = 'junior_conversations'
@@ -201,17 +228,71 @@ WHERE table_schema = 'public'
   )
 `);
   const legacyRecords = await executor.query("SELECT id, checksum FROM junior_schema_migrations");
-  const expectedIds = metrics?.complete ? [...LEGACY_CORE_MIGRATION_IDS, LEGACY_METRICS_MIGRATION_ID] : [...LEGACY_CORE_MIGRATION_IDS];
-  const validIds = new Set(
-    legacyRecords.filter((record) => record.checksum.trim().length > 0).map((record) => record.id)
+  const legacyRecordsById = new Map(
+    legacyRecords.map((record) => [record.id, record.checksum])
   );
-  const missingIds = expectedIds.filter((id) => !validIds.has(id));
+  const metricColumnCount = metrics?.columnCount ?? 0;
+  if (metricColumnCount !== 0 && metricColumnCount !== 4) {
+    throw new Error(
+      `Cannot adopt partial legacy metrics state: found ${metricColumnCount} of 4 required columns`
+    );
+  }
+  const metricsComplete = metricColumnCount === 4;
+  const hasMetricsRecord = legacyRecordsById.has(LEGACY_METRICS_MIGRATION_ID);
+  if (metricsComplete !== hasMetricsRecord) {
+    throw new Error(
+      "Cannot adopt legacy core migration state: legacy metrics migration record does not match physical metric columns"
+    );
+  }
+  const expectedIds = metricsComplete ? [...LEGACY_CORE_MIGRATION_IDS, LEGACY_METRICS_MIGRATION_ID] : [...LEGACY_CORE_MIGRATION_IDS];
+  const missingIds = expectedIds.filter((id) => !legacyRecordsById.has(id));
   if (missingIds.length > 0) {
     throw new Error(
       `Cannot adopt partial legacy core migration state; missing: ${missingIds.join(", ")}`
     );
   }
-  const migration = metrics?.complete ? migrations[1] : migrations[0];
+  const checksumMismatches = expectedIds.filter(
+    (id) => legacyRecordsById.get(id) !== LEGACY_CORE_MIGRATION_CHECKSUMS[id]
+  );
+  if (checksumMismatches.length > 0) {
+    throw new Error(
+      `Cannot adopt legacy core migration state: checksum mismatch: ${checksumMismatches.join(", ")}`
+    );
+  }
+  const [baseline] = await executor.query(`
+SELECT
+  to_regclass('public.junior_conversation_events')::text AS "conversationEventsTable",
+  to_regclass('public.junior_conversation_messages_search_idx')::text AS "searchIndex",
+  EXISTS (
+    SELECT 1
+    FROM information_schema.tables
+    WHERE table_schema = 'public'
+      AND table_name = 'junior_agent_steps'
+      AND table_type = 'BASE TABLE'
+  ) AS "legacyAgentStepsTable",
+  EXISTS (
+    SELECT 1
+    FROM information_schema.columns
+    WHERE table_schema = 'public'
+      AND table_name = 'junior_conversations'
+      AND column_name = 'metric_run_id'
+  ) AS "metricRunIdColumn"
+`);
+  if (!baseline?.legacyAgentStepsTable || baseline.conversationEventsTable) {
+    throw new Error(
+      "Cannot adopt legacy core migration state: expected the pre-Drizzle junior_agent_steps table and no junior_conversation_events table"
+    );
+  }
+  const postBaselineMarkers = [
+    baseline.searchIndex ? "junior_conversation_messages_search_idx" : void 0,
+    baseline.metricRunIdColumn ? "junior_conversations.metric_run_id" : void 0
+  ].filter((marker) => marker !== void 0);
+  if (postBaselineMarkers.length > 0) {
+    throw new Error(
+      `Cannot adopt legacy core migration state: post-baseline schema markers are already present: ${postBaselineMarkers.join(", ")}`
+    );
+  }
+  const migration = metricsComplete ? migrations[1] : migrations[0];
   if (!migration) {
     throw new Error("No core Drizzle migrations were packaged");
   }
@@ -244,10 +325,10 @@ async function migrateSchema(executor) {
 
 // src/cli/upgrade/migrations/core-sql.ts
 async function migrateCoreSqlSchema(_context) {
-  const { sql } = getChatConfig();
+  const { sql: sql2 } = getChatConfig();
   const executor = createJuniorSqlExecutor({
-    connectionString: sql.databaseUrl,
-    driver: sql.driver
+    connectionString: sql2.databaseUrl,
+    driver: sql2.driver
   });
   try {
     await migrateSchema(executor);
@@ -261,56 +342,923 @@ var coreSqlSchemaMigration = {
   run: migrateCoreSqlSchema
 };
 
+// src/cli/upgrade/migrations/conversation-history/import.ts
+import { z as z3 } from "zod";
+import { eq as eq2 } from "drizzle-orm";
+
+// src/cli/upgrade/migrations/conversation-history/session-log.ts
+import { z } from "zod";
+var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
+var AGENT_SESSION_LOG_SCHEMA_VERSION = 2;
+var INITIAL_SESSION_ID = "session_0";
+var schemaVersionSchema = z.union([z.literal(1), z.literal(2)]);
+function legacyActorProvenance(actor) {
+  if (actor.teamId && actor.slackUserId && actor.platform) {
+    return instructionProvenanceFor({
+      platform: "slack",
+      teamId: actor.teamId,
+      userId: actor.slackUserId,
+      ...actor.slackUserName ? { userName: actor.slackUserName } : {},
+      ...actor.fullName ? { fullName: actor.fullName } : {},
+      ...actor.email ? { email: actor.email } : {}
+    });
+  }
+  return contextProvenance;
+}
+var piMessageEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("pi_message"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  message: piMessageSchema,
+  provenance: conversationMessageProvenanceSchema.optional(),
+  // Legacy v1 latest-wins actor, decoded into provenance on read.
+  actor: storedSlackActorSchema.optional()
+});
+var projectionResetEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("projection_reset"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  messages: z.array(piMessageSchema),
+  provenance: z.array(conversationMessageProvenanceSchema).optional(),
+  // Legacy v1 latest-wins actor; v1 resets carry no per-message provenance.
+  actor: storedSlackActorSchema.optional()
+});
+var actorRecordedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("actor_recorded"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  actor: storedSlackActorSchema
+});
+var mcpProviderConnectedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("mcp_provider_connected"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  provider: z.string().min(1)
+});
+var authorizationKindSchema = z.union([
+  z.literal("plugin"),
+  z.literal("mcp")
+]);
+var authorizationRequestedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("authorization_requested"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z.string().min(1),
+  actorId: z.string().min(1),
+  authorizationId: z.string().min(1),
+  delivery: z.union([
+    z.literal("private_link_sent"),
+    z.literal("private_link_reused")
+  ])
+});
+var authorizationCompletedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("authorization_completed"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z.string().min(1),
+  actorId: z.string().min(1),
+  authorizationId: z.string().min(1)
+});
+var transcriptRefSchema = z.object({
+  type: z.literal("advisor_session"),
+  parentConversationId: z.string().min(1),
+  key: z.string().min(1)
+});
+var toolExecutionStartedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("tool_execution_started"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z.number().int().nonnegative(),
+  toolCallId: z.string().min(1),
+  toolName: z.string().min(1),
+  args: z.unknown().optional()
+});
+var subagentStartedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("subagent_started"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z.string().min(1),
+  subagentKind: z.string().min(1),
+  parentToolCallId: z.string().min(1).optional(),
+  parentConversationId: z.string().min(1),
+  parentSessionId: z.string().min(1).optional(),
+  transcriptRef: transcriptRefSchema,
+  historyMode: z.literal("shared"),
+  modelId: z.string().min(1).optional(),
+  reasoningLevel: z.string().min(1).optional(),
+  createdAtMs: z.number().int().nonnegative()
+});
+var subagentEndedEntrySchema = z.object({
+  schemaVersion: schemaVersionSchema,
+  type: z.literal("subagent_ended"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z.string().min(1),
+  outcome: z.union([
+    z.literal("success"),
+    z.literal("error"),
+    z.literal("aborted")
+  ]),
+  errorCode: z.string().min(1).optional(),
+  transcriptEndMessageIndex: z.number().int().nonnegative().optional(),
+  transcriptStartMessageIndex: z.number().int().nonnegative().optional(),
+  createdAtMs: z.number().int().nonnegative()
+});
+var sessionLogEntrySchema = z.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 decode(value) {
+  if (typeof value === "string") {
+    return decode(JSON.parse(value));
+  }
+  const parsed = sessionLogEntrySchema.safeParse(migrateStoredEntry(value));
+  if (parsed.success) {
+    return parsed.data;
+  }
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "pi_message",
+    sessionId: INITIAL_SESSION_ID,
+    message: piMessageSchema.parse(value)
+  };
+}
+function redisStore(redisStateAdapter) {
+  const client = redisStateAdapter.getClient();
+  return {
+    async read(scope) {
+      const values = await client.lRange(key(scope), 0, -1);
+      return values.map(decode);
+    }
+  };
+}
+function stateStore() {
+  const stateAdapter = getStateAdapter();
+  return {
+    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);
+}
+
+// src/cli/upgrade/migrations/conversation-history/advisor-session.ts
+import { z as z2 } from "zod";
+var legacyAdvisorMessagesSchema = z2.array(piMessageSchema);
+function key2(conversationId) {
+  return `junior:${conversationId}:advisor_session`;
+}
+function createLegacyAdvisorSessionReader() {
+  return {
+    load: async (conversationId) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      return legacyAdvisorMessagesSchema.parse(
+        structuredClone(
+          await stateAdapter.get(key2(conversationId)) ?? []
+        )
+      );
+    }
+  };
+}
+
+// src/cli/upgrade/migrations/conversation-history/legacy-history-import.ts
+import { eq, sql } from "drizzle-orm";
+
+// src/cli/upgrade/migrations/conversation-history/legacy-context-message.ts
+var LEGACY_COMPACTION_SUMMARY_PREFIX = "Context handoff summary for future Junior turns:";
+function isLegacyCheckpointText(text) {
+  const normalized = (unwrapCurrentInstruction(text) ?? text).trimStart();
+  return normalized.startsWith(LEGACY_COMPACTION_SUMMARY_PREFIX);
+}
+function isLegacyOrCurrentCheckpointText(text) {
+  return isCompactionSummaryText(text) || isLegacyCheckpointText(text);
+}
+function normalizeText(text) {
+  if (!isLegacyCheckpointText(text)) return text;
+  return text.replace(
+    LEGACY_COMPACTION_SUMMARY_PREFIX,
+    COMPACTION_SUMMARY_PREFIX
+  );
+}
+function normalizeLegacyContextMessage(message) {
+  const record = message;
+  if (typeof record.content === "string") {
+    const content2 = normalizeText(record.content);
+    return content2 === record.content ? message : { ...record, content: content2 };
+  }
+  if (!Array.isArray(record.content)) return message;
+  let changed = false;
+  const content = record.content.map((part) => {
+    if (!part || typeof part !== "object" || typeof part.text !== "string") {
+      return part;
+    }
+    const text = normalizeText(part.text);
+    if (text === part.text) return part;
+    changed = true;
+    return { ...part, text };
+  });
+  return changed ? { ...record, content } : message;
+}
+function isLegacyOrCurrentCheckpointMessage(message) {
+  const record = message;
+  if (typeof record.content === "string") {
+    return isLegacyOrCurrentCheckpointText(record.content);
+  }
+  if (!Array.isArray(record.content)) return false;
+  return record.content.some(
+    (part) => part !== null && typeof part === "object" && typeof part.text === "string" && isLegacyOrCurrentCheckpointText(part.text)
+  );
+}
+
+// src/cli/upgrade/migrations/conversation-history/legacy-history-import.ts
+var INITIAL_SESSION_ID2 = "session_0";
+var ADVISOR_TASK_OPEN = "<advisor-task>\n";
+var ADVISOR_TASK_CLOSE = "\n</advisor-task>";
+var ADVISOR_CONTEXT_OPEN = "<executor-context>\n";
+var ADVISOR_CONTEXT_CLOSE = "\n</executor-context>";
+function importedAdvisorChildConversationId(parentConversationId) {
+  return `advisor:${parentConversationId}`;
+}
+function epochFromSessionId(sessionId) {
+  const match = /^session_(\d+)$/.exec(sessionId);
+  return match ? Number(match[1]) : 0;
+}
+function messageTimestampMs(message) {
+  const timestamp = message.timestamp;
+  return typeof timestamp === "number" ? timestamp : void 0;
+}
+function readAdvisorRequest(text) {
+  if (!text.startsWith(ADVISOR_TASK_OPEN) || !text.endsWith(ADVISOR_CONTEXT_CLOSE)) {
+    return void 0;
+  }
+  const taskEnd = text.indexOf(ADVISOR_TASK_CLOSE, ADVISOR_TASK_OPEN.length);
+  if (taskEnd < 0) {
+    return void 0;
+  }
+  const contextStart = taskEnd + ADVISOR_TASK_CLOSE.length + 2;
+  if (!text.startsWith(ADVISOR_CONTEXT_OPEN, contextStart)) {
+    return void 0;
+  }
+  const task = text.slice(ADVISOR_TASK_OPEN.length, taskEnd);
+  const context = text.slice(
+    contextStart + ADVISOR_CONTEXT_OPEN.length,
+    -ADVISOR_CONTEXT_CLOSE.length
+  );
+  return `${unescapeXml(task)}
+
+Executor context:
+${unescapeXml(context)}`;
+}
+function normalizeAdvisorMessage(message) {
+  const record = message;
+  if (record.role !== "user" || !Array.isArray(record.content)) {
+    return message;
+  }
+  let changed = false;
+  const content = record.content.map((part) => {
+    if (!part || typeof part !== "object" || part.type !== "text" || typeof part.text !== "string") {
+      return part;
+    }
+    const text = readAdvisorRequest(part.text);
+    if (text === void 0) {
+      return part;
+    }
+    changed = true;
+    return { ...part, text };
+  });
+  return changed ? { ...record, content } : message;
+}
+function piEntryProvenance(entry) {
+  if (entry.provenance) {
+    return entry.provenance;
+  }
+  if (entry.actor) {
+    return legacyActorProvenance(entry.actor);
+  }
+  return contextProvenance;
+}
+function convertLegacySessionLog(args) {
+  const events = [];
+  const fallback = args.fallbackCreatedAtMs;
+  let advisorChildConversationId;
+  let seq = 0;
+  const push = (historyVersion, data, createdAtMs) => {
+    events.push({ seq, historyVersion, data, createdAtMs });
+    seq += 1;
+  };
+  for (const entry of args.entries) {
+    const epoch = epochFromSessionId(entry.sessionId ?? INITIAL_SESSION_ID2);
+    switch (entry.type) {
+      case "pi_message": {
+        const message = entry.message;
+        push(
+          epoch,
+          {
+            type: "agent_step",
+            message,
+            provenance: piEntryProvenance(entry)
+          },
+          messageTimestampMs(message) ?? fallback
+        );
+        break;
+      }
+      case "projection_reset": {
+        const provenance = entry.provenance ?? entry.messages.map(() => contextProvenance);
+        if (provenance.length !== entry.messages.length) {
+          throw new Error(
+            "projection_reset provenance must align one-to-one with messages"
+          );
+        }
+        const resetCreatedAtMs = entry.messages.map(messageTimestampMs).find(
+          (timestamp) => timestamp !== void 0
+        ) ?? fallback;
+        const checkpointIndex = entry.messages.findIndex(
+          isLegacyOrCurrentCheckpointMessage
+        );
+        push(
+          epoch,
+          {
+            type: "compaction",
+            modelProfile: "standard",
+            modelId: args.modelId,
+            replacementHistory: entry.messages.map((message, index) => ({
+              message: index === checkpointIndex ? normalizeLegacyContextMessage(message) : message,
+              provenance: provenance[index]
+            }))
+          },
+          resetCreatedAtMs
+        );
+        break;
+      }
+      case "mcp_provider_connected": {
+        push(
+          epoch,
+          { type: "mcp_provider_connected", provider: entry.provider },
+          fallback
+        );
+        break;
+      }
+      case "authorization_requested": {
+        push(
+          epoch,
+          {
+            type: "authorization_requested",
+            kind: entry.kind,
+            provider: entry.provider,
+            actorId: entry.actorId,
+            authorizationId: entry.authorizationId,
+            delivery: entry.delivery
+          },
+          entry.createdAtMs
+        );
+        break;
+      }
+      case "authorization_completed": {
+        push(
+          epoch,
+          {
+            type: "authorization_completed",
+            kind: entry.kind,
+            provider: entry.provider,
+            actorId: entry.actorId,
+            authorizationId: entry.authorizationId
+          },
+          entry.createdAtMs
+        );
+        break;
+      }
+      case "tool_execution_started": {
+        push(
+          epoch,
+          {
+            type: "tool_execution_started",
+            toolCallId: entry.toolCallId,
+            toolName: entry.toolName
+          },
+          entry.createdAtMs
+        );
+        break;
+      }
+      case "subagent_started": {
+        const childConversationId = importedAdvisorChildConversationId(
+          args.conversationId
+        );
+        advisorChildConversationId = childConversationId;
+        push(
+          epoch,
+          {
+            type: "subagent_started",
+            subagentInvocationId: entry.subagentInvocationId,
+            subagentKind: entry.subagentKind,
+            ...entry.parentToolCallId ? { parentToolCallId: entry.parentToolCallId } : {},
+            childConversationId
+          },
+          entry.createdAtMs
+        );
+        break;
+      }
+      case "subagent_ended": {
+        push(
+          epoch,
+          {
+            type: "subagent_ended",
+            subagentInvocationId: entry.subagentInvocationId,
+            outcome: entry.outcome,
+            ...entry.errorCode ? { errorCode: entry.errorCode } : {}
+          },
+          entry.createdAtMs
+        );
+        break;
+      }
+      case "actor_recorded": {
+        break;
+      }
+    }
+  }
+  return {
+    events,
+    ...advisorChildConversationId ? { advisorChildConversationId } : {}
+  };
+}
+function convertAdvisorMessages(messages, fallbackCreatedAtMs) {
+  return messages.map((sourceMessage, seq) => {
+    const message = normalizeAdvisorMessage(sourceMessage);
+    return {
+      seq,
+      historyVersion: 0,
+      data: { type: "agent_step", message, provenance: contextProvenance },
+      createdAtMs: messageTimestampMs(message) ?? fallbackCreatedAtMs
+    };
+  });
+}
+function insertRow(conversationId, event) {
+  const { type, ...payload } = conversationEventDataSchema.parse(event.data);
+  return {
+    conversationId,
+    seq: event.seq,
+    historyVersion: event.historyVersion,
+    schemaVersion: 1,
+    idempotencyKey: event.idempotencyKey ?? null,
+    type,
+    payload: sanitizePostgresJson(payload),
+    createdAt: new Date(event.createdAtMs)
+  };
+}
+function mergeImportedChronology(executionEvents, messages) {
+  const visibleEvents = messages.flatMap((message) => {
+    const recorded = {
+      seq: 0,
+      historyVersion: 0,
+      idempotencyKey: `message:${message.messageId}`,
+      data: {
+        type: "message",
+        messageId: message.messageId,
+        role: message.role,
+        text: message.text,
+        ...message.authorIdentityId ? { authorIdentityId: message.authorIdentityId } : {},
+        ...message.meta ? { meta: message.meta } : {}
+      },
+      createdAtMs: message.createdAtMs
+    };
+    return message.repliedAtMs === void 0 ? [recorded] : [
+      recorded,
+      {
+        seq: 0,
+        historyVersion: 0,
+        idempotencyKey: `message:${message.messageId}:handled`,
+        data: {
+          type: "message_handled",
+          messageId: message.messageId
+        },
+        createdAtMs: message.repliedAtMs
+      }
+    ];
+  }).map((event, sourceOrder) => ({ event, sourceOrder })).sort(
+    (left, right) => left.event.createdAtMs - right.event.createdAtMs || left.sourceOrder - right.sourceOrder
+  );
+  const merged = [];
+  let visibleIndex = 0;
+  let currentEpoch = 0;
+  const push = (event, historyVersion) => {
+    merged.push({ ...event, seq: merged.length, historyVersion });
+  };
+  for (const executionEvent of [...executionEvents].sort(
+    (left, right) => left.seq - right.seq
+  )) {
+    while (visibleIndex < visibleEvents.length && visibleEvents[visibleIndex].event.createdAtMs <= executionEvent.createdAtMs) {
+      push(visibleEvents[visibleIndex].event, currentEpoch);
+      visibleIndex += 1;
+    }
+    push(executionEvent, executionEvent.historyVersion);
+    currentEpoch = Math.max(currentEpoch, executionEvent.historyVersion);
+  }
+  while (visibleIndex < visibleEvents.length) {
+    push(visibleEvents[visibleIndex].event, currentEpoch);
+    visibleIndex += 1;
+  }
+  const firstVisibleSeq = merged.find(
+    (event) => event.data.type === "message"
+  )?.seq;
+  return merged.map(
+    (event) => event.data.type === "messages_summarized" ? {
+      ...event,
+      data: {
+        ...event.data,
+        historyFromSeq: firstVisibleSeq ?? event.seq + 1
+      }
+    } : event
+  );
+}
+async function writeLegacyImport(executor, args) {
+  return withConversationEventLock(executor, args.conversationId, async () => {
+    const db = executor.db();
+    const conversations = await db.select({
+      transcriptPurgedAt: juniorConversations.transcriptPurgedAt
+    }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.conversationId)).for("update");
+    if (conversations[0]?.transcriptPurgedAt) {
+      return false;
+    }
+    const existing = await db.select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(eq(juniorConversationEvents.conversationId, args.conversationId)).limit(1);
+    if (existing.length > 0) {
+      return false;
+    }
+    const createdAt = new Date(args.fallbackCreatedAtMs);
+    await ensureConversationRow(
+      executor,
+      args.conversationId,
+      createdAt,
+      new Date(args.lastActivityAtMs)
+    );
+    const mergedEvents = mergeImportedChronology(
+      args.events,
+      args.messages ?? []
+    );
+    if (mergedEvents.length > 0) {
+      await db.insert(juniorConversationEvents).values(
+        mergedEvents.map((event) => insertRow(args.conversationId, event))
+      );
+    }
+    if (args.child) {
+      const childCreatedAtMs = args.child.events.length > 0 ? Math.min(...args.child.events.map((event) => event.createdAtMs)) : args.fallbackCreatedAtMs;
+      const childLastActivityAtMs = args.child.events.length > 0 ? Math.max(...args.child.events.map((event) => event.createdAtMs)) : childCreatedAtMs;
+      await insertLegacyAdvisorChildRow(
+        executor,
+        args.child.conversationId,
+        args.conversationId,
+        new Date(childCreatedAtMs),
+        new Date(childLastActivityAtMs)
+      );
+      if (args.child.events.length > 0) {
+        await db.insert(juniorConversationEvents).values(
+          args.child.events.map(
+            (event) => insertRow(args.child.conversationId, event)
+          )
+        );
+      }
+    }
+    return true;
+  });
+}
+async function ensureConversationRow(executor, conversationId, createdAt, lastActivityAt) {
+  await executor.db().insert(juniorConversations).values({
+    conversationId,
+    schemaVersion: 1,
+    createdAt,
+    lastActivityAt,
+    updatedAt: lastActivityAt,
+    executionStatus: "idle"
+  }).onConflictDoUpdate({
+    target: juniorConversations.conversationId,
+    set: {
+      createdAt: sql`least(${juniorConversations.createdAt}, excluded.created_at)`,
+      lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+      updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`
+    }
+  });
+}
+async function insertLegacyAdvisorChildRow(executor, childConversationId, parentConversationId, createdAt, lastActivityAt) {
+  await ensureConversationRow(
+    executor,
+    parentConversationId,
+    createdAt,
+    lastActivityAt
+  );
+  await executor.db().insert(juniorConversations).values({
+    conversationId: childConversationId,
+    schemaVersion: 1,
+    parentConversationId,
+    createdAt,
+    lastActivityAt,
+    updatedAt: lastActivityAt,
+    executionStatus: "idle"
+  }).onConflictDoUpdate({
+    target: juniorConversations.conversationId,
+    set: {
+      createdAt: sql`least(${juniorConversations.createdAt}, excluded.created_at)`,
+      lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+      updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`
+    }
+  });
+  const rows = await executor.db().select({
+    parentConversationId: juniorConversations.parentConversationId
+  }).from(juniorConversations).where(eq(juniorConversations.conversationId, childConversationId));
+  const child = rows[0];
+  if (!child || child.parentConversationId !== parentConversationId) {
+    throw new Error(
+      "Legacy advisor child conflicts with existing conversation lineage"
+    );
+  }
+}
+
+// src/cli/upgrade/migrations/conversation-history/import.ts
+var legacyVisibleMessageSchema = z3.object({
+  id: z3.string(),
+  role: z3.enum(["user", "assistant", "system"]),
+  text: z3.string(),
+  createdAtMs: z3.number().finite(),
+  author: z3.object({}).passthrough().optional(),
+  meta: z3.object({}).passthrough().optional()
+});
+var legacyCompactionSchema = z3.object({
+  coveredMessageIds: z3.array(z3.string()),
+  createdAtMs: z3.number().finite(),
+  id: z3.string(),
+  summary: z3.string()
+});
+function toImportedMessage(message) {
+  const meta = {};
+  if (message.author) meta.author = message.author;
+  const { replied: _replied, ...restMeta } = message.meta ?? {};
+  Object.assign(meta, restMeta);
+  return {
+    messageId: message.id,
+    role: message.role,
+    text: message.text,
+    ...Object.keys(meta).length > 0 ? { meta } : {},
+    createdAtMs: message.createdAtMs
+  };
+}
+var legacyThreadStateSnapshotSchema = z3.object({
+  conversation: z3.object({
+    compactions: z3.array(legacyCompactionSchema).optional(),
+    messages: z3.array(legacyVisibleMessageSchema).optional(),
+    stats: z3.object({
+      compactedMessageCount: z3.number().finite().optional(),
+      updatedAtMs: z3.number().finite().optional()
+    }).passthrough().optional()
+  }).passthrough().optional()
+});
+async function loadThreadStateSnapshot(conversationId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const raw = await stateAdapter.get(`thread-state:${conversationId}`);
+  if (!raw) {
+    return { compactions: [], messages: [] };
+  }
+  const conversation = legacyThreadStateSnapshotSchema.parse(raw).conversation;
+  return {
+    compactions: conversation?.compactions ?? [],
+    messages: conversation?.messages ?? [],
+    ...conversation?.stats?.compactedMessageCount !== void 0 ? { compactedMessageCount: conversation.stats.compactedMessageCount } : {},
+    ...conversation?.stats?.updatedAtMs !== void 0 ? { lastActivityAtMs: conversation.stats.updatedAtMs } : {}
+  };
+}
+function intrinsicTimestamps(entries, visible, compactions) {
+  const candidates = [];
+  const pushMessageTs = (message) => {
+    const timestamp = message.timestamp;
+    if (typeof timestamp === "number") {
+      candidates.push(timestamp);
+    }
+  };
+  for (const entry of entries) {
+    if (entry.type === "pi_message") {
+      pushMessageTs(entry.message);
+    } else if (entry.type === "projection_reset") {
+      entry.messages.forEach(pushMessageTs);
+    } else if ("createdAtMs" in entry) {
+      candidates.push(entry.createdAtMs);
+    }
+  }
+  for (const message of visible) {
+    candidates.push(message.createdAtMs);
+  }
+  for (const compaction of compactions) {
+    candidates.push(compaction.createdAtMs);
+  }
+  return candidates;
+}
+async function importConversationFromLegacy(conversationId, deps) {
+  const existing = await deps.executor.db().select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(eq2(juniorConversationEvents.conversationId, conversationId)).limit(1);
+  if (existing.length > 0) {
+    return { imported: false };
+  }
+  const entries = deps.sessionLogStore ? await deps.sessionLogStore.read({ conversationId }) : await readSessionLogEntries({ conversationId });
+  const snapshot = deps.loadVisibleMessages ? {
+    compactions: deps.legacyCompactions ?? [],
+    messages: await deps.loadVisibleMessages(conversationId)
+  } : await loadThreadStateSnapshot(conversationId);
+  const { compactedMessageCount, compactions, messages: visible } = snapshot;
+  if (entries.length === 0 && visible.length === 0 && compactions.length === 0) {
+    return { imported: false };
+  }
+  const hasAdvisor = entries.some((entry) => entry.type === "subagent_started");
+  const advisorMessages = hasAdvisor ? await (deps.advisorSessionStore ?? createLegacyAdvisorSessionReader()).load(conversationId) : [];
+  const intrinsic = intrinsicTimestamps(entries, visible, compactions);
+  for (const message of advisorMessages) {
+    const timestamp = message.timestamp;
+    if (typeof timestamp === "number") {
+      intrinsic.push(timestamp);
+    }
+  }
+  const fallbackCreatedAtMs = deps.conversationRecord?.createdAtMs ?? (intrinsic.length > 0 ? Math.min(...intrinsic) : void 0) ?? 0;
+  const lastActivityAtMs = Math.max(
+    fallbackCreatedAtMs,
+    deps.conversationRecord?.lastActivityAtMs ?? 0,
+    deps.legacyLastActivityAtMs ?? 0,
+    intrinsic.length > 0 ? Math.max(...intrinsic) : 0
+  );
+  const converted = convertLegacySessionLog({
+    conversationId,
+    entries,
+    fallbackCreatedAtMs,
+    modelId: deps.modelId
+  });
+  if (compactions.length > 0) {
+    const storedCount = compactions.reduce(
+      (count, compaction) => count + compaction.coveredMessageIds.length,
+      0
+    );
+    const statsCount = typeof compactedMessageCount === "number" && Number.isFinite(compactedMessageCount) && compactedMessageCount > 0 ? Math.floor(compactedMessageCount) : 0;
+    const totalCount = Math.max(storedCount, statsCount);
+    const compacted = compactions.map((compaction, index) => ({
+      id: compaction.id,
+      summary: compaction.summary,
+      createdAtMs: compaction.createdAtMs,
+      coveredMessageCount: compaction.coveredMessageIds.length + (index === 0 ? totalCount - storedCount : 0)
+    }));
+    converted.events.push({
+      seq: converted.events.length,
+      historyVersion: converted.events.at(-1)?.historyVersion ?? 0,
+      data: {
+        type: "messages_summarized",
+        historyFromSeq: 0,
+        compactions: compacted
+      },
+      createdAtMs: compactions.at(-1)?.createdAtMs ?? fallbackCreatedAtMs
+    });
+  }
+  let child;
+  if (converted.advisorChildConversationId) {
+    child = {
+      conversationId: converted.advisorChildConversationId,
+      events: convertAdvisorMessages(advisorMessages, fallbackCreatedAtMs)
+    };
+  }
+  const messages = visible.map((message) => ({
+    ...toImportedMessage(message),
+    ...message.meta?.replied ? { repliedAtMs: message.createdAtMs } : {}
+  }));
+  const imported = await writeLegacyImport(deps.executor, {
+    conversationId,
+    fallbackCreatedAtMs,
+    lastActivityAtMs,
+    ...messages.length > 0 ? { messages } : {},
+    events: converted.events,
+    ...child ? { child } : {}
+  });
+  return { imported };
+}
+
 // src/cli/upgrade/migrations/conversations-history-sql.ts
-var HISTORY_BACKFILL_LIMIT = 1e4;
+var HISTORY_BACKFILL_PAGE_SIZE = 500;
 async function migrateConversationHistoryToSql(context, options = {}) {
   const source = createStateConversationStore(context.stateAdapter);
+  const chatConfig = getChatConfig();
   let executor = options.executor;
   let closeExecutor;
   if (!executor) {
-    const { sql } = getChatConfig();
+    const { sql: sql2 } = chatConfig;
     executor = createJuniorSqlExecutor({
-      connectionString: sql.databaseUrl,
-      driver: sql.driver
+      connectionString: sql2.databaseUrl,
+      driver: sql2.driver
     });
     closeExecutor = () => executor.close();
   }
-  const limit = Math.max(1, options.batchSize ?? HISTORY_BACKFILL_LIMIT);
+  const pageSize = Math.max(
+    1,
+    Math.floor(options.batchSize ?? HISTORY_BACKFILL_PAGE_SIZE)
+  );
   try {
-    const messageStore = createSqlConversationMessageStore(executor);
-    const conversations = await source.listByActivity({ limit });
     let migrated = 0;
     let existing = 0;
-    for (const conversation of conversations) {
-      const result = await importConversationFromLegacy(
-        conversation.conversationId,
-        {
-          executor,
-          messageStore,
-          conversationRecord: conversation,
-          ...options.sessionLogStore ? { sessionLogStore: options.sessionLogStore } : {},
-          ...options.advisorSessionStore ? { advisorSessionStore: options.advisorSessionStore } : {},
-          ...options.loadVisibleMessages ? { loadVisibleMessages: options.loadVisibleMessages } : {}
+    let scanned = 0;
+    let offset = 0;
+    while (true) {
+      const conversations = await source.listByActivity({
+        limit: pageSize,
+        offset
+      });
+      if (conversations.length === 0) {
+        break;
+      }
+      for (const conversation of conversations) {
+        const result = await importConversationFromLegacy(
+          conversation.conversationId,
+          {
+            executor,
+            modelId: standardModelId(chatConfig.bot),
+            conversationRecord: conversation,
+            ...options.sessionLogStore ? { sessionLogStore: options.sessionLogStore } : {},
+            ...options.advisorSessionStore ? { advisorSessionStore: options.advisorSessionStore } : {},
+            ...options.loadVisibleMessages ? { loadVisibleMessages: options.loadVisibleMessages } : {}
+          }
+        );
+        if (result.imported) {
+          migrated += 1;
+        } else {
+          existing += 1;
         }
-      );
-      if (result.imported) {
-        migrated += 1;
-      } else {
-        existing += 1;
       }
+      scanned += conversations.length;
+      offset += conversations.length;
     }
     return {
       existing,
       migrated,
       missing: 0,
-      scanned: conversations.length
+      scanned
     };
   } finally {
     await closeExecutor?.();
   }
 }
 var sqlConversationHistoryMigration = {
-  name: "backfill-agent-steps-sql",
+  name: "backfill-conversation-events-sql",
   run: migrateConversationHistoryToSql
 };
 
@@ -407,10 +1355,10 @@ async function runPluginStorageMigrations(context) {
     return emptyResult();
   }
   const previousConfig = pluginCatalogRuntime.setConfig(pluginCatalogConfig);
-  const sql = getChatConfig().sql;
+  const sql2 = getChatConfig().sql;
   const ownedExecutor = context.db ? void 0 : createJuniorSqlExecutor({
-    connectionString: sql.databaseUrl,
-    driver: sql.driver
+    connectionString: sql2.databaseUrl,
+    driver: sql2.driver
   });
   const sqlUrlDb = ownedExecutor ? ownedExecutor.db() : void 0;
   try {
@@ -566,12 +1514,12 @@ async function migratePluginSchemas(executor, roots) {
 
 // src/cli/upgrade/migrations/plugin-sql.ts
 async function migratePluginsToSql(context) {
-  const { sql } = getChatConfig();
+  const { sql: sql2 } = getChatConfig();
   const { pluginCatalogConfig } = await resolveUpgradePlugins(context);
   const previousConfig = pluginCatalogRuntime.setConfig(pluginCatalogConfig);
   const executor = createJuniorSqlExecutor({
-    connectionString: sql.databaseUrl,
-    driver: sql.driver
+    connectionString: sql2.databaseUrl,
+    driver: sql2.driver
   });
   try {
     const result = await migratePluginSchemas(
@@ -603,8 +1551,8 @@ var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
 var LEGACY_CONVERSATION_WORK_PREFIX = "junior:conversation-work";
 var LEGACY_CONVERSATION_WORK_SCHEMA_VERSION = 1;
 var LEGACY_CONVERSATION_WORK_INDEX_KEY = `${LEGACY_CONVERSATION_WORK_PREFIX}:index`;
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
+var AGENT_TURN_SESSION_PREFIX2 = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX2}:index`;
 var THREAD_STATE_PREFIX = "thread-state";
 function conversationKey(conversationId) {
   return `${CONVERSATION_PREFIX}:${conversationId}`;
@@ -863,9 +1811,9 @@ function uniqueAwaitingContinuationSummaries(values) {
     if (!summary) {
       continue;
     }
-    const key = `${summary.conversationId}:${summary.sessionId}`;
-    if (!summaries.has(key)) {
-      summaries.set(key, summary);
+    const key3 = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(key3)) {
+      summaries.set(key3, summary);
     }
   }
   return [...summaries.values()];
@@ -902,7 +1850,7 @@ async function removeEmulatedIndexEntry(args) {
   await args.stateAdapter.set(args.indexKey, next, JUNIOR_THREAD_STATE_TTL_MS);
 }
 async function upsertRedisIndexEntry(args) {
-  const key = redisIndexKey(args.indexKey);
+  const key3 = redisIndexKey(args.indexKey);
   if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
     const upsertBoundedActivityScript = `
       redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
@@ -917,7 +1865,7 @@ async function upsertRedisIndexEntry(args) {
       "EVAL",
       upsertBoundedActivityScript,
       "1",
-      key,
+      key3,
       String(args.score),
       args.conversationId,
       String(JUNIOR_THREAD_STATE_TTL_MS),
@@ -927,13 +1875,13 @@ async function upsertRedisIndexEntry(args) {
   }
   await args.client.sendCommand([
     "ZADD",
-    key,
+    key3,
     String(args.score),
     args.conversationId
   ]);
   await args.client.sendCommand([
     "PEXPIRE",
-    key,
+    key3,
     String(JUNIOR_THREAD_STATE_TTL_MS)
   ]);
 }
@@ -1128,31 +2076,31 @@ var redisConversationStateMigration = {
 
 // src/cli/upgrade/migrations/agent-turn-session-actor.ts
 import { THREAD_STATE_TTL_MS } from "chat";
-var AGENT_TURN_SESSION_PREFIX2 = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_INDEX_KEY2 = `${AGENT_TURN_SESSION_PREFIX2}:index`;
+var AGENT_TURN_SESSION_PREFIX3 = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_INDEX_KEY2 = `${AGENT_TURN_SESSION_PREFIX3}:index`;
 var AGENT_TURN_SESSION_INDEX_MAX_LENGTH = 5e3;
 var REDIS_SCAN_COUNT = 500;
 function conversationIndexKey(conversationId) {
-  return `${AGENT_TURN_SESSION_PREFIX2}:conversation:${conversationId}:index`;
+  return `${AGENT_TURN_SESSION_PREFIX3}:conversation:${conversationId}:index`;
 }
 function sessionRecordKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX2}:${conversationId}:${sessionId}`;
+  return `${AGENT_TURN_SESSION_PREFIX3}:${conversationId}:${sessionId}`;
 }
 function logicalConversationIndexPrefix() {
   const prefix = getChatConfig().state.keyPrefix;
   return [
     ...prefix ? [prefix] : [],
-    `${AGENT_TURN_SESSION_PREFIX2}:conversation:`
+    `${AGENT_TURN_SESSION_PREFIX3}:conversation:`
   ].join(":");
 }
-function conversationIdFromRedisListKey(key) {
+function conversationIdFromRedisListKey(key3) {
   const marker = `:list:${logicalConversationIndexPrefix()}`;
-  const markerIndex = key.indexOf(marker);
-  if (markerIndex < 0 || !key.endsWith(":index")) {
+  const markerIndex = key3.indexOf(marker);
+  if (markerIndex < 0 || !key3.endsWith(":index")) {
     return void 0;
   }
   return toOptionalString(
-    key.slice(markerIndex + marker.length, -":index".length)
+    key3.slice(markerIndex + marker.length, -":index".length)
   );
 }
 async function discoverRedisConversationIds(redisStateAdapter) {
@@ -1178,11 +2126,11 @@ async function discoverRedisConversationIds(redisStateAdapter) {
       );
     }
     cursor = String(reply[0]);
-    for (const key of reply[1]) {
-      if (typeof key !== "string") {
+    for (const key3 of reply[1]) {
+      if (typeof key3 !== "string") {
         continue;
       }
-      const conversationId = conversationIdFromRedisListKey(key);
+      const conversationId = conversationIdFromRedisListKey(key3);
       if (conversationId) {
         conversationIds.add(conversationId);
       }
@@ -1220,8 +2168,8 @@ async function rewriteList(args) {
   return { migrated: changed, values: migrated.map((entry) => entry.value) };
 }
 async function migrateSessionRecord(args) {
-  const key = sessionRecordKey(args.conversationId, args.sessionId);
-  const existing = await args.stateAdapter.get(key);
+  const key3 = sessionRecordKey(args.conversationId, args.sessionId);
+  const existing = await args.stateAdapter.get(key3);
   if (existing === void 0) {
     return "missing";
   }
@@ -1229,7 +2177,7 @@ async function migrateSessionRecord(args) {
   if (!migrated.changed) {
     return "existing";
   }
-  await args.stateAdapter.set(key, migrated.value, THREAD_STATE_TTL_MS);
+  await args.stateAdapter.set(key3, migrated.value, THREAD_STATE_TTL_MS);
   return "migrated";
 }
 async function migrateAgentTurnSessionActor(context) {
@@ -1327,25 +2275,25 @@ WITH candidates AS MATERIALIZED (
   ORDER BY conversation_id
   LIMIT $2
 ),
--- Occurrence numbers preserve intentional duplicates within one epoch while
--- collapsing context copies of the same message across rebuilt epochs.
+-- Occurrence numbers preserve intentional duplicates within one history version
+-- while collapsing context copies of the same message across replacements.
 message_occurrences AS (
   SELECT
-    step.conversation_id,
-    step.payload -> 'message' AS message,
+    event.conversation_id,
+    event.payload -> 'message' AS message,
     row_number() OVER (
       PARTITION BY
-        step.conversation_id,
-        step.context_epoch,
-        step.payload -> 'message'
-      ORDER BY step.seq
+        event.conversation_id,
+        event.history_version,
+        event.payload -> 'message'
+      ORDER BY event.seq
     ) AS occurrence
-  FROM junior_agent_steps AS step
+  FROM junior_conversation_events AS event
   INNER JOIN candidates AS candidate
-    ON candidate.conversation_id = step.conversation_id
-  WHERE step.type = 'pi_message'
-    AND step.role = 'assistant'
-    AND jsonb_typeof(step.payload -> 'message' -> 'usage') = 'object'
+    ON candidate.conversation_id = event.conversation_id
+  WHERE event.type = 'agent_step'
+    AND event.payload -> 'message' ->> 'role' = 'assistant'
+    AND jsonb_typeof(event.payload -> 'message' -> 'usage') = 'object'
 ),
 canonical_messages AS (
   SELECT DISTINCT conversation_id, message, occurrence
@@ -1537,10 +2485,10 @@ async function repairConversationUsage(_context, options = {}) {
   let executor = options.executor;
   let closeExecutor;
   if (!executor) {
-    const { sql } = getChatConfig();
+    const { sql: sql2 } = getChatConfig();
     executor = createJuniorSqlExecutor({
-      connectionString: sql.databaseUrl,
-      driver: sql.driver
+      connectionString: sql2.databaseUrl,
+      driver: sql2.driver
     });
     closeExecutor = () => executor.close();
   }
@@ -1594,6 +2542,990 @@ var conversationUsageRepairMigration = {
   run: repairConversationUsage
 };
 
+// src/cli/upgrade/migrations/conversation-event-cursors.ts
+var REDIS_SCAN_COUNT2 = 500;
+function rawTurnSessionKeyPattern() {
+  const statePrefix = getChatConfig().state.keyPrefix;
+  return `*:cache:${statePrefix ? `${statePrefix}:` : ""}${AGENT_TURN_SESSION_PREFIX}:*`;
+}
+function logicalStateKey(rawKey2) {
+  const statePrefix = getChatConfig().state.keyPrefix;
+  const cachePrefix = `:cache:${statePrefix ? `${statePrefix}:` : ""}`;
+  const cacheAt = rawKey2.indexOf(cachePrefix);
+  return cacheAt < 0 ? void 0 : rawKey2.slice(cacheAt + cachePrefix.length);
+}
+async function discoverRawTurnSessionKeys(redisStateAdapter, conversationIds) {
+  const client = redisStateAdapter?.getClient();
+  const discovered = /* @__PURE__ */ new Map();
+  if (!client) return discovered;
+  const targetKeyPrefixes = [...conversationIds].map(
+    (conversationId) => `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:`
+  );
+  let cursor = "0";
+  do {
+    const reply = await client.sendCommand([
+      "SCAN",
+      cursor,
+      "MATCH",
+      rawTurnSessionKeyPattern(),
+      "COUNT",
+      String(REDIS_SCAN_COUNT2)
+    ]);
+    if (!Array.isArray(reply) || reply.length !== 2 || typeof reply[0] !== "string" && typeof reply[0] !== "number" || !Array.isArray(reply[1])) {
+      throw new Error(
+        "Unexpected Redis SCAN response while checking turn-session cursors"
+      );
+    }
+    cursor = String(reply[0]);
+    for (const rawKey2 of reply[1]) {
+      if (typeof rawKey2 !== "string") continue;
+      const logicalKey = logicalStateKey(rawKey2);
+      if (!logicalKey || !targetKeyPrefixes.some((prefix) => logicalKey.startsWith(prefix))) {
+        continue;
+      }
+      const encoded = await client.sendCommand(["GET", rawKey2]);
+      if (encoded === null) continue;
+      if (typeof encoded !== "string") {
+        throw new Error(`Turn-session cursor ${rawKey2} is not JSON text`);
+      }
+      let value;
+      try {
+        value = JSON.parse(encoded);
+      } catch (error) {
+        throw new Error(`Turn-session cursor ${rawKey2} is invalid JSON`, {
+          cause: error
+        });
+      }
+      if (!isRecord(value)) {
+        throw new Error(`Turn-session cursor ${rawKey2} is not an object`);
+      }
+      const conversationId = toOptionalString(value.conversationId);
+      const sessionId = toOptionalString(value.sessionId);
+      if (!conversationId || !sessionId) {
+        throw new Error(`Turn-session cursor ${rawKey2} has no identity`);
+      }
+      const recordKey = agentTurnSessionKey(conversationId, sessionId);
+      if (logicalKey !== recordKey) {
+        throw new Error(
+          `Turn-session cursor ${rawKey2} identity does not match its key`
+        );
+      }
+      if (!conversationIds.has(conversationId)) continue;
+      discovered.set(recordKey, conversationId);
+    }
+  } while (cursor !== "0");
+  return discovered;
+}
+async function indexedTurnSessionIds(context, conversationId) {
+  const summaries = await context.stateAdapter.getList(
+    agentTurnSessionConversationIndexKey(conversationId)
+  );
+  return [
+    ...new Set(
+      summaries.flatMap((summary) => {
+        if (!isRecord(summary)) return [];
+        const sessionId = toOptionalString(summary.sessionId);
+        return sessionId ? [sessionId] : [];
+      })
+    )
+  ];
+}
+function hasSeqCursor(record) {
+  return Number.isInteger(record.committedSeq) || Number.isInteger(record.turnStartSeq);
+}
+async function prepareConversationEventResequence(context, conversationIds) {
+  if (conversationIds.size === 0) return;
+  await context.stateAdapter.connect();
+  const keys = /* @__PURE__ */ new Set();
+  for (const conversationId of conversationIds) {
+    for (const sessionId of await indexedTurnSessionIds(
+      context,
+      conversationId
+    )) {
+      keys.add(agentTurnSessionKey(conversationId, sessionId));
+    }
+  }
+  for (const [key3] of await discoverRawTurnSessionKeys(
+    context.redisStateAdapter,
+    conversationIds
+  )) {
+    keys.add(key3);
+  }
+  const terminalKeys = [];
+  for (const key3 of keys) {
+    const value = await context.stateAdapter.get(key3);
+    if (!isRecord(value) || !hasSeqCursor(value)) continue;
+    if (value.state === "running" || value.state === "awaiting_resume") {
+      throw new Error(
+        `Cannot resequence conversation events while unfinished turn session ${key3} retains a seq cursor`
+      );
+    }
+    if (value.state !== "completed" && value.state !== "failed" && value.state !== "abandoned") {
+      throw new Error(
+        `Cannot resequence conversation events with invalid cursor-bearing turn session ${key3}`
+      );
+    }
+    terminalKeys.push(key3);
+  }
+  for (const key3 of terminalKeys) {
+    await context.stateAdapter.delete(key3);
+  }
+}
+
+// src/cli/upgrade/migrations/conversation-visible-message-events.ts
+var VISIBLE_EVENT_BATCH_SIZE = 500;
+var VISIBLE_EVENT_BACKFILL_LOCK = "junior:upgrade:conversation-visible-message-events";
+var LOAD_VISIBLE_CONVERSATION_IDS_SQL = `
+SELECT DISTINCT conversation_id
+FROM junior_conversation_messages
+WHERE $2::text IS NULL OR conversation_id > $2::text
+ORDER BY conversation_id
+LIMIT $1
+`;
+var LOAD_COMPACTED_CONVERSATION_IDS_SQL = `
+SELECT DISTINCT conversation_id
+FROM junior_conversation_events
+WHERE type = 'messages_summarized'
+  AND payload @? '$.compactions[*].coveredMessageIds'
+  AND ($2::text IS NULL OR conversation_id > $2::text)
+ORDER BY conversation_id
+LIMIT $1
+`;
+var LOAD_MISSING_VISIBLE_EVENTS_SQL = `
+SELECT
+  message.conversation_id,
+  message.message_id,
+  message.role,
+  message.text,
+  message.author_identity_id,
+  message.meta,
+  message.replied_at,
+  message.created_at
+FROM junior_conversation_messages message
+WHERE (
+  NOT EXISTS (
+    SELECT 1
+    FROM junior_conversation_events event
+    WHERE event.conversation_id = message.conversation_id
+      AND event.idempotency_key =
+        'message:' || message.message_id
+  )
+  OR (
+    message.replied_at IS NOT NULL
+    AND NOT EXISTS (
+      SELECT 1
+      FROM junior_conversation_events event
+      WHERE event.conversation_id = message.conversation_id
+        AND event.idempotency_key =
+          'message:' || message.message_id || ':handled'
+    )
+  )
+)
+AND (
+  $2::text IS NULL
+  OR (message.conversation_id, message.created_at, message.message_id) >
+    ($2::text, $3::timestamptz, $4::text)
+)
+ORDER BY message.conversation_id, message.created_at, message.message_id
+LIMIT $1
+`;
+var COUNT_MISSING_VISIBLE_EVENTS_SQL = `
+SELECT count(*)::integer AS count
+FROM junior_conversation_messages message
+WHERE NOT EXISTS (
+  SELECT 1
+  FROM junior_conversation_events event
+  WHERE event.conversation_id = message.conversation_id
+    AND event.idempotency_key =
+      'message:' || message.message_id
+)
+OR (
+  message.replied_at IS NOT NULL
+  AND NOT EXISTS (
+    SELECT 1
+    FROM junior_conversation_events event
+    WHERE event.conversation_id = message.conversation_id
+      AND event.idempotency_key =
+        'message:' || message.message_id || ':handled'
+  )
+)
+`;
+function timestampMs(value) {
+  return value instanceof Date ? value.getTime() : new Date(value).getTime();
+}
+function eventsForRow(row) {
+  const events = [
+    {
+      idempotencyKey: `message:${row.message_id}`,
+      data: {
+        type: "message",
+        messageId: row.message_id,
+        role: row.role,
+        text: row.text,
+        ...row.author_identity_id ? { authorIdentityId: row.author_identity_id } : {},
+        ...row.meta ? { meta: row.meta } : {}
+      },
+      createdAtMs: timestampMs(row.created_at)
+    }
+  ];
+  if (row.replied_at) {
+    events.push({
+      idempotencyKey: `message:${row.message_id}:handled`,
+      data: { type: "message_handled", messageId: row.message_id },
+      createdAtMs: timestampMs(row.replied_at)
+    });
+  }
+  return events;
+}
+async function visitConversationIds(executor, query, batchSize, visit) {
+  let cursor;
+  while (true) {
+    const rows = await executor.query(query, [
+      batchSize,
+      cursor ?? null
+    ]);
+    if (rows.length === 0) return;
+    for (const row of rows) {
+      await visit(row.conversation_id);
+    }
+    cursor = rows.at(-1).conversation_id;
+  }
+}
+async function visitVisibleConversations(executor, batchSize, visit) {
+  await visitConversationIds(
+    executor,
+    LOAD_VISIBLE_CONVERSATION_IDS_SQL,
+    batchSize,
+    visit
+  );
+}
+async function readLegacyCompactionState(context, conversationId) {
+  const raw = await context.stateAdapter.get(
+    `thread-state:${conversationId}`
+  );
+  const conversation = isRecord(raw) && isRecord(raw.conversation) ? raw.conversation : void 0;
+  const stats = conversation && isRecord(conversation.stats) ? conversation.stats : void 0;
+  const rawCount = toOptionalNumber(stats?.compactedMessageCount);
+  const compactedMessageCount = rawCount === void 0 ? void 0 : Math.max(0, Math.floor(rawCount));
+  const messages = conversation && Array.isArray(conversation.messages) ? conversation.messages : [];
+  const liveMessageIds = new Set(
+    messages.flatMap((message) => {
+      if (!isRecord(message)) return [];
+      const id = toOptionalString(message.id);
+      return id ? [id] : [];
+    })
+  );
+  return {
+    ...compactedMessageCount === void 0 ? {} : { compactedMessageCount },
+    liveMessageIds
+  };
+}
+function sqlVisibleEvents(events) {
+  return events.map((event) => {
+    const parsed = newConversationEventSchema.parse(event);
+    if (!parsed.idempotencyKey) {
+      throw new Error(
+        "Visible-message backfill events require idempotency keys"
+      );
+    }
+    const { type, ...payload } = conversationEventDataSchema.parse(parsed.data);
+    return {
+      createdAtMs: parsed.createdAtMs,
+      idempotencyKey: parsed.idempotencyKey,
+      payload: sanitizePostgresJson(payload),
+      type
+    };
+  });
+}
+async function loadVisibleCompactionAnchor(executor, conversationId) {
+  const [row] = await executor.query(
+    `WITH snapshot AS (
+       SELECT payload
+       FROM junior_conversation_events
+       WHERE conversation_id = $1
+         AND type = 'messages_summarized'
+       ORDER BY seq DESC
+       LIMIT 1
+     )
+     SELECT (
+       SELECT event.payload->>'messageId'
+       FROM junior_conversation_events event
+       WHERE event.conversation_id = $1
+         AND event.type = 'message'
+         AND event.seq >= (snapshot.payload->>'historyFromSeq')::integer
+       ORDER BY event.seq
+       LIMIT 1
+     ) AS "messageId"
+     FROM snapshot`,
+    [conversationId]
+  );
+  return row;
+}
+async function normalizeVisibleCompactionBoundary(executor, conversationId, anchor) {
+  if (!anchor) return;
+  let historyFromSeq;
+  if (anchor.messageId) {
+    const [baseline] = await executor.query(
+      `SELECT seq
+       FROM junior_conversation_events
+       WHERE conversation_id = $1
+         AND type = 'message'
+         AND payload->>'messageId' = $2
+       ORDER BY seq
+       LIMIT 1`,
+      [conversationId, anchor.messageId]
+    );
+    if (!baseline) {
+      throw new Error(
+        `Visible compaction anchor ${anchor.messageId} disappeared during resequence`
+      );
+    }
+    historyFromSeq = baseline.seq;
+  } else {
+    const [end] = await executor.query(
+      `SELECT coalesce(max(seq), -1)::integer + 1 AS seq
+       FROM junior_conversation_events
+       WHERE conversation_id = $1`,
+      [conversationId]
+    );
+    historyFromSeq = end?.seq ?? 0;
+  }
+  await executor.execute(
+    `WITH snapshot AS (
+       SELECT ctid
+       FROM junior_conversation_events
+       WHERE conversation_id = $1
+         AND type = 'messages_summarized'
+       ORDER BY seq DESC
+       LIMIT 1
+     )
+     UPDATE junior_conversation_events event
+     SET payload = jsonb_set(
+       event.payload,
+       '{historyFromSeq}',
+       to_jsonb($2::integer)
+     )
+     FROM snapshot
+     WHERE event.ctid = snapshot.ctid`,
+    [conversationId, historyFromSeq]
+  );
+}
+function coveredMessageIds(payload) {
+  if (!Array.isArray(payload.compactions)) return [];
+  return payload.compactions.flatMap((compaction) => {
+    if (!isRecord(compaction) || !Array.isArray(compaction.coveredMessageIds)) {
+      return [];
+    }
+    return compaction.coveredMessageIds.flatMap((id) => {
+      const value = toOptionalString(id);
+      return value ? [value] : [];
+    });
+  });
+}
+function retainedCompactionCount(payload) {
+  if (!Array.isArray(payload.compactions)) return 0;
+  return payload.compactions.reduce((total, value) => {
+    if (!isRecord(value)) return total;
+    const stored = toOptionalNumber(value.coveredMessageCount);
+    const legacy = Array.isArray(value.coveredMessageIds) ? value.coveredMessageIds.length : 0;
+    return total + (stored === void 0 ? legacy : Math.max(0, stored));
+  }, 0);
+}
+function resolvedHistoryFromSeq(args) {
+  if (args.legacyState.liveMessageIds.size > 0) {
+    const live = args.visibleEvents.find(
+      (event) => args.legacyState.liveMessageIds.has(event.messageId)
+    );
+    if (live) return live.seq;
+  }
+  if (args.legacyState.compactedMessageCount !== void 0) {
+    return args.visibleEvents[args.legacyState.compactedMessageCount]?.seq ?? args.endSeq;
+  }
+  const coveredIds = new Set(args.legacyCoveredMessageIds);
+  if (coveredIds.size > 0) {
+    const lastCoveredSeq = args.visibleEvents.reduce(
+      (last, event) => coveredIds.has(event.messageId) ? Math.max(last, event.seq) : last,
+      -1
+    );
+    return args.visibleEvents.find((event) => event.seq > lastCoveredSeq)?.seq ?? args.endSeq;
+  }
+  return args.currentHistoryFromSeq > 0 ? args.currentHistoryFromSeq : args.visibleEvents[0]?.seq ?? args.endSeq;
+}
+async function finalizeVisibleCompactions(context, executor, conversationId) {
+  const legacyState = await readLegacyCompactionState(context, conversationId);
+  await executor.withLock(
+    `junior_conversation:event:${conversationId}`,
+    async () => {
+      const [latest] = await executor.query(
+        `SELECT seq, payload
+         FROM junior_conversation_events
+         WHERE conversation_id = $1
+           AND type = 'messages_summarized'
+         ORDER BY seq DESC
+         LIMIT 1`,
+        [conversationId]
+      );
+      if (!latest) return;
+      const visibleEvents = await executor.query(
+        `SELECT seq, payload->>'messageId' AS "messageId"
+         FROM junior_conversation_events
+         WHERE conversation_id = $1
+           AND type = 'message'
+         ORDER BY seq`,
+        [conversationId]
+      );
+      const [cursor] = await executor.query(
+        `SELECT coalesce(max(seq), -1)::integer + 1 AS "endSeq"
+         FROM junior_conversation_events
+         WHERE conversation_id = $1`,
+        [conversationId]
+      );
+      const currentHistoryFromSeq = toOptionalNumber(latest.payload.historyFromSeq) ?? 0;
+      const historyFromSeq = resolvedHistoryFromSeq({
+        currentHistoryFromSeq: Math.max(0, Math.floor(currentHistoryFromSeq)),
+        endSeq: cursor?.endSeq ?? 0,
+        legacyCoveredMessageIds: coveredMessageIds(latest.payload),
+        legacyState,
+        visibleEvents
+      });
+      const retainedCount = retainedCompactionCount(latest.payload);
+      const countDelta = Math.max(
+        0,
+        (legacyState.compactedMessageCount ?? retainedCount) - retainedCount
+      );
+      await executor.execute(
+        `WITH rewritten AS (
+           SELECT
+             event.ctid,
+             jsonb_agg(
+               (compaction.value - 'coveredMessageIds') ||
+               jsonb_build_object(
+                 'coveredMessageCount',
+                 coalesce(
+                   (compaction.value->>'coveredMessageCount')::integer,
+                   jsonb_array_length(
+                     coalesce(compaction.value->'coveredMessageIds', '[]'::jsonb)
+                   )
+                 ) + CASE
+                   WHEN event.seq = $2 AND compaction.position = 1 THEN $4
+                   ELSE 0
+                 END
+               )
+               ORDER BY compaction.position
+             ) AS compactions
+           FROM junior_conversation_events event
+           CROSS JOIN LATERAL jsonb_array_elements(
+             event.payload->'compactions'
+           ) WITH ORDINALITY AS compaction(value, position)
+           WHERE event.conversation_id = $1
+             AND event.type = 'messages_summarized'
+           GROUP BY event.ctid
+         )
+         UPDATE junior_conversation_events event
+         SET payload =
+           (event.payload - 'compactions') ||
+           jsonb_build_object('compactions', rewritten.compactions) ||
+           CASE WHEN event.seq = $2
+             THEN jsonb_build_object('historyFromSeq', $3::integer)
+             ELSE '{}'::jsonb
+           END
+         FROM rewritten
+         WHERE event.ctid = rewritten.ctid`,
+        [conversationId, latest.seq, historyFromSeq, countDelta]
+      );
+    }
+  );
+}
+async function mergeVisibleEvents(executor, conversationId, events) {
+  const encoded = sqlVisibleEvents(events);
+  await executor.withLock(
+    `junior_conversation:event:${conversationId}`,
+    async () => {
+      await executor.transaction(async () => {
+        const compactionAnchor = await loadVisibleCompactionAnchor(
+          executor,
+          conversationId
+        );
+        await executor.execute(
+          `WITH input AS (
+             SELECT *
+             FROM jsonb_to_recordset($2::jsonb) AS event(
+               "createdAtMs" bigint,
+               "idempotencyKey" text,
+               payload jsonb,
+               type text
+             )
+           ), base AS (
+             SELECT coalesce(max(seq), -1) AS max_seq
+             FROM junior_conversation_events
+             WHERE conversation_id = $1
+           ), pending AS (
+             SELECT
+               input.*,
+               row_number() OVER (
+                 ORDER BY input."createdAtMs", input."idempotencyKey"
+               ) AS offset
+             FROM input
+             WHERE NOT EXISTS (
+               SELECT 1
+               FROM junior_conversation_events existing
+               WHERE existing.conversation_id = $1
+                 AND existing.idempotency_key = input."idempotencyKey"
+             )
+           )
+           INSERT INTO junior_conversation_events (
+             conversation_id,
+             seq,
+             history_version,
+             schema_version,
+             idempotency_key,
+             type,
+             payload,
+             created_at
+           )
+           SELECT
+             $1,
+             base.max_seq + pending.offset,
+             coalesce((
+               SELECT prior.history_version
+               FROM junior_conversation_events prior
+               WHERE prior.conversation_id = $1
+                 AND prior.created_at < to_timestamp(pending."createdAtMs" / 1000.0)
+               ORDER BY prior.seq DESC
+               LIMIT 1
+             ), 0),
+             1,
+             pending."idempotencyKey",
+             pending.type,
+             pending.payload,
+             to_timestamp(pending."createdAtMs" / 1000.0)
+           FROM pending
+           CROSS JOIN base
+           ON CONFLICT (conversation_id, idempotency_key) DO NOTHING`,
+          [conversationId, JSON.stringify(encoded)]
+        );
+        await executor.execute(
+          `UPDATE junior_conversation_events
+           SET seq = -seq - 1
+           WHERE conversation_id = $1`,
+          [conversationId]
+        );
+        await executor.execute(
+          `WITH ranked AS (
+             SELECT
+               event.ctid,
+               row_number() OVER (
+                 ORDER BY
+                   CASE
+                     WHEN event.type IN (
+                       'message',
+                       'message_handled'
+                     ) THEN coalesce((
+                       SELECT max(-execution.seq - 1)
+                       FROM junior_conversation_events execution
+                       WHERE execution.conversation_id = event.conversation_id
+                         AND execution.type NOT IN (
+                           'message',
+                           'message_handled'
+                         )
+                         AND execution.created_at < event.created_at
+                     ), -1)
+                     ELSE -event.seq - 1
+                   END,
+                   CASE
+                     WHEN event.type IN (
+                       'message',
+                       'message_handled'
+                     ) THEN 1
+                     ELSE 0
+                   END,
+                   event.created_at,
+                   CASE event.type
+                     WHEN 'message' THEN 0
+                     WHEN 'message_handled' THEN 1
+                     ELSE 0
+                   END,
+                   event.idempotency_key NULLS FIRST,
+                   event.type
+               ) - 1 AS next_seq
+             FROM junior_conversation_events event
+             WHERE event.conversation_id = $1
+           )
+           UPDATE junior_conversation_events event
+           SET seq = ranked.next_seq
+           FROM ranked
+           WHERE event.ctid = ranked.ctid`,
+          [conversationId]
+        );
+        await normalizeVisibleCompactionBoundary(
+          executor,
+          conversationId,
+          compactionAnchor
+        );
+      });
+    }
+  );
+}
+async function migrateConversationVisibleMessageEvents(context, options = {}) {
+  let executor = options.executor;
+  let closeExecutor;
+  if (!executor) {
+    const { sql: sql2 } = getChatConfig();
+    executor = createJuniorSqlExecutor({
+      connectionString: sql2.databaseUrl,
+      driver: sql2.driver
+    });
+    closeExecutor = () => executor.close();
+  }
+  const batchSize = Math.max(
+    1,
+    Math.floor(options.batchSize ?? VISIBLE_EVENT_BATCH_SIZE)
+  );
+  let migrated = 0;
+  let cursor;
+  try {
+    const [legacyTable] = await executor.query(
+      `SELECT to_regclass('public.junior_conversation_messages') IS NOT NULL AS exists`
+    );
+    if (!legacyTable?.exists) {
+      return { existing: 0, migrated: 0, missing: 0, scanned: 0 };
+    }
+    const [before] = await executor.query(
+      COUNT_MISSING_VISIBLE_EVENTS_SQL
+    );
+    if (!before) {
+      throw new Error(
+        "Visible-message event migration could not inspect its projection"
+      );
+    }
+    if (before.count > 0) {
+      const visibleConversationIds = /* @__PURE__ */ new Set();
+      await visitVisibleConversations(
+        executor,
+        batchSize,
+        async (conversationId) => {
+          visibleConversationIds.add(conversationId);
+        }
+      );
+      await prepareConversationEventResequence(context, visibleConversationIds);
+    }
+    while (true) {
+      const rows = await executor.withLock(
+        VISIBLE_EVENT_BACKFILL_LOCK,
+        () => executor.query(LOAD_MISSING_VISIBLE_EVENTS_SQL, [
+          batchSize,
+          cursor?.conversationId ?? null,
+          cursor?.createdAt ?? null,
+          cursor?.messageId ?? null
+        ])
+      );
+      if (rows.length === 0) {
+        break;
+      }
+      const grouped = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const events = grouped.get(row.conversation_id) ?? [];
+        events.push(...eventsForRow(row));
+        grouped.set(row.conversation_id, events);
+      }
+      for (const [conversationId, events] of grouped) {
+        await mergeVisibleEvents(executor, conversationId, events);
+      }
+      migrated += rows.length;
+      const last = rows.at(-1);
+      cursor = {
+        conversationId: last.conversation_id,
+        createdAt: last.created_at,
+        messageId: last.message_id
+      };
+    }
+    const [remaining] = await executor.query(
+      COUNT_MISSING_VISIBLE_EVENTS_SQL
+    );
+    if (!remaining) {
+      throw new Error(
+        "Visible-message event migration could not verify its projection"
+      );
+    }
+    if (remaining.count > 0) {
+      throw new Error(
+        `Visible-message event migration left ${remaining.count} message row(s) without canonical events`
+      );
+    }
+    await visitConversationIds(
+      executor,
+      LOAD_COMPACTED_CONVERSATION_IDS_SQL,
+      batchSize,
+      async (conversationId) => await finalizeVisibleCompactions(context, executor, conversationId)
+    );
+    return {
+      existing: 0,
+      migrated,
+      missing: 0,
+      scanned: migrated
+    };
+  } finally {
+    await closeExecutor?.();
+  }
+}
+var conversationVisibleMessageEventsMigration = {
+  name: "move-conversation-messages-to-events",
+  run: migrateConversationVisibleMessageEvents
+};
+
+// src/cli/upgrade/migrations/conversation-context-checkpoints.ts
+import { isDeepStrictEqual } from "util";
+var PAGE_SIZE = 250;
+function messageTextParts(message) {
+  if (typeof message.content === "string") {
+    return [message.content];
+  }
+  if (!Array.isArray(message.content)) {
+    return [];
+  }
+  return message.content.flatMap(
+    (part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" ? [part.text] : []
+  );
+}
+function checkpointEnd(messages) {
+  return messages.findIndex((row) => {
+    const message = row.payload.message;
+    return message !== null && typeof message === "object" && !Array.isArray(message) && messageTextParts(message).some(
+      isLegacyOrCurrentCheckpointText
+    );
+  });
+}
+function matchingMessagePrefix(previous, current) {
+  const limit = Math.min(previous.length, current.length);
+  let count = 0;
+  while (count < limit && isDeepStrictEqual(
+    previous[count].payload.message,
+    current[count].payload.message
+  )) {
+    count += 1;
+  }
+  return count;
+}
+function replacementEntry(row, normalizeCheckpoint) {
+  const message = row.payload.message;
+  if (message === null || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error(
+      `Conversation message event ${row.seq} has no message object`
+    );
+  }
+  return {
+    message: normalizeCheckpoint ? normalizeLegacyContextMessage(message) : message,
+    ...row.payload.provenance === void 0 ? {} : { provenance: row.payload.provenance }
+  };
+}
+function resolvedBinding(payload, bot) {
+  const modelProfile = payload.modelProfile === void 0 ? "standard" : modelProfileSchema.parse(payload.modelProfile);
+  const modelId = payload.modelId;
+  if (modelId !== void 0 && (typeof modelId !== "string" || !modelId)) {
+    throw new Error("Context checkpoint modelId must be a non-empty string");
+  }
+  return {
+    modelProfile,
+    modelId: modelId ?? modelIdForProfile(bot, modelProfile)
+  };
+}
+function handoffToolCallId(rows, marker) {
+  if (typeof marker.payload.triggeringToolCallId === "string" && marker.payload.triggeringToolCallId.length > 0) {
+    return marker.payload.triggeringToolCallId;
+  }
+  const tool = [...rows].reverse().find(
+    (row) => row.seq < marker.seq && row.type === "tool_execution_started" && row.payload.toolName === "handoff" && typeof row.payload.toolCallId === "string" && row.payload.toolCallId.length > 0
+  );
+  if (typeof tool?.payload.toolCallId !== "string") {
+    throw new Error(
+      `Cannot correlate handoff checkpoint at event ${marker.seq} during upgrade`
+    );
+  }
+  return tool.payload.toolCallId;
+}
+async function normalizeConversation(args) {
+  return await args.executor.withLock(
+    `junior_conversation:event:${args.conversationId}`,
+    async () => await args.executor.transaction(async () => {
+      const rows = await args.executor.query(
+        `SELECT
+         seq,
+         history_version AS "historyVersion",
+         type,
+         payload
+       FROM junior_conversation_events
+       WHERE conversation_id = $1
+         AND type IN ('context_epoch_started', 'agent_step', 'tool_execution_started')
+       ORDER BY seq`,
+        [args.conversationId]
+      );
+      const messagesByEpoch = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        if (row.type !== "agent_step") continue;
+        const messages = messagesByEpoch.get(row.historyVersion) ?? [];
+        messages.push(row);
+        messagesByEpoch.set(row.historyVersion, messages);
+      }
+      let migrated = 0;
+      const removedSeqs = [];
+      for (const marker of rows) {
+        if (marker.type !== "context_epoch_started") {
+          continue;
+        }
+        const reason = marker.payload.reason;
+        if (reason === "initial") {
+          removedSeqs.push(marker.seq);
+          migrated += 1;
+          continue;
+        }
+        if (reason !== "compaction" && reason !== "handoff" && reason !== "rollback") {
+          throw new Error(
+            `Unknown context checkpoint reason at event ${marker.seq}`
+          );
+        }
+        let replacementHistory = marker.payload.replacementHistory;
+        if (!Array.isArray(replacementHistory)) {
+          const current = messagesByEpoch.get(marker.historyVersion) ?? [];
+          let replacementCount;
+          if (reason === "rollback") {
+            const previous = messagesByEpoch.get(marker.historyVersion - 1) ?? [];
+            replacementCount = matchingMessagePrefix(previous, current);
+          } else {
+            const end = checkpointEnd(current);
+            replacementCount = end < 0 ? current.length : end + 1;
+          }
+          const replacementRows = current.slice(0, replacementCount);
+          replacementHistory = replacementRows.map(
+            (row, index) => replacementEntry(
+              row,
+              reason !== "rollback" && index === replacementRows.length - 1
+            )
+          );
+          removedSeqs.push(...replacementRows.map((row) => row.seq));
+        }
+        const binding = resolvedBinding(marker.payload, args.bot);
+        const parsed = conversationEventDataSchema.parse({
+          type: reason,
+          ...binding,
+          ...reason === "handoff" ? { triggeringToolCallId: handoffToolCallId(rows, marker) } : {},
+          replacementHistory
+        });
+        const { type, ...payload } = parsed;
+        await args.executor.execute(
+          `UPDATE junior_conversation_events
+         SET type = $3, payload = $4::jsonb
+         WHERE conversation_id = $1 AND seq = $2`,
+          [
+            args.conversationId,
+            marker.seq,
+            type,
+            JSON.stringify(sanitizePostgresJson(payload))
+          ]
+        );
+        migrated += 1;
+      }
+      if (removedSeqs.length > 0) {
+        await args.executor.execute(
+          `UPDATE junior_conversation_events
+         SET payload = jsonb_set(
+           payload,
+           '{historyFromSeq}',
+           to_jsonb(
+             (payload->>'historyFromSeq')::integer - (
+               SELECT count(*)::integer
+               FROM unnest($2::integer[]) removed(seq)
+               WHERE removed.seq < (payload->>'historyFromSeq')::integer
+             )
+           )
+         )
+         WHERE conversation_id = $1
+           AND type = 'messages_summarized'
+           AND jsonb_typeof(payload->'historyFromSeq') = 'number'`,
+          [args.conversationId, removedSeqs]
+        );
+        await args.executor.execute(
+          `DELETE FROM junior_conversation_events
+         WHERE conversation_id = $1 AND seq = ANY($2::integer[])`,
+          [args.conversationId, removedSeqs]
+        );
+        await args.executor.execute(
+          `UPDATE junior_conversation_events
+         SET seq = -seq - 1
+         WHERE conversation_id = $1`,
+          [args.conversationId]
+        );
+        await args.executor.execute(
+          `WITH ranked AS (
+           SELECT
+             ctid,
+             row_number() OVER (ORDER BY -seq - 1) - 1 AS next_seq
+           FROM junior_conversation_events
+           WHERE conversation_id = $1
+         )
+         UPDATE junior_conversation_events event
+         SET seq = ranked.next_seq
+         FROM ranked
+         WHERE event.ctid = ranked.ctid`,
+          [args.conversationId]
+        );
+      }
+      return migrated;
+    })
+  );
+}
+async function normalizeConversationContextCheckpoints(context, options = {}) {
+  const config = options.executor && options.bot ? void 0 : getChatConfig();
+  const bot = options.bot ?? config?.bot;
+  if (!bot) throw new Error("Context checkpoint upgrade requires bot config");
+  let executor = options.executor;
+  if (!executor) {
+    if (!config)
+      throw new Error("Context checkpoint upgrade requires SQL config");
+    executor = createJuniorSqlExecutor({
+      connectionString: config.sql.databaseUrl,
+      driver: config.sql.driver
+    });
+  }
+  try {
+    const result = {
+      existing: 0,
+      migrated: 0,
+      missing: 0,
+      scanned: 0
+    };
+    while (true) {
+      const conversations = await executor.query(
+        `SELECT DISTINCT conversation_id AS "conversationId"
+         FROM junior_conversation_events
+         WHERE type = 'context_epoch_started'
+         ORDER BY conversation_id
+         LIMIT $1`,
+        [PAGE_SIZE]
+      );
+      if (conversations.length === 0) break;
+      await prepareConversationEventResequence(
+        context,
+        new Set(conversations.map(({ conversationId }) => conversationId))
+      );
+      for (const { conversationId } of conversations) {
+        result.scanned += 1;
+        result.migrated += await normalizeConversation({
+          bot,
+          conversationId,
+          executor
+        });
+      }
+    }
+    return result;
+  } finally {
+    if (!options.executor) await executor.close();
+  }
+}
+var conversationContextCheckpointMigration = {
+  name: "normalize-conversation-context-checkpoints",
+  run: normalizeConversationContextCheckpoints
+};
+
 // src/cli/upgrade.ts
 var DEFAULT_IO = {
   info: console.log
@@ -1604,7 +3536,11 @@ var MIGRATIONS = [
   redisConversationStateMigration,
   coreSqlSchemaMigration,
   sqlConversationMigration,
+  conversationContextCheckpointMigration,
+  // The external history import must precede the SQL read-model backfill.
+  // Visible events seal a conversation against legacy Redis/session import.
   sqlConversationHistoryMigration,
+  conversationVisibleMessageEventsMigration,
   conversationUsageRepairMigration,
   sqlPluginMigration,
   pluginStorageMigration