@sentry/junior 0.204.0 → 0.206.0

package/dist/{agent-hooks-Bbcp9e33.js → agent-hooks-DNjlz2A-.js}

@@ -1,17 +1,21 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { _ as completeObject, i as getChatConfig, n as botConfig, o as getSlackBotToken, y as embedTexts } from "./config-nGCW1OTG.js";
-import { C as withSpan, P as normalizeIdentityEmail, _ as setSpanAttributes, d as logInfo, f as logWarn, u as logException, v as setSpanStatus } from "./logging-BzAk1S_s.js";
+import { a as embedTexts, r as completeObject } from "./client-ceE7NtvC.js";
+import { C as withSpan, P as normalizeIdentityEmail, _ as setSpanAttributes, d as logInfo, f as logWarn, u as logException, v as setSpanStatus } from "./logging-D37bayDc.js";
+import { a as getClient$1 } from "./sentry-CD3SdJl-.js";
+import { a as getChatConfig, n as botConfig, s as getSlackBotToken } from "./config-CIE83sR2.js";
 import { n as defaultModelId } from "./model-profile-CZmVoGdX.js";
 import { _ as parseSlackMessageTs, c as isActorUserId, h as parseSlackTeamId, m as parseSlackChannelReferenceId, u as parseActorUserId } from "./context-B45_WqVX.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { C as juniorConversations, S as conversationReadColumns, T as juniorUsers, b as juniorCodeRepositories, g as juniorConversationEvents, h as juniorConversationBindings, i as juniorWorkspaces, m as juniorConversationParticipants, n as juniorSnapshots, r as juniorWorkspaceRepos, t as createJuniorSqlExecutor, v as juniorConversationAnnotations, w as juniorIdentities, y as juniorCodeChanges } from "./executor-DcMSlI5c.js";
-import { c as newConversationEventSchema, o as decodeStoredConversationEvent, r as conversationEventDataSchema, s as historyReplacementSchema } from "./history-CqTuSAdI.js";
-import { A as sleep$1, P as SANDBOX_WORKSPACE_ROOT, l as isSandboxMissingError, n as hash, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-CrT5nXbw.js";
+import { C as conversationReadColumns, E as juniorUsers, T as juniorIdentities, _ as juniorConversationEvents, b as juniorCodeChanges, g as juniorConversationBriefs, h as juniorConversationBindings, i as juniorWorkspaces, m as juniorConversationParticipants, n as juniorSnapshots, r as juniorWorkspaceRepos, t as createJuniorSqlExecutor, w as juniorConversations, x as juniorCodeRepositories, y as juniorConversationAnnotations } from "./executor-BfbYPW63.js";
+import { B as decodeStoredConversationEvent, C as conversationReportEventSchema, H as newConversationEventSchema, L as conversationEventDataSchema, M as conversationBriefSchema, N as parseBriefInput, V as historyReplacementSchema } from "./conversation-AA4R1VUn.js";
+import { A as sleep$1, P as SANDBOX_WORKSPACE_ROOT, l as isSandboxMissingError, n as hash, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-CSixooTi.js";
+import { n as briefEntriesFromReportEvents, s as generateBrief, t as BRIEF_PROMPT } from "./prompt-3gqNY1Ka.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
-import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, lte, ne, or, sql } from "drizzle-orm";
-import { codeChangeInputSchema, conversationAnnotationInputSchema, destinationSchema, identitySchema, locationSchema, missingToolAnnotationKeys, normalizeResourceEventIdentifier, pluginResourceEventsSchema, promptContextSchema, promptMessageSchema, resourceEventInputSchema, resourceEventMatchSchema, resourceEventMatches, resourceEventTypeSchema, sourceSchema, stableResourceEventMatchKey, userSchema } from "@sentry/junior-plugin-api";
+import { and, arrayContains, asc, desc, eq, getTableColumns, gt, gte, inArray, isNotNull, isNull, lt, lte, max, ne, or, sql } from "drizzle-orm";
+import { codeChangeInputSchema, conversationAnnotationInputSchema, conversationEventPresentationSchema, defineConversationEvent, destinationSchema, identitySchema, locationSchema, missingToolAnnotationKeys, normalizeResourceEventIdentifier, pluginResourceEventsSchema, promptContextSchema, promptMessageSchema, resourceEventInputSchema, resourceEventMatchSchema, resourceEventMatches, resourceEventTypeSchema, sourceSchema, stableResourceEventMatchKey, userSchema } from "@sentry/junior-plugin-api";
+import { alias } from "drizzle-orm/pg-core";
 import { WebClient } from "@slack/web-api";
 import { Sandbox } from "@vercel/sandbox";
 //#region src/chat/destination.ts
@@ -330,19 +334,21 @@ function locationForWrite(args) {
 	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");
-		return source?.threadTs && !location.threadTs ? {
+		const threadTs = location.threadTs ?? destination?.threadTs ?? source?.threadTs;
+		return threadTs === location.threadTs ? location : {
 			...location,
-			threadTs: source.threadTs
-		} : 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,
-		...source?.threadTs ? { threadTs: source.threadTs } : void 0
+		...threadTs ? { threadTs } : void 0
 	});
 }
 /** Read one complete Location from SQL. */
@@ -1356,6 +1362,126 @@ async function closeDb() {
 	await previous?.db.close();
 }
 //#endregion
+//#region src/chat/conversations/structured-events.ts
+/** Reserved namespace for Junior-owned conversation metadata events. */
+const JUNIOR_NATIVE_EVENT_NAMESPACE = "junior";
+const authenticationEventContentSchema = z.object({
+	accountLabel: z.string().trim().min(1).max(120).optional(),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1).optional(),
+	provider: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	providerLabel: z.string().trim().min(1).max(80).optional()
+}).strict();
+const agentsInstructionsUpdatedContentSchema = z.object({
+	action: z.enum([
+		"loaded",
+		"replaced",
+		"cleared"
+	]),
+	directory: z.string().trim().min(1).max(500).optional(),
+	fingerprint: z.string().trim().min(1).max(128),
+	sources: z.array(z.object({
+		content: z.string().min(1).max(32768),
+		path: z.string().trim().min(1).max(500)
+	}).strict()).max(32),
+	textBytes: z.number().int().nonnegative().optional()
+}).strict();
+function providerTitle(content) {
+	return content.providerLabel?.trim() || content.provider;
+}
+function agentsInstructionsTitle(action) {
+	if (action === "loaded") return "Loaded AGENTS.md";
+	if (action === "replaced") return "Updated AGENTS.md";
+	return "Cleared AGENTS.md";
+}
+function sourceFilename(sourcePath) {
+	return sourcePath.split("/").at(-1) || sourcePath;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} bytes`;
+	const kilobytes = bytes / 1024;
+	return `${Number.isInteger(kilobytes) ? kilobytes : kilobytes.toFixed(1)} KB`;
+}
+function agentsInstructionsPreview(content) {
+	const source = content.sources[0];
+	if (!source) return void 0;
+	const filename = sourceFilename(source.path);
+	const label = content.sources.length === 1 ? filename : `${content.sources.length} AGENTS.md files`;
+	return typeof content.textBytes === "number" ? `${label} · ${formatBytes(content.textBytes)}` : label;
+}
+/** Junior-owned account-link transcript event. */
+const authenticationLinkedEvent = defineConversationEvent({
+	name: "authentication_linked",
+	version: 1,
+	schema: authenticationEventContentSchema,
+	renderEvent(event) {
+		const provider = providerTitle(event);
+		return {
+			icon: "link",
+			title: `${provider} connected`,
+			...event.accountLabel ? { preview: `Connected as \`${event.accountLabel}\`` } : void 0,
+			details: [{
+				title: `${provider} connected`,
+				...event.accountLabel ? { description: `Connected as \`${event.accountLabel}\`` } : void 0,
+				metadata: [event.provider]
+			}]
+		};
+	}
+});
+/** Junior-owned account-unlink transcript event. */
+const authenticationUnlinkedEvent = defineConversationEvent({
+	name: "authentication_unlinked",
+	version: 1,
+	schema: authenticationEventContentSchema,
+	renderEvent(event) {
+		const provider = providerTitle(event);
+		return {
+			icon: "key",
+			title: `${provider} disconnected`,
+			details: [{
+				title: `${provider} disconnected`,
+				metadata: [event.provider]
+			}]
+		};
+	}
+});
+/** Junior-owned AGENTS.md bootstrap transition for the dashboard timeline. */
+const agentsInstructionsUpdatedEvent = defineConversationEvent({
+	name: "agents_instructions_updated",
+	version: 1,
+	schema: agentsInstructionsUpdatedContentSchema,
+	renderEvent(event) {
+		const title = agentsInstructionsTitle(event.action);
+		const preview = agentsInstructionsPreview(event);
+		return {
+			icon: "brain",
+			title,
+			...preview ? { preview } : void 0,
+			...event.sources.length > 0 ? { details: event.sources.map((source) => ({
+				title: sourceFilename(source.path),
+				content: source.content
+			})) } : void 0
+		};
+	}
+});
+const NATIVE_EVENT_DEFINITIONS = [
+	authenticationLinkedEvent,
+	authenticationUnlinkedEvent,
+	agentsInstructionsUpdatedEvent
+];
+/** Resolve a registered Junior-native conversation event definition. */
+function getJuniorNativeEventDefinition(args) {
+	return NATIVE_EVENT_DEFINITIONS.find((definition) => definition.eventName === args.name && definition.version === args.version);
+}
+/** Render one Junior-native event through its active definition. */
+function renderJuniorNativeConversationEvent(args) {
+	if (args.namespace !== "junior") return void 0;
+	const definition = getJuniorNativeEventDefinition(args);
+	if (!definition) return void 0;
+	const presentation = definition.renderEvent(definition.parse(args.content));
+	return presentation === void 0 ? void 0 : conversationEventPresentationSchema.parse(presentation);
+}
+//#endregion
 //#region src/chat/plugins/annotations.ts
 function annotationFromRow(row) {
 	const parsed = conversationAnnotationInputSchema.safeParse(row.annotation);
@@ -1420,6 +1546,926 @@ async function listConversationAnnotationsById(db, conversationIds) {
 	return byConversation;
 }
 //#endregion
+//#region src/chat/conversations/sql/privacy.ts
+const privacyRoot = alias(juniorConversations, "privacy_root");
+/** Accept only a structurally valid persisted root as privacy authority. */
+async function readRootCandidate(executor, conversationId) {
+	const row = (await executor.db().select({
+		requestedConversationId: juniorConversations.conversationId,
+		requestedParentConversationId: juniorConversations.parentConversationId,
+		requestedRootConversationId: juniorConversations.rootConversationId,
+		rootConversationId: privacyRoot.conversationId,
+		rootDestinationId: privacyRoot.destinationId,
+		rootParentConversationId: privacyRoot.parentConversationId,
+		rootRootConversationId: privacyRoot.rootConversationId
+	}).from(juniorConversations).leftJoin(privacyRoot, eq(privacyRoot.conversationId, juniorConversations.rootConversationId)).where(eq(juniorConversations.conversationId, conversationId)))[0];
+	return row?.requestedRootConversationId !== null && (row?.requestedParentConversationId !== null || row?.requestedRootConversationId === row?.requestedConversationId) && row?.rootConversationId === row.requestedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && row.rootDestinationId !== null ? {
+		destinationId: row.rootDestinationId,
+		rootConversationId: row.rootConversationId
+	} : void 0;
+}
+async function readCandidateVisibility(executor, candidate) {
+	const destinations = await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, candidate.destinationId)).for("share");
+	return {
+		rootConversationId: candidate.rootConversationId,
+		visibility: destinations[0]?.visibility ?? null
+	};
+}
+/**
+* Resolve a conversation's privacy authority from its persisted root.
+*
+* Missing or structurally invalid root metadata fails closed. The root
+* destination is locked so callers that keep the transaction open receive a
+* stable visibility decision.
+*/
+async function resolveRootVisibility(executor, conversationId) {
+	const candidate = await readRootCandidate(executor, conversationId);
+	if (!candidate) return {
+		rootConversationId: conversationId,
+		visibility: null
+	};
+	return readCandidateVisibility(executor, candidate);
+}
+//#endregion
+//#region src/chat/briefs/events.ts
+/** Durable cost and size record for one stored Brief version. */
+const briefUpdatedEvent = defineConversationEvent({
+	name: "brief_updated",
+	version: 1,
+	schema: z.object({
+		version: z.number().int().positive(),
+		modelId: z.string().min(1),
+		costUsd: z.number().finite().nonnegative().optional(),
+		decisions: z.number().int().nonnegative(),
+		openDecisions: z.number().int().nonnegative(),
+		links: z.number().int().nonnegative()
+	}).strict(),
+	renderEvent(event) {
+		return {
+			icon: "activity",
+			title: `Brief updated (v${event.version})`
+		};
+	}
+});
+//#endregion
+//#region src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+	return process.env.SENTRY_ORG_SLUG?.trim() || void 0;
+}
+function isSentrySaasDsnHost(host) {
+	return host === "sentry.io" || host.endsWith(".sentry.io");
+}
+function buildSentryWebBaseUrl(dsn) {
+	if (isSentrySaasDsnHost(dsn.host)) return "https://sentry.io";
+	const port = dsn.port ? `:${dsn.port}` : "";
+	const path = dsn.path ? `/${dsn.path}` : "";
+	return `${dsn.protocol}://${dsn.host}${port}${path}`;
+}
+function buildSentryOrgPath(args) {
+	const dsn = getClient$1()?.getDsn();
+	if (!dsn?.host || !dsn.projectId) return;
+	const orgSlug = getSentryOrgSlug();
+	if (!orgSlug) return;
+	const params = new URLSearchParams();
+	params.set("project", dsn.projectId);
+	if (args.query) for (const [key, value] of Object.entries(args.query)) params.set(key, value);
+	const path = `${args.path}?${params.toString()}`;
+	if (isSentrySaasDsnHost(dsn.host)) return `https://${orgSlug}.sentry.io/${path}`;
+	return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+/** Build a Sentry conversation URL only when the runtime has enough Sentry config. */
+function buildSentryConversationUrl(conversationId) {
+	return buildSentryOrgPath({ path: `explore/conversations/${encodeURIComponent(conversationId)}/` });
+}
+/** Build a Sentry event URL only when the runtime has enough Sentry config. */
+function buildSentryEventUrl(eventId) {
+	return buildSentryOrgPath({
+		path: "issues/",
+		query: { query: eventId }
+	});
+}
+//#endregion
+//#region src/api/conversations/events.ts
+/** Canonical event types that can contribute to the reporting projection. */
+const conversationReportSourceEventTypes = [
+	"message",
+	"message_handled",
+	"assistant_message",
+	"tool_result",
+	"tool_execution_started",
+	"guardian_action_reviewed",
+	"turn_started",
+	"turn_context",
+	"structured_event",
+	"attachments_delivered",
+	"turn_routed",
+	"turn_completed",
+	"turn_failed",
+	"compaction",
+	"handoff",
+	"subagent_started",
+	"subagent_ended"
+];
+const reportingAssistantMessageSchema = z.object({
+	type: z.literal("assistant_message"),
+	content: z.array(z.unknown())
+}).passthrough();
+const reportingToolCallPartSchema = z.object({
+	type: z.literal("toolCall"),
+	id: z.string().min(1),
+	name: z.string().min(1),
+	arguments: z.unknown()
+}).passthrough();
+const reportingToolResultMessageSchema = z.object({
+	type: z.literal("tool_result"),
+	toolCallId: z.string().min(1),
+	toolName: z.string().min(1).optional(),
+	name: z.string().min(1).optional(),
+	content: z.array(z.unknown()),
+	details: z.unknown().optional(),
+	isError: z.boolean().optional()
+}).passthrough();
+const reportingToolResultDetailsSchema = z.object({
+	ok: z.boolean().optional(),
+	status: z.string().optional()
+}).passthrough();
+const reportingTextPartSchema = z.object({
+	type: z.literal("text"),
+	text: z.string()
+}).passthrough();
+const reportingReasoningPartSchema = z.object({
+	type: z.literal("thinking"),
+	thinking: z.string(),
+	redacted: z.literal(true).optional()
+}).passthrough();
+const reportingMediaPartSchema = z.object({
+	type: z.enum(["image", "audio"]),
+	mimeType: z.string().min(1).optional()
+}).passthrough();
+const reportingMessageAuthorSchema = z.object({
+	fullName: z.string().min(1).optional(),
+	userId: z.string().min(1).optional(),
+	userName: z.string().min(1).optional()
+}).passthrough();
+/** Retain model-visible text and media descriptors, dropping all opaque fields. */
+function sanitizeModelContentPart(value) {
+	const text = reportingTextPartSchema.safeParse(value);
+	if (text.success) return {
+		type: "text",
+		text: text.data.text
+	};
+	const media = reportingMediaPartSchema.safeParse(value);
+	if (!media.success) return void 0;
+	return {
+		type: media.data.type,
+		...media.data.mimeType ? { mimeType: media.data.mimeType } : void 0
+	};
+}
+/** Convert allowlisted Pi content parts into the reporting result value. */
+function modelVisibleToolOutput(content) {
+	const sanitized = content.map(sanitizeModelContentPart).filter((part) => part !== void 0);
+	if (sanitized.length === 0) return void 0;
+	if (sanitized.length !== 1) return sanitized;
+	const only = sanitized[0];
+	return only.type === "text" ? only.text : only;
+}
+function reportMessageActorIdentity(data) {
+	if (data.role !== "user") return void 0;
+	const author = reportingMessageAuthorSchema.safeParse(data.meta?.author);
+	if (!author.success) return void 0;
+	const actorIdentity = {
+		...author.data.fullName ? { fullName: author.data.fullName } : void 0,
+		...author.data.userId ? { slackUserId: author.data.userId } : void 0,
+		...author.data.userName ? { slackUserName: author.data.userName } : void 0
+	};
+	return Object.keys(actorIdentity).length > 0 ? actorIdentity : void 0;
+}
+/** Project native assistant tool calls through the existing reporting shape. */
+function reportToolCalls(args) {
+	const message = reportingAssistantMessageSchema.safeParse(args.message);
+	if (!message.success) return void 0;
+	const calls = message.data.content.flatMap((part) => {
+		const call = reportingToolCallPartSchema.safeParse(part);
+		if (!call.success) return [];
+		return [{
+			toolCallId: call.data.id,
+			name: call.data.name,
+			status: "running",
+			startedAt: new Date(args.createdAtMs).toISOString(),
+			startedSeq: args.seq,
+			...args.canExposePayload && call.data.arguments !== void 0 ? { input: call.data.arguments } : void 0
+		}];
+	});
+	return calls.length > 0 ? {
+		type: "tool_calls",
+		calls
+	} : void 0;
+}
+/** Project assistant reasoning with tool ids retained only for display order. */
+function reportAssistantMessage(args) {
+	const message = reportingAssistantMessageSchema.safeParse(args.message);
+	if (!message.success) return void 0;
+	if (!message.data.content.some((part) => {
+		const reasoning = reportingReasoningPartSchema.safeParse(part);
+		return reasoning.success && reasoning.data.redacted !== true && reasoning.data.thinking.trim().length > 0;
+	})) return reportToolCalls(args);
+	const reasoningParts = [];
+	const assistantParts = [];
+	for (const part of message.data.content) {
+		const reasoning = reportingReasoningPartSchema.safeParse(part);
+		if (reasoning.success) {
+			if (reasoning.data.redacted !== true && reasoning.data.thinking.trim().length > 0) {
+				const projected = {
+					type: "reasoning",
+					...args.canExposePayload ? { text: reasoning.data.thinking } : { redacted: true }
+				};
+				reasoningParts.push(projected);
+				assistantParts.push(projected);
+			}
+			continue;
+		}
+		const call = reportingToolCallPartSchema.safeParse(part);
+		if (call.success) assistantParts.push({
+			type: "tool_call",
+			toolCallId: call.data.id
+		});
+	}
+	const toolCalls = reportToolCalls(args);
+	if (toolCalls?.type === "tool_calls") return {
+		...toolCalls,
+		assistant: { parts: assistantParts }
+	};
+	return reasoningParts.length > 0 ? {
+		type: "assistant_message",
+		parts: reasoningParts
+	} : void 0;
+}
+/** Project a native tool result without exposing host-only result details. */
+function reportToolResult(args) {
+	const message = reportingToolResultMessageSchema.safeParse(args.message);
+	if (!message.success) return void 0;
+	const details = reportingToolResultDetailsSchema.safeParse(message.data.details);
+	const outcome = message.data.isError === true || details.success && (details.data.ok === false || details.data.status === "error") ? "error" : "completed";
+	const output = modelVisibleToolOutput(message.data.content);
+	const name = message.data.toolName ?? message.data.name ?? args.start?.name;
+	if (!name) return void 0;
+	return {
+		type: "tool_calls",
+		calls: [{
+			toolCallId: message.data.toolCallId,
+			name,
+			status: outcome,
+			...args.start ? {
+				startedAt: new Date(args.start.createdAtMs).toISOString(),
+				startedSeq: args.start.seq
+			} : void 0,
+			...args.canExposePayload && output !== void 0 ? { output } : void 0
+		}]
+	};
+}
+/** Return tool result ids that may need start metadata from outside a page. */
+function conversationReportToolResultIds(events) {
+	return [...new Set(events.flatMap((event) => {
+		const result = reportingToolResultMessageSchema.safeParse(event.data);
+		return result.success ? [result.data.toolCallId] : [];
+	}))];
+}
+function reportEventData(args) {
+	const { data } = args;
+	if (data.type === "structured_event") {
+		if (!args.canExposePayload) return void 0;
+		const presentation = data.namespace === "junior" ? renderJuniorNativeConversationEvent(data) : renderPluginConversationEvent(data);
+		if (!presentation) return void 0;
+		return {
+			type: "structured_event",
+			namespace: data.namespace,
+			name: data.name,
+			version: data.version,
+			...data.turnId ? { turnId: data.turnId } : void 0,
+			presentation
+		};
+	}
+	switch (data.type) {
+		case "message": {
+			const actorIdentity = args.canExposePayload ? reportMessageActorIdentity(data) : void 0;
+			return {
+				type: "message",
+				messageId: data.messageId,
+				role: data.role,
+				...data.meta?.source === "web" || data.meta?.source === "slack" ? { source: data.meta.source } : void 0,
+				...actorIdentity ? { actorIdentity } : void 0,
+				...typeof data.meta?.eventType === "string" ? { eventType: data.meta.eventType } : void 0,
+				...typeof data.meta?.explicitMention === "boolean" ? { explicitMention: data.meta.explicitMention } : void 0,
+				...args.canExposePayload && typeof data.meta?.trustedSummary === "string" ? { trustedSummary: data.meta.trustedSummary } : void 0,
+				...args.canExposePayload ? { text: data.text } : { redacted: true }
+			};
+		}
+		case "message_handled": return {
+			type: "message_handled",
+			messageId: data.messageId
+		};
+		case "turn_started": return {
+			type: "turn_lifecycle",
+			turnId: data.turnId,
+			state: "started",
+			...data.inputMessageIds.length > 0 ? { inputMessageIds: data.inputMessageIds } : void 0
+		};
+		case "turn_context":
+			if (!args.canExposePayload) return;
+			return {
+				type: "turn_context",
+				turnId: data.turnId,
+				pluginName: data.pluginName,
+				kind: data.kind,
+				version: data.version,
+				content: data.content
+			};
+		case "attachments_delivered":
+			if (!args.canExposePayload) return;
+			return {
+				type: "attachments_delivered",
+				attachments: data.attachments
+			};
+		case "turn_routed": return {
+			type: "turn_routed",
+			turnId: data.turnId,
+			modelProfile: data.modelProfile,
+			modelId: data.modelId,
+			...data.costUsd !== void 0 ? { costUsd: data.costUsd } : void 0,
+			reasoningLevel: data.reasoningLevel,
+			...data.confidence !== void 0 ? { confidence: data.confidence } : void 0,
+			source: data.source
+		};
+		case "guardian_action_reviewed": return {
+			type: "guardian_action_reviewed",
+			turnId: data.turnId,
+			toolCallId: data.toolCallId,
+			toolName: data.toolName,
+			decision: data.decision,
+			riskLevel: data.riskLevel,
+			userAuthorization: data.userAuthorization
+		};
+		case "turn_completed": return {
+			type: "turn_lifecycle",
+			turnId: data.turnId,
+			state: data.outcome === "success" ? "succeeded" : "no_reply"
+		};
+		case "turn_failed": {
+			const eventId = data.eventId;
+			const sentryEventUrl = eventId ? buildSentryEventUrl(eventId) : void 0;
+			return {
+				type: "turn_lifecycle",
+				turnId: data.turnId,
+				state: "failed",
+				failureCode: data.failureCode,
+				...data.failureReason ? { failureReason: data.failureReason } : void 0,
+				...eventId ? { eventId } : void 0,
+				...sentryEventUrl ? { sentryEventUrl } : void 0
+			};
+		}
+		case "compaction": return {
+			type: "compaction",
+			modelProfile: data.modelProfile,
+			modelId: data.modelId,
+			...args.canExposePayload && data.summary ? { summary: data.summary } : void 0,
+			...data.details ? { details: data.details } : void 0
+		};
+		default: return;
+	}
+}
+/**
+* Project canonical events into the ordered reporting boundary.
+*
+* `canExposePayload` must come from the authorized conversation-detail policy;
+* this projection never derives visibility or authorization from event data.
+*/
+function projectConversationReportEventPage(args) {
+	const subagentStarts = /* @__PURE__ */ new Map();
+	for (const event of args.subagentStartEvents ?? []) if (event.data.type === "subagent_started") subagentStarts.set(event.data.subagentInvocationId, {
+		createdAtMs: event.createdAtMs,
+		data: event.data,
+		seq: event.seq
+	});
+	const toolStarts = /* @__PURE__ */ new Map();
+	for (const event of args.toolStartEvents ?? []) if (event.data.type === "tool_execution_started") {
+		const current = toolStarts.get(event.data.toolCallId);
+		if (!current || event.seq < current.seq) toolStarts.set(event.data.toolCallId, {
+			createdAtMs: event.createdAtMs,
+			name: event.data.toolName,
+			seq: event.seq
+		});
+	}
+	const projected = [];
+	for (const event of args.events) {
+		let data;
+		if (event.data.type === "assistant_message" || event.data.type === "tool_result") {
+			const reportArgs = {
+				canExposePayload: args.canExposePayload,
+				createdAtMs: event.createdAtMs,
+				message: event.data,
+				seq: event.seq
+			};
+			const result = reportingToolResultMessageSchema.safeParse(event.data);
+			const start = result.success ? toolStarts.get(result.data.toolCallId) : void 0;
+			data = reportAssistantMessage(reportArgs) ?? reportToolResult({
+				canExposePayload: args.canExposePayload,
+				message: event.data,
+				...start && start.seq < event.seq ? { start } : void 0
+			});
+		} else if (event.data.type === "tool_execution_started") {
+			toolStarts.set(event.data.toolCallId, {
+				createdAtMs: event.createdAtMs,
+				name: event.data.toolName,
+				seq: event.seq
+			});
+			data = {
+				type: "tool_calls",
+				calls: [{
+					toolCallId: event.data.toolCallId,
+					name: event.data.toolName,
+					status: "running",
+					startedAt: new Date(event.createdAtMs).toISOString(),
+					startedSeq: event.seq
+				}]
+			};
+		} else if (event.data.type === "subagent_started") {
+			subagentStarts.set(event.data.subagentInvocationId, {
+				createdAtMs: event.createdAtMs,
+				data: event.data,
+				seq: event.seq
+			});
+			data = {
+				type: "subagent",
+				startedSeq: event.seq,
+				startedAt: new Date(event.createdAtMs).toISOString(),
+				childConversationId: event.data.childConversationId,
+				subagentKind: event.data.subagentKind,
+				status: "running",
+				...event.data.parentToolCallId ? { parentToolCallId: event.data.parentToolCallId } : void 0
+			};
+		} else if (event.data.type === "subagent_ended") {
+			const started = subagentStarts.get(event.data.subagentInvocationId);
+			if (started && started.seq < event.seq) {
+				data = {
+					type: "subagent",
+					startedSeq: started.seq,
+					startedAt: new Date(started.createdAtMs).toISOString(),
+					childConversationId: started.data.childConversationId,
+					subagentKind: started.data.subagentKind,
+					...started.data.parentToolCallId ? { parentToolCallId: started.data.parentToolCallId } : void 0,
+					status: event.data.outcome === "success" ? "completed" : event.data.outcome
+				};
+				subagentStarts.delete(event.data.subagentInvocationId);
+			}
+		} else if (event.data.type === "handoff") data = {
+			type: "handoff",
+			modelProfile: event.data.modelProfile,
+			modelId: event.data.modelId,
+			...event.data.reasoningLevel ? { reasoningLevel: event.data.reasoningLevel } : void 0,
+			...event.data.triggeringToolCallId ? { triggeringToolCallId: event.data.triggeringToolCallId } : void 0,
+			...args.canExposePayload && event.data.summary ? { summary: event.data.summary } : void 0
+		};
+		else data = reportEventData({
+			canExposePayload: args.canExposePayload,
+			data: event.data
+		});
+		if (!data) continue;
+		projected.push(conversationReportEventSchema.parse({
+			seq: event.seq,
+			createdAt: new Date(event.createdAtMs).toISOString(),
+			data
+		}));
+	}
+	return projected;
+}
+//#endregion
+//#region src/api/conversations/event-page.ts
+const conversationEventColumns = getTableColumns(juniorConversationEvents);
+const MIN_SCAN_SIZE = 64;
+/** Read bounded canonical rows while excluding model-only replacement history. */
+async function readConversationEventRows(executor, args) {
+	return executor.db().select({
+		...conversationEventColumns,
+		payload: sql`case
+        when ${juniorConversationEvents.type} in ('compaction', 'handoff')
+        then jsonb_set(
+          ${juniorConversationEvents.payload},
+          '{replacementHistory}',
+          '[]'::jsonb
+        )
+        else ${juniorConversationEvents.payload}
+      end`
+	}).from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, args.conversationId), args.beforeSeq === void 0 ? void 0 : lt(juniorConversationEvents.seq, args.beforeSeq), inArray(juniorConversationEvents.type, args.types ?? [...conversationReportSourceEventTypes]), args.subagentInvocationIds === void 0 ? void 0 : inArray(sql`${juniorConversationEvents.payload}->>'subagentInvocationId'`, args.subagentInvocationIds), args.toolCallIds === void 0 ? void 0 : inArray(sql`${juniorConversationEvents.payload}->>'toolCallId'`, args.toolCallIds))).orderBy(args.direction === "forward" ? asc(juniorConversationEvents.seq) : desc(juniorConversationEvents.seq)).limit(args.limit);
+}
+function decodeConversationEventRow(row) {
+	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: row.payload
+	});
+}
+/** Project stored rows and resolve entity starts that precede the page. */
+async function projectConversationEventRows(executor, args) {
+	const events = args.rows.map(decodeConversationEventRow).sort((left, right) => left.seq - right.seq);
+	const endedInvocationIds = [...new Set(events.flatMap((event) => event.data.type === "subagent_ended" ? [event.data.subagentInvocationId] : []))];
+	const subagentStartRows = endedInvocationIds.length === 0 ? [] : await readConversationEventRows(executor, {
+		conversationId: args.conversationId,
+		direction: "forward",
+		limit: endedInvocationIds.length,
+		subagentInvocationIds: endedInvocationIds,
+		types: ["subagent_started"]
+	});
+	const toolResultIds = conversationReportToolResultIds(events);
+	const toolStartRows = toolResultIds.length === 0 ? [] : await readConversationEventRows(executor, {
+		conversationId: args.conversationId,
+		direction: "forward",
+		limit: toolResultIds.length,
+		toolCallIds: toolResultIds,
+		types: ["tool_execution_started"]
+	});
+	return projectConversationReportEventPage({
+		canExposePayload: args.canExposePayload,
+		events,
+		subagentStartEvents: subagentStartRows.map(decodeConversationEventRow),
+		toolStartEvents: toolStartRows.map(decodeConversationEventRow)
+	});
+}
+/**
+* Read the latest reporting events before an exclusive boundary.
+*
+* Source rows are scanned in bounded chunks until the requested projected page
+* and one older event are known. This keeps ordinary pages bounded without
+* assuming every agent history event produces a reporting event.
+*/
+async function readConversationEventPage(executor, args) {
+	const scanSize = Math.max(args.limit + 1, MIN_SCAN_SIZE);
+	const rows = [];
+	let beforeSeq = args.beforeSeq;
+	let projected = [];
+	while (projected.length <= args.limit) {
+		const batch = await readConversationEventRows(executor, {
+			beforeSeq,
+			conversationId: args.conversationId,
+			direction: "backward",
+			limit: scanSize
+		});
+		if (batch.length === 0) break;
+		rows.push(...batch);
+		projected = await projectConversationEventRows(executor, {
+			canExposePayload: args.canExposePayload,
+			conversationId: args.conversationId,
+			rows
+		});
+		if (projected.length > args.limit || batch.length < scanSize) break;
+		beforeSeq = batch.at(-1).seq;
+	}
+	const events = projected.slice(-args.limit);
+	return {
+		events,
+		...projected.length > events.length && events[0] ? { previousSeq: events[0].seq } : void 0
+	};
+}
+//#endregion
+//#region src/chat/briefs/input.ts
+const EVENT_PAGE_SIZE = 500;
+async function readReportEventsThrough(executor, conversationId, throughSeq) {
+	const pages = [];
+	let beforeSeq = throughSeq + 1;
+	do {
+		const page = await readConversationEventPage(executor, {
+			beforeSeq,
+			canExposePayload: true,
+			conversationId,
+			limit: EVENT_PAGE_SIZE
+		});
+		pages.unshift(page.events);
+		beforeSeq = page.previousSeq;
+	} while (beforeSeq !== void 0);
+	const bySequence = /* @__PURE__ */ new Map();
+	for (const event of pages.flat()) bySequence.set(event.seq, event);
+	return [...bySequence.values()].sort((left, right) => left.seq - right.seq);
+}
+/**
+* Build generator input from SQL through one durable event. The caller owns
+* the boundary, so a Turn that completes during the read cannot be covered by
+* a Brief that never saw it.
+*/
+async function briefInputFromSql(executor, conversationId, throughSeq) {
+	const db = executor.db();
+	const conversation = await createSqlStore(executor).get({ conversationId });
+	if (!conversation) throw new Error(`Conversation ${conversationId} is unavailable`);
+	const [events, annotations, codeChanges] = await Promise.all([
+		readReportEventsThrough(executor, conversationId, throughSeq),
+		listConversationAnnotations(db, conversationId),
+		db.select({
+			closedAt: juniorCodeChanges.closedAt,
+			mergedAt: juniorCodeChanges.mergedAt,
+			number: juniorCodeChanges.number,
+			openedAt: juniorCodeChanges.openedAt,
+			repository: juniorCodeRepositories.name,
+			state: juniorCodeChanges.state,
+			title: juniorCodeChanges.title,
+			url: juniorCodeChanges.url
+		}).from(juniorCodeChanges).innerJoin(juniorCodeRepositories, eq(juniorCodeRepositories.id, juniorCodeChanges.repositoryId)).where(and(arrayContains(juniorCodeChanges.conversationIds, [conversationId]), isNotNull(juniorCodeChanges.url)))
+	]);
+	const location = conversation.location;
+	return parseBriefInput({
+		conversationId,
+		...conversation.title ? { title: conversation.title } : void 0,
+		visibility: conversation.visibility ?? "private",
+		...location ? { location: {
+			provider: location.provider,
+			...conversation.channelName ? { channelName: conversation.channelName } : void 0
+		} } : void 0,
+		entries: briefEntriesFromReportEvents(events),
+		codeChanges: codeChanges.map((change) => ({
+			repository: change.repository,
+			number: change.number,
+			...change.title ? { title: change.title } : void 0,
+			url: change.url,
+			state: change.state,
+			openedAt: change.openedAt.toISOString(),
+			...change.mergedAt ? { mergedAt: change.mergedAt.toISOString() } : void 0,
+			...change.closedAt ? { closedAt: change.closedAt.toISOString() } : void 0
+		})),
+		resources: annotations.map((annotation) => ({
+			label: annotation.label,
+			url: annotation.url,
+			...annotation.status ? { status: annotation.status } : void 0
+		}))
+	});
+}
+//#endregion
+//#region src/chat/briefs/operational-report.ts
+const DAY_MS$1 = 864e5;
+const WINDOWS = [
+	7,
+	30,
+	90
+];
+function startOfUtcDay$1(value) {
+	const date = new Date(value);
+	date.setUTCHours(0, 0, 0, 0);
+	return date;
+}
+function formatCount(value) {
+	return new Intl.NumberFormat("en-US").format(value);
+}
+function formatUsd(value) {
+	const maximumFractionDigits = value > 0 && value < .01 ? 4 : 2;
+	return new Intl.NumberFormat("en-US", {
+		currency: "USD",
+		maximumFractionDigits,
+		minimumFractionDigits: 2,
+		style: "currency"
+	}).format(value);
+}
+/**
+* Build Brief storage and model-cost diagnostics for the System page. Cost
+* comes from retained Conversation events, so spend on purged private
+* Conversations leaves the report with them; the labels say so.
+*/
+async function buildBriefsOperationalReport(args) {
+	const newestDay = startOfUtcDay$1(args.nowMs);
+	const windowStart = /* @__PURE__ */ new Date(newestDay.getTime() - 29 * DAY_MS$1);
+	const windowEnd = new Date(newestDay.getTime() + DAY_MS$1);
+	const [[counts], recentCounts] = await Promise.all([args.db.select({
+		conversations: sql`count(distinct ${juniorConversationBriefs.conversationId})`.mapWith(Number),
+		stored: sql`count(*)`.mapWith(Number)
+	}).from(juniorConversationBriefs), args.db.select({ stored: sql`count(*)`.mapWith(Number) }).from(juniorConversationBriefs).where(and(gte(juniorConversationBriefs.createdAt, windowStart), lt(juniorConversationBriefs.createdAt, windowEnd)))]);
+	const recentDays = args.briefDays.filter((day) => {
+		const dayStart = Date.parse(`${day.date}T00:00:00.000Z`);
+		return dayStart >= windowStart.getTime() && dayStart < windowEnd.getTime();
+	});
+	const recentCost = recentDays.reduce((total, day) => total + day.costUsd, 0);
+	const recentBriefs = recentDays.reduce((total, day) => total + day.events, 0);
+	return {
+		generatedAt: new Date(args.nowMs).toISOString(),
+		title: "Briefs",
+		metrics: [
+			{
+				label: "briefs stored",
+				tone: counts?.stored ? "good" : "neutral",
+				value: formatCount(counts?.stored ?? 0)
+			},
+			{
+				label: "conversations with a brief",
+				value: formatCount(counts?.conversations ?? 0)
+			},
+			{
+				label: "briefs · 30d",
+				value: formatCount(recentCounts[0]?.stored ?? 0)
+			},
+			{
+				label: "cost · 30d · retained",
+				value: formatUsd(recentCost)
+			},
+			{
+				label: "average cost per brief · 30d · retained",
+				value: formatUsd(recentBriefs === 0 ? 0 : recentCost / recentBriefs)
+			}
+		],
+		widgets: [{
+			categories: args.briefDays.map((day) => ({
+				id: day.date,
+				label: day.date,
+				values: {
+					briefs: day.events,
+					costUsd: day.costUsd
+				}
+			})),
+			description: "Stored Brief versions and estimated model cost",
+			id: "briefs-created",
+			series: [{
+				key: "briefs",
+				label: "Briefs"
+			}, {
+				format: "usd",
+				key: "costUsd",
+				label: "Cost"
+			}],
+			timeRangeDays: [...WINDOWS],
+			title: "Briefs created",
+			type: "bar_chart"
+		}]
+	};
+}
+//#endregion
+//#region src/chat/briefs/store.ts
+function briefVersionFromRow(row) {
+	return {
+		conversationId: row.conversationId,
+		version: row.version,
+		turnId: row.turnId,
+		throughSeq: row.throughSeq,
+		content: conversationBriefSchema.parse(row.content),
+		searchText: row.searchText,
+		modelId: row.modelId,
+		...row.costUsd !== null ? { costUsd: row.costUsd } : void 0,
+		createdAt: row.createdAt
+	};
+}
+/** Append the next Brief version, or return the row for an existing Turn. */
+async function appendConversationBrief(db, input) {
+	return await db.transaction(async (tx) => {
+		const conversation = (await tx.select({
+			conversationId: juniorConversations.conversationId,
+			transcriptPurgedAt: juniorConversations.transcriptPurgedAt
+		}).from(juniorConversations).where(eq(juniorConversations.conversationId, input.conversationId)).for("update"))[0];
+		if (!conversation) throw new Error(`Conversation ${input.conversationId} is unavailable`);
+		if (conversation.transcriptPurgedAt) {
+			if ((await resolveRootVisibility({ db: () => tx }, input.conversationId)).visibility !== "public") throw new Error(`Cannot append a Brief to purged non-public Conversation ${input.conversationId}`);
+		}
+		const existing = await tx.select().from(juniorConversationBriefs).where(and(eq(juniorConversationBriefs.conversationId, input.conversationId), eq(juniorConversationBriefs.turnId, input.turnId))).limit(1);
+		if (existing[0]) return {
+			inserted: false,
+			value: briefVersionFromRow(existing[0])
+		};
+		const version = ((await tx.select({ version: max(juniorConversationBriefs.version) }).from(juniorConversationBriefs).where(eq(juniorConversationBriefs.conversationId, input.conversationId)))[0]?.version ?? 0) + 1;
+		const row = (await tx.insert(juniorConversationBriefs).values({
+			conversationId: input.conversationId,
+			version,
+			turnId: input.turnId,
+			throughSeq: input.throughSeq,
+			content: conversationBriefSchema.parse(input.content),
+			searchText: input.searchText,
+			modelId: input.modelId,
+			costUsd: input.costUsd ?? null
+		}).onConflictDoNothing({ target: [juniorConversationBriefs.conversationId, juniorConversationBriefs.turnId] }).returning())[0];
+		if (!row) throw new Error("Brief insert conflicted after the Turn check");
+		return {
+			inserted: true,
+			value: briefVersionFromRow(row)
+		};
+	});
+}
+/** Read the Brief version produced for one completed Turn. */
+async function readConversationBriefForTurn(db, conversationId, turnId) {
+	const rows = await db.select().from(juniorConversationBriefs).where(and(eq(juniorConversationBriefs.conversationId, conversationId), eq(juniorConversationBriefs.turnId, turnId))).limit(1);
+	return rows[0] ? briefVersionFromRow(rows[0]) : void 0;
+}
+/** Read the latest Brief version for one Conversation. */
+async function readLatestConversationBrief(db, conversationId) {
+	const rows = await db.select().from(juniorConversationBriefs).where(eq(juniorConversationBriefs.conversationId, conversationId)).orderBy(desc(juniorConversationBriefs.version)).limit(1);
+	return rows[0] ? briefVersionFromRow(rows[0]) : void 0;
+}
+//#endregion
+//#region src/chat/briefs/task.ts
+const BRIEF_LOCK_TTL_MS = 6e5;
+function hasUserInstruction(run) {
+	return run.transcript.some((entry) => entry.type === "message" && entry.role === "user" && entry.provenance?.authority === "instruction");
+}
+function logSkip(context, conversationId, reason) {
+	context.log.info("Brief update skipped", {
+		conversationId,
+		reason
+	});
+}
+async function readTurnCompletedSeq(db, conversationId, turnId) {
+	const seq = (await db.select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(and(eq(juniorConversationEvents.conversationId, conversationId), eq(juniorConversationEvents.type, "turn_completed"), sql`${juniorConversationEvents.payload}->>'turnId' = ${turnId}`)).orderBy(desc(juniorConversationEvents.seq)).limit(1))[0]?.seq;
+	if (seq === void 0) throw new Error(`Completed Turn ${turnId} has no terminal event in Conversation ${conversationId}`);
+	return seq;
+}
+async function emitBriefUpdated(context, stored) {
+	await context.events.emit(briefUpdatedEvent({
+		version: stored.version,
+		modelId: stored.modelId,
+		...stored.costUsd !== void 0 ? { costUsd: stored.costUsd } : void 0,
+		decisions: stored.content.decisions.length,
+		openDecisions: stored.content.openDecisions.length,
+		links: stored.content.links.length
+	}));
+}
+/** Generate and store the next Brief after one completed Turn. */
+async function updateConversationBrief(context) {
+	const run = await context.run.load();
+	if (run.source.kind !== "slack" && run.source.kind !== "web" && run.source.kind !== "local") {
+		logSkip(context, run.conversationId, "unsupported_source");
+		return;
+	}
+	const executor = getSqlExecutor();
+	const conversation = await createSqlStore(executor).get({ conversationId: run.conversationId });
+	if (conversation?.parentConversationId) {
+		logSkip(context, run.conversationId, "child_conversation");
+		return;
+	}
+	if (conversation?.transcriptPurgedAtMs !== void 0) {
+		if ((await resolveRootVisibility(executor, run.conversationId)).visibility !== "public") {
+			logSkip(context, run.conversationId, "purged_private");
+			return;
+		}
+	}
+	if (!hasUserInstruction(run)) {
+		logSkip(context, run.conversationId, "no_user_instruction");
+		return;
+	}
+	await context.state.withLock(`brief:${run.conversationId}`, BRIEF_LOCK_TTL_MS, async () => {
+		const db = context.db;
+		const existing = await readConversationBriefForTurn(db, run.conversationId, run.runId);
+		if (existing) {
+			await emitBriefUpdated(context, existing);
+			logSkip(context, run.conversationId, "turn_already_stored");
+			return;
+		}
+		const terminalSeq = await readTurnCompletedSeq(db, run.conversationId, run.runId);
+		const previous = await readLatestConversationBrief(db, run.conversationId);
+		if (previous && previous.throughSeq >= terminalSeq) {
+			logSkip(context, run.conversationId, "turn_already_covered");
+			return;
+		}
+		const input = await briefInputFromSql(executor, run.conversationId, terminalSeq);
+		const modelId = defaultModelId(botConfig);
+		const generation = await generateBrief({
+			completeObject: (request) => completeObject({
+				...request,
+				modelId,
+				promptName: "junior.brief_update"
+			}),
+			input,
+			previous: previous?.content,
+			prompt: BRIEF_PROMPT,
+			throughIndex: terminalSeq
+		});
+		const stored = await appendConversationBrief(db, {
+			conversationId: run.conversationId,
+			turnId: run.runId,
+			throughSeq: terminalSeq,
+			content: generation.brief,
+			searchText: generation.searchText,
+			modelId,
+			...generation.costUsd !== void 0 ? { costUsd: generation.costUsd } : void 0
+		});
+		await emitBriefUpdated(context, stored.value);
+		if (!stored.inserted) logSkip(context, run.conversationId, "turn_already_stored");
+	});
+}
+/** Core task registration kept outside the installed plugin catalog. */
+const briefsTaskRegistration = {
+	manifest: {
+		name: "briefs",
+		displayName: "Briefs",
+		description: "Durable Conversation Brief generation"
+	},
+	conversationEvents: [briefUpdatedEvent],
+	hooks: { async operationalReport(context) {
+		return await buildBriefsOperationalReport({
+			briefDays: await context.eventStats.costsByDay({
+				days: 90,
+				eventName: "brief_updated"
+			}),
+			db: context.db,
+			nowMs: context.nowMs
+		});
+	} },
+	tasks: { updateBrief: { async run(context) {
+		await updateConversationBrief(context);
+	} } }
+};
+//#endregion
 //#region src/chat/plugins/conversation-events.ts
 function registeredDefinition(plugin, value) {
 	return plugin.conversationEvents?.find((definition) => definition === value.definition);
@@ -1453,7 +2499,7 @@ function createPluginConversationEvents(args) {
 }
 /** Render a stored plugin event through its currently registered definition. */
 function renderPluginConversationEvent(args) {
-	const definition = getPlugins().find((candidate) => candidate.manifest.name === args.namespace)?.conversationEvents?.find((candidate) => candidate.eventName === args.name && candidate.version === args.version);
+	const definition = [briefsTaskRegistration, ...getPlugins()].find((candidate) => candidate.manifest.name === args.namespace)?.conversationEvents?.find((candidate) => candidate.eventName === args.name && candidate.version === args.version);
 	if (!definition) return void 0;
 	return definition.renderEvent(definition.parse(args.content));
 }
@@ -1664,7 +2710,7 @@ function createPluginState(plugin, adapter) {
 	};
 }
 //#endregion
-//#region src/chat/slack/dashboard-link.ts
+//#region src/chat/dashboard-link.ts
 let dashboardConversationLinkOptions;
 function withHttps(host) {
 	return /^https?:\/\//.test(host) ? host : `https://${host}`;
@@ -1687,7 +2733,7 @@ function resolveDashboardBaseURL(config) {
 	if (vercelUrl) return stripTrailingSlashes(withHttps(vercelUrl));
 	return "http://localhost:3000";
 }
-/** Configure core dashboard links used in Slack footers. */
+/** Configure core dashboard links. */
 function setDashboardConversationLinkOptions(options) {
 	const previous = dashboardConversationLinkOptions;
 	dashboardConversationLinkOptions = options?.disabled ? void 0 : options;
@@ -3091,6 +4137,28 @@ function createCodeChangePublisher(provider) {
 	};
 }
 //#endregion
+//#region src/chat/briefs/registration.ts
+var registration_exports = /* @__PURE__ */ __exportAll({
+	coreTaskRegistrations: () => coreTaskRegistrations,
+	isBriefsEnabled: () => isBriefsEnabled,
+	setBriefsConfig: () => setBriefsConfig
+});
+let configuredBriefs = {};
+/** Replace app-level Brief settings and return the previous setting. */
+function setBriefsConfig(config) {
+	const previous = { ...configuredBriefs };
+	configuredBriefs = config ? { ...config } : {};
+	return previous;
+}
+/** Return whether automatic Brief generation is enabled. */
+function isBriefsEnabled() {
+	return configuredBriefs.enabled === true;
+}
+/** Return enabled core task registrations. */
+function coreTaskRegistrations() {
+	return isBriefsEnabled() ? [briefsTaskRegistration] : [];
+}
+//#endregion
 //#region src/chat/plugins/agent-hooks.ts
 var agent_hooks_exports = /* @__PURE__ */ __exportAll({
 	PluginHookDeniedError: () => PluginHookDeniedError,
@@ -3815,7 +4883,7 @@ function failedOperationalReport(args) {
 /** Collect read-only operational summaries exposed by plugins. */
 async function getPluginOperationalReports(nowMs) {
 	const reports = [];
-	for (const plugin of getPlugins()) {
+	for (const plugin of [...coreTaskRegistrations(), ...getPlugins()]) {
 		const pluginName = plugin.manifest.name;
 		const hook = plugin.hooks?.operationalReport;
 		if (!hook) continue;
@@ -4037,4 +5105,4 @@ function createPluginHookRunner(input = {}) {
 	};
 }
 //#endregion
-export { RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS as $, bindEventTaskCredentialSubject as A, sanitizePostgresJson as At, getSlackClient as B, parseDestination as Bt, setWorkspaceSnapshotBuild as C, getConversationEventStore as Ct, tryWorkspaceRepoCheckoutPath as D, getSqlExecutor as Dt, getWorkspaceSnapshotBuilder as E, getDb as Et, verifySlackDirectCredentialSubject as F, resolveRootConversationId as Ft, withSlackRetries as G, isDmChannel as H, sameDestination as Ht, SlackActionError as I, deleteProviderIdentityForSlackUser as It, findUserByEmail as J, getWorkspaceTeamId as K, downloadPrivateSlackFile as L, upsertIdentity as Lt, bindSlackDirectCredentialSubject as M, locationFromRow as Mt, verifyEventTaskCredentialSubject as N, bindProviderConversation as Nt, workspaceRepoCheckoutPath as O, createSqlConversationEventStore as Ot, verifyScheduledTaskCredentialSubject as P, parseSessionSource as Pt, getSlackToolContext as Q, getFilePermalink as R, upsertLinkedIdentity as Rt, setWorkspaceSnapshot as S, db_exports as St, deleteWorkspaceSnapshotBuilders as T, getConversationStore as Tt, normalizeSlackConversationId as U, isConversationScopedChannel as V, requireSlackDestination as Vt, runWithSlackInstallationToken as W, resolveViewerUser as X, readActorIdentity as Y, updateViewerDisplayName as Z, listWorkspaces as _, createPluginLogger as _t, getPluginRoutes as a, collectResourceEventMatchKeys as at, invalidateReadySnapshot as b, listConversationAnnotations as bt, getPluginTools as c, findMatchingResourceEventSubscriptions as ct, setPlugins as d, getDashboardConversationLink as dt, RESOURCE_SUBSCRIPTION_MAX_TTL_MS as et, validatePlugins as f, getDashboardTaskLink as ft, getWorkspaceByName as g, createPluginModel as gt, getWorkspace as h, createPluginEmbedder as ht, getPluginApiRoutes as i, cancelSubscriptions as it, bindScheduledTaskCredentialSubject as j, withConversationMutationLock as jt, resolveChannelCapabilities as k, withConversationEventLock as kt, getPluginUserPromptContributions as l, listResourceEventSubscriptions as lt, deleteWorkspace as m, createPluginState as mt, applyPluginFormatMarkdown as n, STOP_WATCHING_TOOL_NAME as nt, getPluginSlackConversationLink as o, createResourceEventSubscription as ot, createWorkspace as p, setDashboardConversationLinkOptions as pt, runWithWorkspaceTeamId as q, createPluginHookRunner as r, cancelResourceEventSubscription as rt, getPluginSystemPromptContributions as s, deliverResourceEventSubscription as st, agent_hooks_exports as t, RESOURCE_WATCH_TOOL_SOURCE as tt, getPlugins as u, JUNIOR_THREAD_STATE_TTL_MS as ut, updateWorkspace as v, createPluginConversationEvents as vt, SANDBOX_RUNTIME as w, getConversationMessageSearchStore as wt, loadSnapshotsForProfile as x, listConversationAnnotationsById as xt, WorkspaceValidationError as y, renderPluginConversationEvent as yt, getHeaderString as z, createSlackDestination as zt };
+export { resolveViewerUser as $, tryWorkspaceRepoCheckoutPath as A, authenticationLinkedEvent as At, downloadPrivateSlackFile as B, sanitizePostgresJson as Bt, invalidateReadySnapshot as C, readConversationEventPage as Ct, SANDBOX_RUNTIME as D, listConversationAnnotationsById as Dt, setWorkspaceSnapshotBuild as E, listConversationAnnotations as Et, bindSlackDirectCredentialSubject as F, getConversationStore as Ft, isDmChannel as G, resolveRootConversationId as Gt, getHeaderString as H, locationFromRow as Ht, verifyEventTaskCredentialSubject as I, getDb as It, withSlackRetries as J, upsertLinkedIdentity as Jt, normalizeSlackConversationId as K, deleteProviderIdentityForSlackUser as Kt, verifyScheduledTaskCredentialSubject as L, getSqlExecutor as Lt, resolveChannelCapabilities as M, db_exports as Mt, bindEventTaskCredentialSubject as N, getConversationEventStore as Nt, deleteWorkspaceSnapshotBuilders as O, JUNIOR_NATIVE_EVENT_NAMESPACE as Ot, bindScheduledTaskCredentialSubject as P, getConversationMessageSearchStore as Pt, readActorIdentity as Q, sameDestination as Qt, verifySlackDirectCredentialSubject as R, createSqlConversationEventStore as Rt, WorkspaceValidationError as S, readLatestConversationBrief as St, setWorkspaceSnapshot as T, resolveRootVisibility as Tt, getSlackClient as U, bindProviderConversation as Ut, getFilePermalink as V, withConversationMutationLock as Vt, isConversationScopedChannel as W, parseSessionSource as Wt, runWithWorkspaceTeamId as X, parseDestination as Xt, getWorkspaceTeamId as Y, createSlackDestination as Yt, findUserByEmail as Z, requireSlackDestination as Zt, deleteWorkspace as _, createPluginState as _t, getPluginRoutes as a, STOP_WATCHING_TOOL_NAME as at, listWorkspaces as b, createPluginLogger as bt, getPluginTools as c, collectResourceEventMatchKeys as ct, setPlugins as d, findMatchingResourceEventSubscriptions as dt, updateViewerDisplayName as et, validatePlugins as f, listResourceEventSubscriptions as ft, createWorkspace as g, setDashboardConversationLinkOptions as gt, setBriefsConfig as h, getDashboardTaskLink as ht, getPluginApiRoutes as i, RESOURCE_WATCH_TOOL_SOURCE as it, workspaceRepoCheckoutPath as j, authenticationUnlinkedEvent as jt, getWorkspaceSnapshotBuilder as k, agentsInstructionsUpdatedEvent as kt, getPluginUserPromptContributions as l, createResourceEventSubscription as lt, registration_exports as m, getDashboardConversationLink as mt, applyPluginFormatMarkdown as n, RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS as nt, getPluginSlackConversationLink as o, cancelResourceEventSubscription as ot, coreTaskRegistrations as p, JUNIOR_THREAD_STATE_TTL_MS as pt, runWithSlackInstallationToken as q, upsertIdentity as qt, createPluginHookRunner as r, RESOURCE_SUBSCRIPTION_MAX_TTL_MS as rt, getPluginSystemPromptContributions as s, cancelSubscriptions as st, agent_hooks_exports as t, getSlackToolContext as tt, getPlugins as u, deliverResourceEventSubscription as ut, getWorkspace as v, createPluginEmbedder as vt, loadSnapshotsForProfile as w, buildSentryConversationUrl as wt, updateWorkspace as x, createPluginConversationEvents as xt, getWorkspaceByName as y, createPluginModel as yt, SlackActionError as z, withConversationEventLock as zt };