@sentry/junior 0.94.0 → 0.96.0

package/dist/{chunk-NFXSLTYG.js → chunk-RITD7E5L.js}

@@ -1,35 +1,53 @@
 import {
-  getChatConfig
-} from "./chunk-NAPITCZ6.js";
+  getChatConfig,
+  getConnectedStateContext,
+  getStateAdapter
+} from "./chunk-YDVEH3SB.js";
 import {
   parseDestination,
   sameDestination
-} from "./chunk-GHGPTPBL.js";
+} from "./chunk-B7PUBQQM.js";
 import {
   normalizeIdentityEmail,
-  parseStoredSlackActor
-} from "./chunk-S6QKIGRM.js";
+  storedSlackActorSchema
+} from "./chunk-I35CTGPO.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { and as and2, asc, desc, eq as eq2, sql as sql4 } from "drizzle-orm";
+import { and as and2, asc, desc, eq as eq2, isNull, sql as sql4 } from "drizzle-orm";
 
 // src/chat/identities/sql.ts
 import { randomUUID } from "crypto";
 import { and, eq, sql as sql3 } from "drizzle-orm";
 
-// src/chat/conversations/sql/schema/conversations.ts
+// src/db/schema/agent-steps.ts
+import {
+  index as index4,
+  integer as integer2,
+  jsonb as jsonb4,
+  pgTable as pgTable5,
+  primaryKey,
+  text as text5
+} from "drizzle-orm/pg-core";
+
+// src/db/schema/conversations.ts
 import { sql as sql2 } from "drizzle-orm";
-import { index as index3, integer, jsonb as jsonb3, pgTable as pgTable4, text as text4 } from "drizzle-orm/pg-core";
+import {
+  index as index3,
+  integer,
+  jsonb as jsonb3,
+  pgTable as pgTable4,
+  text as text4
+} from "drizzle-orm/pg-core";
 
-// src/chat/conversations/sql/schema/destinations.ts
+// src/db/schema/destinations.ts
 import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
 
-// src/chat/conversations/sql/schema/timestamps.ts
+// src/db/schema/timestamps.ts
 import { timestamp } from "drizzle-orm/pg-core";
 var timestamptz = (name) => timestamp(name, { withTimezone: true });
 
-// src/chat/conversations/sql/schema/destinations.ts
+// src/db/schema/destinations.ts
 var juniorDestinations = pgTable(
   "junior_destinations",
   {
@@ -58,7 +76,7 @@ var juniorDestinations = pgTable(
   ]
 );
 
-// src/chat/conversations/sql/schema/identities.ts
+// src/db/schema/identities.ts
 import { sql } from "drizzle-orm";
 import {
   boolean,
@@ -69,7 +87,7 @@ import {
   uniqueIndex as uniqueIndex3
 } from "drizzle-orm/pg-core";
 
-// src/chat/conversations/sql/schema/users.ts
+// src/db/schema/users.ts
 import { text as text2, pgTable as pgTable2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
 var juniorUsers = pgTable2(
   "junior_users",
@@ -88,7 +106,7 @@ var juniorUsers = pgTable2(
   ]
 );
 
-// src/chat/conversations/sql/schema/identities.ts
+// src/db/schema/identities.ts
 var juniorIdentities = pgTable3(
   "junior_identities",
   {
@@ -122,7 +140,7 @@ var juniorIdentities = pgTable3(
   ]
 );
 
-// src/chat/conversations/sql/schema/conversations.ts
+// src/db/schema/conversations.ts
 var juniorConversations = pgTable4(
   "junior_conversations",
   {
@@ -155,7 +173,13 @@ var juniorConversations = pgTable4(
     executionStatus: text4("execution_status").$type().notNull(),
     runId: text4("run_id"),
     lastCheckpointAt: timestamptz("last_checkpoint_at"),
-    lastEnqueuedAt: timestamptz("last_enqueued_at")
+    lastEnqueuedAt: timestamptz("last_enqueued_at"),
+    // Subagent (advisor) runs are child conversations; top-level listings filter
+    // parent_conversation_id IS NULL.
+    parentConversationId: text4("parent_conversation_id").references(
+      () => juniorConversations.conversationId
+    ),
+    transcriptPurgedAt: timestamptz("transcript_purged_at")
   },
   (table) => [
     index3("junior_conversations_last_activity_idx").on(
@@ -179,20 +203,70 @@ var juniorConversations = pgTable4(
       table.originType,
       table.originId,
       table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_parent_idx").on(table.parentConversationId)
+  ]
+);
+
+// src/db/schema/agent-steps.ts
+var juniorAgentSteps = pgTable5(
+  "junior_agent_steps",
+  {
+    conversationId: text5("conversation_id").notNull().references(() => juniorConversations.conversationId),
+    seq: integer2("seq").notNull(),
+    contextEpoch: integer2("context_epoch").notNull(),
+    type: text5("type").notNull(),
+    role: text5("role"),
+    payload: jsonb4("payload").$type().notNull(),
+    createdAt: timestamptz("created_at").notNull()
+  },
+  (table) => [
+    primaryKey({ columns: [table.conversationId, table.seq] }),
+    index4("junior_agent_steps_epoch_idx").on(
+      table.conversationId,
+      table.contextEpoch,
+      table.seq
     )
   ]
 );
 
-// src/chat/conversations/sql/schema/migrations.ts
-import { pgTable as pgTable5, text as text5 } from "drizzle-orm/pg-core";
-var juniorSchemaMigrations = pgTable5("junior_schema_migrations", {
-  id: text5("id").primaryKey(),
-  checksum: text5("checksum").notNull(),
+// src/db/schema/conversation-messages.ts
+import { index as index5, jsonb as jsonb5, pgTable as pgTable6, primaryKey as primaryKey2, text as text6 } from "drizzle-orm/pg-core";
+var juniorConversationMessages = pgTable6(
+  "junior_conversation_messages",
+  {
+    conversationId: text6("conversation_id").notNull().references(() => juniorConversations.conversationId),
+    messageId: text6("message_id").notNull(),
+    role: text6("role").$type().notNull(),
+    authorIdentityId: text6("author_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    text: text6("text").notNull(),
+    meta: jsonb5("meta").$type(),
+    repliedAt: timestamptz("replied_at"),
+    createdAt: timestamptz("created_at").notNull()
+  },
+  (table) => [
+    primaryKey2({ columns: [table.conversationId, table.messageId] }),
+    index5("junior_conversation_messages_activity_idx").on(
+      table.conversationId,
+      table.createdAt
+    )
+  ]
+);
+
+// src/db/schema/migrations.ts
+import { pgTable as pgTable7, text as text7 } from "drizzle-orm/pg-core";
+var juniorSchemaMigrations = pgTable7("junior_schema_migrations", {
+  id: text7("id").primaryKey(),
+  checksum: text7("checksum").notNull(),
   appliedAt: timestamptz("applied_at").notNull().defaultNow()
 });
 
-// src/chat/conversations/sql/schema.ts
-var schema = {
+// src/db/schema.ts
+var juniorSqlSchema = {
+  juniorAgentSteps,
+  juniorConversationMessages,
   juniorConversations,
   juniorDestinations,
   juniorIdentities,
@@ -200,11 +274,6 @@ var schema = {
   juniorUsers
 };
 
-// src/chat/sql/schema.ts
-var juniorSqlSchema = {
-  ...schema
-};
-
 // src/chat/identities/sql.ts
 function dateFromMs(ms) {
   return new Date(ms);
@@ -312,6 +381,8 @@ async function upsertIdentity(executor, identity, nowMs = Date.now()) {
 
 // src/chat/conversations/sql/migrations.ts
 import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
 import { z } from "zod";
 var MIGRATION_LOCK_NAME = "junior_conversation_schema";
 var migrationRecordSchema = z.object({
@@ -594,6 +665,53 @@ ALTER TABLE junior_conversations
   DROP COLUMN IF EXISTS requester_json
 `
 ];
+var conversationTranscriptStatements = [
+  `
+CREATE TABLE IF NOT EXISTS junior_agent_steps (
+  conversation_id TEXT NOT NULL REFERENCES junior_conversations (conversation_id),
+  seq INTEGER NOT NULL,
+  context_epoch INTEGER NOT NULL,
+  type TEXT NOT NULL,
+  role TEXT,
+  payload JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (conversation_id, seq)
+)
+`,
+  `
+CREATE INDEX IF NOT EXISTS junior_agent_steps_epoch_idx
+  ON junior_agent_steps (conversation_id, context_epoch, seq)
+`,
+  `
+CREATE TABLE IF NOT EXISTS junior_conversation_messages (
+  conversation_id TEXT NOT NULL REFERENCES junior_conversations (conversation_id),
+  message_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  author_identity_id TEXT REFERENCES junior_identities (id),
+  text TEXT NOT NULL,
+  meta JSONB,
+  replied_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (conversation_id, message_id)
+)
+`,
+  `
+CREATE INDEX IF NOT EXISTS junior_conversation_messages_activity_idx
+  ON junior_conversation_messages (conversation_id, created_at)
+`,
+  `
+ALTER TABLE junior_conversations
+  ADD COLUMN IF NOT EXISTS parent_conversation_id TEXT REFERENCES junior_conversations (conversation_id)
+`,
+  `
+ALTER TABLE junior_conversations
+  ADD COLUMN IF NOT EXISTS transcript_purged_at TIMESTAMPTZ
+`,
+  `
+CREATE INDEX IF NOT EXISTS junior_conversations_parent_idx
+  ON junior_conversations (parent_conversation_id)
+`
+];
 var migrations = [
   defineMigration("0001_conversation_core", coreMetadataStatements),
   defineMigration(
@@ -601,7 +719,11 @@ var migrations = [
     destinationVisibilityBackfillStatements
   ),
   defineMigration("0003_user_identities", userIdentityStatements),
-  defineMigration("0004_actor_cutover", actorCutoverStatements)
+  defineMigration("0004_actor_cutover", actorCutoverStatements),
+  defineMigration(
+    "0005_conversation_transcripts",
+    conversationTranscriptStatements
+  )
 ];
 function parseStoredMigrationRecord(value) {
   return migrationRecordSchema.parse(value);
@@ -766,41 +888,54 @@ function executionStatusFromValue(value) {
   throw new Error("Conversation record execution status is invalid");
 }
 function privacyFromRow(row) {
-  if (row.destinationVisibility === null) {
+  if (row.destination === null) {
     return void 0;
   }
-  return row.destinationVisibility === "public" ? "public" : "private";
+  return row.destination.visibility === "public" ? "public" : "private";
 }
-function actorFromIdentityRow(identity, fallback) {
-  if (!identity || identity.provider !== "slack") {
-    return fallback;
+function actorFromIdentityRow(identity) {
+  if (!identity) {
+    return void 0;
+  }
+  if (identity.provider !== "slack") {
+    return void 0;
   }
   return {
-    ...fallback ?? {},
     ...identity.emailNormalized ? { email: identity.emailNormalized } : identity.email ? { email: identity.email } : {},
     ...identity.displayName ? { fullName: identity.displayName } : {},
     platform: "slack",
     slackUserId: identity.providerSubjectId,
     ...identity.handle ? { slackUserName: identity.handle } : {},
-    ...identity.providerTenantId || fallback?.teamId ? { teamId: identity.providerTenantId || fallback?.teamId } : {}
+    ...identity.providerTenantId ? { teamId: identity.providerTenantId } : {}
   };
 }
+function destinationFromRow(destination) {
+  const value = destination?.provider === "slack" ? {
+    platform: "slack",
+    teamId: destination.providerTenantId,
+    channelId: destination.providerDestinationId
+  } : destination?.provider === "local" ? {
+    platform: "local",
+    conversationId: destination.providerDestinationId
+  } : void 0;
+  return parseDestination(value);
+}
 function conversationFromRow(readRow) {
   const row = readRow.conversation;
   const visibility = privacyFromRow(readRow);
   if (row.schemaVersion !== 1) {
     throw new Error("Conversation record schema version is invalid");
   }
-  const destination = row.destination === void 0 || row.destination === null ? void 0 : parseDestination(row.destination);
-  const actor = actorFromIdentityRow(
-    readRow.actorIdentity,
-    parseStoredSlackActor(row.actor)
-  );
-  if (row.destination !== void 0 && row.destination !== null && !destination) {
-    throw new Error("Conversation record destination is invalid");
+  if (row.destination !== null && readRow.destination === null) {
+    throw new Error("Conversation legacy destination is not migrated");
+  }
+  if (row.actor !== null && readRow.actorIdentity === null) {
+    throw new Error("Conversation legacy actor is not migrated");
   }
-  if (row.actor !== void 0 && row.actor !== null && !actor) {
-    throw new Error("Conversation record actor is invalid");
+  const destination = destinationFromRow(readRow.destination);
+  const actor = actorFromIdentityRow(readRow.actorIdentity);
+  if (readRow.destination !== null && !destination) {
+    throw new Error("Conversation record destination is invalid");
   }
   const source = row.source === void 0 || row.source === null ? void 0 : sourceFromValue(row.source);
   if (row.source !== void 0 && row.source !== null && !source) {
@@ -825,6 +960,7 @@ function conversationFromRow(readRow) {
     ...row.channelName ? { channelName: row.channelName } : {},
     ...source ? { source } : {},
     ...row.title ? { title: row.title } : {},
+    ...msFromDate(row.transcriptPurgedAt) !== void 0 ? { transcriptPurgedAtMs: msFromDate(row.transcriptPurgedAt) } : {},
     ...visibility ? { visibility } : {}
   };
 }
@@ -961,6 +1097,31 @@ var SqlStore = class {
       });
     });
   }
+  async ensureChildConversation(args) {
+    const at = dateFromMs2(args.nowMs ?? now());
+    await this.executor.db().insert(juniorConversations).values({
+      conversationId: args.parentConversationId,
+      schemaVersion: 1,
+      createdAt: at,
+      lastActivityAt: at,
+      updatedAt: at,
+      executionStatus: "idle"
+    }).onConflictDoNothing({ target: juniorConversations.conversationId });
+    await this.executor.db().insert(juniorConversations).values({
+      conversationId: args.conversationId,
+      schemaVersion: 1,
+      parentConversationId: args.parentConversationId,
+      createdAt: at,
+      lastActivityAt: at,
+      updatedAt: at,
+      executionStatus: "idle"
+    }).onConflictDoUpdate({
+      target: juniorConversations.conversationId,
+      set: {
+        parentConversationId: sql4`coalesce(${juniorConversations.parentConversationId}, excluded.parent_conversation_id)`
+      }
+    });
+  }
   /** Copy one conversation record into SQL during backfill. */
   async backfillConversation(sourceConversation) {
     const { visibility: _visibility, ...conversation } = sourceConversation;
@@ -1001,7 +1162,7 @@ var SqlStore = class {
   async listByActivity(args = {}) {
     const rows = await this.executor.db().select({
       conversation: juniorConversations,
-      destinationVisibility: juniorDestinations.visibility,
+      destination: juniorDestinations,
       actorIdentity: juniorIdentities
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
@@ -1009,7 +1170,7 @@ var SqlStore = class {
     ).leftJoin(
       juniorIdentities,
       eq2(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).orderBy(
+    ).where(isNull(juniorConversations.parentConversationId)).orderBy(
       desc(juniorConversations.lastActivityAt),
       asc(juniorConversations.conversationId)
     ).limit(Math.max(0, args.limit ?? 1e4)).offset(Math.max(0, args.offset ?? 0));
@@ -1051,7 +1212,7 @@ var SqlStore = class {
   async readConversationRow(conversationId) {
     const rows = await this.executor.db().select({
       conversation: juniorConversations,
-      destinationVisibility: juniorDestinations.visibility,
+      destination: juniorDestinations,
       actorIdentity: juniorIdentities
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
@@ -1091,11 +1252,11 @@ var SqlStore = class {
       originId: null,
       originRunId: null,
       destinationId: destinationId ?? null,
-      destination: conversation.destination ?? null,
+      destination: null,
       actorIdentityId: actorIdentity?.id ?? null,
       creatorIdentityId: null,
       credentialSubjectIdentityId: null,
-      actor: conversation.actor ?? null,
+      actor: null,
       channelName: conversation.channelName ?? null,
       title: conversation.title ?? null,
       createdAt: dateFromMs2(conversation.createdAtMs),
@@ -1114,11 +1275,9 @@ var SqlStore = class {
         originId: sql4`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
         originRunId: sql4`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
         destinationId: sql4`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
-        destination: sql4`coalesce(excluded.destination_json, ${juniorConversations.destination})`,
         actorIdentityId: sql4`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
         creatorIdentityId: sql4`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
         credentialSubjectIdentityId: sql4`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
-        actor: sql4`coalesce(excluded.actor_json, ${juniorConversations.actor})`,
         channelName: sql4`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
         title: sql4`coalesce(excluded.title, ${juniorConversations.title})`,
         createdAt: sql4`least(${juniorConversations.createdAt}, excluded.created_at)`,
@@ -1173,7 +1332,626 @@ function createSqlStore(executor) {
   return new SqlStore(executor, executor);
 }
 
-// src/chat/sql/neon.ts
+// src/chat/conversations/sql/history.ts
+import { and as and3, asc as asc2, eq as eq3, sql as sql6 } from "drizzle-orm";
+
+// src/chat/conversations/history.ts
+import { z as z4 } from "zod";
+
+// src/chat/pi/messages.ts
+import { z as z2 } from "zod";
+var piMessageSchema = z2.object({
+  role: z2.string()
+}).passthrough().transform((value) => value);
+var piContentMessageSchema = z2.object({
+  content: z2.array(z2.unknown()),
+  role: z2.string().min(1)
+}).passthrough().transform((value) => value);
+
+// src/chat/state/session-log.ts
+import { isDeepStrictEqual } from "util";
+import { z as z3 } from "zod";
+import { actorSchema } from "@sentry/junior-plugin-api";
+var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
+var AGENT_SESSION_LOG_SCHEMA_VERSION = 2;
+var INITIAL_SESSION_ID = "session_0";
+var STATE_STORE_LOCK_TTL_MS = 5e3;
+var schemaVersionSchema = z3.union([z3.literal(1), z3.literal(2)]);
+var piMessageAuthoritySchema = z3.union([
+  z3.literal("instruction"),
+  z3.literal("context")
+]);
+var piMessageProvenanceSchema = z3.object({
+  authority: piMessageAuthoritySchema,
+  actor: actorSchema.optional()
+}).strict();
+var unattributedContextProvenance = {
+  authority: "context"
+};
+function instructionProvenance(actor) {
+  return actor ? { authority: "instruction", actor } : { authority: "instruction" };
+}
+function isDefaultContextProvenance(provenance) {
+  return provenance.authority === "context" && !provenance.actor;
+}
+function legacyActorProvenance(actor) {
+  if (actor.teamId && actor.slackUserId && actor.platform) {
+    return instructionProvenance({
+      platform: "slack",
+      teamId: actor.teamId,
+      userId: actor.slackUserId,
+      ...actor.slackUserName ? { userName: actor.slackUserName } : {},
+      ...actor.fullName ? { fullName: actor.fullName } : {},
+      ...actor.email ? { email: actor.email } : {}
+    });
+  }
+  return unattributedContextProvenance;
+}
+var piMessageEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("pi_message"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  message: piMessageSchema,
+  provenance: piMessageProvenanceSchema.optional(),
+  // Legacy v1 latest-wins actor, decoded into provenance on read.
+  actor: storedSlackActorSchema.optional()
+});
+var projectionResetEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("projection_reset"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  messages: z3.array(piMessageSchema),
+  provenance: z3.array(piMessageProvenanceSchema).optional(),
+  // Legacy v1 latest-wins actor; v1 resets carry no per-message provenance.
+  actor: storedSlackActorSchema.optional()
+});
+var actorRecordedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("actor_recorded"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  actor: storedSlackActorSchema
+});
+var mcpProviderConnectedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("mcp_provider_connected"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  provider: z3.string().min(1)
+});
+var authorizationKindSchema = z3.union([
+  z3.literal("plugin"),
+  z3.literal("mcp")
+]);
+var authorizationRequestedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("authorization_requested"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z3.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z3.string().min(1),
+  actorId: z3.string().min(1),
+  authorizationId: z3.string().min(1),
+  delivery: z3.union([
+    z3.literal("private_link_sent"),
+    z3.literal("private_link_reused")
+  ])
+});
+var authorizationCompletedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("authorization_completed"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z3.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z3.string().min(1),
+  actorId: z3.string().min(1),
+  authorizationId: z3.string().min(1)
+});
+var transcriptRefSchema = z3.object({
+  type: z3.literal("advisor_session"),
+  parentConversationId: z3.string().min(1),
+  key: z3.string().min(1)
+});
+var toolExecutionStartedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("tool_execution_started"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z3.number().int().nonnegative(),
+  toolCallId: z3.string().min(1),
+  toolName: z3.string().min(1),
+  args: z3.unknown().optional()
+});
+var subagentStartedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("subagent_started"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z3.string().min(1),
+  subagentKind: z3.string().min(1),
+  parentToolCallId: z3.string().min(1).optional(),
+  parentConversationId: z3.string().min(1),
+  parentSessionId: z3.string().min(1).optional(),
+  transcriptRef: transcriptRefSchema,
+  historyMode: z3.literal("shared"),
+  modelId: z3.string().min(1).optional(),
+  reasoningLevel: z3.string().min(1).optional(),
+  createdAtMs: z3.number().int().nonnegative()
+});
+var subagentEndedEntrySchema = z3.object({
+  schemaVersion: schemaVersionSchema,
+  type: z3.literal("subagent_ended"),
+  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z3.string().min(1),
+  outcome: z3.union([
+    z3.literal("success"),
+    z3.literal("error"),
+    z3.literal("aborted")
+  ]),
+  errorCode: z3.string().min(1).optional(),
+  transcriptEndMessageIndex: z3.number().int().nonnegative().optional(),
+  transcriptStartMessageIndex: z3.number().int().nonnegative().optional(),
+  createdAtMs: z3.number().int().nonnegative()
+});
+var sessionLogEntrySchema = z3.discriminatedUnion("type", [
+  piMessageEntrySchema,
+  projectionResetEntrySchema,
+  actorRecordedEntrySchema,
+  mcpProviderConnectedEntrySchema,
+  authorizationRequestedEntrySchema,
+  authorizationCompletedEntrySchema,
+  toolExecutionStartedEntrySchema,
+  subagentStartedEntrySchema,
+  subagentEndedEntrySchema
+]);
+function key(scope) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [
+    ...prefix ? [prefix] : [],
+    AGENT_SESSION_LOG_PREFIX,
+    scope.conversationId
+  ].join(":");
+}
+function rawKey(scope) {
+  return [AGENT_SESSION_LOG_PREFIX, scope.conversationId].join(":");
+}
+function storedRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function migrateStoredEntry(value) {
+  const record = storedRecord(value);
+  if (!record) {
+    return value;
+  }
+  const migrated = { ...record };
+  if ("requester" in migrated && !("actor" in migrated)) {
+    migrated.actor = migrated.requester;
+  }
+  delete migrated.requester;
+  if (migrated.type === "requester_recorded") {
+    migrated.type = "actor_recorded";
+  }
+  if ("requesterId" in migrated && !("actorId" in migrated)) {
+    migrated.actorId = migrated.requesterId;
+  }
+  delete migrated.requesterId;
+  return migrated;
+}
+function piEntry(message, sessionId, provenance) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "pi_message",
+    sessionId,
+    message,
+    // Ambient context is the decode default, so only attributed/instruction
+    // provenance needs to be persisted on the entry.
+    ...provenance && !isDefaultContextProvenance(provenance) ? { provenance } : {}
+  };
+}
+function decode(value) {
+  if (typeof value === "string") {
+    return decode(JSON.parse(value));
+  }
+  const parsed = sessionLogEntrySchema.safeParse(migrateStoredEntry(value));
+  if (parsed.success) {
+    return parsed.data;
+  }
+  return piEntry(piMessageSchema.parse(value), INITIAL_SESSION_ID);
+}
+function actorIdentityKey(actor) {
+  if (actor.platform === "system") {
+    return `system ${actor.name}`;
+  }
+  return actor.platform === "slack" ? `slack\0${actor.teamId}\0${actor.userId}` : `${actor.platform}\0${actor.userId}`;
+}
+function instructionActors(provenance) {
+  const seen = /* @__PURE__ */ new Set();
+  const actors = [];
+  for (const entry of provenance) {
+    if (entry.authority !== "instruction" || !entry.actor) {
+      continue;
+    }
+    const identity = actorIdentityKey(entry.actor);
+    if (seen.has(identity)) {
+      continue;
+    }
+    seen.add(identity);
+    actors.push(entry.actor);
+  }
+  return actors;
+}
+function redisStore(redisStateAdapter) {
+  const client = redisStateAdapter.getClient();
+  return {
+    async append({ entries, scope, ttlMs }) {
+      const listKey = key(scope);
+      if (entries.length > 0) {
+        await client.rPush(
+          listKey,
+          entries.map((entry) => JSON.stringify(entry))
+        );
+      }
+      await client.pExpire(listKey, Math.max(1, ttlMs));
+    },
+    async read(scope) {
+      const values = await client.lRange(key(scope), 0, -1);
+      return values.map(decode);
+    }
+  };
+}
+function stateStore() {
+  const stateAdapter = getStateAdapter();
+  return {
+    async append({ entries, scope, ttlMs }) {
+      const listKey = rawKey(scope);
+      const lock = await stateAdapter.acquireLock(
+        `${listKey}:commit`,
+        STATE_STORE_LOCK_TTL_MS
+      );
+      if (!lock) {
+        throw new Error("Could not acquire session log commit lock");
+      }
+      try {
+        const existingValue = await stateAdapter.get(listKey);
+        const existingEntries = Array.isArray(existingValue) ? existingValue.map(decode) : (await stateAdapter.getList(listKey)).map(decode);
+        await stateAdapter.set(
+          listKey,
+          [...existingEntries, ...entries],
+          Math.max(1, ttlMs)
+        );
+      } finally {
+        await stateAdapter.releaseLock(lock);
+      }
+    },
+    async read(scope) {
+      const listKey = rawKey(scope);
+      const value = await stateAdapter.get(listKey);
+      if (Array.isArray(value)) {
+        return value.map(decode);
+      }
+      const values = await stateAdapter.getList(listKey);
+      return values.map(decode);
+    }
+  };
+}
+async function defaultStore() {
+  const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
+  if (redisStateAdapter) {
+    return redisStore(redisStateAdapter);
+  }
+  await stateAdapter.connect();
+  return stateStore();
+}
+async function loadEntries(args) {
+  const store = args.store ?? await defaultStore();
+  return (await store.read(args)).map(decode);
+}
+async function readSessionLogEntries(args) {
+  return loadEntries(args);
+}
+function instructionProvenanceFor(actor) {
+  return instructionProvenance(actor);
+}
+var contextProvenance = unattributedContextProvenance;
+
+// src/chat/conversations/history.ts
+var piMessageStepEntrySchema = z4.object({
+  type: z4.literal("pi_message"),
+  schemaVersion: z4.number().int().optional(),
+  message: piMessageSchema,
+  provenance: piMessageProvenanceSchema.optional()
+});
+var contextEpochStartedEntrySchema = z4.object({
+  type: z4.literal("context_epoch_started"),
+  reason: z4.union([z4.literal("compaction"), z4.literal("rollback")])
+});
+var mcpProviderConnectedEntrySchema2 = z4.object({
+  type: z4.literal("mcp_provider_connected"),
+  provider: z4.string().min(1)
+});
+var authorizationKindSchema2 = z4.union([
+  z4.literal("plugin"),
+  z4.literal("mcp")
+]);
+var authorizationRequestedEntrySchema2 = z4.object({
+  type: z4.literal("authorization_requested"),
+  kind: authorizationKindSchema2,
+  provider: z4.string().min(1),
+  actorId: z4.string().min(1),
+  authorizationId: z4.string().min(1),
+  delivery: z4.union([
+    z4.literal("private_link_sent"),
+    z4.literal("private_link_reused")
+  ])
+});
+var authorizationCompletedEntrySchema2 = z4.object({
+  type: z4.literal("authorization_completed"),
+  kind: authorizationKindSchema2,
+  provider: z4.string().min(1),
+  actorId: z4.string().min(1),
+  authorizationId: z4.string().min(1)
+});
+var toolExecutionStartedEntrySchema2 = z4.object({
+  type: z4.literal("tool_execution_started"),
+  toolCallId: z4.string().min(1),
+  toolName: z4.string().min(1),
+  args: z4.unknown().optional()
+});
+var visibleContextCompactedEntrySchema = z4.object({
+  type: z4.literal("visible_context_compacted"),
+  compactions: z4.array(
+    z4.object({
+      coveredMessageIds: z4.array(z4.string()),
+      createdAtMs: z4.number(),
+      id: z4.string().min(1),
+      summary: z4.string()
+    })
+  )
+});
+var subagentStartedEntrySchema2 = z4.object({
+  type: z4.literal("subagent_started"),
+  subagentInvocationId: z4.string().min(1),
+  subagentKind: z4.string().min(1),
+  modelId: z4.string().min(1).optional(),
+  parentToolCallId: z4.string().min(1).optional(),
+  reasoningLevel: z4.string().min(1).optional(),
+  childConversationId: z4.string().min(1),
+  historyMode: z4.literal("shared")
+});
+var subagentEndedEntrySchema2 = z4.object({
+  type: z4.literal("subagent_ended"),
+  subagentInvocationId: z4.string().min(1),
+  outcome: z4.union([
+    z4.literal("success"),
+    z4.literal("error"),
+    z4.literal("aborted")
+  ]),
+  errorCode: z4.string().min(1).optional()
+});
+var agentStepEntrySchema = z4.discriminatedUnion("type", [
+  piMessageStepEntrySchema,
+  contextEpochStartedEntrySchema,
+  mcpProviderConnectedEntrySchema2,
+  authorizationRequestedEntrySchema2,
+  authorizationCompletedEntrySchema2,
+  toolExecutionStartedEntrySchema2,
+  visibleContextCompactedEntrySchema,
+  subagentStartedEntrySchema2,
+  subagentEndedEntrySchema2
+]);
+
+// src/chat/conversations/sql/conversation-row.ts
+import { sql as sql5 } from "drizzle-orm";
+async function ensureConversationRow(executor, conversationId, atMs) {
+  const at = new Date(atMs);
+  await executor.db().insert(juniorConversations).values({
+    conversationId,
+    createdAt: at,
+    lastActivityAt: at,
+    updatedAt: at,
+    executionStatus: "idle"
+  }).onConflictDoUpdate({
+    target: juniorConversations.conversationId,
+    set: {
+      lastActivityAt: sql5`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+      updatedAt: sql5`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+      transcriptPurgedAt: null
+    }
+  });
+}
+
+// src/chat/conversations/sql/history.ts
+function messageRole(entry) {
+  if (entry.type !== "pi_message") {
+    return null;
+  }
+  const role = entry.message.role;
+  return typeof role === "string" ? role : null;
+}
+function insertFromStep(conversationId, seq, contextEpoch, step) {
+  const { type, ...payload } = agentStepEntrySchema.parse(step.entry);
+  return {
+    conversationId,
+    seq,
+    contextEpoch,
+    type,
+    role: messageRole(step.entry),
+    payload,
+    createdAt: new Date(step.createdAtMs)
+  };
+}
+function stepFromRow(row) {
+  const entry = agentStepEntrySchema.parse({ type: row.type, ...row.payload });
+  return {
+    seq: row.seq,
+    contextEpoch: row.contextEpoch,
+    createdAtMs: row.createdAt.getTime(),
+    entry
+  };
+}
+function piMessageStep(step) {
+  return {
+    entry: {
+      type: "pi_message",
+      message: step.message,
+      ...step.provenance ? { provenance: step.provenance } : {}
+    },
+    createdAtMs: step.createdAtMs
+  };
+}
+var SqlAgentStepStore = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async append(conversationId, steps) {
+    if (steps.length === 0) {
+      return;
+    }
+    const newestCreatedAtMs = Math.max(
+      ...steps.map((step) => step.createdAtMs)
+    );
+    await this.executor.transaction(async () => {
+      await ensureConversationRow(
+        this.executor,
+        conversationId,
+        newestCreatedAtMs
+      );
+      const cursor = await this.readCursor(conversationId);
+      const contextEpoch = cursor.maxEpoch ?? 0;
+      let seq = cursor.nextSeq;
+      const rows = steps.map(
+        (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
+      );
+      await this.executor.db().insert(juniorAgentSteps).values(rows);
+    });
+  }
+  async startEpoch(conversationId, opts) {
+    await this.executor.transaction(async () => {
+      await ensureConversationRow(this.executor, conversationId, Date.now());
+      const cursor = await this.readCursor(conversationId);
+      const contextEpoch = (cursor.maxEpoch ?? -1) + 1;
+      let seq = cursor.nextSeq;
+      const marker = {
+        entry: { type: "context_epoch_started", reason: opts.reason },
+        createdAtMs: Date.now()
+      };
+      const rows = [marker, ...opts.messages.map(piMessageStep)].map(
+        (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
+      );
+      await this.executor.db().insert(juniorAgentSteps).values(rows);
+    });
+  }
+  async loadCurrentEpoch(conversationId) {
+    const cursor = await this.readCursor(conversationId);
+    if (cursor.maxEpoch === null) {
+      return [];
+    }
+    const rows = await this.executor.db().select().from(juniorAgentSteps).where(
+      and3(
+        eq3(juniorAgentSteps.conversationId, conversationId),
+        eq3(juniorAgentSteps.contextEpoch, cursor.maxEpoch)
+      )
+    ).orderBy(asc2(juniorAgentSteps.seq));
+    return rows.map(stepFromRow);
+  }
+  async loadHistory(conversationId) {
+    const rows = await this.executor.db().select().from(juniorAgentSteps).where(eq3(juniorAgentSteps.conversationId, conversationId)).orderBy(asc2(juniorAgentSteps.seq));
+    return rows.map(stepFromRow);
+  }
+  /** Read the next `seq` and current highest epoch for one conversation. */
+  async readCursor(conversationId) {
+    const rows = await this.executor.db().select({
+      maxSeq: sql6`max(${juniorAgentSteps.seq})`,
+      maxEpoch: sql6`max(${juniorAgentSteps.contextEpoch})`
+    }).from(juniorAgentSteps).where(eq3(juniorAgentSteps.conversationId, conversationId));
+    const maxSeq = rows[0]?.maxSeq;
+    const maxEpoch = rows[0]?.maxEpoch;
+    return {
+      maxEpoch: maxEpoch === null || maxEpoch === void 0 ? null : Number(maxEpoch),
+      nextSeq: maxSeq === null || maxSeq === void 0 ? 0 : Number(maxSeq) + 1
+    };
+  }
+};
+function createSqlAgentStepStore(executor) {
+  return new SqlAgentStepStore(executor);
+}
+
+// src/chat/conversations/sql/messages.ts
+import { and as and4, asc as asc3, eq as eq4, isNull as isNull2, sql as sql7 } from "drizzle-orm";
+function messageFromRow(row) {
+  return {
+    conversationId: row.conversationId,
+    messageId: row.messageId,
+    role: row.role,
+    text: row.text,
+    createdAtMs: row.createdAt.getTime(),
+    ...row.authorIdentityId ? { authorIdentityId: row.authorIdentityId } : {},
+    ...row.meta ? { meta: row.meta } : {},
+    ...row.repliedAt ? { repliedAtMs: row.repliedAt.getTime() } : {}
+  };
+}
+var SqlConversationMessageStore = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async record(conversationId, messages) {
+    if (messages.length === 0) {
+      return;
+    }
+    const newestCreatedAtMs = Math.max(
+      ...messages.map((message) => message.createdAtMs)
+    );
+    await this.executor.transaction(async () => {
+      await ensureConversationRow(
+        this.executor,
+        conversationId,
+        newestCreatedAtMs
+      );
+      await this.executor.db().insert(juniorConversationMessages).values(
+        messages.map((message) => ({
+          conversationId,
+          messageId: message.messageId,
+          role: message.role,
+          authorIdentityId: message.authorIdentityId ?? null,
+          text: message.text,
+          meta: message.meta ?? null,
+          repliedAt: null,
+          createdAt: new Date(message.createdAtMs)
+        }))
+      ).onConflictDoUpdate({
+        target: [
+          juniorConversationMessages.conversationId,
+          juniorConversationMessages.messageId
+        ],
+        set: {
+          meta: sql7`nullif(coalesce(${juniorConversationMessages.meta}, '{}'::jsonb) || coalesce(excluded.meta, '{}'::jsonb), '{}'::jsonb)`
+        }
+      });
+    });
+  }
+  async markReplied(conversationId, messageId, repliedAtMs) {
+    await this.executor.db().update(juniorConversationMessages).set({
+      repliedAt: sql7`coalesce(${juniorConversationMessages.repliedAt}, ${new Date(repliedAtMs)})`
+    }).where(
+      and4(
+        eq4(juniorConversationMessages.conversationId, conversationId),
+        eq4(juniorConversationMessages.messageId, messageId),
+        isNull2(juniorConversationMessages.repliedAt)
+      )
+    );
+  }
+  async list(conversationId, opts = {}) {
+    const query = this.executor.db().select().from(juniorConversationMessages).where(eq4(juniorConversationMessages.conversationId, conversationId)).orderBy(
+      asc3(juniorConversationMessages.createdAt),
+      asc3(juniorConversationMessages.messageId)
+    );
+    const rows = opts.limit === void 0 ? await query : await query.limit(Math.max(0, opts.limit));
+    return rows.map(messageFromRow);
+  }
+};
+function createSqlConversationMessageStore(executor) {
+  return new SqlConversationMessageStore(executor);
+}
+
+// src/db/neon.ts
 import { AsyncLocalStorage } from "async_hooks";
 import {
   Pool
@@ -1275,7 +2053,7 @@ function createNeonJuniorSqlExecutor(args) {
   );
 }
 
-// src/chat/sql/postgres.ts
+// src/db/postgres.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import pg from "pg";
 import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
@@ -1377,7 +2155,7 @@ function createPostgresJuniorSqlExecutor(args) {
   );
 }
 
-// src/chat/sql/executor.ts
+// src/db/executor.ts
 function createJuniorSqlExecutor(args) {
   if (args.driver === "postgres") {
     return createPostgresJuniorSqlExecutor(args);
@@ -1394,22 +2172,24 @@ function createDb(args) {
   });
 }
 function getSqlExecutor() {
-  const { sql: sql5 } = getChatConfig();
-  if (current?.databaseUrl !== sql5.databaseUrl || current.driver !== sql5.driver) {
+  const { sql: sql8 } = getChatConfig();
+  if (current?.databaseUrl !== sql8.databaseUrl || current.driver !== sql8.driver) {
     if (current) {
       const previous = current;
       current = void 0;
       void previous.db.close().catch(() => void 0);
     }
     const db = createDb({
-      databaseUrl: sql5.databaseUrl,
-      driver: sql5.driver
+      databaseUrl: sql8.databaseUrl,
+      driver: sql8.driver
     });
     current = {
-      databaseUrl: sql5.databaseUrl,
-      driver: sql5.driver,
+      databaseUrl: sql8.databaseUrl,
+      driver: sql8.driver,
       db,
-      store: createSqlStore(db)
+      store: createSqlStore(db),
+      stepStore: createSqlAgentStepStore(db),
+      messageStore: createSqlConversationMessageStore(db)
     };
   }
   return current.db;
@@ -1421,6 +2201,14 @@ function getConversationStore() {
   getSqlExecutor();
   return current.store;
 }
+function getAgentStepStore() {
+  getSqlExecutor();
+  return current.stepStore;
+}
+function getConversationMessageStore() {
+  getSqlExecutor();
+  return current.messageStore;
+}
 async function closeDb() {
   const previous = current;
   current = void 0;
@@ -1432,9 +2220,23 @@ export {
   juniorUsers,
   juniorIdentities,
   juniorConversations,
+  juniorAgentSteps,
+  juniorConversationMessages,
+  migrateSchema,
   createSqlStore,
+  legacyActorProvenance,
+  instructionActors,
+  readSessionLogEntries,
+  instructionProvenanceFor,
+  contextProvenance,
+  agentStepEntrySchema,
+  createSqlAgentStepStore,
+  createSqlConversationMessageStore,
   createJuniorSqlExecutor,
+  getSqlExecutor,
   getDb,
   getConversationStore,
+  getAgentStepStore,
+  getConversationMessageStore,
   closeDb
 };