blun-king-cli 9.1.614 → 9.1.616

package/worker-host.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:0533ca113dc07cc119988be5e76555dec986b6881903f8e2b537f5adf96cc2c5
+// BLUN_BUILD_INPUT_SHA256:8034cba54fd011bf9ce255483d60f6d12f8cdb9862b405ccf424ae40ac14b7c5
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import { createRequire } from "node:module";
-import crypto$1, { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
+import crypto$1, { createHash, createHmac, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fs$12 from "node:fs";
 import Kt, { appendFileSync, chmodSync, closeSync, constants, createReadStream, createWriteStream, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, opendirSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import * as path$11 from "node:path";
@@ -14,13 +14,14 @@ import { Blob as Blob$1, File as File$1 } from "node:buffer";
 import fs, { access, appendFile, chmod, copyFile, cp, link, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import * as nodeOs from "node:os";
 import os, { arch, homedir, hostname, release, tmpdir, type, userInfo } from "node:os";
-import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { Worker } from "node:worker_threads";
 import * as sysPath from "path";
 import path$1, { dirname as dirname$1, parse as parse$1 } from "path";
 import I, { existsSync as existsSync$1, promises as promises$1, stat as stat$1, unwatchFile, watch, watchFile } from "fs";
 import zi from "assert";
 import Qr, { EventEmitter } from "events";
+import { StringDecoder } from "node:string_decoder";
 import { lstat as lstat$1, open as open$1, readdir as readdir$1, realpath as realpath$1, stat as stat$2 } from "fs/promises";
 import Cs, { PassThrough, Readable, pipeline } from "node:stream";
 import { type as type$1 } from "os";
@@ -35,7 +36,6 @@ import * as win32Path from "node:path/win32";
 import { createServer } from "node:http";
 import { pipeline as pipeline$1 } from "node:stream/promises";
 import { EventEmitter as EventEmitter$1 } from "node:events";
-import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { QuickJSAsyncWASMModule, RELEASE_ASYNC, newQuickJSAsyncWASMModule, shouldInterruptAfterDeadline } from "quickjs-emscripten";
@@ -1888,6 +1888,9 @@ var FetchTransport = class {
 		const maxRetries = normalizeMaxRetries(requestOptions?.maxRetries);
 		const requestBytes = exactBodyBytes(init.body);
 		const requestBreakdown = pathname === "/chat/completions" && requestOptions?.onTransportAttempt !== void 0 && typeof init.body === "string" && requestBytes !== void 0 ? measureSerializedRequest(init.body, requestBytes) : void 0;
+		if (pathname === "/chat/completions" && typeof init.body === "string") try {
+			requestOptions?.onSerializedRequest?.(init.body);
+		} catch {}
 		let attempt = 0;
 		while (true) {
 			const headers = new Headers(init.headers);
@@ -1896,6 +1899,9 @@ var FetchTransport = class {
 			const startedAt = performance.now();
 			const startedAtMs = Date.now();
 			try {
+				try {
+					requestOptions?.onRequestSent?.();
+				} catch {}
 				const response = await this.fetch(`${this.baseUrl}${pathname}`, {
 					...init,
 					headers
@@ -1953,16 +1959,6 @@ function measureSerializedRequest(body, requestBytes) {
 		const payload = parsed;
 		const messages = Array.isArray(payload["messages"]) ? payload["messages"] : [];
 		const tools = Array.isArray(payload["tools"]) ? payload["tools"] : void 0;
-		let systemMessageBytes = 0;
-		let conversationMessageBytes = 0;
-		let toolResultMessageBytes = 0;
-		for (const message of messages) {
-			const size = Buffer.byteLength(JSON.stringify(message), "utf8");
-			const role = message !== null && typeof message === "object" ? message["role"] : void 0;
-			if (role === "system" || role === "developer") systemMessageBytes += size;
-			else if (role === "tool") toolResultMessageBytes += size;
-			else conversationMessageBytes += size;
-		}
 		const toolDefinitions = Object.freeze((tools ?? []).map((tool, index) => {
 			const entry = tool !== null && typeof tool === "object" ? tool : void 0;
 			const fn = entry?.["function"];
@@ -1973,6 +1969,44 @@ function measureSerializedRequest(body, requestBytes) {
 				...typeof name === "string" && name.length > 0 && name.length <= 128 ? { name } : {}
 			});
 		}));
+		const declaredNames = new Set(toolDefinitions.flatMap((tool) => tool.name === void 0 ? [] : [tool.name]));
+		const callNames = /* @__PURE__ */ new Map();
+		for (const message of messages) {
+			if (message === null || typeof message !== "object" || message["role"] !== "assistant") continue;
+			const calls = message["tool_calls"];
+			if (!Array.isArray(calls)) continue;
+			for (const call of calls) {
+				if (call === null || typeof call !== "object") continue;
+				const entry = call;
+				const fn = entry["function"];
+				const name = fn !== null && typeof fn === "object" ? fn["name"] : void 0;
+				const id = entry["id"];
+				if (typeof id !== "string" || id.length === 0) continue;
+				callNames.set(id, callNames.has(id) ? void 0 : typeof name === "string" && declaredNames.has(name) ? name : void 0);
+			}
+		}
+		let systemMessageBytes = 0;
+		let conversationMessageBytes = 0;
+		let toolResultMessageBytes = 0;
+		const results = /* @__PURE__ */ new Map();
+		for (const message of messages) {
+			const size = Buffer.byteLength(JSON.stringify(message), "utf8");
+			const role = message !== null && typeof message === "object" ? message["role"] : void 0;
+			if (role === "system" || role === "developer") systemMessageBytes += size;
+			else if (role === "tool") {
+				toolResultMessageBytes += size;
+				const id = message["tool_call_id"];
+				const name = typeof id === "string" ? callNames.get(id) : void 0;
+				const key = name ?? "";
+				const previous = results.get(key);
+				results.set(key, {
+					...name === void 0 ? {} : { name },
+					count: (previous?.count ?? 0) + 1,
+					bytes: (previous?.bytes ?? 0) + size
+				});
+			} else conversationMessageBytes += size;
+		}
+		const toolResultByTool = Object.freeze(Array.from(results.values(), (entry) => Object.freeze(entry)));
 		const toolArrayOverheadBytes = tools === void 0 ? 0 : 2 + Math.max(0, tools.length - 1);
 		const toolSchemaBytes = toolDefinitions.reduce((sum, tool) => sum + tool.bytes, toolArrayOverheadBytes);
 		return Object.freeze({
@@ -1982,6 +2016,7 @@ function measureSerializedRequest(body, requestBytes) {
 			systemMessageBytes,
 			conversationMessageBytes,
 			toolResultMessageBytes,
+			...toolResultByTool.length === 0 ? {} : { toolResultByTool },
 			toolSchemaBytes,
 			toolDefinitions,
 			toolArrayOverheadBytes,
@@ -2366,6 +2401,9 @@ function extractChatCompletionUsage(usage) {
 	const value = usage;
 	const promptTokens = typeof value["prompt_tokens"] === "number" ? value["prompt_tokens"] : 0;
 	const completionTokens = typeof value["completion_tokens"] === "number" ? value["completion_tokens"] : 0;
+	const completionDetails = value["completion_tokens_details"];
+	const reportedReasoning = completionDetails !== null && typeof completionDetails === "object" ? completionDetails["reasoning_tokens"] : void 0;
+	const outputReasoning = typeof reportedReasoning === "number" && Number.isSafeInteger(reportedReasoning) && reportedReasoning >= 0 && reportedReasoning <= completionTokens ? reportedReasoning : void 0;
 	let cachedTokens = 0;
 	if (typeof value["cached_tokens"] === "number") cachedTokens = value["cached_tokens"];
 	else if (value["prompt_tokens_details"] !== null && typeof value["prompt_tokens_details"] === "object") {
@@ -2375,6 +2413,7 @@ function extractChatCompletionUsage(usage) {
 	return {
 		inputOther: promptTokens - cachedTokens,
 		output: completionTokens,
+		...outputReasoning === void 0 ? {} : { outputReasoning },
 		inputCacheRead: cachedTokens,
 		inputCacheCreation: 0
 	};
@@ -2648,6 +2687,23 @@ function collectBlunVisionAttachments(messages) {
 	}
 	return attachments;
 }
+function estimateBlunSerializedBodyBytes(systemPrompt, tools, history) {
+	const normalizedHistory = normalizeToolCallIdsForProvider([...history], BLUN_TOOL_CALL_ID_POLICY);
+	const messages = systemPrompt ? [{
+		role: "system",
+		content: systemPrompt
+	}] : [];
+	for (const message of normalizedHistory) if (!isEmptyAssistantHistoryMessage(message)) messages.push(convertMessage(message));
+	const attachments = collectBlunVisionAttachments(normalizedHistory);
+	return Buffer.byteLength(JSON.stringify({
+		model: "king",
+		messages,
+		stream: true,
+		...tools.length > 0 ? { tools: tools.map(convertTool) } : {},
+		...attachments.length > 0 ? { visionAttachments: attachments } : {},
+		stream_options: { include_usage: true }
+	}), "utf8");
+}
 function convertMessage(message) {
 	let reasoningContent = "";
 	const nonThinkParts = [];
@@ -2957,12 +3013,13 @@ var BlunChatProvider = class {
 		if (this._stream) createParams["stream_options"] = { include_usage: true };
 		try {
 			const client = this._createClient(options?.auth);
-			const requestOptions = options?.signal !== void 0 || options?.transportMaxRetries !== void 0 || options?.onTransportAttempt !== void 0 ? {
+			const requestOptions = options?.signal !== void 0 || options?.transportMaxRetries !== void 0 || options?.onRequestSent !== void 0 || options?.onSerializedRequest !== void 0 || options?.onTransportAttempt !== void 0 ? {
 				...options.signal !== void 0 ? { signal: options.signal } : {},
 				...options.transportMaxRetries !== void 0 ? { maxRetries: options.transportMaxRetries } : {},
+				...options.onRequestSent !== void 0 ? { onRequestSent: options.onRequestSent } : {},
+				...options.onSerializedRequest !== void 0 ? { onSerializedRequest: options.onSerializedRequest } : {},
 				...options.onTransportAttempt !== void 0 ? { onTransportAttempt: options.onTransportAttempt } : {}
 			} : void 0;
-			options?.onRequestSent?.();
 			let response;
 			try {
 				response = await client.chat.completions.create(createParams, requestOptions);
@@ -2971,7 +3028,6 @@ var BlunChatProvider = class {
 				const cap = rejection instanceof APIContextOverflowError ? contextOverflowOutputCap(rejection, createParams["max_completion_tokens"]) : void 0;
 				if (cap === void 0) throw rejection;
 				options?.signal?.throwIfAborted();
-				options?.onRequestSent?.();
 				response = await client.chat.completions.create({
 					...createParams,
 					max_completion_tokens: cap
@@ -3358,9 +3414,11 @@ function emptyUsage() {
 * Sum two TokenUsage values.
 */
 function addUsage(a, b) {
+	const outputReasoning = a.outputReasoning !== void 0 && b.outputReasoning !== void 0 ? a.outputReasoning + b.outputReasoning : a.output === 0 ? b.outputReasoning : b.output === 0 ? a.outputReasoning : void 0;
 	return {
 		inputOther: a.inputOther + b.inputOther,
 		output: a.output + b.output,
+		...outputReasoning === void 0 ? {} : { outputReasoning },
 		inputCacheRead: a.inputCacheRead + b.inputCacheRead,
 		inputCacheCreation: a.inputCacheCreation + b.inputCacheCreation
 	};
@@ -9770,6 +9828,8 @@ const StringRecordSchema = record$2(string(), string());
 const ProviderConfigSchema = object({
 	type: ProviderTypeSchema,
 	apiKey: string().optional(),
+	memoryWorkspaceId: string().regex(/^blun-[0-9a-f]{64}$/u).optional(),
+	memoryApiKeyHash: string().regex(/^[0-9a-f]{64}$/u).optional(),
 	baseUrl: string().optional(),
 	defaultModel: string().optional(),
 	oauth: OAuthRefSchema.optional(),
@@ -10121,7 +10181,17 @@ async function canonicalWriterPath(target) {
 async function readOwner(lockDirectory) {
 	const directory = await lstat(lockDirectory);
 	if (!directory.isDirectory() || directory.isSymbolicLink()) throw unavailable();
-	const names = await readdir(lockDirectory);
+	let names;
+	try {
+		names = await readdir(lockDirectory);
+	} catch (error) {
+		if (process.platform === "win32" && codeOf(error) === "EPERM") try {
+			await lstat(lockDirectory);
+		} catch (inspectionError) {
+			if (codeOf(inspectionError) === "ENOENT") throw inspectionError;
+		}
+		throw error;
+	}
 	if (names.length === 0) return void 0;
 	const name = names[0];
 	const match = markerPattern.exec(name);
@@ -10196,7 +10266,10 @@ async function reclaimDeadOwner(lockDirectory) {
 	}
 }
 /** A local-host writer claim. It never expires based on age or missed heartbeats. */
-async function acquireSessionWriter(sessionDirectory) {
+async function acquireSessionWriter(sessionDirectory, options = {}) {
+	const waitForBusyMs = options.waitForBusyMs ?? 0;
+	if (!Number.isFinite(waitForBusyMs) || waitForBusyMs < 0 || waitForBusyMs > 5e3) throw new RangeError("Writer contention budget must be between 0 and 5000 milliseconds");
+	const deadline = performance.now() + waitForBusyMs;
 	let staged;
 	let name;
 	try {
@@ -10215,7 +10288,8 @@ async function acquireSessionWriter(sessionDirectory) {
 			flag: "wx",
 			mode: 384
 		});
-		for (let attempt = 0; attempt < 8; attempt += 1) {
+		let unownedCollisions = 0;
+		for (;;) {
 			try {
 				await rename(staged, lockDirectory);
 			} catch (error) {
@@ -10225,7 +10299,19 @@ async function acquireSessionWriter(sessionDirectory) {
 					"EPERM",
 					"EACCES"
 				].includes(codeOf(error) ?? "")) throw error;
-				await reclaimDeadOwner(lockDirectory);
+				try {
+					await reclaimDeadOwner(lockDirectory);
+				} catch (ownershipError) {
+					if (!(ownershipError instanceof BlunError) || ownershipError.code !== ErrorCodes.SESSION_WRITER_BUSY) throw ownershipError;
+					const remaining = deadline - performance.now();
+					if (waitForBusyMs === 0 || remaining <= 0) throw ownershipError;
+					await new Promise((resolve) => {
+						setTimeout(resolve, Math.min(25, remaining));
+					});
+					unownedCollisions = 0;
+					continue;
+				}
+				if (++unownedCollisions >= 8) throw unavailable();
 				continue;
 			}
 			let released = false;
@@ -10248,7 +10334,6 @@ async function acquireSessionWriter(sessionDirectory) {
 				}
 			};
 		}
-		throw unavailable();
 	} catch (error) {
 		if (error instanceof BlunError) throw error;
 		throw unavailable(error);
@@ -10318,7 +10403,8 @@ function tokenToWire(token) {
 		expires_at: token.expiresAt,
 		scope: token.scope,
 		token_type: token.tokenType,
-		expires_in: token.expiresIn
+		expires_in: token.expiresIn,
+		...token.memoryWorkspaceId === void 0 ? {} : { memory_workspace_id: token.memoryWorkspaceId }
 	};
 }
 function tokenFromWire(wire) {
@@ -10328,7 +10414,8 @@ function tokenFromWire(wire) {
 		expiresAt: typeof wire.expires_at === "number" ? wire.expires_at : 0,
 		scope: wire.scope ?? "",
 		tokenType: wire.token_type ?? "",
-		expiresIn: typeof wire.expires_in === "number" ? wire.expires_in : 0
+		expiresIn: typeof wire.expires_in === "number" ? wire.expires_in : 0,
+		...typeof wire.memory_workspace_id === "string" && wire.memory_workspace_id.length > 0 ? { memoryWorkspaceId: wire.memory_workspace_id } : {}
 	};
 }
 //#endregion
@@ -12719,6 +12806,27 @@ var OAuthManager = class {
 		const state = await this.loadState();
 		return state.kind === "valid" ? state.token.accessToken : void 0;
 	}
+	async getCachedMemoryWorkspaceId() {
+		const state = await this.loadState();
+		return state.kind === "valid" && state.token.expiresAt > this.now() ? state.token.memoryWorkspaceId : void 0;
+	}
+	async cacheMemoryWorkspaceId(workspaceId) {
+		if (workspaceId.length === 0) return false;
+		const release = await this.acquireRefreshLock();
+		try {
+			const state = await this.loadState();
+			if (state.kind !== "valid" || state.token.expiresAt <= this.now()) return false;
+			if (state.token.memoryWorkspaceId === workspaceId) return true;
+			if (state.token.memoryWorkspaceId !== void 0) return false;
+			await this.storage.save(this.config.name, {
+				...state.token,
+				memoryWorkspaceId: workspaceId
+			});
+			return true;
+		} finally {
+			await release();
+		}
+	}
 	async logout() {
 		await this.inFlightRefresh?.promise.catch(() => void 0);
 		const release = await this.acquireRefreshLock();
@@ -12786,7 +12894,10 @@ var OAuthManager = class {
 			if (activeToken.refreshToken.length === 0) throw new OAuthUnauthorizedError(`Token for "${this.config.name}" has no refresh_token; re-login required.`);
 			try {
 				const refreshed = await this.refreshImpl(this.config, activeToken.refreshToken);
-				await this.storage.save(this.config.name, refreshed);
+				await this.storage.save(this.config.name, {
+					...refreshed,
+					memoryWorkspaceId: activeToken.memoryWorkspaceId
+				});
 				this.notifyRefresh({ success: true });
 				return refreshed.accessToken;
 			} catch (error) {
@@ -14163,6 +14274,16 @@ var BlunOAuthToolkit = class {
 			hasToken: await this.managerFor(name, oauthKey, oauthHost).hasToken()
 		}] };
 	}
+	async getCachedMemoryWorkspaceId(oauthRef) {
+		const oauthHost = this.oauthHostFor(oauthRef);
+		const oauthKey = oauthRef?.key ?? this.defaultOAuthKey(void 0, oauthHost);
+		return this.managerFor(BLUN_PROVIDER_NAME$1, oauthKey, oauthHost).getCachedMemoryWorkspaceId();
+	}
+	async cacheMemoryWorkspaceId(workspaceId, oauthRef) {
+		const oauthHost = this.oauthHostFor(oauthRef);
+		const oauthKey = oauthRef?.key ?? this.defaultOAuthKey(void 0, oauthHost);
+		return this.managerFor(BLUN_PROVIDER_NAME$1, oauthKey, oauthHost).cacheMemoryWorkspaceId(workspaceId);
+	}
 	async login(providerName, options = {}) {
 		const name = providerName ?? "managed:blun";
 		const oauthHost = this.oauthHostFor(options.oauthRef, options.oauthHost);
@@ -16230,6 +16351,8 @@ function providerToToml(provider, rawProvider) {
 	for (const key of [
 		"type",
 		"apiKey",
+		"memoryWorkspaceId",
+		"memoryApiKeyHash",
 		"baseUrl",
 		"defaultModel",
 		"oauth",
@@ -16375,16 +16498,11 @@ function configWriterError(error) {
 	return error;
 }
 async function acquireConfigWriter(filePath) {
-	const deadline = performance.now() + 5e3;
-	for (;;) try {
-		return await acquireSessionWriter(filePath);
+	try {
+		return await acquireSessionWriter(filePath, { waitForBusyMs: 5e3 });
 	} catch (error) {
 		if (!(error instanceof BlunError) || error.code !== ErrorCodes.SESSION_WRITER_BUSY) throw error;
-		const remaining = deadline - performance.now();
-		if (remaining <= 0) throw new BlunError(ErrorCodes.CONFIG_WRITE_BUSY, "Another configuration change is still being saved", { cause: error });
-		await new Promise((resolve) => {
-			setTimeout(resolve, Math.min(25, remaining));
-		});
+		throw new BlunError(ErrorCodes.CONFIG_WRITE_BUSY, "Another configuration change is still being saved", { cause: error });
 	}
 }
 /** Keep transforms synchronous; credential validation and discovery belong before this boundary. */
@@ -21678,6 +21796,31 @@ var InstructionText = class InstructionText {
 	get content() {
 		return this.pieces.map((piece) => piece.text).join("");
 	}
+	prefixUtf8(maxBytes) {
+		if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("Invalid instruction byte budget");
+		const kept = [];
+		let remaining = maxBytes;
+		let totalBytes = 0;
+		let readBytes = 0;
+		for (const piece of this.pieces) {
+			const encoded = Buffer.from(piece.text, "utf8");
+			totalBytes += encoded.length;
+			if (remaining <= 0) continue;
+			const content = encoded.length <= remaining ? piece.text : new StringDecoder("utf8").write(encoded.subarray(0, remaining));
+			const bytes = Buffer.byteLength(content, "utf8");
+			if (content.length > 0) kept.push({
+				...piece,
+				text: content
+			});
+			readBytes += bytes;
+			remaining -= bytes;
+			if (bytes < encoded.length) remaining = 0;
+		}
+		return {
+			text: new InstructionText(kept, new Map(this.sources)),
+			omittedBytes: totalBytes - readBytes
+		};
+	}
 	replaceFirst(needle, replacement) {
 		const start = this.content.indexOf(needle);
 		if (start >= 0) this.replaceRange(start, start + needle.length, replacement);
@@ -21735,6 +21878,64 @@ const IMPORT_MAX_DEPTH = 4;
 const IMPORT_LINE_RE = /^@import\s+(.+)$/gm;
 const S_IFMT$4 = 61440;
 const S_IFREG$2 = 32768;
+function fitAgentsMdContext(context, maxFixedRequestBytes, measureFixedRequestBytes) {
+	if (!Number.isSafeInteger(maxFixedRequestBytes) || maxFixedRequestBytes <= 0) throw new RangeError("Invalid fixed request byte budget");
+	const originalBytes = measureFixedRequestBytes(context);
+	if (originalBytes <= maxFixedRequestBytes) return {
+		context,
+		fixedRequestBytes: originalBytes,
+		omittedBytes: 0,
+		fits: true
+	};
+	const source = context.agentsMdText;
+	if (source === void 0) return {
+		context,
+		fixedRequestBytes: originalBytes,
+		omittedBytes: 0,
+		fits: false
+	};
+	const totalBytes = source.measure().totalBytes;
+	const candidateAt = (maxBytes) => {
+		const { text } = source.prefixUtf8(maxBytes);
+		return {
+			...context,
+			agentsMd: text.content,
+			agentsMdSources: text.measure(),
+			agentsMdText: text
+		};
+	};
+	let low = 0;
+	let high = totalBytes;
+	let fitted = candidateAt(0);
+	let fittedBytes = measureFixedRequestBytes(fitted);
+	if (fittedBytes > maxFixedRequestBytes) {
+		const omittedBytes = context.agentsMdSources?.files.reduce((sum, file) => sum + file.bytes, 0) ?? totalBytes;
+		return {
+			context: fitted,
+			fixedRequestBytes: fittedBytes,
+			omittedBytes,
+			fits: false
+		};
+	}
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		const candidate = candidateAt(middle);
+		const bytes = measureFixedRequestBytes(candidate);
+		if (bytes <= maxFixedRequestBytes) {
+			low = middle;
+			fitted = candidate;
+			fittedBytes = bytes;
+		} else high = middle - 1;
+	}
+	const omittedBytes = context.agentsMdSources?.files.reduce((sum, file) => sum + file.bytes, 0) ?? totalBytes;
+	const retainedBytes = fitted.agentsMdSources?.files.reduce((sum, file) => sum + file.bytes, 0) ?? 0;
+	return {
+		context: fitted,
+		fixedRequestBytes: fittedBytes,
+		omittedBytes: omittedBytes - retainedBytes,
+		fits: true
+	};
+}
 async function prepareSystemPromptContext(kaos, brandHome, options) {
 	const additionalDirs = normalizeAdditionalDirs(options?.additionalDirs ?? []);
 	const [cwdListing, agentsMdResult, additionalDirsInfo] = await Promise.all([
@@ -21747,7 +21948,8 @@ async function prepareSystemPromptContext(kaos, brandHome, options) {
 		agentsMd: agentsMdResult.content,
 		additionalDirsInfo,
 		agentsMdWarning: agentsMdResult.warning,
-		agentsMdSources: agentsMdResult.sources
+		agentsMdSources: agentsMdResult.sources,
+		agentsMdText: agentsMdResult.text
 	};
 }
 async function loadAgentsMd(kaos, brandHome) {
@@ -21757,10 +21959,15 @@ async function loadAgentsMdForRoots(kaos, brandHome, workDirs) {
 	const discovered = [];
 	const emptySources = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
+	const notLoadedCandidates = /* @__PURE__ */ new Set();
 	const collect = async (path) => {
 		const file = await readAgentFile(kaos, path);
-		if (file === void 0) return false;
+		if (file === void 0) {
+			notLoadedCandidates.add(kaos.normpath(path));
+			return false;
+		}
 		const key = kaos.normpath(file.path);
+		notLoadedCandidates.delete(key);
 		if (file.content.length === 0) {
 			emptySources.set(key, InstructionText.file(file.path, "", file.sourceTextBytes));
 			return false;
@@ -21796,7 +22003,11 @@ async function loadAgentsMdForRoots(kaos, brandHome, workDirs) {
 	return {
 		content,
 		warning: totalBytes > AGENTS_MD_RECOMMENDED_MAX_BYTES ? `AGENTS.md total ${formatKB(totalBytes)} KB exceeds the recommended ${formatKB(AGENTS_MD_RECOMMENDED_MAX_BYTES)} KB. Large instruction files increase cost and may impact performance; consider trimming.` : void 0,
-		sources: rendered.measure()
+		text: rendered,
+		sources: {
+			...rendered.measure(),
+			...notLoadedCandidates.size === 0 ? {} : { notLoadedCandidates: [...notLoadedCandidates] }
+		}
 	};
 }
 async function loadAdditionalDirsInfo(kaos, additionalDirs) {
@@ -28778,17 +28989,20 @@ function createSystemPromptRenderer(merged) {
 				const counts = renderPromptContributions(merged.systemPromptTemplate, vars, rendered, true) ?? renderPromptContributions(merged.systemPromptTemplate, vars, rendered);
 				const sources = context.agentsMdSources;
 				const copies = counts?.instructionCopies ?? 0;
-				const sourceMatches = sources !== void 0 && sources.version === 1 && Number.isSafeInteger(sources.generatedBytes) && sources.generatedBytes >= 0 && sources.files.every((file) => typeof file.path === "string" && Number.isSafeInteger(file.bytes) && file.bytes >= 0) && sources.totalBytes === Buffer.byteLength(vars["BLUN_AGENTS_MD"] ?? "", "utf8") && sources.generatedBytes + sources.files.reduce((sum, file) => sum + file.bytes, 0) === sources.totalBytes;
+				const sourceMatches = sources !== void 0 && sources.version === 1 && Number.isSafeInteger(sources.generatedBytes) && sources.generatedBytes >= 0 && sources.files.every((file) => typeof file.path === "string" && Number.isSafeInteger(file.bytes) && file.bytes >= 0) && (sources.notLoadedCandidates?.every((path) => typeof path === "string") ?? true) && sources.totalBytes === Buffer.byteLength(vars["BLUN_AGENTS_MD"] ?? "", "utf8") && sources.generatedBytes + sources.files.reduce((sum, file) => sum + file.bytes, 0) === sources.totalBytes;
+				const notLoadedCandidates = sourceMatches && sources.notLoadedCandidates !== void 0 ? { notLoadedCandidates: [...sources.notLoadedCandidates] } : {};
 				const instructionSources = copies === 0 ? {
 					version: 1,
 					totalBytes: 0,
 					generatedBytes: 0,
-					files: sourceMatches ? sources.files.map((file) => copyInstructionFileBytes(file, 0)) : []
+					files: sourceMatches ? sources.files.map((file) => copyInstructionFileBytes(file, 0)) : [],
+					...notLoadedCandidates
 				} : !sourceMatches ? void 0 : {
 					version: 1,
 					totalBytes: sources.totalBytes * copies,
 					generatedBytes: sources.generatedBytes * copies,
-					files: sources.files.map((file) => copyInstructionFileBytes(file, copies))
+					files: sources.files.map((file) => copyInstructionFileBytes(file, copies)),
+					...notLoadedCandidates
 				};
 				const skillListingSources = counts === void 0 ? void 0 : scaleSkillListingSources(skillSources, vars["BLUN_SKILLS"] ?? "", counts.skillListingBytes);
 				context.onContributions(counts === void 0 ? void 0 : {
@@ -29811,7 +30025,7 @@ var FileSystemAgentRecordPersistence = class {
 	async *readFrom(offset, recordCount) {
 		if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(recordCount) || recordCount < 0) throw new Error("Invalid Wire replay offset");
 		await this.flush();
-		let line = "";
+		const fragments = [];
 		let lineNumber = recordCount;
 		let byteLength = offset;
 		const stream = createReadStream(this.filePath, {
@@ -29820,29 +30034,36 @@ var FileSystemAgentRecordPersistence = class {
 		});
 		try {
 			for await (const chunk of stream) {
-				line += chunk;
-				let newlineIndex = line.indexOf("\n");
+				let start = 0;
+				let newlineIndex = chunk.indexOf("\n", start);
 				while (newlineIndex !== -1) {
-					const rawLine = line.slice(0, newlineIndex);
-					line = line.slice(newlineIndex + 1);
+					const part = chunk.slice(start, newlineIndex);
+					let rawLine = part;
+					if (fragments.length > 0) {
+						fragments.push(part);
+						rawLine = fragments.join("");
+						fragments.length = 0;
+					}
 					lineNumber++;
 					byteLength += Buffer.byteLength(rawLine, "utf8") + 1;
 					const record = parseRecordLine(rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine, lineNumber, this.filePath, false);
 					if (record !== void 0) yield record;
-					newlineIndex = line.indexOf("\n");
+					start = newlineIndex + 1;
+					newlineIndex = chunk.indexOf("\n", start);
 				}
+				if (start < chunk.length) fragments.push(chunk.slice(start));
 			}
 		} catch (error) {
 			if (error.code === "ENOENT") return;
 			throw error;
 		}
-		if (line.length > 0) {
+		if (fragments.length > 0) {
 			lineNumber++;
-			const record = parseRecordLine(line, lineNumber, this.filePath, true);
+			const record = parseRecordLine(fragments.join(""), lineNumber, this.filePath, true);
 			if (record !== void 0) yield record;
 		}
 		this.persistedRecordCount = lineNumber;
-		this.persistedByteLength = line.length === 0 ? byteLength : void 0;
+		this.persistedByteLength = fragments.length === 0 ? byteLength : void 0;
 	}
 	append(input) {
 		this.throwIfError();
@@ -180665,6 +180886,10 @@ var GoalMode = class {
 	restoreUpdate(record) {
 		const state = this.state;
 		if (state === void 0) return;
+		if (record.objective !== void 0) {
+			state.objective = record.objective;
+			this.lifecycleRevision += 1;
+		}
 		const status = record.status;
 		if (status !== void 0) {
 			this.lifecycleRevision += 1;
@@ -180679,7 +180904,17 @@ var GoalMode = class {
 			state.wallClockResumedAt = void 0;
 		}
 		if (record.budgetLimits !== void 0) state.budgetLimits = record.budgetLimits;
-		if (status === void 0) return;
+		if (status === void 0) {
+			if (record.objective !== void 0) this.agent.replayBuilder.push({
+				type: "goal_updated",
+				snapshot: this.toSnapshot(state),
+				change: {
+					kind: "edited",
+					actor: record.actor
+				}
+			});
+			return;
+		}
 		this.agent.replayBuilder.push({
 			type: "goal_updated",
 			snapshot: this.toSnapshot(state),
@@ -180723,11 +180958,11 @@ var GoalMode = class {
 		if (objective.length === 0) throw new BlunError(ErrorCodes.GOAL_OBJECTIVE_EMPTY, "Goal objective cannot be empty");
 		if (objective.length > MAX_GOAL_OBJECTIVE_LENGTH) throw new BlunError(ErrorCodes.GOAL_OBJECTIVE_TOO_LONG, `Goal objective cannot exceed ${MAX_GOAL_OBJECTIVE_LENGTH} characters`);
 		const verificationScope = normalizeVerificationScope(input.verificationScope);
+		const completionCriterion = normalizeCompletionCriterion(input.completionCriterion);
 		if (this.state !== void 0) {
 			if (input.replace !== true) throw new BlunError(ErrorCodes.GOAL_ALREADY_EXISTS, "A goal already exists; use replace to start a new one");
 			this.clearInternal("system");
 		}
-		const completionCriterion = normalizeCompletionCriterion(input.completionCriterion);
 		const state = {
 			goalId: randomUUID(),
 			objective,
@@ -180751,6 +180986,35 @@ var GoalMode = class {
 		this.trackGoalCreated(actor, input.replace === true);
 		return this.toSnapshot(state);
 	}
+	async completeGoal() {
+		const state = this.requireState();
+		if (state.status !== "active") throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Cannot complete a goal in status "${state.status}"`);
+		return this.markComplete({}, "user");
+	}
+	async blockGoal(input = {}) {
+		const state = this.requireState();
+		if (state.status === "blocked") return this.toSnapshot(state);
+		if (state.status !== "active") throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Cannot block a goal in status "${state.status}"`);
+		return await this.markBlocked(input, "user");
+	}
+	async editGoal(input, actor = "user") {
+		const state = this.requireState();
+		const objective = input.objective.trim();
+		if (objective.length === 0) throw new BlunError(ErrorCodes.GOAL_OBJECTIVE_EMPTY, "Goal objective cannot be empty");
+		if (objective.length > MAX_GOAL_OBJECTIVE_LENGTH) throw new BlunError(ErrorCodes.GOAL_OBJECTIVE_TOO_LONG, `Goal objective cannot exceed ${MAX_GOAL_OBJECTIVE_LENGTH} characters`);
+		if (objective === state.objective) return this.toSnapshot(state);
+		state.objective = objective;
+		this.lifecycleRevision += 1;
+		this.appendGoalUpdate({
+			objective,
+			actor
+		});
+		this.persistState(state, { change: {
+			kind: "edited",
+			actor
+		} });
+		return this.toSnapshot(state);
+	}
 	async pauseGoal(input = {}, actor = "user") {
 		const state = this.requireState();
 		if (state.status === "paused") return this.toSnapshot(state);
@@ -181520,6 +181784,613 @@ var ProviderRetryWait = class {
 		}
 	}
 };
+const IMAGE_MIME_BY_SUFFIX = Object.freeze({
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".bmp": "image/bmp",
+	".tif": "image/tiff",
+	".tiff": "image/tiff",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".heic": "image/heic",
+	".heif": "image/heif",
+	".avif": "image/avif",
+	".svgz": "image/svg+xml"
+});
+const VIDEO_MIME_BY_SUFFIX = Object.freeze({
+	".mp4": "video/mp4",
+	".mpg": "video/mpeg",
+	".mpeg": "video/mpeg",
+	".mkv": "video/x-matroska",
+	".avi": "video/x-msvideo",
+	".mov": "video/quicktime",
+	".ogv": "video/ogg",
+	".wmv": "video/x-ms-wmv",
+	".webm": "video/webm",
+	".m4v": "video/x-m4v",
+	".flv": "video/x-flv",
+	".3gp": "video/3gpp",
+	".3g2": "video/3gpp2"
+});
+const TEXT_MIME_BY_SUFFIX = Object.freeze({ ".svg": "image/svg+xml" });
+const NON_TEXT_SUFFIXES = new Set([
+	".icns",
+	".psd",
+	".ai",
+	".eps",
+	".pdf",
+	".doc",
+	".docx",
+	".dot",
+	".dotx",
+	".rtf",
+	".odt",
+	".xls",
+	".xlsx",
+	".xlsm",
+	".xlt",
+	".xltx",
+	".xltm",
+	".ods",
+	".ppt",
+	".pptx",
+	".pptm",
+	".pps",
+	".ppsx",
+	".odp",
+	".pages",
+	".numbers",
+	".key",
+	".zip",
+	".rar",
+	".7z",
+	".tar",
+	".gz",
+	".tgz",
+	".bz2",
+	".xz",
+	".zst",
+	".lz",
+	".lz4",
+	".br",
+	".cab",
+	".ar",
+	".deb",
+	".rpm",
+	".mp3",
+	".wav",
+	".flac",
+	".ogg",
+	".oga",
+	".opus",
+	".aac",
+	".m4a",
+	".wma",
+	".ttf",
+	".otf",
+	".woff",
+	".woff2",
+	".exe",
+	".dll",
+	".so",
+	".dylib",
+	".bin",
+	".apk",
+	".ipa",
+	".jar",
+	".class",
+	".pyc",
+	".pyo",
+	".wasm",
+	".dmg",
+	".iso",
+	".img",
+	".sqlite",
+	".sqlite3",
+	".db",
+	".db3"
+]);
+const ASF_HEADER = Buffer.from([
+	48,
+	38,
+	178,
+	117,
+	142,
+	102,
+	207,
+	17,
+	166,
+	217,
+	0,
+	170,
+	0,
+	98,
+	206,
+	108
+]);
+const FTYP_IMAGE_BRANDS = Object.freeze({
+	avif: "image/avif",
+	avis: "image/avif",
+	heic: "image/heic",
+	heif: "image/heif",
+	heix: "image/heif",
+	hevc: "image/heic",
+	mif1: "image/heif",
+	msf1: "image/heif"
+});
+const FTYP_VIDEO_BRANDS = Object.freeze({
+	isom: "video/mp4",
+	iso2: "video/mp4",
+	iso5: "video/mp4",
+	mp41: "video/mp4",
+	mp42: "video/mp4",
+	avc1: "video/mp4",
+	mp4v: "video/mp4",
+	m4v: "video/x-m4v",
+	qt: "video/quicktime",
+	"3gp4": "video/3gpp",
+	"3gp5": "video/3gpp",
+	"3gp6": "video/3gpp",
+	"3gp7": "video/3gpp",
+	"3g2": "video/3gpp2"
+});
+function toBuffer(data) {
+	return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}
+function startsWith(buf, prefix) {
+	const needle = Buffer.isBuffer(prefix) ? prefix : Buffer.from(prefix);
+	if (buf.length < needle.length) return false;
+	for (let i = 0; i < needle.length; i += 1) if (buf[i] !== needle[i]) return false;
+	return true;
+}
+function sniffFtypBrand(header) {
+	if (header.length < 12) return null;
+	if (header.subarray(4, 8).toString("latin1") !== "ftyp") return null;
+	return header.subarray(8, 12).toString("latin1").toLowerCase().replaceAll(/[\s\u0000]+$/g, "").trim();
+}
+function sniffMediaFromMagic(data) {
+	const buf = toBuffer(data);
+	const header = buf.length > 512 ? buf.subarray(0, 512) : buf;
+	if (startsWith(header, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	])) return {
+		kind: "image",
+		mimeType: "image/png"
+	};
+	if (startsWith(header, [
+		255,
+		216,
+		255
+	])) return {
+		kind: "image",
+		mimeType: "image/jpeg"
+	};
+	if (startsWith(header, Buffer.from("GIF87a")) || startsWith(header, Buffer.from("GIF89a"))) return {
+		kind: "image",
+		mimeType: "image/gif"
+	};
+	if (startsWith(header, Buffer.from("BM"))) return {
+		kind: "image",
+		mimeType: "image/bmp"
+	};
+	if (startsWith(header, [
+		73,
+		73,
+		42,
+		0
+	]) || startsWith(header, [
+		77,
+		77,
+		0,
+		42
+	])) return {
+		kind: "image",
+		mimeType: "image/tiff"
+	};
+	if (startsWith(header, [
+		0,
+		0,
+		1,
+		0
+	])) return {
+		kind: "image",
+		mimeType: "image/x-icon"
+	};
+	if (startsWith(header, Buffer.from("RIFF")) && header.length >= 12) {
+		const chunk = header.subarray(8, 12).toString("latin1");
+		if (chunk === "WEBP") return {
+			kind: "image",
+			mimeType: "image/webp"
+		};
+		if (chunk === "AVI ") return {
+			kind: "video",
+			mimeType: "video/x-msvideo"
+		};
+	}
+	if (startsWith(header, Buffer.from("FLV"))) return {
+		kind: "video",
+		mimeType: "video/x-flv"
+	};
+	if (startsWith(header, ASF_HEADER)) return {
+		kind: "video",
+		mimeType: "video/x-ms-wmv"
+	};
+	if (startsWith(header, [
+		26,
+		69,
+		223,
+		163
+	])) {
+		const lowered = header.toString("latin1").toLowerCase();
+		if (lowered.includes("webm")) return {
+			kind: "video",
+			mimeType: "video/webm"
+		};
+		if (lowered.includes("matroska")) return {
+			kind: "video",
+			mimeType: "video/x-matroska"
+		};
+	}
+	const brand = sniffFtypBrand(header);
+	if (brand !== null && brand !== "") {
+		if (brand in FTYP_IMAGE_BRANDS) return {
+			kind: "image",
+			mimeType: FTYP_IMAGE_BRANDS[brand]
+		};
+		if (brand in FTYP_VIDEO_BRANDS) return {
+			kind: "video",
+			mimeType: FTYP_VIDEO_BRANDS[brand]
+		};
+	}
+	return null;
+}
+/**
+* Best-effort pixel-dimension reader for common raster formats.
+*
+* Inspects only the fixed region near the start of the file where each
+* format records its dimensions (the IHDR/DIB header, the RIFF chunk
+* after the `WEBP` tag, or the first JPEG SOFn segment). Returns `null`
+* for formats whose dimensions are not locatable from that region, or
+* when the supplied buffer is too short to cover it.
+*/
+function sniffImageDimensions(data) {
+	const buf = toBuffer(data);
+	if (startsWith(buf, [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]) && buf.length >= 24) return {
+		width: buf.readUInt32BE(16),
+		height: buf.readUInt32BE(20)
+	};
+	if ((startsWith(buf, Buffer.from("GIF87a")) || startsWith(buf, Buffer.from("GIF89a"))) && buf.length >= 10) return {
+		width: buf.readUInt16LE(6),
+		height: buf.readUInt16LE(8)
+	};
+	if (startsWith(buf, Buffer.from("BM")) && buf.length >= 26) return {
+		width: buf.readInt32LE(18),
+		height: Math.abs(buf.readInt32LE(22))
+	};
+	if (startsWith(buf, Buffer.from("RIFF")) && buf.length >= 30) {
+		const fourCc = buf.subarray(12, 16).toString("latin1");
+		if (fourCc === "VP8 ") return {
+			width: buf.readUInt16LE(26) & 16383,
+			height: buf.readUInt16LE(28) & 16383
+		};
+		if (fourCc === "VP8L" && buf.length >= 25) {
+			const bits = buf.readUInt32LE(21);
+			return {
+				width: (bits & 16383) + 1,
+				height: (bits >> 14 & 16383) + 1
+			};
+		}
+		if (fourCc === "VP8X") return {
+			width: 1 + (buf[24] | buf[25] << 8 | buf[26] << 16),
+			height: 1 + (buf[27] | buf[28] << 8 | buf[29] << 16)
+		};
+	}
+	if (startsWith(buf, [255, 216])) {
+		let offset = 2;
+		while (offset + 9 < buf.length) {
+			if (buf[offset] !== 255) {
+				offset += 1;
+				continue;
+			}
+			const marker = buf[offset + 1];
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
+				height: buf.readUInt16BE(offset + 5),
+				width: buf.readUInt16BE(offset + 7)
+			};
+			if (marker === 216 || marker === 217 || marker >= 208 && marker <= 215) {
+				offset += 2;
+				continue;
+			}
+			const segmentLength = buf.readUInt16BE(offset + 2);
+			if (segmentLength < 2) break;
+			offset += 2 + segmentLength;
+		}
+	}
+	return null;
+}
+function getSuffix(path) {
+	const idx = path.lastIndexOf(".");
+	if (idx === -1) return "";
+	if (idx <= Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1) return "";
+	return path.slice(idx).toLowerCase();
+}
+function detectFileType(path, header, type = "text") {
+	const suffix = getSuffix(path);
+	let mediaHint = null;
+	if (suffix in TEXT_MIME_BY_SUFFIX) mediaHint = {
+		kind: "text",
+		mimeType: TEXT_MIME_BY_SUFFIX[suffix]
+	};
+	else if (suffix in IMAGE_MIME_BY_SUFFIX) mediaHint = {
+		kind: "image",
+		mimeType: IMAGE_MIME_BY_SUFFIX[suffix]
+	};
+	else if (suffix in VIDEO_MIME_BY_SUFFIX) mediaHint = {
+		kind: "video",
+		mimeType: VIDEO_MIME_BY_SUFFIX[suffix]
+	};
+	if (header !== void 0) {
+		const buf = toBuffer(header);
+		const sniffed = sniffMediaFromMagic(buf);
+		if (sniffed) {
+			if (type === "media") return sniffed;
+			if (mediaHint) {
+				if (sniffed.kind !== mediaHint.kind) return {
+					kind: "unknown",
+					mimeType: ""
+				};
+				return mediaHint;
+			}
+			return sniffed;
+		}
+		if (mediaHint?.kind === "image") return {
+			kind: "unknown",
+			mimeType: ""
+		};
+		if (type === "media" && mediaHint?.kind === "video") return mediaHint;
+		if (buf.includes(0)) return {
+			kind: "unknown",
+			mimeType: ""
+		};
+	}
+	if (mediaHint) return mediaHint;
+	if (NON_TEXT_SUFFIXES.has(suffix)) return {
+		kind: "unknown",
+		mimeType: ""
+	};
+	return {
+		kind: "text",
+		mimeType: "text/plain"
+	};
+}
+//#endregion
+//#region ../../packages/agent-core/src/utils/tokens.ts
+const messageTokenEstimateCache = /* @__PURE__ */ new WeakMap();
+/** Open assistant messages grow while streaming; completed history stays cached. */
+function invalidateMessageTokenEstimate(message) {
+	messageTokenEstimateCache.delete(message);
+}
+/**
+* Estimate token count from text using a character-based heuristic.
+*   - ASCII (~4 chars per token)
+*   - CJK and other non-ASCII (~1 char per token)
+* The estimate is transient — the next LLM call returns the real count
+* and supersedes this value. Used to keep `tokenCountWithPending`
+* monotonic between LLM round-trips without paying for a tokenizer.
+*/
+function estimateTokens(text) {
+	let asciiCount = 0;
+	let nonAsciiCount = 0;
+	for (const char of text) if (char.codePointAt(0) <= 127) asciiCount++;
+	else nonAsciiCount++;
+	return Math.ceil(asciiCount / 4) + nonAsciiCount;
+}
+function estimateTokensForMessages(messages) {
+	let total = 0;
+	for (const message of messages) total += estimateTokensForMessage(message);
+	return total;
+}
+/** With stopAfter, the result is a lower bound once it exceeds that budget. */
+function estimateTokensForTools(tools, stopAfter = Infinity) {
+	let total = 0;
+	for (const tool of tools) {
+		total += estimateTokens(tool.name);
+		total += estimateTokens(tool.description);
+		total += estimateTokens(JSON.stringify(tool.parameters));
+		if (total > stopAfter) return total;
+	}
+	return total;
+}
+function estimateTokensForMessage(message) {
+	const cached = messageTokenEstimateCache.get(message);
+	if (cached !== void 0) return cached;
+	let total = estimateTokens(message.role);
+	total += estimateTokensForContentParts(message.content);
+	if (message.toolCalls !== void 0) for (const call of message.toolCalls) {
+		total += estimateTokens(call.name);
+		total += estimateTokens(JSON.stringify(call.arguments));
+	}
+	messageTokenEstimateCache.set(message, total);
+	return total;
+}
+function estimateTokensForContentParts(parts) {
+	let total = 0;
+	for (const part of parts) total += estimateTokensForContentPart(part);
+	return total;
+}
+/**
+* Conservative transient fallback for media whose pixel dimensions or duration
+* are unavailable. Inline raster images use their transmitted dimensions below;
+* audio, video, remote images, and malformed image data keep this safe floor.
+* The next successful LLM round-trip replaces the estimate with reported usage.
+*/
+const MEDIA_TOKEN_ESTIMATE = 2e3;
+/** Enough header data for common JPEG metadata followed by the first SOF marker. */
+const MAX_IMAGE_HEADER_BYTES = 1024 * 1024;
+function imageDimensionsFromDataUrl(url) {
+	const commaIndex = url.indexOf(",");
+	if (commaIndex <= 0) return null;
+	const metadata = url.slice(0, commaIndex).toLowerCase();
+	if (!metadata.startsWith("data:image/") || !metadata.split(";").includes("base64")) return null;
+	const maxBase64Chars = Math.ceil(MAX_IMAGE_HEADER_BYTES / 3) * 4;
+	const encodedHeader = url.slice(commaIndex + 1, commaIndex + 1 + maxBase64Chars);
+	if (encodedHeader.length === 0) return null;
+	try {
+		const dimensions = sniffImageDimensions(Buffer.from(encodedHeader, "base64"));
+		if (dimensions === null || !Number.isSafeInteger(dimensions.width) || !Number.isSafeInteger(dimensions.height) || dimensions.width <= 0 || dimensions.height <= 0) return null;
+		return dimensions;
+	} catch {
+		return null;
+	}
+}
+function estimateImageTokensFromDimensions(width, height) {
+	if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) return MEDIA_TOKEN_ESTIMATE;
+	const patchSize = BigInt(32);
+	const tokens = (BigInt(width) + patchSize - 1n) / patchSize * ((BigInt(height) + patchSize - 1n) / patchSize);
+	return tokens > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(tokens);
+}
+function estimateImageTokens(url) {
+	const dimensions = imageDimensionsFromDataUrl(url);
+	return dimensions === null ? MEDIA_TOKEN_ESTIMATE : estimateImageTokensFromDimensions(dimensions.width, dimensions.height);
+}
+function estimateTokensForContentPart(part) {
+	switch (part.type) {
+		case "text": return estimateTokens(part.text);
+		case "think": return estimateTokens(part.think);
+		case "image_url": return estimateImageTokens(part.imageUrl.url);
+		case "audio_url":
+		case "video_url": return MEDIA_TOKEN_ESTIMATE;
+		default: return 0;
+	}
+}
+const MAX_TOOL_CONTINUITY_SERIALIZED_BYTES = 4096;
+function saturatingAdd(left, right) {
+	return left + Math.min(right, Number.MAX_SAFE_INTEGER - left);
+}
+function renderUnchecked(value) {
+	return [
+		"",
+		"",
+		"<tool-continuity>",
+		"Observed tool-result flags; may be synthetic, not verified job success or permission. omitted counts excluded observations cumulatively, not jobs.",
+		JSON.stringify(value).replaceAll(/[<>&]/g, (character) => {
+			return `\\u${character.codePointAt(0).toString(16).padStart(4, "0")}`;
+		}),
+		"</tool-continuity>"
+	].join("\n");
+}
+function hasExactKeys(value, expected) {
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return false;
+	return Reflect.ownKeys(value).length === expected.length && expected.every((key) => {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		return descriptor !== void 0 && descriptor.enumerable === true && Object.hasOwn(descriptor, "value");
+	});
+}
+function isDataArray(value) {
+	if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || value.length > 8 || Reflect.ownKeys(value).length !== value.length + 1) return false;
+	for (let index = 0; index < value.length; index++) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+		if (descriptor === void 0 || descriptor.enumerable !== true || !Object.hasOwn(descriptor, "value")) return false;
+	}
+	return true;
+}
+/** Validate restored metadata without interpreting any summarizer or tool prose. */
+function isToolContinuity(value) {
+	try {
+		if (value === null || typeof value !== "object" || !hasExactKeys(value, ["receipts", "omitted"])) return false;
+		const candidate = value;
+		if (!Number.isSafeInteger(candidate["omitted"]) || candidate["omitted"] < 0 || !isDataArray(candidate["receipts"]) || candidate["receipts"].length > 8) return false;
+		for (const receipt of candidate["receipts"]) if (receipt === null || typeof receipt !== "object" || !hasExactKeys(receipt, ["toolCallId", "observedIsError"]) || !("toolCallId" in receipt) || !("observedIsError" in receipt) || typeof receipt.toolCallId !== "string" || receipt.toolCallId.length === 0 || Buffer.byteLength(receipt.toolCallId, "utf8") > 256 || receipt.observedIsError !== null && typeof receipt.observedIsError !== "boolean") return false;
+		return Buffer.byteLength(JSON.stringify(renderUnchecked(value)), "utf8") <= MAX_TOOL_CONTINUITY_SERIALIZED_BYTES;
+	} catch {
+		return false;
+	}
+}
+function renderToolContinuity(value) {
+	if (!isToolContinuity(value) || value.receipts.length === 0 && value.omitted === 0) return void 0;
+	return renderUnchecked(value);
+}
+/** The caller passes only the compactable prefix, excluding the preserved tool suffix. */
+function collectToolContinuity(messages) {
+	const observed = /* @__PURE__ */ new Map();
+	let ordinal = 0;
+	let inheritedOmitted = 0;
+	let excluded = 0;
+	const remember = (toolCallId, observedIsError) => {
+		if (toolCallId.length === 0 || Buffer.byteLength(toolCallId, "utf8") > 256) {
+			excluded = saturatingAdd(excluded, 1);
+			return;
+		}
+		const key = JSON.stringify([toolCallId, observedIsError]);
+		observed.set(key, {
+			toolCallId,
+			observedIsError,
+			ordinal: ordinal++
+		});
+	};
+	for (const message of messages) if (message.role === "tool" && typeof message.toolCallId === "string") remember(message.toolCallId, typeof message.isError === "boolean" ? message.isError : null);
+	else if (message.role === "user" && message.origin?.kind === "compaction_summary") {
+		const previous = message.origin.toolContinuity;
+		if (!isToolContinuity(previous)) continue;
+		for (const receipt of previous.receipts.toReversed()) remember(receipt.toolCallId, receipt.observedIsError);
+		inheritedOmitted = Math.max(inheritedOmitted, previous.omitted);
+	}
+	const prioritized = [...observed.values()].toSorted((left, right) => Number(right.observedIsError === true) - Number(left.observedIsError === true) || right.ordinal - left.ordinal);
+	const receipts = prioritized.slice(0, 8).map(({ toolCallId, observedIsError }) => ({
+		toolCallId,
+		observedIsError
+	}));
+	let omitted = saturatingAdd(saturatingAdd(inheritedOmitted, excluded), prioritized.length - receipts.length);
+	while (true) {
+		const result = {
+			receipts: [...receipts],
+			omitted
+		};
+		if (renderToolContinuity(result) !== void 0) return result;
+		if (receipts.length === 0) return void 0;
+		receipts.pop();
+		omitted = saturatingAdd(omitted, 1);
+	}
+}
+/** Fit complete tuples and their disclaimer; never start a new failure or retry path. */
+function fitToolContinuity(value, additionalTokenBudget) {
+	if (value === void 0 || !isToolContinuity(value) || !(additionalTokenBudget > 0)) return void 0;
+	const receipts = [...value.receipts];
+	let omitted = value.omitted;
+	while (true) {
+		const continuity = {
+			receipts: [...receipts],
+			omitted
+		};
+		const text = renderToolContinuity(continuity);
+		if (text !== void 0 && estimateTokens(text) <= additionalTokenBudget) return {
+			continuity,
+			text
+		};
+		if (receipts.length === 0) return void 0;
+		receipts.pop();
+		omitted = saturatingAdd(omitted, 1);
+	}
+}
 //#endregion
 //#region ../../packages/agent-core/src/agent/records/resume-snapshot.ts
 const integer$1 = number$1().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
@@ -181614,6 +182485,7 @@ const stateRecordSchema = union([
 		verificationScope: _enum(GOAL_VERIFICATION_SCOPES).optional()
 	}),
 	record$1("goal.update", {
+		objective: text.min(1).max(4e3).regex(/\S/).optional(),
 		status: _enum([
 			"active",
 			"paused",
@@ -181665,7 +182537,7 @@ const originCase = (kind, shape = {}) => object({
 }).passthrough();
 const origin = union([
 	originCase("user"),
-	originCase("compaction_summary"),
+	originCase("compaction_summary", { toolContinuity: custom$1(isToolContinuity).optional() }),
 	originCase("skill_activation", {
 		activationId: text,
 		skillName: text,
@@ -182016,6 +182888,7 @@ async function writeResumeCheckpoint(wirePath, position, snapshot) {
 	if (Buffer.byteLength(bytes) > MAX_CHECKPOINT_BYTES) return false;
 	const target = resumeCheckpointPath(wirePath);
 	const temporary = `${target}.tmp-${process.pid}-${randomBytes(8).toString("hex")}`;
+	let renamed = false;
 	try {
 		const output = await open(temporary, "wx", 384);
 		try {
@@ -182025,10 +182898,11 @@ async function writeResumeCheckpoint(wirePath, position, snapshot) {
 			await output.close();
 		}
 		await rename(temporary, target);
+		renamed = true;
 		await syncDir(dirname$3(target));
 		return true;
 	} finally {
-		await rm(temporary, { force: true }).catch(() => {});
+		if (!renamed) await rm(temporary, { force: true }).catch(() => {});
 	}
 }
 //#endregion
@@ -185365,501 +186239,6 @@ var TodoListTool = class {
 		})));
 	}
 };
-const IMAGE_MIME_BY_SUFFIX = Object.freeze({
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".gif": "image/gif",
-	".bmp": "image/bmp",
-	".tif": "image/tiff",
-	".tiff": "image/tiff",
-	".webp": "image/webp",
-	".ico": "image/x-icon",
-	".heic": "image/heic",
-	".heif": "image/heif",
-	".avif": "image/avif",
-	".svgz": "image/svg+xml"
-});
-const VIDEO_MIME_BY_SUFFIX = Object.freeze({
-	".mp4": "video/mp4",
-	".mpg": "video/mpeg",
-	".mpeg": "video/mpeg",
-	".mkv": "video/x-matroska",
-	".avi": "video/x-msvideo",
-	".mov": "video/quicktime",
-	".ogv": "video/ogg",
-	".wmv": "video/x-ms-wmv",
-	".webm": "video/webm",
-	".m4v": "video/x-m4v",
-	".flv": "video/x-flv",
-	".3gp": "video/3gpp",
-	".3g2": "video/3gpp2"
-});
-const TEXT_MIME_BY_SUFFIX = Object.freeze({ ".svg": "image/svg+xml" });
-const NON_TEXT_SUFFIXES = new Set([
-	".icns",
-	".psd",
-	".ai",
-	".eps",
-	".pdf",
-	".doc",
-	".docx",
-	".dot",
-	".dotx",
-	".rtf",
-	".odt",
-	".xls",
-	".xlsx",
-	".xlsm",
-	".xlt",
-	".xltx",
-	".xltm",
-	".ods",
-	".ppt",
-	".pptx",
-	".pptm",
-	".pps",
-	".ppsx",
-	".odp",
-	".pages",
-	".numbers",
-	".key",
-	".zip",
-	".rar",
-	".7z",
-	".tar",
-	".gz",
-	".tgz",
-	".bz2",
-	".xz",
-	".zst",
-	".lz",
-	".lz4",
-	".br",
-	".cab",
-	".ar",
-	".deb",
-	".rpm",
-	".mp3",
-	".wav",
-	".flac",
-	".ogg",
-	".oga",
-	".opus",
-	".aac",
-	".m4a",
-	".wma",
-	".ttf",
-	".otf",
-	".woff",
-	".woff2",
-	".exe",
-	".dll",
-	".so",
-	".dylib",
-	".bin",
-	".apk",
-	".ipa",
-	".jar",
-	".class",
-	".pyc",
-	".pyo",
-	".wasm",
-	".dmg",
-	".iso",
-	".img",
-	".sqlite",
-	".sqlite3",
-	".db",
-	".db3"
-]);
-const ASF_HEADER = Buffer.from([
-	48,
-	38,
-	178,
-	117,
-	142,
-	102,
-	207,
-	17,
-	166,
-	217,
-	0,
-	170,
-	0,
-	98,
-	206,
-	108
-]);
-const FTYP_IMAGE_BRANDS = Object.freeze({
-	avif: "image/avif",
-	avis: "image/avif",
-	heic: "image/heic",
-	heif: "image/heif",
-	heix: "image/heif",
-	hevc: "image/heic",
-	mif1: "image/heif",
-	msf1: "image/heif"
-});
-const FTYP_VIDEO_BRANDS = Object.freeze({
-	isom: "video/mp4",
-	iso2: "video/mp4",
-	iso5: "video/mp4",
-	mp41: "video/mp4",
-	mp42: "video/mp4",
-	avc1: "video/mp4",
-	mp4v: "video/mp4",
-	m4v: "video/x-m4v",
-	qt: "video/quicktime",
-	"3gp4": "video/3gpp",
-	"3gp5": "video/3gpp",
-	"3gp6": "video/3gpp",
-	"3gp7": "video/3gpp",
-	"3g2": "video/3gpp2"
-});
-function toBuffer(data) {
-	return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-}
-function startsWith(buf, prefix) {
-	const needle = Buffer.isBuffer(prefix) ? prefix : Buffer.from(prefix);
-	if (buf.length < needle.length) return false;
-	for (let i = 0; i < needle.length; i += 1) if (buf[i] !== needle[i]) return false;
-	return true;
-}
-function sniffFtypBrand(header) {
-	if (header.length < 12) return null;
-	if (header.subarray(4, 8).toString("latin1") !== "ftyp") return null;
-	return header.subarray(8, 12).toString("latin1").toLowerCase().replaceAll(/[\s\u0000]+$/g, "").trim();
-}
-function sniffMediaFromMagic(data) {
-	const buf = toBuffer(data);
-	const header = buf.length > 512 ? buf.subarray(0, 512) : buf;
-	if (startsWith(header, [
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	])) return {
-		kind: "image",
-		mimeType: "image/png"
-	};
-	if (startsWith(header, [
-		255,
-		216,
-		255
-	])) return {
-		kind: "image",
-		mimeType: "image/jpeg"
-	};
-	if (startsWith(header, Buffer.from("GIF87a")) || startsWith(header, Buffer.from("GIF89a"))) return {
-		kind: "image",
-		mimeType: "image/gif"
-	};
-	if (startsWith(header, Buffer.from("BM"))) return {
-		kind: "image",
-		mimeType: "image/bmp"
-	};
-	if (startsWith(header, [
-		73,
-		73,
-		42,
-		0
-	]) || startsWith(header, [
-		77,
-		77,
-		0,
-		42
-	])) return {
-		kind: "image",
-		mimeType: "image/tiff"
-	};
-	if (startsWith(header, [
-		0,
-		0,
-		1,
-		0
-	])) return {
-		kind: "image",
-		mimeType: "image/x-icon"
-	};
-	if (startsWith(header, Buffer.from("RIFF")) && header.length >= 12) {
-		const chunk = header.subarray(8, 12).toString("latin1");
-		if (chunk === "WEBP") return {
-			kind: "image",
-			mimeType: "image/webp"
-		};
-		if (chunk === "AVI ") return {
-			kind: "video",
-			mimeType: "video/x-msvideo"
-		};
-	}
-	if (startsWith(header, Buffer.from("FLV"))) return {
-		kind: "video",
-		mimeType: "video/x-flv"
-	};
-	if (startsWith(header, ASF_HEADER)) return {
-		kind: "video",
-		mimeType: "video/x-ms-wmv"
-	};
-	if (startsWith(header, [
-		26,
-		69,
-		223,
-		163
-	])) {
-		const lowered = header.toString("latin1").toLowerCase();
-		if (lowered.includes("webm")) return {
-			kind: "video",
-			mimeType: "video/webm"
-		};
-		if (lowered.includes("matroska")) return {
-			kind: "video",
-			mimeType: "video/x-matroska"
-		};
-	}
-	const brand = sniffFtypBrand(header);
-	if (brand !== null && brand !== "") {
-		if (brand in FTYP_IMAGE_BRANDS) return {
-			kind: "image",
-			mimeType: FTYP_IMAGE_BRANDS[brand]
-		};
-		if (brand in FTYP_VIDEO_BRANDS) return {
-			kind: "video",
-			mimeType: FTYP_VIDEO_BRANDS[brand]
-		};
-	}
-	return null;
-}
-/**
-* Best-effort pixel-dimension reader for common raster formats.
-*
-* Inspects only the fixed region near the start of the file where each
-* format records its dimensions (the IHDR/DIB header, the RIFF chunk
-* after the `WEBP` tag, or the first JPEG SOFn segment). Returns `null`
-* for formats whose dimensions are not locatable from that region, or
-* when the supplied buffer is too short to cover it.
-*/
-function sniffImageDimensions(data) {
-	const buf = toBuffer(data);
-	if (startsWith(buf, [
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	]) && buf.length >= 24) return {
-		width: buf.readUInt32BE(16),
-		height: buf.readUInt32BE(20)
-	};
-	if ((startsWith(buf, Buffer.from("GIF87a")) || startsWith(buf, Buffer.from("GIF89a"))) && buf.length >= 10) return {
-		width: buf.readUInt16LE(6),
-		height: buf.readUInt16LE(8)
-	};
-	if (startsWith(buf, Buffer.from("BM")) && buf.length >= 26) return {
-		width: buf.readInt32LE(18),
-		height: Math.abs(buf.readInt32LE(22))
-	};
-	if (startsWith(buf, Buffer.from("RIFF")) && buf.length >= 30) {
-		const fourCc = buf.subarray(12, 16).toString("latin1");
-		if (fourCc === "VP8 ") return {
-			width: buf.readUInt16LE(26) & 16383,
-			height: buf.readUInt16LE(28) & 16383
-		};
-		if (fourCc === "VP8L" && buf.length >= 25) {
-			const bits = buf.readUInt32LE(21);
-			return {
-				width: (bits & 16383) + 1,
-				height: (bits >> 14 & 16383) + 1
-			};
-		}
-		if (fourCc === "VP8X") return {
-			width: 1 + (buf[24] | buf[25] << 8 | buf[26] << 16),
-			height: 1 + (buf[27] | buf[28] << 8 | buf[29] << 16)
-		};
-	}
-	if (startsWith(buf, [255, 216])) {
-		let offset = 2;
-		while (offset + 9 < buf.length) {
-			if (buf[offset] !== 255) {
-				offset += 1;
-				continue;
-			}
-			const marker = buf[offset + 1];
-			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
-				height: buf.readUInt16BE(offset + 5),
-				width: buf.readUInt16BE(offset + 7)
-			};
-			if (marker === 216 || marker === 217 || marker >= 208 && marker <= 215) {
-				offset += 2;
-				continue;
-			}
-			const segmentLength = buf.readUInt16BE(offset + 2);
-			if (segmentLength < 2) break;
-			offset += 2 + segmentLength;
-		}
-	}
-	return null;
-}
-function getSuffix(path) {
-	const idx = path.lastIndexOf(".");
-	if (idx === -1) return "";
-	if (idx <= Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1) return "";
-	return path.slice(idx).toLowerCase();
-}
-function detectFileType(path, header, type = "text") {
-	const suffix = getSuffix(path);
-	let mediaHint = null;
-	if (suffix in TEXT_MIME_BY_SUFFIX) mediaHint = {
-		kind: "text",
-		mimeType: TEXT_MIME_BY_SUFFIX[suffix]
-	};
-	else if (suffix in IMAGE_MIME_BY_SUFFIX) mediaHint = {
-		kind: "image",
-		mimeType: IMAGE_MIME_BY_SUFFIX[suffix]
-	};
-	else if (suffix in VIDEO_MIME_BY_SUFFIX) mediaHint = {
-		kind: "video",
-		mimeType: VIDEO_MIME_BY_SUFFIX[suffix]
-	};
-	if (header !== void 0) {
-		const buf = toBuffer(header);
-		const sniffed = sniffMediaFromMagic(buf);
-		if (sniffed) {
-			if (type === "media") return sniffed;
-			if (mediaHint) {
-				if (sniffed.kind !== mediaHint.kind) return {
-					kind: "unknown",
-					mimeType: ""
-				};
-				return mediaHint;
-			}
-			return sniffed;
-		}
-		if (mediaHint?.kind === "image") return {
-			kind: "unknown",
-			mimeType: ""
-		};
-		if (type === "media" && mediaHint?.kind === "video") return mediaHint;
-		if (buf.includes(0)) return {
-			kind: "unknown",
-			mimeType: ""
-		};
-	}
-	if (mediaHint) return mediaHint;
-	if (NON_TEXT_SUFFIXES.has(suffix)) return {
-		kind: "unknown",
-		mimeType: ""
-	};
-	return {
-		kind: "text",
-		mimeType: "text/plain"
-	};
-}
-//#endregion
-//#region ../../packages/agent-core/src/utils/tokens.ts
-const messageTokenEstimateCache = /* @__PURE__ */ new WeakMap();
-/** Open assistant messages grow while streaming; completed history stays cached. */
-function invalidateMessageTokenEstimate(message) {
-	messageTokenEstimateCache.delete(message);
-}
-/**
-* Estimate token count from text using a character-based heuristic.
-*   - ASCII (~4 chars per token)
-*   - CJK and other non-ASCII (~1 char per token)
-* The estimate is transient — the next LLM call returns the real count
-* and supersedes this value. Used to keep `tokenCountWithPending`
-* monotonic between LLM round-trips without paying for a tokenizer.
-*/
-function estimateTokens(text) {
-	let asciiCount = 0;
-	let nonAsciiCount = 0;
-	for (const char of text) if (char.codePointAt(0) <= 127) asciiCount++;
-	else nonAsciiCount++;
-	return Math.ceil(asciiCount / 4) + nonAsciiCount;
-}
-function estimateTokensForMessages(messages) {
-	let total = 0;
-	for (const message of messages) total += estimateTokensForMessage(message);
-	return total;
-}
-function estimateTokensForTools(tools) {
-	let total = 0;
-	for (const tool of tools) {
-		total += estimateTokens(tool.name);
-		total += estimateTokens(tool.description);
-		total += estimateTokens(JSON.stringify(tool.parameters));
-	}
-	return total;
-}
-function estimateTokensForMessage(message) {
-	const cached = messageTokenEstimateCache.get(message);
-	if (cached !== void 0) return cached;
-	let total = estimateTokens(message.role);
-	total += estimateTokensForContentParts(message.content);
-	if (message.toolCalls !== void 0) for (const call of message.toolCalls) {
-		total += estimateTokens(call.name);
-		total += estimateTokens(JSON.stringify(call.arguments));
-	}
-	messageTokenEstimateCache.set(message, total);
-	return total;
-}
-function estimateTokensForContentParts(parts) {
-	let total = 0;
-	for (const part of parts) total += estimateTokensForContentPart(part);
-	return total;
-}
-/**
-* Conservative transient fallback for media whose pixel dimensions or duration
-* are unavailable. Inline raster images use their transmitted dimensions below;
-* audio, video, remote images, and malformed image data keep this safe floor.
-* The next successful LLM round-trip replaces the estimate with reported usage.
-*/
-const MEDIA_TOKEN_ESTIMATE = 2e3;
-/** Enough header data for common JPEG metadata followed by the first SOF marker. */
-const MAX_IMAGE_HEADER_BYTES = 1024 * 1024;
-function imageDimensionsFromDataUrl(url) {
-	const commaIndex = url.indexOf(",");
-	if (commaIndex <= 0) return null;
-	const metadata = url.slice(0, commaIndex).toLowerCase();
-	if (!metadata.startsWith("data:image/") || !metadata.split(";").includes("base64")) return null;
-	const maxBase64Chars = Math.ceil(MAX_IMAGE_HEADER_BYTES / 3) * 4;
-	const encodedHeader = url.slice(commaIndex + 1, commaIndex + 1 + maxBase64Chars);
-	if (encodedHeader.length === 0) return null;
-	try {
-		const dimensions = sniffImageDimensions(Buffer.from(encodedHeader, "base64"));
-		if (dimensions === null || !Number.isSafeInteger(dimensions.width) || !Number.isSafeInteger(dimensions.height) || dimensions.width <= 0 || dimensions.height <= 0) return null;
-		return dimensions;
-	} catch {
-		return null;
-	}
-}
-function estimateImageTokensFromDimensions(width, height) {
-	if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) return MEDIA_TOKEN_ESTIMATE;
-	const patchSize = BigInt(32);
-	const tokens = (BigInt(width) + patchSize - 1n) / patchSize * ((BigInt(height) + patchSize - 1n) / patchSize);
-	return tokens > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(tokens);
-}
-function estimateImageTokens(url) {
-	const dimensions = imageDimensionsFromDataUrl(url);
-	return dimensions === null ? MEDIA_TOKEN_ESTIMATE : estimateImageTokensFromDimensions(dimensions.width, dimensions.height);
-}
-function estimateTokensForContentPart(part) {
-	switch (part.type) {
-		case "text": return estimateTokens(part.text);
-		case "think": return estimateTokens(part.think);
-		case "image_url": return estimateImageTokens(part.imageUrl.url);
-		case "audio_url":
-		case "video_url": return MEDIA_TOKEN_ESTIMATE;
-		default: return 0;
-	}
-}
 //#endregion
 //#region ../../node_modules/.pnpm/bmp-ts@1.0.9/node_modules/bmp-ts/dist/esm/header-types.js
 var HeaderTypes, header_types_default;
@@ -228325,6 +228704,8 @@ async function compressImageForModel(bytes, mimeType, options = {}) {
 	if (bytes.length <= byteBudget && (longestEdge > 0 && longestEdge <= maxEdge || longestEdge === 0)) return passthrough();
 	if (dims && dims.width * dims.height > MAX_DECODE_PIXELS) return passthrough();
 	if (bytes.length > maxDecodeBytes) return passthrough();
+	const detected = detectFileType("", bytes.subarray(0, 512), "media");
+	if (!RECODABLE_MIME.has(detected.mimeType)) return passthrough();
 	try {
 		const { Jimp } = await Promise.resolve().then(() => (init_esm(), esm_exports$3));
 		const image = await Jimp.fromBuffer(Buffer.from(bytes));
@@ -230115,7 +230496,7 @@ function buildCompactionSummaryText(summary) {
 const MAX_SESSION_COMPACTION_FAILURES = 2;
 const DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS = 128 * 1024;
 const COMPACTION_SUMMARY_RESERVE_RATIO = .1;
-const BLUN_COMPACTION_REQUEST_BUDGET_BYTES = 75e4;
+const BLUN_COMPACTION_REQUEST_BUDGET_BYTES = 48e4;
 const MAX_HIERARCHICAL_COMPACTION_PASSES = 64;
 const HIERARCHICAL_COMPACTION_PREFIX = "This is a complete summary of an earlier chronological segment. Preserve it as source material when merging it with the following conversation:";
 var CompactionTruncatedError = class extends Error {
@@ -230235,16 +230616,19 @@ var FullCompaction = class {
 		const projected = context.additionalMessages === void 0 ? messages : [...messages, ...context.additionalMessages];
 		const historyBudget = this.requestHistoryByteBudget(projected);
 		const historyThresholdReached = historyBudget !== void 0 && historyBudget.usedHistoryBytes >= historyBudget.thresholdHistoryBytes;
+		const requestBudget = this.requestBodyByteBudget(projected, context);
+		const requestThresholdReached = requestBudget !== void 0 && requestBudget.usedRequestBytesEstimate >= requestBudget.thresholdRequestBytes;
 		if (this.sessionCompactionFailures >= MAX_SESSION_COMPACTION_FAILURES) reason = "session_stopped";
 		else if (this.isCompacting) reason = "already_compacting";
-		else if (thresholdTokens === void 0 && historyBudget === void 0) reason = "no_budget";
-		else if (!historyThresholdReached && (thresholdTokens === void 0 || !Number.isFinite(usedTokens) || usedTokens < thresholdTokens)) reason = "below_threshold";
+		else if (thresholdTokens === void 0 && historyBudget === void 0 && requestBudget === void 0) reason = "no_budget";
+		else if (!historyThresholdReached && !requestThresholdReached && (thresholdTokens === void 0 || !Number.isFinite(usedTokens) || usedTokens < thresholdTokens)) reason = "below_threshold";
 		else if (!this.hasShrinkableHistory(projected)) reason = "nothing_to_compact";
 		return {
 			eligible: reason === "eligible",
 			usedTokens,
 			thresholdTokens,
 			...historyBudget,
+			...requestBudget,
 			reason
 		};
 	}
@@ -230266,6 +230650,19 @@ var FullCompaction = class {
 			thresholdHistoryBytes: limit
 		};
 	}
+	requestBodyByteBudget(messages, context) {
+		const limit = this.agent.blunConfig?.loopControl?.maxRequestHistoryBytes;
+		if (!this.agent.config.hasProvider || this.strategy.compactionBudgetTokens === void 0 || limit !== void 0 && (!Number.isSafeInteger(limit) || limit <= 0)) return void 0;
+		const model = this.agent.activeResponderModel ?? this.agent.config.modelAlias;
+		if (model === void 0 || this.agent.config.runtimeModel(model).provider.name !== "blun") return void 0;
+		const systemPrompt = context.systemPrompt ?? this.agent.effectiveSystemPrompt;
+		const tools = context.tools ?? this.agent.tools.loopTools;
+		if (estimateBlunSerializedBodyBytes(systemPrompt, [], []) + 4096 >= BLUN_COMPACTION_REQUEST_BUDGET_BYTES) return void 0;
+		return {
+			usedRequestBytesEstimate: estimateBlunSerializedBodyBytes(systemPrompt, tools, messages) + 4096,
+			thresholdRequestBytes: BLUN_COMPACTION_REQUEST_BUDGET_BYTES
+		};
+	}
 	requestProactiveCompaction(context = {}) {
 		const status = this.proactiveCompactionStatus(context);
 		if (status.eligible && !this.proactiveCompactionRequested) {
@@ -230274,7 +230671,9 @@ var FullCompaction = class {
 				used_tokens: status.usedTokens,
 				threshold_tokens: status.thresholdTokens,
 				used_history_bytes: status.usedHistoryBytes,
-				threshold_history_bytes: status.thresholdHistoryBytes
+				threshold_history_bytes: status.thresholdHistoryBytes,
+				used_request_bytes_estimate: status.usedRequestBytesEstimate,
+				threshold_request_bytes: status.thresholdRequestBytes
 			});
 		}
 		return status;
@@ -230403,7 +230802,9 @@ var FullCompaction = class {
 		const requestTokens = this.estimateCurrentRequestTokens(requestContext);
 		const budget = this.getCompactionBudgetTokens();
 		const historyBudget = this.requestHistoryByteBudget(projectedMessages);
-		const proactive = (historyBudget !== void 0 && historyBudget.usedHistoryBytes >= historyBudget.thresholdHistoryBytes || !this.isCompacting && budget !== void 0 && Number.isFinite(requestTokens) && requestTokens >= Math.max(1, Math.floor(budget * .9))) && this.hasShrinkableHistory(projectedMessages);
+		const historyThresholdReached = historyBudget !== void 0 && historyBudget.usedHistoryBytes >= historyBudget.thresholdHistoryBytes;
+		const requestBudget = this.requestBodyByteBudget(projectedMessages, requestContext);
+		const proactive = (requestBudget !== void 0 && requestBudget.usedRequestBytesEstimate >= requestBudget.thresholdRequestBytes || historyThresholdReached || !this.isCompacting && budget !== void 0 && Number.isFinite(requestTokens) && requestTokens >= Math.max(1, Math.floor(budget * .9))) && this.hasShrinkableHistory(projectedMessages);
 		if (this.checkAutoCompaction(true, requestTokens, projectedMessages, proactive) && (proactive || this.strategy.shouldBlock(requestTokens))) await this.block(signal);
 		signal.throwIfAborted();
 		const compacted = this.agent.context.history !== historyBefore;
@@ -230613,7 +231014,7 @@ var FullCompaction = class {
 					dropOrphanResults: true
 				}), createUserMessage(requestInstruction)], capability));
 			};
-			const estimateRequestBytes = (messages) => Buffer.byteLength(JSON.stringify(messages), "utf8") + Buffer.byteLength(this.agent.config.systemPrompt, "utf8");
+			const estimateRequestBytes = (messages) => estimateBlunSerializedBodyBytes(this.agent.effectiveSystemPrompt, compactionTools, messages) + 4096;
 			while (true) {
 				signal.throwIfAborted();
 				if (hierarchicalPassCount >= MAX_HIERARCHICAL_COMPACTION_PASSES) throw new BlunError(ErrorCodes.COMPACTION_FAILED, `Compaction stopped after ${String(MAX_HIERARCHICAL_COMPACTION_PASSES)} staged requests without reaching a final summary. The conversation history was not changed.`, { details: {
@@ -231292,6 +231693,13 @@ const CronRunStatusSchema = _enum([
 ]);
 const counter = number$1().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 const timestamp$1 = string().datetime();
+const CronProviderUsageSchema = object({
+	inputOther: counter,
+	inputCacheRead: counter,
+	inputCacheCreation: counter,
+	output: counter,
+	outputReasoning: counter.optional()
+}).strict();
 const CronRunReceiptSchema = object({
 	runId: CronRunIdSchema,
 	jobId: CronJobIdSchema,
@@ -231312,6 +231720,7 @@ const CronRunReceiptSchema = object({
 		names: array(string().regex(/^[\w.:-]{1,160}$/)).max(64),
 		excessNames: counter
 	}).strict(),
+	providerUsage: CronProviderUsageSchema.nullable().optional(),
 	outputs: array(object({
 		rootRef: string().regex(/^(workspace|additional:[0-9]+)$/),
 		path: string().min(1).max(1024).refine((value) => Buffer.byteLength(value) <= 1024 && !value.startsWith("/") && !value.includes("\\") && !value.includes(":") && !value.split("/").some((part) => part === ".." || part === ".") && !/[\u0000-\u001F\u007F]/.test(value))
@@ -231347,6 +231756,7 @@ function publicCronRun(run) {
 		coalescedCount: receipt.coalescedCount,
 		toolCalls: receipt.toolSummary.calls,
 		toolErrors: receipt.toolSummary.errors,
+		providerUsage: receipt.providerUsage ?? null,
 		outputCount: receipt.outputs.length,
 		finalMessageAvailable: run.finalMessage !== null,
 		durable: run.durable
@@ -231548,6 +231958,8 @@ var CronRunOutputCollector = class {
 	errors = 0;
 	excessNames = 0;
 	outputs = [];
+	providerUsage;
+	usageComplete = true;
 	invalid = false;
 	constructor(roots) {
 		this.roots = roots;
@@ -231568,6 +231980,7 @@ var CronRunOutputCollector = class {
 		}
 		if (event.type === "step.retrying") {
 			if (event.turnId !== String(this.turnId)) return;
+			this.usageComplete = false;
 			if (this.step === void 0 || this.step.id !== event.stepUuid || this.step.step !== event.step || this.step.tools) this.invalid = true;
 			else {
 				this.step = {
@@ -231636,19 +232049,29 @@ var CronRunOutputCollector = class {
 		} else if (event.type === "step.end") {
 			const step = this.step;
 			if (step === void 0 || event.uuid !== step.id || event.step !== step.step) this.invalid = true;
-			else if (event.finishReason === "end_turn" && !step.tools && !this.invalid) {
-				const clipped = prefix(step.text);
-				const truncated = step.chars > clipped.length;
-				const text = clipped + (truncated ? CRON_RUN_TRUNCATION_MARKER : "");
-				if (text) this.candidate = {
-					stepId: step.id,
-					turnId: this.turnId,
-					message: {
-						text,
-						truncated,
-						chars: step.chars
-					}
-				};
+			else {
+				const usage = event.usage === void 0 ? void 0 : CronProviderUsageSchema.safeParse(event.usage);
+				if (usage?.success !== true) this.usageComplete = false;
+				else {
+					const total = this.providerUsage === void 0 ? usage.data : addUsage(this.providerUsage, usage.data);
+					const checked = CronProviderUsageSchema.safeParse(total);
+					if (checked.success) this.providerUsage = checked.data;
+					else this.usageComplete = false;
+				}
+				if (event.finishReason === "end_turn" && !step.tools && !this.invalid) {
+					const clipped = prefix(step.text);
+					const truncated = step.chars > clipped.length;
+					const text = clipped + (truncated ? CRON_RUN_TRUNCATION_MARKER : "");
+					if (text) this.candidate = {
+						stepId: step.id,
+						turnId: this.turnId,
+						message: {
+							text,
+							truncated,
+							chars: step.chars
+						}
+					};
+				}
 			}
 			this.step = void 0;
 		}
@@ -231663,6 +232086,7 @@ var CronRunOutputCollector = class {
 				excessNames: this.excessNames
 			},
 			outputs: structuredClone(this.outputs),
+			providerUsage: complete && this.usageComplete && this.providerUsage !== void 0 ? structuredClone(this.providerUsage) : null,
 			final: complete ? this.candidate : void 0,
 			complete
 		};
@@ -232821,6 +233245,7 @@ var CronManager = class {
 			status,
 			endedAt: new Date(this.clocks.wallNow()).toISOString(),
 			toolSummary: result.toolSummary,
+			providerUsage: completed ? result.providerUsage : null,
 			outputs: result.outputs,
 			finalMessageRef: final === void 0 ? null : {
 				stepId: final.stepId,
@@ -233008,6 +233433,7 @@ var CronManager = class {
 				names: [],
 				excessNames: 0
 			},
+			providerUsage: null,
 			outputs: [],
 			finalMessageRef: null,
 			unavailableReason
@@ -234063,6 +234489,10 @@ const SYNTHETIC_TOOL_RESULT_TEXT = "Tool result is not available in the current
 function repairToolExchangeAdjacency(messages, options) {
 	let lastNonToolIndex = messages.length - 1;
 	while (lastNonToolIndex >= 0 && messages[lastNonToolIndex]?.role === "tool") lastNonToolIndex -= 1;
+	let remainingResults;
+	const consumeResult = (toolCallId) => {
+		if (remainingResults !== void 0) remainingResults.set(toolCallId, (remainingResults.get(toolCallId) ?? 0) - 1);
+	};
 	const out = [];
 	const consumed = /* @__PURE__ */ new Set();
 	for (let i = 0; i < messages.length; i++) {
@@ -234070,12 +234500,15 @@ function repairToolExchangeAdjacency(messages, options) {
 		const message = messages[i];
 		if (message.role !== "assistant" || message.toolCalls.length === 0) {
 			out.push(message);
+			if (message.role === "tool" && message.toolCallId !== void 0) consumeResult(message.toolCallId);
 			continue;
 		}
 		out.push(message);
 		const pending = new Set(message.toolCalls.map((toolCall) => toolCall.id));
+		const counts = remainingResults;
+		let searchable = counts === void 0 ? void 0 : new Set([...pending].filter((id) => (counts.get(id) ?? 0) > 0));
 		let foreignBetween = false;
-		for (let j = i + 1; j < messages.length && pending.size > 0; j++) {
+		for (let j = i + 1; j < messages.length && (searchable ?? pending).size > 0; j++) {
 			if (consumed.has(j)) continue;
 			const next = messages[j];
 			const toolCallId = next.toolCallId;
@@ -234083,11 +234516,25 @@ function repairToolExchangeAdjacency(messages, options) {
 				out.push(next);
 				consumed.add(j);
 				pending.delete(toolCallId);
+				searchable?.delete(toolCallId);
+				consumeResult(toolCallId);
 				if (foreignBetween) options?.onAnomaly?.({
 					kind: "tool_result_reordered",
 					toolCallId
 				});
-			} else foreignBetween = true;
+			} else {
+				foreignBetween = true;
+				if (remainingResults === void 0) {
+					remainingResults = /* @__PURE__ */ new Map();
+					for (let index = j; index < messages.length; index += 1) {
+						if (consumed.has(index)) continue;
+						const result = messages[index];
+						if (result.role === "tool" && result.toolCallId !== void 0) remainingResults.set(result.toolCallId, (remainingResults.get(result.toolCallId) ?? 0) + 1);
+					}
+				}
+				const counts = remainingResults;
+				searchable ??= new Set([...pending].filter((id) => (counts.get(id) ?? 0) > 0));
+			}
 		}
 		const isMidHistory = i < lastNonToolIndex;
 		if (options?.synthesizeMissing === true || isMidHistory) for (const missingId of pending) {
@@ -234193,8 +234640,9 @@ function makeSyntheticToolResult(toolCallId) {
 }
 function mergeAdjacentUserMessages(history, onAnomaly) {
 	const out = [];
-	for (const source of history) {
-		const message = prepareMessageForProjection(source, onAnomaly);
+	const latestUserIndex = history.findLastIndex((message) => message.role === "user" && message.partial !== true && (message.origin === void 0 || message.origin.kind === "user"));
+	for (const [index, source] of history.entries()) {
+		const message = prepareMessageForProjection(source, onAnomaly, index < latestUserIndex);
 		if (message === null) continue;
 		const previous = out.at(-1);
 		if (canMergeUserMessage(message) && previous !== void 0 && canMergeUserMessage(previous)) {
@@ -234205,7 +234653,7 @@ function mergeAdjacentUserMessages(history, onAnomaly) {
 	}
 	return out.map(stripContextMetadata);
 }
-function prepareMessageForProjection(message, onAnomaly) {
+function prepareMessageForProjection(message, onAnomaly, historical = false) {
 	if (message.partial === true) return null;
 	let content;
 	for (const [index, part] of message.content.entries()) {
@@ -234217,6 +234665,19 @@ function prepareMessageForProjection(message, onAnomaly) {
 			});
 			continue;
 		}
+		if (historical && message.role === "user" && part.type === "text") {
+			const text = withoutHistoricalTelegramGroupReminder(part.text);
+			if (text !== part.text) {
+				content ??= message.content.slice(0, index);
+				const shortened = {
+					...part,
+					text
+				};
+				copyRequestTextOrigin(part, shortened, message.origin);
+				content.push(shortened);
+				continue;
+			}
+		}
 		content?.push(part);
 	}
 	const next = content === void 0 ? message : {
@@ -234226,6 +234687,14 @@ function prepareMessageForProjection(message, onAnomaly) {
 	if (next.role === "tool" && next.content.length === 0) throw new BlunError(ErrorCodes.REQUEST_INVALID, "Tool result message content cannot be empty after removing empty text blocks.", { details: { toolCallId: next.toolCallId } });
 	return next.content.length === 0 && next.toolCalls.length === 0 ? null : next;
 }
+function withoutHistoricalTelegramGroupReminder(text) {
+	if (!text.startsWith("<channel source=\"telegram\"") && !text.startsWith("You are connected to a Telegram channel.")) return text;
+	const start = text.lastIndexOf(`</channel>\n[GRUPPENANTWORT:`);
+	if (start < 0) return text;
+	const reminder = text.slice(start + 10 + 1);
+	if (!/^\[GRUPPENANTWORT:[^\r\n]*\]$/.test(reminder)) return text;
+	return text.slice(0, start + 10);
+}
 function canMergeUserMessage(message) {
 	return message.role === "user" && message.origin?.kind === "user";
 }
@@ -234290,6 +234759,8 @@ function checkedRemovalIndexes(indexes, length) {
 }
 var ContextMemory = class {
 	agent;
+	mutationGeneration = randomUUID();
+	mutationRevision = 0;
 	_history = [];
 	_tokenCount = 0;
 	tokenCountCoveredMessageCount = 0;
@@ -234301,6 +234772,15 @@ var ContextMemory = class {
 	constructor(agent) {
 		this.agent = agent;
 	}
+	publishMutation(reason) {
+		if (this.agent.records.restoring) return;
+		this.agent.emitEvent({
+			type: "context.changed",
+			generation: this.mutationGeneration,
+			revision: ++this.mutationRevision,
+			reason
+		});
+	}
 	get lastAssistantAt() {
 		return this._lastAssistantAt;
 	}
@@ -234432,17 +234912,29 @@ var ContextMemory = class {
 			deferredIndexes: [...deferredIndexes]
 		});
 		const removedMessages = /* @__PURE__ */ new Set();
+		let shiftedSlots = -historyIndexes.size * (historyIndexes.size - 1) / 2;
+		for (const index of historyIndexes) shiftedSlots += this._history.length - 1 - index;
+		const compactHistory = shiftedSlots > this._history.length * 64;
 		for (let i = this._history.length - 1; i >= 0; i--) {
 			const message = this._history[i];
 			if (message === void 0 || !historyIndexes.has(i)) continue;
 			removedMessages.add(message);
-			this._history.splice(i, 1);
+			if (!compactHistory) this._history.splice(i, 1);
 			this.agent.injection.onContextMessageRemoved(i);
 			if (i < this.tokenCountCoveredMessageCount) {
 				this.tokenCountCoveredMessageCount--;
 				this._tokenCount -= estimateTokensForMessages([message]);
 			}
 		}
+		if (compactHistory) {
+			let retained = 0;
+			for (let index = 0; index < this._history.length; index++) {
+				if (historyIndexes.has(index)) continue;
+				if (retained !== index) this._history[retained] = this._history[index];
+				retained++;
+			}
+			this._history.length = retained;
+		}
 		this.deferredMessages = this.deferredMessages.filter((message, index) => {
 			if (!deferredIndexes.has(index)) return true;
 			removedMessages.add(message);
@@ -234454,6 +234946,7 @@ var ContextMemory = class {
 		return removedMessages.size;
 	}
 	clear() {
+		const changed = this._history.length > 0;
 		this.agent.records.logRecord({ type: "context.clear" });
 		this._history = [];
 		this._tokenCount = 0;
@@ -234465,6 +234958,7 @@ var ContextMemory = class {
 		this.agent.microCompaction.reset();
 		this.agent.injection.onContextClear();
 		this.agent.emitStatusUpdated();
+		if (changed) this.publishMutation("clear");
 	}
 	undo(count) {
 		if (count <= 0) return;
@@ -234502,6 +234996,7 @@ var ContextMemory = class {
 		this.deferredMessages = [];
 		this.agent.microCompaction.reset(this._history.length);
 		this.agent.emitStatusUpdated();
+		if (removedMessages.size > 0) this.publishMutation("undo");
 		if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) throw new BlunError(ErrorCodes.REQUEST_INVALID, formatUndoUnavailableMessage(count, removedUserCount, stoppedAtBoundary), { details: {
 			reason: "undo_limit",
 			requestedCount: count,
@@ -234510,6 +235005,7 @@ var ContextMemory = class {
 		} });
 	}
 	applyCompaction(input, options = {}) {
+		if (this.agent.records.restoring !== null && input.toolContinuity !== void 0 && !isToolContinuity(input.toolContinuity)) throw new Error("Invalid compaction tool continuity");
 		let preservedToolTailCount = input.preservedToolTailCount;
 		if (this.agent.records.restoring === null && this.hasOpenToolExchange()) {
 			const start = this._history.findIndex((message) => message.role === "assistant" && message.toolCalls.some((call) => this.pendingToolResultIds.has(call.id)));
@@ -234546,25 +235042,75 @@ var ContextMemory = class {
 			elisionMessage,
 			...selection.tail
 		];
-		const contextSummary = input.contextSummary ?? input.summary;
-		const summaryMessage = {
+		let contextSummary = input.contextSummary ?? input.summary;
+		let toolContinuity = this.agent.records.restoring === null ? void 0 : input.toolContinuity;
+		let summaryMessage = {
 			role: "user",
 			content: [{
 				type: "text",
 				text: contextSummary
 			}],
 			toolCalls: [],
-			origin: { kind: "compaction_summary" }
+			origin: {
+				kind: "compaction_summary",
+				...toolContinuity === void 0 ? {} : { toolContinuity }
+			}
 		};
-		const replacement = [
+		let replacement = [
 			...keptMessages,
 			summaryMessage,
 			...preservedToolTail
 		];
+		const previousHistoryTokens = options.requireReduction && this.agent.records.restoring === null ? estimateTokensForMessages(project(this.agent.microCompaction.compact(this._history), { dropOrphanResults: true })) : void 0;
+		if (this.agent.records.restoring === null) {
+			toolContinuity = void 0;
+			const observations = collectToolContinuity(this._history.slice(0, tailStart));
+			if (observations !== void 0) {
+				const baseProjected = project(replacement, { dropOrphanResults: true });
+				const baseTokens = estimateTokensForMessages(baseProjected);
+				let extraTokens = previousHistoryTokens === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, previousHistoryTokens - baseTokens - 1);
+				if (this.agent.config.hasProvider) {
+					const window = this.agent.fullCompaction.getEffectiveMaxContextTokens();
+					const budget = this.agent.fullCompaction.getCompactionBudgetTokens();
+					const requestLimit = Math.min(window > 0 ? window - 1 : Number.POSITIVE_INFINITY, budget ?? Number.POSITIVE_INFINITY);
+					extraTokens = Math.min(extraTokens, Math.max(0, requestLimit - this.agent.fullCompaction.estimateProjectedRequestTokens({ messages: baseProjected }) - 1));
+				}
+				let fitted = fitToolContinuity(observations, extraTokens);
+				while (fitted !== void 0) {
+					const candidateSummary = {
+						...summaryMessage,
+						content: [{
+							type: "text",
+							text: contextSummary + fitted.text
+						}],
+						origin: {
+							kind: "compaction_summary",
+							toolContinuity: fitted.continuity
+						}
+					};
+					const candidate = [
+						...keptMessages,
+						candidateSummary,
+						...preservedToolTail
+					];
+					const projected = project(candidate, { dropOrphanResults: true });
+					const status = this.agent.fullCompaction.proactiveCompactionStatus({ messages: projected });
+					const reducing = previousHistoryTokens === void 0 || estimateTokensForMessages(projected) < previousHistoryTokens;
+					const bytesFit = (status.usedHistoryBytes === void 0 || status.thresholdHistoryBytes === void 0 || status.usedHistoryBytes < status.thresholdHistoryBytes) && (status.usedRequestBytesEstimate === void 0 || status.thresholdRequestBytes === void 0 || status.usedRequestBytesEstimate < status.thresholdRequestBytes);
+					if (reducing && bytesFit) {
+						toolContinuity = fitted.continuity;
+						contextSummary += fitted.text;
+						summaryMessage = candidateSummary;
+						replacement = candidate;
+						break;
+					}
+					fitted = fitToolContinuity(observations, estimateTokens(fitted.text) - 1);
+				}
+			}
+		}
 		if (options.requireReduction && this.agent.records.restoring === null) {
-			const previousHistoryTokens = estimateTokensForMessages(project(this.agent.microCompaction.compact(this._history), { dropOrphanResults: true }));
 			const nextHistoryTokens = estimateTokensForMessages(project(replacement, { dropOrphanResults: true }));
-			if (nextHistoryTokens >= previousHistoryTokens) throw new BlunError(ErrorCodes.COMPACTION_FAILED, "Automatic compaction did not reduce the history. The conversation history was not changed.", { details: {
+			if (previousHistoryTokens !== void 0 && nextHistoryTokens >= previousHistoryTokens) throw new BlunError(ErrorCodes.COMPACTION_FAILED, "Automatic compaction did not reduce the history. The conversation history was not changed.", { details: {
 				reason: "non_reducing_summary",
 				contextUnchanged: true,
 				previousHistoryTokens,
@@ -234577,6 +235123,7 @@ var ContextMemory = class {
 		const result = {
 			summary: input.summary,
 			contextSummary,
+			...toolContinuity === void 0 ? {} : { toolContinuity },
 			compactedCount: input.compactedCount,
 			tokensBefore: input.tokensBefore,
 			tokensAfter,
@@ -234593,6 +235140,7 @@ var ContextMemory = class {
 		this.agent.replayBuilder.patchLast("compaction", { result: {
 			summary: result.summary,
 			contextSummary: result.contextSummary,
+			...result.toolContinuity === void 0 ? {} : { toolContinuity: result.toolContinuity },
 			compactedCount: result.compactedCount,
 			tokensBefore: result.tokensBefore,
 			tokensAfter: result.tokensAfter,
@@ -236200,20 +236748,75 @@ function fingerprintTitle(title) {
 	return createHash("sha256").update(title.trim().toLowerCase()).digest("hex");
 }
 async function loadRegister(mistakeDir = defaultMistakeDir()) {
+	const target = join(mistakeDir, REGISTER_FILENAME);
 	try {
 		await mkdir(mistakeDir, { recursive: true });
-		const content = await readFile(join(mistakeDir, REGISTER_FILENAME), "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return {
+		const before = await lstat(target).catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		if (before === void 0) return {
 			version: 1,
 			entries: []
 		};
+		if (!before.isFile() || before.isSymbolicLink()) throw new Error("Mistake register must be a regular file.");
+		const handle = await open(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+		let content;
+		try {
+			const opened = await handle.stat();
+			if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) throw new Error("Mistake register changed while opening.");
+			content = await handle.readFile("utf8");
+		} finally {
+			await handle.close();
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch {
+			throw new Error("Mistake register has invalid JSON.");
+		}
+		assertRegister(parsed);
+		return parsed;
+	} catch (error) {
+		throw registerError(error, "read");
 	}
 }
 async function saveRegister(register, mistakeDir = defaultMistakeDir()) {
-	await mkdir(mistakeDir, { recursive: true });
-	await writeFile(join(mistakeDir, REGISTER_FILENAME), JSON.stringify(register, null, 2), "utf-8");
+	assertRegister(register);
+	const target = join(mistakeDir, REGISTER_FILENAME);
+	const temporary = `${target}.tmp.${process.pid}.${randomUUID()}`;
+	let created = false;
+	try {
+		await loadRegister(mistakeDir);
+		const handle = await open(temporary, "wx", 384);
+		created = true;
+		try {
+			await handle.writeFile(JSON.stringify(register, null, 2), "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await rename(temporary, target);
+	} catch (error) {
+		throw registerError(error, "write");
+	} finally {
+		if (created) await unlink(temporary).catch(() => {});
+	}
+}
+function assertRegister(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Mistake register has an invalid v1 schema.");
+	const register = value;
+	if (register["version"] !== 1 || !Array.isArray(register["entries"]) || !register["entries"].every((entry) => {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return false;
+		const fields = entry;
+		return typeof fields["entryIndex"] === "number" && Number.isSafeInteger(fields["entryIndex"]) && fields["entryIndex"] >= 0 && typeof fields["titleFingerprint"] === "string" && fields["titleFingerprint"].trim().length > 0 && typeof fields["title"] === "string" && fields["title"].trim().length > 0 && typeof fields["count"] === "number" && Number.isSafeInteger(fields["count"]) && fields["count"] >= 0 && typeof fields["lastHitAt"] === "string" && fields["lastHitAt"].trim().length > 0 && (fields["origin"] === "program" || fields["origin"] === "hand");
+	})) throw new Error("Mistake register has an invalid v1 schema.");
+}
+function registerError(error, operation) {
+	if (error instanceof Error && error.message.startsWith("Mistake register ")) return error;
+	const code = typeof error === "object" && error !== null ? error.code : void 0;
+	const suffix = typeof code === "string" && /^[A-Z0-9_]+$/u.test(code) ? ` (${code})` : "";
+	return /* @__PURE__ */ new Error(`Mistake register ${operation} failed${suffix}.`);
 }
 /**
 * Findet einen Register-Eintrag anhand des Titels (Fingerabdruck).
@@ -238906,6 +239509,7 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 	const DEFERRED_TOOL_LOADER_NAME = "ToolSearch";
 	const MAX_PERSISTENT_DEFERRED_TOOLS = 12;
 	const MAX_TOOL_SEARCH_QUERY_CHARS = 1e3;
+	const MAX_TOOL_CATALOG_RESULT_BYTES = 4096;
 	const MAX_AUTO_RANKED_TOOLS = 6;
 	const deferredToolLoaders = /* @__PURE__ */ new WeakSet();
 	const TOOL_RANK_EMBEDDED_CONTENT_RE = /<(attached_documents?|attachment_content|document_content|file_content)\b[^>]*>[\s\S]*?<\/\1>/giu;
@@ -238976,6 +239580,32 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		"suchen"
 	]);
 	const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
+		Object.freeze([
+			"persist",
+			"save",
+			"speichere",
+			"speichern",
+			"store"
+		]),
+		Object.freeze([
+			"erinnerung",
+			"erinnerungen",
+			"fact",
+			"facts",
+			"fakt",
+			"fakten",
+			"memory",
+			"memories",
+			"merk",
+			"merken",
+			"remember"
+		]),
+		Object.freeze([
+			"note",
+			"notes",
+			"notiz",
+			"notizen"
+		]),
 		Object.freeze([
 			"checklist",
 			"list",
@@ -239093,10 +239723,18 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		if (VIDEO_MEDIA_TERM_RE.test(text)) selected.add("GenerateVideo");
 		return selected;
 	}
+	function channelMessagesForTurnText(value) {
+		return [...String(value || "").matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu)].map((match) => ({
+			text: match[1],
+			start: match.index,
+			end: match.index + match[0].length,
+			telegram: /^<channel\s+source=["']telegram["'](?:\s|>)/iu.test(match[0].trimStart())
+		}));
+	}
 	function mediaToolNamesForTurnText(value) {
 		const text = String(value || "");
 		const selected = /* @__PURE__ */ new Set();
-		const channelBodies = [...text.matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu)].map((match) => match[1]);
+		const channelBodies = channelMessagesForTurnText(text).map((message) => message.text);
 		const intentTexts = channelBodies.length > 0 ? channelBodies : [text];
 		for (const intentText of intentTexts) for (const name of mediaGenerationToolNamesForText(intentText)) selected.add(name);
 		if (/\bimage_path\s*=\s*["'][^"']+["']/iu.test(text)) {
@@ -239124,6 +239762,27 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		for (const leaf of leaves) leafCounts.set(leaf, (leafCounts.get(leaf) || 0) + 1);
 		return names.map((name, index) => leafCounts.get(leaves[index]) === 1 ? leaves[index] : name).sort((left, right) => left.localeCompare(right));
 	}
+	function boundedDeferredToolCatalog(tools, filter) {
+		const needle = filter.toLowerCase();
+		const matched = deferredToolCatalog(tools).filter((name) => name.toLowerCase().includes(needle));
+		const names = [];
+		let bytes = Buffer.byteLength(JSON.stringify({
+			names,
+			total: matched.length,
+			truncated: false
+		}));
+		for (const name of matched) {
+			const nextBytes = Buffer.byteLength(JSON.stringify(name)) + (names.length > 0 ? 1 : 0);
+			if (bytes + nextBytes > MAX_TOOL_CATALOG_RESULT_BYTES) break;
+			names.push(name);
+			bytes += nextBytes;
+		}
+		return JSON.stringify({
+			names,
+			total: matched.length,
+			truncated: names.length < matched.length
+		});
+	}
 	function normalizeDeferredToolQuery(value) {
 		const query = String(value ?? "").trim();
 		if (query.length <= MAX_TOOL_SEARCH_QUERY_CHARS) return query;
@@ -239173,22 +239832,39 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 	function relatedSearchTerms(token) {
 		return TOOL_SEARCH_RELATED_TERM_GROUPS.find((terms) => terms.includes(token)) || [token];
 	}
+	function withoutFencedCode(value) {
+		const visibleLines = [];
+		let fence = null;
+		for (const line of String(value || "").split(/\r?\n/)) {
+			const marker = line.match(/^ {0,3}(`{3,}|~{3,})/u)?.[1];
+			if (fence) {
+				if (marker?.[0] === fence[0] && marker.length >= fence.length && /^ {0,3}(?:`{3,}|~{3,})[ \t]*$/u.test(line)) fence = null;
+				continue;
+			}
+			if (marker) {
+				fence = marker;
+				continue;
+			}
+			visibleLines.push(line);
+		}
+		return visibleLines.join("\n");
+	}
 	function rankingIntentTexts(value) {
 		const text = String(value || "");
-		const channelBodies = [...text.matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu)].map((match) => match[1]);
-		return (channelBodies.length > 0 ? channelBodies : [text]).map((intentText) => normalizeDeferredToolQuery(intentText.replace(TOOL_RANK_EMBEDDED_CONTENT_RE, " ")));
+		const channelBodies = channelMessagesForTurnText(text).map((message) => message.text);
+		return (channelBodies.length > 0 ? channelBodies : [text]).map((intentText) => normalizeDeferredToolQuery(withoutFencedCode(intentText.replace(TOOL_RANK_EMBEDDED_CONTENT_RE, " "))));
 	}
 	function rankingTokens(value) {
 		return [...new Set(String(value || "").normalize("NFKC").toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) || [])].filter((token) => !TOOL_RANK_STOP_WORDS.has(token));
 	}
-	function toolRankingDocument(tool) {
+	function toolRankingDocument(tool, trustedToolNames) {
 		const name = String(tool?.name || "");
 		const leaf = name.split(/__|:/).at(-1) || name;
 		const splitToolName = (value) => String(value || "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll("_", " ");
 		const nameTokens = rankingTokens(`${splitToolName(name)} ${splitToolName(leaf)}`);
 		const descriptionTokens = rankingTokens(tool?.description);
 		const parameterText = [];
-		const properties = tool?.parameters?.properties;
+		const properties = /^mcp__/iu.test(name) && !trustedToolNames?.has(name) ? void 0 : tool?.parameters?.properties;
 		if (properties && typeof properties === "object") for (const [parameterName, definition] of Object.entries(properties)) parameterText.push(parameterName, definition?.description || "");
 		const exampleText = Array.isArray(tool?.examples) ? tool.examples.map((example) => example?.prompt || "").join(" ") : "";
 		return {
@@ -239220,7 +239896,7 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		const queryTokens = [...new Set(rankingIntentTexts(value).flatMap(rankingTokens))];
 		if (queryTokens.length === 0) return /* @__PURE__ */ new Set();
 		const ranked = (Array.isArray(tools) ? tools : []).map((tool) => {
-			const document = toolRankingDocument(tool);
+			const document = toolRankingDocument(tool, options.trustedToolNames);
 			if (!document.name) return null;
 			let score = 0;
 			let matchedTokens = 0;
@@ -239234,7 +239910,7 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 				if (document.nameTokens.has(token)) exactNameMatches += 1;
 				else if (relatedSearchTerms(token).some((term) => document.nameTokens.has(term))) relatedNameMatches += 1;
 			}
-			return matchedTokens >= 2 || exactNameMatches >= 1 && score >= 10 || relatedNameMatches >= 1 && score >= 5 ? {
+			return matchedTokens >= 2 || exactNameMatches >= 1 && score >= 10 || queryTokens.length === 1 && relatedNameMatches >= 1 && score >= 5 ? {
 				name: document.name,
 				score,
 				matchedTokens,
@@ -239252,17 +239928,15 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		if (!supportChoice.match(/^(?:tool|skill)\s*:\s*(.+)$/iu)?.[1]) return /* @__PURE__ */ new Set();
 		return rankedToolNamesForTurnText(tools, supportChoice, { maxTools: 1 });
 	}
-	function searchRelatedDeferredTools(tools, query, options = {}) {
+	function searchRelatedDeferredTools(tools, query) {
 		const normalized = normalizeDeferredToolQuery(query).toLowerCase();
 		if (!normalized || normalized.startsWith("select:")) return [];
-		const tokens = normalized.split(/\s+/).filter(Boolean);
-		const requestedNameTokens = tokens.filter((token) => token.startsWith("+")).map((token) => token.slice(1)).filter(Boolean);
-		const relaxRequiredNameTokens = options.relaxRequiredNameTokens === true && requestedNameTokens.length > 0;
-		const requiredNameTokens = relaxRequiredNameTokens ? [] : requestedNameTokens;
-		const searchTokens = [...tokens.filter((token) => !token.startsWith("+")), ...relaxRequiredNameTokens ? requestedNameTokens : []].filter((token) => !TOOL_SEARCH_INTENT_WORDS.has(token));
+		const tokens = normalized.match(/\+?[\p{L}\p{N}_-]+/gu) || [];
+		const requiredNameTokens = tokens.filter((token) => token.startsWith("+")).map((token) => token.slice(1)).filter(Boolean);
+		const searchTokens = tokens.filter((token) => !token.startsWith("+")).filter((token) => !TOOL_SEARCH_INTENT_WORDS.has(token) && !TOOL_RANK_STOP_WORDS.has(token));
 		if (searchTokens.length < 2 && !TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS.has(searchTokens[0])) return [];
 		const minimumMatchedTokens = searchTokens.length === 1 ? 1 : Math.max(2, Math.ceil(searchTokens.length * .75));
-		const ranked = tools.map((tool) => {
+		return tools.map((tool) => {
 			const name = String(tool?.name || "").toLowerCase();
 			const description = String(tool?.description || "").toLowerCase();
 			if (!requiredNameTokens.every((token) => name.includes(token))) return null;
@@ -239293,12 +239967,7 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 				score,
 				matchedTokens
 			} : null;
-		}).filter(Boolean).sort((left, right) => right.matchedTokens - left.matchedTokens || right.score - left.score || String(left.tool.name).localeCompare(String(right.tool.name)));
-		if (relaxRequiredNameTokens && ranked.length > 0) {
-			const best = ranked[0];
-			return ranked.filter((entry) => entry.matchedTokens === best.matchedTokens && entry.score === best.score).slice(0, 5).map((entry) => entry.tool);
-		}
-		return ranked.slice(0, 5).map((entry) => entry.tool);
+		}).filter(Boolean).sort((left, right) => right.matchedTokens - left.matchedTokens || right.score - left.score || String(left.tool.name).localeCompare(String(right.tool.name))).slice(0, 5).map((entry) => entry.tool);
 	}
 	function rememberLoadedTool(loadedToolNames, name) {
 		loadedToolNames.delete(name);
@@ -239323,13 +239992,12 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		const usedNames = new Set([...selectedTools, ...available.values()].map((tool) => String(tool?.name ?? "")));
 		let loaderName = DEFERRED_TOOL_LOADER_NAME;
 		for (let suffix = 1; usedNames.has(loaderName); suffix += 1) loaderName = `${DEFERRED_TOOL_LOADER_NAME}_${suffix}`;
-		const deferredCount = available.size;
 		const loader = {
 			name: loaderName,
 			description: [
-				`Search ${deferredCount} deferred ${deferredCount === 1 ? "tool schema" : "tool schemas"} without loading all definitions.`,
-				"Use select:leaf_name for one known tool, plain keywords to search, or +word to require that word in the tool name.",
-				`Loaded tools are available in the next step; the ${MAX_PERSISTENT_DEFERRED_TOOLS} most recently selected schemas remain loaded.`
+				"Search deferred tool schemas without loading all definitions.",
+				"Use select:leaf_name for one known tool, plain keywords to search, +word to require a name word, or catalog:fragment to list matching names.",
+				`Loaded tools are available in the next step; up to ${MAX_PERSISTENT_DEFERRED_TOOLS} recently selected schemas remain loaded when the context budget allows.`
 			].join("\n"),
 			parameters: {
 				type: "object",
@@ -239346,17 +240014,18 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 				return {
 					description: query ? `Searching tool schemas for ${query}` : "Searching tool schemas",
 					approvalRule: loaderName,
-					execute: async () => {
+					execute: async (context) => {
+						context?.signal?.throwIfAborted();
+						if (query.toLowerCase().startsWith("catalog:")) return {
+							isError: false,
+							output: boundedDeferredToolCatalog([...available.values()], query.slice(8).trim())
+						};
 						let matches = searchDeferredTools([...available.values()], query);
 						let relatedFallback = false;
 						if (matches.length === 0) {
 							matches = searchRelatedDeferredTools([...available.values()], query);
 							relatedFallback = matches.length > 0;
 						}
-						if (matches.length === 0) {
-							matches = searchRelatedDeferredTools([...available.values()], query, { relaxRequiredNameTokens: true });
-							relatedFallback = matches.length > 0;
-						}
 						if (matches.length === 0) {
 							const alreadyLoaded = query.toLowerCase().startsWith("select:") ? searchDeferredTools(selectedTools.filter((tool) => tool?.name !== loaderName), query) : [];
 							if (alreadyLoaded.length === 1) return {
@@ -239395,6 +240064,7 @@ var import_turn_tool_performance_policy = (/* @__PURE__ */ __commonJSMin(((expor
 		return loader;
 	}
 	module.exports = {
+		channelMessagesForTurnText,
 		isDeferredToolLoader: (tool) => deferredToolLoaders.has(tool),
 		CORE_TOOL_NAMES,
 		DEFERRED_TOOL_LOADER_NAME,
@@ -240697,10 +241367,14 @@ var ReplayBuilder = class {
 		return this.records;
 	}
 	removeMessagesFrom(records, removedMessages) {
-		for (let i = records.length - 1; i >= 0; i--) {
-			const record = records[i];
-			if (record.type === "message" && removedMessages.has(record.message)) records.splice(i, 1);
+		let retained = 0;
+		for (let index = 0; index < records.length; index++) {
+			const record = records[index];
+			if (record.type === "message" && removedMessages.has(record.message)) continue;
+			if (retained !== index) records[retained] = record;
+			retained++;
 		}
+		records.length = retained;
 	}
 };
 //#endregion
@@ -241639,6 +242313,7 @@ function withThinkingOnlyRecovery(llm, onTimeout, observeExecution) {
 		systemPrompt: llm.systemPrompt,
 		modelName: llm.modelName,
 		capability: llm.capability,
+		rebuildsMessagesAtRequestBoundary: llm.rebuildsMessagesAtRequestBoundary,
 		prepareRequestBoundary: llm.prepareRequestBoundary?.bind(llm),
 		isRetryableError: llm.isRetryableError === void 0 ? void 0 : (error) => !recoveryCallbackFailed && !(error instanceof ThinkingOnlyTimeoutError) && (llm.isRetryableError?.(error) ?? false),
 		async chat(params) {
@@ -249872,7 +250547,9 @@ async function executeLoopStep(deps) {
 		if (beforeStep?.block === true) throw new Error(beforeStep.reason ?? `Step ${String(currentStep)} was blocked`);
 	}
 	signal.throwIfAborted();
-	const messages = await buildMessages();
+	const prepareRequestBoundary = llm.prepareRequestBoundary?.bind(llm);
+	const deferMessageBuild = prepareRequestBoundary !== void 0 && llm.rebuildsMessagesAtRequestBoundary === true;
+	const messages = deferMessageBuild ? [] : await buildMessages();
 	signal.throwIfAborted();
 	const stepUuid = randomUUID();
 	const stepEvents = createStepEventGate({
@@ -249882,7 +250559,6 @@ async function executeLoopStep(deps) {
 		stepUuid,
 		onStepStarted
 	});
-	const prepareRequestBoundary = llm.prepareRequestBoundary?.bind(llm);
 	const step = {
 		tools,
 		hooks,
@@ -249962,7 +250638,7 @@ async function executeLoopStep(deps) {
 			turnStep: `${turnId}.${String(currentStep)}`,
 			model: llm.modelName
 		});
-		const strictMessages = await buildMessagesStrict();
+		const strictMessages = deferMessageBuild ? [] : await buildMessagesStrict();
 		signal.throwIfAborted();
 		let strictParams = {
 			...chatParams,
@@ -250063,7 +250739,8 @@ function logStepTiming(log, turnId, step, response) {
 		inputOtherTokens: response.usage.inputOther,
 		cacheReadTokens: response.usage.inputCacheRead,
 		cacheCreationTokens: response.usage.inputCacheCreation,
-		outputTokens: response.usage.output
+		outputTokens: response.usage.output,
+		...response.usage.outputReasoning === void 0 ? {} : { outputReasoningTokens: response.usage.outputReasoning }
 	});
 }
 function deriveStepStopReason(response) {
@@ -251051,6 +251728,7 @@ const MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE = "mcp.oauth.authorization_url";
 const tokenUsageSchema = object({
 	inputOther: number$1(),
 	output: number$1(),
+	outputReasoning: number$1().optional(),
 	inputCacheRead: number$1(),
 	inputCacheCreation: number$1()
 });
@@ -251210,7 +251888,11 @@ const goalChangeStatsSchema = object({
 	wallClockMs: number$1()
 });
 const goalChangeSchema = object({
-	kind: _enum(["lifecycle", "completion"]),
+	kind: _enum([
+		"lifecycle",
+		"completion",
+		"edited"
+	]),
 	status: goalStatusSchema.optional(),
 	reason: string().optional(),
 	stats: goalChangeStatsSchema.optional(),
@@ -251361,6 +252043,12 @@ const turnEndReasonSchema = _enum([
 	"failed",
 	"filtered"
 ]);
+const contextChangedEventSchema = object({
+	type: literal("context.changed"),
+	generation: string().uuid(),
+	revision: number$1().int().positive().max(Number.MAX_SAFE_INTEGER),
+	reason: _enum(["clear", "undo"])
+});
 const agentStatusUpdatedEventSchema = object({
 	type: literal("agent.status.updated"),
 	model: string().optional(),
@@ -251680,6 +252368,7 @@ const eventSchema = discriminatedUnion("type", [
 	errorEventSchema,
 	warningEventSchema,
 	agentStatusUpdatedEventSchema,
+	contextChangedEventSchema,
 	sessionMetaUpdatedEventSchema,
 	sessionCreatedEventSchema,
 	workspaceCreatedEventSchema,
@@ -265080,9 +265769,16 @@ var ToolCallDeduplicator = class {
 //#region ../../packages/agent-core/src/agent/turn/tool-result-budget.ts
 const TOOL_RESULT_MAX_CHARS = 5e4;
 const TOOL_RESULT_PREVIEW_CHARS = 2e3;
+function toolResultMaxChars(maxContextTokens) {
+	if (maxContextTokens === void 0 || !Number.isFinite(maxContextTokens) || maxContextTokens <= 0) return TOOL_RESULT_MAX_CHARS;
+	if (maxContextTokens < 1e5) return 16e3;
+	if (maxContextTokens < 2e5) return 32e3;
+	return TOOL_RESULT_MAX_CHARS;
+}
 async function budgetToolResultForModel(options) {
 	const text = persistableToolResultText(options.result.output);
-	if (text === void 0 || text.length <= TOOL_RESULT_MAX_CHARS) return options.result;
+	const maxChars = toolResultMaxChars(options.maxContextTokens);
+	if (text === void 0 || text.length <= maxChars) return options.result;
 	if (options.result.truncated === true) return options.result;
 	if (options.homedir === void 0) return options.result;
 	if (text.includes("\0") || Buffer.from(text, "utf8").toString("utf8") !== text || text.split("\n").some((line) => line.length > 2e3)) return options.result;
@@ -265093,7 +265789,7 @@ async function budgetToolResultForModel(options) {
 		toolCallId: options.toolCallId
 	}, text);
 	if (outputPath === void 0) return options.result;
-	const output = renderPersistedToolResult(options.toolName, options.toolCallId, text, outputPath);
+	const output = renderPersistedToolResult(options.toolName, options.toolCallId, text, outputPath, maxChars);
 	return options.result.isError === true ? {
 		...options.result,
 		output,
@@ -265125,9 +265821,9 @@ async function saveToolResult(options, text) {
 		return;
 	}
 }
-function renderPersistedToolResult(toolName, toolCallId, text, outputPath) {
+function renderPersistedToolResult(toolName, toolCallId, text, outputPath, maxChars) {
 	const lines = [
-		`Tool output exceeded ${String(TOOL_RESULT_MAX_CHARS)} characters; showing a preview only.`,
+		`Tool output exceeded ${String(maxChars)} characters; showing a preview only.`,
 		`tool_name: ${toolName}`,
 		`tool_call_id: ${toolCallId}`,
 		`output_size_chars: ${String(text.length)}`,
@@ -265135,7 +265831,9 @@ function renderPersistedToolResult(toolName, toolCallId, text, outputPath) {
 		`output_path: ${outputPath}`,
 		"next_step: Use Read with output_path to page through the full output."
 	];
-	lines.push("", "[preview]", text.slice(0, TOOL_RESULT_PREVIEW_CHARS));
+	let preview = text.slice(0, TOOL_RESULT_PREVIEW_CHARS);
+	if (/[\uD800-\uDBFF]$/.test(preview)) preview = preview.slice(0, -1);
+	lines.push("", "[preview]", preview);
 	return lines.join("\n");
 }
 function safeToolResultFileStem(toolName, toolCallId) {
@@ -266692,6 +267390,48 @@ var HistoricalToolProjection = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/turn/baseline-skill-projection.ts
+const BASELINE_ORIGIN = "baseline_skill:blun-design-dna";
+const NONVISUAL_TASK = /\b(?:backend|back-end|serverseitig|server-side|datenbank|database|sql|api[- ](?:endpoint|route)|memory broker)\b/i;
+const VISUAL_TASK = /\b(?:ui|ux|frontend|front-end|website|webseite|web|page|screen|screenshot|bild|image|design|layout|css|html|react|vue|svelte|komponente|component|button|formular|form|style|visual|visuell|interaction|interaktion|interface|oberfl[aä]che|dashboard|landing|mobile|responsive|accessibility|barrierefreiheit|tui|terminal|konsole|console|browser|diagram|chart|graph)\b/i;
+const SHORT_REFERENCE = [
+	"<system-reminder>",
+	"The BLUN Design DNA baseline is retained in the session. Its visual rules are dormant for this explicitly non-visual backend or data task. Preserve security, privacy, accessibility, permissions, and verification. If the work turns visual or interactive, use the complete baseline before continuing.",
+	"</system-reminder>"
+].join("\n");
+function shortNonVisualText(text) {
+	return text.length <= 500 && !/[<>]/.test(text) && !/https?:\/\//i.test(text) && NONVISUAL_TASK.test(text) && !VISUAL_TASK.test(text);
+}
+function clearlyNonVisual(input, origin) {
+	if (origin.kind !== "user" || input.length !== 1 || input[0]?.type !== "text") return false;
+	const text = input[0].text;
+	if (text.length > 16e3 || /\b(?:image_path|attachment_file_id)\s*=|Telegram-Anhang:/i.test(text)) return false;
+	const messages = (0, import_turn_tool_performance_policy.channelMessagesForTurnText)(text);
+	if (messages.length === 0) return shortNonVisualText(text);
+	if (messages.some((message) => !message.telegram || !shortNonVisualText(message.text)) || messages.reduce((size, message) => size + message.text.length, 0) > 500) return false;
+	let cursor = 0;
+	let remainder = "";
+	for (const message of messages) {
+		remainder += text.slice(cursor, message.start);
+		cursor = message.end;
+	}
+	remainder += text.slice(cursor);
+	return !VISUAL_TASK.test(remainder) && remainder.split(/\r?\n/).every((line) => line.trim().length === 0 || /^\[(?:GRUPPENANTWORT|REPLY-PFLICHT|SEMANTISCHE ADRESSIERUNG|NUR MITLESEN)\b[^\r\n]*\]$/.test(line.trim()));
+}
+/** Request-only view; the context, records, and resume state keep the full skill. */
+function projectBaselineSkillForTurn(history, input, origin, turnAnchor) {
+	if (!clearlyNonVisual(input, origin)) return history;
+	const anchorIndex = turnAnchor === void 0 ? -1 : history.indexOf(turnAnchor);
+	if (anchorIndex >= 0 && history.slice(anchorIndex + 1).some((message) => message.role === "tool" && message.content.some((part) => part.type !== "text" || VISUAL_TASK.test(part.text)))) return history;
+	return history.map((message) => message.origin?.kind === "injection" && message.origin.variant === BASELINE_ORIGIN ? {
+		...message,
+		content: [{
+			type: "text",
+			text: SHORT_REFERENCE
+		}]
+	} : message);
+}
+//#endregion
 //#region ../../packages/agent-core/src/agent/response-review-decision.ts
 const STAGES = [
 	"setup",
@@ -267000,6 +267740,23 @@ function createReviewedOutputDispatcher(options) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/agent/turn/index.ts
+function restoreRecentMcpToolNames(history, loadedNames) {
+	const successfulResults = /* @__PURE__ */ new Set();
+	const recentNames = [];
+	const start = Math.max(0, history.length - 256);
+	for (let index = history.length - 1; index >= start && recentNames.length < import_turn_tool_performance_policy.MAX_PERSISTENT_DEFERRED_TOOLS; index--) {
+		const message = history[index];
+		if (message.role === "tool" && message.isError !== true && message.toolCallId !== void 0) {
+			if (successfulResults.size < 64) successfulResults.add(message.toolCallId);
+		} else if (message.role === "assistant") for (let callIndex = message.toolCalls.length - 1; callIndex >= 0; callIndex--) {
+			const call = message.toolCalls[callIndex];
+			if (!successfulResults.delete(call.id) || !/^mcp__[\w.:-]{1,160}$/.test(call.name) || recentNames.includes(call.name)) continue;
+			recentNames.push(call.name);
+			if (recentNames.length >= import_turn_tool_performance_policy.MAX_PERSISTENT_DEFERRED_TOOLS) break;
+		}
+	}
+	for (const name of recentNames.reverse()) loadedNames.add(name);
+}
 function blunExtractText(content) {
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) return content.map((c) => typeof c === "string" ? c : c && typeof c === "object" && "text" in c && typeof c.text === "string" ? c.text : "").join(" ");
@@ -267019,7 +267776,7 @@ function blunTurnNeedsTools(input, origin) {
 	return !/^(?:hi|hallo|hey|hello|hoi|moin|servus|yo|danke|thanks|thx|bye|tschau|ciao)[.!?]*$/.test(text) && !/^(?:wer bist du|who are you|wie geht(?: es dir)?|how are you|na)[.!?]*$/.test(text);
 }
 function blunThinkingIntentInput(input) {
-	const channelText = [...blunExtractText(input).matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/gi)].at(-1)?.[1];
+	const channelText = (0, import_turn_tool_performance_policy.channelMessagesForTurnText)(blunExtractText(input)).at(-1)?.text;
 	return channelText === void 0 ? input : [{
 		type: "text",
 		text: channelText
@@ -267093,14 +267850,51 @@ function blunToolsForOrigin(tools, origin) {
 * the ordinary permission pipeline.
 */
 function blunSelectTurnTools(tools, maxContextTokens, loadedToolNames = /* @__PURE__ */ new Set(), requiredToolNames = /* @__PURE__ */ new Set(), selected = []) {
-	if (estimateTokensForTools(tools) <= (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(maxContextTokens) || tools.some(import_turn_tool_performance_policy.isDeferredToolLoader)) {
+	const schemaBudget = (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(maxContextTokens);
+	const estimates = /* @__PURE__ */ new Map();
+	const estimateSummary = (tool) => {
+		let estimate = estimates.get(tool);
+		if (estimate === void 0) {
+			estimate = { summary: estimateTokens(tool.name) + estimateTokens(tool.description) };
+			estimates.set(tool, estimate);
+		}
+		return estimate;
+	};
+	const estimateSelection = (candidates) => {
+		let total = 0;
+		for (const candidate of candidates) {
+			const estimate = estimateSummary(candidate);
+			if (estimate.complete === void 0) estimate.complete = estimate.summary + estimateTokens(JSON.stringify(candidate.parameters));
+			total += estimate.complete;
+			if (total > schemaBudget) break;
+		}
+		return total;
+	};
+	let summaryTokens = 0;
+	for (const tool of tools) {
+		summaryTokens += estimateSummary(tool).summary;
+		if (summaryTokens > schemaBudget) break;
+	}
+	if (tools.some(import_turn_tool_performance_policy.isDeferredToolLoader) || summaryTokens <= schemaBudget && estimateSelection(tools) <= schemaBudget) {
 		selected.splice(0, selected.length, ...tools);
 		return selected;
 	}
-	selected.splice(0, selected.length, ...tools.filter((tool) => BLUN_LEAN_TOOL_NAMES.has(tool.name) || BLUN_LEAN_KEEP_RE.test(tool.name) || BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name) || loadedToolNames.has(tool.name) || requiredToolNames.has(tool.name)));
-	const names = new Set(selected.map((tool) => tool.name));
-	const deferred = tools.filter((tool) => !names.has(tool.name));
-	if (deferred.length > 0) selected.push((0, import_turn_tool_performance_policy.createDeferredToolLoader)(selected, deferred, loadedToolNames));
+	const priorLoaderIndex = selected.findIndex(import_turn_tool_performance_policy.isDeferredToolLoader);
+	const justLoaded = new Set(priorLoaderIndex < 0 ? [] : selected.slice(priorLoaderIndex + 1).filter((tool) => loadedToolNames.has(tool.name)).map((tool) => tool.name));
+	const remembered = new Set(loadedToolNames);
+	const choose = () => {
+		selected.splice(0, selected.length, ...tools.filter((tool) => BLUN_LEAN_TOOL_NAMES.has(tool.name) || BLUN_LEAN_KEEP_RE.test(tool.name) || BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name) || remembered.has(tool.name) || requiredToolNames.has(tool.name)));
+		const names = new Set(selected.map((tool) => tool.name));
+		const deferred = tools.filter((tool) => !names.has(tool.name));
+		if (deferred.length > 0) selected.push((0, import_turn_tool_performance_policy.createDeferredToolLoader)(selected, deferred, loadedToolNames));
+	};
+	choose();
+	for (const name of loadedToolNames) {
+		if (estimateSelection(selected) <= schemaBudget) break;
+		if (justLoaded.has(name)) continue;
+		if (!remembered.delete(name)) continue;
+		choose();
+	}
 	return selected;
 }
 const LLM_NOT_SET_MESSAGE = "LLM not set, send \"/login\" to login";
@@ -267460,6 +268254,7 @@ var TurnFlow = class {
 	}
 	finishResume() {
 		if (this.activeTurn === "resuming") this.activeTurn = null;
+		restoreRecentMcpToolNames(this.agent.context.history, this.loadedToolNames);
 		this.steerBuffer.length = 0;
 	}
 	/**
@@ -267590,6 +268385,7 @@ var TurnFlow = class {
 		const appendedMessage = this.agent.context.history.at(-1);
 		const turnAnchor = appendedMessage !== previousLastMessage && appendedMessage?.role === "user" && appendedMessage.origin === origin ? appendedMessage : void 0;
 		const startedAt = Date.now();
+		const preRequestHookStartedAt = performance.now();
 		let ended;
 		let blockedByUserPromptHook = false;
 		let completedStopReason;
@@ -267615,6 +268411,13 @@ var TurnFlow = class {
 					this.agent.log.warn("Turn-start observation failed");
 				}
 				signal.throwIfAborted();
+				if (this.agent.type === "main" && process.env["BLUN_DIAG_PRE_REQUEST_PHASES"] === "1") try {
+					this.agent.log.info("turn pre-request phase", {
+						turnId,
+						phase: "turn-hooks",
+						durationMs: Math.max(0, Math.round(performance.now() - preRequestHookStartedAt))
+					});
+				} catch {}
 				const stopReason = await this.runStepLoop(turnId, signal, input, origin, turnAnchor, (response) => {
 					completedResponse = response;
 				});
@@ -267726,6 +268529,10 @@ var TurnFlow = class {
 		signal.throwIfAborted();
 		const blockResult = renderUserPromptHookBlockResult(promptHookResults);
 		if (blockResult !== void 0) {
+			this.agent.log.warn("turn blocked by UserPromptSubmit hook", {
+				turnId,
+				reason: blockResult.message
+			});
 			this.agent.context.appendMessage({
 				role: "assistant",
 				content: [{
@@ -267784,9 +268591,26 @@ var TurnFlow = class {
 		let stopHookContinuationUsed = false;
 		let goalOutcomeMessageContinuationUsed = false;
 		const deduper = new ToolCallDeduplicator({ telemetry: this.agent.telemetry });
+		const diagnosePreRequest = this.agent.type === "main" && process.env["BLUN_DIAG_PRE_REQUEST_PHASES"] === "1";
+		const recordPreRequestPhase = (phase, startedAt) => {
+			if (!diagnosePreRequest) return;
+			try {
+				this.agent.log.info("turn pre-request phase", {
+					turnId,
+					phase,
+					durationMs: Math.max(0, Math.round(performance.now() - startedAt))
+				});
+			} catch {}
+		};
+		let phaseStartedAt = performance.now();
 		await this.agent.mcp?.waitForInitialLoad(signal);
+		recordPreRequestPhase("mcp-initial-load", phaseStartedAt);
+		phaseStartedAt = performance.now();
 		const personalMemoryRecall = await this.agent.injection.injectPersonalMemoryForTurn(turnId, input, origin, signal);
+		recordPreRequestPhase("personal-memory-recall", phaseStartedAt);
+		phaseStartedAt = performance.now();
 		await this.agent.injection.injectGoal();
+		recordPreRequestPhase("goal-injection", phaseStartedAt);
 		this.setActiveSteerAcceptance(turnId, true);
 		const turnNeedsThinking = blunTurnNeedsTools(blunThinkingIntentInput(input), origin);
 		let toolInput = input;
@@ -267797,23 +268621,27 @@ var TurnFlow = class {
 			const raw = [...this.agent.context.history];
 			const history = personalMemoryRecall === void 0 ? raw : [...raw, personalMemoryRecall];
 			const selected = taskToolsNeeded ? history : greetingHistory(history, greetingAnchor);
+			const projectionStartedAt = performance.now();
 			const projected = await this.historicalToolProjection.project(selected, turnAnchor, tools, {
 				turnId: String(turnId),
 				stepNumber: this.currentStep,
 				signal,
 				llm: turnLLM
 			});
+			recordPreRequestPhase("historical-tool-projection", projectionStartedAt);
 			const current = this.agent.context.history;
 			if (current.length !== raw.length || current.some((message, index) => message !== raw[index])) {
 				const latest = personalMemoryRecall === void 0 ? current : [...current, personalMemoryRecall];
 				const retained = taskToolsNeeded ? latest : greetingHistory(latest, greetingAnchor);
-				partialContext = retained.length < latest.length;
-				return retained;
+				const request = projectBaselineSkillForTurn(retained, toolInput, origin, turnAnchor);
+				partialContext = retained.length < latest.length || request !== retained;
+				return request;
 			}
-			partialContext = selected.length < history.length || projected.changed;
-			return projected.history;
+			const request = projectBaselineSkillForTurn(projected.history, toolInput, origin, turnAnchor);
+			partialContext = selected.length < history.length || projected.changed || request !== projected.history;
+			return request;
 		};
-		const turnLLM = this.agent.llmForTurn(turnNeedsThinking ? void 0 : "off");
+		const turnLLM = this.agent.llmForTurn(turnNeedsThinking ? void 0 : "off", turnId);
 		const turnTools = this.agent.tools.captureTurnTools();
 		while (true) {
 			signal.throwIfAborted();
@@ -267823,18 +268651,22 @@ var TurnFlow = class {
 			try {
 				const selectedTools = [];
 				this.refreshSelectedTools = (snapshot) => {
+					const selectionStartedAt = performance.now();
 					if (snapshot.messages.length > 0) toolInput = snapshot.messages.flatMap((message) => message.content);
 					const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, turnTools()), origin);
 					const intent = blunThinkingIntentInput(toolInput);
 					taskToolsNeeded ||= blunTurnNeedsTools(intent, origin) || blunTurnHasAttachment(toolInput);
 					const required = (0, import_turn_tool_performance_policy.mediaToolNamesForTurnText)(blunExtractText(toolInput));
 					if (taskToolsNeeded) {
-						blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, required, selectedTools);
-						for (const name of (0, import_turn_tool_performance_policy.rankedToolNamesForTurnText)(eligibleTools, blunExtractText(intent))) {
+						const maxContextTokens = this.agent.fullCompaction.getEffectiveMaxContextTokens();
+						blunSelectTurnTools(eligibleTools, maxContextTokens, this.loadedToolNames, required, selectedTools);
+						const trustedToolNames = new Set(eligibleTools.filter((tool) => this.agent.tools.isUserTool(tool)).map((tool) => tool.name));
+						for (const name of (0, import_turn_tool_performance_policy.rankedToolNamesForTurnText)(eligibleTools, blunExtractText(intent), { trustedToolNames })) {
 							const tool = eligibleTools.find((candidate) => candidate.name === name);
-							if (tool !== void 0 && !selectedTools.some((candidate) => candidate.name === name) && estimateTokensForTools([...selectedTools, tool]) <= (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(this.agent.config.modelCapabilities?.max_context_tokens)) selectedTools.push(tool);
+							if (tool !== void 0 && !selectedTools.some((candidate) => candidate.name === name) && estimateTokensForTools([...selectedTools, tool]) <= (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(maxContextTokens)) selectedTools.push(tool);
 						}
 					} else selectedTools.splice(0, selectedTools.length, ...eligibleTools.filter((tool) => BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name) || BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name)));
+					recordPreRequestPhase("tool-selection", selectionStartedAt);
 					return selectedTools;
 				};
 				return (await runTurn({
@@ -267847,14 +268679,24 @@ var TurnFlow = class {
 						}, completion);
 					},
 					llm: turnLLM,
-					buildMessages: async () => this.agent.context.project(await turnHistory(selectedTools), { dropOrphanResults: true }),
-					buildMessagesStrict: async () => this.agent.context.project(await turnHistory(selectedTools), {
-						synthesizeMissing: true,
-						dropOrphanResults: true,
-						dedupeDuplicateToolCalls: true,
-						dropLeadingNonUser: true,
-						mergeConsecutiveAssistants: true
-					}),
+					buildMessages: async () => {
+						const startedAt = performance.now();
+						const messages = this.agent.context.project(await turnHistory(selectedTools), { dropOrphanResults: true });
+						recordPreRequestPhase("message-build", startedAt);
+						return messages;
+					},
+					buildMessagesStrict: async () => {
+						const startedAt = performance.now();
+						const messages = this.agent.context.project(await turnHistory(selectedTools), {
+							synthesizeMissing: true,
+							dropOrphanResults: true,
+							dedupeDuplicateToolCalls: true,
+							dropLeadingNonUser: true,
+							mergeConsecutiveAssistants: true
+						});
+						recordPreRequestPhase("message-build-strict", startedAt);
+						return messages;
+					},
 					dispatchEvent: this.buildDispatchEvent(turnId, signal, onFinalResponse, () => partialContext),
 					tools: selectedTools,
 					log: this.agent.log,
@@ -267871,8 +268713,10 @@ var TurnFlow = class {
 					},
 					hooks: {
 						beforeStep: async ({ signal: stepSignal, llm }) => {
+							const injectionStartedAt = performance.now();
 							this.agent.microCompaction.detect();
 							await this.agent.injection.inject();
+							recordPreRequestPhase("step-injection", injectionStartedAt);
 							stepSignal.throwIfAborted();
 							deduper.beginStep();
 						},
@@ -267910,6 +268754,17 @@ var TurnFlow = class {
 								signal.throwIfAborted();
 								if (stopBlock !== void 0) {
 									stopHookContinuationUsed = true;
+									this.agent.log.warn("turn continuation blocked by Stop hook", {
+										turnId,
+										reason: stopBlock.reason
+									});
+									this.agent.emitEvent({
+										type: "hook.result",
+										turnId,
+										hookEvent: "Stop",
+										content: stopBlock.reason,
+										blocked: true
+									});
 									this.agent.context.appendUserMessage([{
 										type: "text",
 										text: stopBlock.reason
@@ -267949,6 +268804,7 @@ var TurnFlow = class {
 							});
 							return budgetToolResultForModel({
 								homedir: this.agent.homedir,
+								maxContextTokens: this.agent.fullCompaction.getEffectiveMaxContextTokens(),
 								toolName: ctx.toolCall.name,
 								toolCallId: ctx.toolCall.id,
 								result: finalResult
@@ -268806,10 +269662,10 @@ var BashTool = class {
 			},
 			approvalRule: literalRulePattern(this.name, args.command),
 			matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, args.command),
-			execute: ({ signal, onUpdate, onForegroundTaskStart }) => this.execution(args, signal, onUpdate, onForegroundTaskStart)
+			execute: ({ signal, onUpdate, onForegroundTaskStart, executionOrigin }) => this.execution(args, signal, onUpdate, onForegroundTaskStart, executionOrigin)
 		};
 	}
-	spawn(effectiveCwd, command) {
+	spawn(effectiveCwd, command, executionOrigin) {
 		const shellCwd = this.isWindowsBash ? windowsPathToPosixPath(effectiveCwd) : effectiveCwd;
 		const shellArgs = [
 			this.kaos.osEnv.shellPath,
@@ -268826,9 +269682,11 @@ var BashTool = class {
 			...process.env,
 			...noninteractiveEnv
 		};
+		delete mergedEnv["BLUN_SHELL"];
+		if (executionOrigin === "operator_shell") mergedEnv["BLUN_SHELL"] = "operator-local";
 		return this.kaos.execWithEnv(shellArgs, mergedEnv);
 	}
-	async execution(args, signal, onUpdate, onForegroundTaskStart) {
+	async execution(args, signal, onUpdate, onForegroundTaskStart, executionOrigin) {
 		const validationError = this.validateRunRequest(args, signal);
 		if (validationError !== void 0) return validationError;
 		const startsInBackground = args.run_in_background === true;
@@ -268840,7 +269698,7 @@ var BashTool = class {
 		const builder = new ToolResultBuilder();
 		let proc;
 		try {
-			proc = await this.spawn(effectiveCwd, command);
+			proc = await this.spawn(effectiveCwd, command, executionOrigin);
 		} catch (error) {
 			return {
 				isError: true,
@@ -269204,14 +270062,14 @@ function classifySearchError(error) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/search/codebase-search.md?raw
-var codebase_search_default = "Find code by **meaning**, not by keywords.\n\nThis tool runs a semantic search over the codebase index. It understands what a file or function *does*, not just what words appear in it. Use it when you are looking for *where* something is handled, *which file* implements a concept, or *how* a particular concern is addressed — even when the exact term never appears in the source.\n\n**When to use this tool:**\n- \"Where is keyboard input handled?\" — finds the handler even if the word \"keyboard\" never appears.\n- \"Which file manages the retry logic for API calls?\"\n- \"How does the app decide which model to route a message to?\"\n- \"Find the code that handles user authentication flow.\"\n- Any question where you want to locate code by its *purpose* or *behavior*.\n\n**When NOT to use this tool — use a different one instead:**\n- Exact string matches, regex patterns, or specific identifiers → `Grep`\n- Finding files by name, extension, or path glob → `Glob`\n- Reading a known file path → `Read`\n\n**Parameters:**\n- `query` (required): A natural-language question, concept, or phrase describing what the code does. Examples: `\"keyboard event handling\"`, `\"retry with exponential backoff\"`, `\"where chat messages are routed to the model\"`.\n- `top` (optional, default 5): Maximum number of results to return.\n\n**Output:**\nEach result includes a file path and a relevance snippet. The index is rebuilt incrementally; if a file was recently added it may not appear until the next index update. Always verify the finding by reading the file before relying on it.\n";
+var codebase_search_default = "Find code by **meaning**, not by keywords.\n\nThis tool runs a semantic search over the codebase index. It understands what a file or function *does*, not just what words appear in it. Use it when you are looking for *where* something is handled, *which file* implements a concept, or *how* a particular concern is addressed — even when the exact term never appears in the source.\n\n**When to use this tool:**\n- \"Where is keyboard input handled?\" — finds the handler even if the word \"keyboard\" never appears.\n- \"Which file manages the retry logic for API calls?\"\n- \"How does the app decide which model to route a message to?\"\n- \"Find the code that handles user authentication flow.\"\n- Any question where you want to locate code by its *purpose* or *behavior*.\n\n**When NOT to use this tool — use a different one instead:**\n- Exact string matches, regex patterns, or specific identifiers → `Grep`\n- Finding files by name, extension, or path glob → `Glob`\n- Reading a known file path → `Read`\n\n**Parameters:**\n- `query` (required): A natural-language question, concept, or phrase describing what the code does. Examples: `\"keyboard event handling\"`, `\"retry with exponential backoff\"`, `\"where chat messages are routed to the model\"`.\n- `top` (optional, default 5, maximum 100): Maximum number of results to return.\n\n**Output:**\nEach result includes a file path and a relevance score, plus the index model and revision. The index is rebuilt incrementally; if a file was recently added it may not appear until the next index update. Always verify the finding by reading the file before relying on it.\n";
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/search/codebase-search.ts
 /**
 * CodebaseSearchTool — semantic code search via the codebase-index.
 *
 * Shells out to `python codebase_index.py query <repo> "<frage>" --top N`
-* through spawnSync. The script lives at
+* through asynchronous execFile. The script lives at
 * `packages/codebase-index/codebase_index.py` relative to the workspace root.
 *
 * Unlike Grep (keyword/regex) or Glob (file-name patterns), this tool finds
@@ -269219,11 +270077,13 @@ var codebase_search_default = "Find code by **meaning**, not by keywords.\n\nThi
 * to the query, so it can locate a keyboard handler even when the word
 * "keyboard" never appears in the source.
 */
+const MAX_SEARCH_RESULTS = 100;
 const CodebaseSearchInputSchema = object({
 	query: string().min(1, "Query cannot be empty.").describe("A natural-language question or concept describing what the code does. Examples: \"keyboard event handling\", \"retry with exponential backoff\", \"where chat messages are routed to the model\"."),
-	top: number$1().int().positive().default(5).describe("Maximum number of results to return. Defaults to 5.")
+	top: number$1().int().positive().max(MAX_SEARCH_RESULTS).default(5).describe(`Maximum number of results to return (1-${String(MAX_SEARCH_RESULTS)}). Defaults to 5.`)
 });
 const SCRIPT_TIMEOUT_MS = 6e4;
+const SCRIPT_MAX_BUFFER = 1024 * 1024;
 function isScriptFile(path) {
 	try {
 		return statSync(path).isFile();
@@ -269262,45 +270122,72 @@ var CodebaseSearchTool = class {
 			},
 			approvalRule: literalRulePattern(this.name, args.query),
 			matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, args.query),
-			execute: () => this.execution(args)
+			execute: async (context) => {
+				context.signal.throwIfAborted();
+				return this.execution(args, context.signal);
+			}
 		};
 	}
-	execution(args) {
+	async execution(args, signal) {
 		const builder = new ToolResultBuilder();
-		if (this.scriptPath.length === 0) return Promise.resolve(builder.error("Could not locate codebase_index.py. Set CODEBASE_INDEX_SCRIPT to its absolute path."));
+		if (!Number.isSafeInteger(args.top) || args.top < 1 || args.top > MAX_SEARCH_RESULTS) return builder.error(`Codebase search top must be between 1 and ${String(MAX_SEARCH_RESULTS)}.`);
+		if (this.scriptPath.length === 0) return builder.error("Could not locate codebase_index.py. Set CODEBASE_INDEX_SCRIPT to its absolute path.");
 		try {
-			const result = spawnSync("python", [
-				this.scriptPath,
-				"query",
-				this.cwd,
-				args.query,
-				"--top",
-				String(args.top),
-				"--model",
-				"auto"
-			], {
-				cwd: this.cwd,
-				timeout: SCRIPT_TIMEOUT_MS,
-				encoding: "utf-8",
-				windowsHide: true
+			const result = await new Promise((resolve) => {
+				let closed = false;
+				let output;
+				const finish = () => {
+					if (closed && output !== void 0) resolve(output);
+				};
+				execFile("python", [
+					this.scriptPath,
+					"query",
+					this.cwd,
+					args.query,
+					"--top",
+					String(args.top),
+					"--model",
+					"auto"
+				], {
+					cwd: this.cwd,
+					timeout: SCRIPT_TIMEOUT_MS,
+					encoding: "utf-8",
+					windowsHide: true,
+					shell: false,
+					maxBuffer: SCRIPT_MAX_BUFFER,
+					signal
+				}, (error, stdout, stderr) => {
+					output = {
+						error,
+						stdout,
+						stderr
+					};
+					finish();
+				}).once("close", () => {
+					closed = true;
+					finish();
+				});
 			});
-			if (result.error !== void 0) {
+			signal.throwIfAborted();
+			if (result.error !== null && typeof result.error.code !== "number") {
 				const msg = result.error instanceof Error ? result.error.message : String(result.error);
-				return Promise.resolve(builder.error(`Failed to run codebase_index.py: ${msg}`));
+				builder.write(result.stdout + result.stderr);
+				return builder.error(`Failed to run codebase_index.py: ${msg}`);
 			}
 			const stdout = result.stdout ?? "";
 			const stderr = result.stderr ?? "";
-			const exitCode = result.status ?? -1;
+			const exitCode = result.error?.code ?? 0;
 			if (exitCode !== 0) {
 				const combined = stderr.trim().length > 0 ? `${stdout}${stdout.length > 0 ? "\n" : ""}Error: ${stderr.trim()}` : stdout;
 				builder.write(combined.length > 0 ? combined : `codebase_index.py exited with code ${String(exitCode)}`);
-				return Promise.resolve(builder.error(`Codebase search failed with exit code ${String(exitCode)}.`));
+				return builder.error(`Codebase search failed with exit code ${String(exitCode)}.`);
 			}
 			builder.write(stdout.length > 0 ? stdout : "No results found.");
-			return Promise.resolve(builder.ok());
+			return builder.ok();
 		} catch (error) {
+			signal.throwIfAborted();
 			const msg = error instanceof Error ? error.message : String(error);
-			return Promise.resolve(builder.error(`Codebase search error: ${msg}`));
+			return builder.error(`Codebase search error: ${msg}`);
 		}
 	}
 };
@@ -270540,6 +271427,7 @@ var ToolManager = class {
 			const result = await execution.execute({
 				turnId: "",
 				toolCallId: "shell-command",
+				executionOrigin: "operator_shell",
 				signal: controller.signal,
 				onUpdate: (update) => {
 					if (update.kind === "stdout") stdout += update.text ?? "";
@@ -270628,6 +271516,9 @@ var ToolManager = class {
 	hasUserTool(name) {
 		return this.userTools.has(name);
 	}
+	isUserTool(tool) {
+		return this.userTools.get(tool.name) === tool;
+	}
 	inheritUserTools(parent) {
 		for (const tool of parent.userTools.values()) {
 			if (!parent.enabledTools.has(tool.name)) continue;
@@ -271327,15 +272218,17 @@ var FallbackLLM = class {
 	onModelChanged;
 	prepareRequest;
 	onContextOverflow;
+	messagePreparation;
 	currentIndex = 0;
 	attemptedProviders = /* @__PURE__ */ new Set();
 	errorsAfterOutput = /* @__PURE__ */ new WeakSet();
 	rebuildBoundaryMessages;
-	constructor(candidates, onModelChanged = () => {}, prepareRequest, onContextOverflow) {
+	constructor(candidates, onModelChanged = () => {}, prepareRequest, onContextOverflow, messagePreparation = "eager") {
 		this.candidates = candidates;
 		this.onModelChanged = onModelChanged;
 		this.prepareRequest = prepareRequest;
 		this.onContextOverflow = onContextOverflow;
+		this.messagePreparation = messagePreparation;
 		if (candidates.length === 0) throw new Error("FallbackLLM requires at least one model candidate.");
 	}
 	get activeAlias() {
@@ -271350,6 +272243,9 @@ var FallbackLLM = class {
 	get capability() {
 		return this.current.llm.capability;
 	}
+	get rebuildsMessagesAtRequestBoundary() {
+		return this.messagePreparation === "boundary" && this.prepareRequest !== void 0;
+	}
 	async prepareRequestBoundary(params, rebuildMessages) {
 		params.signal.throwIfAborted();
 		this.rebuildBoundaryMessages = rebuildMessages;
@@ -271412,6 +272308,7 @@ var FallbackLLM = class {
 			throw new Error("Fallback request preparation requires a fresh request boundary.");
 		}
 		let requestParams = params;
+		let messagesReady = false;
 		const rebuildRequestMessages = async () => {
 			const messages = await rebuildMessages();
 			const suffix = requestParams.boundaryMessageSuffix;
@@ -271420,7 +272317,14 @@ var FallbackLLM = class {
 		while (true) {
 			const candidate = this.current;
 			try {
-				requestParams = await this.prepareRequest?.(candidate, requestParams, rebuildRequestMessages) ?? requestParams;
+				const prepared = await this.prepareRequest?.(candidate, requestParams, rebuildRequestMessages);
+				if (prepared !== void 0) if ("messagesReady" in prepared) {
+					requestParams = prepared.params;
+					messagesReady = true;
+				} else {
+					requestParams = prepared;
+					messagesReady = false;
+				}
 			} catch (error) {
 				if (!isFallbackCandidateError(error) && !isUnavailableFallbackCandidate(error)) throw error;
 				const nextIndex = this.findNextCandidateIndex();
@@ -271430,13 +272334,14 @@ var FallbackLLM = class {
 					...requestParams,
 					messages: await rebuildRequestMessages()
 				};
+				messagesReady = false;
 				requestParams.signal.throwIfAborted();
 				this.currentIndex = nextIndex;
 				this.onModelChanged(this.current.alias);
 				continue;
 			}
 			requestParams.signal.throwIfAborted();
-			const messages = await rebuildRequestMessages();
+			const messages = messagesReady ? requestParams.messages : await rebuildRequestMessages();
 			requestParams.signal.throwIfAborted();
 			return {
 				...requestParams,
@@ -271538,8 +272443,13 @@ var LlmRequestLogger = class {
 	toolsEstimatedTokens = 0;
 	requestSequence = 0;
 	lastTurnRequest;
-	constructor(log) {
+	serializedPrefixKey;
+	requestSignatures = /* @__PURE__ */ new Map();
+	prefixComparisons = /* @__PURE__ */ new Map();
+	lastSerializedRequest;
+	constructor(log, serializedPrefixDiagnostic = process.env["BLUN_DIAG_SERIALIZED_PREFIX"] === "1") {
 		this.log = log;
+		this.serializedPrefixKey = serializedPrefixDiagnostic ? randomBytes(32) : void 0;
 	}
 	logRequest(input) {
 		const sequence = ++this.requestSequence;
@@ -271556,6 +272466,10 @@ var LlmRequestLogger = class {
 			toolsHash: fingerprint(JSON.stringify(toolSignature(tools)))
 		};
 		const signature = JSON.stringify(config);
+		if (this.serializedPrefixKey !== void 0) {
+			this.requestSignatures.set(sequence, signature);
+			if (this.requestSignatures.size > 32) this.requestSignatures.delete(this.requestSignatures.keys().next().value);
+		}
 		if (signature !== this.lastConfigLogSignature) {
 			this.lastConfigLogSignature = signature;
 			this.configRevision++;
@@ -271585,6 +272499,20 @@ var LlmRequestLogger = class {
 			}
 		};
 		if (partialMessageCount > 0) requestFields.partialMessageCount = partialMessageCount;
+		const source = input.systemPromptContributions;
+		if (source?.version === 1 && [
+			source.totalBytes,
+			source.instructionBytes,
+			source.skillListingBytes,
+			source.runtimeMemoryBytes,
+			source.otherBytes
+		].every((value) => Number.isSafeInteger(value) && value >= 0) && source.instructionBytes + source.skillListingBytes + source.runtimeMemoryBytes + source.otherBytes === source.totalBytes && source.totalBytes === Buffer.byteLength(systemPrompt, "utf8")) requestFields.systemPromptSourceBytes = {
+			totalBytes: source.totalBytes,
+			instructionBytes: source.instructionBytes,
+			skillListingBytes: source.skillListingBytes,
+			runtimeMemoryBytes: source.runtimeMemoryBytes,
+			otherBytes: source.otherBytes
+		};
 		this.log.info("llm request", requestFields);
 		if (fields?.turnStep !== void 0 && /^\d+\.\d+$/.test(fields.turnStep)) {
 			const historyTextOrigins = summarizeRequestTextOrigins(messages);
@@ -271610,10 +272538,51 @@ var LlmRequestLogger = class {
 	getLastTurnRequest() {
 		return this.lastTurnRequest === void 0 ? void 0 : structuredClone(this.lastTurnRequest);
 	}
+	get serializedPrefixDiagnosticEnabled() {
+		return this.serializedPrefixKey !== void 0;
+	}
+	observeSerializedRequest(body, fields, sequence) {
+		const key = this.serializedPrefixKey;
+		if (key === void 0 || !/^\d+\.\d+$/.test(fields?.turnStep ?? "")) return;
+		const signature = this.requestSignatures.get(sequence);
+		if (signature === void 0) return;
+		try {
+			const bytes = Buffer.from(body, "utf8");
+			const granularityBytes = 1024;
+			const chunks = [];
+			for (let start = 0; start + granularityBytes <= bytes.length; start += granularityBytes) chunks.push(createHmac("sha256", key).update(bytes.subarray(start, start + granularityBytes)).digest("hex"));
+			const previous = this.lastSerializedRequest;
+			if (previous !== void 0 && previous.signature === signature) {
+				let common = 0;
+				while (common < previous.chunks.length && common < chunks.length && previous.chunks[common] === chunks[common]) common++;
+				this.prefixComparisons.set(sequence, {
+					version: 1,
+					granularityBytes,
+					previousBytes: previous.bytes,
+					currentBytes: bytes.length,
+					commonPrefixBytesLowerBound: common * granularityBytes,
+					previousSequence: previous.sequence,
+					currentSequence: sequence
+				});
+				if (this.prefixComparisons.size > 32) this.prefixComparisons.delete(this.prefixComparisons.keys().next().value);
+			}
+			this.lastSerializedRequest = {
+				sequence,
+				signature,
+				bytes: bytes.length,
+				chunks
+			};
+		} catch {
+			this.lastSerializedRequest = void 0;
+		}
+	}
 	logTransportAttempt(stats, fields, sequence) {
+		const serializedPrefix = sequence === void 0 ? void 0 : this.prefixComparisons.get(sequence);
 		this.log.info("llm transport attempt", {
 			...fields,
-			...stats
+			...stats,
+			...this.serializedPrefixKey === void 0 || sequence === void 0 ? {} : { requestSequence: sequence },
+			...serializedPrefix === void 0 ? {} : { serializedPrefix }
 		});
 		if (sequence === void 0 || this.lastTurnRequest?.sequence !== sequence) return;
 		const breakdown = stats.requestBreakdown;
@@ -271635,6 +272604,11 @@ var LlmRequestLogger = class {
 					systemMessageBytes: breakdown.systemMessageBytes,
 					conversationMessageBytes: breakdown.conversationMessageBytes,
 					toolResultMessageBytes: breakdown.toolResultMessageBytes,
+					...breakdown.toolResultByTool === void 0 ? {} : { toolResultByTool: breakdown.toolResultByTool.map((tool) => ({
+						count: tool.count,
+						bytes: tool.bytes,
+						...tool.name === void 0 ? {} : { name: tool.name }
+					})) },
 					toolSchemaBytes: breakdown.toolSchemaBytes,
 					otherBytes: breakdown.otherBytes,
 					...breakdown.toolArrayOverheadBytes === void 0 ? {} : { toolArrayOverheadBytes: breakdown.toolArrayOverheadBytes },
@@ -271696,7 +272670,8 @@ function copyContributions(value) {
 			version: source.version,
 			totalBytes: source.totalBytes,
 			generatedBytes: source.generatedBytes,
-			files: source.files.map((file) => copyInstructionFileBytes(file))
+			files: source.files.map((file) => copyInstructionFileBytes(file)),
+			...source.notLoadedCandidates === void 0 ? {} : { notLoadedCandidates: [...source.notLoadedCandidates] }
 		} }
 	};
 }
@@ -271792,7 +272767,11 @@ var Agent$1 = class {
 	errorMemory;
 	replayBuilder;
 	additionalDirs;
+	systemPromptStartedAt = /* @__PURE__ */ new Date();
 	activeProfile;
+	rawSystemPromptContext;
+	profileSystemPromptText;
+	agentsMdRequestWarningShown = false;
 	brandHome;
 	_activeResponderModel;
 	allowModelFallback = true;
@@ -271879,6 +272858,7 @@ var Agent$1 = class {
 			const retryScope = providerRetryScope(modelAlias, provider);
 			await this.providerRetryWait.wait(retryScope, generateOptions?.signal);
 			const callerTransportAttempt = generateOptions?.onTransportAttempt;
+			const callerSerializedRequest = generateOptions?.onSerializedRequest;
 			const ownedGenerateOptions = {
 				...generateOptions,
 				transportMaxRetries: 0
@@ -271901,6 +272881,12 @@ var Agent$1 = class {
 							callerTransportAttempt?.(stats);
 							this.llmRequestLogger.logTransportAttempt(stats, requestLogFields, requestSequence);
 						},
+						...callerSerializedRequest !== void 0 || this.llmRequestLogger.serializedPrefixDiagnosticEnabled ? { onSerializedRequest: (body) => {
+							try {
+								callerSerializedRequest?.(body);
+							} catch {}
+							this.llmRequestLogger.observeSerializedRequest(body, requestLogFields, requestSequence);
+						} } : {},
 						onRequestStart: () => {
 							requestOptions?.onRequestStart?.();
 							requestStarted = true;
@@ -271926,7 +272912,7 @@ var Agent$1 = class {
 	get llm() {
 		return this.llmForTurn();
 	}
-	llmForTurn(thinkingEffort) {
+	llmForTurn(thinkingEffort, diagnosticTurnId) {
 		const selectedAlias = this.config.model;
 		const modelProvider = this.modelProvider;
 		if (modelProvider === void 0) throw new BlunError(ErrorCodes.MODEL_NOT_CONFIGURED, "Provider not set");
@@ -271940,7 +272926,18 @@ var Agent$1 = class {
 				tools: requestTools,
 				messages: await rebuildMessages()
 			};
+			if (this.activeProfile !== void 0 && this.rawSystemPromptContext !== void 0 && this.config.systemPrompt === this.profileSystemPromptText) this.updateSystemPromptFromProfile(this.activeProfile, this.fitProfileInstructions(this.activeProfile, this.rawSystemPromptContext, requestTools, true));
 			let systemPrompt = this.effectiveSystemPrompt;
+			if (this.config.runtimeModel(_candidate.alias).provider.name === "blun") {
+				const fixedTools = requestTools.filter((tool) => tool.name !== "CompactConversation");
+				const fixedRequestBytes = estimateBlunSerializedBodyBytes(systemPrompt, fixedTools, []) + 4096;
+				if (fixedRequestBytes >= 5e5) throw new BlunError(ErrorCodes.CONTEXT_OVERFLOW, "Fixed instructions or tools exceed the BLUN request limit; compaction cannot reduce them.", { details: {
+					contextBrakeBlocked: true,
+					estimatedRequestBytes: fixedRequestBytes,
+					requestBudgetBytes: 5e5
+				} });
+			}
+			const preflightStartedAt = performance.now();
 			const compacted = await this.fullCompaction.beforeStep(params.signal, {
 				messages: params.messages,
 				additionalMessages: steers.messages,
@@ -271949,21 +272946,42 @@ var Agent$1 = class {
 				rebuildSystemPrompt: () => systemPrompt = this.effectiveSystemPrompt,
 				tools: params.tools
 			});
+			if (this.type === "main" && diagnosticTurnId !== void 0 && process.env["BLUN_DIAG_PRE_REQUEST_PHASES"] === "1") try {
+				this.log.info("turn pre-request phase", {
+					turnId: diagnosticTurnId,
+					phase: "compaction-preflight",
+					durationMs: Math.max(0, Math.round(performance.now() - preflightStartedAt))
+				});
+			} catch {}
 			const tools = params.tools.some((tool) => tool.name === "CompactConversation") && !this.fullCompaction.proactiveCompactionStatus({
 				messages: compacted ? await rebuildMessages() : params.messages,
 				additionalMessages: steers.messages,
 				systemPrompt,
 				tools: params.tools
 			}).eligible ? params.tools.filter((tool) => tool.name !== "CompactConversation") : params.tools;
-			this.turn.commitPendingSteers(steers);
-			return {
+			const steersCommitted = this.turn.commitPendingSteers(steers);
+			if (compacted || steersCommitted) params = {
 				...params,
-				systemPrompt,
-				tools
+				messages: await rebuildMessages()
+			};
+			if (this.config.runtimeModel(_candidate.alias).provider.name === "blun") {
+				const requestBytes = estimateBlunSerializedBodyBytes(systemPrompt, tools, params.messages) + 4096;
+				if (requestBytes >= 5e5) throw new BlunError(ErrorCodes.CONTEXT_OVERFLOW, "The BLUN request is too large after compaction. Shorten fixed instructions or tools.", { details: {
+					estimatedRequestBytes: requestBytes,
+					requestBudgetBytes: 5e5
+				} });
+			}
+			return {
+				params: {
+					...params,
+					systemPrompt,
+					tools
+				},
+				messagesReady: true
 			};
 		}, (candidate, _params, error) => {
 			this.fullCompaction.observeContextOverflow(error, candidate.alias);
-		});
+		}, "boundary");
 	}
 	createKosongLLM(modelAlias, thinkingEffort) {
 		const runtimeModel = this.config.runtimeModel(modelAlias);
@@ -272031,8 +273049,14 @@ var Agent$1 = class {
 	}
 	useProfile(profile, context, brandHome) {
 		this.setActiveProfile(profile, brandHome);
-		this.updateSystemPromptFromProfile(profile, context);
+		this.rawSystemPromptContext = context;
+		if (context?.agentsMdText === void 0) {
+			this.updateSystemPromptFromProfile(profile, context);
+			this.tools.setActiveTools(profile.tools);
+			return;
+		}
 		this.tools.setActiveTools(profile.tools);
+		this.updateSystemPromptFromProfile(profile, this.fitProfileInstructions(profile, context));
 	}
 	setActiveProfile(profile, brandHome) {
 		this.activeProfile = profile;
@@ -272047,12 +273071,74 @@ var Agent$1 = class {
 	async refreshSystemPrompt() {
 		if (this.activeProfile === void 0) return;
 		const context = this.systemPromptContextProvider === void 0 ? await prepareSystemPromptContext(this.kaos, this.brandHome, { additionalDirs: this.additionalDirs }) : await this.systemPromptContextProvider();
-		this.updateSystemPromptFromProfile(this.activeProfile, context);
+		this.rawSystemPromptContext = context;
+		this.updateSystemPromptFromProfile(this.activeProfile, this.fitProfileInstructions(this.activeProfile, context));
+	}
+	fitProfileInstructions(profile, context, tools = this.tools.loopTools, notify = false) {
+		if (context?.agentsMdText === void 0 || this.config.modelAlias === void 0) return context;
+		if (this.config.runtimeModel(this.config.modelAlias).provider.name !== "blun") return context;
+		const renderFixedPrompt = (candidate) => {
+			const rendered = profile.systemPrompt({
+				osEnv: this.kaos.osEnv,
+				now: this.systemPromptStartedAt,
+				cwd: this.config.cwd,
+				skills: this.skills?.registry,
+				cwdListing: candidate.cwdListing,
+				agentsMd: candidate.agentsMd,
+				additionalDirsInfo: candidate.additionalDirsInfo
+			});
+			const compact = this.skills?.registry === void 0 ? rendered : compactLegacyModelSkillListing(rendered, this.skills.registry);
+			return this.runtimeSystemPromptAppend.length === 0 ? compact : compact.length === 0 ? this.runtimeSystemPromptAppend : `${compact}\n\n${this.runtimeSystemPromptAppend}`;
+		};
+		const fitted = fitAgentsMdContext(context, 4e5, (candidate) => {
+			return estimateBlunSerializedBodyBytes(renderFixedPrompt(candidate), tools, []) + 4096;
+		});
+		const describeFixedEstimate = () => {
+			const systemPrompt = renderFixedPrompt(fitted.context);
+			const envelopeBytes = estimateBlunSerializedBodyBytes("", [], []);
+			const withoutToolsBytes = estimateBlunSerializedBodyBytes(systemPrompt, [], []);
+			return {
+				estimationStage: notify ? "request" : "profile",
+				toolCount: tools.length,
+				serializedPromptBytes: withoutToolsBytes - envelopeBytes,
+				serializedToolsBytes: fitted.fixedRequestBytes - 4096 - withoutToolsBytes,
+				envelopeBytes,
+				reserveBytes: 4096,
+				instructionBytes: fitted.context.agentsMdSources?.totalBytes ?? 0,
+				runtimeAppendBytes: Buffer.byteLength(this.runtimeSystemPromptAppend, "utf8")
+			};
+		};
+		if (!fitted.fits) this.log.warn("fixed BLUN request exceeds 400000 bytes without AGENTS.md", {
+			fixedRequestBytes: fitted.fixedRequestBytes,
+			...describeFixedEstimate()
+		});
+		else if (fitted.omittedBytes > 0) {
+			this.log.warn("AGENTS.md content shortened for BLUN request budget", {
+				omittedBytes: fitted.omittedBytes,
+				fixedRequestBytes: fitted.fixedRequestBytes,
+				...describeFixedEstimate()
+			});
+			if (notify && !this.agentsMdRequestWarningShown) {
+				this.agentsMdRequestWarningShown = true;
+				const retained = new Map(fitted.context.agentsMdSources?.files.map((file) => [file.path, file.bytes]));
+				const files = context.agentsMdSources?.files.flatMap((file) => {
+					const read = retained.get(file.path) ?? 0;
+					return read < file.bytes ? [`${file.path}: ${file.bytes} bytes, ${read} read, ${file.bytes - read} omitted`] : [];
+				}) ?? [];
+				this.emitEvent({
+					type: "warning",
+					code: "agents-md-request-truncated",
+					message: `Instructions shortened for the request size limit: ${files.join("; ")}.`
+				});
+			}
+		}
+		return fitted.context;
 	}
 	updateSystemPromptFromProfile(profile, context) {
 		let contributions;
 		const systemPrompt = profile.systemPrompt({
 			osEnv: this.kaos.osEnv,
+			now: this.systemPromptStartedAt,
 			cwd: this.config.cwd,
 			skills: this.skills?.registry,
 			cwdListing: context?.cwdListing,
@@ -272067,6 +273153,7 @@ var Agent$1 = class {
 			profileName: profile.name,
 			systemPrompt
 		});
+		this.profileSystemPromptText = systemPrompt;
 		this.renderedPromptContributions = contributions === void 0 ? void 0 : {
 			text: systemPrompt,
 			value: structuredClone(contributions)
@@ -272243,6 +273330,9 @@ var Agent$1 = class {
 			},
 			startBtw: () => this.subagentHost.startBtw(),
 			createGoal: (payload) => this.goal.createGoal(payload),
+			editGoal: (payload) => this.goal.editGoal(payload),
+			blockGoal: (payload) => this.goal.blockGoal(payload),
+			completeGoal: () => this.goal.completeGoal(),
 			getGoal: () => this.goal.getGoal(),
 			pauseGoal: () => this.goal.pauseGoal(),
 			resumeGoal: () => this.goal.resumeGoal(),
@@ -336497,6 +337587,15 @@ var SessionAPIImpl = class {
 	async createGoal({ agentId, ...payload }) {
 		return (await this.getAgent(agentId)).createGoal(payload);
 	}
+	async editGoal({ agentId, ...payload }) {
+		return (await this.getAgent(agentId)).editGoal(payload);
+	}
+	async blockGoal({ agentId, ...payload }) {
+		return (await this.getAgent(agentId)).blockGoal(payload);
+	}
+	async completeGoal({ agentId }) {
+		return (await this.getAgent(agentId)).completeGoal({});
+	}
 	async getGoal({ agentId, ...payload }) {
 		return (await this.getAgent(agentId, true)).getGoal(payload);
 	}
@@ -337741,6 +338840,15 @@ var BlunCore = class {
 	getGoal({ sessionId, ...payload }) {
 		return Promise.resolve(this.sessionApi(sessionId).getGoal(payload));
 	}
+	editGoal({ sessionId, ...payload }) {
+		return Promise.resolve(this.sessionApi(sessionId).editGoal(payload));
+	}
+	blockGoal({ sessionId, ...payload }) {
+		return Promise.resolve(this.sessionApi(sessionId).blockGoal(payload));
+	}
+	completeGoal({ sessionId, ...payload }) {
+		return Promise.resolve(this.sessionApi(sessionId).completeGoal(payload));
+	}
 	pauseGoal({ sessionId, ...payload }) {
 		return Promise.resolve(this.sessionApi(sessionId).pauseGoal(payload));
 	}
@@ -344942,7 +346050,10 @@ function reduceWireRecords(records) {
 						text: record.summary
 					}],
 					toolCalls: [],
-					origin: { kind: "compaction_summary" }
+					origin: {
+						kind: "compaction_summary",
+						...record.toolContinuity === void 0 ? {} : { toolContinuity: record.toolContinuity }
+					}
 				},
 				time: record.time
 			};
@@ -347193,6 +348304,24 @@ var Session = class {
 		this.ensureOpen();
 		return this.rpc.getGoal({ sessionId: this.id });
 	}
+	async editGoal(input) {
+		this.ensureOpen();
+		return this.rpc.editGoal({
+			sessionId: this.id,
+			objective: input.objective
+		});
+	}
+	async blockGoal(input = {}) {
+		this.ensureOpen();
+		return this.rpc.blockGoal({
+			sessionId: this.id,
+			reason: input.reason
+		});
+	}
+	async completeGoal() {
+		this.ensureOpen();
+		return this.rpc.completeGoal({ sessionId: this.id });
+	}
 	async pauseGoal() {
 		this.ensureOpen();
 		return this.rpc.pauseGoal({ sessionId: this.id });
@@ -347752,6 +348881,39 @@ var BlunAuthFacade = class {
 		}
 		return this.toolkit.status(providerName, this.resolveRuntimeManagedAuth(providerName).oauthRef);
 	}
+	async getCachedMemoryWorkspaceId() {
+		const apiKey = nonEmpty(this.resolveManagedAuth(BLUN_PROVIDER_NAME$1).apiKey);
+		if (apiKey !== void 0) {
+			const provider = readConfigFileForUpdate(this.options.configPath).providers[BLUN_PROVIDER_NAME$1];
+			if (provider?.apiKey !== apiKey || provider.memoryApiKeyHash !== memoryApiKeyHash(apiKey)) return;
+			return provider.memoryWorkspaceId;
+		}
+		return this.toolkit.getCachedMemoryWorkspaceId(this.resolveRuntimeManagedAuth(BLUN_PROVIDER_NAME$1).oauthRef);
+	}
+	async cacheMemoryWorkspaceId(workspaceId) {
+		const apiKey = nonEmpty(this.resolveManagedAuth(BLUN_PROVIDER_NAME$1).apiKey);
+		if (apiKey !== void 0) {
+			const hash = memoryApiKeyHash(apiKey);
+			return mutateConfigFile(this.options.configPath, (config) => {
+				const provider = config.providers[BLUN_PROVIDER_NAME$1];
+				if (provider?.apiKey !== apiKey) return {
+					config,
+					result: false
+				};
+				if (provider.memoryApiKeyHash === hash && provider.memoryWorkspaceId !== void 0 && provider.memoryWorkspaceId !== workspaceId) return {
+					config,
+					result: false
+				};
+				provider.memoryApiKeyHash = hash;
+				provider.memoryWorkspaceId = workspaceId;
+				return {
+					config,
+					result: true
+				};
+			});
+		}
+		return this.toolkit.cacheMemoryWorkspaceId(workspaceId, this.resolveRuntimeManagedAuth(BLUN_PROVIDER_NAME$1).oauthRef);
+	}
 	async login(providerName = BLUN_PROVIDER_NAME$1, options = {}) {
 		const auth = this.resolveManagedAuth(providerName);
 		const loginAuth = resolveBlunCodeLoginAuth({
@@ -348057,6 +349219,9 @@ function nonEmpty(value) {
 	const normalized = value?.trim();
 	return normalized === void 0 || normalized.length === 0 ? void 0 : normalized;
 }
+function memoryApiKeyHash(apiKey) {
+	return createHash("sha256").update(apiKey).digest("hex");
+}
 function transitionAggregateError(message, primary, secondary) {
 	return new AggregateError([primary, secondary], message, { cause: primary });
 }
@@ -348537,6 +349702,26 @@ var SDKRpcClientBase = class {
 			replace: input.replace
 		});
 	}
+	async editGoal(input) {
+		return (await this.getRpc()).editGoal({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId,
+			objective: input.objective
+		});
+	}
+	async blockGoal(input) {
+		return (await this.getRpc()).blockGoal({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId,
+			reason: input.reason
+		});
+	}
+	async completeGoal(input) {
+		return (await this.getRpc()).completeGoal({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId
+		});
+	}
 	async getGoal(input) {
 		return (await this.getRpc()).getGoal({
 			sessionId: input.sessionId,
@@ -348785,6 +349970,7 @@ var SDKRpcClient = class extends SDKRpcClientBase {
 	core;
 	ready;
 	usesDefaultConfigPath;
+	restoreProfileModel;
 	constructor(options = {}) {
 		super();
 		this.identity = options.identity === void 0 ? void 0 : assertBlunHostIdentity(options.identity);
@@ -348794,9 +349980,11 @@ var SDKRpcClient = class extends SDKRpcClientBase {
 			configPath: options.configPath
 		});
 		this.usesDefaultConfigPath = options.configPath === void 0;
+		const authHomeDir = authHomeForProfile(this.homeDir);
+		this.restoreProfileModel = this.usesDefaultConfigPath && authHomeDir !== this.homeDir;
 		this.telemetry = options.telemetry ?? noopTelemetryClient;
 		this.auth = new BlunAuthFacade({
-			homeDir: authHomeForProfile(this.homeDir),
+			homeDir: authHomeDir,
 			configPath: this.configPath,
 			identity: this.identity,
 			onRefresh: options.onOAuthRefresh
@@ -348816,7 +350004,7 @@ var SDKRpcClient = class extends SDKRpcClientBase {
 	}
 	async ensureConfigFile() {
 		await ensureConfigFile(this.configPath);
-		if (this.usesDefaultConfigPath && authHomeForProfile(this.homeDir) !== this.homeDir) await this.auth.restoreMissingProfileModel();
+		if (this.restoreProfileModel) await this.auth.restoreMissingProfileModel();
 	}
 	async close() {
 		try {