@sentry/junior 0.106.0 → 0.107.1

package/dist/{runner-HA5XAL6K.js → runner-ACR2HAIC.js}

@@ -1,64 +1,73 @@
 import {
+  ConversationTurnLifecycleService,
   buildDeliveredTurnStatePatch,
-  finalizeFailedTurnReply,
+  finalizeFailedTurnReplyWithEvent,
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-4W4O4DCV.js";
+} from "./chunk-CQ7KSO2B.js";
 import "./chunk-KNFROR7R.js";
 import {
+  buildConversationContext,
   coerceThreadArtifactsState,
   completeDeliveredTurn,
   getPersistedSandboxState,
   getPersistedThreadState,
-  markTurnFailed,
-  persistThreadStateById,
-  startActiveTurn
-} from "./chunk-BKM4UXUD.js";
-import {
-  coerceThreadConversationState
-} from "./chunk-XIMUQ4IU.js";
-import {
-  commitMessages,
-  loadProjection
-} from "./chunk-DDRQ4U7I.js";
-import {
-  buildConversationContext,
   hydrateConversationMessages,
   markConversationMessage,
+  markTurnFailed,
   normalizeConversationText,
+  persistConversationMessages,
+  persistThreadStateById,
+  persistWithRetry,
+  recordDeliveredAssistantMessage,
+  startActiveTurn,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-P4P7O5WG.js";
+} from "./chunk-YFQ7CQDE.js";
+import {
+  coerceThreadConversationState,
+  loadProjection
+} from "./chunk-4YF7Z6IA.js";
+import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
-import "./chunk-ZMRLBBD5.js";
-import "./chunk-AZ5OMSN5.js";
+import "./chunk-RMVOAJRL.js";
+import "./chunk-AUUOHQAT.js";
 import "./chunk-G3E7SCME.js";
-import "./chunk-3MPPVPGZ.js";
-import "./chunk-XTKJPSMF.js";
+import "./chunk-B2Z2H66D.js";
+import "./chunk-VH6KWKG2.js";
 import {
-  sleep
-} from "./chunk-4ZNGQH7C.js";
+  getConversationEventStore
+} from "./chunk-NVOTGWYX.js";
+import "./chunk-4ZNGQH7C.js";
 import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-4UYIRWDW.js";
-import "./chunk-FXFQNHRU.js";
+} from "./chunk-SS67LUOK.js";
+import "./chunk-VFUK3X5B.js";
 import "./chunk-RT5BUHR5.js";
 import "./chunk-B7PUBQQM.js";
+import "./chunk-VIXFG2VC.js";
 import {
   logException
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-7FBGKXPE.js";
 import "./chunk-MLKGABMK.js";
 
 // src/chat/local/runner.ts
+import { randomUUID } from "crypto";
 import {
   createLocalSource,
   localDestinationSchema
 } from "@sentry/junior-plugin-api";
-var DELIVERED_STATE_PERSIST_ATTEMPTS = 3;
+var SENTRY_EVENT_ID_PATTERN = /^[a-f0-9]{32}$/i;
+var LOCAL_FAILURE_EVENT_NAMES = {
+  agent_run_failed: "local_agent_run_failed",
+  delivery_failed: "local_reply_delivery_failed",
+  model_execution_failed: "local_model_execution_failed",
+  persistence_failed: "local_turn_persistence_failed"
+};
 function localDestination(conversationId) {
   const parsed = localDestinationSchema.safeParse({
     platform: "local",
@@ -69,16 +78,18 @@ function localDestination(conversationId) {
   }
   return parsed.data;
 }
-function localTurnId(sequence) {
-  return `local-turn-${sequence}`;
-}
-function localReply(reply) {
-  return {
-    text: reply.text
-  };
+function localTurnId() {
+  return `local-turn-${randomUUID()}`;
 }
-function nextUserMessageSequence(conversation) {
-  return conversation.messages.filter((message) => message.role === "user").length + 1;
+function captureLocalBoundaryFailure(args) {
+  const eventId = args.capture(
+    args.error,
+    LOCAL_FAILURE_EVENT_NAMES[args.failureCode],
+    { conversationId: args.conversationId, runId: args.turnId },
+    { "app.ai.failure_code": args.failureCode },
+    "Local agent turn failed at its owning runtime boundary"
+  );
+  return eventId && SENTRY_EVENT_ID_PATTERN.test(eventId) ? eventId : void 0;
 }
 async function loadLocalPiMessages(args) {
   const projection = await loadProjection({
@@ -89,21 +100,6 @@ async function loadLocalPiMessages(args) {
   }
   return stripRuntimeTurnContext(trimTrailingAssistantMessages(projection));
 }
-async function persistDeliveredLocalTurnState(conversationId, patch) {
-  let lastError;
-  for (let attempt = 1; attempt <= DELIVERED_STATE_PERSIST_ATTEMPTS; attempt += 1) {
-    try {
-      await persistThreadStateById(conversationId, patch);
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt < DELIVERED_STATE_PERSIST_ATTEMPTS) {
-        await sleep(attempt * 100);
-      }
-    }
-  }
-  throw lastError;
-}
 async function runLocalAgentTurn(input, deps) {
   const text = input.message.trim();
   if (!text) {
@@ -114,6 +110,7 @@ async function runLocalAgentTurn(input, deps) {
   }
   const destination = localDestination(input.conversationId);
   const source = createLocalSource(destination.conversationId);
+  const lifecycle = deps.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
   const now = deps.now ?? (() => Date.now());
   const persisted = await getPersistedThreadState(input.conversationId);
   const conversation = coerceThreadConversationState(persisted);
@@ -126,8 +123,7 @@ async function runLocalAgentTurn(input, deps) {
   const initialArtifacts = artifacts;
   const initialSandboxId = sandboxId;
   const initialSandboxDependencyProfileHash = sandboxDependencyProfileHash;
-  const sequence = nextUserMessageSequence(conversation);
-  const turnId = localTurnId(sequence);
+  const turnId = localTurnId();
   const userMessageId = `${turnId}:user`;
   const startedAtMs = now();
   upsertConversationMessage(conversation, {
@@ -145,27 +141,75 @@ async function runLocalAgentTurn(input, deps) {
       replied: false
     }
   });
+  await persistConversationMessages({
+    conversation,
+    conversationId: input.conversationId
+  });
+  await lifecycle.start({
+    conversationId: input.conversationId,
+    createdAtMs: now(),
+    inputMessageIds: [userMessageId],
+    surface: "internal",
+    turnId
+  });
   startActiveTurn({
     conversation,
     nextTurnId: turnId,
     updateConversationStats
   });
-  await persistThreadStateById(input.conversationId, { conversation });
   let reply;
   let completedState;
-  let piMessagesBeforeRun;
+  let failureCode = "persistence_failed";
+  let modelFailureEventId;
+  let modelFailureCaptureAttempted = false;
   const localActor = {
     fullName: "Local CLI",
     platform: "local",
     userId: "local-cli",
     userName: "local"
   };
+  let assistantMessageDelivered = false;
+  const deliverAssistantMessage = async (message) => {
+    if (!message.text.trim()) {
+      return;
+    }
+    failureCode = "delivery_failed";
+    await deps.deliverReply({ text: message.text });
+    assistantMessageDelivered = true;
+    recordDeliveredAssistantMessage({
+      conversation,
+      sessionId: turnId,
+      text: message.text,
+      userMessageId
+    });
+    try {
+      await persistWithRetry(
+        () => persistConversationMessages({
+          conversation,
+          conversationId: input.conversationId
+        })
+      );
+    } catch (error) {
+      logException(
+        new Error("Accepted assistant message persistence failed"),
+        "local_assistant_message_post_delivery_persist_failed",
+        { conversationId: input.conversationId },
+        { "error.type": error instanceof Error ? error.name : typeof error },
+        "Failed to persist an accepted local assistant message"
+      );
+    }
+    failureCode = "agent_run_failed";
+  };
   try {
-    const piMessages = await loadLocalPiMessages({
+    await persistThreadStateById(input.conversationId, { conversation });
+    const piMessages = await (deps.loadPiMessages ?? loadLocalPiMessages)({
       conversationId: input.conversationId
     });
-    piMessagesBeforeRun = piMessages;
+    failureCode = "agent_run_failed";
     const outcome = await deps.agentRunner.run({
+      conversationId: input.conversationId,
+      turnId,
+      runId: turnId,
       input: {
         messageText: text,
         conversationContext: buildConversationContext(conversation, {
@@ -180,12 +224,7 @@ async function runLocalAgentTurn(input, deps) {
         destination,
         source,
         actor: localActor,
-        surface: "internal",
-        correlation: {
-          conversationId: input.conversationId,
-          turnId,
-          runId: turnId
-        }
+        surface: "internal"
       },
       policy: {
         authorizationFlowMode: "disabled"
@@ -201,7 +240,6 @@ async function runLocalAgentTurn(input, deps) {
         onStatus: async (status) => {
           await deps.onStatus?.(status.text);
         },
-        onTextDelta: deps.onTextDelta,
         onToolInvocation: async (invocation) => {
           await deps.onToolInvocation?.(invocation);
         },
@@ -209,6 +247,9 @@ async function runLocalAgentTurn(input, deps) {
           await deps.onToolResult?.(result);
         }
       },
+      delivery: {
+        onAssistantMessage: deliverAssistantMessage
+      },
       durability: {
         onArtifactStateUpdated: async (nextArtifacts) => {
           artifacts = nextArtifacts;
@@ -235,11 +276,17 @@ async function runLocalAgentTurn(input, deps) {
       throw new Error(`Local agent run ended with ${outcome.status}`);
     }
     reply = outcome.result;
-    reply = finalizeFailedTurnReply({
+    modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
+    const finalized = finalizeFailedTurnReplyWithEvent({
       reply,
-      logException,
+      logException: deps.logException ?? logException,
       context: { conversationId: input.conversationId }
     });
+    reply = finalized.reply;
+    modelFailureEventId = finalized.eventId;
+    if (reply.diagnostics.outcome !== "success") {
+      await deliverAssistantMessage({ text: reply.text });
+    }
     completedState = buildDeliveredTurnStatePatch({
       artifacts,
       conversation,
@@ -247,52 +294,113 @@ async function runLocalAgentTurn(input, deps) {
       sessionId: turnId,
       userMessageId
     });
-    await deps.deliverReply(localReply(reply));
   } catch (error) {
-    if (reply) {
-      await commitMessages({
+    const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureLocalBoundaryFailure({
+      capture: deps.logException ?? logException,
+      conversationId: input.conversationId,
+      error,
+      failureCode,
+      turnId
+    });
+    try {
+      markTurnFailed({
+        conversation,
+        nowMs: now(),
+        sessionId: turnId,
+        userMessageId,
+        markConversationMessage,
+        updateConversationStats
+      });
+      await persistThreadStateById(input.conversationId, {
+        artifacts: initialArtifacts,
+        conversation,
+        sandboxId: initialSandboxId ?? "",
+        sandboxDependencyProfileHash: initialSandboxDependencyProfileHash ?? ""
+      });
+    } catch (persistenceError) {
+      const persistenceEventId = captureLocalBoundaryFailure({
+        capture: deps.logException ?? logException,
         conversationId: input.conversationId,
-        modelId: reply.diagnostics.modelId,
-        messages: piMessagesBeforeRun ?? []
+        error: persistenceError,
+        failureCode: "persistence_failed",
+        turnId
       });
+      await lifecycle.fail({
+        conversationId: input.conversationId,
+        createdAtMs: now(),
+        ...persistenceEventId ? { eventId: persistenceEventId } : {},
+        failureCode: "persistence_failed",
+        turnId
+      });
+      throw new AggregateError(
+        [error, persistenceError],
+        "Local turn failure state could not be persisted"
+      );
     }
-    markTurnFailed({
-      conversation,
-      nowMs: now(),
-      sessionId: turnId,
-      userMessageId,
-      markConversationMessage,
-      updateConversationStats
+    await lifecycle.fail({
+      conversationId: input.conversationId,
+      createdAtMs: now(),
+      ...failureEventId ? { eventId: failureEventId } : {},
+      failureCode,
+      turnId
     });
+    throw error;
+  }
+  try {
     await persistThreadStateById(input.conversationId, {
-      artifacts: initialArtifacts,
-      conversation,
-      sandboxId: initialSandboxId ?? "",
-      sandboxDependencyProfileHash: initialSandboxDependencyProfileHash ?? ""
+      artifacts: completedState.artifacts ?? artifacts,
+      conversation: completedState.conversation,
+      sandboxId: reply.sandboxId ?? sandboxId,
+      sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
+    });
+    if (reply.piMessages?.length) {
+      await (deps.completeDeliveredTurn ?? completeDeliveredTurn)({
+        conversationId: input.conversationId,
+        sessionId: turnId,
+        sliceId: 1,
+        messages: reply.piMessages,
+        modelId: reply.diagnostics.modelId,
+        durationMs: reply.diagnostics.durationMs,
+        usage: reply.diagnostics.usage,
+        reasoningLevel: reply.diagnostics.reasoningLevel,
+        destination,
+        source,
+        actor: localActor,
+        surface: "internal",
+        logContext: {}
+      });
+    }
+  } catch (error) {
+    const persistenceEventId = captureLocalBoundaryFailure({
+      capture: deps.logException ?? logException,
+      conversationId: input.conversationId,
+      error,
+      failureCode: "persistence_failed",
+      turnId
+    });
+    await lifecycle.fail({
+      conversationId: input.conversationId,
+      createdAtMs: now(),
+      ...persistenceEventId ? { eventId: persistenceEventId } : {},
+      failureCode: "persistence_failed",
+      turnId
     });
     throw error;
   }
-  await persistDeliveredLocalTurnState(input.conversationId, {
-    artifacts: completedState.artifacts ?? artifacts,
-    conversation: completedState.conversation,
-    sandboxId: reply.sandboxId ?? sandboxId,
-    sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
-  });
-  if (reply.piMessages?.length) {
-    await completeDeliveredTurn({
+  if (reply.diagnostics.outcome === "success") {
+    await lifecycle.complete({
       conversationId: input.conversationId,
-      sessionId: turnId,
-      sliceId: 1,
-      messages: reply.piMessages,
-      modelId: reply.diagnostics.modelId,
-      durationMs: reply.diagnostics.durationMs,
-      usage: reply.diagnostics.usage,
-      reasoningLevel: reply.diagnostics.reasoningLevel,
-      destination,
-      source,
-      actor: localActor,
-      surface: "internal",
-      logContext: {}
+      createdAtMs: now(),
+      outcome: assistantMessageDelivered ? "success" : "no_reply",
+      turnId
+    });
+  } else {
+    await lifecycle.fail({
+      conversationId: input.conversationId,
+      createdAtMs: now(),
+      ...modelFailureEventId ? { eventId: modelFailureEventId } : {},
+      failureCode: "model_execution_failed",
+      turnId
     });
   }
   if (reply.diagnostics.outcome === "success") {

package/dist/{skills-722AXRV5.js → skills-ITNHBARB.js}

@@ -6,9 +6,10 @@ import {
   parseSkillInvocation,
   resetSkillDiscoveryCache,
   stripFrontmatter
-} from "./chunk-WR7H7VLJ.js";
-import "./chunk-77LHNQK4.js";
-import "./chunk-AEWZ7F65.js";
+} from "./chunk-YT72TOEK.js";
+import "./chunk-YIPD3L6L.js";
+import "./chunk-VIXFG2VC.js";
+import "./chunk-O24R4DCK.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";

package/dist/{validation-EUI2UFRM.js → validation-AGQ46ZGV.js}

@@ -1,9 +1,10 @@
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-MJSJAHBW.js";
-import "./chunk-77LHNQK4.js";
-import "./chunk-AEWZ7F65.js";
+} from "./chunk-DY7TRYB5.js";
+import "./chunk-YIPD3L6L.js";
+import "./chunk-VIXFG2VC.js";
+import "./chunk-O24R4DCK.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";

package/migrations/0005_conversation_events.sql

@@ -0,0 +1,122 @@
+ALTER TABLE "junior_agent_steps" RENAME TO "junior_conversation_events";--> statement-breakpoint
+DO $$
+BEGIN
+	IF EXISTS (
+		SELECT 1
+		FROM pg_constraint
+		WHERE conrelid = 'junior_conversation_events'::regclass
+			AND conname = 'junior_agent_steps_conversation_id_seq_pk'
+	) THEN
+		ALTER TABLE "junior_conversation_events"
+			RENAME CONSTRAINT "junior_agent_steps_conversation_id_seq_pk"
+			TO "junior_conversation_events_conversation_id_seq_pk";
+	ELSIF EXISTS (
+		SELECT 1
+		FROM pg_constraint
+		WHERE conrelid = 'junior_conversation_events'::regclass
+			AND conname = 'junior_agent_steps_pkey'
+	) THEN
+		ALTER TABLE "junior_conversation_events"
+			RENAME CONSTRAINT "junior_agent_steps_pkey"
+			TO "junior_conversation_events_conversation_id_seq_pk";
+	ELSE
+		RAISE EXCEPTION 'junior_agent_steps primary key constraint is missing';
+	END IF;
+END
+$$;--> statement-breakpoint
+DO $$
+BEGIN
+	IF EXISTS (
+		SELECT 1
+		FROM pg_constraint
+		WHERE conrelid = 'junior_conversation_events'::regclass
+			AND conname = 'junior_agent_steps_conversation_id_junior_conversations_conversation_id_fk'
+	) THEN
+		ALTER TABLE "junior_conversation_events"
+			RENAME CONSTRAINT "junior_agent_steps_conversation_id_junior_conversations_conversation_id_fk"
+			TO "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk";
+	ELSIF EXISTS (
+		SELECT 1
+		FROM pg_constraint
+		WHERE conrelid = 'junior_conversation_events'::regclass
+			AND conname = 'junior_agent_steps_conversation_id_fkey'
+	) THEN
+		ALTER TABLE "junior_conversation_events"
+			RENAME CONSTRAINT "junior_agent_steps_conversation_id_fkey"
+			TO "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk";
+	ELSE
+		RAISE EXCEPTION 'junior_agent_steps conversation foreign key constraint is missing';
+	END IF;
+END
+$$;--> statement-breakpoint
+ALTER INDEX "junior_agent_steps_epoch_idx" RENAME TO "junior_conversation_events_history_version_idx";--> statement-breakpoint
+ALTER TABLE "junior_conversation_events" RENAME COLUMN "context_epoch" TO "history_version";--> statement-breakpoint
+ALTER TABLE "junior_conversation_events" ADD COLUMN "schema_version" integer DEFAULT 1 NOT NULL;--> statement-breakpoint
+ALTER TABLE "junior_conversation_events" DROP COLUMN "role";--> statement-breakpoint
+ALTER TABLE "junior_conversation_events" ADD COLUMN "idempotency_key" text;--> statement-breakpoint
+CREATE UNIQUE INDEX "junior_conversation_events_idempotency_idx" ON "junior_conversation_events" USING btree ("conversation_id","idempotency_key");--> statement-breakpoint
+CREATE INDEX "junior_conversation_events_type_idx" ON "junior_conversation_events" USING btree ("conversation_id","type","seq");--> statement-breakpoint
+CREATE INDEX "junior_conversation_events_message_search_idx" ON "junior_conversation_events" USING gin (to_tsvector('english', "payload"->>'text')) WHERE "type" = 'message';--> statement-breakpoint
+UPDATE "junior_conversation_events"
+SET
+	"schema_version" = 1,
+	"type" = 'agent_step',
+	"payload" = CASE
+		WHEN jsonb_typeof("payload") = 'object'
+			THEN "payload" - 'schemaVersion'
+		ELSE "payload"
+	END
+WHERE "type" = 'pi_message';--> statement-breakpoint
+UPDATE "junior_conversation_events"
+SET "payload" = "payload" - 'historyMode'
+WHERE "type" = 'subagent_started'
+	AND jsonb_typeof("payload") = 'object'
+	AND "payload" ? 'historyMode';--> statement-breakpoint
+UPDATE "junior_conversation_events"
+SET "payload" = "payload" - 'args'
+WHERE "type" = 'tool_execution_started'
+	AND jsonb_typeof("payload") = 'object'
+	AND "payload" ? 'args';--> statement-breakpoint
+UPDATE "junior_conversation_events"
+SET "type" = 'messages_summarized'
+WHERE "type" = 'visible_context_compacted';--> statement-breakpoint
+UPDATE "junior_conversation_events" AS snapshot
+SET "payload" =
+	(snapshot."payload" - 'compactions') ||
+	jsonb_build_object(
+		'historyFromSeq',
+		coalesce((
+			SELECT max(recorded."seq") + 1
+			FROM "junior_conversation_events" AS recorded
+			WHERE recorded."conversation_id" = snapshot."conversation_id"
+				AND recorded."seq" < snapshot."seq"
+				AND recorded."type" = 'message'
+				AND EXISTS (
+					SELECT 1
+					FROM jsonb_array_elements(snapshot."payload"->'compactions') AS compaction,
+						jsonb_array_elements_text(compaction->'coveredMessageIds') AS covered_id(value)
+					WHERE covered_id.value = recorded."payload"->>'messageId'
+				)
+		), 0),
+		'compactions',
+		coalesce((
+			SELECT jsonb_agg(
+					(CASE
+						WHEN EXISTS (
+							SELECT 1
+							FROM "junior_conversation_events" AS recorded
+							WHERE recorded."conversation_id" = snapshot."conversation_id"
+								AND recorded."type" = 'message'
+						)
+							THEN compaction - 'coveredMessageIds'
+						ELSE compaction
+					END) ||
+					jsonb_build_object(
+						'coveredMessageCount',
+						jsonb_array_length(compaction->'coveredMessageIds')
+				)
+			)
+			FROM jsonb_array_elements(snapshot."payload"->'compactions') AS compaction
+		), '[]'::jsonb)
+	)
+WHERE snapshot."type" = 'messages_summarized';--> statement-breakpoint

package/migrations/README.md

@@ -1,14 +1,27 @@
-# SQL migrations for `@sentry/junior`
+# SQL migrations
 
-This is a standard Drizzle migration folder. `drizzle-kit generate` owns each
-SQL file, snapshot, and journal entry; `junior upgrade` applies the folder with
-Drizzle ORM's migrator before any data backfills run.
+`src/db/schema.ts` is the Drizzle schema entrypoint. This directory is the
+append-only history used to bring an existing database to that schema.
 
-1. Edit the schema under `src/db/schema/`.
+`junior upgrade` runs the ordered migration list in `src/cli/upgrade.ts`. Core
+SQL runs under a migration lock and is recorded in
+`drizzle.__drizzle_junior_core`, so reruns do not reapply it. Register backfills
+after the schema migration they require.
+
+## Add a migration
+
+1. Change the owning table definition under `src/db/schema/`.
 2. Run `pnpm --filter @sentry/junior db:generate --name <migration_name>`.
-3. Commit the generated SQL file and `meta/` changes together.
+3. Review the generated SQL and commit it with `meta/_journal.json` and its
+   snapshot.
+
+- Prefer SQL for schema changes and deterministic transformations of rows in
+  the same database.
+- Use an application data migration only for external data or work that must be
+  decoded in application code; keep it bounded and rerunnable.
+- Never edit, rename, reorder, or delete an applied SQL migration or its
+  metadata. Add a new migration to correct it.
 
-The `0000_initial.sql` baseline represents the schema already deployed by the
-pre-Drizzle Junior migration runner. During upgrade, existing installations
-adopt that baseline once; new installations execute it normally. All later
-migrations are applied by Drizzle in journal order.
+Migration loading, locking, and legacy baseline adoption live in
+`src/chat/conversations/sql/migrations.ts`. Their integration coverage lives in
+`tests/integration/conversation-sql.test.ts`.