@sentry/junior 0.203.0 → 0.205.0

package/dist/checkpoint-CrViJ8Ps.js

@@ -0,0 +1,2450 @@
+import { D as unwrapCurrentInstruction, O as escapeXml, b as resolveGatewayModel, n as botConfig, v as completeText } from "./config-BOtJQ7Pc.js";
+import { _ as setSpanAttributes, f as logWarn, o as getActiveTraceId, t as buildTurnFailureResponse, u as logException } from "./logging-BMJzdDlP.js";
+import { _ as parseSlackMessageTs, f as toStoredSlackActor } from "./context-B45_WqVX.js";
+import { At as sanitizePostgresJson, Ct as getConversationEventStore, Dt as getSqlExecutor, Nt as bindProviderConversation, Ot as createSqlConversationEventStore, Tt as getConversationStore, kt as withConversationEventLock } from "./agent-hooks-DXHpTJ4m.js";
+import { d as instructionProvenanceFor, l as contextProvenance, n as agentHistoryItemSchema, u as instructionActors } from "./history-CqTuSAdI.js";
+import { c as generateShortTitle, d as agentsInstructionsUpdatedEvent, f as authenticationLinkedEvent, o as ToolInputError, p as authenticationUnlinkedEvent, s as fallbackShortTitle, t as addAgentTurnUsage, u as JUNIOR_NATIVE_EVENT_NAMESPACE } from "./usage-B5SfMb3H.js";
+import { A as sleep, D as fenceLock, M as SANDBOX_REPOS_ROOT, P as SANDBOX_WORKSPACE_ROOT, T as MUTATION_LOCK_TTL_MS, k as withLock, w as getStateAdapter } from "./profile-T0tXE4zu.js";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { actorSchema, sourceSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/pi/messages.ts
+/** Permissive schema for durable Pi SDK messages whose content shape may evolve. */
+const piMessageSchema = z.object({ role: z.string() }).passthrough().transform((value) => value);
+z.object({
+	content: z.array(z.unknown()),
+	role: z.string().min(1)
+}).passthrough().transform((value) => value);
+//#endregion
+//#region src/chat/turn-context-tag.ts
+/**
+* Canonical tag name for the runtime turn context block injected into Pi
+* messages. Shared between prompt assembly and turn context stripping to keep
+* both in sync without requiring the full prompt module.
+*/
+const TURN_CONTEXT_TAG = "runtime-turn-context";
+//#endregion
+//#region src/chat/pi/transcript.ts
+const RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
+const AGENTS_INSTRUCTIONS_START = "# AGENTS.md instructions";
+function userMessageContent(message) {
+	const record = message;
+	return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
+}
+function isRuntimeTurnContextPart(part) {
+	return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && (part.text.startsWith(RUNTIME_TURN_CONTEXT_START) || part.text.startsWith(AGENTS_INSTRUCTIONS_START));
+}
+function hasCurrentInstruction(message) {
+	return userMessageContent(message)?.some((part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.includes("<current-instruction")) ?? false;
+}
+function messageTimestamp$1(message) {
+	return message.timestamp;
+}
+function isStandaloneRuntimeContextMessage(messages, index) {
+	const message = messages[index];
+	const next = messages[index + 1];
+	return Boolean(message && next && userMessageContent(message) && userMessageContent(next) && messageTimestamp$1(message) === messageTimestamp$1(next) && !hasCurrentInstruction(message) && hasCurrentInstruction(next));
+}
+const EMBEDDED_THREAD_CONTEXT_PATTERN = new RegExp(`<(${[
+	"thread-context",
+	"recent-thread-messages",
+	"thread-compactions",
+	"thread-transcript",
+	"thread-background"
+].join("|")})(?:\\s[^>]*)?>[\\s\\S]*</\\1>`, "g");
+/** Type guard for Pi SDK assistant messages. */
+function isAssistantMessage(value) {
+	return typeof value === "object" && value !== null && value.role === "assistant";
+}
+/** Type guard for Pi SDK tool result messages. */
+function isToolResultMessage(value) {
+	return typeof value === "object" && value !== null && value.role === "toolResult";
+}
+/** Check whether a tool result carries an error flag. */
+function isToolResultError(result) {
+	if (!result || typeof result !== "object") return false;
+	return Boolean(result.isError);
+}
+/** Extract the tool name from a raw tool result message. */
+function normalizeToolNameFromResult(result) {
+	if (!result || typeof result !== "object") return void 0;
+	const record = result;
+	if (typeof record.toolName === "string" && record.toolName.length > 0) return record.toolName;
+	if (typeof record.name === "string" && record.name.length > 0) return record.name;
+}
+/** Extract role string from a raw Pi message. */
+function getPiMessageRole(value) {
+	if (!value || typeof value !== "object") return;
+	const role = value.role;
+	return typeof role === "string" ? role : void 0;
+}
+/** Return whether Pi can continue directly from the current history tail. */
+function isContinuablePiBoundary(messages) {
+	const lastRole = getPiMessageRole(messages.at(-1));
+	return lastRole === "user" || lastRole === "toolResult";
+}
+/** Concatenate text content parts from an assistant message. */
+function extractAssistantText(message) {
+	return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+/** Return assistant messages that belong to the terminal post-tool reply phase. */
+function getTerminalAssistantMessages(messages) {
+	let lastNonAssistantIndex = -1;
+	for (let index = messages.length - 1; index >= 0; index -= 1) if (!isAssistantMessage(messages[index])) {
+		lastNonAssistantIndex = index;
+		break;
+	}
+	return messages.slice(lastNonAssistantIndex + 1).filter(isAssistantMessage);
+}
+/** Remove trailing assistant messages before committing a resumable boundary. */
+function trimTrailingAssistantMessages(messages) {
+	let end = messages.length;
+	while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") end -= 1;
+	return end === messages.length ? [...messages] : messages.slice(0, end);
+}
+/** Return whether Pi history already carries session bootstrap context. */
+function hasRuntimeTurnContext(messages) {
+	return messages.some((message, index) => isStandaloneRuntimeContextMessage(messages, index) || userMessageContent(message)?.some(isRuntimeTurnContextPart));
+}
+/** Keep only volatile bootstrap messages needed by an in-turn context replacement. */
+function retainRuntimeTurnContext(messages) {
+	return messages.flatMap((message, index) => {
+		if (isStandaloneRuntimeContextMessage(messages, index)) return [message];
+		const runtimeContent = userMessageContent(message)?.filter(isRuntimeTurnContextPart) ?? [];
+		return runtimeContent.length > 0 ? [{
+			...message,
+			content: runtimeContent
+		}] : [];
+	});
+}
+/**
+* Reduce a runtime user-turn prompt to only the current turn's instruction.
+*
+* Live user prompts embed prior-thread context as `<thread-context
+* authority="evidence-only">` (or legacy transcript/background blocks) beside
+* the `<current-instruction>` block. Those blocks hold other participants'
+* verbatim messages, so completed-run projections consumed by plugins must
+* expose only the instruction authored by this turn's actor — otherwise
+* per-entry provenance can be defeated by reading another user's text out of an
+* instruction-authority entry. Prior thread context is projected separately as
+* per-author context-authority entries, so dropping it here is non-lossy for
+* plugins. This is projection-only; it never touches what the model sees during
+* a live run.
+*/
+function instructionTextForProjection(text) {
+	const withoutContext = text.replace(EMBEDDED_THREAD_CONTEXT_PATTERN, "").trim();
+	return unwrapCurrentInstruction(withoutContext) ?? withoutContext;
+}
+/** Return the projected instruction text carried by one user message. */
+function getUserMessageInstructionText(message) {
+	if (getPiMessageRole(message) !== "user") return "";
+	const content = message.content;
+	return instructionTextForProjection(typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n") : "").trim();
+}
+/** Remove volatile runtime context before reusing messages as history. */
+function stripRuntimeTurnContext(messages) {
+	return messages.flatMap((message, index) => {
+		if (isStandaloneRuntimeContextMessage(messages, index)) return [];
+		const content = userMessageContent(message);
+		if (!content) return [message];
+		const nextContent = content.filter((part) => !isRuntimeTurnContextPart(part));
+		if (nextContent.length === content.length) return [message];
+		if (nextContent.length === 0) return [];
+		return [{
+			...message,
+			content: nextContent
+		}];
+	});
+}
+//#endregion
+//#region src/chat/pi/conversation-events.ts
+function authorizationObservationMessage(data, createdAtMs) {
+	const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
+	return piMessageSchema.parse({
+		role: "user",
+		content: [{
+			type: "text",
+			text: `${label} completed for provider "${data.provider}". Continue the blocked request and retry the provider operation if needed.`
+		}],
+		timestamp: createdAtMs
+	});
+}
+function durableMessages(message) {
+	return stripRuntimeTurnContext([message]);
+}
+/** Translate one Pi message into Junior's native durable history item. */
+function historyItemFromPiMessage(message, provenance) {
+	const { role, ...fields } = piMessageSchema.parse(message);
+	if (role === "user") return agentHistoryItemSchema.parse({
+		...fields,
+		type: "user_message",
+		provenance
+	});
+	if (role === "assistant") return agentHistoryItemSchema.parse({
+		...fields,
+		type: "assistant_message"
+	});
+	if (role === "toolResult") return agentHistoryItemSchema.parse({
+		...fields,
+		type: "tool_result"
+	});
+	throw new Error(`Unsupported durable agent message role "${role}"`);
+}
+/** Translate one Junior-native history item into the Pi message it represents. */
+function piMessageFromHistoryItem(data) {
+	if (data.type === "user_message") {
+		const { type: _, provenance: __, ...fields } = data;
+		return piMessageSchema.parse({
+			...fields,
+			role: "user"
+		});
+	}
+	if (data.type === "assistant_message") {
+		const { type: _, ...fields } = data;
+		return piMessageSchema.parse({
+			...fields,
+			role: "assistant"
+		});
+	}
+	const { type: _, ...fields } = data;
+	return piMessageSchema.parse({
+		...fields,
+		role: "toolResult"
+	});
+}
+function historyItemProvenance(data) {
+	return data.type === "user_message" ? data.provenance : contextProvenance;
+}
+/**
+* Project ordered Junior events into Pi context.
+*
+* Compaction and handoff start with replacement history. Later native history
+* events append after it.
+*
+* Host-only events are filtered, completed authorization becomes a synthetic
+* observation, and `maxSeq` reproduces an exact committed boundary.
+*/
+function projectConversationEvents(events, options) {
+	const messages = [];
+	const provenance = [];
+	const seqs = [];
+	let modelProfile = options.defaultProfile;
+	let replacementSeq;
+	for (const event of events) {
+		if (options.maxSeq !== void 0 && event.seq > options.maxSeq) break;
+		if (event.data.type === "unknown") throw new Error(`Unsupported conversation event "${event.data.originalType}" at seq ${event.seq} (schema version ${event.schemaVersion})`);
+		if (event.data.type === "compaction" || event.data.type === "handoff") {
+			modelProfile = event.data.modelProfile;
+			replacementSeq = event.seq;
+			for (const replacement of event.data.replacementHistory) for (const message of durableMessages(piMessageFromHistoryItem(replacement.item))) {
+				messages.push(message);
+				provenance.push(historyItemProvenance(replacement.item));
+				seqs.push(replacement.sourceEventSeq ?? event.seq);
+			}
+			continue;
+		}
+		if (event.data.type === "user_message" || event.data.type === "assistant_message" || event.data.type === "tool_result") {
+			for (const message of durableMessages(piMessageFromHistoryItem(event.data))) {
+				messages.push(message);
+				provenance.push(historyItemProvenance(event.data));
+				seqs.push(event.seq);
+			}
+			continue;
+		}
+		if (event.data.type === "authorization_completed") {
+			messages.push(authorizationObservationMessage(event.data, event.createdAtMs));
+			provenance.push(contextProvenance);
+			seqs.push(event.seq);
+		}
+	}
+	return {
+		messages,
+		provenance,
+		seqs,
+		modelProfile,
+		replacementSeq
+	};
+}
+//#endregion
+//#region src/chat/services/context-budget.ts
+const COMPACTION_TRIGGER_RATIO = .9;
+const CONTEXT_INPUT_LIMIT_RATIO = .95;
+const COMPACTION_TARGET_RATIO = .8;
+const FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+function positiveInteger$1(value, fallback) {
+	return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+/** Estimate text tokens with the shared coarse heuristic used for local budgets. */
+function estimateTextTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+/** Derive the automatic compaction threshold from model context capacity. */
+function calculateContextCompactionTriggerTokens(model) {
+	const contextWindow = positiveInteger$1(model.contextWindow, FALLBACK_CONTEXT_WINDOW_TOKENS);
+	return Math.max(1, Math.floor(contextWindow * COMPACTION_TRIGGER_RATIO));
+}
+/** Derive the maximum estimated input size with room for uncounted request overhead. */
+function calculateContextInputLimitTokens(model) {
+	const contextWindow = positiveInteger$1(model.contextWindow, FALLBACK_CONTEXT_WINDOW_TOKENS);
+	return Math.max(1, Math.floor(contextWindow * CONTEXT_INPUT_LIMIT_RATIO));
+}
+/** Derive the post-compaction target from the automatic trigger threshold. */
+function calculateContextCompactionTargetTokens(triggerTokens) {
+	return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+/** Cap one model's advertised context capacity with the host bot configuration. */
+function getModelContextBudget(modelId) {
+	const advertisedContextWindow = positiveInteger$1(resolveGatewayModel(modelId).contextWindow, FALLBACK_CONTEXT_WINDOW_TOKENS);
+	return { contextWindow: Math.min(botConfig.contextWindowTokens, advertisedContextWindow) };
+}
+/** Resolve the automatic compaction threshold for the active agent model. */
+function getAgentContextCompactionTriggerTokens(modelId) {
+	return calculateContextCompactionTriggerTokens(getModelContextBudget(modelId));
+}
+/** Resolve the hard input ceiling for the active agent model. */
+function getAgentContextInputLimitTokens(modelId) {
+	return calculateContextInputLimitTokens(getModelContextBudget(modelId));
+}
+/** Resolve the visible conversation compaction threshold for the auxiliary model. */
+function getConversationContextCompactionTriggerTokens() {
+	return calculateContextCompactionTriggerTokens(getModelContextBudget(botConfig.fastModelId));
+}
+//#endregion
+//#region src/chat/services/conversation-memory.ts
+const CONTEXT_MIN_LIVE_MESSAGES = 12;
+const CONTEXT_COMPACTION_BATCH_SIZE = 24;
+const CONTEXT_MAX_COMPACTIONS = 16;
+const CONTEXT_MAX_MESSAGE_CHARS = 3200;
+const SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function generateConversationId(prefix) {
+	return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Normalize message boundaries without changing transcript formatting. */
+function normalizeConversationText(text) {
+	return text.replace(/\r\n?/g, "\n").trim();
+}
+function buildImageContextSuffix(message, conversation) {
+	const byFileId = conversation?.vision.byFileId;
+	const imageFileIds = message.meta?.imageFileIds ?? [];
+	if (!byFileId || imageFileIds.length === 0) return "";
+	const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
+	if (summaries.length === 0) return "";
+	return ` [image context: ${escapeXml(summaries.join(" | "))}]`;
+}
+function renderConversationMessageLine(message, conversation) {
+	const displayName = escapeXml(conversationAuthorDisplayName(message));
+	const text = escapeXml(message.text.replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS));
+	const markers = [];
+	if (message.meta?.replied === false) markers.push(escapeXml(`assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`));
+	if (message.meta?.explicitMention) markers.push("explicit mention");
+	const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
+	const imageContext = buildImageContextSuffix(message, conversation);
+	return `[${message.role}] ${displayName}: ${text}${imageContext}${markerSuffix}`;
+}
+function conversationAuthorDisplayName(message) {
+	const author = message.author;
+	const fullName = authorDisplayField(author?.fullName, author?.userId);
+	const userName = authorDisplayField(author?.userName, author?.userId);
+	return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
+}
+function authorDisplayField(value, userId) {
+	if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) return;
+	return value;
+}
+/** Estimate the token cost of the current visible conversation context. */
+function estimateConversationContextTokens(conversation) {
+	return estimateTextTokens(buildConversationContext(conversation) ?? "");
+}
+function upsertConversationMessage(conversation, message) {
+	const existingIndex = conversation.messages.findIndex((entry) => entry.id === message.id);
+	if (existingIndex >= 0) {
+		conversation.messages[existingIndex] = {
+			...conversation.messages[existingIndex],
+			...message,
+			meta: {
+				...conversation.messages[existingIndex]?.meta,
+				...message.meta
+			}
+		};
+		return message.id;
+	}
+	conversation.messages.push(message);
+	return message.id;
+}
+/** Record one assistant message after its destination accepts it. */
+function recordDeliveredAssistantMessage(args) {
+	const prefix = `${args.sessionId}:assistant:`;
+	const messageId = `${prefix}${args.conversation.messages.filter((message) => message.id.startsWith(prefix)).length + 1}`;
+	markConversationMessage(args.conversation, args.userMessageId, {
+		replied: true,
+		skippedReason: void 0
+	});
+	upsertConversationMessage(args.conversation, {
+		id: messageId,
+		role: "assistant",
+		text: normalizeConversationText(args.text),
+		createdAtMs: Date.now(),
+		author: {
+			userName: botConfig.userName,
+			isBot: true
+		},
+		meta: {
+			replied: true,
+			...args.source ? { source: args.source } : void 0
+		}
+	});
+	return messageId;
+}
+/** Return whether a turn already has a destination-accepted assistant reply. */
+function turnHasReply(conversation, turnId) {
+	const assistantPrefix = `${turnId}:assistant:`;
+	return conversation.messages.some((message) => message.role === "assistant" && message.id.startsWith(assistantPrefix));
+}
+function markConversationMessage(conversation, messageId, patch) {
+	if (!messageId) return;
+	const messageIndex = conversation.messages.findIndex((entry) => entry.id === messageId);
+	if (messageIndex < 0) return;
+	const current = conversation.messages[messageIndex];
+	conversation.messages[messageIndex] = {
+		...current,
+		meta: {
+			...current.meta ?? {},
+			...patch
+		}
+	};
+}
+/**
+* Render thread history as structured XML. Each compaction and message is
+* wrapped with index/ts metadata so the model can reference prior items
+* individually instead of treating the whole block as one flat narrative.
+*/
+function buildConversationContext(conversation, options = {}) {
+	const messages = conversation.messages.filter((entry) => entry.id !== options.excludeMessageId);
+	if (messages.length === 0 && conversation.compactions.length === 0) return;
+	const lines = [];
+	if (conversation.compactions.length > 0) {
+		lines.push("<thread-compactions>");
+		for (const [index, compaction] of conversation.compactions.entries()) lines.push(`  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageCount}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`, compaction.summary, "  </compaction>");
+		lines.push("</thread-compactions>");
+	}
+	if (messages.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("<thread-context authority=\"evidence-only\">");
+		for (const [index, message] of messages.entries()) {
+			const author = escapeXml(conversationAuthorDisplayName(message));
+			const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
+			const ts = new Date(message.createdAtMs).toISOString();
+			const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+			lines.push(`  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`, renderConversationMessageLine(message, conversation), "  </message>");
+		}
+		lines.push("</thread-context>");
+	}
+	return lines.join("\n");
+}
+const THREAD_CONTEXT_OPEN = "<thread-context authority=\"evidence-only\">";
+const THREAD_CONTEXT_CLOSE = "</thread-context>";
+/**
+* Keep ambient history as one evidence-only block.
+*
+* When durable context already ends a thread-context envelope, append message
+* lines inside that envelope. Otherwise wrap the new messages in one envelope.
+*/
+function appendThreadContextMessages(baseContext, messageLines) {
+	const base = baseContext?.trim();
+	if (messageLines.length === 0) return base || void 0;
+	const entryBlock = messageLines.join("\n");
+	if (!base) return [
+		THREAD_CONTEXT_OPEN,
+		entryBlock,
+		THREAD_CONTEXT_CLOSE
+	].join("\n");
+	const closeIdx = base.lastIndexOf(THREAD_CONTEXT_CLOSE);
+	if (closeIdx >= 0) return `${base.slice(0, closeIdx).replace(/\s*$/, "")}\n${entryBlock}\n${base.slice(closeIdx)}`;
+	return [
+		base,
+		"",
+		THREAD_CONTEXT_OPEN,
+		entryBlock,
+		THREAD_CONTEXT_CLOSE
+	].join("\n");
+}
+function pruneCompactions(compactions) {
+	if (compactions.length <= CONTEXT_MAX_COMPACTIONS) return compactions;
+	const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
+	const merged = compactions.slice(0, overflowCount);
+	const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
+	const coveredMessageCount = merged.reduce((count, entry) => count + entry.coveredMessageCount, 0);
+	return [{
+		id: generateConversationId("compaction"),
+		createdAtMs: Date.now(),
+		summary: mergedSummary,
+		coveredMessageCount
+	}, ...compactions.slice(overflowCount)];
+}
+async function summarizeConversationChunk(messages, conversation, context, deps) {
+	const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
+	try {
+		const summary = (await deps.completeText({
+			modelId: botConfig.fastModelId,
+			temperature: 0,
+			promptName: "junior.thread_compaction",
+			messages: [{
+				role: "user",
+				content: [
+					"Summarize the following older Slack thread transcript segment for future assistant turns.",
+					"Keep the summary factual and concise. Do not invent details.",
+					"",
+					"Output exactly three XML sections in this order:",
+					"<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+					"<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
+					"<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+					"",
+					"Do not output any text outside the three sections.",
+					"",
+					transcript
+				].join("\n"),
+				timestamp: Date.now()
+			}],
+			metadata: {
+				modelId: botConfig.fastModelId,
+				threadId: context.threadId ?? "",
+				channelId: context.channelId ?? "",
+				actorId: context.actorId ?? "",
+				runId: context.runId ?? ""
+			}
+		})).text.trim();
+		if (summary.length > 0) return summary.slice(0, 3500);
+	} catch (error) {
+		logWarn("conversation.compaction.summary.failed", {
+			"exception.message": error instanceof Error ? error.message : String(error),
+			"app.compaction_messages_covered": messages.length
+		});
+	}
+	return transcript.slice(0, 2800);
+}
+/** Return the earliest human-authored message known for a thread. */
+function getThreadTitleSourceMessage(conversation) {
+	let firstMessage;
+	for (const message of conversation.messages) {
+		if (!isHumanConversationMessage(message)) continue;
+		if (!firstMessage) {
+			firstMessage = message;
+			continue;
+		}
+		if (message.createdAtMs < firstMessage.createdAtMs) {
+			firstMessage = message;
+			continue;
+		}
+		if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) firstMessage = message;
+	}
+	return firstMessage;
+}
+async function compactConversationIfNeededWithDeps(conversation, context, deps) {
+	let estimatedTokens = estimateConversationContextTokens(conversation);
+	setSpanAttributes({ "app.context_tokens_estimated": estimatedTokens });
+	const triggerTokens = getConversationContextCompactionTriggerTokens();
+	const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
+	while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+		const compactCount = Math.min(CONTEXT_COMPACTION_BATCH_SIZE, conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES);
+		if (compactCount <= 0) break;
+		const compactedChunk = conversation.messages.slice(0, compactCount);
+		const summary = await summarizeConversationChunk(compactedChunk, conversation, context, deps);
+		conversation.compactions.push({
+			id: generateConversationId("compaction"),
+			createdAtMs: Date.now(),
+			summary,
+			coveredMessageCount: compactedChunk.length
+		});
+		conversation.compactions = pruneCompactions(conversation.compactions);
+		conversation.messages = conversation.messages.slice(compactCount);
+		estimatedTokens = estimateConversationContextTokens(conversation);
+		setSpanAttributes({
+			"app.compaction_messages_covered": compactCount,
+			"app.compaction.trigger_tokens": triggerTokens,
+			"app.compaction.target_tokens": targetTokens,
+			"app.context_tokens_estimated": estimatedTokens
+		});
+		if (estimatedTokens <= targetTokens) break;
+	}
+}
+/** Build the service that owns durable conversation memory compaction. */
+function createConversationMemoryService(deps) {
+	return { compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps) };
+}
+function isHumanConversationMessage(message) {
+	return message.role === "user" && message.author?.isBot !== true;
+}
+/** Return the native Slack timestamp for a persisted conversation message. */
+function getConversationMessageSlackTs(message) {
+	return parseSlackMessageTs(message.meta?.slackTs);
+}
+//#endregion
+//#region src/chat/services/conversation-title.ts
+const inFlightTitles = /* @__PURE__ */ new Map();
+/**
+* Set-once conversation title from the earliest human message.
+*
+* One automatic generation path for every surface. Starts only from durable
+* transcript writes via `scheduleConversationTitle`. Returns a newly persisted
+* title, or undefined when the conversation is already titled or generation
+* does not apply.
+*/
+async function ensureConversationTitle(args) {
+	const pending = inFlightTitles.get(args.conversationId);
+	if (pending) return pending;
+	const work = ensureConversationTitleOnce(args).finally(() => {
+		inFlightTitles.delete(args.conversationId);
+	});
+	inFlightTitles.set(args.conversationId, work);
+	return work;
+}
+async function ensureConversationTitleOnce(args) {
+	if (!args.conversation.messages.some(isHumanConversationMessage)) return;
+	const store = args.conversationStore ?? getConversationStore();
+	try {
+		const stored = await store.get({ conversationId: args.conversationId });
+		if (stored?.title?.trim()) return;
+		if (stored?.parentConversationId) return;
+		const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
+		const sourceText = titleSourceMessage?.text.trim() ?? "";
+		if (!titleSourceMessage || !sourceText) return;
+		let title;
+		try {
+			title = await generateShortTitle({
+				completeText,
+				kind: "conversation",
+				sourceText
+			}) ?? fallbackShortTitle(sourceText, "Conversation");
+		} catch (error) {
+			logWarn("conversation.title.generation.failed", { "exception.message": error instanceof Error ? error.message : String(error) });
+			title = fallbackShortTitle(sourceText, "Conversation");
+		}
+		const normalized = title.trim();
+		if (!normalized) return;
+		const activityAtMs = titleSourceMessage.createdAtMs;
+		const nowMs = args.nowMs ?? Date.now();
+		try {
+			await store.recordActivity({
+				activityAtMs,
+				conversationId: args.conversationId,
+				nowMs,
+				title: normalized
+			});
+		} catch (error) {
+			logException(error, "conversation.title.persist.failed");
+			return;
+		}
+		return normalized;
+	} catch (error) {
+		logException(error, "conversation.title.ensure.failed");
+		return;
+	}
+}
+/**
+* Fire-and-forget title work after durable human transcript writes.
+* This is the only entry that starts generation.
+*/
+function scheduleConversationTitle(args) {
+	if (!args.conversationId) return;
+	ensureConversationTitle({
+		conversation: args.conversation,
+		conversationId: args.conversationId
+	}).catch((error) => {
+		logException(error, "conversation.title.task.failed");
+	});
+}
+/**
+* Join in-flight generation when present, otherwise read the stored title.
+* Does not start generation; providers use this only to project a title.
+*/
+async function resolveConversationTitle(args) {
+	const pending = inFlightTitles.get(args.conversationId);
+	if (pending) {
+		const generated = await pending;
+		if (generated?.trim()) return generated.trim();
+	}
+	return (await (args.conversationStore ?? getConversationStore()).get({ conversationId: args.conversationId }))?.title?.trim() || void 0;
+}
+//#endregion
+//#region src/chat/conversations/message-summaries.ts
+/** Project the latest source-message summary snapshot from event history. */
+function projectConversationMessageSummaries(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const data = events[index]?.data;
+		if (data?.type === "messages_summarized") return data.compactions;
+	}
+	return [];
+}
+/** Persist a changed source-message summary snapshot in event history. */
+async function persistConversationMessageSummaries(args) {
+	const eventStore = getConversationEventStore();
+	const history = await eventStore.loadMessageHistory(args.conversationId);
+	const existing = history.compaction ? projectConversationMessageSummaries([history.compaction]) : [];
+	if (isDeepStrictEqual(existing, args.conversation.compactions)) return;
+	const liveMessageIds = new Set(args.conversation.messages.map((message) => message.id));
+	const nextHistoryFromSeq = history.events.find((event) => event.data.type === "message" && liveMessageIds.has(event.data.messageId))?.seq ?? Math.max(history.historyFromSeq, (history.events.at(-1)?.seq ?? -1) + 1);
+	await eventStore.append(args.conversationId, [{
+		data: {
+			type: "messages_summarized",
+			historyFromSeq: nextHistoryFromSeq,
+			compactions: args.conversation.compactions
+		},
+		createdAtMs: args.conversation.compactions.at(-1)?.createdAtMs ?? Date.now()
+	}]);
+}
+//#endregion
+//#region src/chat/conversations/message-projection.ts
+function isMessageEvent(event) {
+	return event.data.type === "message" || event.data.type === "message_updated" || event.data.type === "message_handled";
+}
+function splitMeta(meta) {
+	const rest = { ...meta ?? {} };
+	const author = rest.author;
+	delete rest.author;
+	return {
+		...author ? { author } : void 0,
+		...Object.keys(rest).length > 0 ? { meta: rest } : void 0
+	};
+}
+function missingBaselineError(event) {
+	return /* @__PURE__ */ new Error(`Message event ${event.data.type} at seq ${event.seq} references ${event.data.messageId} before message`);
+}
+/** Reduce a boundary-bearing message-history suffix into destination history. */
+function projectConversationMessages(history) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const event of history.events) {
+		if (!isMessageEvent(event)) continue;
+		const data = event.data;
+		const current = byId.get(data.messageId);
+		if (data.type === "message" || data.type === "message_updated") {
+			const message = {
+				id: data.messageId,
+				role: data.role,
+				text: data.text,
+				createdAtMs: event.createdAtMs,
+				...splitMeta(data.meta)
+			};
+			if (data.type === "message" && current) throw new Error(`Duplicate message event for ${data.messageId} at seq ${event.seq}`);
+			if (data.type === "message_updated" && !current) {
+				if (history.historyFromSeq > 0) continue;
+				throw missingBaselineError(event);
+			}
+			byId.set(data.messageId, {
+				message: {
+					...message,
+					createdAtMs: current?.message.createdAtMs ?? message.createdAtMs
+				},
+				...current?.repliedAtMs === void 0 ? void 0 : { repliedAtMs: current.repliedAtMs }
+			});
+			continue;
+		}
+		if (!current) {
+			if (history.historyFromSeq > 0) continue;
+			throw missingBaselineError(event);
+		}
+		current.repliedAtMs ??= event.createdAtMs;
+	}
+	return [...byId.values()].map(({ message, repliedAtMs }) => {
+		if (repliedAtMs === void 0) return message;
+		return {
+			...message,
+			meta: {
+				...message.meta ?? {},
+				replied: true
+			}
+		};
+	});
+}
+//#endregion
+//#region src/chat/conversations/messages.ts
+/**
+* Conversation-message persistence and hydration.
+*/
+/** Serialize one in-memory message into its event-backed write shape. */
+function toStoredConversationMessage(message) {
+	const meta = {};
+	if (message.author) meta.author = message.author;
+	const { replied, ...restMeta } = message.meta ?? {};
+	Object.assign(meta, restMeta);
+	if (replied === false) meta.replied = false;
+	return {
+		messageId: message.id,
+		role: message.role,
+		text: message.text,
+		...Object.keys(meta).length > 0 ? { meta } : void 0,
+		createdAtMs: message.createdAtMs
+	};
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)]));
+}
+function messageStateKey(message) {
+	return createHash("sha256").update(JSON.stringify(canonicalJson(message))).digest("hex").slice(0, 32);
+}
+/** Hydrate the current message working set from canonical conversation events. */
+async function hydrateConversationMessages(args) {
+	if (!args.conversationId) {
+		args.conversation.messages = [];
+		return;
+	}
+	const history = await getConversationEventStore().loadMessageHistory(args.conversationId);
+	args.conversation.compactions = history.compaction ? projectConversationMessageSummaries([history.compaction]) : [];
+	args.conversation.messages = projectConversationMessages(history);
+}
+/** Append new messages and handled markers idempotently. */
+async function persistConversationMessages(args) {
+	if (!args.conversationId || args.conversation.messages.length === 0) return;
+	await appendConversationMessages(getConversationEventStore(), {
+		...args,
+		conversationId: args.conversationId
+	});
+	scheduleConversationTitle({
+		conversation: args.conversation,
+		conversationId: args.conversationId
+	});
+}
+/** Append visible message facts through a caller-owned event-store transaction. */
+async function appendConversationMessages(eventStore, args) {
+	if (args.conversation.messages.length === 0) return;
+	const history = await eventStore.loadMessageHistory(args.conversationId);
+	const existingMessages = new Map(projectConversationMessages(history).map((message) => [message.id, message]));
+	const handledAtMs = args.repliedAtMs ?? Date.now();
+	const events = args.conversation.messages.flatMap((message) => {
+		const stored = toStoredConversationMessage(message);
+		const existing = existingMessages.get(stored.messageId);
+		const changed = existing !== void 0 && !isDeepStrictEqual(toStoredConversationMessage(existing), stored);
+		return [...existing ? changed ? [{
+			idempotencyKey: `message:${stored.messageId}:update:${messageStateKey(stored)}`,
+			createdAtMs: handledAtMs,
+			data: {
+				type: "message_updated",
+				messageId: stored.messageId,
+				role: stored.role,
+				text: stored.text,
+				...stored.authorIdentityId ? { authorIdentityId: stored.authorIdentityId } : void 0,
+				...stored.meta ? { meta: stored.meta } : void 0
+			}
+		}] : [] : [{
+			idempotencyKey: `message:${stored.messageId}`,
+			createdAtMs: stored.createdAtMs,
+			data: {
+				type: "message",
+				messageId: stored.messageId,
+				role: stored.role,
+				text: stored.text,
+				...stored.authorIdentityId ? { authorIdentityId: stored.authorIdentityId } : void 0,
+				...stored.meta ? { meta: stored.meta } : void 0
+			}
+		}], ...message.meta?.replied === true ? [{
+			idempotencyKey: `message:${stored.messageId}:handled`,
+			createdAtMs: handledAtMs,
+			data: {
+				type: "message_handled",
+				messageId: stored.messageId
+			}
+		}] : []];
+	});
+	await eventStore.append(args.conversationId, events);
+}
+//#endregion
+//#region src/chat/conversations/projection.ts
+/**
+* Conversation projection orchestration.
+*
+* Materializes Pi agent history and derived run facts such as connected
+* providers. Storage and commit lifecycle stay in the conversations domain;
+* the Pi adapter owns event reduction and opaque-message validation.
+*/
+/** Distinct MCP providers one credential subject connected in the given events, sorted. */
+function connectedMcpProvidersFromEvents(events, credentialSubjectId) {
+	const providers = /* @__PURE__ */ new Set();
+	for (const event of events) if (event.data.type === "mcp_provider_connected" && event.data.credentialSubjectId === credentialSubjectId) providers.add(event.data.provider);
+	return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function isUserMessage(message) {
+	return message.role === "user";
+}
+/** A checkpoint tried to replace already committed agent history. */
+var AgentHistoryBranchError = class extends Error {
+	constructor(conversationId) {
+		super(`Agent history for ${conversationId} changed before its committed boundary`);
+		this.name = "AgentHistoryBranchError";
+	}
+};
+/** Match the exact JSONB shape used for prefix comparison and replay. */
+function normalizeDurableMessage(message) {
+	return piMessageSchema.parse(JSON.parse(JSON.stringify(sanitizePostgresJson(message))));
+}
+/**
+* Identity used for append-only prefix checks.
+*
+* Pi may mutate already-committed assistant envelopes in place (usage,
+* stopReason, provider metadata). Append checkpoints must still accept the
+* new suffix when role, timestamp, and durable content match.
+*/
+function durableMessageIdentity(message) {
+	const record = message;
+	if (record.role === "toolResult") return {
+		role: "toolResult",
+		timestamp: record.timestamp,
+		toolCallId: record.toolCallId,
+		toolName: record.toolName,
+		isError: record.isError,
+		content: record.content
+	};
+	return {
+		role: record.role,
+		timestamp: record.timestamp,
+		content: record.content
+	};
+}
+/**
+* Count how much of `current` is a durable prefix of `next`.
+*
+* Returns `current.length` only when every committed message still matches by
+* durable identity. A shorter `next` or a content/role/timestamp change is a
+* branch that only compaction/handoff may perform.
+*/
+function countDurablePrefix(current, next) {
+	if (next.length < current.length) return countMatchingDeepPrefix(current, next);
+	for (let index = 0; index < current.length; index += 1) if (!isDeepStrictEqual(durableMessageIdentity(current[index]), durableMessageIdentity(next[index]))) return index;
+	return current.length;
+}
+function countMatchingDeepPrefix(left, right) {
+	const limit = Math.min(left.length, right.length);
+	for (let index = 0; index < limit; index += 1) if (!isDeepStrictEqual(left[index], right[index])) return index;
+	return limit;
+}
+/**
+* Resolve the aligned provenance to persist for `nextMessages`.
+*
+* Explicit per-message provenance always wins; otherwise the unchanged prefix
+* reuses its committed provenance, new messages default to unauthored context,
+* and any new-user-message default (the turn author's instruction) attaches to
+* the last new user message — the current turn's input.
+*/
+function resolveCommitProvenance(args) {
+	if (args.explicitProvenance) {
+		if (args.explicitProvenance.length !== args.nextMessages.length) throw new Error("commit provenance must align one-to-one with messages");
+		return args.explicitProvenance;
+	}
+	if (args.existing.provenance.length !== args.existing.messages.length) throw new Error("committed provenance must align one-to-one with messages");
+	const matchingPrefix = args.matchingPrefix;
+	const provenance = args.nextMessages.map((_, index) => index < matchingPrefix ? args.existing.provenance[index] : contextProvenance);
+	if (args.newMessageProvenance) {
+		for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) if (isUserMessage(args.nextMessages[index])) {
+			provenance[index] = args.newMessageProvenance;
+			break;
+		}
+	}
+	if (args.trailingMessageProvenance) {
+		if (args.trailingMessageProvenance.length > provenance.length) throw new Error("trailing commit provenance cannot exceed committed messages");
+		const newMessageCount = args.nextMessages.length - matchingPrefix;
+		if (args.trailingMessageProvenance.length > newMessageCount) throw new Error("trailing commit provenance must align to newly committed messages");
+		const start = provenance.length - args.trailingMessageProvenance.length;
+		args.trailingMessageProvenance.forEach((entry, offset) => {
+			provenance[start + offset] = entry;
+		});
+	}
+	return provenance;
+}
+/** Load the current Pi agent history for a conversation. */
+async function loadProjection(args) {
+	return projectConversationEvents(await getConversationEventStore().loadCurrentHistory(args.conversationId), { defaultProfile: botConfig.defaultProfile }).messages;
+}
+/** Load current Pi context with aligned provenance and source event sequences. */
+async function loadConversationProjection(args) {
+	return projectConversationEvents(await getConversationEventStore().loadCurrentHistory(args.conversationId), { defaultProfile: botConfig.defaultProfile });
+}
+/** Load the active Pi projection before a conversation's next request. */
+async function openConversationProjection(args) {
+	return projectConversationEvents(await getConversationEventStore().loadCurrentHistory(args.conversationId), { defaultProfile: botConfig.defaultProfile });
+}
+/**
+* Load a turn's committed Pi projection from the durable event store.
+*
+* The record stays pinned to the history version containing its committed
+* boundary, so later compaction cannot rewrite what a stale record resumes
+* from. Unfinished records (`includeTail`) also see that version's tail so
+* parked input appended after the last safe boundary is model-visible. Terminal records
+* reproduce exactly the boundary they committed by cutting at `committedSeq`.
+* Returns undefined when the committed boundary no longer exists (purged
+* history) so callers fail closed.
+*/
+async function loadTurnProjection(args) {
+	const eventStore = getConversationEventStore();
+	if (args.committedSeq < 0) return projectConversationEvents(await eventStore.loadCurrentHistory(args.conversationId), { defaultProfile: botConfig.defaultProfile });
+	const historyEvents = await eventStore.loadHistoryContaining(args.conversationId, args.committedSeq, args.includeTail ? void 0 : args.committedSeq);
+	if (!historyEvents) return;
+	return projectConversationEvents(historyEvents, { defaultProfile: botConfig.defaultProfile });
+}
+/** Load MCP providers the credential subject connected in this conversation. */
+async function loadConnectedMcpProviders(args) {
+	return connectedMcpProvidersFromEvents(await getConversationEventStore().loadHistory(args.conversationId), args.credentialSubjectId);
+}
+function messageTimestamp(message) {
+	const timestamp = message.timestamp;
+	return typeof timestamp === "number" ? timestamp : Date.now();
+}
+/**
+* Append newly stable native history items.
+*
+* Checkpoints are append-only against the durable identity of the committed
+* prefix (role, timestamp, content; tool results also match call id). A shorter
+* history or a true content branch is rejected — only compaction and handoff may
+* intentionally replace active model history. In-place Pi mutations of already
+* committed assistant envelopes (usage/stopReason) do not block the suffix.
+*/
+async function commitMessages(args) {
+	const executor = args.executor ?? getSqlExecutor();
+	return await withConversationEventLock(executor, args.conversationId, async () => executor.transaction(async () => await commitMessagesLocked(args, executor)));
+}
+/**
+* Commit an accepted agent reply and its visible message in causal order.
+*
+* The destination has already accepted the reply. One transaction prevents
+* reporting from observing the visible reply before the agent message that
+* produced it.
+*/
+async function commitAcceptedReply(args) {
+	const executor = getSqlExecutor();
+	await withConversationEventLock(executor, args.conversationId, async () => executor.transaction(async () => {
+		if (args.agentMessage) {
+			const agentMessage = normalizeDurableMessage(args.agentMessage);
+			await createSqlConversationEventStore(executor).append(args.conversationId, [{
+				idempotencyKey: `message:${args.conversationMessageId}:agent`,
+				data: historyItemFromPiMessage(agentMessage, contextProvenance),
+				createdAtMs: messageTimestamp(agentMessage)
+			}]);
+		}
+		await appendConversationMessages(createSqlConversationEventStore(executor), {
+			conversation: args.conversation,
+			conversationId: args.conversationId,
+			...args.repliedAtMs === void 0 ? void 0 : { repliedAtMs: args.repliedAtMs }
+		});
+		for (const binding of args.providerConversationBindings ?? []) await bindProviderConversation(executor, {
+			conversationId: args.conversationId,
+			...binding
+		});
+	}));
+}
+async function commitMessagesLocked(args, executor) {
+	const eventStore = createSqlConversationEventStore(executor);
+	const currentEvents = await eventStore.loadCurrentHistory(args.conversationId);
+	const current = projectConversationEvents(currentEvents, { defaultProfile: botConfig.defaultProfile });
+	const nextLocalMessages = stripRuntimeTurnContext(args.messages).map(normalizeDurableMessage);
+	const matchingPrefix = countDurablePrefix(current.messages, nextLocalMessages);
+	const nextLocalProvenance = resolveCommitProvenance({
+		existing: current,
+		nextMessages: nextLocalMessages,
+		matchingPrefix,
+		...args.provenance ? { explicitProvenance: args.provenance } : void 0,
+		...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : void 0,
+		...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : void 0
+	});
+	if (matchingPrefix === current.messages.length) {
+		const newMessages = nextLocalMessages.slice(matchingPrefix);
+		const turnContext = args.turnContext;
+		const turnContextEvents = turnContext?.contexts.map((context, index) => ({
+			idempotencyKey: `turn:${turnContext.turnId}:context:${context.pluginName}:${index}`,
+			createdAtMs: context.loadedAtMs,
+			data: {
+				type: "turn_context",
+				turnId: turnContext.turnId,
+				pluginName: context.pluginName,
+				kind: context.kind,
+				version: context.version,
+				content: context.content
+			}
+		})) ?? [];
+		const appendedEvents = await eventStore.append(args.conversationId, [...newMessages.map((message, index) => ({
+			data: historyItemFromPiMessage(message, nextLocalProvenance[matchingPrefix + index]),
+			createdAtMs: messageTimestamp(message)
+		})), ...turnContextEvents]);
+		const cursor = appendedEvents.at(-1) ?? currentEvents.at(-1);
+		return {
+			committedSeq: cursor?.seq ?? -1,
+			historyVersion: cursor?.historyVersion ?? 0,
+			messageSeqs: [...current.seqs, ...appendedEvents.slice(0, newMessages.length).map((event) => event.seq)],
+			messages: nextLocalMessages,
+			provenance: nextLocalProvenance
+		};
+	}
+	throw new AgentHistoryBranchError(args.conversationId);
+}
+/** Record a successful MCP provider connection for one credential subject without duplicating it. */
+async function recordMcpProviderConnected(args) {
+	const eventStore = getConversationEventStore();
+	if (connectedMcpProvidersFromEvents(await eventStore.loadCurrentHistory(args.conversationId), args.credentialSubjectId).includes(args.provider)) return;
+	await eventStore.append(args.conversationId, [{
+		data: {
+			type: "mcp_provider_connected",
+			provider: args.provider,
+			credentialSubjectId: args.credentialSubjectId
+		},
+		createdAtMs: Date.now()
+	}]);
+}
+/** Record that an OAuth/MCP authorization link was delivered or reused. */
+async function recordAuthorizationRequested(args) {
+	const eventStore = getConversationEventStore();
+	if ((await eventStore.loadCurrentHistory(args.conversationId)).some((event) => event.data.type === "authorization_requested" && event.data.authorizationId === args.authorizationId)) return;
+	await eventStore.append(args.conversationId, [{
+		data: {
+			type: "authorization_requested",
+			kind: args.kind,
+			provider: args.provider,
+			actorId: args.actorId,
+			authorizationId: args.authorizationId,
+			delivery: args.delivery
+		},
+		createdAtMs: Date.now()
+	}]);
+}
+/** Record completed authorization as a chronological host observation for Pi. */
+async function recordAuthorizationCompleted(args) {
+	const eventStore = getConversationEventStore();
+	if ((await eventStore.loadCurrentHistory(args.conversationId)).some((event) => event.data.type === "authorization_completed" && event.data.authorizationId === args.authorizationId)) return;
+	await eventStore.append(args.conversationId, [{
+		data: {
+			type: "authorization_completed",
+			kind: args.kind,
+			provider: args.provider,
+			actorId: args.actorId,
+			authorizationId: args.authorizationId
+		},
+		createdAtMs: Date.now()
+	}]);
+}
+function authenticationEventIdempotencyKey(args) {
+	if (args.authorizationId) return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:authentication_${args.action}:authorization:${args.authorizationId}`;
+	return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:authentication_${args.action}:${args.provider}:actor:${args.actorId}`;
+}
+async function recordAuthenticationAccountChange(action, args) {
+	const definition = action === "linked" ? authenticationLinkedEvent : authenticationUnlinkedEvent;
+	const content = definition.parse({
+		actorId: args.actorId,
+		provider: args.provider,
+		...args.accountLabel ? { accountLabel: args.accountLabel } : void 0,
+		...args.authorizationId ? { authorizationId: args.authorizationId } : void 0,
+		...args.providerLabel ? { providerLabel: args.providerLabel } : void 0
+	});
+	await getConversationEventStore().append(args.conversationId, [{
+		createdAtMs: Date.now(),
+		idempotencyKey: authenticationEventIdempotencyKey({
+			action,
+			actorId: args.actorId,
+			authorizationId: args.authorizationId,
+			provider: args.provider
+		}),
+		data: {
+			type: "structured_event",
+			namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
+			name: definition.eventName,
+			version: definition.version,
+			...args.turnId ? { turnId: args.turnId } : void 0,
+			content
+		}
+	}]);
+}
+/** Record a successful conversation-bound account link as host transcript metadata. */
+async function recordAuthenticationLinked(args) {
+	await recordAuthenticationAccountChange("linked", args);
+}
+async function loadAgentsEvent(conversationId) {
+	const event = await getConversationEventStore().loadLatestStructuredEvent(conversationId, JUNIOR_NATIVE_EVENT_NAMESPACE, agentsInstructionsUpdatedEvent.eventName);
+	if (!event || event.data.type !== "structured_event") return void 0;
+	return {
+		content: agentsInstructionsUpdatedEvent.parse(event.data.content),
+		seq: event.seq
+	};
+}
+function agentsInstructionsIdempotencyKey(args) {
+	const previous = args.previousSeq ?? "none";
+	return `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:agents_instructions_updated:${args.turnId}:${args.action}:${previous}->${args.fingerprint}`;
+}
+/** Record one AGENTS.md bootstrap transition as host transcript metadata. */
+async function recordAgentsInstructionsUpdated(args) {
+	const previous = await loadAgentsEvent(args.conversationId);
+	const instructions = args.instructions;
+	if (previous && (!instructions && previous.content.action === "cleared" || instructions && previous.content.action !== "cleared" && previous.content.fingerprint === instructions.fingerprint && previous.content.directory === instructions.directory)) return;
+	const action = !instructions ? "cleared" : previous && previous.content.action !== "cleared" ? "replaced" : "loaded";
+	const fingerprint = instructions?.fingerprint ?? "cleared";
+	const content = agentsInstructionsUpdatedEvent.parse({
+		action,
+		fingerprint,
+		sources: instructions?.sources ?? [],
+		...instructions ? { directory: instructions.directory } : void 0,
+		...instructions ? { textBytes: Buffer.byteLength(instructions.text, "utf8") } : void 0
+	});
+	await getConversationEventStore().append(args.conversationId, [{
+		createdAtMs: Date.now(),
+		idempotencyKey: agentsInstructionsIdempotencyKey({
+			action,
+			fingerprint,
+			previousSeq: previous?.seq,
+			turnId: args.turnId
+		}),
+		data: {
+			type: "structured_event",
+			namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
+			name: agentsInstructionsUpdatedEvent.eventName,
+			version: agentsInstructionsUpdatedEvent.version,
+			turnId: args.turnId,
+			content
+		}
+	}]);
+}
+/** Record a model-backed subscribed reply route, including no-reply outcomes. */
+async function recordSubscribedReplyRoute(args) {
+	await getConversationEventStore().append(args.conversationId, [{
+		idempotencyKey: `native:${JUNIOR_NATIVE_EVENT_NAMESPACE}:passive_reply_routed:${args.runId}`,
+		createdAtMs: Date.now(),
+		data: {
+			type: "structured_event",
+			namespace: JUNIOR_NATIVE_EVENT_NAMESPACE,
+			name: "passive_reply_routed",
+			version: 1,
+			content: {
+				costUsd: args.costUsd,
+				reason: args.reason,
+				shouldReply: args.shouldReply,
+				...args.shouldUnsubscribe !== void 0 ? { shouldUnsubscribe: args.shouldUnsubscribe } : void 0
+			}
+		}
+	}]);
+}
+/** Load a previously selected model profile for a resumed turn. */
+async function loadTurnRoute(args) {
+	const event = await getConversationEventStore().loadByIdempotencyKey(args.conversationId, `turn:${args.turnId}:routed`);
+	if (!event) return;
+	if (event.data.type !== "turn_routed" || event.data.turnId !== args.turnId) throw new Error(`Turn route key for "${args.turnId}" has invalid data`);
+	return {
+		...event.data,
+		seq: event.seq
+	};
+}
+/** Record the model profile selected for one turn without changing agent history. */
+async function recordTurnRoute(args) {
+	await getConversationEventStore().append(args.conversationId, [{
+		idempotencyKey: `turn:${args.turnId}:routed`,
+		createdAtMs: Date.now(),
+		data: {
+			type: "turn_routed",
+			turnId: args.turnId,
+			modelProfile: args.modelProfile,
+			modelId: args.modelId,
+			...args.costUsd !== void 0 ? { costUsd: args.costUsd } : void 0,
+			reasoningLevel: args.reasoningLevel,
+			...args.confidence !== void 0 ? { confidence: args.confidence } : void 0,
+			source: args.source
+		}
+	}]);
+}
+/** Record a host-observed parent tool start without adding it to Pi replay. */
+async function recordToolExecutionStarted(args) {
+	await getConversationEventStore().append(args.conversationId, [{
+		data: {
+			type: "tool_execution_started",
+			toolCallId: args.toolCallId,
+			toolName: args.toolName
+		},
+		createdAtMs: args.createdAtMs ?? Date.now()
+	}]);
+}
+/** Stable write key so retries do not mint duplicate delivery rows. */
+function attachmentsDeliveredIdempotencyKey(args) {
+	if (args.toolCallId) return `attachments_delivered:tool:${args.toolCallId}`;
+	if (args.turnId) return `attachments_delivered:turn:${args.turnId}:` + args.attachments.map((attachment) => attachment.id).sort().join(",");
+	return `attachments_delivered:${args.conversationId}:` + args.attachments.map((attachment) => attachment.id).sort().join(",");
+}
+/** Record files delivered for humans without adding them to Pi replay. */
+async function recordAttachmentsDelivered(args) {
+	if (args.attachments.length === 0) return;
+	await getConversationEventStore().append(args.conversationId, [{
+		idempotencyKey: attachmentsDeliveredIdempotencyKey({
+			attachments: args.attachments,
+			conversationId: args.conversationId,
+			...args.toolCallId ? { toolCallId: args.toolCallId } : void 0,
+			...args.turnId ? { turnId: args.turnId } : void 0
+		}),
+		data: {
+			type: "attachments_delivered",
+			attachments: args.attachments.map((attachment) => ({
+				id: attachment.id,
+				filename: attachment.filename,
+				contentType: attachment.contentType,
+				bytes: attachment.bytes
+			})),
+			...args.toolCallId ? { toolCallId: args.toolCallId } : void 0,
+			...args.turnId ? { turnId: args.turnId } : void 0
+		},
+		createdAtMs: args.createdAtMs ?? Date.now()
+	}]);
+}
+/** Record one privacy-safe Guardian decision before the reviewed action continues. */
+async function recordGuardianActionReviewed(args) {
+	await getConversationEventStore().append(args.conversationId, [{
+		data: {
+			type: "guardian_action_reviewed",
+			turnId: args.turnId,
+			toolCallId: args.toolCallId,
+			toolName: args.toolName,
+			...args.costUsd !== void 0 ? { costUsd: args.costUsd } : void 0,
+			decision: args.decision,
+			riskLevel: args.riskLevel,
+			userAuthorization: args.userAuthorization
+		},
+		createdAtMs: Date.now()
+	}]);
+}
+//#endregion
+//#region src/chat/tools/sandbox/file-utils.ts
+const MAX_TEXT_CHARS = 6e4;
+const RIPGREP_EXCLUDED_GLOBS = ["!**/.git/**", "!**/node_modules/**"];
+const DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
+const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+/** Normalize model-supplied numeric knobs before they reach filesystem tools. */
+function positiveInteger(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	const integer = Math.floor(value);
+	return integer > 0 ? integer : void 0;
+}
+/** Compare and slice text in one line-ending space while preserving callers' output rules. */
+function normalizeToLf(value) {
+	return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+/** Keep tool output inside the model-facing budget with an explicit notice. */
+function truncateText(value, maxChars = MAX_TEXT_CHARS) {
+	if (value.length <= maxChars) return {
+		content: value,
+		truncated: false
+	};
+	const removed = value.length - maxChars;
+	return {
+		content: `${value.slice(0, maxChars)}\n\n[output truncated: ${removed} characters removed]`,
+		truncated: true
+	};
+}
+/** Detect model-facing missing paths without swallowing sandbox lifecycle/API failures. */
+function isMissingPathError(error) {
+	if (!error || typeof error !== "object") return false;
+	const candidate = error;
+	if (candidate.code === "ENOENT") return true;
+	return typeof candidate.message === "string" && candidate.message.startsWith("File not found:");
+}
+/** Reject an expected missing search/list path through the tool-error channel. */
+function missingPathSearchResult(params) {
+	const textPath = params.displayPath ?? params.missingPath ?? params.path;
+	throw new ToolInputError(`Path not found: ${textPath}`);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegExp(pattern) {
+	let source = "";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		const next = pattern[index + 1];
+		if (char === "*" && next === "*") {
+			if (pattern[index + 2] === "/") {
+				source += "(?:.*/)?";
+				index += 2;
+				continue;
+			}
+			source += ".*";
+			index += 1;
+			continue;
+		}
+		if (char === "*") {
+			source += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			source += "[^/]";
+			continue;
+		}
+		source += escapeRegExp(char);
+	}
+	return new RegExp(`^${source}$`);
+}
+function matchesGlob(relativePath, pattern) {
+	const matcher = globToRegExp(pattern);
+	if (matcher.test(relativePath)) return true;
+	if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) return true;
+	return !pattern.includes("/") && matcher.test(path.posix.basename(relativePath));
+}
+/** Keep sandbox filesystem tools scoped to the mounted workspace root. */
+function resolveWorkspacePath(input, fallback = ".") {
+	const requested = (input ?? "").trim() || fallback;
+	const absolute = requested.startsWith("/") ? requested : path.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
+	const normalized = path.posix.normalize(absolute);
+	if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) throw new ToolInputError(`Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`);
+	return normalized;
+}
+/** Anchor ripgrep paths and globs to the requested search root. */
+function getRipgrepSearchLocation(root, rootIsDirectory) {
+	if (rootIsDirectory) return {
+		cwd: root,
+		target: "."
+	};
+	return {
+		cwd: path.posix.dirname(root),
+		target: path.posix.basename(root)
+	};
+}
+/** Share bounded workspace traversal across search tools so their skip rules stay aligned. */
+async function collectFiles(params) {
+	const files = [];
+	let limitReached = false;
+	let missingPath;
+	const visit = async (dirPath) => {
+		if (missingPath) return;
+		let entries;
+		try {
+			entries = (await params.fs.readdir(dirPath)).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+		} catch (error) {
+			if (isMissingPathError(error)) {
+				missingPath = dirPath;
+				return;
+			}
+			throw error;
+		}
+		for (const entry of entries) {
+			const fullPath = path.posix.join(dirPath, entry);
+			let stat;
+			try {
+				stat = await params.fs.stat(fullPath);
+			} catch (error) {
+				if (isMissingPathError(error)) {
+					missingPath = fullPath;
+					return;
+				}
+				throw error;
+			}
+			if (stat.isDirectory()) {
+				if (!SKIPPED_DIRECTORIES.has(entry)) await visit(fullPath);
+				if (limitReached) return;
+				continue;
+			}
+			const relativePath = path.posix.relative(params.root, fullPath);
+			if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
+				files.push(fullPath);
+				if (params.limit && files.length >= params.limit) {
+					limitReached = true;
+					return;
+				}
+			}
+		}
+	};
+	let stat;
+	try {
+		stat = await params.fs.stat(params.root);
+	} catch (error) {
+		if (isMissingPathError(error)) return {
+			files,
+			limitReached: false,
+			missingPath: params.root,
+			missingRoot: true
+		};
+		throw error;
+	}
+	if (!stat.isDirectory()) {
+		const relativePath = path.posix.basename(params.root);
+		return {
+			files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
+			limitReached: false,
+			missingRoot: false
+		};
+	}
+	await visit(params.root);
+	return {
+		files,
+		limitReached,
+		missingPath,
+		missingRoot: missingPath === params.root
+	};
+}
+//#endregion
+//#region src/chat/repository-instructions.ts
+const AGENTS_FILENAME = "AGENTS.md";
+const MAX_REPOSITORY_INSTRUCTIONS_BYTES = 32768;
+const AGENTS_REPLACEMENT_NOTICE = "These AGENTS.md instructions replace all previously provided AGENTS.md instructions.";
+const AGENTS_REMOVAL_NOTICE = "The previously provided AGENTS.md instructions no longer apply.";
+async function pathExists(fs, target) {
+	try {
+		await fs.stat(target);
+		return true;
+	} catch (error) {
+		if (isMissingPathError(error)) return false;
+		throw error;
+	}
+}
+async function directoryExists(fs, target) {
+	try {
+		return (await fs.stat(target)).isDirectory();
+	} catch (error) {
+		if (isMissingPathError(error)) return false;
+		throw error;
+	}
+}
+async function findGitRoot(fs, cwd) {
+	let current = cwd;
+	for (;;) {
+		if (await pathExists(fs, path.posix.join(current, ".git"))) return current;
+		if (current === SANDBOX_WORKSPACE_ROOT) return;
+		const parent = path.posix.dirname(current);
+		if (parent === current || parent !== SANDBOX_WORKSPACE_ROOT && !parent.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) return;
+		current = parent;
+	}
+}
+/** Return Git worktrees under repos/, sorted for stable instruction capture. */
+async function listRepositoryDirectories(fs) {
+	if (!await directoryExists(fs, SANDBOX_REPOS_ROOT)) return [];
+	const entries = await fs.readdir(SANDBOX_REPOS_ROOT);
+	const repositories = [];
+	for (const entry of entries) {
+		const candidate = path.posix.join(SANDBOX_REPOS_ROOT, entry);
+		if (await directoryExists(fs, candidate) && await pathExists(fs, path.posix.join(candidate, ".git"))) repositories.push(candidate);
+	}
+	return repositories.sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+}
+async function readInstructionFile(fs, filePath) {
+	try {
+		const content = await fs.readFile(filePath, { encoding: "utf8" });
+		return content.trim() ? content : void 0;
+	} catch (error) {
+		if (isMissingPathError(error)) return;
+		throw error;
+	}
+}
+/** Resolve the effective root-to-cwd AGENTS.md bundle for one selected directory. */
+async function resolveRepositoryInstructions(args) {
+	const gitRoot = await findGitRoot(args.fs, args.cwd);
+	if (!gitRoot) return;
+	const directories = [];
+	let current = args.cwd;
+	for (;;) {
+		directories.push(current);
+		if (current === gitRoot) break;
+		current = path.posix.dirname(current);
+	}
+	directories.reverse();
+	const sources = [];
+	let remaining = Math.max(0, args.maxBytes ?? MAX_REPOSITORY_INSTRUCTIONS_BYTES);
+	for (const directory of directories) {
+		if (remaining <= 0) break;
+		const filePath = path.posix.join(directory, AGENTS_FILENAME);
+		const content = await readInstructionFile(args.fs, filePath);
+		if (!content) continue;
+		const bytes = Buffer.from(content, "utf8");
+		const bounded = bytes.length <= remaining ? content : bytes.subarray(0, remaining).toString("utf8");
+		sources.push({
+			content: bounded,
+			path: filePath
+		});
+		remaining -= Buffer.byteLength(bounded, "utf8");
+	}
+	if (sources.length === 0) return;
+	const text = formatInstructionSources(sources);
+	const fingerprint = createHash("sha256").update(JSON.stringify({
+		directory: args.cwd,
+		sources
+	})).digest("hex");
+	return {
+		directory: args.cwd,
+		fingerprint,
+		sources,
+		text
+	};
+}
+function formatInstructionSources(sources) {
+	if (sources.length === 1) return sources[0].content;
+	return sources.map((source) => `## ${path.posix.dirname(source.path)}\n\n${source.content}`).join("\n\n");
+}
+/** Combine AGENTS.md bundles from one or more repository directories. */
+function mergeRepositoryInstructions(bundles) {
+	if (bundles.length === 0) return;
+	if (bundles.length === 1) return bundles[0];
+	const sources = bundles.flatMap((bundle) => bundle.sources);
+	const text = formatInstructionSources(sources);
+	return {
+		fingerprint: createHash("sha256").update(JSON.stringify({
+			directories: bundles.map((bundle) => bundle.directory ?? null),
+			sources
+		})).digest("hex"),
+		sources,
+		text
+	};
+}
+/** Resolve AGENTS.md instructions for each selected repository directory. */
+async function resolveRepositoryInstructionsForDirectories(args) {
+	const uniqueDirectories = [...new Set(args.directories.filter((directory) => directory === SANDBOX_WORKSPACE_ROOT || directory.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)))].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+	let remaining = MAX_REPOSITORY_INSTRUCTIONS_BYTES;
+	const bundles = [];
+	for (const directory of uniqueDirectories) {
+		if (remaining <= 0) break;
+		const instructions = await resolveRepositoryInstructions({
+			cwd: directory,
+			fs: args.fs,
+			maxBytes: remaining
+		});
+		if (!instructions) continue;
+		bundles.push(instructions);
+		remaining -= instructions.sources.reduce((total, source) => total + Buffer.byteLength(source.content, "utf8"), 0);
+	}
+	return mergeRepositoryInstructions(bundles);
+}
+/** Render repository instructions with Codex's exact model-visible wrapper. */
+function renderAgentsInstructions(args) {
+	return `# AGENTS.md instructions${args.directory ? ` for ${args.directory}` : ""}\n\n<INSTRUCTIONS>\n${args.text}\n</INSTRUCTIONS>`;
+}
+/** Build one user-role repository-instructions context message. */
+function buildAgentsInstructionsMessage(args) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: renderAgentsInstructions(args)
+		}],
+		timestamp: args.timestamp ?? Date.now()
+	};
+}
+/** Read the latest effective AGENTS.md state from model-visible history. */
+function findVisibleAgentsInstructions(messages) {
+	for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+		const message = messages[messageIndex];
+		if (message.role !== "user" || !Array.isArray(message.content)) continue;
+		for (let partIndex = message.content.length - 1; partIndex >= 0; partIndex -= 1) {
+			const part = message.content[partIndex];
+			if (part.type !== "text" || typeof part.text !== "string" || !part.text.startsWith("# AGENTS.md instructions")) continue;
+			const match = part.text.match(/^# AGENTS\.md instructions(?: for ([^\n]+))?\n\n<INSTRUCTIONS>\n([\s\S]*)\n<\/INSTRUCTIONS>$/);
+			if (!match) continue;
+			let text = match[2];
+			if (text === "The previously provided AGENTS.md instructions no longer apply.") return { active: false };
+			if (text.startsWith(`These AGENTS.md instructions replace all previously provided AGENTS.md instructions.\n\n`)) text = text.slice(86);
+			return {
+				active: true,
+				...match[1] ? { directory: match[1] } : void 0,
+				text
+			};
+		}
+	}
+}
+/** Whether one message is a generated AGENTS.md context update. */
+function isAgentsInstructionsMessage(message) {
+	return Boolean(findVisibleAgentsInstructions([message]));
+}
+//#endregion
+//#region src/chat/services/turn-limit.ts
+/** Terminal failure when one turn uses too many execution slices. */
+var TurnSliceLimitExceededError = class extends Error {
+	constructor(maxSlices) {
+		super(`Agent turn exceeded execution limit (${maxSlices} slices)`);
+		this.name = "TurnSliceLimitExceededError";
+	}
+};
+/** Terminal failure when one turn uses too many tool calls. */
+var TurnToolCallLimitExceededError = class extends Error {
+	constructor(maxToolCalls) {
+		super(`Agent turn exceeded execution limit (${maxToolCalls} tool calls)`);
+		this.name = "TurnToolCallLimitExceededError";
+	}
+};
+function isDirectTurnExecutionLimitError(error) {
+	return error instanceof TurnSliceLimitExceededError || error instanceof TurnToolCallLimitExceededError;
+}
+/** True when a turn hit a hard execution limit, including one Error.cause wrap. */
+function isTurnExecutionLimitExceededError(error) {
+	if (isDirectTurnExecutionLimitError(error)) return true;
+	return error instanceof Error && isDirectTurnExecutionLimitError(error.cause);
+}
+/** Stop the turn when its tool-call count is past the limit. */
+function assertTurnToolCallLimit(toolCallCount, maxToolCalls) {
+	if (toolCallCount <= maxToolCalls) return;
+	throw new TurnToolCallLimitExceededError(maxToolCalls);
+}
+/** Explain a terminal turn execution limit with actionable recovery guidance. */
+function buildTurnLimitResponse(eventId) {
+	return `I couldn't finish this request because this turn reached its execution limit. Please try again with a smaller or more specific request. Reference: \`event_id=${eventId}\`.`;
+}
+/** User-facing reply for a thrown turn error. */
+function buildTurnErrorResponse(error, eventId) {
+	return isTurnExecutionLimitExceededError(error) ? buildTurnLimitResponse(eventId) : buildTurnFailureResponse(eventId);
+}
+//#endregion
+//#region src/chat/services/persist-retry.ts
+/**
+* Shared post-delivery persist retry.
+*
+* Delivered outcomes the user already saw must not be lost to a transient
+* state-write failure, so both Slack turns and dispatch turns retry these
+* persists with the same short linear backoff.
+*/
+const PERSIST_ATTEMPTS = 3;
+/** Retry a delivered-state persist briefly before surfacing the failure. */
+async function persistWithRetry(persist) {
+	let lastError;
+	for (let attempt = 1; attempt <= PERSIST_ATTEMPTS; attempt += 1) try {
+		await persist();
+		return;
+	} catch (error) {
+		lastError = error;
+		if (attempt < PERSIST_ATTEMPTS) await sleep(attempt * 100);
+	}
+	throw lastError;
+}
+//#endregion
+//#region src/chat/task-execution/turn-cursor-keys.ts
+/** Redis namespace for the current turn cursor format. */
+const TURN_CURSOR_PREFIX = "junior:turn_cursor:v2";
+/** Return the Redis key for one turn cursor. */
+function turnCursorKey(conversationId, turnId) {
+	return `${TURN_CURSOR_PREFIX}:${conversationId}:${turnId}`;
+}
+/** Return the Redis index key for one conversation's turns. */
+function turnCursorIndexKey(conversationId) {
+	return `${TURN_CURSOR_PREFIX}:conversation:${conversationId}:index`;
+}
+/** Return the lock key that serializes writes to one turn cursor. */
+function turnCursorMutationKey(conversationId, turnId) {
+	return `${TURN_CURSOR_PREFIX}:mutation:${conversationId}:${turnId}`;
+}
+//#endregion
+//#region src/chat/task-execution/turn-cursor.ts
+/**
+* Internal turn cursor storage for `checkpoint.ts`.
+*
+* Callers outside `task-execution/` should use `checkpoint.ts` only.
+* These records track one turn across auth pauses, timeout slices, and
+* completion. Full Pi messages live in SQL conversation events; this store
+* keeps resume metadata and a committed `seq` cursor into
+* `junior_conversation_events`.
+*/
+const TURN_CURSOR_SCHEMA_VERSION = 2;
+const TURN_CURSOR_RESUME_TTL_MS = 864e5;
+const TURN_CURSOR_TERMINAL_TTL_MS = 36e5;
+const TURN_CURSOR_MUTATION_LOCK_WAIT_MS = 1e4;
+async function withTurnCursorMutation(conversationId, turnId, run) {
+	const state = getStateAdapter();
+	await state.connect();
+	const result = await withLock(state, turnCursorMutationKey(conversationId, turnId), async (lock) => await run(async () => await fenceLock(state, lock)), {
+		keepAlive: true,
+		ttlMs: MUTATION_LOCK_TTL_MS,
+		waitMs: TURN_CURSOR_MUTATION_LOCK_WAIT_MS
+	});
+	if (!result.acquired) throw new Error(`Could not acquire turn cursor lock for ${turnId}`);
+	return result.value;
+}
+function executionMetricsForTurn(conversation, turnId) {
+	return conversation?.executionMetrics?.runId === turnId ? conversation.executionMetrics : void 0;
+}
+/** Keep only keys whose value is defined. */
+function definedProps$1(values) {
+	return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+const turnStatusSchema = z.enum([
+	"running",
+	"paused",
+	"completed",
+	"failed",
+	"abandoned"
+]);
+const turnSurfaceSchema = z.enum([
+	"slack",
+	"api",
+	"scheduler",
+	"internal"
+]);
+const turnPauseReasonSchema = z.enum([
+	"timeout",
+	"auth",
+	"yield",
+	"retry"
+]);
+const nonNegativeNumberSchema = z.number().finite().nonnegative();
+const seqCursorSchema = z.number().int().min(-1);
+/** Thin recovery projection stored per conversation. Reporting reads SQL. */
+const storedTurnSummarySchema = z.object({
+	schemaVersion: z.literal(TURN_CURSOR_SCHEMA_VERSION),
+	version: z.number().int().nonnegative(),
+	conversationId: z.string().min(1),
+	dispatchId: z.string().min(1).optional(),
+	dispatchOutcome: z.enum([
+		"blocked",
+		"completed",
+		"failed"
+	]).optional(),
+	resultMessageId: z.string().min(1).optional(),
+	resumeReason: turnPauseReasonSchema.optional(),
+	turnId: z.string().min(1),
+	sliceId: z.number().int().nonnegative(),
+	state: turnStatusSchema,
+	surface: turnSurfaceSchema.optional(),
+	updatedAtMs: nonNegativeNumberSchema
+}).strip();
+/** Full resume cursor stored for one turn. */
+const storedTurnRecordSchema = z.object({
+	actor: actorSchema.optional(),
+	schemaVersion: z.literal(TURN_CURSOR_SCHEMA_VERSION),
+	version: z.number().int().nonnegative(),
+	conversationId: z.string().min(1),
+	dispatchId: z.string().min(1).optional(),
+	dispatchOutcome: z.enum([
+		"blocked",
+		"completed",
+		"failed"
+	]).optional(),
+	resultMessageId: z.string().min(1).optional(),
+	lastProgressAtMs: nonNegativeNumberSchema,
+	resumeReason: turnPauseReasonSchema.optional(),
+	publishExternally: z.boolean().optional(),
+	source: sourceSchema.optional(),
+	resumedFromSliceId: z.number().int().nonnegative().optional(),
+	turnId: z.string().min(1),
+	sliceId: z.number().int().nonnegative(),
+	startedAtMs: nonNegativeNumberSchema,
+	state: turnStatusSchema,
+	surface: turnSurfaceSchema.optional(),
+	traceId: z.string().optional(),
+	updatedAtMs: nonNegativeNumberSchema,
+	committedSeq: seqCursorSchema,
+	historyVersion: z.number().int().nonnegative().optional(),
+	errorMessage: z.string().optional(),
+	cumulativeToolCallCount: z.number().int().nonnegative().optional(),
+	turnStartSeq: seqCursorSchema.optional(),
+	runtimeContext: z.array(piMessageSchema).optional()
+}).strip();
+function conversationExecutionFromSummary(summary) {
+	return {
+		status: summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state,
+		runId: summary.turnId,
+		updatedAtMs: summary.updatedAtMs
+	};
+}
+function sessionLogActor(actor) {
+	return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
+}
+function parseTurnRecord(value) {
+	return storedTurnRecordSchema.parse(value);
+}
+function parseTurnSummary(value) {
+	return storedTurnSummarySchema.parse(value);
+}
+function storeTurnSummary(summary) {
+	return storedTurnSummarySchema.parse(summary);
+}
+function turnCursorTtlMs(state, ttlMs) {
+	if (ttlMs !== void 0) return Math.max(1, ttlMs);
+	return state === "running" || state === "paused" ? TURN_CURSOR_RESUME_TTL_MS : TURN_CURSOR_TERMINAL_TTL_MS;
+}
+/**
+* The per-conversation recovery index holds many turns. Keep it on the resume
+* window so a terminal write cannot expire unfinished siblings still under a
+* resume lease. Explicit ttl overrides (tests) still win.
+*/
+function turnCursorIndexTtlMs(ttlMs) {
+	return Math.max(1, ttlMs ?? TURN_CURSOR_RESUME_TTL_MS);
+}
+function projectTurnSummary(record) {
+	return parseTurnSummary(record);
+}
+async function appendTurnSummary(summary, ttlMs) {
+	await getStateAdapter().appendToList(turnCursorIndexKey(summary.conversationId), storeTurnSummary(summary), { ttlMs });
+}
+/** Store run summary metadata in the configured conversation store. */
+async function recordConversationActivityMetadata(args) {
+	const conversationStore = args.conversationStore ?? getConversationStore();
+	const conversation = await conversationStore.get({ conversationId: args.summary.conversationId });
+	const hasParent = Boolean(conversation?.parentConversationId);
+	const destination = hasParent ? void 0 : args.destination;
+	if (!hasParent && !destination && !conversation) return;
+	const activitySource = hasParent ? "internal" : args.source?.kind === "web" ? "web" : destination?.platform === "local" ? "local" : destination ? args.summary.surface : void 0;
+	await conversationStore.recordActivity({
+		activityAtMs: args.summary.updatedAtMs,
+		channelName: args.summary.channelName,
+		conversationId: args.summary.conversationId,
+		destination,
+		nowMs: args.nowMs,
+		actor: sessionLogActor(args.actor),
+		...definedProps$1({ source: activitySource }),
+		...args.source ? { sessionSource: args.source } : void 0,
+		visibility: hasParent ? void 0 : args.destinationVisibility
+	});
+	await conversationStore.recordExecution({
+		channelName: args.summary.channelName,
+		conversationId: args.summary.conversationId,
+		createdAtMs: args.summary.startedAtMs,
+		destination,
+		execution: conversationExecutionFromSummary(args.summary),
+		lastActivityAtMs: args.summary.updatedAtMs,
+		metrics: {
+			durationMs: args.summary.cumulativeDurationMs,
+			...args.summary.cumulativeUsage ? { usage: args.summary.cumulativeUsage } : void 0
+		},
+		actor: sessionLogActor(args.actor),
+		...definedProps$1({ source: activitySource }),
+		updatedAtMs: args.nowMs,
+		visibility: hasParent ? void 0 : args.destinationVisibility
+	});
+}
+function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true, runtimeMetrics) {
+	const restoredProjection = restoreVolatileContext && (stored.state === "running" || stored.state === "paused") ? restoreRuntimeContext(piProjection, stored.runtimeContext) : piProjection;
+	return {
+		...definedProps$1({ actor: stored.actor }),
+		schemaVersion: stored.schemaVersion,
+		version: stored.version,
+		conversationId: stored.conversationId,
+		turnId: stored.turnId,
+		sliceId: stored.sliceId,
+		state: stored.state,
+		startedAtMs: stored.startedAtMs,
+		lastProgressAtMs: stored.lastProgressAtMs,
+		updatedAtMs: stored.updatedAtMs,
+		piMessages: restoredProjection.messages,
+		piMessageProvenance: restoredProjection.provenance,
+		actors: instructionActors(piProjection.provenance),
+		cumulativeDurationMs: runtimeMetrics?.cumulativeDurationMs ?? 0,
+		...definedProps$1({
+			channelName: runtimeMetrics?.channelName,
+			cumulativeToolCallCount: stored.cumulativeToolCallCount,
+			cumulativeUsage: runtimeMetrics?.cumulativeUsage,
+			dispatchId: stored.dispatchId,
+			dispatchOutcome: stored.dispatchOutcome,
+			errorMessage: stored.errorMessage,
+			resumeReason: stored.resumeReason,
+			source: stored.source,
+			resultMessageId: stored.resultMessageId,
+			resumedFromSliceId: stored.resumedFromSliceId,
+			surface: stored.surface,
+			traceId: stored.traceId,
+			turnStartMessageIndex
+		})
+	};
+}
+function restoreRuntimeContext(projection, runtimeContext) {
+	if (!runtimeContext || runtimeContext.length === 0) return projection;
+	const restoredMessages = [...projection.messages];
+	const restoredProvenance = [...projection.provenance];
+	const unmatchedRuntimeContext = [];
+	for (const runtimeMessage of runtimeContext) {
+		const runtime = runtimeMessage;
+		const targetIndex = restoredMessages.findIndex((message) => {
+			const candidate = message;
+			return candidate.role === "user" && candidate.timestamp === runtime.timestamp;
+		});
+		if (targetIndex < 0) {
+			if (isAgentsInstructionsMessage(runtimeMessage)) {
+				const followingIndex = restoredMessages.findIndex((message) => {
+					const timestamp = message.timestamp;
+					return typeof runtime.timestamp === "number" && typeof timestamp === "number" && timestamp > runtime.timestamp;
+				});
+				const insertionIndex = followingIndex < 0 ? restoredMessages.length : followingIndex;
+				restoredMessages.splice(insertionIndex, 0, runtimeMessage);
+				restoredProvenance.splice(insertionIndex, 0, contextProvenance);
+			} else unmatchedRuntimeContext.push(runtimeMessage);
+			continue;
+		}
+		restoredMessages.splice(targetIndex, 0, runtimeMessage);
+		restoredProvenance.splice(targetIndex, 0, contextProvenance);
+	}
+	return {
+		messages: [...unmatchedRuntimeContext, ...restoredMessages],
+		provenance: [...unmatchedRuntimeContext.map(() => contextProvenance), ...restoredProvenance]
+	};
+}
+/** Read only the stored metadata record without materializing transcript logs. */
+async function getStoredTurnRecord(conversationId, turnId) {
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	const value = await stateAdapter.get(turnCursorKey(conversationId, turnId));
+	return value == null ? void 0 : parseTurnRecord(value);
+}
+/** Read a materialized turn cursor for resume and history loading. */
+async function materializeStoredTurnRecord(conversationId, turnId, followCurrentReplacement) {
+	const parsed = await getStoredTurnRecord(conversationId, turnId);
+	if (!parsed) return;
+	const pinnedProjection = await loadTurnProjection({
+		conversationId,
+		committedSeq: parsed.committedSeq,
+		includeTail: parsed.state === "running" || parsed.state === "paused"
+	});
+	if (!pinnedProjection) return;
+	const eventStore = getConversationEventStore();
+	const currentHistoryVersion = await eventStore.loadCurrentHistoryVersion(conversationId);
+	const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "paused") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
+	const piProjection = followsReplacement ? projectConversationEvents(await eventStore.loadCurrentHistory(conversationId), { defaultProfile: botConfig.defaultProfile }) : pinnedProjection;
+	const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
+	const conversation = await getConversationStore().get({ conversationId });
+	const executionMetrics = executionMetricsForTurn(conversation, turnId);
+	return materializeTurnRecord(parsed, piProjection, turnStartMessageIndex, !followsReplacement && (parsed.historyVersion === void 0 || parsed.historyVersion === currentHistoryVersion), {
+		channelName: conversation?.channelName,
+		cumulativeDurationMs: executionMetrics?.durationMs,
+		cumulativeUsage: executionMetrics?.usage
+	});
+}
+/** Read a turn record pinned to the history version containing its checkpoint. */
+async function getTurnRecord(conversationId, turnId) {
+	return await materializeStoredTurnRecord(conversationId, turnId, false);
+}
+/** Read a turn cursor for resume, following a newer committed replacement while unfinished. */
+async function getTurnRecordForResume(conversationId, turnId) {
+	return await materializeStoredTurnRecord(conversationId, turnId, true);
+}
+/** Build the storage record that advances optimistic resume versioning. */
+function buildStoredRecord(args) {
+	const nowMs = Date.now();
+	return {
+		schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
+		version: (args.previousVersion ?? 0) + 1,
+		conversationId: args.conversationId,
+		turnId: args.turnId,
+		sliceId: args.sliceId,
+		state: args.state,
+		startedAtMs: args.startedAtMs ?? nowMs,
+		lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+		updatedAtMs: nowMs,
+		committedSeq: args.committedSeq,
+		...definedProps$1({
+			actor: args.actor,
+			cumulativeToolCallCount: args.cumulativeToolCallCount,
+			dispatchId: args.dispatchId,
+			dispatchOutcome: args.dispatchOutcome,
+			errorMessage: args.errorMessage,
+			historyVersion: args.historyVersion,
+			resumeReason: args.resumeReason,
+			publishExternally: args.publishExternally,
+			source: args.source,
+			resultMessageId: args.resultMessageId,
+			resumedFromSliceId: args.resumedFromSliceId,
+			runtimeContext: args.runtimeContext && args.runtimeContext.length > 0 ? args.runtimeContext : void 0,
+			surface: args.surface,
+			traceId: args.traceId,
+			turnStartSeq: args.turnStartSeq
+		})
+	};
+}
+async function setStoredRecord(args) {
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	const storedRecord = storedTurnRecordSchema.parse(args.record);
+	await args.fence();
+	await recordConversationActivityMetadata({
+		actor: args.actor,
+		conversationStore: args.conversationStore,
+		destination: args.destination,
+		destinationVisibility: args.destinationVisibility,
+		nowMs: Date.now(),
+		source: args.source,
+		summary: {
+			...projectTurnSummary(storedRecord),
+			startedAtMs: storedRecord.startedAtMs,
+			...args.runtimeMetrics
+		}
+	});
+	await args.fence();
+	await stateAdapter.set(turnCursorKey(storedRecord.conversationId, storedRecord.turnId), storedRecord, args.ttlMs);
+	await args.fence();
+	await appendTurnSummary(projectTurnSummary(storedRecord), turnCursorIndexTtlMs(args.indexTtlMs));
+	return materializeTurnRecord(storedRecord, {
+		messages: [...args.piMessages],
+		provenance: [...args.piMessageProvenance]
+	}, args.turnStartMessageIndex, true, args.runtimeMetrics);
+}
+/**
+* Transition an unfinished turn only if the caller still holds the
+* version it loaded, preventing stale resume callbacks from winning.
+*/
+async function updateTurnState(args) {
+	const parsed = await getStoredTurnRecord(args.existing.conversationId, args.existing.turnId);
+	if (!parsed || parsed.version !== args.existing.version) return;
+	return await setStoredRecord({
+		actor: args.existing.actor,
+		fence: args.fence,
+		piMessages: args.existing.piMessages,
+		piMessageProvenance: args.existing.piMessageProvenance,
+		ttlMs: turnCursorTtlMs(args.state),
+		runtimeMetrics: {
+			cumulativeDurationMs: args.existing.cumulativeDurationMs,
+			...definedProps$1({
+				channelName: args.existing.channelName,
+				cumulativeUsage: args.existing.cumulativeUsage
+			})
+		},
+		...definedProps$1({ turnStartMessageIndex: args.existing.turnStartMessageIndex }),
+		record: buildStoredRecord({
+			actor: args.existing.actor,
+			conversationId: args.existing.conversationId,
+			turnId: args.existing.turnId,
+			sliceId: args.existing.sliceId,
+			state: args.state,
+			committedSeq: parsed.committedSeq,
+			startedAtMs: parsed.startedAtMs,
+			lastProgressAtMs: parsed.lastProgressAtMs,
+			previousVersion: parsed.version,
+			...definedProps$1({
+				cumulativeToolCallCount: args.existing.cumulativeToolCallCount,
+				dispatchId: args.existing.dispatchId,
+				dispatchOutcome: args.existing.dispatchOutcome,
+				errorMessage: args.errorMessage ?? args.existing.errorMessage,
+				historyVersion: parsed.historyVersion,
+				resumeReason: args.existing.resumeReason,
+				publishExternally: parsed.publishExternally,
+				source: args.existing.source,
+				resultMessageId: args.resultMessageId ?? args.existing.resultMessageId,
+				resumedFromSliceId: args.existing.resumedFromSliceId,
+				surface: args.existing.surface,
+				traceId: args.existing.traceId,
+				turnStartSeq: parsed.turnStartSeq
+			})
+		})
+	});
+}
+/** Commit stable Pi state and advance the turn cursor. */
+async function upsertTurnRecord(args) {
+	return await withTurnCursorMutation(args.conversationId, args.turnId, async (fence) => await upsertTurnRecordLocked(args, fence));
+}
+async function upsertTurnRecordLocked(args, fence) {
+	const existingRecord = await getStoredTurnRecord(args.conversationId, args.turnId);
+	const conversation = await (args.conversationStore ?? getConversationStore()).get({ conversationId: args.conversationId });
+	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const existingDispatchId = existingRecord?.dispatchId ?? (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId)?.dispatchId;
+	if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
+	const ttlMs = turnCursorTtlMs(args.state, args.ttlMs);
+	const instructionActor = args.actor;
+	const commit = await commitMessages({
+		conversationId: args.conversationId,
+		messages: args.piMessages,
+		...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : void 0,
+		...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : void 0,
+		...args.turnContexts && args.turnContexts.length > 0 ? { turnContext: {
+			contexts: args.turnContexts,
+			turnId: args.turnId
+		} } : void 0
+	});
+	const durableTurnStartMessageIndex = args.turnStartMessageIndex === void 0 ? void 0 : stripRuntimeTurnContext(args.piMessages.slice(0, args.turnStartMessageIndex)).length;
+	const runtimeContext = retainRuntimeTurnContext(args.piMessages);
+	const retainedRuntimeContext = runtimeContext.length > 0 ? runtimeContext : existingRecord?.historyVersion === commit.historyVersion ? existingRecord.runtimeContext : void 0;
+	const turnStartSeq = durableTurnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : durableTurnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[durableTurnStartMessageIndex - 1] ?? commit.committedSeq;
+	const turnStartMessageIndex = durableTurnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
+	const turnSource = args.source ?? existingRecord?.source;
+	const dispatchId = args.dispatchId ?? existingRecord?.dispatchId;
+	const hasProviderLocation = Boolean(conversation?.location) || args.destination?.platform === "slack";
+	const publishExternally = dispatchId || turnSource ? hasProviderLocation && (Boolean(dispatchId) || turnSource?.kind === "slack" || turnSource?.kind === "resource_event") : existingRecord?.publishExternally ?? false;
+	return await setStoredRecord({
+		actor: existingRecord?.actor ?? args.actor,
+		fence,
+		conversationStore: args.conversationStore,
+		destination: args.destination,
+		destinationVisibility: args.destinationVisibility,
+		source: args.source,
+		piMessages: commit.messages,
+		piMessageProvenance: commit.provenance,
+		ttlMs,
+		runtimeMetrics: {
+			channelName: args.channelName ?? conversation?.channelName,
+			cumulativeDurationMs: args.cumulativeDurationMs ?? executionMetrics?.durationMs ?? 0,
+			cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage
+		},
+		...definedProps$1({ indexTtlMs: args.ttlMs }),
+		turnStartMessageIndex,
+		record: buildStoredRecord({
+			actor: existingRecord?.actor ?? args.actor,
+			conversationId: args.conversationId,
+			turnId: args.turnId,
+			sliceId: args.sliceId,
+			state: args.state,
+			committedSeq: commit.committedSeq,
+			historyVersion: commit.historyVersion,
+			previousVersion: existingRecord?.version,
+			...definedProps$1({
+				cumulativeToolCallCount: args.cumulativeToolCallCount ?? existingRecord?.cumulativeToolCallCount,
+				dispatchId,
+				dispatchOutcome: args.dispatchOutcome ?? existingRecord?.dispatchOutcome,
+				errorMessage: args.errorMessage,
+				lastProgressAtMs: args.lastProgressAtMs,
+				resumeReason: args.resumeReason,
+				publishExternally,
+				source: args.source ?? existingRecord?.source,
+				resultMessageId: args.resultMessageId ?? existingRecord?.resultMessageId,
+				resumedFromSliceId: args.resumedFromSliceId,
+				runtimeContext: args.state === "running" || args.state === "paused" ? retainedRuntimeContext : void 0,
+				startedAtMs: existingRecord?.startedAtMs,
+				surface: args.surface ?? existingRecord?.surface,
+				traceId: args.traceId ?? existingRecord?.traceId,
+				turnStartSeq
+			})
+		})
+	});
+}
+/** Record turn metadata without storing conversation messages. */
+async function recordTurnSummary(args) {
+	await withTurnCursorMutation(args.conversationId, args.turnId, async (fence) => await recordTurnSummaryOwned(args, fence));
+}
+async function recordTurnSummaryOwned(args, fence) {
+	const stored = await getStoredTurnRecord(args.conversationId, args.turnId);
+	const conversationStore = args.conversationStore ?? getConversationStore();
+	const conversation = await conversationStore.get({ conversationId: args.conversationId });
+	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const priorSummary = (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId);
+	const terminalSummary = priorSummary && (priorSummary.state === "completed" || priorSummary.state === "failed" || priorSummary.state === "abandoned") ? priorSummary : void 0;
+	const terminalRecord = stored && (stored.state === "completed" || stored.state === "failed" || stored.state === "abandoned") ? stored : void 0;
+	const existing = terminalSummary ?? terminalRecord ?? stored ?? priorSummary;
+	if ((terminalSummary || terminalRecord) && (args.state === "running" || args.state === "paused")) return;
+	const existingDispatchId = existing?.dispatchId;
+	const existingDispatchOutcome = priorSummary?.dispatchOutcome ?? stored?.dispatchOutcome;
+	const existingResultMessageId = priorSummary?.resultMessageId ?? stored?.resultMessageId;
+	if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
+	const nowMs = Date.now();
+	const ttlMs = turnCursorIndexTtlMs(args.ttlMs);
+	const summary = {
+		schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
+		version: existing?.version ?? 0,
+		conversationId: args.conversationId,
+		turnId: args.turnId,
+		sliceId: args.sliceId,
+		state: args.state,
+		updatedAtMs: nowMs,
+		...definedProps$1({
+			dispatchId: args.dispatchId ?? existingDispatchId,
+			dispatchOutcome: args.dispatchOutcome ?? existingDispatchOutcome,
+			resumeReason: args.resumeReason,
+			resultMessageId: args.resultMessageId ?? existingResultMessageId,
+			surface: args.surface ?? existing?.surface
+		})
+	};
+	await fence();
+	await recordConversationActivityMetadata({
+		actor: args.actor,
+		conversationStore,
+		destination: args.destination,
+		destinationVisibility: args.destinationVisibility,
+		nowMs,
+		source: args.source,
+		summary: {
+			...summary,
+			channelName: args.channelName ?? conversation?.channelName,
+			cumulativeDurationMs: args.cumulativeDurationMs ?? executionMetrics?.durationMs ?? 0,
+			cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage,
+			startedAtMs: stored?.startedAtMs ?? args.startedAtMs ?? nowMs
+		}
+	});
+	await fence();
+	await appendTurnSummary(summary, ttlMs);
+}
+async function readTurnSummaries(key) {
+	const stateAdapter = getStateAdapter();
+	await stateAdapter.connect();
+	const values = await stateAdapter.getList(key);
+	const summaries = /* @__PURE__ */ new Map();
+	for (const value of [...values].reverse()) {
+		let summary;
+		try {
+			summary = parseTurnSummary(value);
+		} catch {
+			continue;
+		}
+		const summaryKey = `${summary.conversationId}:${summary.turnId}`;
+		if (!summaries.has(summaryKey)) summaries.set(summaryKey, summary);
+	}
+	return [...summaries.values()].sort((left, right) => right.updatedAtMs - left.updatedAtMs);
+}
+/** List retained turn recovery projections for one conversation. */
+async function listTurnSummaries(conversationId) {
+	return readTurnSummaries(turnCursorIndexKey(conversationId));
+}
+/** Mark an unfinished turn cursor as abandoned when a newer turn wins. */
+async function abandonTurnRecord(args) {
+	return await withTurnCursorMutation(args.conversationId, args.turnId, async (fence) => {
+		const existing = await getTurnRecord(args.conversationId, args.turnId);
+		if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") return;
+		return await updateTurnState({
+			existing,
+			fence,
+			state: "abandoned",
+			errorMessage: args.errorMessage ?? existing.errorMessage
+		});
+	});
+}
+/** Mark an unfinished turn cursor as completed after delivery was accepted. */
+async function completeTurnRecord(args) {
+	return await withTurnCursorMutation(args.conversationId, args.turnId, async (fence) => {
+		const existing = await getTurnRecord(args.conversationId, args.turnId);
+		if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) return;
+		return await updateTurnState({
+			existing,
+			fence,
+			resultMessageId: args.resultMessageId,
+			state: "completed"
+		});
+	});
+}
+/** Mark an unfinished turn cursor as failed so it cannot resume. */
+async function failTurnRecord(args) {
+	return await withTurnCursorMutation(args.conversationId, args.turnId, async (fence) => {
+		const existing = await getTurnRecord(args.conversationId, args.turnId);
+		if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) return;
+		return await updateTurnState({
+			existing,
+			fence,
+			state: "failed",
+			errorMessage: args.errorMessage ?? existing.errorMessage
+		});
+	});
+}
+//#endregion
+//#region src/chat/task-execution/checkpoint.ts
+function definedProps(values) {
+	return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+function addDurationMs(prior, current) {
+	return [prior, current].reduce((sum, value) => {
+		if (typeof value !== "number" || !Number.isFinite(value)) return sum;
+		return (sum ?? 0) + Math.max(0, Math.floor(value));
+	}, void 0);
+}
+/** Boundary safe to continue after auth/timeout (trim mid-assistant). */
+function continuableMessages(messages, fallback) {
+	const current = trimTrailingAssistantMessages(messages);
+	if (current.length > 0 && isContinuablePiBoundary(current)) return current;
+	return trimTrailingAssistantMessages(fallback ?? []);
+}
+/** Load resume cursor for one turn. */
+async function loadTurnCheckpoint(args) {
+	const record = await getTurnRecordForResume(args.conversationId, args.turnId);
+	if (record?.state === "paused") return {
+		resumed: true,
+		sliceId: record.sliceId,
+		record
+	};
+	return {
+		resumed: false,
+		sliceId: 1,
+		record
+	};
+}
+async function saveTurnCheckpoint(args) {
+	if (args.mode === "running") return await saveRunning(args);
+	if (args.mode === "paused") return await savePaused(args);
+	await saveDone(args);
+}
+function sharedWrite(args, latest) {
+	return {
+		conversationId: args.conversationId,
+		turnId: args.turnId,
+		...definedProps({
+			actor: args.actor,
+			channelName: args.channelName ?? latest?.channelName,
+			destination: args.destination,
+			destinationVisibility: args.destinationVisibility,
+			dispatchId: args.dispatchId ?? latest?.dispatchId,
+			source: args.source,
+			surface: args.surface ?? latest?.surface,
+			traceId: getActiveTraceId() ?? latest?.traceId,
+			turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex,
+			cumulativeToolCallCount: args.cumulativeToolCallCount ?? latest?.cumulativeToolCallCount
+		})
+	};
+}
+async function saveRunning(args) {
+	if (args.messages.length === 0 || !isContinuablePiBoundary(args.messages)) return;
+	try {
+		const latest = await getTurnRecord(args.conversationId, args.turnId);
+		return await upsertTurnRecord({
+			...sharedWrite(args, latest),
+			...definedProps({
+				trailingMessageProvenance: args.trailingMessageProvenance,
+				turnContexts: args.turnContexts
+			}),
+			cumulativeDurationMs: latest?.cumulativeDurationMs,
+			cumulativeUsage: latest?.cumulativeUsage,
+			piMessages: args.messages,
+			sliceId: args.sliceId,
+			state: "running"
+		});
+	} catch (error) {
+		if (!(error instanceof AgentHistoryBranchError)) logException(error, "agent.turn.checkpoint.running.failed", {
+			"app.ai.resume_conversation_id": args.conversationId,
+			"app.ai.resume_session_id": args.turnId,
+			"app.ai.resume_slice_id": args.sliceId
+		});
+		return;
+	}
+}
+async function savePaused(args) {
+	const keepSlice = args.reason === "yield";
+	const nextSliceId = keepSlice ? args.sliceId : args.sliceId + 1;
+	try {
+		const latest = await getTurnRecord(args.conversationId, args.turnId);
+		const messages = args.reason === "yield" ? [...args.messages] : continuableMessages(args.messages, latest?.piMessages);
+		if (args.reason === "auth") {
+			if (messages.length > 0 && !isContinuablePiBoundary(messages)) return;
+		} else if (messages.length === 0 || !isContinuablePiBoundary(messages)) return;
+		const base = {
+			...sharedWrite(args, latest),
+			...definedProps({
+				cumulativeDurationMs: addDurationMs(latest?.cumulativeDurationMs, args.durationMs),
+				cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
+				errorMessage: args.errorMessage
+			}),
+			piMessages: messages,
+			resumeReason: args.reason
+		};
+		if (!keepSlice && nextSliceId > botConfig.maxSlicesPerTurn) {
+			const error = new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
+			await upsertTurnRecord({
+				...base,
+				...definedProps({ resumedFromSliceId: latest?.resumedFromSliceId }),
+				errorMessage: error.message,
+				sliceId: args.sliceId,
+				state: "failed"
+			});
+			throw error;
+		}
+		return await upsertTurnRecord({
+			...base,
+			...definedProps({ resumedFromSliceId: keepSlice ? latest?.resumedFromSliceId : args.sliceId }),
+			sliceId: nextSliceId,
+			state: "paused"
+		});
+	} catch (error) {
+		if (error instanceof TurnSliceLimitExceededError) throw error;
+		logException(error, "agent.turn.checkpoint.paused.failed", {
+			"app.ai.resume_conversation_id": args.conversationId,
+			"app.ai.resume_session_id": args.turnId,
+			"app.ai.resume_from_slice_id": args.sliceId,
+			"app.ai.resume_next_slice_id": nextSliceId,
+			"app.ai.resume_reason": args.reason
+		});
+		return;
+	}
+}
+async function saveDone(args) {
+	let latest;
+	await persistWithRetry(async () => {
+		latest = await getTurnRecord(args.conversationId, args.turnId);
+	});
+	const sliceId = args.sliceId ?? latest?.sliceId;
+	if (sliceId === void 0) throw new Error("Completed turn checkpoint requires a slice id from the caller or the latest stored record");
+	await persistWithRetry(async () => {
+		await upsertTurnRecord({
+			...sharedWrite(args, latest),
+			...definedProps({
+				cumulativeDurationMs: addDurationMs(latest?.cumulativeDurationMs, args.durationMs),
+				cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
+				dispatchOutcome: args.dispatchOutcome ?? latest?.dispatchOutcome,
+				errorMessage: args.errorMessage,
+				resultMessageId: args.resultMessageId ?? latest?.resultMessageId
+			}),
+			piMessages: args.messages,
+			sliceId,
+			state: args.mode
+		});
+	});
+}
+//#endregion
+export { persistConversationMessages as $, normalizeToLf as A, retainRuntimeTurnContext as At, openConversationProjection as B, DEFAULT_SEARCH_COMMAND_TIMEOUT_MS as C, hasRuntimeTurnContext as Ct, getRipgrepSearchLocation as D, isToolResultError as Dt, collectFiles as E, isContinuablePiBoundary as Et, commitMessages as F, recordAuthorizationRequested as G, recordAttachmentsDelivered as H, loadConnectedMcpProviders as I, recordSubscribedReplyRoute as J, recordGuardianActionReviewed as K, loadConversationProjection as L, resolveWorkspacePath as M, trimTrailingAssistantMessages as Mt, truncateText as N, TURN_CONTEXT_TAG as Nt, isMissingPathError as O, isToolResultMessage as Ot, commitAcceptedReply as P, hydrateConversationMessages as Q, loadProjection as R, resolveRepositoryInstructionsForDirectories as S, getUserMessageInstructionText as St, RIPGREP_EXCLUDED_GLOBS as T, isAssistantMessage as Tt, recordAuthenticationLinked as U, recordAgentsInstructionsUpdated as V, recordAuthorizationCompleted as W, recordTurnRoute as X, recordToolExecutionStarted as Y, appendConversationMessages as Z, AGENTS_REPLACEMENT_NOTICE as _, historyItemFromPiMessage as _t, completeTurnRecord as a, createConversationMemoryService as at, listRepositoryDirectories as b, getPiMessageRole as bt, getTurnRecordForResume as c, isHumanConversationMessage as ct, persistWithRetry as d, recordDeliveredAssistantMessage as dt, projectConversationMessages as et, TurnSliceLimitExceededError as f, turnHasReply as ft, AGENTS_REMOVAL_NOTICE as g, getAgentContextInputLimitTokens as gt, isTurnExecutionLimitExceededError as h, getAgentContextCompactionTriggerTokens as ht, abandonTurnRecord as i, buildConversationContext as it, positiveInteger as j, stripRuntimeTurnContext as jt, missingPathSearchResult as k, normalizeToolNameFromResult as kt, listTurnSummaries as l, markConversationMessage as lt, buildTurnErrorResponse as m, estimateTextTokens as mt, loadTurnCheckpoint as n, resolveConversationTitle as nt, failTurnRecord as o, estimateConversationContextTokens as ot, assertTurnToolCallLimit as p, upsertConversationMessage as pt, recordMcpProviderConnected as q, saveTurnCheckpoint as r, appendThreadContextMessages as rt, getTurnRecord as s, getConversationMessageSlackTs as st, continuableMessages as t, persistConversationMessageSummaries as tt, recordTurnSummary as u, normalizeConversationText as ut, buildAgentsInstructionsMessage as v, piMessageFromHistoryItem as vt, MAX_TEXT_CHARS as w, instructionTextForProjection as wt, renderAgentsInstructions as x, getTerminalAssistantMessages as xt, findVisibleAgentsInstructions as y, extractAssistantText as yt, loadTurnRoute as z };