@sentry/junior 0.107.1 → 0.109.0

package/dist/cli/upgrade.js

@@ -1,3550 +1,353 @@
-import {
-  getConversation,
-  listConversationsByActivity,
-  recordConversationActivity,
-  recordConversationExecution,
-  requestConversationWork
-} from "../chunk-YNP2ATQX.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
-  pluginCatalogConfigFromPluginSet,
-  pluginRuntimeRegistrationsFromPluginSet
+  pluginCatalogConfigFromPluginSet
 } from "../chunk-SG5WAA7H.js";
-import {
-  AGENT_TURN_SESSION_PREFIX,
-  JUNIOR_THREAD_STATE_TTL_MS,
-  agentTurnSessionConversationIndexKey,
-  agentTurnSessionKey,
-  coerceThreadConversationState,
-  listAgentTurnSessionSummariesForConversations,
-  piMessageSchema
-} from "../chunk-4YF7Z6IA.js";
-import {
-  addAgentTurnUsage
-} from "../chunk-MU6HHZEN.js";
-import "../chunk-PDO5BLNM.js";
 import {
   loadAppPluginSet
 } from "../chunk-Y2CM7HXH.js";
 import {
-  createPluginLogger,
-  createPluginState
-} from "../chunk-AUUOHQAT.js";
-import {
-  disconnectStateAdapter,
-  getConnectedStateContext,
-  getStateAdapter
-} from "../chunk-B2Z2H66D.js";
+  createJuniorSqlExecutor
+} from "../chunk-TMBRFULF.js";
 import {
-  contextProvenance,
-  conversationEventDataSchema,
-  conversationMessageProvenanceSchema,
-  createJuniorSqlExecutor,
-  createSqlStore,
-  getDb,
-  instructionProvenanceFor,
-  juniorConversationEvents,
-  juniorConversations,
-  newConversationEventSchema,
-  sanitizePostgresJson,
-  withConversationEventLock
-} from "../chunk-NVOTGWYX.js";
-import {
-  COMPACTION_SUMMARY_PREFIX,
-  getChatConfig,
-  isCompactionSummaryText,
-  modelIdForProfile,
-  modelProfileSchema,
-  standardModelId,
-  unescapeXml,
-  unwrapCurrentInstruction
-} from "../chunk-SS67LUOK.js";
+  getChatConfig
+} from "../chunk-JNAVF45E.js";
 import "../chunk-VFUK3X5B.js";
-import "../chunk-RT5BUHR5.js";
-import {
-  parseDestination,
-  sameDestination
-} from "../chunk-B7PUBQQM.js";
-import {
-  pluginCatalogRuntime
-} from "../chunk-YIPD3L6L.js";
-import {
-  storedSlackActorSchema
-} from "../chunk-VIXFG2VC.js";
-import "../chunk-O24R4DCK.js";
+import "../chunk-O3JMSZLI.js";
 import {
-  isRecord,
-  toOptionalNumber,
-  toOptionalString
-} from "../chunk-OB42YVAE.js";
+  createPluginCatalogRuntime
+} from "../chunk-TT6GMXNA.js";
+import "../chunk-PLB7MRCQ.js";
+import "../chunk-ISMWX44P.js";
+import "../chunk-OB42YVAE.js";
 import "../chunk-6GWA276C.js";
 import "../chunk-B3IT5END.js";
-import "../chunk-7FBGKXPE.js";
 import "../chunk-3V7OFJZC.js";
+import "../chunk-IVVGFRQQ.js";
+import "../chunk-OCD3OZRK.js";
 import "../chunk-MLKGABMK.js";
 
-// src/cli/upgrade.ts
-import { createJiti } from "jiti";
-
-// 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,
-    recordActivity: (args) => recordConversationActivity({ ...args, state }),
-    recordExecution: (args) => recordConversationExecution({ ...args, state }),
-    listByActivity: (args) => listConversationsByActivity({ ...args, state })
-  };
-}
-
-// src/cli/upgrade/migrations/conversations-sql.ts
-var CONVERSATION_BACKFILL_LIMIT = 1e4;
-async function migrateConversationsToSql(context, options = {}) {
-  const source = createStateConversationStore(context.stateAdapter);
-  let target = options.target;
-  let closeTarget;
-  if (!target) {
-    const { sql: sql2 } = getChatConfig();
-    const executor = createJuniorSqlExecutor({
-      connectionString: sql2.databaseUrl,
-      driver: sql2.driver
-    });
-    target = createSqlStore(executor);
-    closeTarget = () => executor.close();
-  }
-  const limit = Math.max(1, options.batchSize ?? CONVERSATION_BACKFILL_LIMIT);
-  try {
-    const [stateConversations, sqlConversations] = await Promise.all([
-      source.listByActivity({ limit }),
-      target.listByActivity({ limit })
-    ]);
-    const byId = new Map(
-      sqlConversations.map((conversation) => [
-        conversation.conversationId,
-        conversation
-      ])
-    );
-    for (const conversation of stateConversations) {
-      const existing = byId.get(conversation.conversationId);
-      const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
-      const stateExecutionAt = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
-      if (!existing || stateExecutionAt >= existingExecutionAt) {
-        byId.set(conversation.conversationId, conversation);
-      }
-    }
-    const conversations = [...byId.values()].sort(
-      (left, right) => right.lastActivityAtMs - left.lastActivityAtMs || left.conversationId.localeCompare(right.conversationId)
-    ).slice(0, limit);
-    const summaries = await listAgentTurnSessionSummariesForConversations(
-      context.stateAdapter,
-      conversations.map((conversation) => conversation.conversationId)
-    );
-    for (const conversation of conversations) {
-      const conversationSummaries = summaries.get(conversation.conversationId) ?? [];
-      const executionSummary = conversation.execution.runId ? conversationSummaries.find(
-        (summary) => summary.sessionId === conversation.execution.runId
-      ) : void 0;
-      await target.backfillConversation(
-        conversation,
-        conversationSummaries.length > 0 ? {
-          durationMs: conversationSummaries.reduce(
-            (total, summary) => total + summary.cumulativeDurationMs,
-            0
-          ),
-          usage: addAgentTurnUsage(
-            ...conversationSummaries.map(
-              (summary) => summary.cumulativeUsage
-            )
-          ),
-          executionDurationMs: executionSummary?.cumulativeDurationMs ?? 0,
-          executionUsage: executionSummary?.cumulativeUsage
-        } : void 0
-      );
-    }
-    return {
-      existing: 0,
-      migrated: conversations.length,
-      missing: 0,
-      scanned: conversations.length
-    };
-  } finally {
-    await closeTarget?.();
-  }
-}
-var sqlConversationMigration = {
-  name: "backfill-conversations-sql",
-  run: migrateConversationsToSql
-};
-
 // src/chat/conversations/sql/migrations.ts
 import { basename, dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import { readMigrationFiles } from "drizzle-orm/migrator";
-var LEGACY_CORE_MIGRATION_IDS = [
-  "0001_conversation_core",
-  "0002_slack_destination_visibility_backfill",
-  "0003_user_identities",
-  "0004_actor_cutover",
-  "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"
-};
+
+// src/db/postgres-error.ts
+function isPostgresErrorCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// src/chat/conversations/sql/migrations.ts
+var CORE_MIGRATION_BRIDGE_VERSION = "0.107.1";
 var MIGRATIONS_TABLE = "__drizzle_junior_core";
 function migrationFolder() {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   const packageRoot = basename(moduleDir) === "dist" ? dirname(moduleDir) : basename(dirname(moduleDir)) === "dist" ? resolve(moduleDir, "../..") : resolve(moduleDir, "../../../..");
-  return join(packageRoot, "migrations");
-}
-async function adoptLegacyMigrationState(executor, migrationsFolder) {
-  const [tables] = await executor.query(`
-SELECT
-  to_regclass('drizzle.__drizzle_junior_core')::text AS "drizzleTable",
-  to_regclass('public.junior_schema_migrations')::text AS "legacyTable"
-`);
-  if (!tables?.legacyTable || tables.drizzleTable) {
-    return;
-  }
-  const migrations = readMigrationFiles({ migrationsFolder });
-  const [metrics] = await executor.query(`
-SELECT count(*)::integer AS "columnCount"
-FROM information_schema.columns
-WHERE table_schema = 'public'
-  AND table_name = 'junior_conversations'
-  AND column_name IN (
-    'duration_ms',
-    'usage_json',
-    'execution_duration_ms',
-    'execution_usage_json'
-  )
-`);
-  const legacyRecords = await executor.query("SELECT id, checksum FROM junior_schema_migrations");
-  const legacyRecordsById = new Map(
-    legacyRecords.map((record) => [record.id, record.checksum])
-  );
-  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 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");
-  }
-  await executor.transaction(async () => {
-    await executor.execute("CREATE SCHEMA IF NOT EXISTS drizzle");
-    await executor.execute(`
-CREATE TABLE IF NOT EXISTS drizzle.__drizzle_junior_core (
-  id SERIAL PRIMARY KEY,
-  hash TEXT NOT NULL,
-  created_at BIGINT
-)
-`);
-    await executor.execute(
-      `INSERT INTO drizzle.__drizzle_junior_core (hash, created_at)
-       VALUES ($1, $2)`,
-      [migration.hash, migration.folderMillis]
-    );
-  });
-}
-async function migrateSchema(executor) {
-  const migrationsFolder = migrationFolder();
-  await executor.withMigrationLock(MIGRATIONS_TABLE, async () => {
-    await adoptLegacyMigrationState(executor, migrationsFolder);
-    await executor.migrate({
-      migrationsFolder,
-      migrationsTable: MIGRATIONS_TABLE
-    });
-  });
-}
-
-// src/cli/upgrade/migrations/core-sql.ts
-async function migrateCoreSqlSchema(_context) {
-  const { sql: sql2 } = getChatConfig();
-  const executor = createJuniorSqlExecutor({
-    connectionString: sql2.databaseUrl,
-    driver: sql2.driver
-  });
-  try {
-    await migrateSchema(executor);
-    return { existing: 0, migrated: 0, missing: 0, scanned: 0 };
-  } finally {
-    await executor.close();
-  }
-}
-var coreSqlSchemaMigration = {
-  name: "core-sql-schema",
-  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_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: sql2 } = chatConfig;
-    executor = createJuniorSqlExecutor({
-      connectionString: sql2.databaseUrl,
-      driver: sql2.driver
-    });
-    closeExecutor = () => executor.close();
-  }
-  const pageSize = Math.max(
-    1,
-    Math.floor(options.batchSize ?? HISTORY_BACKFILL_PAGE_SIZE)
-  );
-  try {
-    let migrated = 0;
-    let existing = 0;
-    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;
-        }
-      }
-      scanned += conversations.length;
-      offset += conversations.length;
-    }
-    return {
-      existing,
-      migrated,
-      missing: 0,
-      scanned
-    };
-  } finally {
-    await closeExecutor?.();
-  }
-}
-var sqlConversationHistoryMigration = {
-  name: "backfill-conversation-events-sql",
-  run: migrateConversationHistoryToSql
-};
-
-// src/cli/upgrade/migrations/upgrade-plugins.ts
-function unique(values) {
-  return [...new Set(values)];
-}
-function baseCatalogConfig(context) {
-  return context.pluginCatalogConfig ?? (context.pluginSet ? pluginCatalogConfigFromPluginSet(context.pluginSet) : pluginCatalogConfigFromEnv());
-}
-function inlinePluginName(definition) {
-  return definition.manifest.name;
-}
-function mergeInlineManifests(left, right) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const definition of [...left ?? [], ...right ?? []]) {
-    merged.set(inlinePluginName(definition), definition);
-  }
-  return merged.size > 0 ? [...merged.values()] : void 0;
-}
-function mergeCatalogConfig(base, added) {
-  if (!base) {
-    return added;
-  }
-  if (!added) {
-    return base;
-  }
-  const inlineManifests = mergeInlineManifests(
-    base.inlineManifests,
-    added.inlineManifests
-  );
-  const packages = unique([
-    ...base.packages ?? [],
-    ...added.packages ?? []
-  ]);
-  const manifests = base.manifests || added.manifests ? { ...base.manifests, ...added.manifests } : void 0;
-  return {
-    ...inlineManifests ? { inlineManifests } : {},
-    ...packages.length > 0 ? { packages } : {},
-    ...manifests ? { manifests } : {}
-  };
-}
-function packageNamesFromContext(context, catalog) {
-  return unique([
-    ...context.pluginSet?.packageNames ?? [],
-    ...catalog?.packages ?? []
-  ]);
-}
-async function resolveUpgradePlugins(context) {
-  const catalog = baseCatalogConfig(context);
-  const packageNames = packageNamesFromContext(context, catalog);
-  const registrations = context.pluginSet?.registrations ?? [];
-  const manifests = context.pluginSet?.manifests || catalog?.manifests ? {
-    ...catalog?.manifests,
-    ...context.pluginSet?.manifests
-  } : void 0;
-  const pluginSet = packageNames.length > 0 || registrations.length > 0 || context.pluginSet ? defineJuniorPlugins(
-    [...packageNames, ...registrations],
-    manifests ? { manifests } : {}
-  ) : void 0;
-  return {
-    pluginCatalogConfig: mergeCatalogConfig(
-      catalog,
-      pluginCatalogConfigFromPluginSet(pluginSet)
-    ),
-    ...pluginSet ? { pluginSet } : {}
-  };
-}
-
-// src/cli/upgrade/migrations/plugin-storage.ts
-function emptyResult() {
-  return {
-    existing: 0,
-    migrated: 0,
-    missing: 0,
-    scanned: 0
-  };
-}
-function addResult(left, right) {
-  return {
-    existing: left.existing + right.existing,
-    migrated: left.migrated + right.migrated,
-    missing: left.missing + right.missing,
-    scanned: left.scanned + right.scanned,
-    ...left.skipped !== void 0 || right.skipped !== void 0 ? { skipped: (left.skipped ?? 0) + (right.skipped ?? 0) } : {}
-  };
-}
-function dbForPlugin(context, sqlUrlDb) {
-  return context.db ?? sqlUrlDb ?? getDb();
-}
-async function runPluginStorageMigrations(context) {
-  const { pluginCatalogConfig, pluginSet } = await resolveUpgradePlugins(context);
-  if (!pluginSet) {
-    return emptyResult();
-  }
-  const previousConfig = pluginCatalogRuntime.setConfig(pluginCatalogConfig);
-  const sql2 = getChatConfig().sql;
-  const ownedExecutor = context.db ? void 0 : createJuniorSqlExecutor({
-    connectionString: sql2.databaseUrl,
-    driver: sql2.driver
-  });
-  const sqlUrlDb = ownedExecutor ? ownedExecutor.db() : void 0;
-  try {
-    let result = emptyResult();
-    const plugins = pluginRuntimeRegistrationsFromPluginSet(pluginSet).filter((plugin) => plugin.hooks?.migrateStorage).sort(
-      (left, right) => left.manifest.name.localeCompare(right.manifest.name)
-    );
-    for (const plugin of plugins) {
-      const pluginName = plugin.manifest.name;
-      const hook = plugin.hooks?.migrateStorage;
-      if (!hook) {
-        continue;
-      }
-      const db = dbForPlugin(context, sqlUrlDb);
-      const pluginResult = await hook({
-        db,
-        log: createPluginLogger(pluginName),
-        plugin: { name: pluginName },
-        state: createPluginState(pluginName, context.stateAdapter)
-      });
-      if (pluginResult) {
-        result = addResult(result, pluginResult);
-      }
-    }
-    return result;
-  } finally {
-    pluginCatalogRuntime.setConfig(previousConfig);
-    await ownedExecutor?.close();
-  }
-}
-var pluginStorageMigration = {
-  name: "run-plugin-storage-migrations",
-  run: runPluginStorageMigrations
-};
-
-// src/chat/plugins/migrations.ts
-import { createHash } from "crypto";
-import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
-var LEGACY_SCHEDULER_BASELINE_HASH = "d1d2f712181dd3a0557808f0fc67fd0722691d25f4c8cfb816b77c71d19e1e42";
-function migrationTable(pluginName) {
-  const label = pluginName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32);
-  const hash = createHash("sha256").update(pluginName).digest("hex").slice(0, 8);
-  return `__drizzle_${label}_${hash}`;
-}
-async function appliedMigrationTime(executor, table) {
-  const [exists] = await executor.query(
-    `SELECT to_regclass($1)::text AS "tableName"`,
-    [`drizzle.${table}`]
-  );
-  if (!exists?.tableName) {
-    return void 0;
-  }
-  const [row] = await executor.query(
-    `SELECT created_at::text AS "createdAt"
-     FROM drizzle.${table}
-     ORDER BY created_at DESC
-     LIMIT 1`
-  );
-  return row?.createdAt === null || row?.createdAt === void 0 ? void 0 : Number(row.createdAt);
-}
-async function legacyMigrationHashes(executor, pluginName) {
-  const [exists] = await executor.query(
-    `SELECT to_regclass('public.junior_schema_migrations')::text AS "tableName"`
-  );
-  if (!exists?.tableName) {
-    return /* @__PURE__ */ new Set();
-  }
-  const rows = await executor.query(
-    `SELECT checksum
-     FROM junior_schema_migrations
-     WHERE id LIKE $1
-     ORDER BY id ASC`,
-    [`plugin:${pluginName}/%`]
-  );
-  return new Set(rows.map((row) => row.checksum));
-}
-function adoptedMigration(migrations, legacyHashes, pluginName) {
-  let adopted;
-  for (const migration of migrations) {
-    if (!legacyHashes.has(migration.hash)) {
-      break;
-    }
-    adopted = migration;
-  }
-  if (!adopted && pluginName === "scheduler" && legacyHashes.has(LEGACY_SCHEDULER_BASELINE_HASH)) {
-    return migrations[0];
-  }
-  return adopted;
-}
-async function adoptLegacyMigrationState2(args) {
-  const legacyHashes = await legacyMigrationHashes(
-    args.executor,
-    args.pluginName
-  );
-  const migration = adoptedMigration(
-    args.migrations,
-    legacyHashes,
-    args.pluginName
-  );
-  if (!migration) {
-    return void 0;
-  }
-  await args.executor.transaction(async () => {
-    await args.executor.execute("CREATE SCHEMA IF NOT EXISTS drizzle");
-    await args.executor.execute(`
-CREATE TABLE IF NOT EXISTS drizzle.${args.table} (
-  id SERIAL PRIMARY KEY,
-  hash TEXT NOT NULL,
-  created_at BIGINT
-)
-`);
-    await args.executor.execute(
-      `INSERT INTO drizzle.${args.table} (hash, created_at) VALUES ($1, $2)`,
-      [migration.hash, migration.folderMillis]
-    );
-  });
-  return migration.folderMillis;
-}
-function appliedCount(migrations, createdAt) {
-  return createdAt === void 0 ? 0 : migrations.filter((migration) => migration.folderMillis <= createdAt).length;
-}
-async function migratePluginSchemas(executor, roots) {
-  const result = {
-    existing: 0,
-    migrated: 0,
-    scanned: 0
-  };
-  const orderedRoots = [...roots].sort(
-    (left, right) => left.pluginName.localeCompare(right.pluginName)
-  );
-  for (const root of orderedRoots) {
-    const migrations = readMigrationFiles2({ migrationsFolder: root.dir });
-    const table = migrationTable(root.pluginName);
-    await executor.withMigrationLock(table, async () => {
-      const currentTime = await appliedMigrationTime(executor, table) ?? await adoptLegacyMigrationState2({
-        executor,
-        migrations,
-        pluginName: root.pluginName,
-        table
-      });
-      const existing = appliedCount(migrations, currentTime);
-      await executor.migrate({
-        migrationsFolder: root.dir,
-        migrationsTable: table
-      });
-      result.scanned += migrations.length;
-      result.existing += existing;
-      result.migrated += migrations.length - existing;
-    });
-  }
-  return result;
-}
-
-// src/cli/upgrade/migrations/plugin-sql.ts
-async function migratePluginsToSql(context) {
-  const { sql: sql2 } = getChatConfig();
-  const { pluginCatalogConfig } = await resolveUpgradePlugins(context);
-  const previousConfig = pluginCatalogRuntime.setConfig(pluginCatalogConfig);
-  const executor = createJuniorSqlExecutor({
-    connectionString: sql2.databaseUrl,
-    driver: sql2.driver
-  });
-  try {
-    const result = await migratePluginSchemas(
-      executor,
-      pluginCatalogRuntime.getMigrationRoots()
-    );
-    return {
-      existing: result.existing,
-      migrated: result.migrated,
-      missing: 0,
-      scanned: result.scanned
-    };
-  } finally {
-    pluginCatalogRuntime.setConfig(previousConfig);
-    await executor.close();
-  }
-}
-var sqlPluginMigration = {
-  name: "migrate-plugin-sql",
-  run: migratePluginsToSql
-};
-
-// src/cli/upgrade/migrations/redis-conversation-state.ts
-var CONVERSATION_PREFIX = "junior:conversation";
-var CONVERSATION_SCHEMA_VERSION = 1;
-var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
-var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
-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_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}`;
-}
-function legacyConversationWorkKey(conversationId) {
-  return `${LEGACY_CONVERSATION_WORK_PREFIX}:state:${conversationId}`;
-}
-function threadStateKey(conversationId) {
-  return `${THREAD_STATE_PREFIX}:${conversationId}`;
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-function uniqueStringValues(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return uniqueStrings(
-    value.map((value2) => typeof value2 === "string" ? value2 : void 0).filter((value2) => Boolean(value2))
-  );
-}
-function normalizeSource(value) {
-  if (value === "api" || value === "internal" || value === "plugin" || value === "scheduler" || value === "slack") {
-    return value;
-  }
-  return void 0;
-}
-function normalizeMetadata(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  return value;
-}
-function normalizeInput(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const text = toOptionalString(value.text);
-  if (!text) {
-    return void 0;
-  }
-  return {
-    text,
-    authorId: toOptionalString(value.authorId),
-    attachments: Array.isArray(value.attachments) ? [...value.attachments] : void 0,
-    metadata: normalizeMetadata(value.metadata)
-  };
-}
-function normalizeMessage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const inboundMessageId = toOptionalString(value.inboundMessageId);
-  const source = normalizeSource(value.source);
-  const destination = parseDestination(value.destination);
-  const createdAtMs = toOptionalNumber(value.createdAtMs);
-  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
-  const input = normalizeInput(value.input);
-  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
-    return void 0;
-  }
-  return {
-    conversationId,
-    destination,
-    inboundMessageId,
-    source,
-    createdAtMs,
-    receivedAtMs,
-    input,
-    injectedAtMs: toOptionalNumber(value.injectedAtMs)
-  };
-}
-function normalizeLegacyLease(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const token = toOptionalString(value.leaseToken);
-  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
-  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
-  const expiresAtMs = toOptionalNumber(value.leaseExpiresAtMs);
-  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
-    return void 0;
-  }
-  return {
-    token,
-    acquiredAtMs,
-    lastCheckInAtMs,
-    expiresAtMs
-  };
-}
-function compareMessages(left, right) {
-  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
-}
-function normalizeLegacyConversation(conversationId, value) {
-  if (!isRecord(value) || value.schemaVersion !== LEGACY_CONVERSATION_WORK_SCHEMA_VERSION) {
-    return void 0;
-  }
-  const storedConversationId = toOptionalString(value.conversationId);
-  const destination = parseDestination(value.destination);
-  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-  if (storedConversationId !== conversationId || !destination || typeof updatedAtMs !== "number") {
-    return void 0;
-  }
-  const normalizedMessages = Array.isArray(value.messages) ? value.messages.map(normalizeMessage).filter((message) => Boolean(message)) : [];
-  if (normalizedMessages.some(
-    (message) => message.conversationId === conversationId && !sameDestination(message.destination, destination)
-  )) {
-    return void 0;
-  }
-  const messages = normalizedMessages.filter((message) => message.conversationId === conversationId).sort(compareMessages);
-  const pendingMessages = messages.filter(
-    (message) => message.injectedAtMs === void 0
-  );
-  const lease = normalizeLegacyLease(value.lease);
-  const needsRun = value.needsRun === true || pendingMessages.length > 0;
-  const status = lease ? value.needsRun === true ? "awaiting_resume" : "running" : needsRun ? "pending" : "idle";
-  const messageTimes = messages.flatMap((message) => [
-    message.createdAtMs,
-    message.receivedAtMs
-  ]);
-  const createdAtMs = messageTimes.length > 0 ? Math.min(...messageTimes) : updatedAtMs;
-  const lastActivityAtMs = messageTimes.length > 0 ? Math.max(...messageTimes) : updatedAtMs;
-  return {
-    schemaVersion: CONVERSATION_SCHEMA_VERSION,
-    conversationId,
-    createdAtMs,
-    destination,
-    lastActivityAtMs,
-    source: messages[0]?.source,
-    updatedAtMs,
-    execution: {
-      status,
-      inboundMessageIds: uniqueStrings(
-        messages.map((message) => message.inboundMessageId)
-      ),
-      pendingCount: pendingMessages.length,
-      pendingMessages,
-      ...lease ? { lease } : {},
-      lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-      updatedAtMs
-    }
-  };
-}
-function mergeLegacyConversation(existing, legacy) {
-  if (existing.destination && legacy.destination && !sameDestination(existing.destination, legacy.destination)) {
-    throw new Error(
-      `Legacy conversation work destination does not match conversation ${existing.conversationId}`
-    );
-  }
-  const knownInboundIds = new Set(existing.execution.inboundMessageIds);
-  const pendingMessages = [
-    ...existing.execution.pendingMessages,
-    ...legacy.execution.pendingMessages.filter(
-      (message) => !knownInboundIds.has(message.inboundMessageId)
-    )
-  ].sort(compareMessages);
-  const legacyIsRunnable = legacy.execution.status !== "idle";
-  const existingIsIdle = existing.execution.status === "idle";
-  const legacyLease = existingIsIdle && legacy.execution.lease ? { lease: legacy.execution.lease } : {};
-  const legacyRunId = existingIsIdle && legacy.execution.runId ? { runId: legacy.execution.runId } : {};
-  const legacyCheckpoint = existing.execution.lastCheckpointAtMs === void 0 && legacy.execution.lastCheckpointAtMs !== void 0 ? { lastCheckpointAtMs: legacy.execution.lastCheckpointAtMs } : {};
-  const legacyEnqueue = existing.execution.lastEnqueuedAtMs === void 0 && legacy.execution.lastEnqueuedAtMs !== void 0 ? { lastEnqueuedAtMs: legacy.execution.lastEnqueuedAtMs } : {};
-  const executionUpdatedAtMs = Math.max(
-    existing.execution.updatedAtMs ?? existing.updatedAtMs,
-    legacy.execution.updatedAtMs ?? legacy.updatedAtMs
-  );
-  const status = existingIsIdle && legacyIsRunnable ? legacy.execution.lease ? legacy.execution.status : "pending" : pendingMessages.length > 0 && existingIsIdle ? "pending" : existing.execution.status;
-  return {
-    ...existing,
-    destination: existing.destination ?? legacy.destination,
-    source: existing.source ?? legacy.source,
-    createdAtMs: Math.min(existing.createdAtMs, legacy.createdAtMs),
-    lastActivityAtMs: Math.max(
-      existing.lastActivityAtMs,
-      legacy.lastActivityAtMs
-    ),
-    updatedAtMs: Math.max(existing.updatedAtMs, legacy.updatedAtMs),
-    execution: {
-      ...existing.execution,
-      ...legacyLease,
-      ...legacyRunId,
-      ...legacyCheckpoint,
-      ...legacyEnqueue,
-      status,
-      inboundMessageIds: uniqueStrings([
-        ...existing.execution.inboundMessageIds,
-        ...legacy.execution.inboundMessageIds
-      ]),
-      pendingCount: pendingMessages.length,
-      pendingMessages,
-      updatedAtMs: executionUpdatedAtMs
-    }
-  };
-}
-function compareIndexDescending(left, right) {
-  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
-}
-function compareIndexAscending(left, right) {
-  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
-}
-function normalizeIndexEntry(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const score = toOptionalNumber(value.score);
-  if (!conversationId || typeof score !== "number") {
-    return void 0;
-  }
-  return { conversationId, score };
-}
-function uniqueIndexEntries(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const entries = /* @__PURE__ */ new Map();
-  for (const item of value) {
-    const entry = normalizeIndexEntry(item);
-    if (!entry) {
-      continue;
-    }
-    const existing = entries.get(entry.conversationId);
-    if (!existing || entry.score > existing.score) {
-      entries.set(entry.conversationId, entry);
-    }
-  }
-  return [...entries.values()];
-}
-function normalizeAwaitingContinuationSummary(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const sessionId = toOptionalString(value.sessionId);
-  const state = value.state;
-  const resumeReason = value.resumeReason;
-  const destination = parseDestination(value.destination);
-  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-  if (!conversationId || !sessionId || state !== "awaiting_resume" || resumeReason !== "timeout" && resumeReason !== "yield" || !destination || typeof updatedAtMs !== "number") {
-    return void 0;
-  }
-  return {
-    conversationId,
-    destination,
-    resumeReason,
-    sessionId,
-    state,
-    updatedAtMs
-  };
-}
-function uniqueAwaitingContinuationSummaries(values) {
-  const summaries = /* @__PURE__ */ new Map();
-  for (const value of [...values].reverse()) {
-    const summary = normalizeAwaitingContinuationSummary(value);
-    if (!summary) {
-      continue;
-    }
-    const key3 = `${summary.conversationId}:${summary.sessionId}`;
-    if (!summaries.has(key3)) {
-      summaries.set(key3, summary);
-    }
-  }
-  return [...summaries.values()];
-}
-function redisIndexKey(indexKey) {
-  const prefix = getChatConfig().state.keyPrefix;
-  return [...prefix ? [prefix] : [], indexKey].join(":");
-}
-async function upsertEmulatedIndexEntry(args) {
-  const existing = uniqueIndexEntries(
-    await args.stateAdapter.get(args.indexKey)
-  );
-  const next = [
-    ...existing.filter((entry) => entry.conversationId !== args.conversationId),
-    { conversationId: args.conversationId, score: args.score }
-  ];
-  const retained = args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY ? next.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH) : next.sort(compareIndexAscending);
-  await args.stateAdapter.set(
-    args.indexKey,
-    retained,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-}
-async function removeEmulatedIndexEntry(args) {
-  const existing = uniqueIndexEntries(
-    await args.stateAdapter.get(args.indexKey)
-  );
-  const next = existing.filter(
-    (entry) => entry.conversationId !== args.conversationId
-  );
-  if (next.length === existing.length) {
-    return;
-  }
-  await args.stateAdapter.set(args.indexKey, next, JUNIOR_THREAD_STATE_TTL_MS);
-}
-async function upsertRedisIndexEntry(args) {
-  const key3 = redisIndexKey(args.indexKey);
-  if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
-    const upsertBoundedActivityScript = `
-      redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
-      redis.call("PEXPIRE", KEYS[1], ARGV[3])
-      local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
-      if extra > 0 then
-        redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
-      end
-      return 1
-    `;
-    await args.client.sendCommand([
-      "EVAL",
-      upsertBoundedActivityScript,
-      "1",
-      key3,
-      String(args.score),
-      args.conversationId,
-      String(JUNIOR_THREAD_STATE_TTL_MS),
-      String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
-    ]);
-    return;
-  }
-  await args.client.sendCommand([
-    "ZADD",
-    key3,
-    String(args.score),
-    args.conversationId
-  ]);
-  await args.client.sendCommand([
-    "PEXPIRE",
-    key3,
-    String(JUNIOR_THREAD_STATE_TTL_MS)
-  ]);
-}
-async function removeRedisIndexEntry(args) {
-  await args.client.sendCommand([
-    "ZREM",
-    redisIndexKey(args.indexKey),
-    args.conversationId
-  ]);
-}
-async function upsertConversationIndexes(args) {
-  const redisClient = args.redisStateAdapter?.getClient();
-  const upsert = redisClient ? (indexKey, score) => upsertRedisIndexEntry({
-    client: redisClient,
-    conversationId: args.conversation.conversationId,
-    indexKey,
-    score
-  }) : (indexKey, score) => upsertEmulatedIndexEntry({
-    stateAdapter: args.stateAdapter,
-    conversationId: args.conversation.conversationId,
-    indexKey,
-    score
-  });
-  const remove = redisClient ? (indexKey) => removeRedisIndexEntry({
-    client: redisClient,
-    conversationId: args.conversation.conversationId,
-    indexKey
-  }) : (indexKey) => removeEmulatedIndexEntry({
-    stateAdapter: args.stateAdapter,
-    conversationId: args.conversation.conversationId,
-    indexKey
-  });
-  await upsert(
-    CONVERSATION_BY_ACTIVITY_INDEX_KEY,
-    args.conversation.lastActivityAtMs
-  );
-  if (args.conversation.execution.status === "idle") {
-    await remove(CONVERSATION_ACTIVE_INDEX_KEY);
-    return;
-  }
-  await upsert(
-    CONVERSATION_ACTIVE_INDEX_KEY,
-    args.conversation.execution.updatedAtMs ?? args.conversation.updatedAtMs
-  );
-}
-async function removeLegacyIndexEntry(args) {
-  const existing = uniqueStringValues(
-    await args.stateAdapter.get(LEGACY_CONVERSATION_WORK_INDEX_KEY)
-  );
-  const next = existing.filter((id) => id !== args.conversationId);
-  if (next.length === existing.length) {
-    return;
-  }
-  if (next.length === 0) {
-    await args.stateAdapter.delete(LEGACY_CONVERSATION_WORK_INDEX_KEY);
-    return;
-  }
-  await args.stateAdapter.set(
-    LEGACY_CONVERSATION_WORK_INDEX_KEY,
-    next,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-}
-async function migrateLegacyConversationWorkRedisState(context) {
-  const legacyIds = uniqueStringValues(
-    await context.stateAdapter.get(LEGACY_CONVERSATION_WORK_INDEX_KEY)
-  );
-  const result = {
-    existing: 0,
-    migrated: 0,
-    missing: 0,
-    scanned: legacyIds.length
-  };
-  for (const conversationId of legacyIds) {
-    const legacyKey = legacyConversationWorkKey(conversationId);
-    const raw = await context.stateAdapter.get(legacyKey);
-    if (raw == null) {
-      result.missing += 1;
-      await removeLegacyIndexEntry({
-        conversationId,
-        stateAdapter: context.stateAdapter
-      });
-      continue;
-    }
-    const conversation = normalizeLegacyConversation(conversationId, raw);
-    if (!conversation) {
-      throw new Error(
-        `Legacy conversation work state is invalid for ${conversationId}`
-      );
-    }
-    const existingConversation = await getConversation({
-      conversationId,
-      state: context.stateAdapter
-    });
-    if (existingConversation) {
-      const mergedConversation = mergeLegacyConversation(
-        existingConversation,
-        conversation
-      );
-      await context.stateAdapter.set(
-        conversationKey(conversationId),
-        mergedConversation,
-        JUNIOR_THREAD_STATE_TTL_MS
-      );
-      await upsertConversationIndexes({
-        conversation: mergedConversation,
-        redisStateAdapter: context.redisStateAdapter,
-        stateAdapter: context.stateAdapter
-      });
-      result.existing += 1;
-      await context.stateAdapter.delete(legacyKey);
-      await removeLegacyIndexEntry({
-        conversationId,
-        stateAdapter: context.stateAdapter
-      });
-      continue;
-    }
-    await context.stateAdapter.set(
-      conversationKey(conversationId),
-      conversation,
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-    await upsertConversationIndexes({
-      conversation,
-      redisStateAdapter: context.redisStateAdapter,
-      stateAdapter: context.stateAdapter
-    });
-    await context.stateAdapter.delete(legacyKey);
-    await removeLegacyIndexEntry({
-      conversationId,
-      stateAdapter: context.stateAdapter
-    });
-    result.migrated += 1;
-  }
-  return result;
-}
-async function isActiveContinuationSummary(context, summary) {
-  const rawState = await context.stateAdapter.get(
-    threadStateKey(summary.conversationId)
-  ) ?? {};
-  const conversation = coerceThreadConversationState(rawState);
-  return conversation.processing.activeTurnId === summary.sessionId;
-}
-async function seedAwaitingContinuationConversationWork(context, result) {
-  const summaries = uniqueAwaitingContinuationSummaries(
-    await context.stateAdapter.getList(AGENT_TURN_SESSION_INDEX_KEY)
-  );
-  result.scanned += summaries.length;
-  for (const summary of summaries) {
-    if (!await isActiveContinuationSummary(context, summary)) {
-      continue;
-    }
-    const existingConversation = await getConversation({
-      conversationId: summary.conversationId,
-      state: context.stateAdapter
-    });
-    if (existingConversation?.destination && !sameDestination(existingConversation.destination, summary.destination)) {
-      throw new Error(
-        `Awaiting continuation destination does not match conversation ${summary.conversationId}`
-      );
-    }
-    if (existingConversation && existingConversation.execution.status !== "idle") {
-      continue;
-    }
-    await requestConversationWork({
-      conversationId: summary.conversationId,
-      destination: summary.destination,
-      nowMs: Math.max(
-        summary.updatedAtMs,
-        existingConversation?.updatedAtMs ?? 0
-      ),
-      state: context.stateAdapter
-    });
-    if (existingConversation) {
-      result.existing += 1;
-    } else {
-      result.migrated += 1;
-    }
-  }
-}
-async function migrateRedisConversationState(context) {
-  const result = await migrateLegacyConversationWorkRedisState(context);
-  await seedAwaitingContinuationConversationWork(context, result);
-  return result;
-}
-var redisConversationStateMigration = {
-  // TODO(after 2026-07-01): remove after deployed installs have had a release
-  // window to move legacy conversation-work Redis state forward.
-  name: "migrate-redis-conversation-state",
-  run: migrateRedisConversationState
-};
-
-// src/cli/upgrade/migrations/agent-turn-session-actor.ts
-import { THREAD_STATE_TTL_MS } from "chat";
-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_PREFIX3}:conversation:${conversationId}:index`;
-}
-function sessionRecordKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX3}:${conversationId}:${sessionId}`;
-}
-function logicalConversationIndexPrefix() {
-  const prefix = getChatConfig().state.keyPrefix;
-  return [
-    ...prefix ? [prefix] : [],
-    `${AGENT_TURN_SESSION_PREFIX3}:conversation:`
-  ].join(":");
-}
-function conversationIdFromRedisListKey(key3) {
-  const marker = `:list:${logicalConversationIndexPrefix()}`;
-  const markerIndex = key3.indexOf(marker);
-  if (markerIndex < 0 || !key3.endsWith(":index")) {
-    return void 0;
-  }
-  return toOptionalString(
-    key3.slice(markerIndex + marker.length, -":index".length)
-  );
-}
-async function discoverRedisConversationIds(redisStateAdapter) {
-  const client = redisStateAdapter?.getClient();
-  if (!client) {
-    return [];
-  }
-  const conversationIds = /* @__PURE__ */ new Set();
-  const match = `*:list:${logicalConversationIndexPrefix()}*:index`;
-  let cursor = "0";
-  do {
-    const reply = await client.sendCommand([
-      "SCAN",
-      cursor,
-      "MATCH",
-      match,
-      "COUNT",
-      String(REDIS_SCAN_COUNT)
-    ]);
-    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 migrating turn sessions"
-      );
-    }
-    cursor = String(reply[0]);
-    for (const key3 of reply[1]) {
-      if (typeof key3 !== "string") {
-        continue;
-      }
-      const conversationId = conversationIdFromRedisListKey(key3);
-      if (conversationId) {
-        conversationIds.add(conversationId);
-      }
-    }
-  } while (cursor !== "0");
-  return [...conversationIds];
-}
-function migrateRequesterToActor(value) {
-  if (!isRecord(value) || value.requester === void 0) {
-    return { changed: false, value };
-  }
-  const { requester, ...record } = value;
-  return {
-    changed: true,
-    value: {
-      ...record,
-      ...record.actor === void 0 ? { actor: requester } : {}
-    }
-  };
-}
-async function rewriteList(args) {
-  const values = await args.stateAdapter.getList(args.key);
-  const migrated = values.map(migrateRequesterToActor);
-  const changed = migrated.filter((entry) => entry.changed).length;
-  if (changed === 0) {
-    return { migrated: 0, values };
-  }
-  await args.stateAdapter.delete(args.key);
-  for (const entry of migrated) {
-    await args.stateAdapter.appendToList(args.key, entry.value, {
-      ...args.maxLength !== void 0 ? { maxLength: args.maxLength } : {},
-      ttlMs: THREAD_STATE_TTL_MS
-    });
-  }
-  return { migrated: changed, values: migrated.map((entry) => entry.value) };
-}
-async function migrateSessionRecord(args) {
-  const key3 = sessionRecordKey(args.conversationId, args.sessionId);
-  const existing = await args.stateAdapter.get(key3);
-  if (existing === void 0) {
-    return "missing";
-  }
-  const migrated = migrateRequesterToActor(existing);
-  if (!migrated.changed) {
-    return "existing";
-  }
-  await args.stateAdapter.set(key3, migrated.value, THREAD_STATE_TTL_MS);
-  return "migrated";
-}
-async function migrateAgentTurnSessionActor(context) {
-  const result = {
-    existing: 0,
-    migrated: 0,
-    missing: 0,
-    scanned: 0
-  };
-  const global = await rewriteList({
-    key: AGENT_TURN_SESSION_INDEX_KEY2,
-    maxLength: AGENT_TURN_SESSION_INDEX_MAX_LENGTH,
-    stateAdapter: context.stateAdapter
-  });
-  result.scanned += global.values.length;
-  result.migrated += global.migrated;
-  const conversations = /* @__PURE__ */ new Set();
-  const sessions = /* @__PURE__ */ new Set();
-  for (const conversationId of await discoverRedisConversationIds(
-    context.redisStateAdapter
-  )) {
-    conversations.add(conversationId);
-  }
-  for (const value of global.values) {
-    if (!isRecord(value)) {
-      continue;
-    }
-    const conversationId = toOptionalString(value.conversationId);
-    const sessionId = toOptionalString(value.sessionId);
-    if (!conversationId) {
-      continue;
-    }
-    conversations.add(conversationId);
-    if (sessionId) {
-      sessions.add(`${conversationId}\0${sessionId}`);
-    }
-  }
-  for (const conversationId of conversations) {
-    const conversation = await rewriteList({
-      key: conversationIndexKey(conversationId),
-      stateAdapter: context.stateAdapter
-    });
-    result.scanned += conversation.values.length;
-    result.migrated += conversation.migrated;
-    for (const value of conversation.values) {
-      if (!isRecord(value)) {
-        continue;
-      }
-      const sessionId = toOptionalString(value.sessionId);
-      if (sessionId) {
-        sessions.add(`${conversationId}\0${sessionId}`);
-      }
-    }
-  }
-  for (const session of sessions) {
-    const separator = session.indexOf("\0");
-    const conversationId = session.slice(0, separator);
-    const sessionId = session.slice(separator + 1);
-    result.scanned += 1;
-    const status = await migrateSessionRecord({
-      conversationId,
-      sessionId,
-      stateAdapter: context.stateAdapter
-    });
-    if (status === "migrated") {
-      result.migrated += 1;
-    } else if (status === "existing") {
-      result.existing += 1;
-    } else {
-      result.missing += 1;
-    }
-  }
-  return result;
-}
-var agentTurnSessionActorMigration = {
-  name: "migrate-agent-turn-session-requester-to-actor",
-  run: migrateAgentTurnSessionActor
-};
-
-// src/cli/upgrade/migrations/conversation-usage.ts
-var CONVERSATION_USAGE_REPAIR_BATCH_SIZE = 500;
-var MAX_SAFE_INTEGER = 9007199254740991;
-var MAX_FINITE_DOUBLE = "1.7976931348623157e308";
-var REPAIR_LOCK = "junior:upgrade:repair-conversation-usage";
-var USAGE_REPAIR_BATCH_SQL = `
-WITH candidates AS MATERIALIZED (
-  SELECT
-    conversation_id,
-    updated_at,
-    execution_updated_at
-  FROM junior_conversations
-  WHERE parent_conversation_id IS NULL
-    AND execution_status = 'idle'
-    AND conversation_id > $1
-  ORDER BY conversation_id
-  LIMIT $2
-),
--- Occurrence numbers preserve intentional duplicates within one history version
--- while collapsing context copies of the same message across replacements.
-message_occurrences AS (
-  SELECT
-    event.conversation_id,
-    event.payload -> 'message' AS message,
-    row_number() OVER (
-      PARTITION BY
-        event.conversation_id,
-        event.history_version,
-        event.payload -> 'message'
-      ORDER BY event.seq
-    ) AS occurrence
-  FROM junior_conversation_events AS event
-  INNER JOIN candidates AS candidate
-    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
-  FROM message_occurrences
-),
-usage_values AS (
-  SELECT
-    conversation_id,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'input') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'input')::numeric))
-      WHEN jsonb_typeof(message -> 'usage' -> 'inputTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'inputTokens')::numeric))
-    END AS input_tokens,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'output') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'output')::numeric))
-      WHEN jsonb_typeof(message -> 'usage' -> 'outputTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'outputTokens')::numeric))
-    END AS output_tokens,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'cacheRead') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'cacheRead')::numeric))
-      WHEN jsonb_typeof(message -> 'usage' -> 'cachedInputTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'cachedInputTokens')::numeric))
-    END AS cached_input_tokens,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'cacheWrite') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'cacheWrite')::numeric))
-      WHEN jsonb_typeof(message -> 'usage' -> 'cacheCreationTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'cacheCreationTokens')::numeric))
-    END AS cache_creation_tokens,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'reasoning') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'reasoning')::numeric))
-      WHEN jsonb_typeof(message -> 'usage' -> 'reasoningTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'reasoningTokens')::numeric))
-    END AS reasoning_tokens,
-    CASE
-      WHEN jsonb_typeof(message -> 'usage' -> 'totalTokens') = 'number'
-        THEN greatest(0, floor((message -> 'usage' ->> 'totalTokens')::numeric))
-    END AS total_tokens,
-    CASE WHEN jsonb_typeof(message -> 'usage' -> 'cost' -> 'input') = 'number'
-      THEN greatest(0, (message -> 'usage' -> 'cost' ->> 'input')::numeric)
-    END AS cost_input,
-    CASE WHEN jsonb_typeof(message -> 'usage' -> 'cost' -> 'output') = 'number'
-      THEN greatest(0, (message -> 'usage' -> 'cost' ->> 'output')::numeric)
-    END AS cost_output,
-    CASE WHEN jsonb_typeof(message -> 'usage' -> 'cost' -> 'cacheRead') = 'number'
-      THEN greatest(0, (message -> 'usage' -> 'cost' ->> 'cacheRead')::numeric)
-    END AS cost_cache_read,
-    CASE WHEN jsonb_typeof(message -> 'usage' -> 'cost' -> 'cacheWrite') = 'number'
-      THEN greatest(0, (message -> 'usage' -> 'cost' ->> 'cacheWrite')::numeric)
-    END AS cost_cache_write,
-    CASE WHEN jsonb_typeof(message -> 'usage' -> 'cost' -> 'total') = 'number'
-      THEN greatest(0, (message -> 'usage' -> 'cost' ->> 'total')::numeric)
-    END AS cost_total
-  FROM canonical_messages
-),
-rollups AS (
-  SELECT
-    conversation_id,
-    sum(input_tokens) AS input_tokens,
-    sum(output_tokens) AS output_tokens,
-    sum(cached_input_tokens) AS cached_input_tokens,
-    sum(cache_creation_tokens) AS cache_creation_tokens,
-    sum(reasoning_tokens) AS reasoning_tokens,
-    sum(
-      CASE
-        WHEN input_tokens IS NULL
-          AND output_tokens IS NULL
-          AND cached_input_tokens IS NULL
-          AND cache_creation_tokens IS NULL
-        THEN total_tokens
-      END
-    ) AS total_only_tokens,
-    round(sum(cost_input), 12) AS cost_input,
-    round(sum(cost_output), 12) AS cost_output,
-    round(sum(cost_cache_read), 12) AS cost_cache_read,
-    round(sum(cost_cache_write), 12) AS cost_cache_write,
-    round(sum(cost_total), 12) AS cost_total
-  FROM usage_values
-  GROUP BY conversation_id
-  HAVING count(input_tokens)
-    + count(output_tokens)
-    + count(cached_input_tokens)
-    + count(cache_creation_tokens)
-    + count(reasoning_tokens)
-    + count(total_tokens)
-    + count(cost_input)
-    + count(cost_output)
-    + count(cost_cache_read)
-    + count(cost_cache_write)
-    + count(cost_total) > 0
-),
-valid_rollups AS (
-  SELECT *
-  FROM rollups
-  WHERE (input_tokens IS NULL OR input_tokens <= ${MAX_SAFE_INTEGER})
-    AND (output_tokens IS NULL OR output_tokens <= ${MAX_SAFE_INTEGER})
-    AND (cached_input_tokens IS NULL OR cached_input_tokens <= ${MAX_SAFE_INTEGER})
-    AND (cache_creation_tokens IS NULL OR cache_creation_tokens <= ${MAX_SAFE_INTEGER})
-    AND (reasoning_tokens IS NULL OR reasoning_tokens <= ${MAX_SAFE_INTEGER})
-    AND (total_only_tokens IS NULL OR total_only_tokens <= ${MAX_SAFE_INTEGER})
-    AND (
-      total_only_tokens IS NULL
-      OR total_only_tokens
-        + coalesce(input_tokens, 0)
-        + coalesce(output_tokens, 0)
-        + coalesce(cached_input_tokens, 0)
-        + coalesce(cache_creation_tokens, 0) <= ${MAX_SAFE_INTEGER}
-    )
-    AND (cost_input IS NULL OR cost_input <= ${MAX_FINITE_DOUBLE}::numeric)
-    AND (cost_output IS NULL OR cost_output <= ${MAX_FINITE_DOUBLE}::numeric)
-    AND (cost_cache_read IS NULL OR cost_cache_read <= ${MAX_FINITE_DOUBLE}::numeric)
-    AND (cost_cache_write IS NULL OR cost_cache_write <= ${MAX_FINITE_DOUBLE}::numeric)
-    AND (cost_total IS NULL OR cost_total <= ${MAX_FINITE_DOUBLE}::numeric)
-),
-normalized AS (
-  SELECT
-    conversation_id,
-    jsonb_strip_nulls(jsonb_build_object(
-      'inputTokens', CASE WHEN total_only_tokens IS NULL THEN input_tokens END,
-      'outputTokens', CASE WHEN total_only_tokens IS NULL THEN output_tokens END,
-      'cachedInputTokens', CASE
-        WHEN total_only_tokens IS NULL THEN cached_input_tokens
-      END,
-      'cacheCreationTokens', CASE
-        WHEN total_only_tokens IS NULL THEN cache_creation_tokens
-      END,
-      'reasoningTokens', reasoning_tokens,
-      'totalTokens', CASE
-        WHEN total_only_tokens IS NOT NULL
-        THEN total_only_tokens
-          + coalesce(input_tokens, 0)
-          + coalesce(output_tokens, 0)
-          + coalesce(cached_input_tokens, 0)
-          + coalesce(cache_creation_tokens, 0)
-      END,
-      'cost', CASE
-        WHEN cost_input IS NULL
-          AND cost_output IS NULL
-          AND cost_cache_read IS NULL
-          AND cost_cache_write IS NULL
-          AND cost_total IS NULL
-        THEN NULL
-        ELSE jsonb_strip_nulls(jsonb_build_object(
-          'input', cost_input,
-          'output', cost_output,
-          'cacheRead', cost_cache_read,
-          'cacheWrite', cost_cache_write,
-          'total', cost_total
-        ))
-      END
-    )) AS usage
-  FROM valid_rollups
-),
-matched AS MATERIALIZED (
-  SELECT conversation.conversation_id
-  FROM junior_conversations AS conversation
-  INNER JOIN candidates AS candidate USING (conversation_id)
-  INNER JOIN normalized USING (conversation_id)
-  WHERE conversation.execution_status = 'idle'
-    AND conversation.updated_at = candidate.updated_at
-    AND conversation.execution_updated_at IS NOT DISTINCT FROM candidate.execution_updated_at
-  FOR UPDATE OF conversation
-),
-updated AS (
-  UPDATE junior_conversations AS conversation
-  SET usage_json = normalized.usage
-  FROM normalized
-  INNER JOIN matched USING (conversation_id)
-  WHERE conversation.conversation_id = normalized.conversation_id
-    AND conversation.usage_json IS DISTINCT FROM normalized.usage
-  RETURNING conversation.conversation_id
-)
-SELECT
-  candidate.conversation_id AS "conversationId",
-  updated.conversation_id IS NOT NULL AS changed,
-  matched.conversation_id IS NOT NULL AS matched,
-  normalized.conversation_id IS NOT NULL AS repairable
-FROM candidates AS candidate
-LEFT JOIN normalized USING (conversation_id)
-LEFT JOIN matched USING (conversation_id)
-LEFT JOIN updated USING (conversation_id)
-ORDER BY candidate.conversation_id
-`;
-async function repairConversationUsage(_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 ?? CONVERSATION_USAGE_REPAIR_BATCH_SIZE)
-  );
-  try {
-    let cursor = "";
-    let existing = 0;
-    let migrated = 0;
-    let missing = 0;
-    let scanned = 0;
-    let skipped = 0;
-    while (true) {
-      const sources = await executor.withLock(
-        REPAIR_LOCK,
-        () => executor.query(USAGE_REPAIR_BATCH_SQL, [
-          cursor,
-          batchSize
-        ])
-      );
-      if (sources.length === 0) break;
-      scanned += sources.length;
-      for (const source of sources) {
-        if (!source.repairable) {
-          missing += 1;
-        } else if (source.changed) {
-          migrated += 1;
-        } else if (source.matched) {
-          existing += 1;
-        } else {
-          skipped += 1;
-        }
-      }
-      cursor = sources.at(-1).conversationId;
-    }
-    return {
-      existing,
-      migrated,
-      missing,
-      scanned,
-      ...skipped > 0 ? { skipped } : {}
-    };
-  } finally {
-    await closeExecutor?.();
-  }
-}
-var conversationUsageRepairMigration = {
-  name: "repair-conversation-usage",
-  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();
+  return join(packageRoot, "migrations");
 }
-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)
+async function loadCoreMigrationState(executor) {
+  try {
+    const [migration] = await executor.query(`
+SELECT created_at::text AS "appliedAt"
+FROM drizzle.__drizzle_junior_core
+ORDER BY created_at DESC
+LIMIT 1
+`);
+    if (migration?.appliedAt !== null && migration?.appliedAt !== void 0) {
+      return {
+        appliedAt: Number(migration.appliedAt),
+        hasJuniorTables: true
+      };
     }
-  ];
-  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);
+  } catch (error) {
+    if (!isPostgresErrorCode(error, "42P01")) {
+      throw error;
     }
-    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] : [];
-    })
-  );
+  const [tables] = await executor.query(`
+SELECT EXISTS (
+    SELECT 1
+    FROM information_schema.tables
+    WHERE table_schema = 'public'
+      AND table_name LIKE 'junior\\_%' ESCAPE '\\'
+  ) AS "hasJuniorTables"
+`);
   return {
-    ...compactedMessageCount === void 0 ? {} : { compactedMessageCount },
-    liveMessageIds
+    hasJuniorTables: tables?.hasJuniorTables ?? false
   };
 }
-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
-    };
-  });
+function isCurrentMigrationState(state, latestMigrationAt) {
+  return state.appliedAt !== void 0 && state.appliedAt >= latestMigrationAt;
 }
-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;
+function migrationResult(migrations, state) {
+  const appliedAt = state.appliedAt;
+  const existing = appliedAt === void 0 ? 0 : migrations.filter((migration) => migration.folderMillis <= appliedAt).length;
+  return {
+    existing,
+    migrated: migrations.length - existing,
+    scanned: migrations.length
+  };
 }
-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;
+function assertSupportedMigrationState(state) {
+  if (!state.hasJuniorTables || state.appliedAt !== void 0) {
+    return;
   }
-  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]
+  throw new Error(
+    `Existing Junior SQL tables have no core Drizzle migration history. Stop old Junior workers, install @sentry/junior@${CORE_MIGRATION_BRIDGE_VERSION}, run \`junior upgrade\`, then restore this Junior version and rerun \`junior upgrade\` before restarting workers.`
   );
 }
-function coveredMessageIds(payload) {
-  if (!Array.isArray(payload.compactions)) return [];
-  return payload.compactions.flatMap((compaction) => {
-    if (!isRecord(compaction) || !Array.isArray(compaction.coveredMessageIds)) {
-      return [];
+async function migrateSchema(executor) {
+  const migrationsFolder = migrationFolder();
+  const migrations = readMigrationFiles({ migrationsFolder });
+  const latestMigration = migrations.at(-1);
+  if (!latestMigration) {
+    throw new Error("No core Drizzle migrations were packaged");
+  }
+  const initialState = await loadCoreMigrationState(executor);
+  if (isCurrentMigrationState(initialState, latestMigration.folderMillis)) {
+    return migrationResult(migrations, initialState);
+  }
+  assertSupportedMigrationState(initialState);
+  return await executor.withMigrationLock(MIGRATIONS_TABLE, async () => {
+    const lockedState = await loadCoreMigrationState(executor);
+    if (isCurrentMigrationState(lockedState, latestMigration.folderMillis)) {
+      return migrationResult(migrations, lockedState);
     }
-    return compaction.coveredMessageIds.flatMap((id) => {
-      const value = toOptionalString(id);
-      return value ? [value] : [];
+    assertSupportedMigrationState(lockedState);
+    await executor.migrate({
+      migrationsFolder,
+      migrationsTable: MIGRATIONS_TABLE
     });
+    return migrationResult(migrations, lockedState);
   });
 }
-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);
+
+// src/cli/upgrade.ts
+import { createJiti } from "jiti";
+
+// src/chat/plugins/migrations.ts
+import { createHash } from "crypto";
+import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
+var LEGACY_SCHEDULER_BASELINE_HASH = "d1d2f712181dd3a0557808f0fc67fd0722691d25f4c8cfb816b77c71d19e1e42";
+function migrationTable(pluginName) {
+  const label = pluginName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32);
+  const hash = createHash("sha256").update(pluginName).digest("hex").slice(0, 8);
+  return `__drizzle_${label}_${hash}`;
 }
-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
+async function appliedMigrationTime(executor, table) {
+  try {
+    const [row] = await executor.query(
+      `SELECT created_at::text AS "createdAt"
+       FROM drizzle.${table}
+       ORDER BY created_at DESC
+       LIMIT 1`
     );
-    return args.visibleEvents.find((event) => event.seq > lastCoveredSeq)?.seq ?? args.endSeq;
+    return row?.createdAt === null || row?.createdAt === void 0 ? void 0 : Number(row.createdAt);
+  } catch (error) {
+    if (isPostgresErrorCode(error, "42P01")) {
+      return void 0;
+    }
+    throw error;
   }
-  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 legacyMigrationHashes(executor, pluginName) {
+  const [exists] = await executor.query(
+    `SELECT to_regclass('public.junior_schema_migrations')::text AS "tableName"`
   );
-}
-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
-        );
-      });
-    }
+  if (!exists?.tableName) {
+    return /* @__PURE__ */ new Set();
+  }
+  const rows = await executor.query(
+    `SELECT checksum
+     FROM junior_schema_migrations
+     WHERE id LIKE $1
+     ORDER BY id ASC`,
+    [`plugin:${pluginName}/%`]
   );
+  return new Set(rows.map((row) => row.checksum));
 }
-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();
+function adoptedMigration(migrations, legacyHashes, pluginName) {
+  let adopted;
+  for (const migration of migrations) {
+    if (!legacyHashes.has(migration.hash)) {
+      break;
+    }
+    adopted = migration;
+  }
+  if (!adopted && pluginName === "scheduler" && legacyHashes.has(LEGACY_SCHEDULER_BASELINE_HASH)) {
+    return migrations[0];
   }
-  const batchSize = Math.max(
-    1,
-    Math.floor(options.batchSize ?? VISIBLE_EVENT_BATCH_SIZE)
+  return adopted;
+}
+async function adoptLegacyMigrationState(args) {
+  const legacyHashes = await legacyMigrationHashes(
+    args.executor,
+    args.pluginName
   );
-  let migrated = 0;
-  let cursor;
-  try {
-    const [legacyTable] = await executor.query(
-      `SELECT to_regclass('public.junior_conversation_messages') IS NOT NULL AS exists`
+  const migration = adoptedMigration(
+    args.migrations,
+    legacyHashes,
+    args.pluginName
+  );
+  if (!migration) {
+    return void 0;
+  }
+  await args.executor.transaction(async () => {
+    await args.executor.execute("CREATE SCHEMA IF NOT EXISTS drizzle");
+    await args.executor.execute(`
+CREATE TABLE IF NOT EXISTS drizzle.${args.table} (
+  id SERIAL PRIMARY KEY,
+  hash TEXT NOT NULL,
+  created_at BIGINT
+)
+`);
+    await args.executor.execute(
+      `INSERT INTO drizzle.${args.table} (hash, created_at) VALUES ($1, $2)`,
+      [migration.hash, migration.folderMillis]
     );
-    if (!legacyTable?.exists) {
-      return { existing: 0, migrated: 0, missing: 0, scanned: 0 };
+  });
+  return migration.folderMillis;
+}
+function appliedCount(migrations, createdAt) {
+  return createdAt === void 0 ? 0 : migrations.filter((migration) => migration.folderMillis <= createdAt).length;
+}
+async function migratePluginSchemas(executor, roots, options = {}) {
+  const result = {
+    existing: 0,
+    migrated: 0,
+    scanned: 0
+  };
+  const orderedRoots = [...roots].sort(
+    (left, right) => left.pluginName.localeCompare(right.pluginName)
+  );
+  for (const root of orderedRoots) {
+    const migrations = readMigrationFiles2({ migrationsFolder: root.dir });
+    if (migrations.length === 0) {
+      continue;
     }
-    const [before] = await executor.query(
-      COUNT_MISSING_VISIBLE_EVENTS_SQL
-    );
-    if (!before) {
-      throw new Error(
-        "Visible-message event migration could not inspect its projection"
-      );
+    const table = migrationTable(root.pluginName);
+    const initialTime = await appliedMigrationTime(executor, table);
+    const initialExisting = appliedCount(migrations, initialTime);
+    if (initialExisting === migrations.length) {
+      const summary2 = {
+        existing: initialExisting,
+        migrated: 0,
+        pluginName: root.pluginName,
+        scanned: migrations.length
+      };
+      result.scanned += summary2.scanned;
+      result.existing += summary2.existing;
+      options.onPluginMigration?.(summary2);
+      continue;
     }
-    if (before.count > 0) {
-      const visibleConversationIds = /* @__PURE__ */ new Set();
-      await visitVisibleConversations(
+    const summary = await executor.withMigrationLock(table, async () => {
+      const currentTime = await appliedMigrationTime(executor, table) ?? await adoptLegacyMigrationState({
         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);
+        migrations,
+        pluginName: root.pluginName,
+        table
+      });
+      const existing = appliedCount(migrations, currentTime);
+      if (existing < migrations.length) {
+        await executor.migrate({
+          migrationsFolder: root.dir,
+          migrationsTable: table
+        });
       }
-      migrated += rows.length;
-      const last = rows.at(-1);
-      cursor = {
-        conversationId: last.conversation_id,
-        createdAt: last.created_at,
-        messageId: last.message_id
+      return {
+        existing,
+        migrated: migrations.length - existing,
+        pluginName: root.pluginName,
+        scanned: migrations.length
       };
-    }
-    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?.();
+    });
+    result.scanned += summary.scanned;
+    result.existing += summary.existing;
+    result.migrated += summary.migrated;
+    options.onPluginMigration?.(summary);
   }
+  return result;
 }
-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] : []
-  );
+// src/cli/upgrade/migrations/upgrade-plugins.ts
+function unique(values) {
+  return [...new Set(values)];
 }
-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 baseCatalogConfig(context) {
+  return context.pluginCatalogConfig ?? (context.pluginSet ? pluginCatalogConfigFromPluginSet(context.pluginSet) : pluginCatalogConfigFromEnv());
 }
-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 inlinePluginName(definition) {
+  return definition.manifest.name;
 }
-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`
-    );
+function mergeInlineManifests(left, right) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const definition of [...left ?? [], ...right ?? []]) {
+    merged.set(inlinePluginName(definition), definition);
   }
-  return {
-    message: normalizeCheckpoint ? normalizeLegacyContextMessage(message) : message,
-    ...row.payload.provenance === void 0 ? {} : { provenance: row.payload.provenance }
-  };
+  return merged.size > 0 ? [...merged.values()] : void 0;
 }
-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");
+function mergeCatalogConfig(base, added) {
+  if (!base) {
+    return added;
+  }
+  if (!added) {
+    return base;
   }
+  const inlineManifests = mergeInlineManifests(
+    base.inlineManifests,
+    added.inlineManifests
+  );
+  const packages = unique([
+    ...base.packages ?? [],
+    ...added.packages ?? []
+  ]);
+  const manifests = base.manifests || added.manifests ? { ...base.manifests, ...added.manifests } : void 0;
   return {
-    modelProfile,
-    modelId: modelId ?? modelIdForProfile(bot, modelProfile)
+    ...inlineManifests ? { inlineManifests } : {},
+    ...packages.length > 0 ? { packages } : {},
+    ...manifests ? { manifests } : {}
   };
 }
-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;
+function packageNamesFromContext(context, catalog) {
+  return unique([
+    ...context.pluginSet?.packageNames ?? [],
+    ...catalog?.packages ?? []
+  ]);
 }
-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 resolveUpgradePluginCatalog(context) {
+  const catalog = baseCatalogConfig(context);
+  const packageNames = packageNamesFromContext(context, catalog);
+  const registrations = context.pluginSet?.registrations ?? [];
+  const manifests = context.pluginSet?.manifests || catalog?.manifests ? {
+    ...catalog?.manifests,
+    ...context.pluginSet?.manifests
+  } : void 0;
+  const pluginSet = packageNames.length > 0 || registrations.length > 0 || context.pluginSet ? defineJuniorPlugins(
+    [...packageNames, ...registrations],
+    manifests ? { manifests } : {}
+  ) : void 0;
+  return mergeCatalogConfig(
+    catalog,
+    pluginCatalogConfigFromPluginSet(pluginSet)
   );
 }
-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();
-  }
+
+// src/cli/upgrade/migrations/plugin-sql.ts
+async function migratePluginsToSql(context, options = {}) {
+  const pluginCatalog = createPluginCatalogRuntime();
+  pluginCatalog.setConfig(await resolveUpgradePluginCatalog(context));
+  return await migratePluginSchemas(
+    context.sqlExecutor,
+    pluginCatalog.getMigrationRoots(),
+    options
+  );
 }
-var conversationContextCheckpointMigration = {
-  name: "normalize-conversation-context-checkpoints",
-  run: normalizeConversationContextCheckpoints
-};
 
 // src/cli/upgrade.ts
 var DEFAULT_IO = {
   info: console.log
 };
 var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
-var MIGRATIONS = [
-  agentTurnSessionActorMigration,
-  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
-];
 function isMissingVirtualConfig(error) {
   if (!(error instanceof Error)) {
     return false;
@@ -3566,50 +369,56 @@ async function resolveUpgradePluginSet() {
     async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
   );
 }
-function formatMigrationResult(result) {
-  const fields = [
-    `scanned=${result.scanned}`,
-    `migrated=${result.migrated}`,
-    `existing=${result.existing}`,
-    `missing=${result.missing}`
-  ];
-  if (result.skipped !== void 0) {
-    fields.push(`skipped=${result.skipped}`);
-  }
-  return fields.join(" ");
+function migrationCount(count) {
+  return `${count} ${count === 1 ? "migration" : "migrations"}`;
 }
-async function runUpgradeMigrations(context) {
-  const plugins = await resolveUpgradePlugins(context);
-  const migrationContext = { ...context, ...plugins };
-  const results = [];
-  for (const migration of MIGRATIONS) {
-    migrationContext.io.info(`Running migration ${migration.name}...`);
-    const result = await migration.run(migrationContext);
-    migrationContext.io.info(
-      `Finished migration ${migration.name}: ${formatMigrationResult(result)}`
-    );
-    results.push(result);
+function formatOwnerSummary(owner, summary) {
+  if (summary.migrated === 0) {
+    return `  ${owner}: up to date (${migrationCount(summary.scanned)})`;
   }
-  return results;
+  return `  ${owner}: applied ${migrationCount(summary.migrated)} (${summary.scanned} total)`;
+}
+function pluginMigrationOwner(pluginName) {
+  const unscopedName = pluginName.split("/").at(-1) ?? pluginName;
+  return unscopedName.startsWith("junior-") ? unscopedName : `junior-${unscopedName}`;
+}
+async function runDatabaseMigrations(context, io) {
+  io.info("Checking database migrations...");
+  const core = await migrateSchema(context.sqlExecutor);
+  io.info(formatOwnerSummary("junior", core));
+  const plugins = await migratePluginsToSql(context, {
+    onPluginMigration: (summary) => {
+      io.info(
+        formatOwnerSummary(pluginMigrationOwner(summary.pluginName), summary)
+      );
+    }
+  });
+  const migrated = core.migrated + plugins.migrated;
+  const scanned = core.scanned + plugins.scanned;
+  io.info(
+    migrated === 0 ? `Database is up to date (${migrationCount(scanned)}).` : `Applied ${migrationCount(migrated)} (${scanned} total).`
+  );
 }
 async function runUpgrade(io = DEFAULT_IO, options = {}) {
+  const { sql } = getChatConfig();
+  const sqlExecutor = createJuniorSqlExecutor({
+    connectionString: sql.databaseUrl,
+    driver: sql.driver
+  });
   try {
-    const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
     const pluginSet = options.pluginSet === void 0 ? await resolveUpgradePluginSet() : options.pluginSet ?? void 0;
-    io.info("Running Junior upgrade migrations...");
-    await runUpgradeMigrations({
-      io,
-      pluginSet,
-      redisStateAdapter,
-      stateAdapter
-    });
-    io.info("Junior upgrade complete.");
+    await runDatabaseMigrations(
+      {
+        pluginSet,
+        sqlExecutor
+      },
+      io
+    );
   } finally {
-    await disconnectStateAdapter();
+    await sqlExecutor.close();
   }
 }
 export {
   resolveUpgradePluginSet,
-  runUpgrade,
-  runUpgradeMigrations
+  runUpgrade
 };