@sentry/junior 0.237.0 → 0.238.0

package/dist/viewer-DsyM9kb9.js

@@ -0,0 +1,1636 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { F as normalizeIdentityEmail } from "./logging-BNi_jyHb.js";
+import { i as getChatConfig } from "./config-DRw358bB.js";
+import { d as parseSlackTeamId, o as parseActorUserId, u as parseSlackChannelReferenceId } from "./actor-BTtLaeWy.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { D as juniorConversations, E as conversationReadColumns, O as juniorIdentities, S as juniorConversationAnnotations, b as juniorConversationEvents, g as juniorConversationBindings, h as juniorConversationParticipants, k as juniorUsers, t as createJuniorSqlExecutor, v as CONVERSATION_METRICS, y as juniorConversationMetrics } from "./executor-DgPk8Lsx.js";
+import { c as newConversationEventSchema, l as encodeHistoryPayload, m as usageSchema, o as decodeStoredConversationEvent, r as conversationEventDataSchema, s as historyReplacementSchema } from "./history-BLTUgFYO.js";
+import { randomUUID } from "node:crypto";
+import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, lte, ne, or, sql } from "drizzle-orm";
+import { destinationSchema, identitySchema, locationSchema, sourceSchema, userSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/destination.ts
+/** Build Junior's canonical destination from Slack workspace and channel ids. */
+function createSlackDestination(input) {
+	const channelId = parseSlackChannelReferenceId(input.channelId);
+	const teamId = parseSlackTeamId(input.teamId);
+	if (!channelId || !teamId) return;
+	return {
+		platform: "slack",
+		teamId,
+		channelId
+	};
+}
+/** Parse and validate a serialized destination that crossed a runtime boundary. */
+function parseDestination(value) {
+	const parsed = destinationSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+/** Require a Slack destination at a Slack-only runtime boundary. */
+function requireSlackDestination(destination, action) {
+	if (destination?.platform === "slack") return destination;
+	throw new Error(`${action} requires a Slack destination`);
+}
+/** Compare two destinations without relying on object identity. */
+function sameDestination(left, right) {
+	if (left.platform !== right.platform) return false;
+	if (left.platform === "local" && right.platform === "local") return left.conversationId === right.conversationId;
+	if (left.platform === "slack" && right.platform === "slack") return left.teamId === right.teamId && left.channelId === right.channelId;
+	return false;
+}
+//#endregion
+//#region src/chat/identities/sql.ts
+function dateFromMs$1(ms) {
+	return new Date(ms);
+}
+function tenantId$1(value) {
+	return value ?? "";
+}
+async function upsertUser(executor, args) {
+	const id = (await executor.db().insert(juniorUsers).values({
+		id: randomUUID(),
+		primaryEmail: args.email,
+		primaryEmailNormalized: args.emailNormalized,
+		displayName: args.displayName ?? null,
+		createdAt: dateFromMs$1(args.nowMs),
+		updatedAt: dateFromMs$1(args.nowMs)
+	}).onConflictDoUpdate({
+		target: juniorUsers.primaryEmailNormalized,
+		set: {
+			displayName: sql`coalesce(${juniorUsers.displayName}, excluded.display_name)`,
+			updatedAt: sql`excluded.updated_at`
+		}
+	}).returning({ id: juniorUsers.id }))[0]?.id;
+	if (!id) throw new Error("User identity upsert returned no row");
+	return id;
+}
+async function existingIdentity(executor, identity) {
+	return (await executor.db().select().from(juniorIdentities).where(and(eq(juniorIdentities.provider, identity.provider), eq(juniorIdentities.providerTenantId, tenantId$1(identity.providerTenantId)), eq(juniorIdentities.providerSubjectId, identity.providerSubjectId))))[0];
+}
+async function upsertIdentityRecord(executor, identity, linkedUserId, nowMs) {
+	const emailNormalized = normalizeIdentityEmail(identity.email);
+	const email = emailNormalized ? identity.email?.trim() || emailNormalized : void 0;
+	const existing = await existingIdentity(executor, identity);
+	const userEmailNormalized = existing?.emailVerified && existing.emailNormalized ? existing.emailNormalized : identity.emailVerified ? emailNormalized : void 0;
+	const userEmail = existing?.emailVerified && existing.email ? existing.email : email ?? userEmailNormalized;
+	const verifiedUserId = identity.kind === "user" && userEmailNormalized ? await upsertUser(executor, {
+		email: userEmail ?? userEmailNormalized,
+		emailNormalized: userEmailNormalized,
+		nowMs,
+		...existing?.displayName || identity.displayName ? { displayName: existing?.displayName ?? identity.displayName } : void 0
+	}) : void 0;
+	if (existing?.userId && verifiedUserId && existing.userId !== verifiedUserId) throw new Error("Identity verified email conflicts with linked user");
+	if (linkedUserId && verifiedUserId && linkedUserId !== verifiedUserId) throw new Error("Linked identity conflicts with verified email user");
+	if (existing?.userId && linkedUserId && existing.userId !== linkedUserId) throw new Error("Identity conflicts with linked user");
+	const userId = existing?.userId ?? linkedUserId ?? verifiedUserId;
+	const row = (await executor.db().insert(juniorIdentities).values({
+		id: randomUUID(),
+		userId: userId ?? null,
+		kind: identity.kind,
+		provider: identity.provider,
+		providerTenantId: tenantId$1(identity.providerTenantId),
+		providerSubjectId: identity.providerSubjectId,
+		displayName: identity.displayName ?? null,
+		handle: identity.handle ?? null,
+		email: email ?? null,
+		emailNormalized: emailNormalized ?? null,
+		emailVerified: Boolean(identity.emailVerified && emailNormalized),
+		avatarUrl: null,
+		metadata: identity.metadata ?? null,
+		createdAt: dateFromMs$1(nowMs),
+		updatedAt: dateFromMs$1(nowMs)
+	}).onConflictDoUpdate({
+		target: [
+			juniorIdentities.provider,
+			juniorIdentities.providerTenantId,
+			juniorIdentities.providerSubjectId
+		],
+		set: {
+			kind: sql`excluded.kind`,
+			userId: sql`coalesce(${juniorIdentities.userId}, excluded.user_id)`,
+			displayName: linkedUserId ? sql`coalesce(excluded.display_name, ${juniorIdentities.displayName})` : sql`coalesce(${juniorIdentities.displayName}, excluded.display_name)`,
+			handle: linkedUserId ? sql`coalesce(excluded.handle, ${juniorIdentities.handle})` : sql`coalesce(${juniorIdentities.handle}, excluded.handle)`,
+			email: sql`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.email}, excluded.email) when excluded.email_verified then excluded.email else coalesce(${juniorIdentities.email}, excluded.email) end`,
+			emailNormalized: sql`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) when excluded.email_verified then excluded.email_normalized else coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) end`,
+			emailVerified: sql`${juniorIdentities.emailVerified} OR excluded.email_verified`,
+			avatarUrl: sql`coalesce(${juniorIdentities.avatarUrl}, excluded.avatar_url)`,
+			metadata: sql`coalesce(${juniorIdentities.metadata}, excluded.metadata_json)`,
+			updatedAt: sql`excluded.updated_at`
+		},
+		...linkedUserId ? { setWhere: sql`${juniorIdentities.userId} IS NULL OR ${juniorIdentities.userId} = excluded.user_id` } : void 0
+	}).returning({
+		id: juniorIdentities.id,
+		userId: juniorIdentities.userId
+	}))[0];
+	if (!row) {
+		if (linkedUserId) throw new Error("Identity conflicts with linked user");
+		throw new Error("Identity upsert returned no row");
+	}
+	return {
+		id: row.id,
+		...row.userId ? { userId: row.userId } : void 0
+	};
+}
+/** Read the saved timezone for one user. */
+async function readUserTimezone(db, userId) {
+	return (await db.select({ timezone: juniorUsers.timezone }).from(juniorUsers).where(eq(juniorUsers.id, userId)).limit(1))[0]?.timezone ?? void 0;
+}
+/** Save the IANA timezone for one user. */
+async function saveUserTimezone(db, userId, timezone, nowMs) {
+	await db.update(juniorUsers).set({
+		timezone,
+		updatedAt: dateFromMs$1(nowMs)
+	}).where(and(eq(juniorUsers.id, userId), sql`${juniorUsers.timezone} is distinct from ${timezone}`));
+}
+/** Persist one provider identity observation and link verified emails to users. */
+async function upsertIdentity(executor, identity, nowMs = Date.now()) {
+	return await upsertIdentityRecord(executor, identity, void 0, nowMs);
+}
+/**
+* Persist one provider identity after a trusted account-linking flow.
+* Callers must use provider-verified account data, such as GitHub's authenticated
+* user response, never identity claims inferred from content such as Git commits.
+*/
+async function upsertLinkedIdentity(executor, userId, identity, nowMs = Date.now()) {
+	return await upsertIdentityRecord(executor, identity, userId, nowMs);
+}
+/** Remove one exact provider identity owned by a workspace Slack user. */
+async function deleteProviderIdentityForSlackUser(executor, slackTeamId, slackUserId, provider, providerSubjectId) {
+	const userId = (await executor.db().select({ userId: juniorIdentities.userId }).from(juniorIdentities).where(and(eq(juniorIdentities.kind, "user"), eq(juniorIdentities.provider, "slack"), eq(juniorIdentities.providerTenantId, slackTeamId), eq(juniorIdentities.providerSubjectId, slackUserId))).limit(1))[0]?.userId;
+	if (!userId) return;
+	await executor.db().delete(juniorIdentities).where(and(eq(juniorIdentities.userId, userId), eq(juniorIdentities.provider, provider), eq(juniorIdentities.providerTenantId, ""), eq(juniorIdentities.providerSubjectId, providerSubjectId)));
+}
+//#endregion
+//#region src/chat/conversations/sql/participants.ts
+/** Resolve the root conversation id that owns personal-feed membership. */
+async function resolveRootConversationId(executor, conversationId) {
+	const [row] = await executor.db().select({ rootConversationId: juniorConversations.rootConversationId }).from(juniorConversations).where(eq(juniorConversations.conversationId, conversationId)).limit(1);
+	return row?.rootConversationId ?? conversationId;
+}
+/**
+* Upsert one linked user as a participant on a root conversation.
+* No-ops when the identity is missing, unlinked, or not a user.
+*/
+async function recordConversationParticipant(executor, args) {
+	const [identity] = await executor.db().select({
+		kind: juniorIdentities.kind,
+		userId: juniorIdentities.userId
+	}).from(juniorIdentities).where(eq(juniorIdentities.id, args.actorIdentityId)).limit(1);
+	if (!identity?.userId || identity.kind !== "user") return;
+	const rootConversationId = await resolveRootConversationId(executor, args.conversationId);
+	const at = new Date(args.atMs);
+	await executor.db().insert(juniorConversationParticipants).values({
+		userId: identity.userId,
+		rootConversationId,
+		lastMessageAt: at
+	}).onConflictDoUpdate({
+		target: [juniorConversationParticipants.userId, juniorConversationParticipants.rootConversationId],
+		set: {
+			lastMessageAt: sql`greatest(${juniorConversationParticipants.lastMessageAt}, excluded.last_message_at)`,
+			...args.restoreArchive ? { archivedAt: null } : void 0
+		}
+	});
+}
+//#endregion
+//#region src/chat/usage.ts
+const agentTurnUsageSchema = usageSchema;
+const COMPONENT_USAGE_FIELDS = [
+	"inputTokens",
+	"outputTokens",
+	"cachedInputTokens",
+	"cacheCreationTokens"
+];
+const COST_COMPONENT_FIELDS = [
+	"input",
+	"output",
+	"cacheRead",
+	"cacheWrite"
+];
+/** Return whether any token counter is present on a usage record. */
+function hasAgentTurnUsage(usage) {
+	return Boolean(usage && (Object.entries(usage).some(([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)) || Object.values(usage.cost ?? {}).some((value) => typeof value === "number" && Number.isFinite(value))));
+}
+function getFiniteCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getFiniteCost(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function addCost(left, right) {
+	return Math.round(((left ?? 0) + right) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+function getComponentTotal(usage) {
+	let total;
+	for (const field of COMPONENT_USAGE_FIELDS) {
+		const value = getFiniteCount(usage[field]);
+		if (value === void 0) continue;
+		total = (total ?? 0) + value;
+	}
+	return total;
+}
+/** Estimated total USD cost from one usage record, when any cost field is present. */
+function agentTurnCostUsd(usage) {
+	if (!usage?.cost) return void 0;
+	const total = getFiniteCost(usage.cost.total);
+	if (total !== void 0) return total;
+	let componentTotal = 0;
+	let hasComponent = false;
+	for (const field of COST_COMPONENT_FIELDS) {
+		const value = getFiniteCost(usage.cost[field]);
+		if (value === void 0) continue;
+		hasComponent = true;
+		componentTotal = addCost(componentTotal, value);
+	}
+	return hasComponent ? componentTotal : void 0;
+}
+/** Total token count from one usage record, preferring component counters. */
+function agentTurnTotalTokens(usage) {
+	if (!usage) return void 0;
+	const componentTotal = getComponentTotal(usage);
+	if (componentTotal !== void 0) return componentTotal;
+	return getFiniteCount(usage.totalTokens);
+}
+/** Aggregate token usage across slices without double-counting provider totals. */
+function addAgentTurnUsage(...usages) {
+	const components = {};
+	let componentTotal;
+	let totalOnlyTokens;
+	let reasoningTokens;
+	const cost = {};
+	for (const usage of usages) {
+		if (!usage) continue;
+		const reasoning = getFiniteCount(usage.reasoningTokens);
+		if (reasoning !== void 0) reasoningTokens = (reasoningTokens ?? 0) + reasoning;
+		if (usage.cost) for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
+			const value = getFiniteCost(usage.cost[field]);
+			if (value === void 0) continue;
+			cost[field] = addCost(cost[field], value);
+		}
+		const usageComponentTotal = getComponentTotal(usage);
+		if (usageComponentTotal !== void 0) {
+			componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+			for (const field of COMPONENT_USAGE_FIELDS) {
+				const value = getFiniteCount(usage[field]);
+				if (value === void 0) continue;
+				components[field] = (components[field] ?? 0) + value;
+			}
+			continue;
+		}
+		const totalTokens = getFiniteCount(usage.totalTokens);
+		if (totalTokens !== void 0) totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+	}
+	if (totalOnlyTokens !== void 0) return {
+		totalTokens: totalOnlyTokens + (componentTotal ?? 0),
+		...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+		...Object.keys(cost).length > 0 ? { cost } : void 0
+	};
+	const result = {
+		...components,
+		...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+		...Object.keys(cost).length > 0 ? { cost } : void 0
+	};
+	return hasAgentTurnUsage(result) ? result : void 0;
+}
+//#endregion
+//#region src/chat/conversations/metrics.ts
+function finite(value) {
+	return value !== void 0 && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/** Convert one Run summary to metric rows. */
+function conversationMetricValues(args) {
+	const usage = args.usage;
+	return {
+		duration_ms: Math.max(0, args.durationMs),
+		total_tokens: agentTurnTotalTokens(usage),
+		input_tokens: finite(usage?.inputTokens),
+		output_tokens: finite(usage?.outputTokens),
+		cached_input_tokens: finite(usage?.cachedInputTokens),
+		cache_creation_tokens: finite(usage?.cacheCreationTokens),
+		reasoning_tokens: finite(usage?.reasoningTokens),
+		cost_usd: agentTurnCostUsd(usage)
+	};
+}
+/** Replace one Run's metric rows and refresh its Conversation totals. */
+async function replaceConversationMetrics(executor, args) {
+	const [current] = await executor.db().select({ updatedAt: juniorConversationMetrics.updatedAt }).from(juniorConversationMetrics).where(and(eq(juniorConversationMetrics.conversationId, args.conversationId), eq(juniorConversationMetrics.runId, args.runId))).limit(1);
+	if (current && current.updatedAt.getTime() > args.updatedAtMs) return;
+	await executor.db().delete(juniorConversationMetrics).where(and(eq(juniorConversationMetrics.conversationId, args.conversationId), eq(juniorConversationMetrics.runId, args.runId)));
+	const metricValues = conversationMetricValues({
+		durationMs: args.durationMs,
+		usage: args.usage
+	});
+	const values = CONVERSATION_METRICS.flatMap((metric) => {
+		const value = metricValues[metric];
+		return value === void 0 ? [] : [{
+			conversationId: args.conversationId,
+			runId: args.runId,
+			metric,
+			value,
+			occurredAt: new Date(args.occurredAtMs),
+			updatedAt: new Date(args.updatedAtMs)
+		}];
+	});
+	if (values.length > 0) await executor.db().insert(juniorConversationMetrics).values(values);
+	const metric = (name) => sql`(
+    select sum(${juniorConversationMetrics.value})
+    from ${juniorConversationMetrics}
+    where ${juniorConversationMetrics.conversationId} = ${args.conversationId}
+      and ${juniorConversationMetrics.metric} = ${name}
+  )`;
+	const totalTokens = metric("total_tokens");
+	const componentTokens = sql`
+    coalesce(${metric("input_tokens")}, 0)
+      + coalesce(${metric("output_tokens")}, 0)
+      + coalesce(${metric("cached_input_tokens")}, 0)
+      + coalesce(${metric("cache_creation_tokens")}, 0)
+  `;
+	const hasComponents = sql`
+    ${metric("input_tokens")} is not null
+      or ${metric("output_tokens")} is not null
+      or ${metric("cached_input_tokens")} is not null
+      or ${metric("cache_creation_tokens")} is not null
+  `;
+	const cost = sql`case when ${metric("cost_usd")} is null then null
+    else jsonb_build_object('total', ${metric("cost_usd")}) end`;
+	await executor.db().update(juniorConversations).set({
+		durationMs: sql`coalesce(${metric("duration_ms")}, 0)`,
+		usage: sql`case
+        when ${totalTokens} is not null
+          and (${hasComponents})
+          and ${totalTokens} <> ${componentTokens}
+        then jsonb_strip_nulls(jsonb_build_object(
+          'totalTokens', ${totalTokens},
+          'reasoningTokens', ${metric("reasoning_tokens")},
+          'cost', ${cost}
+        ))
+        else jsonb_strip_nulls(jsonb_build_object(
+          'totalTokens', ${totalTokens},
+          'inputTokens', ${metric("input_tokens")},
+          'outputTokens', ${metric("output_tokens")},
+          'cachedInputTokens', ${metric("cached_input_tokens")},
+          'cacheCreationTokens', ${metric("cache_creation_tokens")},
+          'reasoningTokens', ${metric("reasoning_tokens")},
+          'cost', ${cost}
+        ))
+      end`
+	}).where(eq(juniorConversations.conversationId, args.conversationId));
+}
+//#endregion
+//#region src/chat/source.ts
+/**
+* Normalize a Turn Source into legacy provider fields stored on a Conversation.
+* System Sources do not contain a Conversation Location.
+*/
+function normalizeSessionSource(value) {
+	if (!value) return;
+	if (value.kind === "local") return {
+		kind: "local",
+		visibility: value.visibility,
+		conversationId: value.conversationId
+	};
+	if (value.kind === "web") return {
+		kind: "web",
+		visibility: value.visibility,
+		conversationId: value.conversationId
+	};
+	if (value.kind === "event" || value.kind === "scheduled_automation" || value.kind === "event_automation" || value.kind === "plugin_dispatch" || value.kind === "agent_invocation") return;
+	const threadTs = value.threadTs?.trim();
+	return {
+		kind: "slack",
+		visibility: value.visibility,
+		teamId: value.teamId,
+		channelId: value.channelId,
+		...threadTs ? { threadTs } : void 0
+	};
+}
+/** Parse a serialized Source into legacy provider fields stored on a Conversation. */
+function parseSessionSource(value) {
+	const parsed = sourceSchema.safeParse(value);
+	return parsed.success ? normalizeSessionSource(parsed.data) : void 0;
+}
+//#endregion
+//#region src/chat/conversations/sql/bindings.ts
+/** Resolve the durable conversation bound to provider-owned coordinates. */
+async function getConversationIdByProviderConversation(executor, args) {
+	return (await executor.db().select({ conversationId: juniorConversationBindings.conversationId }).from(juniorConversationBindings).where(and(eq(juniorConversationBindings.provider, args.provider), eq(juniorConversationBindings.providerTenantId, args.providerTenantId), eq(juniorConversationBindings.providerDestinationId, args.providerDestinationId), eq(juniorConversationBindings.providerConversationId, args.providerConversationId))).limit(1))[0]?.conversationId;
+}
+/** Return the first provider conversation bound in one destination. */
+async function getFirstProviderConversationId(executor, args) {
+	return (await executor.db().select({ providerConversationId: juniorConversationBindings.providerConversationId }).from(juniorConversationBindings).where(and(eq(juniorConversationBindings.conversationId, args.conversationId), eq(juniorConversationBindings.provider, args.provider), eq(juniorConversationBindings.providerTenantId, args.providerTenantId), eq(juniorConversationBindings.providerDestinationId, args.providerDestinationId))).orderBy(asc(juniorConversationBindings.createdAt), asc(juniorConversationBindings.providerConversationId)).limit(1))[0]?.providerConversationId;
+}
+/** Bind provider coordinates to a durable conversation in the caller's SQL scope. */
+async function bindProviderConversation(executor, args) {
+	if (((await executor.db().insert(juniorConversationBindings).values({
+		...args,
+		createdAt: /* @__PURE__ */ new Date()
+	}).onConflictDoNothing().returning({ conversationId: juniorConversationBindings.conversationId }))[0]?.conversationId ?? await getConversationIdByProviderConversation(executor, args)) !== args.conversationId) throw new Error("Provider conversation is already bound to another conversation");
+}
+//#endregion
+//#region src/chat/conversations/sql/actor-identity.ts
+/** Build a durable identity observation from a stored conversation actor. */
+function identityFromActor(actor) {
+	if (actor?.slackUserId) return {
+		kind: "user",
+		provider: "slack",
+		providerTenantId: actor.teamId,
+		providerSubjectId: actor.slackUserId,
+		...actor.fullName ? { displayName: actor.fullName } : void 0,
+		...actor.slackUserName ? { handle: actor.slackUserName } : void 0,
+		...actor.email ? {
+			email: actor.email,
+			emailVerified: true
+		} : void 0,
+		metadata: { platform: "slack" }
+	};
+	const email = actor?.email?.trim().toLowerCase();
+	if (!email) return;
+	return {
+		kind: "user",
+		provider: "junior",
+		providerSubjectId: email,
+		email,
+		emailVerified: true,
+		...actor?.fullName ? { displayName: actor.fullName } : void 0,
+		metadata: { platform: "web" }
+	};
+}
+/** Build a system identity when a conversation has no user actor. */
+function systemIdentityFromSource(source) {
+	if (source === "scheduler") return {
+		kind: "system",
+		provider: "junior",
+		providerSubjectId: "scheduler",
+		displayName: "Junior Scheduler"
+	};
+	if (source === "local") return {
+		kind: "system",
+		provider: "junior",
+		providerSubjectId: "local-cli",
+		displayName: "Local CLI"
+	};
+	if (source === "event") return {
+		kind: "system",
+		provider: "junior",
+		providerSubjectId: "event",
+		displayName: "Event"
+	};
+}
+/** Prefer the user actor identity, else a source-derived system identity. */
+function actorIdentityForConversation(conversation) {
+	return identityFromActor(conversation.actor) ?? systemIdentityFromSource(conversation.source);
+}
+/**
+* Reconstruct a stored actor with the linked user name and identity-scoped
+* provider fields.
+*/
+function actorFromIdentityRow(identity, userDisplayName) {
+	if (!identity) return;
+	const fullName = userDisplayName?.trim() ? userDisplayName : identity.displayName;
+	const email = identity.emailNormalized ?? identity.email ?? void 0;
+	if (identity.provider === "slack") return {
+		...email ? { email } : void 0,
+		...fullName ? { fullName } : void 0,
+		platform: "slack",
+		slackUserId: identity.providerSubjectId,
+		...identity.handle ? { slackUserName: identity.handle } : void 0,
+		...identity.providerTenantId ? { teamId: identity.providerTenantId } : void 0
+	};
+	if (identity.provider === "junior" && email) return {
+		email,
+		...fullName ? { fullName } : void 0
+	};
+}
+/** Merge later actor observations without replacing a durable Slack subject. */
+function mergeActor(current, next) {
+	if (!current) return next;
+	if (!next) return current;
+	if (current.slackUserId && next.slackUserId && current.slackUserId !== next.slackUserId) return current;
+	return {
+		...current,
+		...current.email ?? next.email ? { email: current.email ?? next.email } : void 0,
+		...current.fullName ?? next.fullName ? { fullName: current.fullName ?? next.fullName } : void 0,
+		...current.platform ?? next.platform ? { platform: current.platform ?? next.platform } : void 0,
+		...current.slackUserId ?? next.slackUserId ? { slackUserId: current.slackUserId ?? next.slackUserId } : void 0,
+		...current.slackUserName ?? next.slackUserName ? { slackUserName: current.slackUserName ?? next.slackUserName } : void 0,
+		...current.teamId ?? next.teamId ? { teamId: current.teamId ?? next.teamId } : void 0
+	};
+}
+//#endregion
+//#region src/chat/conversations/sql/location.ts
+/** Build the complete Location for one Conversation SQL write. */
+function locationForWrite(args) {
+	const location = args.location ? locationSchema.parse(args.location) : void 0;
+	const destination = args.destination?.platform === "slack" ? args.destination : void 0;
+	const source = args.sessionSource?.kind === "slack" ? args.sessionSource : void 0;
+	if (location) {
+		if (destination && (location.id !== args.destinationId || location.teamId !== destination.teamId || location.channelId !== destination.channelId) || source && (location.teamId !== source.teamId || location.channelId !== source.channelId)) throw new Error("Conversation Location changed");
+		const threadTs = location.threadTs ?? destination?.threadTs ?? source?.threadTs;
+		return threadTs === location.threadTs ? location : {
+			...location,
+			threadTs
+		};
+	}
+	if (destination && source && (destination.teamId !== source.teamId || destination.channelId !== source.channelId)) throw new Error("Conversation Location does not match its session Source");
+	if (!destination || !args.destinationId) return;
+	const threadTs = destination.threadTs ?? source?.threadTs;
+	return locationSchema.parse({
+		id: args.destinationId,
+		provider: "slack",
+		teamId: destination.teamId,
+		channelId: destination.channelId,
+		...threadTs ? { threadTs } : void 0
+	});
+}
+/** Read one complete Location from SQL. */
+function locationFromRow(value, row, sessionSource) {
+	if (value !== void 0 && value !== null) {
+		const location = locationSchema.parse(value);
+		const slackSource = !location.threadTs && sessionSource?.kind === "slack" && sessionSource.teamId === location.teamId && sessionSource.channelId === location.channelId ? sessionSource : void 0;
+		return slackSource?.threadTs ? {
+			...location,
+			threadTs: slackSource.threadTs
+		} : location;
+	}
+	if (!row || row.provider === "local") return;
+	if (row.provider !== "slack") throw new Error("Conversation Location provider is not supported");
+	const slackSource = sessionSource?.kind === "slack" && sessionSource.teamId === row.providerTenantId && sessionSource.channelId === row.providerDestinationId ? sessionSource : void 0;
+	return locationSchema.parse({
+		id: row.id,
+		provider: "slack",
+		teamId: row.providerTenantId,
+		channelId: row.providerDestinationId,
+		...slackSource?.threadTs ? { threadTs: slackSource.threadTs } : void 0
+	});
+}
+/** Read confirmed visibility from one linked Location row. */
+function visibilityFromLocationRow(row) {
+	if (!row) return;
+	if (row.visibility === "public" || row.visibility === "private") return row.visibility;
+}
+//#endregion
+//#region src/chat/conversations/sql/store.ts
+const CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
+/** Serialize one conversation's durable mutations inside a SQL transaction. */
+async function withConversationMutationLock(executor, conversationId, callback) {
+	return await executor.withLock(`${CONVERSATION_MUTATION_LOCK_PREFIX}:${conversationId}`, async () => await executor.transaction(callback));
+}
+function now() {
+	return Date.now();
+}
+function dateFromMs(ms) {
+	return new Date(ms);
+}
+function msFromDate(value) {
+	if (value === null || value === void 0) return;
+	return (value instanceof Date ? value : new Date(value)).getTime();
+}
+function requiredMsFromDate(value) {
+	const ms = msFromDate(value);
+	if (typeof ms !== "number" || Number.isNaN(ms)) throw new Error("Conversation record timestamp is invalid");
+	return ms;
+}
+function tenantId(value) {
+	return value ?? "";
+}
+function sourceFromValue(value) {
+	if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "event" || value === "scheduler" || value === "slack" || value === "web") return value;
+}
+function originTypeFromSource(source) {
+	return source;
+}
+function localWorkspaceFromConversationId(conversationId) {
+	return /^local:([^:]+):/.exec(conversationId)?.[1];
+}
+function destinationUpsertFromDestination(args) {
+	const { destination } = args;
+	if (!destination) return;
+	if (destination.platform === "slack") {
+		const channelId = destination.channelId;
+		return {
+			kind: channelId.startsWith("D") ? "dm" : channelId.startsWith("G") ? "group" : "channel",
+			provider: "slack",
+			providerTenantId: destination.teamId,
+			providerDestinationId: channelId,
+			refreshVisibility: args.visibility !== void 0,
+			visibility: args.visibility ?? "unknown",
+			...args.channelName ? { displayName: args.channelName } : void 0,
+			metadata: { platform: "slack" }
+		};
+	}
+	return {
+		kind: "local_conversation",
+		provider: "local",
+		providerTenantId: localWorkspaceFromConversationId(destination.conversationId) ?? localWorkspaceFromConversationId(args.conversationId ?? ""),
+		providerDestinationId: destination.conversationId,
+		refreshVisibility: args.visibility !== void 0,
+		visibility: args.visibility ?? "direct",
+		metadata: { platform: "local" }
+	};
+}
+function executionStatusFromValue(value) {
+	if (value === "awaiting_resume" || value === "paused") return "paused";
+	if (value === "failed" || value === "idle" || value === "pending" || value === "running") return value;
+	throw new Error("Conversation record execution status is invalid");
+}
+function executionStatusToSql(status) {
+	return status === "paused" ? "awaiting_resume" : status;
+}
+function destinationFromRow(destination) {
+	return parseDestination(destination?.provider === "slack" ? {
+		platform: "slack",
+		teamId: destination.providerTenantId,
+		channelId: destination.providerDestinationId
+	} : destination?.provider === "local" ? {
+		platform: "local",
+		conversationId: destination.providerDestinationId
+	} : void 0);
+}
+/** Decode one SQL row and reject invalid durable conversation records. */
+function conversationFromRow(readRow) {
+	const row = readRow.conversation;
+	const visibility = visibilityFromLocationRow(readRow.destination);
+	if (row.schemaVersion !== 1) throw new Error("Conversation record schema version 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");
+	const destination = destinationFromRow(readRow.destination);
+	const actor = actorFromIdentityRow(readRow.actorIdentity, readRow.actorUserDisplayName);
+	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) throw new Error("Conversation record source is invalid");
+	const sessionSource = row.sessionSource === void 0 || row.sessionSource === null ? void 0 : parseSessionSource(row.sessionSource);
+	if (row.sessionSource !== void 0 && row.sessionSource !== null && !sessionSource) throw new Error("Conversation record session source is invalid");
+	const execution = {
+		status: executionStatusFromValue(row.executionStatus),
+		lastCheckpointAtMs: msFromDate(row.lastCheckpointAt),
+		lastEnqueuedAtMs: msFromDate(row.lastEnqueuedAt),
+		...row.runId ? { runId: row.runId } : void 0,
+		updatedAtMs: msFromDate(row.executionUpdatedAt) ?? requiredMsFromDate(row.updatedAt)
+	};
+	const location = locationFromRow(row.location, readRow.destination, sessionSource);
+	return {
+		schemaVersion: 1,
+		conversationId: row.conversationId,
+		createdAtMs: requiredMsFromDate(row.createdAt),
+		lastActivityAtMs: requiredMsFromDate(row.lastActivityAt),
+		updatedAtMs: requiredMsFromDate(row.updatedAt),
+		execution,
+		executionMetrics: {
+			durationMs: row.executionDurationMs,
+			...row.metricRunId ? { runId: row.metricRunId } : void 0,
+			...row.executionUsage ? { usage: row.executionUsage } : void 0
+		},
+		...row.parentConversationId ? { parentConversationId: row.parentConversationId } : void 0,
+		...destination ? { destination } : void 0,
+		...location ? { location } : void 0,
+		...actor ? { actor } : void 0,
+		...row.channelName ? { channelName: row.channelName } : void 0,
+		...source ? { source } : void 0,
+		...sessionSource ? { sessionSource } : void 0,
+		...row.title ? { title: row.title } : void 0,
+		...msFromDate(row.transcriptPurgedAt) !== void 0 ? { transcriptPurgedAtMs: msFromDate(row.transcriptPurgedAt) } : void 0,
+		...visibility ? { visibility } : void 0
+	};
+}
+function emptyConversation(args) {
+	return {
+		schemaVersion: 1,
+		conversationId: args.conversationId,
+		createdAtMs: args.nowMs,
+		lastActivityAtMs: args.nowMs,
+		updatedAtMs: args.nowMs,
+		...args.destination ? { destination: args.destination } : void 0,
+		...args.source ? { source: args.source } : void 0,
+		...args.sessionSource ? { sessionSource: args.sessionSource } : void 0,
+		execution: {
+			status: "idle",
+			updatedAtMs: args.nowMs
+		}
+	};
+}
+function assertSameConversationDestination(args) {
+	if (!args.current || sameDestination(args.current, args.next)) return;
+	throw new Error(`Conversation destination changed for ${args.conversationId}`);
+}
+var SqlStore = class {
+	executor;
+	constructor(executor) {
+		this.executor = executor;
+	}
+	async getConversationIdByProviderConversation(args) {
+		return await getConversationIdByProviderConversation(this.executor, args);
+	}
+	async getFirstProviderConversationId(args) {
+		return await getFirstProviderConversationId(this.executor, args);
+	}
+	async bindProviderConversation(args) {
+		await bindProviderConversation(this.executor, args);
+	}
+	async createChild(args) {
+		const nowMs = args.nowMs ?? now();
+		await this.withConversationMutation(args.parentConversationId, async () => {
+			await this.withConversationMutation(args.childConversationId, async () => {
+				const existing = await this.get({ conversationId: args.childConversationId });
+				if (existing) {
+					if (existing.parentConversationId !== args.parentConversationId) throw new Error(`Conversation parent changed for ${args.childConversationId}`);
+					return;
+				}
+				const parent = await this.get({ conversationId: args.parentConversationId });
+				if (!parent) throw new Error(`Conversation parent is missing for ${args.childConversationId}`);
+				if (parent.parentConversationId) throw new Error("Recursive agent delegation is not enabled");
+				const child = {
+					...emptyConversation({
+						conversationId: args.childConversationId,
+						nowMs,
+						source: args.source
+					}),
+					parentConversationId: args.parentConversationId
+				};
+				await this.upsertConversation({ conversation: child });
+			});
+		});
+	}
+	async get(args) {
+		const row = await this.readConversationRow(args.conversationId);
+		if (!row) return;
+		return conversationFromRow(row);
+	}
+	async recordActivity(args) {
+		const nowMs = args.nowMs ?? now();
+		const activityAtMs = args.activityAtMs ?? nowMs;
+		const sessionSource = normalizeSessionSource(args.sessionSource);
+		await this.withConversationMutation(args.conversationId, async () => {
+			const existing = await this.get({ conversationId: args.conversationId });
+			if (existing && args.destination) assertSameConversationDestination({
+				conversationId: args.conversationId,
+				current: existing.destination,
+				next: args.destination
+			});
+			const current = existing ?? emptyConversation({
+				conversationId: args.conversationId,
+				destination: args.destination,
+				nowMs,
+				source: args.source,
+				...sessionSource ? { sessionSource } : void 0
+			});
+			const { sessionSource: _persistedSessionSource, visibility: _persistedVisibility, ...currentWithoutPersistedSignals } = current;
+			await this.upsertConversation({ conversation: {
+				...currentWithoutPersistedSignals,
+				destination: current.destination ?? args.destination,
+				source: current.source ?? args.source,
+				...sessionSource ? { sessionSource } : void 0,
+				channelName: current.channelName ?? args.channelName,
+				actor: mergeActor(current.actor, args.actor),
+				title: current.title ?? args.title,
+				lastActivityAtMs: Math.max(current.lastActivityAtMs, activityAtMs),
+				updatedAtMs: nowMs,
+				execution: {
+					...current.execution,
+					updatedAtMs: current.execution.updatedAtMs ?? nowMs
+				},
+				...args.visibility ? { visibility: args.visibility } : void 0
+			} });
+		});
+	}
+	async recordExecution(args) {
+		if (args.metrics && !args.execution.runId) throw new Error("Conversation Run metrics require a Run id");
+		await this.withConversationMutation(args.conversationId, async () => {
+			const existingRow = await this.readConversationRow(args.conversationId);
+			const existing = existingRow ? conversationFromRow(existingRow) : void 0;
+			if (!existing && !args.destination) return;
+			const incomingExecutionAt = args.execution.updatedAtMs ?? args.updatedAtMs;
+			const incomingIsFresh = incomingExecutionAt >= (existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0);
+			const execution = incomingIsFresh ? args.execution : existing?.execution ?? args.execution;
+			await this.upsertConversation({ conversation: {
+				schemaVersion: 1,
+				conversationId: args.conversationId,
+				createdAtMs: args.createdAtMs,
+				lastActivityAtMs: args.lastActivityAtMs,
+				updatedAtMs: args.updatedAtMs,
+				...existing?.parentConversationId ? { parentConversationId: existing.parentConversationId } : void 0,
+				...existing?.location ? { location: existing.location } : void 0,
+				...args.channelName ? { channelName: args.channelName } : void 0,
+				...args.destination ? { destination: args.destination } : void 0,
+				...args.actor ? { actor: args.actor } : void 0,
+				...args.source ? { source: args.source } : void 0,
+				...args.title ? { title: args.title } : void 0,
+				...args.visibility ? { visibility: args.visibility } : void 0,
+				execution
+			} });
+			if (args.metrics && args.execution.runId) {
+				await replaceConversationMetrics(this.executor, {
+					conversationId: args.conversationId,
+					runId: args.execution.runId,
+					occurredAtMs: args.createdAtMs,
+					updatedAtMs: incomingExecutionAt,
+					...args.metrics
+				});
+				if (incomingIsFresh) await this.executor.db().update(juniorConversations).set({
+					metricRunId: args.execution.runId,
+					executionDurationMs: args.metrics.durationMs,
+					executionUsage: args.metrics.usage ?? null
+				}).where(eq(juniorConversations.conversationId, args.conversationId));
+			}
+		});
+	}
+	async listByActivity(args = {}) {
+		const rows = await this.executor.db().select({
+			conversation: conversationReadColumns(),
+			destination: juniorDestinations,
+			actorIdentity: juniorIdentities,
+			actorUserDisplayName: juniorUsers.displayName
+		}).from(juniorConversations).leftJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).leftJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversations.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).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));
+		const conversations = [];
+		for (const row of rows) conversations.push(conversationFromRow(row));
+		return conversations;
+	}
+	async getDestinationVisibility(args) {
+		const row = (await this.executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(and(eq(juniorDestinations.provider, args.provider), eq(juniorDestinations.providerTenantId, tenantId(args.providerTenantId)), eq(juniorDestinations.providerDestinationId, args.providerDestinationId))))[0];
+		if (!row) return;
+		if (row.visibility === "public" || row.visibility === "private") return row.visibility;
+	}
+	async findSlackDestinationByName(args) {
+		const normalized = args.channelName.trim().replace(/^#/, "").toLowerCase();
+		if (!normalized) return;
+		const rows = await this.executor.db().select({
+			channelId: juniorDestinations.providerDestinationId,
+			channelName: juniorDestinations.displayName
+		}).from(juniorDestinations).where(and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, tenantId(args.teamId)), eq(juniorDestinations.kind, "channel"), sql`lower(ltrim(${juniorDestinations.displayName}, '#')) = ${normalized}`)).limit(2);
+		if (rows.length !== 1) return;
+		const row = rows[0];
+		if (!row?.channelId) return;
+		return {
+			channelId: row.channelId,
+			...row.channelName ? { channelName: row.channelName } : void 0
+		};
+	}
+	/** Serialize all durable mutations for one conversation inside a SQL transaction. */
+	async withConversationMutation(conversationId, callback) {
+		return await withConversationMutationLock(this.executor, conversationId, callback);
+	}
+	async readConversationRow(conversationId) {
+		return (await this.executor.db().select({
+			conversation: conversationReadColumns(),
+			destination: juniorDestinations,
+			actorIdentity: juniorIdentities,
+			actorUserDisplayName: juniorUsers.displayName
+		}).from(juniorConversations).leftJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).leftJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversations.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(eq(juniorConversations.conversationId, conversationId)))[0];
+	}
+	/** Upsert the conversation row while preserving previously discovered nullable metadata fields. */
+	async upsertConversation(args) {
+		const { conversation } = args;
+		if (!conversation.parentConversationId && !conversation.destination) {
+			if (!await this.get({ conversationId: conversation.conversationId })) throw new Error(`Conversation ${conversation.conversationId} requires a destination at create`);
+		}
+		const incomingExecutionVersion = sql`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
+		const currentExecutionVersion = sql`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
+		const incomingExecutionIsFresh = sql`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
+		const destinationId = await this.upsertDestination(destinationUpsertFromDestination({
+			channelName: conversation.channelName,
+			conversationId: conversation.conversationId,
+			destination: conversation.destination,
+			...conversation.visibility ? { visibility: conversation.visibility } : void 0
+		}), conversation.updatedAtMs);
+		const location = locationForWrite({
+			destination: conversation.destination,
+			destinationId,
+			location: conversation.location,
+			sessionSource: conversation.sessionSource
+		});
+		const actorIdentityObservation = actorIdentityForConversation(conversation);
+		const actorIdentity = actorIdentityObservation ? await upsertIdentity(this.executor, actorIdentityObservation, conversation.updatedAtMs) : void 0;
+		const rootConversationId = conversation.parentConversationId ? sql`(
+          select parent.root_conversation_id
+          from junior_conversations parent
+          where parent.conversation_id = ${conversation.parentConversationId}
+        )` : conversation.conversationId;
+		const row = (await this.executor.db().insert(juniorConversations).values({
+			conversationId: conversation.conversationId,
+			schemaVersion: 1,
+			source: conversation.source ?? null,
+			sessionSource: conversation.sessionSource ?? null,
+			originType: originTypeFromSource(conversation.source) ?? null,
+			originId: null,
+			originRunId: null,
+			location: location ?? null,
+			destinationId: destinationId ?? null,
+			destination: null,
+			actorIdentityId: actorIdentity?.id ?? null,
+			creatorIdentityId: null,
+			credentialSubjectIdentityId: null,
+			actor: null,
+			channelName: conversation.channelName ?? null,
+			title: conversation.title ?? null,
+			createdAt: dateFromMs(conversation.createdAtMs),
+			lastActivityAt: dateFromMs(conversation.lastActivityAtMs),
+			updatedAt: dateFromMs(conversation.updatedAtMs),
+			executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs(conversation.execution.updatedAtMs),
+			executionStatus: executionStatusToSql(conversation.execution.status),
+			runId: conversation.execution.runId ?? null,
+			lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs(conversation.execution.lastCheckpointAtMs),
+			lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs(conversation.execution.lastEnqueuedAtMs),
+			parentConversationId: conversation.parentConversationId ?? null,
+			rootConversationId
+		}).onConflictDoUpdate({
+			target: juniorConversations.conversationId,
+			set: {
+				source: sql`coalesce(${juniorConversations.source}, excluded.source)`,
+				sessionSource: sql`coalesce(${juniorConversations.sessionSource}, excluded.source_json)`,
+				originType: sql`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
+				originId: sql`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
+				originRunId: sql`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
+				location: sql`coalesce(excluded.location_json, ${juniorConversations.location})`,
+				destinationId: sql`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
+				actorIdentityId: sql`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
+				creatorIdentityId: sql`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
+				credentialSubjectIdentityId: sql`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
+				channelName: sql`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
+				title: sql`coalesce(excluded.title, ${juniorConversations.title})`,
+				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)`,
+				executionUpdatedAt: sql`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
+				executionStatus: sql`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
+				runId: sql`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
+				lastCheckpointAt: sql`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
+				lastEnqueuedAt: sql`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`,
+				rootConversationId: sql`coalesce(${juniorConversations.rootConversationId}, excluded.root_conversation_id)`
+			}
+		}).returning({
+			actorIdentityId: juniorConversations.actorIdentityId,
+			parentConversationId: juniorConversations.parentConversationId,
+			rootConversationId: juniorConversations.rootConversationId
+		}))[0];
+		if (!row?.rootConversationId) throw new Error("Conversation parent is missing its persisted root");
+		if (row.actorIdentityId && row.parentConversationId === null) await recordConversationParticipant(this.executor, {
+			actorIdentityId: row.actorIdentityId,
+			conversationId: conversation.conversationId,
+			atMs: conversation.lastActivityAtMs
+		});
+	}
+	async upsertDestination(destination, nowMs) {
+		if (!destination) return;
+		const visibilityUpdate = destination.refreshVisibility ? sql`excluded.visibility` : juniorDestinations.visibility;
+		return (await this.executor.db().insert(juniorDestinations).values({
+			id: randomUUID(),
+			provider: destination.provider,
+			providerTenantId: tenantId(destination.providerTenantId),
+			providerDestinationId: destination.providerDestinationId,
+			kind: destination.kind,
+			parentDestinationId: null,
+			displayName: destination.displayName ?? null,
+			visibility: destination.visibility,
+			metadata: destination.metadata ?? null,
+			createdAt: dateFromMs(nowMs),
+			updatedAt: dateFromMs(nowMs)
+		}).onConflictDoUpdate({
+			target: [
+				juniorDestinations.provider,
+				juniorDestinations.providerTenantId,
+				juniorDestinations.providerDestinationId
+			],
+			set: {
+				kind: sql`excluded.kind`,
+				displayName: sql`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
+				visibility: visibilityUpdate,
+				metadata: sql`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
+				updatedAt: sql`excluded.updated_at`
+			}
+		}).returning({ id: juniorDestinations.id }))[0]?.id;
+	}
+};
+/** Create a SQL-backed conversation store. */
+function createSqlStore(executor) {
+	return new SqlStore(executor);
+}
+//#endregion
+//#region src/chat/conversations/sql/conversation-row.ts
+/**
+* Establish the conversation metadata row on first contact for content writes
+* (conversation events, visible transcript) that can land before activity has
+* created the row, and whose tables FK to it.
+*
+* First contact creates the row; every later content write advances the
+* activity clock so retention mirrors append-refresh semantics (each content
+* append refreshes the retention window). Background observations may opt out
+* and leave an existing row unchanged. The timestamp is content-intrinsic (the
+* first item's `createdAtMs`), and `greatest(...)` guarantees a backfilled or
+* imported historical write — which carries an old timestamp — can never
+* regress `last_activity_at`.
+*/
+async function ensureConversationRow(executor, conversationId, atMs, options = {}) {
+	const at = new Date(atMs);
+	const insert = executor.db().insert(juniorConversations).values({
+		conversationId,
+		createdAt: at,
+		lastActivityAt: at,
+		updatedAt: at,
+		executionStatus: "idle"
+	});
+	if (options.activity === "preserve") {
+		await insert.onConflictDoNothing({ target: juniorConversations.conversationId });
+		return;
+	}
+	await insert.onConflictDoUpdate({
+		target: juniorConversations.conversationId,
+		set: {
+			lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+			updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+			transcriptPurgedAt: null
+		}
+	});
+}
+//#endregion
+//#region src/chat/conversations/sql/event-actor.ts
+const SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readAuthor(meta) {
+	if (!isRecord(meta) || !isRecord(meta.author)) return {};
+	const author = meta.author;
+	return {
+		...typeof author.email === "string" ? { email: author.email } : void 0,
+		...typeof author.fullName === "string" ? { fullName: author.fullName } : void 0,
+		...typeof author.isBot === "boolean" ? { isBot: author.isBot } : void 0,
+		...typeof author.userId === "string" ? { userId: author.userId } : void 0,
+		...typeof author.userName === "string" ? { userName: author.userName } : void 0
+	};
+}
+async function loadConversationSlackTenantId(executor, conversationId) {
+	const [row] = await executor.db().select({
+		providerTenantId: juniorDestinations.providerTenantId,
+		sessionSource: juniorConversations.sessionSource
+	}).from(juniorConversations).leftJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).where(eq(juniorConversations.conversationId, conversationId)).limit(1);
+	const destinationTenant = row?.providerTenantId?.trim();
+	if (destinationTenant) return destinationTenant;
+	const sessionSource = parseSessionSource(row?.sessionSource);
+	if (sessionSource?.kind === "slack") return sessionSource.teamId;
+}
+async function findIdentityIdByProviderSubject(executor, args) {
+	return (await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(and(eq(juniorIdentities.provider, args.provider), eq(juniorIdentities.providerSubjectId, args.providerSubjectId), args.providerTenantId === void 0 ? void 0 : eq(juniorIdentities.providerTenantId, args.providerTenantId))).limit(1))[0]?.id;
+}
+async function findJuniorIdentityIdByEmail(executor, email) {
+	const normalized = email.trim().toLowerCase();
+	if (!normalized) return void 0;
+	return (await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(and(eq(juniorIdentities.provider, "junior"), eq(juniorIdentities.kind, "user"), or(eq(juniorIdentities.providerSubjectId, normalized), and(eq(juniorIdentities.emailNormalized, normalized), eq(juniorIdentities.emailVerified, true))))).limit(1))[0]?.id;
+}
+/**
+* Resolve a dashboard:<hash> author against junior identities keyed by email.
+* Web actors store userId as dashboard:${sha256(email).slice(0,24)} while the
+* durable identity subject remains the verified email.
+*/
+async function findJuniorIdentityIdByDashboardAuthorId(executor, dashboardAuthorId) {
+	if (!dashboardAuthorId.startsWith("dashboard:")) return;
+	return (await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(and(eq(juniorIdentities.provider, "junior"), eq(juniorIdentities.kind, "user"), eq(juniorIdentities.emailVerified, true), sql`${juniorIdentities.emailNormalized} is not null`, sql`concat(
+          'dashboard:',
+          left(encode(digest(${juniorIdentities.emailNormalized}, 'sha256'), 'hex'), 24)
+        ) = ${dashboardAuthorId}`)).limit(1))[0]?.id;
+}
+/**
+* Resolve the durable actor identity for one event payload.
+* Human user messages get an identity when author data is enough; other events
+* keep a null actor.
+*/
+async function resolveEventActorIdentityId(executor, args) {
+	const data = args.data;
+	if (data.type !== "message" && data.type !== "message_updated") return;
+	if (typeof data.authorIdentityId === "string" && data.authorIdentityId) return data.authorIdentityId;
+	if (data.role !== "user") return;
+	const author = readAuthor(data.meta);
+	if (author.isBot === true) return;
+	const userId = parseActorUserId(author.userId);
+	if (!userId) return;
+	if (SLACK_USER_ID_PATTERN.test(userId)) {
+		const tenantId = await loadConversationSlackTenantId(executor, args.conversationId);
+		const observation = {
+			kind: "user",
+			provider: "slack",
+			providerSubjectId: userId,
+			...tenantId ? { providerTenantId: tenantId } : void 0,
+			...author.fullName ? { displayName: author.fullName } : void 0,
+			...author.userName ? { handle: author.userName } : void 0,
+			...author.email ? {
+				email: author.email,
+				emailVerified: true
+			} : void 0
+		};
+		if (tenantId) return (await upsertIdentity(executor, observation, args.nowMs)).id;
+		return await findIdentityIdByProviderSubject(executor, {
+			provider: "slack",
+			providerSubjectId: userId
+		}) ?? void 0;
+	}
+	const email = typeof author.email === "string" && author.email.includes("@") ? author.email.trim().toLowerCase() : userId.includes("@") ? userId.trim().toLowerCase() : void 0;
+	if (email) return (await upsertIdentity(executor, {
+		kind: "user",
+		provider: "junior",
+		providerSubjectId: email,
+		email,
+		emailVerified: true,
+		...author.fullName ? { displayName: author.fullName } : void 0,
+		metadata: { platform: "web" }
+	}, args.nowMs)).id;
+	if (userId.startsWith("dashboard:")) return findJuniorIdentityIdByDashboardAuthorId(executor, userId);
+	return findJuniorIdentityIdByEmail(executor, userId);
+}
+/** Drop payload-only authorIdentityId after lifting it onto the event column. */
+function stripPayloadAuthorIdentityId(data) {
+	if (data.type !== "message" && data.type !== "message_updated" || data.authorIdentityId === void 0) return data;
+	const { authorIdentityId: _authorIdentityId, ...rest } = data;
+	return rest;
+}
+//#endregion
+//#region src/db/postgres-json.ts
+/**
+* Replace actual NUL characters that PostgreSQL cannot store in JSONB.
+* Literal `\\u0000` text is preserved because it contains no NUL character.
+*/
+function sanitizePostgresJson(value) {
+	if (typeof value === "string") return value.replaceAll("\0", " ");
+	if (Array.isArray(value)) return value.map((item) => sanitizePostgresJson(item));
+	if (value === null || typeof value !== "object") return value;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizePostgresJson(item)]));
+}
+//#endregion
+//#region src/chat/conversations/sql/event-lock.ts
+/** Serialize event sequence allocation with other conversation writes. */
+async function withConversationEventLock(executor, conversationId, callback) {
+	return executor.withLock(`junior_conversation:${conversationId}`, callback);
+}
+//#endregion
+//#region src/chat/conversations/sql/history.ts
+const messageHistoryEventTypes = [
+	"message",
+	"message_updated",
+	"message_handled"
+];
+const HUMAN_INSTRUCTION_PLATFORMS = /* @__PURE__ */ new Set([
+	"slack",
+	"local",
+	"web"
+]);
+/**
+* Whether one event should restore an archived conversation to the feed.
+*
+* Archive hides finished noise until a human comes back. Events,
+* turn lifecycle, compaction, and other system writes may still refresh
+* activity clocks, but they must not unarchive on their own.
+*/
+function eventUnarchivesConversation(data) {
+	if (data.type === "user_message") {
+		const provenance = data.provenance;
+		if (provenance.authority !== "instruction") return false;
+		const platform = provenance.actor?.platform;
+		return platform === void 0 || HUMAN_INSTRUCTION_PLATFORMS.has(platform);
+	}
+	if (data.type !== "message") return false;
+	if (data.role !== "user") return false;
+	const meta = data.meta;
+	if (!meta) return true;
+	if (typeof meta.eventType === "string" && meta.eventType.length > 0) return false;
+	const author = meta.author;
+	if (author && typeof author === "object" && !Array.isArray(author) && author.isBot === true) return false;
+	return true;
+}
+/** Split validated event data into column-lifted and JSON payload fields. */
+function insertFromEvent(conversationId, seq, historyVersion, event, actorIdentityId) {
+	const stripped = stripPayloadAuthorIdentityId(event.data);
+	const data = conversationEventDataSchema.parse(stripped);
+	const encoded = encodeHistoryPayload(data);
+	return {
+		conversationId,
+		seq,
+		historyVersion,
+		schemaVersion: encoded.schemaVersion,
+		idempotencyKey: event.idempotencyKey ?? null,
+		type: data.type,
+		payload: sanitizePostgresJson(encoded.payload),
+		actorIdentityId: actorIdentityId ?? null,
+		createdAt: new Date(event.createdAtMs)
+	};
+}
+/** Parse one physical event row into the storage-compatible domain envelope. */
+function eventFromRow(row) {
+	const payload = row.actorIdentityId && typeof row.payload === "object" && row.payload !== null && !Array.isArray(row.payload) && (row.type === "message" || row.type === "message_updated") && !("authorIdentityId" in row.payload) ? {
+		...row.payload,
+		authorIdentityId: row.actorIdentityId
+	} : row.payload;
+	return decodeStoredConversationEvent({
+		schemaVersion: row.schemaVersion,
+		seq: row.seq,
+		historyVersion: row.historyVersion,
+		...row.idempotencyKey ? { idempotencyKey: row.idempotencyKey } : void 0,
+		createdAtMs: row.createdAt.getTime(),
+		type: row.type,
+		payload
+	});
+}
+/** Decode the summary row that defines a readable message-history suffix. */
+function messagesSummarizedEventFromRow(row) {
+	const event = eventFromRow(row);
+	if (event.schemaVersion !== 1 || event.data.type !== "messages_summarized") throw new Error("Message compaction row did not decode as messages_summarized");
+	return {
+		...event,
+		schemaVersion: 1,
+		data: event.data
+	};
+}
+var SqlConversationEventStore = class {
+	executor;
+	constructor(executor) {
+		this.executor = executor;
+	}
+	async append(conversationId, events, options = {}) {
+		const parsed = events.map((event) => newConversationEventSchema.parse(event));
+		if (parsed.length === 0) return [];
+		return withConversationEventLock(this.executor, conversationId, async () => {
+			const existingKeys = parsed.map((event) => event.idempotencyKey).filter((key) => key !== void 0);
+			const persistedKeys = existingKeys.length === 0 ? /* @__PURE__ */ new Set() : new Set((await this.executor.db().select({ key: juniorConversationEvents.idempotencyKey }).from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), inArray(juniorConversationEvents.idempotencyKey, existingKeys)))).flatMap((row) => row.key ? [row.key] : []));
+			const acceptedKeys = new Set(persistedKeys);
+			const pending = parsed.filter((event) => {
+				if (event.idempotencyKey === void 0) return true;
+				if (acceptedKeys.has(event.idempotencyKey)) return false;
+				acceptedKeys.add(event.idempotencyKey);
+				return true;
+			});
+			if (pending.length === 0) return [];
+			const newestCreatedAtMs = Math.max(...pending.map((event) => event.createdAtMs));
+			await ensureConversationRow(this.executor, conversationId, newestCreatedAtMs, options);
+			const cursor = await this.readCursor(conversationId);
+			const historyVersion = cursor.maxHistoryVersion ?? 0;
+			let seq = cursor.nextSeq;
+			const rows = [];
+			for (const event of pending) {
+				const actorIdentityId = await resolveEventActorIdentityId(this.executor, {
+					conversationId,
+					data: event.data,
+					nowMs: event.createdAtMs
+				});
+				rows.push(insertFromEvent(conversationId, seq++, historyVersion, event, actorIdentityId));
+				if (actorIdentityId) await recordConversationParticipant(this.executor, {
+					actorIdentityId,
+					conversationId,
+					atMs: event.createdAtMs,
+					restoreArchive: eventUnarchivesConversation(event.data)
+				});
+			}
+			await this.executor.db().insert(juniorConversationEvents).values(rows);
+			return rows.map((row) => ({
+				seq: row.seq,
+				historyVersion: row.historyVersion
+			}));
+		});
+	}
+	async replaceHistory(conversationId, replacement) {
+		const parsed = historyReplacementSchema.parse(replacement);
+		await withConversationEventLock(this.executor, conversationId, async () => {
+			await ensureConversationRow(this.executor, conversationId, Date.now());
+			const cursor = await this.readCursor(conversationId);
+			const historyVersion = (cursor.maxHistoryVersion ?? 0) + 1;
+			await this.executor.db().insert(juniorConversationEvents).values(insertFromEvent(conversationId, cursor.nextSeq, historyVersion, parsed));
+		});
+	}
+	async loadCurrentHistoryVersion(conversationId) {
+		return (await this.readCursor(conversationId)).maxHistoryVersion ?? 0;
+	}
+	async loadCurrentHistory(conversationId) {
+		const cursor = await this.readCursor(conversationId);
+		if (cursor.maxHistoryVersion === null) return [];
+		return (await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.historyVersion, cursor.maxHistoryVersion))).orderBy(asc(juniorConversationEvents.seq))).map(eventFromRow);
+	}
+	async loadByIdempotencyKey(conversationId, idempotencyKey) {
+		const [row] = await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.idempotencyKey, idempotencyKey))).limit(1);
+		return row ? eventFromRow(row) : void 0;
+	}
+	async loadHistoryContaining(conversationId, seq, throughSeq) {
+		const [boundary] = await this.executor.db().select({ historyVersion: juniorConversationEvents.historyVersion }).from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.seq, seq))).limit(1);
+		if (!boundary) return void 0;
+		return (await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.historyVersion, boundary.historyVersion), throughSeq === void 0 ? void 0 : lte(juniorConversationEvents.seq, throughSeq))).orderBy(asc(juniorConversationEvents.seq))).map(eventFromRow);
+	}
+	async loadLatestStructuredEvent(conversationId, namespace, name) {
+		const [row] = await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.type, "structured_event"), sql`${juniorConversationEvents.payload}->>'namespace' = ${namespace}`, sql`${juniorConversationEvents.payload}->>'name' = ${name}`)).orderBy(desc(juniorConversationEvents.seq)).limit(1);
+		return row ? eventFromRow(row) : void 0;
+	}
+	async loadLatestInstruction(conversationId) {
+		const [row] = await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.type, "user_message"), sql`${juniorConversationEvents.payload}->'provenance'->>'authority' = 'instruction'`)).orderBy(desc(juniorConversationEvents.seq)).limit(1);
+		return row ? eventFromRow(row) : void 0;
+	}
+	async loadMessageHistory(conversationId) {
+		const [compactionRow] = await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.type, "messages_summarized"))).orderBy(desc(juniorConversationEvents.seq)).limit(1);
+		const compaction = compactionRow ? messagesSummarizedEventFromRow(compactionRow) : void 0;
+		const historyFromSeq = compaction?.data.historyFromSeq ?? 0;
+		return {
+			events: (await this.executor.db().select().from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), inArray(juniorConversationEvents.type, messageHistoryEventTypes), gte(juniorConversationEvents.seq, historyFromSeq))).orderBy(asc(juniorConversationEvents.seq))).map(eventFromRow),
+			compaction,
+			historyFromSeq
+		};
+	}
+	async loadHistory(conversationId) {
+		return (await this.executor.db().select().from(juniorConversationEvents).where(eq(juniorConversationEvents.conversationId, conversationId)).orderBy(asc(juniorConversationEvents.seq))).map(eventFromRow);
+	}
+	async query(conversationId, query) {
+		if (query.limit < 1) throw new Error("Conversation event query limit must be at least 1");
+		if (query.afterSeq !== void 0 && query.beforeSeq !== void 0 && query.afterSeq >= query.beforeSeq) return {
+			events: [],
+			hasOlder: false,
+			hasNewer: false
+		};
+		const typeFilter = query.types && query.types.length > 0 ? inArray(juniorConversationEvents.type, [...query.types]) : void 0;
+		const bounds = and(eq(juniorConversationEvents.conversationId, conversationId), query.afterSeq === void 0 ? void 0 : gt(juniorConversationEvents.seq, query.afterSeq), query.beforeSeq === void 0 ? void 0 : lt(juniorConversationEvents.seq, query.beforeSeq), typeFilter);
+		const newestFirst = query.afterSeq === void 0;
+		const rows = await this.executor.db().select().from(juniorConversationEvents).where(bounds).orderBy(newestFirst ? desc(juniorConversationEvents.seq) : asc(juniorConversationEvents.seq)).limit(query.limit + 1);
+		const overflow = rows.length > query.limit;
+		const pageRows = overflow ? rows.slice(0, query.limit) : rows;
+		const events = (newestFirst ? [...pageRows].reverse() : pageRows).map(eventFromRow);
+		if (events.length === 0) return {
+			events,
+			hasOlder: false,
+			hasNewer: false
+		};
+		const firstSeq = events[0].seq;
+		const lastSeq = events[events.length - 1].seq;
+		return {
+			events,
+			hasOlder: newestFirst && overflow ? true : await this.hasMatchingEvent({
+				conversationId,
+				beforeSeq: firstSeq,
+				typeFilter
+			}),
+			hasNewer: !newestFirst && overflow ? true : await this.hasMatchingEvent({
+				conversationId,
+				afterSeq: lastSeq,
+				typeFilter
+			})
+		};
+	}
+	/** Return whether any matching event exists inside the exclusive seq window. */
+	async hasMatchingEvent(args) {
+		if (args.afterSeq !== void 0 && args.beforeSeq !== void 0 && args.afterSeq >= args.beforeSeq) return false;
+		const [row] = await this.executor.db().select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, args.conversationId), args.afterSeq === void 0 ? void 0 : gt(juniorConversationEvents.seq, args.afterSeq), args.beforeSeq === void 0 ? void 0 : lt(juniorConversationEvents.seq, args.beforeSeq), args.typeFilter)).limit(1);
+		return row !== void 0;
+	}
+	/** Read the next sequence and active model-history version. */
+	async readCursor(conversationId) {
+		const rows = await this.executor.db().select({
+			maxSeq: sql`max(${juniorConversationEvents.seq})`,
+			maxHistoryVersion: sql`max(${juniorConversationEvents.historyVersion})`
+		}).from(juniorConversationEvents).where(eq(juniorConversationEvents.conversationId, conversationId));
+		const maxSeq = rows[0]?.maxSeq;
+		const maxHistoryVersion = rows[0]?.maxHistoryVersion;
+		return {
+			maxHistoryVersion: maxHistoryVersion === null || maxHistoryVersion === void 0 ? null : Number(maxHistoryVersion),
+			nextSeq: maxSeq === null || maxSeq === void 0 ? 0 : Number(maxSeq) + 1
+		};
+	}
+};
+/** Create a SQL-backed canonical conversation event store. */
+function createSqlConversationEventStore(executor) {
+	return new SqlConversationEventStore(executor);
+}
+//#endregion
+//#region src/chat/conversations/sql/message-search.ts
+const EXCERPT_WITHOUT_QUERY_CHARS = 240;
+var SqlConversationMessageSearchStore = class {
+	executor;
+	constructor(executor) {
+		this.executor = executor;
+	}
+	async search(args) {
+		const db = this.executor.db();
+		const query = args.filters.query?.trim() || void 0;
+		const text = sql`${juniorConversationEvents.payload}->>'text'`;
+		const role = sql`${juniorConversationEvents.payload}->>'role'`;
+		const messageId = sql`${juniorConversationEvents.payload}->>'messageId'`;
+		const tsquery = query ? sql`websearch_to_tsquery('english', ${query})` : void 0;
+		const rank = tsquery ? sql`ts_rank_cd(to_tsvector('english', ${text}), ${tsquery})` : sql`1`;
+		const excerpt = tsquery ? sql`ts_headline('english', ${text}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')` : sql`left(${text}, ${EXCERPT_WITHOUT_QUERY_CHARS})`;
+		const conditions = [
+			eq(juniorConversations.source, "slack"),
+			isNull(juniorConversations.parentConversationId),
+			isNull(juniorConversations.transcriptPurgedAt),
+			ne(juniorConversations.conversationId, args.currentConversationId),
+			eq(juniorDestinations.provider, args.scope.provider),
+			eq(juniorDestinations.providerTenantId, args.scope.providerTenantId),
+			eq(juniorDestinations.visibility, "public"),
+			eq(juniorConversationEvents.type, "message"),
+			sql`${role} in ('user', 'assistant')`
+		];
+		if (tsquery) conditions.push(sql`to_tsvector('english', ${text}) @@ ${tsquery}`);
+		if (args.filters.channelId) conditions.push(eq(juniorDestinations.providerDestinationId, args.filters.channelId));
+		if (args.filters.afterMs !== void 0 && Number.isFinite(args.filters.afterMs)) conditions.push(gte(juniorConversations.lastActivityAt, new Date(args.filters.afterMs)));
+		if (args.filters.beforeMs !== void 0 && Number.isFinite(args.filters.beforeMs)) conditions.push(lt(juniorConversations.lastActivityAt, new Date(args.filters.beforeMs)));
+		if (args.filters.annotation) {
+			const annotation = args.filters.annotation.toLowerCase();
+			const nestedAnnotationPrefix = `${annotation}#`;
+			conditions.push(sql`exists (
+          select 1
+          from ${juniorConversationAnnotations}
+          where ${and(eq(juniorConversationAnnotations.conversationId, juniorConversations.conversationId), sql`(
+              lower(${juniorConversationAnnotations.key}) = ${annotation}
+              or starts_with(
+                lower(${juniorConversationAnnotations.key}),
+                ${nestedAnnotationPrefix}
+              )
+            )`)}
+        )`);
+		}
+		const bestPerConversation = db.selectDistinctOn([juniorConversations.conversationId], {
+			channelName: juniorDestinations.displayName,
+			conversationId: juniorConversations.conversationId,
+			excerpt: excerpt.as("excerpt"),
+			lastActivityAt: juniorConversations.lastActivityAt,
+			messageCreatedAt: juniorConversationEvents.createdAt,
+			messageId: messageId.as("message_id"),
+			providerDestinationId: juniorDestinations.providerDestinationId,
+			rank: rank.as("rank"),
+			role: role.as("role")
+		}).from(juniorConversationEvents).innerJoin(juniorConversations, eq(juniorConversations.conversationId, juniorConversationEvents.conversationId)).innerJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).where(and(...conditions)).orderBy(juniorConversations.conversationId, desc(rank), desc(juniorConversationEvents.createdAt)).as("best_conversation_matches");
+		return (await db.select().from(bestPerConversation).orderBy(desc(bestPerConversation.rank), desc(bestPerConversation.lastActivityAt), desc(bestPerConversation.messageCreatedAt)).limit(args.limit)).map((row) => ({
+			conversationId: row.conversationId,
+			excerpt: row.excerpt,
+			messageCreatedAtMs: row.messageCreatedAt.getTime(),
+			messageId: row.messageId,
+			providerDestinationId: row.providerDestinationId,
+			role: row.role,
+			...row.channelName ? { channelName: row.channelName } : void 0
+		}));
+	}
+};
+/** Create a SQL-backed public workspace message search store. */
+function createSqlConversationMessageSearchStore(executor) {
+	return new SqlConversationMessageSearchStore(executor);
+}
+//#endregion
+//#region src/chat/db.ts
+var db_exports = /* @__PURE__ */ __exportAll({
+	closeDb: () => closeDb,
+	getConversationEventStore: () => getConversationEventStore,
+	getConversationMessageSearchStore: () => getConversationMessageSearchStore,
+	getConversationStore: () => getConversationStore,
+	getDb: () => getDb,
+	getSqlExecutor: () => getSqlExecutor
+});
+let current;
+function createDb(args) {
+	return createJuniorSqlExecutor({
+		connectionString: args.databaseUrl,
+		driver: args.driver,
+		statementTimeoutMs: args.statementTimeoutMs
+	});
+}
+/** Return the process SQL executor for SQL-specific queries and transactions. */
+function getSqlExecutor() {
+	const { sql } = getChatConfig();
+	if (current?.databaseUrl !== sql.databaseUrl || current.driver !== sql.driver || current.statementTimeoutMs !== sql.statementTimeoutMs) {
+		if (current) {
+			const previous = current;
+			current = void 0;
+			previous.db.close().catch(() => void 0);
+		}
+		const db = createDb({
+			databaseUrl: sql.databaseUrl,
+			driver: sql.driver,
+			statementTimeoutMs: sql.statementTimeoutMs
+		});
+		current = {
+			databaseUrl: sql.databaseUrl,
+			driver: sql.driver,
+			statementTimeoutMs: sql.statementTimeoutMs,
+			db,
+			store: createSqlStore(db),
+			eventStore: createSqlConversationEventStore(db),
+			searchStore: createSqlConversationMessageSearchStore(db)
+		};
+	}
+	return current.db;
+}
+/** Return the process Drizzle database. */
+function getDb() {
+	return getSqlExecutor().db();
+}
+/** Return the SQL-backed conversation store. */
+function getConversationStore() {
+	getSqlExecutor();
+	return current.store;
+}
+/** Return the canonical SQL-backed conversation event store. */
+function getConversationEventStore() {
+	getSqlExecutor();
+	return current.eventStore;
+}
+/** Return the SQL-backed public provider-tenant conversation search store. */
+function getConversationMessageSearchStore() {
+	getSqlExecutor();
+	return current.searchStore;
+}
+/** Close the process SQL database when it has been opened. */
+async function closeDb() {
+	const previous = current;
+	current = void 0;
+	await previous?.db.close();
+}
+//#endregion
+//#region src/chat/plugins/viewer.ts
+function identityFromRow(row) {
+	return identitySchema.parse({
+		id: row.id,
+		provider: row.provider,
+		providerSubjectId: row.providerSubjectId,
+		...row.providerTenantId ? { providerTenantId: row.providerTenantId } : void 0,
+		...row.displayName ? { displayName: row.displayName } : void 0,
+		...row.handle ? { handle: row.handle } : void 0
+	});
+}
+async function readUserById(db, userRow) {
+	const identityRows = await db.select().from(juniorIdentities).where(and(eq(juniorIdentities.userId, userRow.id), eq(juniorIdentities.kind, "user"))).orderBy(asc(juniorIdentities.provider), asc(juniorIdentities.providerTenantId), asc(juniorIdentities.providerSubjectId));
+	return userSchema.parse({
+		email: userRow.primaryEmail,
+		id: userRow.id,
+		identities: identityRows.map(identityFromRow),
+		...userRow.displayName ? { displayName: userRow.displayName } : void 0,
+		...userRow.isAdmin ? { isAdmin: true } : void 0
+	});
+}
+/** Resolve or create the canonical user for one verified viewer email. */
+async function resolveViewerUserFromSql(db, email) {
+	const normalizedEmail = normalizeIdentityEmail(email);
+	if (!normalizedEmail) return void 0;
+	const now = /* @__PURE__ */ new Date();
+	const userRow = (await db.insert(juniorUsers).values({
+		id: randomUUID(),
+		primaryEmail: email.trim(),
+		primaryEmailNormalized: normalizedEmail,
+		displayName: null,
+		createdAt: now,
+		updatedAt: now
+	}).onConflictDoNothing({ target: juniorUsers.primaryEmailNormalized }).returning())[0] ?? (await db.select().from(juniorUsers).where(eq(juniorUsers.primaryEmailNormalized, normalizedEmail)).limit(1))[0];
+	return userRow ? await readUserById(db, userRow) : void 0;
+}
+/** Resolve or create the canonical user for one authenticated viewer. */
+async function resolveViewerUser(email) {
+	return await resolveViewerUserFromSql(getDb(), email);
+}
+/** Read one existing canonical user by verified email without creating a row. */
+async function findUserByEmailFromSql(db, email) {
+	const normalizedEmail = normalizeIdentityEmail(email);
+	if (!normalizedEmail) return void 0;
+	const userRow = (await db.select().from(juniorUsers).where(eq(juniorUsers.primaryEmailNormalized, normalizedEmail)).limit(1))[0];
+	return userRow ? await readUserById(db, userRow) : void 0;
+}
+/** Read one existing canonical user by verified email without creating a row. */
+async function findUserByEmail(email) {
+	return await findUserByEmailFromSql(getDb(), email);
+}
+/** Update one canonical user's display name in SQL. */
+async function updateViewerDisplayNameFromSql(db, userId, displayName) {
+	const userRow = (await db.update(juniorUsers).set({
+		displayName,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(juniorUsers.id, userId)).returning())[0];
+	return userRow ? await readUserById(db, userRow) : void 0;
+}
+/** Update one canonical user's display name. */
+async function updateViewerDisplayName(userId, displayName) {
+	return await updateViewerDisplayNameFromSql(getDb(), userId, displayName);
+}
+/**
+* Grant or revoke the Junior-wide admin role for one email.
+*
+* Granting creates the canonical user when needed, so an operator can grant
+* admin before that person first signs in. Revoking never creates a user.
+*/
+async function setUserAdminFromSql(db, email, isAdmin) {
+	const user = isAdmin ? await resolveViewerUserFromSql(db, email) : await findUserByEmailFromSql(db, email);
+	if (!user) return void 0;
+	const userRow = (await db.update(juniorUsers).set({
+		isAdmin,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(juniorUsers.id, user.id)).returning())[0];
+	return userRow ? await readUserById(db, userRow) : void 0;
+}
+/** List every Junior admin by primary email. */
+async function listAdminUsersFromSql(db) {
+	const rows = await db.select().from(juniorUsers).where(eq(juniorUsers.isAdmin, true)).orderBy(asc(juniorUsers.primaryEmailNormalized));
+	return await Promise.all(rows.map((row) => readUserById(db, row)));
+}
+/** Resolve the stored identity and linked user for one runtime actor. */
+async function readActorIdentityFromSql(db, actor) {
+	if (actor.platform === "system") return void 0;
+	const providerTenantId = actor.platform === "slack" ? actor.teamId : "";
+	const row = (await db.select({
+		identity: juniorIdentities,
+		user: juniorUsers
+	}).from(juniorIdentities).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(eq(juniorIdentities.kind, "user"), eq(juniorIdentities.provider, actor.platform), eq(juniorIdentities.providerTenantId, providerTenantId), eq(juniorIdentities.providerSubjectId, actor.userId))).limit(1))[0];
+	if (!row) return void 0;
+	return {
+		identity: identityFromRow(row.identity),
+		...row.user ? { user: await readUserById(db, row.user) } : void 0
+	};
+}
+/** Resolve the stored identity and linked user for one runtime actor. */
+async function readActorIdentity(actor) {
+	return await readActorIdentityFromSql(getDb(), actor);
+}
+//#endregion
+export { upsertLinkedIdentity as A, agentTurnUsageSchema as C, readUserTimezone as D, deleteProviderIdentityForSlackUser as E, parseDestination as M, requireSlackDestination as N, saveUserTimezone as O, sameDestination as P, agentTurnTotalTokens as S, resolveRootConversationId as T, locationFromRow as _, setUserAdminFromSql as a, addAgentTurnUsage as b, getConversationEventStore as c, getDb as d, getSqlExecutor as f, withConversationMutationLock as g, createSqlStore as h, resolveViewerUser as i, createSlackDestination as j, upsertIdentity as k, getConversationMessageSearchStore as l, withConversationEventLock as m, listAdminUsersFromSql as n, updateViewerDisplayName as o, createSqlConversationEventStore as p, readActorIdentity as r, db_exports as s, findUserByEmail as t, getConversationStore as u, bindProviderConversation as v, hasAgentTurnUsage as w, agentTurnCostUsd as x, parseSessionSource as y };