@sentry/junior 0.205.0 → 0.207.0

package/dist/{agent-hooks-DXHpTJ4m.js → agent-hooks-BBX9p6aG.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-BOtJQ7Pc.js";
-import { C as withSpan, P as normalizeIdentityEmail, _ as setSpanAttributes, d as logInfo, f as logWarn, u as logException, v as setSpanStatus } from "./logging-BMJzdDlP.js";
+import { a as embedTexts, r as completeObject } from "./client-Bp297GA0.js";
+import { C as withSpan, P as normalizeIdentityEmail, _ as setSpanAttributes, d as logInfo, f as logWarn, u as logException, v as setSpanStatus } from "./logging-Dx0S5k2z.js";
+import { a as getClient$1 } from "./sentry-CD3SdJl-.js";
+import { a as getChatConfig, n as botConfig, s as getSlackBotToken } from "./config-G2gv97R1.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 { _ as parseSlackMessageTs, c as isActorUserId, h as parseSlackTeamId, m as parseSlackChannelReferenceId, u as parseActorUserId } from "./context-Bplcgypl.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-BlUhFL7_.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-T0tXE4zu.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-BZu1Ta06.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-d-fKypxo.js";
+import { n as briefEntriesFromReportEvents, s as generateBrief, t as BRIEF_PROMPT } from "./prompt-x-0ZtTyb.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, eventInputSchema, eventMatchSchema, eventMatches, eventTypeSchema, identitySchema, locationSchema, missingToolAnnotationKeys, normalizeEventIdentifier, pluginEventsSchema, promptContextSchema, promptMessageSchema, sourceSchema, stableEventMatchKey, 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
@@ -203,7 +207,7 @@ function normalizeSessionSource(value) {
 		visibility: value.visibility,
 		conversationId: value.conversationId
 	};
-	if (value.kind === "resource_event" || value.kind === "scheduled_task" || value.kind === "event_task" || value.kind === "plugin_dispatch" || value.kind === "agent_invocation") return;
+	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",
@@ -274,11 +278,11 @@ function systemIdentityFromSource(source) {
 		providerSubjectId: "local-cli",
 		displayName: "Local CLI"
 	};
-	if (source === "resource_event") return {
+	if (source === "event") return {
 		kind: "system",
 		provider: "junior",
-		providerSubjectId: "resource-event",
-		displayName: "Resource Event"
+		providerSubjectId: "event",
+		displayName: "Event"
 	};
 }
 /** Prefer the user actor identity, else a source-derived system identity. */
@@ -399,7 +403,7 @@ function tenantId(value) {
 	return value ?? "";
 }
 function sourceFromValue(value) {
-	if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "resource_event" || value === "scheduler" || value === "slack" || value === "web") return 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;
@@ -1001,7 +1005,7 @@ const HUMAN_INSTRUCTION_PLATFORMS = /* @__PURE__ */ new Set([
 /**
 * Whether one event should restore an archived conversation to the feed.
 *
-* Archive hides finished noise until a human comes back. Resource events,
+* 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.
 */
@@ -1358,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);
@@ -1422,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);
@@ -1455,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));
 }
@@ -1666,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}`;
@@ -1689,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;
@@ -1707,15 +2751,15 @@ function getDashboardConversationLink(conversationId) {
 }
 /** Build the dashboard task detail URL when the core dashboard is enabled. */
 function getDashboardTaskLink(taskId) {
-	return resolveDashboardPath(`/tasks/${encodeURIComponent(taskId)}`);
+	return resolveDashboardPath(`/automations/${encodeURIComponent(taskId)}`);
 }
 //#endregion
 //#region src/chat/state/ttl.ts
 /** Retain expiring conversation/runtime state long enough for resume and dashboard history. */
 const JUNIOR_THREAD_STATE_TTL_MS = 6048e5;
 //#endregion
-//#region src/chat/resource-events/store.ts
-const RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v5";
+//#region src/chat/events/store.ts
+const EVENT_PREFIX = "junior:resource_event_subscription:v5";
 const INDEX_LOCK_TTL_MS = 1e4;
 const SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 const SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
@@ -1730,12 +2774,12 @@ const subscriptionIdIndexSchema = z.array(z.string().min(1));
 const subscriptionSchema = z.object({
 	conversationId: z.string().min(1),
 	createdAtMs: z.number().finite(),
-	events: z.array(resourceEventTypeSchema).min(1),
+	events: z.array(eventTypeSchema).min(1),
 	expiresAtMs: z.number().finite(),
 	id: z.string().min(1),
 	intent: z.string().min(1),
 	label: z.string().min(1),
-	match: resourceEventMatchSchema.optional(),
+	match: eventMatchSchema.optional(),
 	namespace: z.string().min(1),
 	identifier: z.string().min(1),
 	resourceType: z.string().min(1),
@@ -1746,16 +2790,16 @@ function digest(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 32);
 }
 function subscriptionKey(id) {
-	return `${RESOURCE_EVENT_PREFIX}:record:${id}`;
+	return `${EVENT_PREFIX}:record:${id}`;
 }
 function subscriptionLockKey(id) {
-	return `${RESOURCE_EVENT_PREFIX}:lock:${id}`;
+	return `${EVENT_PREFIX}:lock:${id}`;
 }
 function resourceIndexKey(namespace, identifier) {
-	return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${namespace}\0${identifier}`)}`;
+	return `${EVENT_PREFIX}:resource:${digest(`${namespace}\0${identifier}`)}`;
 }
 function conversationIndexKey(conversationId) {
-	return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
+	return `${EVENT_PREFIX}:conversation:${digest(conversationId)}`;
 }
 function indexLockKey(key) {
 	return `${key}:lock`;
@@ -1769,7 +2813,7 @@ async function acquireSubscriptionLock(state, subscriptionId, waitDeadlineMs = D
 	while (true) {
 		const lock = await state.acquireLock(subscriptionLockKey(subscriptionId), SUBSCRIPTION_LOCK_TTL_MS);
 		if (lock) return lock;
-		if (Date.now() >= waitDeadlineMs) throw new Error(`Could not acquire resource event subscription lock for ${subscriptionId}`);
+		if (Date.now() >= waitDeadlineMs) throw new Error(`Could not acquire watch lock for ${subscriptionId}`);
 		await sleep(SUBSCRIPTION_LOCK_RETRY_MS);
 	}
 }
@@ -1783,7 +2827,7 @@ async function withSubscriptionLock(state, subscriptionId, callback, waitDeadlin
 		if (heartbeat) return;
 		heartbeat = state.extendLock(lock, SUBSCRIPTION_LOCK_TTL_MS).then((extended) => {
 			if (extended) heartbeatError = void 0;
-			else lockLostError = /* @__PURE__ */ new Error(`Resource event subscription lock was lost for ${subscriptionId}`);
+			else lockLostError = /* @__PURE__ */ new Error(`Watch lock was lost for ${subscriptionId}`);
 		}).catch((error) => {
 			heartbeatError = error instanceof Error ? error : /* @__PURE__ */ new Error(`Failed to extend subscription lock: ${String(error)}`);
 		}).finally(() => {
@@ -1813,12 +2857,12 @@ async function readSubscriptionIdIndex(state, key) {
 }
 function buildSubscriptionId(input) {
 	const eventKey = [...new Set(input.events)].sort().join("\0");
-	const matchKey = stableResourceEventMatchKey(input.match);
+	const matchKey = stableEventMatchKey(input.match);
 	return `resub_${digest(matchKey ? `${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}\0${matchKey}` : `${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}`)}`;
 }
 async function withIndexLock(state, key, callback) {
 	const lock = await state.acquireLock(indexLockKey(key), INDEX_LOCK_TTL_MS);
-	if (!lock) throw new Error(`Could not acquire resource event index lock for ${key}`);
+	if (!lock) throw new Error(`Could not acquire event index lock for ${key}`);
 	try {
 		return await callback();
 	} finally {
@@ -1850,16 +2894,16 @@ function activeAt(subscription, nowMs) {
 	return subscription.status === "active" && subscription.expiresAtMs > nowMs;
 }
 function matchesEvent(subscription, input) {
-	return subscription.namespace === input.namespace && subscription.identifier === input.identifier && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs) && resourceEventMatches(subscription.match, input.data);
+	return subscription.namespace === input.namespace && subscription.identifier === input.identifier && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs) && eventMatches(subscription.match, input.data);
 }
 /** Create or replace the active subscription for one conversation/resource/event set. */
-async function createResourceEventSubscription(input, options = {}) {
+async function createWatch(input, options = {}) {
 	const state = options.state ?? getStateAdapter();
 	await state.connect();
 	const nowMs = options.nowMs ?? Date.now();
 	const events = [...new Set(input.events.map((event) => event.trim()))].filter(Boolean);
-	if (events.length === 0) throw new Error("Resource event subscription requires at least one event");
-	if (input.expiresAtMs <= nowMs) throw new Error("Resource event subscription expiry must be in the future");
+	if (events.length === 0) throw new Error("Watch requires at least one event");
+	if (input.expiresAtMs <= nowMs) throw new Error("Watch expiry must be in the future");
 	const match = input.match && Object.keys(input.match).length > 0 ? input.match : void 0;
 	const id = buildSubscriptionId({
 		conversationId: input.conversationId,
@@ -1890,7 +2934,7 @@ async function createResourceEventSubscription(input, options = {}) {
 	return parsed;
 }
 /** List active subscriptions bound to one conversation. */
-async function listResourceEventSubscriptions(input) {
+async function listWatches(input) {
 	const state = input.state ?? getStateAdapter();
 	await state.connect();
 	const nowMs = input.nowMs ?? Date.now();
@@ -1898,7 +2942,7 @@ async function listResourceEventSubscriptions(input) {
 	return (await Promise.all(ids.map(async (id) => parseSubscription(await state.get(subscriptionKey(id)))))).filter((record) => record !== void 0 && record.conversationId === input.conversationId && activeAt(record, nowMs)).sort((left, right) => left.createdAtMs - right.createdAtMs);
 }
 /** Cancel a current-conversation subscription and remove it from match indexes. */
-async function cancelResourceEventSubscription(input) {
+async function cancelWatch(input) {
 	const state = input.state ?? getStateAdapter();
 	await state.connect();
 	return await withSubscriptionLock(state, input.id, async () => {
@@ -1916,10 +2960,10 @@ async function cancelResourceEventSubscription(input) {
 		return next;
 	});
 }
-/** Cancel every active resource event subscription bound to one conversation. */
+/** Cancel every active watch bound to one conversation. */
 async function cancelSubscriptions(input) {
-	const subscriptions = await listResourceEventSubscriptions(input);
-	for (const subscription of subscriptions) await cancelResourceEventSubscription({
+	const subscriptions = await listWatches(input);
+	for (const subscription of subscriptions) await cancelWatch({
 		conversationId: input.conversationId,
 		id: subscription.id,
 		nowMs: input.nowMs,
@@ -1930,7 +2974,7 @@ async function cancelSubscriptions(input) {
 * Collect match keys from active watches for these identifiers and event types.
 * Does not evaluate match values — only reports keys that filters use.
 */
-async function collectResourceEventMatchKeys(input) {
+async function collectEventMatchKeys(input) {
 	const state = input.state ?? getStateAdapter();
 	await state.connect();
 	const nowMs = input.nowMs ?? Date.now();
@@ -1952,8 +2996,8 @@ async function collectResourceEventMatchKeys(input) {
 	}
 	return [...keys].sort();
 }
-/** Find active subscriptions interested in a normalized resource event. */
-async function findMatchingResourceEventSubscriptions(input) {
+/** Find active subscriptions interested in a normalized event. */
+async function findMatchingWatches(input) {
 	const state = input.state ?? getStateAdapter();
 	await state.connect();
 	const nowMs = input.nowMs ?? Date.now();
@@ -1967,7 +3011,7 @@ async function findMatchingResourceEventSubscriptions(input) {
 	}));
 }
 /** Recheck and deliver a matched subscription while holding its status lock. */
-async function deliverResourceEventSubscription(input) {
+async function deliverWatch(input) {
 	const state = input.state ?? getStateAdapter();
 	await state.connect();
 	return await withSubscriptionLock(state, input.subscription.id, async () => {
@@ -1997,15 +3041,15 @@ async function deliverResourceEventSubscription(input) {
 	}, input.waitDeadlineMs);
 }
 //#endregion
-//#region src/chat/resource-events/tool-support.ts
-/** Default lifetime for temporary resource subscriptions. */
+//#region src/chat/events/tool-support.ts
+/** Default lifetime for temporary watches. */
 const RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS = 12096e5;
-/** Hard upper bound for temporary resource subscriptions. */
+/** Hard upper bound for temporary watches. */
 const RESOURCE_SUBSCRIPTION_MAX_TTL_MS = 2592e6;
 const STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
 const RESOURCE_WATCH_TOOL_SOURCE = {
 	id: "resource-watches",
-	description: "Inspect or stop resource watches for the current conversation."
+	description: "Inspect or stop watches for the current conversation."
 };
 //#endregion
 //#region src/chat/slack/tool-support/context.ts
@@ -2534,24 +3578,24 @@ function verifySlackDirectCredentialSubject(input) {
 	])), binding.signature);
 }
 /** Bind a delegated user subject to one scheduler task dispatch. */
-function bindScheduledTaskCredentialSubject(input) {
+function bindScheduledAutomationCredentialSubject(input) {
 	const secret = getCredentialSubjectSecret();
 	const plugin = input.plugin.trim();
 	const userId = parseActorUserId(input.subject.userId);
-	if (!secret || plugin !== "scheduler" || !userId || input.subject.allowedWhen !== "scheduled-task") return;
+	if (!secret || plugin !== "scheduler" || !userId || input.subject.allowedWhen !== "scheduled-automation") return;
 	const taskId = input.subject.taskId;
 	if (!taskId || taskId !== taskId.trim()) return;
 	return {
 		type: "user",
 		userId,
-		allowedWhen: "scheduled-task",
+		allowedWhen: "scheduled-automation",
 		taskId,
 		binding: {
-			type: "scheduled-task",
+			type: "scheduled-automation",
 			plugin,
 			taskId,
 			signature: signPayload(secret, buildPayload([
-				"scheduled-task",
+				"scheduled-automation",
 				plugin,
 				taskId,
 				userId
@@ -2560,37 +3604,37 @@ function bindScheduledTaskCredentialSubject(input) {
 	};
 }
 /** Verify that a delegated subject was signed for one scheduler task. */
-function verifyScheduledTaskCredentialSubject(input) {
+function verifyScheduledAutomationCredentialSubject(input) {
 	const secret = getCredentialSubjectSecret();
 	const { subject } = input;
 	const binding = subject.binding;
-	if (!secret || input.plugin !== "scheduler" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "scheduled-task" || !subject.taskId || binding.type !== "scheduled-task" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) return false;
+	if (!secret || input.plugin !== "scheduler" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "scheduled-automation" || !subject.taskId || binding.type !== "scheduled-automation" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) return false;
 	return timingSafeMatch(signPayload(secret, buildPayload([
-		"scheduled-task",
+		"scheduled-automation",
 		binding.plugin,
 		binding.taskId,
 		subject.userId
 	])), binding.signature);
 }
-/** Bind a delegated user subject to one event task dispatch. */
-function bindEventTaskCredentialSubject(input) {
+/** Bind a delegated user subject to one event automation dispatch. */
+function bindEventAutomationCredentialSubject(input) {
 	const secret = getCredentialSubjectSecret();
 	const plugin = input.plugin.trim();
 	const userId = parseActorUserId(input.subject.userId);
-	if (!secret || plugin !== "junior" || !userId || input.subject.allowedWhen !== "event-task") return;
+	if (!secret || plugin !== "junior" || !userId || input.subject.allowedWhen !== "event-automation") return;
 	const taskId = input.subject.taskId;
 	if (!taskId || taskId !== taskId.trim()) return;
 	return {
 		type: "user",
 		userId,
-		allowedWhen: "event-task",
+		allowedWhen: "event-automation",
 		taskId,
 		binding: {
-			type: "event-task",
+			type: "event-automation",
 			plugin,
 			taskId,
 			signature: signPayload(secret, buildPayload([
-				"event-task",
+				"event-automation",
 				plugin,
 				taskId,
 				userId
@@ -2598,14 +3642,14 @@ function bindEventTaskCredentialSubject(input) {
 		}
 	};
 }
-/** Verify that a delegated subject was signed for one event task. */
-function verifyEventTaskCredentialSubject(input) {
+/** Verify that a delegated subject was signed for one event automation. */
+function verifyEventAutomationCredentialSubject(input) {
 	const secret = getCredentialSubjectSecret();
 	const { subject } = input;
 	const binding = subject.binding;
-	if (!secret || input.plugin !== "junior" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "event-task" || !subject.taskId || binding.type !== "event-task" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) return false;
+	if (!secret || input.plugin !== "junior" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "event-automation" || !subject.taskId || binding.type !== "event-automation" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) return false;
 	return timingSafeMatch(signPayload(secret, buildPayload([
-		"event-task",
+		"event-automation",
 		binding.plugin,
 		binding.taskId,
 		subject.userId
@@ -3093,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,
@@ -3190,9 +4256,9 @@ function pluginInvocationContext(context) {
 			destination: context.destination,
 			source: context.source
 		};
-		case "resource_event":
-		case "scheduled_task":
-		case "event_task":
+		case "event":
+		case "scheduled_automation":
+		case "event_automation":
 		case "plugin_dispatch":
 		case "agent_invocation": return {
 			...common,
@@ -3296,7 +4362,7 @@ function validatePlugins(plugins) {
 		const name = plugin.manifest.name;
 		if (!PLUGIN_NAME_RE.test(name)) throw new Error(`Plugin name "${name}" must be a lowercase plugin identifier`);
 		if (seen.has(name)) throw new Error(`Duplicate plugin name "${name}"`);
-		if (plugin.resourceEvents !== void 0 && !pluginResourceEventsSchema.safeParse(plugin.resourceEvents).success) throw new Error(`Plugin "${name}" resourceEvents is invalid`);
+		if (plugin.events !== void 0 && !pluginEventsSchema.safeParse(plugin.events).success) throw new Error(`Plugin "${name}" events is invalid`);
 		for (const [taskName, task] of Object.entries(plugin.tasks ?? {})) {
 			if (!PLUGIN_TOOL_NAME_RE.test(taskName)) throw new Error(`Plugin task "${taskName}" from plugin "${name}" must be a camelCase identifier`);
 			if (typeof task.run !== "function") throw new Error(`Plugin task "${taskName}" from plugin "${name}" must define a run function`);
@@ -3451,22 +4517,22 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
 			plugin: pluginName
 		});
 		const mcp = pluginMcpContext(plugin, context);
-		const canSubscribe = Boolean(plugin.resourceEvents) && plugin.resourceEvents?.isEnabled?.() !== false;
-		const resourceEvents = {
+		const canSubscribe = Boolean(plugin.events) && plugin.events?.isEnabled?.() !== false;
+		const events = {
 			canSubscribe,
 			async subscribe(input) {
-				if (!canSubscribe) throw new Error("Resource subscriptions are not available in this conversation.");
-				const registration = plugin.resourceEvents;
+				if (!canSubscribe) throw new Error("Watches are not available in this conversation.");
+				const registration = plugin.events;
 				const resourceType = registration?.resourceTypes.find((candidate) => candidate.type === input.resource.type);
-				if (input.resource.namespace !== pluginName || !resourceType || input.events.length === 0 || input.events.some((eventType) => !resourceType.supportedEvents.includes(eventType))) throw new Error("Resource subscription contains an event or resource that the plugin does not support.");
-				const subscription = await createResourceEventSubscription({
+				if (input.resource.namespace !== pluginName || !resourceType || input.events.length === 0 || input.events.some((eventType) => !resourceType.supportedEvents.includes(eventType))) throw new Error("Watch contains an event or resource that the plugin does not support.");
+				const subscription = await createWatch({
 					conversationId: context.conversationId,
 					events: input.events,
 					expiresAtMs: Date.now() + RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
 					intent: input.intent,
 					label: input.resource.label,
 					namespace: pluginName,
-					identifier: normalizeResourceEventIdentifier(registration, input.resource.identifier),
+					identifier: normalizeEventIdentifier(registration, input.resource.identifier),
 					resourceType: input.resource.type
 				});
 				return {
@@ -3487,7 +4553,7 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
 			egress: context.egress,
 			...mcp ? { mcp } : void 0,
 			model: createPluginModel(pluginName, plugin.model),
-			resourceEvents,
+			events,
 			sandbox,
 			state: createPluginState(pluginName),
 			users: { resolveActor },
@@ -3523,9 +4589,9 @@ function getPluginTools(context, sandbox = createSandboxCapability(context.works
 					source: context.source
 				};
 				break;
-			case "resource_event":
-			case "scheduled_task":
-			case "event_task":
+			case "event":
+			case "scheduled_automation":
+			case "event_automation":
 			case "plugin_dispatch":
 			case "agent_invocation": pluginContext = {
 				...common,
@@ -3571,10 +4637,10 @@ function routeMethods(route, pluginName) {
 	if (methods.includes("ALL") && methods.length > 1) throw new Error(`Plugin route "${route.path}" from plugin "${pluginName}" must not combine ALL with explicit methods`);
 	return methods;
 }
-function requirePublishedResourceEvent(plugin, eventType) {
-	const registration = plugin.resourceEvents;
-	if (!registration || registration.isEnabled?.() === false) throw new Error(`Plugin "${plugin.manifest.name}" cannot publish resource events without an active registration`);
-	if (!registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))) throw new Error(`Plugin "${plugin.manifest.name}" did not register resource event "${eventType}"`);
+function requirePublishedEvent(plugin, eventType) {
+	const registration = plugin.events;
+	if (!registration || registration.isEnabled?.() === false) throw new Error(`Plugin "${plugin.manifest.name}" cannot publish events without an active registration`);
+	if (!registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))) throw new Error(`Plugin "${plugin.manifest.name}" did not register event "${eventType}"`);
 }
 /** Collect route handlers exposed by plugins for app-level mounting. */
 function getPluginRoutes(options) {
@@ -3593,33 +4659,33 @@ function getPluginRoutes(options) {
 				plugin: pluginName
 			}) },
 			codeChanges: createCodeChangePublisher(pluginName),
-			resourceEvents: {
+			events: {
 				async hasMatch(event) {
-					if (!options.resourceEvents.hasMatch) return false;
-					const parsed = resourceEventInputSchema.parse(event);
-					requirePublishedResourceEvent(plugin, parsed.eventType);
-					return await options.resourceEvents.hasMatch({
+					if (!options.events.hasMatch) return false;
+					const parsed = eventInputSchema.parse(event);
+					requirePublishedEvent(plugin, parsed.eventType);
+					return await options.events.hasMatch({
 						...parsed,
-						identifier: normalizeResourceEventIdentifier(plugin.resourceEvents, parsed.identifier),
+						identifier: normalizeEventIdentifier(plugin.events, parsed.identifier),
 						namespace: pluginName
 					});
 				},
 				async neededMatchKeys(input) {
-					if (!options.resourceEvents.neededMatchKeys) return [];
-					const identifiers = [...new Set(input.identifiers.map((identifier) => normalizeResourceEventIdentifier(plugin.resourceEvents, identifier)).filter(Boolean))];
+					if (!options.events.neededMatchKeys) return [];
+					const identifiers = [...new Set(input.identifiers.map((identifier) => normalizeEventIdentifier(plugin.events, identifier)).filter(Boolean))];
 					if (identifiers.length === 0 || input.eventTypes.length === 0) return [];
-					return await options.resourceEvents.neededMatchKeys({
+					return await options.events.neededMatchKeys({
 						eventTypes: input.eventTypes,
 						identifiers,
 						namespace: pluginName
 					});
 				},
 				async publish(event) {
-					const parsed = resourceEventInputSchema.parse(event);
-					requirePublishedResourceEvent(plugin, parsed.eventType);
-					await options.resourceEvents.publish({
+					const parsed = eventInputSchema.parse(event);
+					requirePublishedEvent(plugin, parsed.eventType);
+					await options.events.publish({
 						...parsed,
-						identifier: normalizeResourceEventIdentifier(plugin.resourceEvents, parsed.identifier),
+						identifier: normalizeEventIdentifier(plugin.events, parsed.identifier),
 						namespace: pluginName
 					});
 				}
@@ -3817,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;
@@ -3960,6 +5026,7 @@ function createPluginHookRunner(input = {}) {
 				paths.add(key);
 			}
 			const sandboxCapability = createSandboxCapability(sandbox, signal);
+			const finalizers = [];
 			for (const plugin of loaded) {
 				const hook = plugin.hooks?.workspacePrepare;
 				if (!hook) continue;
@@ -3968,12 +5035,16 @@ function createPluginHookRunner(input = {}) {
 					repo: repo.repo
 				}));
 				if (selected.length === 0) continue;
-				await hook({
+				const finalize = await hook({
 					...basePluginContext(plugin),
 					repos: selected,
 					sandbox: sandboxCapability
 				});
+				if (finalize) finalizers.push(finalize);
 			}
+			return async () => {
+				for (const finalize of finalizers) await finalize();
+			};
 		},
 		async prepareSandbox(sandbox) {
 			const sandboxCapability = createSandboxCapability(sandbox);
@@ -4039,4 +5110,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, verifyEventAutomationCredentialSubject as I, getDb as It, withSlackRetries as J, upsertLinkedIdentity as Jt, normalizeSlackConversationId as K, deleteProviderIdentityForSlackUser as Kt, verifyScheduledAutomationCredentialSubject as L, getSqlExecutor as Lt, resolveChannelCapabilities as M, db_exports as Mt, bindEventAutomationCredentialSubject as N, getConversationEventStore as Nt, deleteWorkspaceSnapshotBuilders as O, JUNIOR_NATIVE_EVENT_NAMESPACE as Ot, bindScheduledAutomationCredentialSubject 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, collectEventMatchKeys as ct, setPlugins as d, findMatchingWatches as dt, updateViewerDisplayName as et, validatePlugins as f, listWatches 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, createWatch as lt, registration_exports as m, getDashboardConversationLink as mt, applyPluginFormatMarkdown as n, RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS as nt, getPluginSlackConversationLink as o, cancelSubscriptions 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, cancelWatch as st, agent_hooks_exports as t, getSlackToolContext as tt, getPlugins as u, deliverWatch 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 };