@sentry/junior 0.236.0 → 0.238.0

package/dist/experimental-Qn9rKLgx.js

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+//#region src/chat/experimental.ts
+var experimental_exports = /* @__PURE__ */ __exportAll({
+	EXPERIMENTAL_FEATURES: () => EXPERIMENTAL_FEATURES,
+	getExperimentalFeatures: () => getExperimentalFeatures,
+	isExperimentalFeatureEnabled: () => isExperimentalFeatureEnabled,
+	setExperimentalFeatures: () => setExperimentalFeatures
+});
+/**
+* Known unstable product features that must be opted into explicitly.
+* Add new keys here as features graduate from private experiments; remove them
+* once they become stable defaults.
+*/
+const EXPERIMENTAL_FEATURES = [
+	"operator-tools",
+	"passive-routing",
+	"subagents"
+];
+const EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
+let configuredExperimental = {};
+function isExperimentalFeature(value) {
+	return EXPERIMENTAL_FEATURE_SET.has(value);
+}
+/** Replace app-level experimental opt-ins and return the previous setting. */
+function setExperimentalFeatures(config) {
+	const previous = { ...configuredExperimental };
+	if (config === void 0) {
+		configuredExperimental = {};
+		return previous;
+	}
+	const next = {};
+	for (const [rawName, enabled] of Object.entries(config)) {
+		if (enabled === void 0) continue;
+		if (typeof enabled !== "boolean") throw new Error(`experimental.${rawName} must be a boolean when provided`);
+		if (!isExperimentalFeature(rawName)) throw new Error(`experimental.${rawName} is not a known experimental feature. Known features: ${EXPERIMENTAL_FEATURES.join(", ")}`);
+		next[rawName] = enabled;
+	}
+	configuredExperimental = next;
+	return previous;
+}
+/** Return a copy of the app-level experimental opt-ins configured by createApp(). */
+function getExperimentalFeatures() {
+	return { ...configuredExperimental };
+}
+/** Return whether one experimental feature is enabled via createApp({ experimental }). */
+function isExperimentalFeatureEnabled(feature) {
+	return configuredExperimental[feature] === true;
+}
+//#endregion
+export { setExperimentalFeatures as i, getExperimentalFeatures as n, isExperimentalFeatureEnabled as r, experimental_exports as t };

package/dist/history-BLTUgFYO.js

@@ -0,0 +1,518 @@
+import { l as TURN_REASONING_LEVELS, s as modelProfileSchema } from "./model-profile-BwU8mqwD.js";
+import { z } from "zod";
+import { actorSchema } from "@sentry/junior-plugin-api";
+//#region src/usage-schema.ts
+const usageCostSchema = z.object({
+	input: z.number().finite().nonnegative().optional(),
+	output: z.number().finite().nonnegative().optional(),
+	cacheRead: z.number().finite().nonnegative().optional(),
+	cacheWrite: z.number().finite().nonnegative().optional(),
+	total: z.number().finite().nonnegative().optional()
+}).strict();
+const usageSchema = z.object({
+	inputTokens: z.number().int().nonnegative().optional(),
+	outputTokens: z.number().int().nonnegative().optional(),
+	cachedInputTokens: z.number().int().nonnegative().optional(),
+	cacheCreationTokens: z.number().int().nonnegative().optional(),
+	reasoningTokens: z.number().int().nonnegative().optional(),
+	totalTokens: z.number().int().nonnegative().optional(),
+	cost: usageCostSchema.optional()
+}).strict();
+//#endregion
+//#region src/chat/conversations/provenance.ts
+/**
+* Durable message attribution shared by storage and projections.
+* Attribution never grants credential authority.
+*/
+const conversationMessageAuthoritySchema = z.union([z.literal("instruction"), z.literal("context")]);
+/** Canonical authority and actor metadata for one durable message event. */
+const conversationMessageProvenanceSchema = z.object({
+	authority: conversationMessageAuthoritySchema,
+	actor: actorSchema.optional()
+}).strict();
+/** Build instruction provenance for an optional actor. */
+function instructionProvenanceFor(actor) {
+	return actor ? {
+		authority: "instruction",
+		actor
+	} : { authority: "instruction" };
+}
+/** Unattributed ambient-context provenance for non-instruction messages. */
+const contextProvenance = { authority: "context" };
+function actorIdentityKey(actor) {
+	if (actor.platform === "system") return `system ${actor.name}`;
+	return actor.platform === "slack" ? `slack\u0000${actor.teamId}\u0000${actor.userId}` : `${actor.platform}\u0000${actor.userId}`;
+}
+/** Compare two actors by runtime identity only, never by display metadata. */
+function sameActorIdentity(left, right) {
+	return Boolean(left && right && actorIdentityKey(left) === actorIdentityKey(right));
+}
+/**
+* Return distinct instruction actors in first-seen order for attribution only.
+* Never use this list as credential authority.
+*/
+function instructionActors(provenance) {
+	const seen = /* @__PURE__ */ new Set();
+	const actors = [];
+	for (const entry of provenance) {
+		if (entry.authority !== "instruction" || !entry.actor) continue;
+		const identity = actorIdentityKey(entry.actor);
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		actors.push(entry.actor);
+	}
+	return actors;
+}
+//#endregion
+//#region src/chat/conversations/history-payload.ts
+const messageFieldsSchema = z.record(z.string(), z.unknown());
+const replacementEntrySchema = z.object({ item: z.string() }).passthrough();
+/** Identify history events that store message fields as JSON strings. */
+function isEncodedHistoryType(type) {
+	return type === "user_message" || type === "assistant_message" || type === "tool_result" || type === "handoff" || type === "compaction";
+}
+/** Encode agent history before SQL can change keys or string contents. */
+function encodeHistoryPayload(data) {
+	const { type, ...payload } = data;
+	if (!isEncodedHistoryType(type)) return {
+		schemaVersion: 1,
+		payload
+	};
+	if (data.type === "handoff" || data.type === "compaction") return {
+		schemaVersion: 2,
+		payload: {
+			...payload,
+			replacementHistory: data.replacementHistory.map(({ item, ...entry }) => ({
+				...entry,
+				item: JSON.stringify(item)
+			}))
+		}
+	};
+	const { provenance, ...message } = payload;
+	return {
+		schemaVersion: 2,
+		payload: {
+			message: JSON.stringify(message),
+			provenance,
+			model: message.model,
+			provider: message.provider,
+			usage: message.usage,
+			toolCallId: message.toolCallId
+		}
+	};
+}
+/** Decode stored history for validation by the conversation event schema. */
+function decodeHistoryPayload(type, payload) {
+	const fields = messageFieldsSchema.parse(payload);
+	if (type === "handoff" || type === "compaction") return {
+		...fields,
+		replacementHistory: z.array(replacementEntrySchema).parse(fields.replacementHistory).map(({ item, ...entry }) => ({
+			...entry,
+			item: JSON.parse(item)
+		}))
+	};
+	const message = messageFieldsSchema.parse(JSON.parse(z.string().parse(fields.message)));
+	if (fields.provenance !== void 0) message.provenance = fields.provenance;
+	return message;
+}
+//#endregion
+//#region src/chat/conversations/history.ts
+/**
+* Durable conversation event history port.
+*
+* Events append under the conversation lease in stable sequence order.
+* Compaction and handoff replace the active model history without rewriting
+* prior events. Unsupported stored events remain readable as opaque facts,
+* while malformed known events fail loudly. Provider-specific message fields
+* are validated by the Pi adapter when it restores model context.
+*/
+const userMessageEventDataSchema = z.object({
+	type: z.literal("user_message"),
+	role: z.never().optional(),
+	provenance: conversationMessageProvenanceSchema
+}).passthrough();
+const assistantMessageEventDataSchema = z.object({
+	type: z.literal("assistant_message"),
+	role: z.never().optional()
+}).passthrough();
+const toolResultEventDataSchema = z.object({
+	type: z.literal("tool_result"),
+	role: z.never().optional()
+}).passthrough();
+/**
+* One replayable agent-history item. Junior owns `type` and user provenance,
+* forbids the provider `role` discriminator, and leaves preserved message
+* fields for the Pi adapter to validate when restoring model context.
+*/
+const agentHistoryItemSchema = z.discriminatedUnion("type", [
+	userMessageEventDataSchema,
+	assistantMessageEventDataSchema,
+	toolResultEventDataSchema
+]);
+const nativeReplacementHistoryItemSchema = z.object({
+	item: agentHistoryItemSchema,
+	sourceEventSeq: z.number().int().nonnegative().optional()
+}).strict();
+/**
+* The complete agent history used immediately after a replacement. Later
+* native history events append to it. Replacement entries are replayed model
+* history, not new conversation activity.
+*/
+const replacementHistorySchema = z.array(nativeReplacementHistoryItemSchema);
+const compactionDetailsSchema = z.object({
+	reason: z.literal("capacity"),
+	estimatedInputTokens: z.number().int().nonnegative(),
+	replacementInputTokens: z.number().int().nonnegative().optional(),
+	triggerTokens: z.number().int().nonnegative(),
+	inputLimitTokens: z.number().int().positive(),
+	inputMessageCount: z.number().int().nonnegative(),
+	retainedMessageCount: z.number().int().nonnegative(),
+	summaryChars: z.number().int().nonnegative()
+}).strict();
+const historyReplacementEventDataSchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("handoff"),
+	modelProfile: modelProfileSchema,
+	modelId: z.string().min(1),
+	reasoningLevel: z.string().min(1).optional(),
+	triggeringToolCallId: z.string().min(1).optional(),
+	summary: z.string().min(1).optional(),
+	replacementHistory: replacementHistorySchema
+}).strict(), z.object({
+	type: z.literal("compaction"),
+	modelProfile: modelProfileSchema,
+	modelId: z.string().min(1),
+	details: compactionDetailsSchema.optional(),
+	summary: z.string().min(1).optional(),
+	replacementHistory: replacementHistorySchema
+}).strict()]);
+/** Validate an event that intentionally replaces active model history. */
+const historyReplacementSchema = z.object({
+	data: historyReplacementEventDataSchema,
+	createdAtMs: z.number().finite()
+}).strict();
+const mcpProviderConnectedEventDataSchema = z.object({
+	type: z.literal("mcp_provider_connected"),
+	provider: z.string().min(1),
+	credentialSubjectId: z.string().min(1)
+}).strict();
+const unownedMcpProviderConnectedEventDataSchema = z.object({
+	type: z.literal("mcp_provider_connected_unowned"),
+	provider: z.string().min(1)
+}).strict();
+const authorizationKindSchema = z.union([z.literal("plugin"), z.literal("mcp")]);
+const authorizationRequestedEventDataSchema = z.object({
+	type: z.literal("authorization_requested"),
+	kind: authorizationKindSchema,
+	provider: z.string().min(1),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1),
+	delivery: z.union([z.literal("private_link_sent"), z.literal("private_link_reused")])
+}).strict();
+const authorizationCompletedEventDataSchema = z.object({
+	type: z.literal("authorization_completed"),
+	kind: authorizationKindSchema,
+	provider: z.string().min(1),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1)
+}).strict();
+const toolExecutionStartedEventDataSchema = z.object({
+	type: z.literal("tool_execution_started"),
+	toolCallId: z.string().min(1),
+	toolName: z.string().min(1)
+}).strict();
+const guardianActionReviewedEventDataSchema = z.object({
+	type: z.literal("guardian_action_reviewed"),
+	turnId: z.string().min(1),
+	toolCallId: z.string().min(1),
+	toolName: z.string().min(1),
+	costUsd: z.number().finite().nonnegative().optional(),
+	decision: z.enum([
+		"allow",
+		"ask",
+		"deny"
+	]),
+	riskLevel: z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	]),
+	userAuthorization: z.enum([
+		"high",
+		"medium",
+		"low",
+		"unknown"
+	])
+}).strict();
+const conversationMessageRoleSchema = z.union([
+	z.literal("user"),
+	z.literal("assistant"),
+	z.literal("system")
+]);
+const messageEventDataSchema = z.object({
+	type: z.literal("message"),
+	messageId: z.string().min(1),
+	role: conversationMessageRoleSchema,
+	text: z.string(),
+	authorIdentityId: z.string().min(1).optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+}).strict();
+const messageUpdatedEventDataSchema = messageEventDataSchema.extend({ type: z.literal("message_updated") });
+const messageHandledEventDataSchema = z.object({
+	type: z.literal("message_handled"),
+	messageId: z.string().min(1)
+}).strict();
+const messagesSummarizedEventDataSchema = z.object({
+	type: z.literal("messages_summarized"),
+	historyFromSeq: z.number().int().nonnegative(),
+	compactions: z.array(z.object({
+		coveredMessageCount: z.number().int().nonnegative(),
+		createdAtMs: z.number(),
+		id: z.string().min(1),
+		summary: z.string()
+	}).strict())
+}).strict();
+/** Product surface that owns a durable conversation turn. */
+const conversationTurnSurfaceSchema = z.enum([
+	"slack",
+	"api",
+	"scheduler",
+	"internal"
+]);
+/** Where a failed turn stopped. */
+const conversationTurnFailureCodeSchema = z.enum([
+	"agent_run_failed",
+	"delivery_failed",
+	"model_execution_failed",
+	"persistence_failed"
+]);
+/**
+* Why a failed turn stopped.
+* Values are fixed labels only. Do not store raw exception text.
+*/
+const conversationTurnFailureReasonSchema = z.enum([
+	"auth",
+	"permission",
+	"rate_limit",
+	"capacity",
+	"timeout",
+	"network",
+	"server",
+	"invalid_request",
+	"invalid_response",
+	"quota",
+	"content_policy",
+	"unknown",
+	"empty_output",
+	"tool_errors",
+	"suppressed_output"
+]);
+const turnStartedEventDataSchema = z.object({
+	type: z.literal("turn_started"),
+	turnId: z.string().min(1),
+	inputMessageIds: z.array(z.string().min(1)).min(1),
+	surface: conversationTurnSurfaceSchema
+}).strict().refine((data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length, "turn input message ids must be unique");
+const turnRoutedEventDataSchema = z.object({
+	type: z.literal("turn_routed"),
+	turnId: z.string().min(1),
+	modelProfile: modelProfileSchema,
+	modelId: z.string().min(1),
+	costUsd: z.number().finite().nonnegative().optional(),
+	reasoningLevel: z.enum(TURN_REASONING_LEVELS),
+	confidence: z.number().min(0).max(1).optional(),
+	source: z.enum([
+		"configured",
+		"inherited",
+		"router"
+	])
+}).strict();
+const turnContextEventDataSchema = z.object({
+	type: z.literal("turn_context"),
+	turnId: z.string().min(1),
+	pluginName: z.string().min(1),
+	kind: z.string().min(1).max(64),
+	version: z.number().int().positive(),
+	content: z.record(z.string(), z.unknown())
+}).strict();
+const structuredConversationEventDataSchema = z.object({
+	type: z.literal("structured_event"),
+	namespace: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	name: z.string().regex(/^[a-z][a-z0-9_]*$/),
+	version: z.number().int().positive(),
+	turnId: z.string().min(1).optional(),
+	content: z.record(z.string(), z.unknown())
+}).strict();
+/** Durable attachment metadata on host-owned delivery events. */
+const deliveredAttachmentSchema = z.object({
+	id: z.string().min(1),
+	filename: z.string().min(1),
+	contentType: z.string().min(1),
+	bytes: z.number().int().nonnegative()
+}).strict();
+/** Host-owned transcript item for files delivered to humans this turn. */
+const attachmentsDeliveredEventDataSchema = z.object({
+	type: z.literal("attachments_delivered"),
+	attachments: z.array(deliveredAttachmentSchema).min(1),
+	toolCallId: z.string().min(1).optional(),
+	turnId: z.string().min(1).optional()
+}).strict();
+const turnCompletedEventDataSchema = z.object({
+	type: z.literal("turn_completed"),
+	turnId: z.string().min(1),
+	outcome: z.enum([
+		"success",
+		"no_reply",
+		"cancelled"
+	])
+}).strict();
+const turnFailedEventDataSchema = z.object({
+	type: z.literal("turn_failed"),
+	turnId: z.string().min(1),
+	failureCode: conversationTurnFailureCodeSchema,
+	failureReason: conversationTurnFailureReasonSchema.optional(),
+	eventId: z.string().regex(/^[a-f0-9]{32}$/i).optional()
+}).strict();
+const subagentStartedEventDataSchema = z.object({
+	type: z.literal("subagent_started"),
+	subagentInvocationId: z.string().min(1),
+	subagentKind: z.string().min(1),
+	modelId: z.string().min(1).optional(),
+	parentToolCallId: z.string().min(1).optional(),
+	reasoningLevel: z.string().min(1).optional(),
+	childConversationId: z.string().min(1)
+}).strict();
+const subagentEndedEventDataSchema = z.object({
+	type: z.literal("subagent_ended"),
+	subagentInvocationId: z.string().min(1),
+	outcome: z.union([
+		z.literal("success"),
+		z.literal("error"),
+		z.literal("aborted")
+	]),
+	errorCode: z.string().min(1).optional()
+}).strict();
+/** Prevent ordinary appends from bypassing history-replacement validation. */
+const appendableConversationEventDataSchema = z.union([
+	messageEventDataSchema,
+	messageUpdatedEventDataSchema,
+	agentHistoryItemSchema,
+	mcpProviderConnectedEventDataSchema,
+	authorizationRequestedEventDataSchema,
+	authorizationCompletedEventDataSchema,
+	toolExecutionStartedEventDataSchema,
+	guardianActionReviewedEventDataSchema,
+	messageHandledEventDataSchema,
+	messagesSummarizedEventDataSchema,
+	turnStartedEventDataSchema,
+	turnContextEventDataSchema,
+	structuredConversationEventDataSchema,
+	attachmentsDeliveredEventDataSchema,
+	turnRoutedEventDataSchema,
+	turnCompletedEventDataSchema,
+	turnFailedEventDataSchema,
+	subagentStartedEventDataSchema,
+	subagentEndedEventDataSchema
+]);
+/** Strict event-data contract reused by the SQL row codec. */
+const conversationEventDataSchema = z.union([
+	appendableConversationEventDataSchema,
+	historyReplacementEventDataSchema,
+	unownedMcpProviderConnectedEventDataSchema
+]);
+/** Event type names recognized by current readers and observational queries. */
+const KNOWN_CONVERSATION_EVENT_TYPES = [
+	"message",
+	"message_updated",
+	"user_message",
+	"assistant_message",
+	"tool_result",
+	"mcp_provider_connected",
+	"mcp_provider_connected_unowned",
+	"authorization_requested",
+	"authorization_completed",
+	"tool_execution_started",
+	"guardian_action_reviewed",
+	"message_handled",
+	"messages_summarized",
+	"turn_started",
+	"turn_context",
+	"structured_event",
+	"attachments_delivered",
+	"turn_routed",
+	"turn_completed",
+	"turn_failed",
+	"subagent_started",
+	"subagent_ended",
+	"handoff",
+	"compaction"
+];
+const knownConversationEventTypeSchema = z.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+const unknownConversationEventDataSchema = z.object({
+	type: z.literal("unknown"),
+	originalType: z.string().min(1),
+	payload: z.unknown()
+}).strict();
+const conversationEventEnvelopeSchema = z.object({
+	schemaVersion: z.number().int().nonnegative(),
+	seq: z.number().int().nonnegative(),
+	historyVersion: z.number().int().nonnegative(),
+	idempotencyKey: z.string().min(1).optional(),
+	createdAtMs: z.number().finite()
+}).strict();
+/**
+* Canonical ordered envelope for the durable conversation log.
+* `schemaVersion` is persisted with every physical event row.
+*/
+const conversationEventSchema = z.union([conversationEventEnvelopeSchema.extend({
+	schemaVersion: z.union([z.literal(1), z.literal(2)]),
+	data: conversationEventDataSchema
+}).refine((event) => event.schemaVersion === 1 || isEncodedHistoryType(event.data.type)), conversationEventEnvelopeSchema.extend({ data: unknownConversationEventDataSchema })]);
+const storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
+	type: z.string().min(1),
+	payload: z.unknown()
+});
+/**
+* Decode a physical event row without making old or future event types
+* unreadable. Unsupported rows stay opaque until an upgrade migration defines
+* their semantics; supported events remain strict so corrupt canonical
+* data cannot be mistaken for compatibility data.
+*/
+function decodeStoredConversationEvent(value) {
+	const stored = storedConversationEventSchema.parse(value);
+	const { type, payload, ...envelope } = stored;
+	const knownType = knownConversationEventTypeSchema.safeParse(type).success;
+	if (stored.schemaVersion === 2 && isEncodedHistoryType(type)) return conversationEventSchema.parse({
+		...envelope,
+		data: {
+			...decodeHistoryPayload(type, payload),
+			type
+		}
+	});
+	if (stored.schemaVersion === 1 && knownType) {
+		const data = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? {
+			...payload,
+			type
+		} : { type };
+		return conversationEventSchema.parse({
+			...envelope,
+			data
+		});
+	}
+	return conversationEventSchema.parse({
+		...envelope,
+		data: {
+			type: "unknown",
+			originalType: type,
+			payload
+		}
+	});
+}
+/** Validate an append without permitting model-history replacement events. */
+const newConversationEventSchema = z.object({
+	data: appendableConversationEventDataSchema,
+	idempotencyKey: z.string().min(1).optional(),
+	createdAtMs: z.number().finite()
+}).strict();
+//#endregion
+export { conversationTurnFailureReasonSchema as a, newConversationEventSchema as c, instructionActors as d, instructionProvenanceFor as f, conversationTurnFailureCodeSchema as i, encodeHistoryPayload as l, usageSchema as m, agentHistoryItemSchema as n, decodeStoredConversationEvent as o, sameActorIdentity as p, conversationEventDataSchema as r, historyReplacementSchema as s, KNOWN_CONVERSATION_EVENT_TYPES as t, contextProvenance as u };

package/dist/{images-BdG7zcNf.js → images-puyEuXoY.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { j as storeAttachment, k as readLiveAttachment } from "./agent-runner-uP7QRc4c.js";
-import { nn as getSqlExecutor } from "./agent-hooks-Da_H0jHv.js";
-import "./conversation-9Fxa1Zbq.js";
+import { D as storeAttachment, T as readLiveAttachment } from "./agent-runner-ZS1LHtSR.js";
+import { f as getSqlExecutor } from "./viewer-DsyM9kb9.js";
+import "./conversation-DwD-vquD.js";
 //#region src/chat/attachments/images.ts
 var images_exports = /* @__PURE__ */ __exportAll({
 	decodeInputImages: () => decodeInputImages,

package/dist/instrumentation.js

@@ -1,6 +1,6 @@
-import { N as getDeploymentServiceVersion, P as getDeploymentTelemetryAttributes } from "./logging-B4sKwmCG.js";
+import { N as getDeploymentServiceVersion, P as getDeploymentTelemetryAttributes } from "./logging-BNi_jyHb.js";
 import { _ as vercelAIIntegration, a as getClient, b as withStreamedSpan, c as init, o as getGlobalScope } from "./sentry-CgWZM_kV.js";
-import { n as getCurrentConversationPrivacy } from "./conversation-privacy-au02dyZK.js";
+import { n as getCurrentConversationPrivacy } from "./conversation-privacy-DAYxHp74.js";
 import { t as consumePrivateTraceResultMarker } from "./private-trace-result-BLvBjy_e.js";
 //#region src/chat/sentry-payload-filter.ts
 const PAYLOAD_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([

package/dist/{job-queue-BqXd0ZPV.js → job-queue-BL9stv_E.js}

@@ -1,4 +1,4 @@
-import { i as getChatConfig } from "./config-JR9wke1W.js";
+import { i as getChatConfig } from "./config-DRw358bB.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, timingSafeEqual } from "node:crypto";

package/dist/{logging-B4sKwmCG.js → logging-BNi_jyHb.js}

@@ -1,5 +1,5 @@
 import { d as setTag, f as setUser, h as startSpan, i as getActiveSpan, l as logger, n as captureMessage, p as spanToJSON, s as getTraceData, t as captureException, y as withScope } from "./sentry-CgWZM_kV.js";
-import { t as JUNIOR_VERSION } from "./version-CWkIGcLU.js";
+import { t as JUNIOR_VERSION } from "./version-Chc6bVG5.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import { ConfigError, configureSync, getConfig, getLogger } from "@logtape/logtape";

package/dist/nitro.d.ts

@@ -1,4 +1,4 @@
-import { r as JuniorDashboardOptions } from "./app-MEd7wbF0.js";
+import { r as JuniorDashboardOptions } from "./app-FB2hmHpZ.js";
 import { n as JuniorPluginSet } from "./plugins-CjfUP5gJ.js";
 //#region src/nitro.d.ts
 export type JuniorNitroDashboardOptions = JuniorDashboardOptions;

package/dist/nitro.js

@@ -1,8 +1,8 @@
-import { A as JUNIOR_RETENTION_ROUTE, D as JUNIOR_HEARTBEAT_ROUTE, E as JUNIOR_HEARTBEAT_CRON_SCHEDULE, O as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, T as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, j as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, k as JUNIOR_RETENTION_CRON_SCHEDULE } from "./logging-B4sKwmCG.js";
+import { A as JUNIOR_RETENTION_ROUTE, D as JUNIOR_HEARTBEAT_ROUTE, E as JUNIOR_HEARTBEAT_CRON_SCHEDULE, O as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, T as JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE, j as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, k as JUNIOR_RETENTION_CRON_SCHEDULE } from "./logging-BNi_jyHb.js";
 import { d as resolvePackageDir, t as discoverInstalledPluginPackageContent, u as isValidPackageName } from "./package-discovery-BVvSnQBB.js";
-import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-BqXd0ZPV.js";
+import { o as resolveConversationWorkQueueTopic, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-BL9stv_E.js";
 import { a as pluginRuntimeRegistrationsFromPluginSet, r as pluginCatalogConfigFromPluginSet } from "./plugins-egKWjgue.js";
-import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-DGQEOk1A.js";
+import { t as PLUGIN_TASK_QUEUE_TOPIC } from "./task-queue-Bi2uNATu.js";
 import { n as loadPluginSetFromModule, r as resolvePluginModule } from "./plugin-module-CVvEUSMH.js";
 import path from "node:path";
 import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";

package/dist/{oauth-authorization-BjRN99dc.js → oauth-authorization-Zv1oLB1J.js}

@@ -1,4 +1,4 @@
-import { h as extractAssistantText } from "./checkpoint-DaD7_Gsb.js";
+import { h as extractAssistantText } from "./checkpoint-DWGyJg4c.js";
 //#region src/chat/runtime/turn.ts
 /** Classified Slack turn failure carrying the owning Sentry capture outward. */
 var ConversationTurnBoundaryError = class extends Error {

package/dist/{oauth-callback-server-B_1p98Mb.js → oauth-callback-server-BHtVbKvO.js}

@@ -1,5 +1,5 @@
-import { Pn as createUserTokenStore } from "./agent-runner-uP7QRc4c.js";
-import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-BWTA3LnL.js";
+import { Mn as createUserTokenStore } from "./agent-runner-ZS1LHtSR.js";
+import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-DmRbuyE4.js";
 import { createServer } from "node:http";
 //#region src/chat/local/oauth-callback-server.ts
 const LOCAL_OAUTH_TIMEOUT_MS = 6e5;