@moonshot-ai/kimi-code 0.23.1 → 0.23.3

package/dist/main.mjs

@@ -9285,6 +9285,16 @@ function normalizeAnthropicStopReason(raw) {
 		};
 	}
 }
+function applyResponseFormat$1(kwargs, format) {
+	if (format === void 0) return;
+	if (format.type === "json_object") throw new ChatProviderError("Anthropic provider requires a JSON schema for structured response output.");
+	const outputConfig = kwargs["output_config"] !== void 0 && kwargs["output_config"] !== null ? { ...kwargs["output_config"] } : {};
+	outputConfig["format"] = {
+		type: "json_schema",
+		schema: format.jsonSchema.schema
+	};
+	kwargs["output_config"] = outputConfig;
+}
 /**
 * Extract Claude family + version from a model id.
 *
@@ -9927,6 +9937,7 @@ var init_anthropic = __esmMin((() => {
 			const thinking = this._generationKwargs.thinking;
 			if (thinking !== void 0 && !(thinking.type === "disabled" && isFableModel(this._model))) kwargs["thinking"] = thinking;
 			if (this._generationKwargs.output_config !== void 0) kwargs["output_config"] = this._generationKwargs.output_config;
+			applyResponseFormat$1(kwargs, options?.responseFormat);
 			if (this._generationKwargs.contextManagement !== void 0) kwargs["context_management"] = this._generationKwargs.contextManagement;
 			const betas = this._generationKwargs.betaFeatures ?? [];
 			const extraHeaders = {};
@@ -44858,6 +44869,13 @@ function toolToGoogleGenAI(tool) {
 		parametersJsonSchema: tool.parameters
 	}] };
 }
+function applyResponseFormat(config, format) {
+	if (format === void 0) return;
+	config["responseMimeType"] = "application/json";
+	delete config["responseSchema"];
+	delete config["responseJsonSchema"];
+	if (format.type === "json_schema") config["responseJsonSchema"] = format.jsonSchema.schema;
+}
 function toolCallIdToName(toolCallId, toolNameById) {
 	const name = toolNameById.get(toolCallId);
 	if (name !== void 0) return name;
@@ -45299,6 +45317,7 @@ var init_google_genai = __esmMin((() => {
 				systemInstruction: systemPrompt,
 				...tools.length > 0 ? { tools: tools.map((t) => toolToGoogleGenAI(t)) } : {}
 			};
+			applyResponseFormat(config, options?.responseFormat);
 			try {
 				const models = this._createClient(options?.auth).models;
 				const params = {
@@ -53516,6 +53535,18 @@ function convertTool$1(tool) {
 		}
 	};
 }
+function responseFormatToOpenAI$1(format) {
+	if (format.type === "json_object") return { type: "json_object" };
+	return {
+		type: "json_schema",
+		json_schema: {
+			name: format.jsonSchema.name,
+			schema: format.jsonSchema.schema,
+			strict: format.jsonSchema.strict,
+			description: format.jsonSchema.description
+		}
+	};
+}
 /**
 * Extract usage from a streaming chunk. Moonshot may place usage in
 * `choices[0].usage` in addition to the top-level `usage` field.
@@ -53717,6 +53748,7 @@ var init_kimi = __esmMin((() => {
 				...requestKwargs,
 				...extraBody
 			};
+			if (options?.responseFormat !== void 0) createParams["response_format"] = responseFormatToOpenAI$1(options.responseFormat);
 			if (tools.length > 0) createParams["tools"] = tools.map((t) => convertTool$1(t));
 			if (this._stream) createParams["stream_options"] = { include_usage: true };
 			try {
@@ -53798,6 +53830,18 @@ var init_kimi = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/kosong/src/providers/openai-legacy.ts
+function responseFormatToOpenAI(format) {
+	if (format.type === "json_object") return { type: "json_object" };
+	return {
+		type: "json_schema",
+		json_schema: {
+			name: format.jsonSchema.name,
+			schema: format.jsonSchema.schema,
+			strict: format.jsonSchema.strict,
+			description: format.jsonSchema.description
+		}
+	};
+}
 function extractReasoningContent(source, explicitKey) {
 	if (typeof source !== "object" || source === null) return void 0;
 	const record = source;
@@ -54070,6 +54114,7 @@ var init_openai_legacy = __esmMin((() => {
 				stream: this._stream,
 				...kwargs
 			};
+			if (options?.responseFormat !== void 0) createParams["response_format"] = responseFormatToOpenAI(options.responseFormat);
 			if (tools.length > 0) createParams["tools"] = tools.map((t) => toolToOpenAI(t));
 			if (this._stream) createParams["stream_options"] = { include_usage: true };
 			if (reasoningEffort !== void 0) createParams["reasoning_effort"] = reasoningEffort;
@@ -54295,6 +54340,16 @@ function formatResponsesFailedResponse(response) {
 	const reason = incompleteDetails === void 0 ? void 0 : readStringField$1(incompleteDetails, "reason");
 	return reason === void 0 ? "Unknown error (no error details in response)" : `incomplete: ${reason}`;
 }
+function responseFormatToResponsesText(format) {
+	if (format.type === "json_object") return { format: { type: "json_object" } };
+	return { format: {
+		type: "json_schema",
+		name: format.jsonSchema.name,
+		schema: format.jsonSchema.schema,
+		strict: format.jsonSchema.strict,
+		description: format.jsonSchema.description
+	} };
+}
 function contentPartsToInputItems(parts) {
 	const items = [];
 	for (const part of parts) switch (part.type) {
@@ -54814,6 +54869,10 @@ var init_openai_responses = __esmMin((() => {
 					...kwargs
 				};
 				if (systemPrompt) createParams["instructions"] = systemPrompt;
+				if (options?.responseFormat !== void 0) createParams["text"] = {
+					...asRawObject(createParams["text"]),
+					...responseFormatToResponsesText(options.responseFormat)
+				};
 				if (!("responses" in client) || typeof client.responses?.create !== "function") throw new Error("OpenAI SDK version does not support Responses API. Upgrade to >=4.x with responses support.");
 				options?.onRequestSent?.();
 				return new OpenAIResponsesStreamedMessage(await client.responses.create(createParams, options?.signal ? { signal: options.signal } : void 0), this._stream);
@@ -77871,57 +77930,6 @@ var init_full = __esmMin((() => {
 		buildInstruction(customInstruction) {
 			return renderPrompt(compaction_instruction_default, { customInstruction: customInstruction?.trim() ?? "" }).trimEnd();
 		}
-		/**
-		* Keep-all rebuild (Phase 1): after compaction folded the history — and the
-		* dynamic tool schema messages with it — append ONE merged schema message so
-		* the model keeps calling its loaded tools without re-selecting. Schemas are
-		* read from the live registry, never copied from the old history, so a
-		* schema that changed since load self-heals here. Names whose server is
-		* currently disconnected have no registry schema and are not rebuilt (the
-		* model re-selects after reconnect); names that survived into the
-		* post-compaction history (none under today's users+summary rebuild, but
-		* guarded) are not duplicated. The message goes through the normal
-		* injection-origin append, so estimation and records pick it up as usual.
-		*
-		* Budget guard: the rebuilt floor (users + summary + schemas) is the one
-		* part of the post-compaction context that compaction itself can never
-		* shrink — if it lands inside the auto-compaction trigger band, every
-		* following step re-compacts and rebuilds in a loop. Admit schemas (in name
-		* order) only while the projected context stays within HALF the compaction
-		* trigger, so normal turn content still fits before the next compaction;
-		* anything dropped is simply re-selectable on demand, the same degradation
-		* as a disconnected server.
-		*/
-		rebuildDynamicToolSchemas(activeBefore) {
-			if (!this.agent.toolSelectEnabled) return;
-			if (activeBefore.size === 0) return;
-			const surviving = collectLoadedDynamicToolNames(this.agent.context.history);
-			const candidates = [...activeBefore].filter((name) => !surviving.has(name)).toSorted((a, b) => a.localeCompare(b)).map((name) => this.agent.tools.getMcpToolSchema(name)).filter((tool) => tool !== void 0);
-			if (candidates.length === 0) return;
-			const tools = [];
-			let projected = this.tokenCountWithPending;
-			for (const tool of candidates) {
-				const toolTokens = estimateTokensForTools([tool]);
-				if (this.strategy.shouldCompact((projected + toolTokens) * 2)) break;
-				tools.push(tool);
-				projected += toolTokens;
-			}
-			if (tools.length < candidates.length) this.agent.log.info("trimmed dynamic tool schema rebuild to stay clear of the compaction trigger", {
-				kept: tools.length,
-				dropped: candidates.slice(tools.length).map((tool) => tool.name)
-			});
-			if (tools.length === 0) return;
-			this.agent.context.appendMessage({
-				role: "system",
-				content: [],
-				toolCalls: [],
-				tools,
-				origin: {
-					kind: "injection",
-					variant: DYNAMIC_TOOL_SCHEMA_VARIANT
-				}
-			});
-		}
 		postProcessSummary(summary) {
 			const todos = this.agent.tools.storeData()["todo"] ?? [];
 			if (todos.length === 0) return summary;
@@ -77932,7 +77940,6 @@ var init_full = __esmMin((() => {
 			const startedAt = Date.now();
 			const originalHistory = [...this.agent.context.history];
 			const tokensBefore = estimateTokensForMessages(originalHistory);
-			const activeDynamicToolsBefore = new Set(this.agent.tools.loadedDynamicToolNames());
 			let retryCount = 0;
 			try {
 				await this.triggerPreCompactHook(data, tokensBefore, signal);
@@ -78021,7 +78028,6 @@ var init_full = __esmMin((() => {
 					tokensBefore,
 					droppedCount: droppedCount === 0 ? void 0 : droppedCount
 				});
-				this.rebuildDynamicToolSchemas(activeDynamicToolsBefore);
 				this.agent.telemetry.track("compaction_finished", {
 					source: data.source,
 					tokens_before: result.tokensBefore,
@@ -78050,7 +78056,7 @@ var init_full = __esmMin((() => {
 					thinking_effort: this.agent.config.thinkingEffort,
 					error_type: error instanceof Error ? error.name : "Unknown"
 				});
-				if (isKimiError(error) && error.code === ErrorCodes.AUTH_LOGIN_REQUIRED) throw error;
+				if (isKimiError(error) && (error.code === ErrorCodes.AUTH_LOGIN_REQUIRED || error.code === ErrorCodes.PROVIDER_AUTH_ERROR)) throw error;
 				throw new KimiError(ErrorCodes.COMPACTION_FAILED, String(error), { cause: error });
 			}
 		}
@@ -79838,6 +79844,11 @@ function sniffMediaFromMagic(data) {
 * 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.
+*
+* JPEG dimensions are reported in DISPLAY space: an EXIF Orientation of
+* 5-8 transposes the image at decode time, so the SOF width/height are
+* swapped to match what decoders (and this codebase's crop regions and
+* compression captions) actually operate in.
 */
 function sniffImageDimensions(data) {
 	const buf = toBuffer$2(data);
@@ -79881,6 +79892,7 @@ function sniffImageDimensions(data) {
 		};
 	}
 	if (startsWith(buf, [255, 216])) {
+		let orientation = null;
 		let offset = 2;
 		while (offset + 9 < buf.length) {
 			if (buf[offset] !== 255) {
@@ -79888,21 +79900,60 @@ function sniffImageDimensions(data) {
 				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 >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+				const height = buf.readUInt16BE(offset + 5);
+				const width = buf.readUInt16BE(offset + 7);
+				return orientation !== null && orientation >= 5 ? {
+					width: height,
+					height: width,
+					transposed: true
+				} : {
+					width,
+					height
+				};
+			}
 			if (marker === 216 || marker === 217 || marker >= 208 && marker <= 215) {
 				offset += 2;
 				continue;
 			}
 			const segmentLength = buf.readUInt16BE(offset + 2);
 			if (segmentLength < 2) break;
+			if (marker === 225 && orientation === null) orientation = readExifOrientation(buf, offset + 4, offset + 2 + segmentLength);
 			offset += 2 + segmentLength;
 		}
 	}
 	return null;
 }
+/**
+* Read the Orientation tag (0x0112) out of a JPEG APP1 payload spanning
+* [`start`, `end`). Returns 1-8, or `null` when the payload is not EXIF,
+* is truncated, or carries no valid orientation. Only IFD0 is examined —
+* that is where the tag lives; nothing here follows nested IFDs.
+*/
+function readExifOrientation(buf, start, end) {
+	const boundedEnd = Math.min(end, buf.length);
+	if (start + 6 > boundedEnd || buf.toString("latin1", start, start + 6) !== "Exif\0\0") return null;
+	const tiff = start + 6;
+	if (tiff + 8 > boundedEnd) return null;
+	const byteOrder = buf.toString("latin1", tiff, tiff + 2);
+	const le = byteOrder === "II";
+	if (!le && byteOrder !== "MM") return null;
+	const u16 = (offset) => le ? buf.readUInt16LE(offset) : buf.readUInt16BE(offset);
+	const u32 = (offset) => le ? buf.readUInt32LE(offset) : buf.readUInt32BE(offset);
+	if (u16(tiff + 2) !== 42) return null;
+	const ifd = tiff + u32(tiff + 4);
+	if (ifd + 2 > boundedEnd) return null;
+	const entryCount = u16(ifd);
+	for (let i = 0; i < entryCount; i += 1) {
+		const entry = ifd + 2 + i * 12;
+		if (entry + 12 > boundedEnd) return null;
+		if (u16(entry) === 274) {
+			const value = u16(entry + 8);
+			return value >= 1 && value <= 8 ? value : null;
+		}
+	}
+	return null;
+}
 function getSuffix(path) {
 	const idx = path.lastIndexOf(".");
 	if (idx === -1) return "";
@@ -121696,7 +121747,8 @@ var init_esm$13 = __esmMin((() => {
 * `changed: false`.
 */
 async function compressImageForModel(bytes, mimeType, options = {}) {
-	const maxEdge = options.maxEdge ?? 2e3;
+	const startedAt = Date.now();
+	const maxEdge = options.maxEdge ?? 3e3;
 	const byteBudget = options.byteBudget ?? 3932160;
 	const maxDecodeBytes = options.maxDecodeBytes ?? MAX_DECODE_BYTES;
 	const normalizedMime = normalizeMime(mimeType);
@@ -121712,38 +121764,50 @@ async function compressImageForModel(bytes, mimeType, options = {}) {
 		originalByteLength: bytes.length,
 		finalByteLength: bytes.length
 	});
-	if (bytes.length === 0) return passthrough();
-	if (!RECODABLE_MIME.has(normalizedMime)) return passthrough();
+	const finish = (outcome, result) => {
+		reportCompressEvent(options.telemetry, {
+			outcome,
+			startedAt,
+			inputMime: normalizedMime,
+			exifTransposed: dims?.transposed === true,
+			result
+		});
+		return result;
+	};
+	if (bytes.length === 0) return finish("passthrough_unsupported", passthrough());
+	if (!RECODABLE_MIME.has(normalizedMime)) return finish("passthrough_unsupported", passthrough());
 	const longestEdge = dims ? Math.max(dims.width, dims.height) : 0;
-	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();
+	if (bytes.length <= byteBudget && (longestEdge > 0 && longestEdge <= maxEdge || longestEdge === 0)) return finish("passthrough_fast", passthrough());
+	if (dims && dims.width * dims.height > MAX_DECODE_PIXELS) return finish("passthrough_guard", passthrough());
+	if (bytes.length > maxDecodeBytes) return finish("passthrough_guard", passthrough());
 	try {
 		const { Jimp } = await Promise.resolve().then(() => (init_esm$13(), esm_exports$3));
 		const image = await Jimp.fromBuffer(Buffer.from(bytes));
 		const sourceIsPng = normalizedMime === "image/png";
+		const decodedWidth = image.width;
+		const decodedHeight = image.height;
 		fitWithinEdge(image, maxEdge);
 		const encoded = await encodeWithinBudget(image, {
 			sourceIsPng,
 			byteBudget,
-			fallbackEdge: FALLBACK_EDGE_PX
+			fallbackEdges: FALLBACK_EDGES_PX
 		});
-		const originalPixels = (dims?.width ?? 0) * (dims?.height ?? 0);
+		const originalPixels = decodedWidth * decodedHeight;
 		const finalPixels = encoded.width * encoded.height;
-		if (!(encoded.data.length < bytes.length) && !(originalPixels > 0 && finalPixels < originalPixels)) return passthrough();
-		return {
+		if (!(encoded.data.length < bytes.length) && !(finalPixels < originalPixels)) return finish("passthrough_unhelpful", passthrough());
+		return finish("compressed", {
 			data: encoded.data,
 			mimeType: encoded.mimeType,
 			width: encoded.width,
 			height: encoded.height,
-			originalWidth: dims?.width ?? 0,
-			originalHeight: dims?.height ?? 0,
+			originalWidth: decodedWidth,
+			originalHeight: decodedHeight,
 			changed: true,
 			originalByteLength: bytes.length,
 			finalByteLength: encoded.data.length
-		};
+		});
 	} catch {
-		return passthrough();
+		return finish("passthrough_error", passthrough());
 	}
 }
 /**
@@ -121752,24 +121816,35 @@ async function compressImageForModel(bytes, mimeType, options = {}) {
 * returns the original base64 unchanged on any failure.
 */
 async function compressBase64ForModel(base64, mimeType, options = {}) {
+	const startedAt = Date.now();
 	const maxDecodeBytes = options.maxDecodeBytes ?? MAX_DECODE_BYTES;
 	const approxBytes = Math.floor(base64.length * 3 / 4);
-	if (approxBytes > maxDecodeBytes) return {
-		base64,
-		mimeType,
-		width: 0,
-		height: 0,
-		originalWidth: 0,
-		originalHeight: 0,
-		changed: false,
-		originalByteLength: approxBytes,
-		finalByteLength: approxBytes
-	};
+	if (approxBytes > maxDecodeBytes) {
+		const result = {
+			base64,
+			mimeType,
+			width: 0,
+			height: 0,
+			originalWidth: 0,
+			originalHeight: 0,
+			changed: false,
+			originalByteLength: approxBytes,
+			finalByteLength: approxBytes
+		};
+		reportCompressEvent(options.telemetry, {
+			outcome: "passthrough_guard",
+			startedAt,
+			inputMime: normalizeMime(mimeType),
+			exifTransposed: false,
+			result
+		});
+		return result;
+	}
 	let bytes;
 	try {
 		bytes = Buffer.from(base64, "base64");
 	} catch {
-		return {
+		const result = {
 			base64,
 			mimeType,
 			width: 0,
@@ -121780,6 +121855,14 @@ async function compressBase64ForModel(base64, mimeType, options = {}) {
 			originalByteLength: 0,
 			finalByteLength: 0
 		};
+		reportCompressEvent(options.telemetry, {
+			outcome: "passthrough_error",
+			startedAt,
+			inputMime: normalizeMime(mimeType),
+			exifTransposed: false,
+			result
+		});
+		return result;
 	}
 	const result = await compressImageForModel(bytes, mimeType, options);
 	if (!result.changed) return {
@@ -121884,36 +121967,41 @@ async function compressImageContentParts(parts, options = {}) {
 * larger than the edge cap is therefore delivered at native resolution.
 */
 async function cropImageForModel(bytes, mimeType, region, options = {}) {
-	const maxEdge = options.maxEdge ?? 2e3;
+	const startedAt = Date.now();
+	const maxEdge = options.maxEdge ?? 3e3;
 	const byteBudget = options.byteBudget ?? 3932160;
 	const maxDecodeBytes = options.maxDecodeBytes ?? MAX_DECODE_BYTES;
 	const normalizedMime = normalizeMime(mimeType);
-	if (bytes.length === 0) return {
-		ok: false,
-		error: "The image is empty."
+	const fail = (errorKind, error) => {
+		reportCropEvent(options.telemetry, {
+			startedAt,
+			ok: false,
+			errorKind
+		});
+		return {
+			ok: false,
+			error
+		};
 	};
-	if (!RECODABLE_MIME.has(normalizedMime)) return {
-		ok: false,
-		error: `Cropping is only supported for PNG and JPEG images; got ${mimeType}.`
+	const succeed = (result) => {
+		reportCropEvent(options.telemetry, {
+			startedAt,
+			ok: true,
+			result
+		});
+		return result;
 	};
+	if (bytes.length === 0) return fail("empty", "The image is empty.");
+	if (!RECODABLE_MIME.has(normalizedMime)) return fail("unsupported_format", `Cropping is only supported for PNG and JPEG images; got ${mimeType}.`);
 	if (![
 		region.x,
 		region.y,
 		region.width,
 		region.height
-	].every((value) => Number.isFinite(value))) return {
-		ok: false,
-		error: `Region coordinates must be finite numbers; got x=${String(region.x)}, y=${String(region.y)}, width=${String(region.width)}, height=${String(region.height)}.`
-	};
+	].every((value) => Number.isFinite(value))) return fail("region_invalid", `Region coordinates must be finite numbers; got x=${String(region.x)}, y=${String(region.y)}, width=${String(region.width)}, height=${String(region.height)}.`);
 	const dims = sniffImageDimensions(bytes);
-	if (dims && dims.width * dims.height > MAX_DECODE_PIXELS) return {
-		ok: false,
-		error: `The image (${String(dims.width)}x${String(dims.height)} pixels) is too large to decode for cropping.`
-	};
-	if (bytes.length > maxDecodeBytes) return {
-		ok: false,
-		error: "The image is too large to decode for cropping."
-	};
+	if (dims && dims.width * dims.height > MAX_DECODE_PIXELS) return fail("too_large", `The image (${String(dims.width)}x${String(dims.height)} pixels) is too large to decode for cropping.`);
+	if (bytes.length > maxDecodeBytes) return fail("too_large", "The image is too large to decode for cropping.");
 	try {
 		const { Jimp } = await Promise.resolve().then(() => (init_esm$13(), esm_exports$3));
 		const image = await Jimp.fromBuffer(Buffer.from(bytes));
@@ -121921,10 +122009,7 @@ async function cropImageForModel(bytes, mimeType, region, options = {}) {
 		const originalHeight = image.height;
 		const x = Math.floor(region.x);
 		const y = Math.floor(region.y);
-		if (x < 0 || y < 0 || x >= originalWidth || y >= originalHeight || region.width < 1 || region.height < 1) return {
-			ok: false,
-			error: `Region (x=${String(region.x)}, y=${String(region.y)}, width=${String(region.width)}, height=${String(region.height)}) lies outside the ${String(originalWidth)}x${String(originalHeight)} image.`
-		};
+		if (x < 0 || y < 0 || x >= originalWidth || y >= originalHeight || region.width < 1 || region.height < 1) return fail("out_of_bounds", `Region (x=${String(region.x)}, y=${String(region.y)}, width=${String(region.width)}, height=${String(region.height)}) lies outside the ${String(originalWidth)}x${String(originalHeight)} image.`);
 		const w = Math.min(Math.floor(region.width), originalWidth - x);
 		const h = Math.min(Math.floor(region.height), originalHeight - y);
 		const applied = {
@@ -121942,11 +122027,8 @@ async function cropImageForModel(bytes, mimeType, region, options = {}) {
 		const sourceIsPng = normalizedMime === "image/png";
 		if (options.skipResize === true) {
 			const buffer = sourceIsPng ? await image.getBuffer("image/png", { deflateLevel: 9 }) : await image.getBuffer("image/jpeg", { quality: 90 });
-			if (buffer.length > byteBudget) return {
-				ok: false,
-				error: `The cropped region encodes to ${String(buffer.length)} bytes (${formatByteSize$2(buffer.length)}), over the ${String(byteBudget)}-byte (${formatByteSize$2(byteBudget)}) per-image limit. Choose a smaller region, or allow downscaling.`
-			};
-			return {
+			if (buffer.length > byteBudget) return fail("budget", `The cropped region encodes to ${String(buffer.length)} bytes (${formatByteSize$2(buffer.length)}), over the ${String(byteBudget)}-byte (${formatByteSize$2(byteBudget)}) per-image limit. Choose a smaller region, or allow downscaling.`);
+			return succeed({
 				ok: true,
 				data: new Uint8Array(buffer),
 				mimeType: sourceIsPng ? "image/png" : "image/jpeg",
@@ -121958,15 +122040,15 @@ async function cropImageForModel(bytes, mimeType, region, options = {}) {
 				resized: false,
 				originalByteLength: bytes.length,
 				finalByteLength: buffer.length
-			};
+			});
 		}
 		fitWithinEdge(image, maxEdge);
 		const encoded = await encodeWithinBudget(image, {
 			sourceIsPng,
 			byteBudget,
-			fallbackEdge: FALLBACK_EDGE_PX
+			fallbackEdges: FALLBACK_EDGES_PX
 		});
-		return {
+		return succeed({
 			ok: true,
 			data: new Uint8Array(encoded.data),
 			mimeType: encoded.mimeType,
@@ -121978,12 +122060,9 @@ async function cropImageForModel(bytes, mimeType, region, options = {}) {
 			resized: encoded.width !== w || encoded.height !== h,
 			originalByteLength: bytes.length,
 			finalByteLength: encoded.data.length
-		};
+		});
 	} catch (error) {
-		return {
-			ok: false,
-			error: `Failed to decode the image for cropping: ${error instanceof Error ? error.message : String(error)}`
-		};
+		return fail("decode_failed", `Failed to decode the image for cropping: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
 /**
@@ -122056,14 +122135,17 @@ function parseImageDataUrl$1(url) {
 * Strategy — prefer the source format so a downscaled screenshot stays lossless
 * PNG (preserving text and transparency), and only fall back to lossy JPEG when
 * PNG cannot meet the byte budget:
-*  - PNG source: PNG at the fitted size → a smaller PNG rescale → JPEG ladder.
-*  - JPEG source: JPEG quality ladder → a smaller JPEG rescale.
+*  - PNG source: PNG at the fitted size → smaller PNG rescales, stepping down
+*    the fallback edges → JPEG ladder.
+*  - JPEG source: the full quality ladder at the fitted size, then again at
+*    each fallback edge — a smaller rescale must not skip the high-quality
+*    rungs its extra pixels just paid for.
 *
 * Always returns the smallest buffer it produced, even if no attempt met the
 * budget — the caller still gates on whether it actually helped.
 */
 async function encodeWithinBudget(image, opts) {
-	const { sourceIsPng, byteBudget, fallbackEdge } = opts;
+	const { sourceIsPng, byteBudget, fallbackEdges } = opts;
 	let smallest = null;
 	const consider = (data, mimeType) => {
 		const candidate = {
@@ -122079,7 +122161,8 @@ async function encodeWithinBudget(image, opts) {
 		const png = await image.getBuffer("image/png", { deflateLevel: 9 });
 		if (png.length <= byteBudget) return consider(png, "image/png");
 		consider(png, "image/png");
-		if (fitWithinEdge(image, fallbackEdge)) {
+		for (const edge of fallbackEdges) {
+			if (!fitWithinEdge(image, edge)) continue;
 			const smallerPng = await image.getBuffer("image/png", { deflateLevel: 9 });
 			if (smallerPng.length <= byteBudget) return consider(smallerPng, "image/png");
 			consider(smallerPng, "image/png");
@@ -122096,12 +122179,26 @@ async function encodeWithinBudget(image, opts) {
 		if (jpeg.length <= byteBudget) return consider(jpeg, "image/jpeg");
 		consider(jpeg, "image/jpeg");
 	}
-	if (fitWithinEdge(image, fallbackEdge)) consider(await image.getBuffer("image/jpeg", { quality: JPEG_QUALITY_STEPS.at(-1) }), "image/jpeg");
+	for (const edge of fallbackEdges) {
+		if (!fitWithinEdge(image, edge)) continue;
+		for (const quality of JPEG_QUALITY_STEPS) {
+			const jpeg = await image.getBuffer("image/jpeg", { quality });
+			if (jpeg.length <= byteBudget) return consider(jpeg, "image/jpeg");
+			consider(jpeg, "image/jpeg");
+		}
+	}
 	return smallest;
 }
 /**
 * Scale `image` so its longest edge is at most `edge`, preserving aspect
 * ratio. No-op (returns false) when the image already fits.
+*
+* Deliberately passes no `mode`: without one, jimp's default resizer
+* downscales with a full-coverage area average (every source pixel
+* contributes to the output), which does not alias. The named
+* ResizeStrategy modes (BILINEAR, BICUBIC, …) switch to point-sampled
+* interpolation that skips source pixels beyond ~2x reduction and produces
+* moiré on text and fine patterns — do not "upgrade" this call to one.
 */
 function fitWithinEdge(image, edge) {
 	const longest = Math.max(image.width, image.height);
@@ -122117,7 +122214,53 @@ function normalizeMime(mimeType) {
 	const lower = mimeType.trim().toLowerCase();
 	return lower === "image/jpg" ? "image/jpeg" : lower;
 }
-var IMAGE_BYTE_BUDGET, JPEG_QUALITY_STEPS, FALLBACK_EDGE_PX, MAX_DECODE_PIXELS, MAX_DECODE_BYTES, RECODABLE_MIME, CAPTION_OPENING, CAPTION_PATTERN;
+/**
+* Emit the `image_compress` event. Properties are all numeric/enum — never
+* paths or content — and a throwing client is swallowed so telemetry can
+* never affect the compression result.
+*/
+function reportCompressEvent(telemetry, input) {
+	if (telemetry === void 0) return;
+	try {
+		telemetry.client.track("image_compress", {
+			source: telemetry.source,
+			outcome: input.outcome,
+			input_mime: input.inputMime,
+			output_mime: normalizeMime(input.result.mimeType),
+			original_bytes: input.result.originalByteLength,
+			final_bytes: input.result.finalByteLength,
+			original_width: input.result.originalWidth,
+			original_height: input.result.originalHeight,
+			final_width: input.result.width,
+			final_height: input.result.height,
+			exif_transposed: input.exifTransposed,
+			duration_ms: Date.now() - input.startedAt
+		});
+	} catch {}
+}
+/**
+* Emit the `image_crop` event. Reports the region as a share of the original
+* pixel area rather than raw coordinates.
+*/
+function reportCropEvent(telemetry, input) {
+	if (telemetry === void 0) return;
+	try {
+		const { result } = input;
+		const originalPixels = result === void 0 ? 0 : result.originalWidth * result.originalHeight;
+		telemetry.client.track("image_crop", {
+			source: telemetry.source,
+			ok: input.ok,
+			error_kind: input.errorKind,
+			resized: result?.resized,
+			original_width: result?.originalWidth,
+			original_height: result?.originalHeight,
+			region_area_ratio: result === void 0 || originalPixels === 0 ? void 0 : result.region.width * result.region.height / originalPixels,
+			final_bytes: result?.finalByteLength,
+			duration_ms: Date.now() - input.startedAt
+		});
+	} catch {}
+}
+var IMAGE_BYTE_BUDGET, JPEG_QUALITY_STEPS, FALLBACK_EDGES_PX, MAX_DECODE_PIXELS, MAX_DECODE_BYTES, RECODABLE_MIME, CAPTION_OPENING, CAPTION_PATTERN;
 var init_image_compress = __esmMin((() => {
 	init_file_type$1();
 	IMAGE_BYTE_BUDGET = 3.75 * 1024 * 1024;
@@ -122127,7 +122270,7 @@ var init_image_compress = __esmMin((() => {
 		40,
 		20
 	];
-	FALLBACK_EDGE_PX = 1e3;
+	FALLBACK_EDGES_PX = [2e3, 1e3];
 	MAX_DECODE_PIXELS = 1e8;
 	MAX_DECODE_BYTES = 64 * 1024 * 1024;
 	RECODABLE_MIME = new Set(["image/png", "image/jpeg"]);
@@ -123396,19 +123539,26 @@ var init_goal$1 = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/session/hooks/runner.ts
+function buildHookSpawnOptions(options) {
+	return {
+		shell: true,
+		cwd: options.cwd,
+		stdio: "pipe",
+		detached: process.platform !== "win32",
+		windowsHide: true,
+		env: options.env ? {
+			...process.env,
+			...options.env
+		} : void 0
+	};
+}
 async function runHook(command, input, options) {
 	let child;
 	try {
-		child = spawn$1(command, {
-			shell: true,
+		child = spawn$1(command, buildHookSpawnOptions({
 			cwd: options.cwd,
-			stdio: "pipe",
-			detached: process.platform !== "win32",
-			env: options.env ? {
-				...process.env,
-				...options.env
-			} : void 0
-		});
+			env: options.env
+		}));
 	} catch (error) {
 		return allowResult({ stderr: errorMessage$4(error) });
 	}
@@ -124229,7 +124379,7 @@ function buildGoalReminder(goal) {
 	lines.push("");
 	lines.push("Before doing any goal work, check the objective and latest request for a clear hard budget limit. If one is present and the current goal does not already record that limit, call SetGoalBudget first. Do not invent budgets. If a requested budget is not reasonable, do not set it; tell the user it is not reasonable.");
 	lines.push("");
-	lines.push("Goal mode is iterative. Keep the self-audit brief each turn. Do not explore unrelated interpretations once the goal can be decided. If the objective is simple, already answered, impossible, unsafe, or contradictory, do not run another goal turn. Explain briefly if useful, then call UpdateGoal with `complete` or `blocked` in the same turn. Otherwise, choose one bounded, useful slice of work toward the objective. Do not try to finish a broad goal in one turn unless the whole goal is genuinely small. Most goal turns should not call UpdateGoal: after completing a useful slice, if material work remains, end the turn normally without calling UpdateGoal so the runtime can continue the goal in the next turn. Call UpdateGoal with `complete` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not mark complete after only producing a plan, summary, first pass, or partial result. Before calling `complete`, check that every required part of the objective is done, completion criteria are satisfied, requested or expected validation passed or has been reported as impossible, and no known material task remains. Call UpdateGoal with `blocked` only for a genuine impasse: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. Do not use `blocked` because the work is large, hard, slow, uncertain, partial, still needs validation, or needs more goal turns.");
+	lines.push("Goal mode is iterative. Keep the self-audit brief each turn. Do not explore unrelated interpretations once the goal can be decided. If the objective is simple, already answered, impossible, unsafe, or contradictory, do not run another goal turn. Explain briefly if useful, then call UpdateGoal with `complete` or `blocked` in the same turn. Otherwise, choose one bounded, useful slice of work toward the objective. Do not try to finish a broad goal in one turn unless the whole goal is genuinely small. Most goal turns should not call UpdateGoal: after completing a useful slice, if material work remains, end the turn normally without calling UpdateGoal so the runtime can continue the goal in the next turn. Call UpdateGoal with `complete` only when all required work is done, any stated validation has passed, and there is no useful next action. Completion audit: before calling `complete`, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not mark complete after only producing a plan, summary, first pass, or partial result. Do not mark complete merely because a budget is nearly exhausted or you want to stop. Blocked audit: do not call UpdateGoal with `blocked` the first time you hit a blocker. Use `blocked` only for a genuine impasse: an external condition, required user input, missing credentials or permissions, or a persistent technical failure. For those non-terminal blockers, the same blocking condition must repeat for at least 3 consecutive goal turns before you call `blocked`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. Exception: if the objective itself is impossible, unsafe, or contradictory, call UpdateGoal with `blocked` in the same turn; do not run more goal turns just to satisfy the audit. Do not use `blocked` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call UpdateGoal with `blocked`; do not keep reporting the blocker while leaving the goal active.");
 	return lines.join("\n");
 }
 /** Highest budget-usage fraction across the set hard budgets (turns/tokens/time). */
@@ -142142,7 +142292,13 @@ async function mcpResultToExecutableOutput(result, qualifiedToolName, options =
 		if (part !== null) converted.push(part);
 	}
 	const budgeted = applyTextBudget(wrapMediaOnly(converted, qualifiedToolName));
-	const compressed = await compressImageContentParts(budgeted.parts, { annotate: { persistOriginal: (bytes, mimeType) => persistOriginalImage(bytes, mimeType, options.originalsDir === void 0 ? {} : { dir: options.originalsDir }) } });
+	const compressed = await compressImageContentParts(budgeted.parts, {
+		telemetry: options.telemetry === void 0 ? void 0 : {
+			client: options.telemetry,
+			source: "mcp_tool_result"
+		},
+		annotate: { persistOriginal: (bytes, mimeType) => persistOriginalImage(bytes, mimeType, options.originalsDir === void 0 ? {} : { dir: options.originalsDir }) }
+	});
 	const capped = applyBinaryPartCap(compressed.parts);
 	const truncated = budgeted.truncated || capped.truncated;
 	return {
@@ -150452,7 +150608,8 @@ var init_read_media = __esmMin((() => {
 		name = "ReadMediaFile";
 		description;
 		parameters = toInputJsonSchema(ReadMediaFileInputSchema);
-		constructor(kaos, workspace, capabilities, videoUploader) {
+		compressTelemetry;
+		constructor(kaos, workspace, capabilities, videoUploader, telemetry) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.capabilities = capabilities;
@@ -150463,6 +150620,10 @@ var init_read_media = __esmMin((() => {
 				throw skip;
 			}
 			this.description = buildDescription(capabilities);
+			this.compressTelemetry = telemetry === void 0 ? void 0 : {
+				client: telemetry,
+				source: "read_media"
+			};
 		}
 		resolveExecution(args) {
 			const path = resolvePathAccessPath(args.path, {
@@ -150528,7 +150689,10 @@ var init_read_media = __esmMin((() => {
 				let mediaPart;
 				let delivery;
 				if (fileType.kind === "image") if (args.region !== void 0) {
-					const outcome = await cropImageForModel(data, fileType.mimeType, args.region, { skipResize: args.full_resolution === true });
+					const outcome = await cropImageForModel(data, fileType.mimeType, args.region, {
+						skipResize: args.full_resolution === true,
+						telemetry: this.compressTelemetry
+					});
 					if (!outcome.ok) return {
 						isError: true,
 						output: `Cannot read region from "${args.path}": ${outcome.error}`
@@ -150547,7 +150711,7 @@ var init_read_media = __esmMin((() => {
 						region: outcome.region,
 						resized: outcome.resized
 					};
-					dimensions ??= {
+					dimensions = {
 						width: outcome.originalWidth,
 						height: outcome.originalHeight
 					};
@@ -150569,7 +150733,7 @@ var init_read_media = __esmMin((() => {
 						mimeType: fileType.mimeType
 					};
 				} else {
-					const compressed = await compressImageForModel(data, fileType.mimeType);
+					const compressed = await compressImageForModel(data, fileType.mimeType, { telemetry: this.compressTelemetry });
 					const base64 = Buffer.from(compressed.data).toString("base64");
 					mediaPart = {
 						type: "image_url",
@@ -150582,6 +150746,10 @@ var init_read_media = __esmMin((() => {
 						byteLength: compressed.finalByteLength,
 						mimeType: compressed.mimeType
 					};
+					if (compressed.changed) dimensions = {
+						width: compressed.originalWidth,
+						height: compressed.originalHeight
+					};
 				}
 				else if (this.videoUploader !== void 0) mediaPart = await this.videoUploader({
 					data,
@@ -151012,10 +151180,13 @@ var init_outcome_prompts = __esmMin((() => {}));
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.md?raw
 var update_goal_default;
 var init_update_goal$1 = __esmMin((() => {
-	update_goal_default = "Set the status of the current goal. This is how you resume, end, or yield an autonomous goal.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded.\n- `blocked` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. The goal stops but can be resumed later. Do not use `blocked` because the work is large, hard, slow, uncertain, partial, still needs validation, or needs more goal turns.\n- `paused` — set the goal aside for now (e.g. to hand control back to the user). It can be resumed later.\n\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call `complete` only when all required work is done, any stated validation has passed, and there is no useful next action. Before calling `complete`, check that every required part of the objective is done, completion criteria are satisfied, requested or expected validation passed or has been reported as impossible, and no known material task remains. Do not call `complete` after only producing a plan, summary, first pass, or partial result. If you call `blocked`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\n";
+	update_goal_default = "Set the status of the current goal. This is how you resume, complete, or block an autonomous goal.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is satisfied and any stated validation has passed. The goal ends and a completion summary is recorded. Before using this, verify the current state against the actual objective and every explicit requirement. Treat weak or indirect evidence as not complete. Do not use `complete` merely because a budget is nearly exhausted or you want to stop.\n- `blocked` — a genuine impasse prevents useful progress: an external condition, required user input, missing credentials or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory objective. For non-terminal blockers, do not use `blocked` the first time you hit the blocker. The same blocking condition must repeat for at least 3 consecutive goal turns before you call `blocked`, counting the original/user-triggered turn and automatic continuations. If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit. If the objective itself is impossible, unsafe, or contradictory, call `blocked` in the same turn instead of running more goal turns. Do not use `blocked` because the work is large, hard, slow, uncertain, incomplete, still needs validation, would benefit from clarification, or needs more goal turns. Once the 3-turn threshold is met and you cannot make meaningful progress without user input or an external-state change, call `blocked` instead of leaving the goal active.\n\nMost active goal turns should not call this tool. If you complete one useful slice of work and material work remains, end the turn normally without calling UpdateGoal; the runtime will prompt you to continue in the next goal turn. Call `complete` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not call `complete` after only producing a plan, summary, first pass, or partial result. Call `blocked` only after the blocked audit threshold is met. If you call `blocked`, you will be prompted to explain the blocker in your next message. Setting the status is the machine-readable signal; the completion summary or blocker explanation is yours to write in the following message.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts
+function isUpdateGoalStatus(status) {
+	return status === "active" || status === "complete" || status === "blocked";
+}
 var UpdateGoalToolInputSchema, UpdateGoalTool;
 var init_update_goal = __esmMin((() => {
 	init_zod$1();
@@ -151025,9 +151196,8 @@ var init_update_goal = __esmMin((() => {
 	UpdateGoalToolInputSchema = object({ status: _enum([
 		"active",
 		"complete",
-		"paused",
 		"blocked"
-	]).describe("The lifecycle status to set for the current goal.") }).strict();
+	]).describe("The lifecycle status to set for the current goal. Use `blocked` for impossible, unsafe, or contradictory objectives, or after the same non-terminal blocking condition repeats for at least 3 consecutive goal turns.") }).strict();
 	UpdateGoalTool = class {
 		agent;
 		name = "UpdateGoal";
@@ -151037,20 +151207,25 @@ var init_update_goal = __esmMin((() => {
 			this.agent = agent;
 		}
 		resolveExecution(args) {
+			if (!isUpdateGoalStatus(args.status)) return {
+				isError: true,
+				output: "Invalid goal status. Use `active`, `complete`, or `blocked`."
+			};
+			const status = args.status;
 			const goal = this.agent.goal;
 			const currentGoal = goal.getGoal().goal;
 			const goalIsActive = currentGoal?.status === "active";
 			return {
-				description: `Setting goal status: ${args.status}`,
-				stopBatchAfterThis: args.status !== "active" && goalIsActive,
+				description: `Setting goal status: ${status}`,
+				stopBatchAfterThis: status !== "active" && goalIsActive,
 				approvalRule: this.name,
 				execute: async () => {
-					if (args.status === "active") {
+					if (status === "active") {
 						if (currentGoal === null) return { output: "Goal not resumed: no current goal." };
 						await goal.resumeGoal({}, "model");
 						return { output: "Goal resumed." };
 					}
-					if (args.status === "complete") {
+					if (status === "complete") {
 						const completed = await goal.markComplete({}, "model");
 						if (completed === null) return { output: "Goal not completed: no active goal." };
 						return {
@@ -151058,7 +151233,7 @@ var init_update_goal = __esmMin((() => {
 							stopTurn: true
 						};
 					}
-					if (args.status === "blocked") {
+					if (status === "blocked") {
 						const blocked = await goal.markBlocked({}, "model");
 						if (blocked === null) return { output: "Goal not blocked: no active goal." };
 						return {
@@ -151066,11 +151241,9 @@ var init_update_goal = __esmMin((() => {
 							stopTurn: true
 						};
 					}
-					if (currentGoal === null) return { output: "Goal not paused: no current goal." };
-					await goal.pauseGoal({}, "model");
 					return {
-						output: "Goal paused.",
-						stopTurn: true
+						isError: true,
+						output: "Invalid goal status. Use `active`, `complete`, or `blocked`."
 					};
 				}
 			};
@@ -152107,7 +152280,10 @@ var init_tool$1 = __esmMin((() => {
 						return {
 							approvalRule: qualified,
 							execute: async (context) => {
-								return mcpResultToExecutableOutput(await client.callTool(tool.name, args ?? {}, context.signal), qualified, { originalsDir: this.agent.mediaOriginalsDir });
+								return mcpResultToExecutableOutput(await client.callTool(tool.name, args ?? {}, context.signal), qualified, {
+									originalsDir: this.agent.mediaOriginalsDir,
+									telemetry: this.agent.telemetry
+								});
 							}
 						};
 					}
@@ -152292,8 +152468,8 @@ var init_tool$1 = __esmMin((() => {
 		* defer-window pending set. History is the single source of truth, so the
 		* ledger survives resume (records replay rebuilds the history), keeps its
 		* state across undo (schema messages have `injection` origin and are not
-		* undone), and self-heals after compaction (the rebuild message re-carries
-		* the schemas).
+		* undone), and empties at compaction (schema messages are discarded with
+		* the folded history — the model re-selects what it still needs).
 		*/
 		loadedDynamicToolNames() {
 			const names = collectLoadedDynamicToolNames(this.agent.context.history);
@@ -152314,12 +152490,11 @@ var init_tool$1 = __esmMin((() => {
 			this.pendingLoadedDynamicTools.clear();
 		}
 		/**
-		* Compaction rebuilt the history: from here on the keep-all rebuild message
-		* (which may have trimmed or skipped schemas — budget guard, disconnected
-		* servers) is the sole truth about what is still loaded. A pending entry
-		* surviving past this boundary would report a schema the context no longer
-		* carries as loaded, and re-selecting it would wrongly answer
-		* "Already available" instead of injecting.
+		* Compaction rebuilt the history and discarded every loaded schema with it
+		* — the loaded set is empty from here on. A pending entry surviving past
+		* this boundary would report a schema the context no longer carries as
+		* loaded, and re-selecting it would wrongly answer "Already available"
+		* instead of injecting.
 		*/
 		onContextCompacted() {
 			this.pendingLoadedDynamicTools.clear();
@@ -152393,7 +152568,7 @@ var init_tool$1 = __esmMin((() => {
 				new GrepTool(kaos, workspace, this.agent.telemetry),
 				new GlobTool(kaos, workspace, this.agent.telemetry),
 				new BashTool(kaos, cwd, background, { allowBackground }),
-				(modelCapabilities.image_in || modelCapabilities.video_in) && new ReadMediaFileTool(kaos, workspace, modelCapabilities, videoUploader),
+				(modelCapabilities.image_in || modelCapabilities.video_in) && new ReadMediaFileTool(kaos, workspace, modelCapabilities, videoUploader, this.agent.telemetry),
 				new EnterPlanModeTool(this.agent),
 				new ExitPlanModeTool(this.agent),
 				new SelectToolsTool(this.agent),
@@ -153011,15 +153186,23 @@ var init_turn = __esmMin((() => {
 		"useful slice, if material work remains, end the turn normally without calling UpdateGoal so",
 		"the runtime can continue the goal in the next turn. Call UpdateGoal with `complete` only when",
 		"all required work is done, any stated validation has passed, and there is no useful next",
-		"action. Do not mark complete after only producing a plan, summary, first pass, or partial",
-		"result. Before calling `complete`, check that every required part of the objective is done,",
-		"completion criteria are satisfied, requested or expected validation passed or has been",
-		"reported as impossible, and no known material task remains. Call UpdateGoal with `blocked`",
-		"only for a genuine impasse: an external condition, required user input, missing credentials",
-		"or permissions, a persistent technical failure, or an impossible, unsafe, or contradictory",
-		"objective. Do not use `blocked` because the work is large, hard, slow, uncertain, partial,",
-		"still needs validation, or needs more goal turns. Do not ask the user for input unless a real",
-		"blocker prevents progress."
+		"action. Completion audit: before calling `complete`, verify the current state against the",
+		"actual objective and every explicit requirement. Treat weak or indirect evidence as not",
+		"complete. Do not mark complete after only producing a plan, summary, first pass, or partial",
+		"result. Do not mark complete merely because a budget is nearly exhausted or you want to stop.",
+		"Blocked audit: do not call UpdateGoal with `blocked` the first time you hit a blocker. Use",
+		"`blocked` only for a genuine impasse: an external condition, required user input, missing",
+		"credentials or permissions, or a persistent technical failure. For those non-terminal",
+		"blockers, the same blocking condition must repeat for at least 3 consecutive goal turns before",
+		"you call `blocked`, counting the original/user-triggered turn and automatic continuations.",
+		"If a previously blocked goal is resumed, treat the resumed run as a fresh blocked audit.",
+		"Exception: if the objective itself is impossible, unsafe, or contradictory, call UpdateGoal",
+		"with `blocked` in the same turn; do not run more goal turns just to satisfy the audit. Do not",
+		"use `blocked` because the work is large, hard, slow, uncertain, incomplete, still needs",
+		"validation, would benefit from clarification, or needs more goal turns. Once the 3-turn",
+		"threshold is met and you cannot make meaningful progress without user input or an",
+		"external-state change, call UpdateGoal with `blocked`; do not keep reporting the blocker while",
+		"leaving the goal active. Do not ask the user for input unless a real blocker prevents progress."
 	].join(" ");
 	TurnFlow = class {
 		agent;
@@ -153212,10 +153395,16 @@ var init_turn = __esmMin((() => {
 			try {
 				if (this.agent.goal.getGoal().goal?.status === "active") return await this.driveGoal(firstTurnId, input, origin, signal);
 				const end = await this.runOneTurn(firstTurnId, input, origin, signal, true);
-				if (this.agent.goal.getGoal().goal?.status === "active" && end.event.reason !== "cancelled" && end.event.reason !== "failed" && end.event.reason !== "filtered") return await this.driveGoal(this.allocateTurnId(), [{
-					type: "text",
-					text: GOAL_CONTINUATION_PROMPT
-				}], GOAL_CONTINUATION_ORIGIN, signal);
+				if (this.agent.goal.getGoal().goal?.status === "active" && end.event.reason !== "cancelled" && end.event.reason !== "failed" && end.event.reason !== "filtered") {
+					if ((await this.agent.goal.incrementTurn())?.budget.overBudget === true) {
+						await this.agent.goal.markBlocked({ reason: "A configured budget was reached" });
+						return end;
+					}
+					return await this.driveGoal(this.allocateTurnId(), [{
+						type: "text",
+						text: GOAL_CONTINUATION_PROMPT
+					}], GOAL_CONTINUATION_ORIGIN, signal);
+				}
 				return end;
 			} finally {
 				if (ownsActiveTurn()) this.activeTurn = null;
@@ -153225,8 +153414,8 @@ var init_turn = __esmMin((() => {
 		* Drives an active goal as a sequence of ordinary turns — the autonomous
 		* equivalent of the user repeatedly typing "continue". Each iteration runs one
 		* full turn, then reads the goal status the model set via `UpdateGoal`:
-		* `complete` (the record is cleared) / `blocked` / `paused` stop the loop;
-		* `active` (the model didn't decide) re-injects the goal reminder and runs the
+		* `complete` (the record is cleared) / `blocked` stop the loop; `active`
+		* (the model didn't decide) re-injects the goal reminder and runs the
 		* next continuation turn. Aborted or failed turns pause the goal. Goal-state
 		* blockers, such as explicit `UpdateGoal('blocked')`, prompt-hook blocks, and
 		* budget limits, block it (all resumable). Returns the final turn's result.
@@ -205862,13 +206051,16 @@ var init_provider_manager = __esmMin((() => {
 					return await request(auth);
 				} catch (error) {
 					if (!(error instanceof APIStatusError) || error.statusCode !== 401) throw error;
-					if (refreshed) throw new KimiError(ErrorCodes.AUTH_LOGIN_REQUIRED, "OAuth provider credentials were rejected. Send /login to login.", {
-						cause: error,
-						details: {
-							statusCode: error.statusCode,
-							requestId: error.requestId
-						}
-					});
+					if (refreshed) {
+						const reason = error.message.replaceAll("\r", "");
+						throw new KimiError(ErrorCodes.PROVIDER_AUTH_ERROR, reason.length > 0 ? reason : "OAuth provider credentials were rejected.", {
+							cause: error,
+							details: {
+								statusCode: error.statusCode,
+								requestId: error.requestId
+							}
+						});
+					}
 					auth = await fetchAuth(true);
 				}
 			};
@@ -209492,6 +209684,7 @@ var _CoreProcessService, CoreProcessService;
 var init_coreProcessService = __esmMin((() => {
 	init_rpc();
 	init_di();
+	init_telemetry();
 	init_src$2();
 	init_managedAuth();
 	init_coreProcessClient();
@@ -209513,6 +209706,7 @@ var init_coreProcessService = __esmMin((() => {
 		*/
 		rpc;
 		kimiRequestHeaders;
+		telemetry;
 		/**
 		* The in-process `KimiCore` instance. Kept private so daemon-side code can't
 		* grab it and bypass the peer-service indirection.
@@ -209535,6 +209729,7 @@ var init_coreProcessService = __esmMin((() => {
 			const [coreRpc, sdkRpc] = createRPC();
 			const resolveOAuthTokenProvider = options.resolveOAuthTokenProvider ?? _CoreProcessService._defaultOAuthTokenResolver(env.homeDir, env.configPath);
 			this.kimiRequestHeaders = options.kimiRequestHeaders ?? _CoreProcessService._defaultKimiRequestHeaders(env.homeDir, options.identity);
+			this.telemetry = options.telemetry ?? noopTelemetryClient;
 			const appVersion = options.appVersion ?? options.identity?.version;
 			this._core = new KimiCore(coreRpc, {
 				...options,
@@ -218643,8 +218838,12 @@ function applyCatalogProvider(config, options) {
 init_src();
 //#endregion
 //#region ../../packages/telemetry/src/types.ts
+const MAX_TELEMETRY_NUMBER_MAGNITUDE = Number.MAX_SAFE_INTEGER;
 function isTelemetryPrimitive(value) {
-	return value === null || value === void 0 || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+	return value === null || value === void 0 || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && isTelemetryNumber(value);
+}
+function isTelemetryNumber(value) {
+	return Number.isFinite(value) && Math.abs(value) <= MAX_TELEMETRY_NUMBER_MAGNITUDE;
 }
 //#endregion
 //#region ../../packages/telemetry/src/client.ts
@@ -218928,7 +219127,7 @@ function setPrimitive(target, key, value) {
 }
 //#endregion
 //#region ../../packages/telemetry/src/systemMetrics.ts
-const DEFAULT_INTERVAL_MS = 3e4;
+const DEFAULT_INTERVAL_MS = 3e5;
 const DEFAULT_WARMUP_SAMPLE_MS = 1500;
 const SYSTEM_METRICS_EVENT = "system_metrics";
 var SystemMetricsCollector = class {
@@ -218984,7 +219183,7 @@ var SystemMetricsCollector = class {
 		this.previousHrtime = now;
 		const mem = process.memoryUsage();
 		const constrainedMemory = getConstrainedMemoryBytes();
-		this.client.track(SYSTEM_METRICS_EVENT, {
+		const properties = {
 			process_started_at: this.processStartedAtSeconds,
 			process_uptime_ms: Math.round(process.uptime() * 1e3),
 			rss_bytes: mem.rss,
@@ -218992,7 +219191,6 @@ var SystemMetricsCollector = class {
 			heap_total_bytes: mem.heapTotal,
 			external_bytes: mem.external,
 			array_buffers_bytes: mem.arrayBuffers,
-			constrained_memory_bytes: constrainedMemory,
 			cpu_user_us: cpu.user,
 			cpu_system_us: cpu.system,
 			cpu_elapsed_us: Math.round(elapsedUs),
@@ -219000,13 +219198,15 @@ var SystemMetricsCollector = class {
 			free_mem_bytes: freemem(),
 			total_mem_bytes: totalmem(),
 			cpu_count: cpus().length
-		});
+		};
+		if (constrainedMemory !== void 0) properties["constrained_memory_bytes"] = constrainedMemory;
+		this.client.track(SYSTEM_METRICS_EVENT, properties);
 	}
 };
 function getConstrainedMemoryBytes() {
 	if (typeof process.constrainedMemory !== "function") return void 0;
 	const value = process.constrainedMemory();
-	return Number.isFinite(value) ? value : void 0;
+	return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
 const SERVER_EVENT_PREFIX = "kfc_";
 const USER_ID_PREFIX = "kfc_device_id_";
@@ -238571,7 +238771,10 @@ async function compressPromptImageParts(parts, options = {}) {
 		if (part.type === "image_url") {
 			const parsed = parseImageDataUrl(part.imageUrl.url);
 			if (parsed !== null) {
-				const result = await compressBase64ForModel(parsed.base64, parsed.mimeType);
+				const result = await compressBase64ForModel(parsed.base64, parsed.mimeType, { telemetry: options.telemetry === void 0 ? void 0 : {
+					client: options.telemetry,
+					source: "acp_prompt"
+				} });
 				if (result.changed) {
 					const originalPath = await persistOriginalImage(Buffer.from(parsed.base64, "base64"), parsed.mimeType, options.originalsDir === void 0 ? {} : { dir: options.originalsDir });
 					out.push({
@@ -240372,7 +240575,11 @@ var AcpSession = class {
 		let parts;
 		try {
 			const sessionDir = this.session.summary?.sessionDir;
-			parts = await compressPromptImageParts(acpBlocksToPromptParts(blocks), { originalsDir: sessionDir === void 0 ? void 0 : sessionMediaOriginalsDir(sessionDir) });
+			const track = this.track;
+			parts = await compressPromptImageParts(acpBlocksToPromptParts(blocks), {
+				originalsDir: sessionDir === void 0 ? void 0 : sessionMediaOriginalsDir(sessionDir),
+				telemetry: track === void 0 ? void 0 : { track: (event, properties) => track(event, properties === void 0 ? void 0 : { ...properties }) }
+			});
 		} finally {
 			this.pendingPromptAborts.delete(pending);
 		}
@@ -276137,10 +276344,13 @@ function registerPromptsRoutes(app, ix) {
 				const promptService = a.get(IPromptService);
 				const fileStore = a.get(IFileStore);
 				const core = a.get(ICoreProcessService);
-				const resolved = await resolvePromptMediaFiles(body, fileStore, join(a.get(IEnvironmentService).homeDir, "cache"), { resolveOriginalsDir: async () => {
-					const sessionDir = (await core.rpc.listSessions({ sessionId: session_id }))[0]?.sessionDir;
-					return sessionDir === void 0 ? void 0 : sessionMediaOriginalsDir(sessionDir);
-				} });
+				const resolved = await resolvePromptMediaFiles(body, fileStore, join(a.get(IEnvironmentService).homeDir, "cache"), {
+					telemetry: core.telemetry === void 0 ? void 0 : withTelemetryContext$1(core.telemetry, { sessionId: session_id }),
+					resolveOriginalsDir: async () => {
+						const sessionDir = (await core.rpc.listSessions({ sessionId: session_id }))[0]?.sessionDir;
+						return sessionDir === void 0 ? void 0 : sessionMediaOriginalsDir(sessionDir);
+					}
+				});
 				return promptService.submit(session_id, resolved);
 			});
 			reply.send(okEnvelope(result, req.id));
@@ -276229,10 +276439,14 @@ async function resolvePromptMediaFiles(body, store, cacheDir, options = {}) {
 		}
 		return originalsDir;
 	};
+	const telemetryFor = (source) => options.telemetry === void 0 ? void 0 : {
+		client: options.telemetry,
+		source
+	};
 	const content = [];
 	for (const part of body.content) {
 		if (part.type === "image" && part.source.kind === "base64") {
-			const compressed = await compressBase64ForModel(part.source.data, part.source.media_type);
+			const compressed = await compressBase64ForModel(part.source.data, part.source.media_type, { telemetry: telemetryFor("prompt_inline") });
 			if (compressed.changed) {
 				const dir = await resolveOriginalsDir();
 				const originalPath = await persistOriginalImage(Buffer.from(part.source.data, "base64"), part.source.media_type, dir === void 0 ? {} : { dir });
@@ -276285,7 +276499,7 @@ async function resolvePromptMediaFiles(body, store, cacheDir, options = {}) {
 		let mediaType = file.meta.media_type;
 		let bytes = data;
 		if (part.type === "image") {
-			const compressed = await compressImageForModel(data, mediaType);
+			const compressed = await compressImageForModel(data, mediaType, { telemetry: telemetryFor("prompt_file") });
 			if (compressed.changed) content.push({
 				type: "text",
 				text: buildImageCompressionCaption({
@@ -368352,7 +368566,11 @@ init_dist$7();
 *
 * Used to bound shutdown so a wedged cleanup step can't keep a completed
 * headless run alive, without silently swallowing a cleanup that fails fast. The
-* timer is unref'd so it never keeps the loop alive on its own.
+* timer stays ref'd so a cleanup step that suspends on an unref'd handle (e.g.
+* telemetry's retry backoff when the network is blocked) can't drain the event
+* loop and exit 0 before the rejection propagates — the timer keeps the loop
+* alive until it fires, then gives the rejection a chance to surface. A wedged
+* cleanup is still bounded by `timeoutMs`, so this can't hang the run forever.
 */
 async function raceWithTimeout(promise, timeoutMs) {
 	let timedOut = false;
@@ -368366,7 +368584,6 @@ async function raceWithTimeout(promise, timeoutMs) {
 			timedOut = true;
 			resolve();
 		}, timeoutMs);
-		timer.unref?.();
 	});
 	try {
 		await Promise.race([guarded, timedOutSignal]);
@@ -374112,15 +374329,18 @@ var EditorKeyboardController = class {
 		}
 		const meta = parseImageMeta(media.bytes);
 		if (meta === null) return false;
-		const compressed = await compressImageForModel(media.bytes, meta.mime);
+		const compressed = await compressImageForModel(media.bytes, meta.mime, { telemetry: {
+			client: { track: (event, properties) => this.host.track(event, properties === void 0 ? void 0 : { ...properties }) },
+			source: "tui_paste"
+		} });
 		const sessionDir = this.host.session?.summary?.sessionDir;
 		const attachment = compressed.changed ? this.imageStore.addImage(compressed.data, compressed.mimeType, compressed.width, compressed.height, {
 			path: await persistOriginalImage(media.bytes, meta.mime, sessionDir === void 0 ? {} : { dir: sessionMediaOriginalsDir(sessionDir) }),
-			width: meta.width,
-			height: meta.height,
+			width: compressed.originalWidth,
+			height: compressed.originalHeight,
 			byteLength: media.bytes.length,
 			mime: meta.mime
-		}) : this.imageStore.addImage(media.bytes, meta.mime, meta.width, meta.height);
+		}) : this.imageStore.addImage(media.bytes, meta.mime, compressed.width || meta.width, compressed.height || meta.height);
 		this.host.state.editor.insertTextAtCursor?.(`${attachment.placeholder} `);
 		this.host.state.ui.requestRender();
 		this.host.track("shortcut_paste", { kind: "image" });
@@ -383290,6 +383510,7 @@ function main() {
 		handleMainCommand(opts, version).then(async (outcome) => {
 			if (outcome.headlessCompleted) await finalizeHeadlessRun(process, [process.stdout, process.stderr], () => Number(process.exitCode) || 0);
 		}).catch(async (error) => {
+			process.exitCode = 1;
 			const operation = opts.prompt !== void 0 ? "run prompt" : "start shell";
 			await logStartupFailure(operation, error);
 			process.stderr.write(formatStartupError(error, { operation }));