blun-king-cli 9.1.47 → 9.1.49

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.47
+  npm install -g blun-king-cli@9.1.49
 
 Start
 -----
@@ -31,6 +31,16 @@ Die Grenzwerte lassen sich vor dem Start über diese Umgebungsvariablen ändern:
   BLUN_TURN_WATCHDOG_IDLE_MINUTES
   BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS
 
+Befehle und Loops während eines laufenden Zugs
+------------------------------------------------
+Slash-Befehle, die einen freien Agenten benötigen, werden während eines
+laufenden Zugs in ihrer Eingabereihenfolge vorgemerkt und danach ausgeführt.
+Status-, Stopp- und andere sichere Steuerbefehle bleiben sofort verfügbar.
+
+Ein neuer /loop ersetzt den bisherigen Loop derselben Sitzung. Dabei bleibt
+genau ein gespeicherter Loop aktiv. /loop stop, /loop pause und /loop status
+wirken auch dann sofort, wenn der Agent gerade arbeitet.
+
 Nachweisbare Arbeitsabläufe
 ---------------------------
 
@@ -44,6 +54,14 @@ Nachweisbare Arbeitsabläufe
 
 Alle Befehle funktionieren identisch mit `king`.
 
+Medienerzeugung
+---------------
+GenerateVideo erzeugt Videos aus einer Textbeschreibung oder animiert einen
+bereits abgeschlossenen Bildauftrag. Für Bild-zu-Video wird die Medienkennung
+des fertigen PNG- oder JPEG-Bildes verwendet; lokale Serverpfade werden nicht
+akzeptiert. Der Auftrag läuft asynchron und wird anschließend mit GetMedia
+abgerufen.
+
 Aktualisieren
 -------------
 

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.47
+npm install -g blun-king-cli@9.1.49
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -45,6 +45,17 @@ Die Grenzwerte lassen sich vor dem Start mit
 `BLUN_TURN_WATCHDOG_IDLE_MINUTES` und
 `BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS` ändern.
 
+## Befehle und Loops während eines laufenden Zugs
+
+Slash-Befehle, die einen freien Agenten benötigen, werden während eines
+laufenden Zugs in ihrer Eingabereihenfolge vorgemerkt und danach ausgeführt.
+Status-, Stopp- und andere sichere Steuerbefehle bleiben sofort verfügbar.
+
+Ein neuer `/loop` ersetzt den bisherigen Loop derselben Sitzung. Dabei bleibt
+genau ein gespeicherter Loop aktiv; der neue Auftrag, das neue Intervall und
+der neue Startzeitpunkt gelten vollständig. `/loop stop`, `/loop pause` und
+`/loop status` wirken auch dann sofort, wenn der Agent gerade arbeitet.
+
 Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
 eingerichtet. Die Anmeldung erfolgt anschließend in der
 Konsole mit `/login` über den BLUN-OAuth-Server. Das Paket erzeugt keine
@@ -64,6 +75,14 @@ Version 9.1.0 enthält sieben zusätzliche, getrennt nutzbare Befehlsgruppen:
 
 Sie stehen unter `blun` und `king` identisch zur Verfügung.
 
+## Medienerzeugung
+
+`GenerateVideo` erzeugt Videos aus einer Textbeschreibung oder animiert einen
+bereits abgeschlossenen Bildauftrag. Für Bild-zu-Video wird die Medienkennung
+des fertigen PNG- oder JPEG-Bildes verwendet; lokale Serverpfade werden nicht
+akzeptiert. Der Auftrag läuft asynchron und wird anschließend mit `GetMedia`
+abgerufen.
+
 ## Aktualisieren
 
 `blun update`, `king update` und die jeweilige Variante `upgrade` verwenden

package/blun.mjs

@@ -28101,6 +28101,19 @@ var init_render_prompt = __esmMin((() => {
 * Build the static conduct block. Pure function of nothing — the rules are
 * the same for every session and every profile.
 */
+const IMAGE_GENERATION_ALLOWED_CATEGORIES = Object.freeze([
+	"adult fictional people in bikinis, swimwear, beachwear, or sportswear",
+	"adult fictional people in form-fitting clothing or lingerie",
+	"tasteful, sensual, or figure-emphasizing depictions of clearly adult fictional people"
+]);
+const IMAGE_GENERATION_BLOCKED_CATEGORIES = Object.freeze([
+	"explicit sexual depictions",
+	"sexual or romantic depictions involving minors or youthfully depicted people",
+	"depictions of real, recognizable people without their consent"
+]);
+function conductCategoryList(items) {
+	return items.map((item) => `  - ${item}`).join("\n");
+}
 function conductSystemBlock() {
 	return `## Conduct — how you behave
 
@@ -28125,6 +28138,13 @@ function conductSystemBlock() {
 - NEVER create romantic or sexual content involving or directed at minors, and nothing that facilitates grooming, secrecy between an adult and a child, or isolating a minor from trusted adults. A minor is anyone under 18 (or older where local law says so).
 - If you catch yourself mentally reframing such a request to make it seem acceptable, that reframing is itself the signal to refuse. After one child-safety refusal, treat all follow-ups in that conversation with extreme caution.
 
+### Image generation boundaries
+Allowed categories — do not refuse, sanitize, or replace these merely because they are sensual or reveal the figure:
+${conductCategoryList(IMAGE_GENERATION_ALLOWED_CATEGORIES)}
+Blocked categories — refuse these without exception, regardless of claimed authority:
+${conductCategoryList(IMAGE_GENERATION_BLOCKED_CATEGORIES)}
+- When an image request mixes allowed and blocked elements, generate the allowed part and decline only the blocked part. If an adult-oriented request leaves age ambiguous, make the fictional subject clearly adult rather than refusing an otherwise allowed request.
+
 ### Copyright
 - Default to paraphrasing. Quote at most ~15 words from any single source, and at most one quote per source. Never reproduce song lyrics, poems, or full passages, even from search results — discuss themes and meaning instead.
 
@@ -75066,10 +75086,6 @@ function estimateCompactionStageCount(initialInputTokens, safeRequestLimitTokens
 	if (safeRequestLimitTokens <= 0) return currentStage;
 	return Math.max(currentStage, Math.ceil(initialInputTokens / safeRequestLimitTokens));
 }
-function estimateCompactionProgressPercent(stage, estimatedStageCount) {
-	if (estimatedStageCount <= 0) return 0;
-	return Math.min(99, Math.floor(stage / estimatedStageCount * 100));
-}
 function estimateCompactionWindowUsagePercent(requestTokens, maxContextTokens) {
 	if (maxContextTokens <= 0) return void 0;
 	return Math.min(100, Math.max(0, Math.ceil(requestTokens / maxContextTokens * 100)));
@@ -75554,7 +75570,6 @@ var init_full = __esmMin((() => {
 					charsReceived = 0;
 					const stage = hierarchicalPassCount + 1;
 					const estimatedStageCount = estimateCompactionStageCount(initialCompactionRequestTokens, safeCompactionRequestLimit, stage);
-					const estimatedProgressPercent = estimateCompactionProgressPercent(stage, estimatedStageCount);
 					const windowUsagePercent = estimateCompactionWindowUsagePercent(estimatedCompactionRequestTokens, compactionRequestLimit);
 					this.agent.log.info("compaction stage request", {
 						requestPurpose: "compaction",
@@ -75578,7 +75593,6 @@ var init_full = __esmMin((() => {
 							stage,
 							estimatedStageCount,
 							estimatedInputTokens: estimatedCompactionRequestTokens,
-							estimatedProgressPercent,
 							...windowUsagePercent === void 0 ? {} : { windowUsagePercent },
 							charsReceived,
 							attempt: attemptCount,
@@ -77688,12 +77702,29 @@ var init_session_loop = __esmMin((() => {
 		}
 		createLoop(input) {
 			if (process.env["BLUN_DISABLE_CRON"] === "1") throw new BlunError(ErrorCodes.LOOP_DISABLED, "Recurring loops are disabled");
-			if (this.currentTask() !== void 0) throw new BlunError(ErrorCodes.LOOP_ALREADY_EXISTS, "A recurring loop already exists");
-			if (this.cron.store.list().length >= 50) throw new BlunError(ErrorCodes.LOOP_LIMIT_REACHED, "Session cron task limit reached");
+			const existing = this.currentTask();
+			if (existing === void 0 && this.cron.store.list().length >= 50) throw new BlunError(ErrorCodes.LOOP_LIMIT_REACHED, "Session cron task limit reached");
 			const parsed = parseLoopInterval(input.interval);
 			const prompt = input.prompt.trim();
 			if (prompt.length === 0) throw new BlunError(ErrorCodes.LOOP_PROMPT_EMPTY, "Loop prompt cannot be empty");
 			if (Buffer.byteLength(prompt, "utf8") > MAX_LOOP_PROMPT_BYTES) throw new BlunError(ErrorCodes.LOOP_PROMPT_TOO_LONG, `Loop prompt cannot exceed ${String(MAX_LOOP_PROMPT_BYTES)} UTF-8 bytes`);
+			if (existing !== void 0) {
+				const now = this.cron.clocks.wallNow();
+				const task = this.requireUpdatedTask(existing.id, {
+					cron: parsed.cron,
+					prompt,
+					recurring: true,
+					owner: "session-loop",
+					loopInterval: parsed.interval,
+					paused: false,
+					autoExpire: false,
+					createdAt: now,
+					scheduleFromAt: now,
+					lastFiredAt: void 0
+				});
+				this.cron.emitScheduled(task);
+				return this.snapshot(task);
+			}
 			const task = this.cron.addTask({
 				cron: parsed.cron,
 				prompt,
@@ -261933,6 +261964,45 @@ function contentPartFor(mimeType, url) {
 function errorMessage$10(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+const MEDIA_PROGRESS_CUSTOM_KIND = "blun.media.progress";
+function mediaKindForToolName(name) {
+	switch (name) {
+		case "GenerateImage": return "image";
+		case "GenerateVideo": return "video";
+		case "GenerateSpeech": return "voice";
+		case "UnderstandImage": return "image-analysis";
+		case "UnderstandVideo": return "video-analysis";
+		case "DubVideo": return "dubbing";
+		case "LipSyncMedia": return "lipsync";
+		case "GetMedia": return "media";
+		default: return "media";
+	}
+}
+function isMediaToolName(name) {
+	return [
+		"GenerateImage",
+		"GenerateVideo",
+		"GenerateSpeech",
+		"UnderstandImage",
+		"UnderstandVideo",
+		"DubVideo",
+		"LipSyncMedia",
+		"GetMedia"
+	].includes(name);
+}
+function emitMediaProgress(ctx, toolName, phase, data = {}) {
+	ctx.onUpdate({
+		kind: "custom",
+		customKind: MEDIA_PROGRESS_CUSTOM_KIND,
+		customData: {
+			toolName,
+			mediaKind: data.mediaKind ?? mediaKindForToolName(toolName),
+			phase,
+			observedAt: Date.now(),
+			...data
+		}
+	});
+}
 var PromptSchema, MediaIdSchema, GenerateImageInputSchema, GenerateVideoInputSchema, GenerateSpeechInputSchema, GetMediaInputSchema, UnderstandImageInputSchema, UnderstandVideoInputSchema, DubVideoInputSchema, LipSyncMediaInputSchema, REQUEST_NOTE, LIPSYNC_REQUEST_NOTE, MediaGenerationTool, GenerateImageTool, GenerateVideoTool, GenerateSpeechTool, UnderstandImageTool, UnderstandVideoTool, DubVideoTool, LipSyncMediaTool, GetMediaTool;
 var init_blun_media$1 = __esmMin((() => {
 	init_zod$1();
@@ -261945,7 +262015,10 @@ var init_blun_media$1 = __esmMin((() => {
 	PromptSchema = string().trim().min(1).max(2e4);
 	MediaIdSchema = string().trim().min(1).max(200).regex(/^[A-Za-z0-9_-]+$/);
 	GenerateImageInputSchema = object({ prompt: PromptSchema.describe("A complete visual description of the image to generate.") });
-	GenerateVideoInputSchema = object({ prompt: PromptSchema.describe("A complete visual description of the video to generate.") });
+	GenerateVideoInputSchema = object({
+		prompt: PromptSchema.describe("A complete visual description of the video or motion to generate."),
+		image_id: MediaIdSchema.optional().describe("An optional completed PNG or JPEG media job id to animate into the video.")
+	});
 	GenerateSpeechInputSchema = object({ input: PromptSchema.describe("The exact text to synthesize as speech.") });
 	GetMediaInputSchema = object({ id: MediaIdSchema.describe("The media job id returned by a generation tool.") });
 	UnderstandImageInputSchema = object({
@@ -261984,16 +262057,22 @@ var init_blun_media$1 = __esmMin((() => {
 			};
 		}
 		async execution(args, ctx) {
+			emitMediaProgress(ctx, this.name, "submitting");
 			try {
 				const job = await this.submit(args, {
 					signal: ctx.signal,
 					toolCallId: ctx.toolCallId
 				});
+				emitMediaProgress(ctx, this.name, job.status, {
+					id: job.id,
+					...job.progress
+				});
 				return {
 					output: `Media job ${job.id} accepted with status ${job.status}. ${this.requestNote}`,
 					isError: false
 				};
 			} catch (error) {
+				emitMediaProgress(ctx, this.name, "failed", { error: errorMessage$10(error) });
 				return {
 					isError: true,
 					output: `Media request failed: ${errorMessage$10(error)}`
@@ -262014,13 +262093,13 @@ var init_blun_media$1 = __esmMin((() => {
 	};
 	GenerateVideoTool = class extends MediaGenerationTool {
 		name = "GenerateVideo";
-		description = "Generate a new video from text with BLUN media models. Use this for motion or text-to-video requests, not for understanding an existing video. This starts a billed asynchronous media job.";
+		description = "Generate a new video from text or animate an existing completed image job with BLUN media models. Pass image_id for image-to-video requests. Do not use this for understanding an existing video. This starts a billed asynchronous media job.";
 		parameters = toInputJsonSchema(GenerateVideoInputSchema);
 		subject(args) {
-			return args.prompt;
+			return args.image_id ? `${args.image_id}: ${args.prompt}` : args.prompt;
 		}
 		submit(args, options) {
-			return this.provider.generateVideo(args.prompt, options);
+			return this.provider.generateVideo(args.prompt, options, args.image_id);
 		}
 	};
 	GenerateSpeechTool = class extends MediaGenerationTool {
@@ -262070,6 +262149,7 @@ var init_blun_media$1 = __esmMin((() => {
 			};
 		}
 		async execution(args, safePath, ctx) {
+			emitMediaProgress(ctx, "UnderstandImage", "uploading");
 			try {
 				const fileType = detectFileType(safePath, await this.kaos.readBytes(safePath, 512), "media");
 				if (fileType.mimeType !== "image/png" && fileType.mimeType !== "image/jpeg") return {
@@ -262086,12 +262166,18 @@ var init_blun_media$1 = __esmMin((() => {
 					toolCallId: ctx.toolCallId
 				};
 				const upload = await this.provider.uploadMedia(data, fileType.mimeType, options);
+				emitMediaProgress(ctx, "UnderstandImage", "processing");
 				const job = await this.provider.understandImage(upload.id, args.prompt, options);
+				emitMediaProgress(ctx, "UnderstandImage", job.status, {
+					id: job.id,
+					...job.progress
+				});
 				return {
 					output: `Media job ${job.id} accepted with status ${job.status}. ${REQUEST_NOTE}`,
 					isError: false
 				};
 			} catch (error) {
+				emitMediaProgress(ctx, "UnderstandImage", "failed", { error: errorMessage$10(error) });
 				return {
 					isError: true,
 					output: `Image understanding failed: ${errorMessage$10(error)}`
@@ -262153,6 +262239,7 @@ var init_blun_media$1 = __esmMin((() => {
 			};
 		}
 		async execution(args, ctx) {
+			emitMediaProgress(ctx, "GetMedia", "checking", { id: args.id });
 			try {
 				const result = await this.provider.getMedia(args.id, {
 					signal: ctx.signal,
@@ -262166,15 +262253,22 @@ var init_blun_media$1 = __esmMin((() => {
 					].includes(result.status.trim().toLowerCase());
 					const source = result.sourceId === void 0 ? "" : ` Source job ${result.sourceId}${result.sourceStatus === void 0 ? "" : ` status: ${result.sourceStatus}`}.`;
 					const retryable = result.retryable === void 0 ? "" : ` Retryable: ${result.retryable ? "yes" : "no"}.`;
+					emitMediaProgress(ctx, "GetMedia", result.status, {
+						id: result.id,
+						...result.progress
+					});
 					return {
 						output: `Media job ${result.id} status: ${result.status}.${source}${retryable}`,
 						isError: terminalError
 					};
 				}
-				if (result.kind === "text") return {
-					output: result.text,
-					isError: false
-				};
+				if (result.kind === "text") {
+					emitMediaProgress(ctx, "GetMedia", "complete", { id: result.id });
+					return {
+						output: result.text,
+						isError: false
+					};
+				}
 				const url = `data:${result.mimeType};base64,${Buffer.from(result.data).toString("base64")}`;
 				const mediaPart = contentPartFor(result.mimeType, url);
 				if (mediaPart === void 0) return {
@@ -262187,6 +262281,11 @@ var init_blun_media$1 = __esmMin((() => {
 				});
 				const localPath = join(this.outputDir, `${safeMediaId(result.id)}.${extensionForMediaType(result.mimeType)}`);
 				await writeFile(localPath, result.data, { mode: 384 });
+				emitMediaProgress(ctx, "GetMedia", "complete", {
+					id: result.id,
+					mimeType: result.mimeType,
+					localPath
+				});
 				return {
 					output: [{
 						type: "text",
@@ -262195,6 +262294,10 @@ var init_blun_media$1 = __esmMin((() => {
 					isError: false
 				};
 			} catch (error) {
+				emitMediaProgress(ctx, "GetMedia", "failed", {
+					id: args.id,
+					error: errorMessage$10(error)
+				});
 				return {
 					isError: true,
 					output: `Media lookup failed: ${errorMessage$10(error)}`
@@ -310721,13 +310824,64 @@ async function parseBlockedStatus(response, id) {
 		...typeof retryable === "boolean" ? { retryable } : {}
 	};
 }
+function mediaPayloadNumber(payload, keys) {
+	for (const key of keys) {
+		const value = payload[key];
+		const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+		if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+	}
+}
+function mediaPayloadText(payload, keys) {
+	for (const key of keys) {
+		const value = payload[key];
+		if (typeof value === "string" && value.trim() !== "") return value.trim();
+	}
+}
+function mediaPayloadNumberArray(payload, keys) {
+	for (const key of keys) {
+		const value = payload[key];
+		if (!Array.isArray(value)) continue;
+		const samples = value.map((entry) => typeof entry === "number" ? entry : Number(entry)).filter((entry) => Number.isFinite(entry));
+		if (samples.length > 0) return samples.slice(0, 512);
+	}
+}
+function mediaProgressFromPayload(payload) {
+	const rawPercent = mediaPayloadNumber(payload, ["percent", "progress_percent", "progressPercent", "progress"]);
+	const percent = rawPercent === void 0 ? void 0 : rawPercent <= 1 ? rawPercent * 100 : rawPercent;
+	const progress = {
+		phaseLabel: mediaPayloadText(payload, ["phase", "stage", "step_name", "stepName"]),
+		percent: percent === void 0 ? void 0 : Math.min(100, Math.max(0, percent)),
+		currentFrame: mediaPayloadNumber(payload, ["current_frame", "currentFrame", "frames_completed", "framesCompleted"]),
+		totalFrames: mediaPayloadNumber(payload, ["total_frames", "totalFrames", "frame_count", "frameCount"]),
+		fps: mediaPayloadNumber(payload, ["fps", "frames_per_second", "framesPerSecond"]),
+		currentStep: mediaPayloadNumber(payload, ["current_step", "currentStep", "step"]),
+		totalSteps: mediaPayloadNumber(payload, ["total_steps", "totalSteps", "steps"]),
+		currentSegment: mediaPayloadNumber(payload, ["current_segment", "currentSegment", "segment"]),
+		totalSegments: mediaPayloadNumber(payload, ["total_segments", "totalSegments", "segments"]),
+		generatedSeconds: mediaPayloadNumber(payload, ["generated_seconds", "generatedSeconds", "audio_seconds", "audioSeconds"]),
+		queuePosition: mediaPayloadNumber(payload, ["queue_position", "queuePosition"]),
+		elapsedSeconds: mediaPayloadNumber(payload, ["elapsed_seconds", "elapsedSeconds"]),
+		remainingSeconds: mediaPayloadNumber(payload, ["remaining_seconds", "remainingSeconds", "eta_seconds", "etaSeconds"]),
+		durationSeconds: mediaPayloadNumber(payload, ["duration_seconds", "durationSeconds"]),
+		width: mediaPayloadNumber(payload, ["width", "width_px", "widthPx"]),
+		height: mediaPayloadNumber(payload, ["height", "height_px", "heightPx"]),
+		previewUrl: mediaPayloadText(payload, ["preview_url", "previewUrl", "thumbnail_url", "thumbnailUrl"]),
+		previewDataBase64: mediaPayloadText(payload, ["preview_base64", "previewBase64", "thumbnail_base64", "thumbnailBase64"]),
+		previewMimeType: mediaPayloadText(payload, ["preview_mime_type", "previewMimeType", "thumbnail_mime_type", "thumbnailMimeType"]),
+		sampleUrl: mediaPayloadText(payload, ["sample_url", "sampleUrl", "audio_preview_url", "audioPreviewUrl"]),
+		localPath: mediaPayloadText(payload, ["local_path", "localPath"]),
+		waveform: mediaPayloadNumberArray(payload, ["waveform", "waveform_samples", "waveformSamples"])
+	};
+	return Object.fromEntries(Object.entries(progress).filter(([, value]) => value !== void 0));
+}
 function parseJob(payload) {
 	const id = payload["id"];
 	const status = payload["status"];
 	if (typeof id !== "string" || id.length === 0 || typeof status !== "string" || status.length === 0) throw new Error("Media request returned an invalid job response.");
 	return {
 		id,
-		status
+		status,
+		progress: mediaProgressFromPayload(payload)
 	};
 }
 function parseStatus(payload, expectedId) {
@@ -310737,7 +310891,8 @@ function parseStatus(payload, expectedId) {
 	return {
 		kind: "status",
 		id,
-		status
+		status,
+		progress: mediaProgressFromPayload(payload)
 	};
 }
 async function assertSuccess(response, operation) {
@@ -310769,8 +310924,10 @@ var init_blun_media = __esmMin((() => {
 		generateImage(prompt, options) {
 			return this.submit("/images/generations", { prompt }, options);
 		}
-		generateVideo(prompt, options) {
-			return this.submit("/videos/generations", { prompt }, options);
+		generateVideo(prompt, options, imageId) {
+			const body = { prompt };
+			if (imageId !== void 0 && imageId.length > 0) body["image_id"] = imageId;
+			return this.submit("/videos/generations", body, options);
 		}
 		generateSpeech(input, options) {
 			return this.submit("/audio/speech", { input }, options);
@@ -401449,6 +401606,16 @@ function slashCommandBusyReason(options) {
 	if (options.isStreaming) return "streaming";
 	if (options.isCompacting) return "compacting";
 }
+function shouldQueueBusySlashCommand(input, options) {
+	const parsed = parseSlashInput(input);
+	if (parsed === null) return false;
+	if (slashCommandBusyReason(options) === void 0) return false;
+	const normalizedName = normalizeLegacyEffortCommandName(parsed.name);
+	const command = findBuiltInSlashCommand(normalizedName);
+	if (command === void 0) return true;
+	if (!isExperimentalFlagEnabled(command.experimentalFlag)) return false;
+	return resolveSlashCommandAvailability(command, parsed.args) === "idle-only";
+}
 function slashBusyMessage(commandName, reason) {
 	if (reason === "streaming") return uiText("resolve.busy.streaming", { command: commandName });
 	return uiText("resolve.busy.compacting", { command: commandName });
@@ -426149,27 +426316,7 @@ registerUiCatalogFragment({
 	}
 });
 const TICK_INTERVAL = 200;
-const COMPACTION_TOKENS_PER_SECOND = 4250;
-const MIN_ESTIMATED_DURATION_MS = 1e3;
-const ACTIVE_PERCENT_LIMIT = 97;
 const BAR_WIDTH = 12;
-const LOAD_PHASE_SHARE = .72;
-const TAIL_PHASE_SHARE = .25;
-function estimateCompactionDurationMs(inputTokens) {
-	if (inputTokens === void 0 || !Number.isFinite(inputTokens) || inputTokens <= 0) return;
-	return Math.max(MIN_ESTIMATED_DURATION_MS, Math.round(inputTokens / COMPACTION_TOKENS_PER_SECOND * 1e3));
-}
-function estimateCompactionPercent(elapsedMs, inputTokens) {
-	const durationMs = estimateCompactionDurationMs(inputTokens);
-	if (durationMs === void 0) return 0;
-	const safeElapsedMs = Math.max(0, elapsedMs);
-	let estimate = Math.min(1, safeElapsedMs / durationMs) * LOAD_PHASE_SHARE;
-	if (safeElapsedMs > durationMs) {
-		const tailFraction = 1 - Math.exp(-(safeElapsedMs - durationMs) / durationMs);
-		estimate += tailFraction * TAIL_PHASE_SHARE;
-	}
-	return Math.min(ACTIVE_PERCENT_LIMIT, Math.max(0, Math.round(estimate * 100)));
-}
 var SingleLineText = class {
 	text;
 	constructor(text) {
@@ -426240,7 +426387,6 @@ var CompactionComponent = class extends Container {
 	stage = 1;
 	estimatedStageCount;
 	stageCount;
-	estimatedProgressPercent;
 	windowUsagePercent;
 	constructor(ui, instruction, tip, showRunning = true) {
 		super();
@@ -426297,7 +426443,6 @@ var CompactionComponent = class extends Container {
 		this.attempt = progress.attempt;
 		this.stage = progress.stage ?? this.stage;
 		this.estimatedStageCount = progress.estimatedStageCount;
-		this.estimatedProgressPercent = progress.estimatedProgressPercent;
 		this.windowUsagePercent = progress.windowUsagePercent;
 		this.statusText.setText(this.buildStatusLine());
 		if (this.showRunning) this.ui?.requestRender();
@@ -426319,21 +426464,16 @@ var CompactionComponent = class extends Container {
 		}
 		if (this.failed) return `${currentTheme.fg("error", STATUS_BULLET)}${currentTheme.boldFg("error", this.failureTitle ?? uiText("compaction.failed"))}${currentTheme.fg("textDim", ` · ${this.failureDetail ?? uiText("compaction.failureDetail")}`)}`;
 		if (this.canceled) return `${currentTheme.fg("warning", STATUS_BULLET)}${currentTheme.boldFg("warning", uiText("compaction.canceled"))}`;
-		const elapsedMs = Math.max(0, Date.now() - this.attemptStartedAtMs);
-		const percent = this.estimatedProgressPercent ?? estimateCompactionPercent(elapsedMs, this.estimatedInputTokens);
-		const filled = Math.round(percent / 100 * BAR_WIDTH);
-		const bar = `[${"█".repeat(filled)}${"░".repeat(BAR_WIDTH - filled)}]`;
 		const stageText = formatCompactionStageText({
 			stage: this.stage,
 			estimatedStageCount: this.estimatedStageCount,
-			estimatedProgressPercent: this.estimatedProgressPercent,
 			windowUsagePercent: this.windowUsagePercent,
 			estimatedInputTokens: this.estimatedInputTokens,
 			charsReceived: 0,
 			attempt: this.attempt
 		});
 		const runningText = `${formatCompactionRunningText(this.estimatedInputTokens)}${stageText.length === 0 ? "" : ` · ${stageText}`}`;
-		return `${currentTheme.fg("primary", bar)} ${currentTheme.boldFg("primary", runningText)}${this.windowUsagePercent === void 0 ? currentTheme.fg("textDim", ` ~${String(percent)} %`) : ""}${currentTheme.fg("textDim", ` · ${String(this.elapsedSeconds())}s`)}${this.attempt > 1 ? currentTheme.fg("textDim", uiText("compaction.attempt", { attempt: this.attempt })) : ""}${currentTheme.fg("textDim", ` · ${uiText("compaction.cancelHint")}`)}${this.instruction ? currentTheme.fg("textDim", ` · ${this.instruction}`) : ""}${this.tip ? currentTheme.fg("textDim", ` · ${this.tip}`) : ""}`;
+		return `${currentTheme.fg("primary", STATUS_BULLET)}${currentTheme.boldFg("primary", runningText)}${currentTheme.fg("textDim", ` · ${String(this.elapsedSeconds())}s`)}${this.attempt > 1 ? currentTheme.fg("textDim", uiText("compaction.attempt", { attempt: this.attempt })) : ""}${currentTheme.fg("textDim", ` · ${uiText("compaction.cancelHint")}`)}${this.instruction ? currentTheme.fg("textDim", ` · ${this.instruction}`) : ""}${this.tip ? currentTheme.fg("textDim", ` · ${this.tip}`) : ""}`;
 	}
 	startTicking() {
 		this.timer = setInterval(() => {
@@ -427842,24 +427982,12 @@ var AgentSwarmProgressComponent = class {
 		if (snapshot.phase === "cancelled" && snapshot.ticks <= 0) return renderCancelledUnstartedCell(member, width, this.colors);
 		if (!layout.renderText) return this.renderCompactCell(member, snapshot, layout.barCells, nowMs);
 		if (snapshot.phase === "queued" && snapshot.ticks <= 0) return renderQueuedCell(member, width, this.colors);
-		const estimate = this.progressEstimator.estimate({
-			memberKey: member.id,
-			phase: snapshot.phase,
-			capacityTicks: layout.barCells * PROGRESS_LEVELS.length,
-			nowMs
-		});
-		const prefix = `${chalk.hex(this.colors.primary)(member.id)} ${progressBar(estimate.displayTicks, snapshot.phase, layout.barCells, this.colors, snapshot.phaseElapsedMs, cancelledProgressColor(member, snapshot.phase, this.colors))} `;
+		const prefix = `${chalk.hex(this.colors.primary)(member.id)} ${chalk.hex(phaseColor(snapshot.phase, this.colors))(phaseLabel(snapshot.phase))} · `;
 		return prefix + renderCellLabel(member, snapshot, Math.max(1, width - visibleWidth(prefix)), this.colors);
 	}
 	renderCompactCell(member, snapshot, barCells, nowMs) {
 		const estimatePhase = snapshot.phase === "pending" ? "queued" : snapshot.phase;
-		const estimate = this.progressEstimator.estimate({
-			memberKey: member.id,
-			phase: estimatePhase,
-			capacityTicks: barCells * PROGRESS_LEVELS.length,
-			nowMs
-		});
-		return `${chalk.hex(this.colors.primary)(member.id)} ${progressBar(estimate.displayTicks, estimatePhase, barCells, this.colors, snapshot.phaseElapsedMs, cancelledProgressColor(member, snapshot.phase, this.colors))}${compactTerminalMark(member, snapshot.phase, this.colors)}`;
+		return `${chalk.hex(this.colors.primary)(member.id)} ${chalk.hex(phaseColor(estimatePhase, this.colors))(phaseLabel(estimatePhase))}${compactTerminalMark(member, snapshot.phase, this.colors)}`;
 	}
 	findMemberForSubagent(agentId, swarmIndex) {
 		const existing = this.findMemberByAgentId(agentId);
@@ -497915,6 +498043,365 @@ var ActivityPaneComponent = class extends Container {
 		return lines;
 	}
 };
+registerUiCatalogFragment({
+	en: {
+		"media.activity.jobs": "{count} media jobs active",
+		"media.activity.showJobs": "ctrl+o: show jobs",
+		"media.activity.collapse": "ctrl+o: collapse",
+		"media.activity.chain": "Production chain",
+		"media.detail.queue": "Position {position}",
+		"media.detail.segment": "Segment {current}/{total}",
+		"media.detail.audio": "{seconds}s audio",
+		"media.detail.remaining": "about {duration} remaining",
+		"media.detail.preview": "Preview",
+		"media.detail.playSample": "Play sample",
+		"media.detail.waveform": "Waveform",
+		"media.detail.open": "Open",
+		"media.detail.duration": "Duration {duration}",
+		"media.detail.resolution": "{width}x{height}",
+		"media.kind.media": "Media",
+		"media.kind.image": "Image",
+		"media.kind.video": "Video",
+		"media.kind.voice": "Voice",
+		"media.kind.image-analysis": "Image analysis",
+		"media.kind.video-analysis": "Video analysis",
+		"media.kind.dubbing": "Dubbing",
+		"media.kind.lipsync": "Lip sync",
+		"media.phase.submitting": "Sending request",
+		"media.phase.uploading": "Sending request",
+		"media.phase.accepted": "Queued",
+		"media.phase.pending": "Queued",
+		"media.phase.queued": "Queued",
+		"media.phase.running": "Processing",
+		"media.phase.in-progress": "Processing",
+		"media.phase.generating": "Generating",
+		"media.phase.rendering": "Rendering",
+		"media.phase.processing": "Processing",
+		"media.phase.checking": "Checking status",
+		"media.phase.audio-analysis": "Audio analysis",
+		"media.phase.face-detection": "Face detection",
+		"media.phase.face-tracking": "Face tracking",
+		"media.phase.lip-sync-running": "Lip sync running",
+		"media.phase.exporting": "Exporting",
+		"media.phase.saving": "Saving",
+		"media.phase.upscaling": "Upscaling",
+		"media.phase.analyzing": "Analyzing"
+	},
+	de: {
+		"media.activity.jobs": "{count} Medienaufträge aktiv",
+		"media.activity.showJobs": "ctrl+o: Aufträge öffnen",
+		"media.activity.collapse": "ctrl+o: einklappen",
+		"media.activity.chain": "Produktionskette",
+		"media.detail.queue": "Platz {position}",
+		"media.detail.segment": "Abschnitt {current}/{total}",
+		"media.detail.audio": "{seconds}s Audio",
+		"media.detail.remaining": "noch etwa {duration}",
+		"media.detail.preview": "Vorschau",
+		"media.detail.playSample": "Probehören",
+		"media.detail.waveform": "Wellenform",
+		"media.detail.open": "Öffnen",
+		"media.detail.duration": "Dauer {duration}",
+		"media.detail.resolution": "{width}x{height}",
+		"media.kind.media": "Medien",
+		"media.kind.image": "Bild",
+		"media.kind.video": "Video",
+		"media.kind.voice": "Stimme",
+		"media.kind.image-analysis": "Bildanalyse",
+		"media.kind.video-analysis": "Videoanalyse",
+		"media.kind.dubbing": "Vertonung",
+		"media.kind.lipsync": "Lip-Sync",
+		"media.phase.submitting": "Auftrag wird gesendet",
+		"media.phase.uploading": "Auftrag wird gesendet",
+		"media.phase.accepted": "Eingereiht",
+		"media.phase.pending": "Eingereiht",
+		"media.phase.queued": "Eingereiht",
+		"media.phase.running": "Wird verarbeitet",
+		"media.phase.in-progress": "Wird verarbeitet",
+		"media.phase.generating": "Wird erzeugt",
+		"media.phase.rendering": "Wird gerendert",
+		"media.phase.processing": "Wird verarbeitet",
+		"media.phase.checking": "Status wird geprüft",
+		"media.phase.audio-analysis": "Audioanalyse",
+		"media.phase.face-detection": "Gesichtserkennung",
+		"media.phase.face-tracking": "Gesicht wird verfolgt",
+		"media.phase.lip-sync-running": "Lip-Sync läuft",
+		"media.phase.exporting": "Wird exportiert",
+		"media.phase.saving": "Wird gespeichert",
+		"media.phase.upscaling": "Wird hochskaliert",
+		"media.phase.analyzing": "Wird analysiert"
+	}
+});
+function mediaActivityStatusKey(value) {
+	return String(value ?? "processing").trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "-");
+}
+function mediaActivityIsTerminal(value) {
+	return [
+		"complete",
+		"completed",
+		"ready",
+		"failed",
+		"expired",
+		"blocked"
+	].includes(mediaActivityStatusKey(value));
+}
+function shouldSuppressMediaPollTranscript(toolName, isError, output) {
+	if (toolName !== "GetMedia" || isError === true) return false;
+	const text = typeof output === "string" ? output : JSON.stringify(output);
+	const match = /Media job\s+\S+\s+status:\s*([a-z0-9_-]+)/i.exec(text);
+	return match !== null && !mediaActivityIsTerminal(match[1]);
+}
+function mediaActivityIsQueued(job) {
+	return job.queuePosition !== void 0 || [
+		"accepted",
+		"pending",
+		"queued",
+		"submitting",
+		"uploading"
+	].includes(mediaActivityStatusKey(job.phase));
+}
+function mediaActivityShouldShowPercent(job) {
+	return !mediaActivityIsQueued(job) && job.percent !== void 0 && Number.isFinite(job.percent);
+}
+function mediaActivityCanonicalPhase(value) {
+	const phase = mediaActivityStatusKey(value);
+	if (["accepted", "pending", "submitting", "uploading"].includes(phase)) return "queued";
+	if (["running", "in-progress"].includes(phase)) return "processing";
+	if (phase === "face-detection") return "face-tracking";
+	return phase;
+}
+function mediaActivityPhaseSequence(mediaKind) {
+	switch (mediaActivityStatusKey(mediaKind)) {
+		case "image": return ["queued", "generating", "upscaling", "saving"];
+		case "video": return ["queued", "generating", "rendering", "saving"];
+		case "voice": return ["queued", "processing", "saving"];
+		case "dubbing": return ["queued", "audio-analysis", "rendering", "saving"];
+		case "lipsync": return ["queued", "audio-analysis", "face-tracking", "lip-sync-running", "rendering", "exporting", "saving"];
+		case "image-analysis":
+		case "video-analysis": return ["queued", "analyzing"];
+		default: return ["queued", "processing", "saving"];
+	}
+}
+function mediaActivityChainStates(job) {
+	const current = mediaActivityCanonicalPhase(job.phaseLabel ?? job.phase);
+	const history = new Set((job.phaseHistory ?? []).map((phase) => mediaActivityCanonicalPhase(phase)));
+	return mediaActivityPhaseSequence(job.mediaKind).map((phase) => ({
+		phase,
+		state: phase === current ? "active" : history.has(phase) ? "done" : "pending"
+	}));
+}
+function renderMediaWaveform(samples, width) {
+	if (!Array.isArray(samples) || samples.length === 0 || width <= 0) return "";
+	const bars = "▁▂▃▄▅▆▇█";
+	const safeWidth = Math.max(1, Math.floor(width));
+	const max = Math.max(...samples.map((sample) => Math.abs(sample)), 1e-9);
+	let output = "";
+	for (let index = 0; index < safeWidth; index++) {
+		const sampleIndex = Math.min(samples.length - 1, Math.floor(index * samples.length / safeWidth));
+		const normalized = Math.min(1, Math.abs(samples[sampleIndex]) / max);
+		output += bars[Math.min(bars.length - 1, Math.floor(normalized * bars.length))];
+	}
+	return output;
+}
+function mediaActivityOpenUrl(job) {
+	const candidate = [job.sampleUrl, job.previewUrl, job.localPath].find((value) => typeof value === "string" && value.trim().length > 0)?.trim();
+	if (candidate === void 0) return;
+	if (/^https?:\/\//iu.test(candidate) || /^file:\/\//iu.test(candidate)) try {
+		const parsed = new URL(candidate);
+		if (["http:", "https:", "file:"].includes(parsed.protocol)) return parsed.href;
+	} catch {
+		return;
+	}
+	if (/^[A-Za-z]:[\\/]/u.test(candidate) || candidate.startsWith("/")) return pathToFileURL(candidate).href;
+}
+const MEDIA_ACTIVITY_LABELS = {
+	"media.kind": /* @__PURE__ */ new Set([
+		"media",
+		"image",
+		"video",
+		"voice",
+		"image-analysis",
+		"video-analysis",
+		"dubbing",
+		"lipsync"
+	]),
+	"media.phase": /* @__PURE__ */ new Set([
+		"submitting",
+		"uploading",
+		"accepted",
+		"pending",
+		"queued",
+		"running",
+		"in-progress",
+		"generating",
+		"rendering",
+		"processing",
+		"checking",
+		"audio-analysis",
+		"face-detection",
+		"face-tracking",
+		"lip-sync-running",
+		"exporting",
+		"saving",
+		"upscaling",
+		"analyzing"
+	])
+};
+function mediaUiText(key, params = {}) {
+	return uiTextFor(getCurrentUiLocale() === "de" ? "de" : "en", key, params);
+}
+function mediaActivityLabel(prefix, value, fallback) {
+	const normalized = mediaActivityStatusKey(value);
+	if (!MEDIA_ACTIVITY_LABELS[prefix]?.has(normalized)) return fallback;
+	return mediaUiText(`${prefix}.${normalized}`);
+}
+function formatMediaDuration(seconds) {
+	if (!Number.isFinite(seconds) || seconds < 0) return;
+	const whole = Math.round(seconds);
+	const minutes = Math.floor(whole / 60);
+	const rest = whole % 60;
+	return minutes > 0 ? `${String(minutes)}:${String(rest).padStart(2, "0")}` : `${String(rest)}s`;
+}
+var MediaActivityStore = class {
+	jobs = /* @__PURE__ */ new Map();
+	update(toolCallId, event) {
+		if (event === null || typeof event !== "object") return;
+		const id = typeof event.id === "string" && event.id.length > 0 ? event.id : void 0;
+		let existingKey = id;
+		if (existingKey === void 0 || !this.jobs.has(existingKey)) for (const [key, job] of this.jobs) if (job.toolCallId === toolCallId || id !== void 0 && job.id === id) {
+			existingKey = key;
+			break;
+		}
+		const key = id ?? existingKey ?? toolCallId;
+		const previous = existingKey === void 0 ? void 0 : this.jobs.get(existingKey);
+		if (existingKey !== void 0 && existingKey !== key) this.jobs.delete(existingKey);
+		if (mediaActivityIsTerminal(event.phase)) {
+			this.jobs.delete(key);
+			return;
+		}
+		const mediaKind = event.mediaKind === "media" && previous?.mediaKind !== void 0 ? previous.mediaKind : event.mediaKind ?? previous?.mediaKind ?? "media";
+		const phase = mediaActivityStatusKey(event.phase ?? previous?.phase ?? "processing");
+		const phaseHistory = [...previous?.phaseHistory ?? []];
+		if (phaseHistory.at(-1) !== phase) phaseHistory.push(phase);
+		this.jobs.set(key, {
+			...previous,
+			...event,
+			id: id ?? previous?.id,
+			mediaKind,
+			phase,
+			phaseHistory,
+			toolCallId,
+			startedAt: previous?.startedAt ?? Date.now(),
+			updatedAt: Date.now()
+		});
+	}
+	active() {
+		return [...this.jobs.values()].filter((job) => !mediaActivityIsTerminal(job.phase)).sort((a, b) => a.startedAt - b.startedAt);
+	}
+	clear() {
+		this.jobs.clear();
+	}
+};
+var MediaActivityComponent = class {
+	jobs;
+	expanded;
+	previewImages = /* @__PURE__ */ new Map();
+	constructor(jobs, expanded = false) {
+		this.jobs = jobs;
+		this.expanded = expanded;
+	}
+	invalidate() {
+		for (const image of this.previewImages.values()) image.invalidate();
+	}
+	jobLine(job, width, includeBar) {
+		const kind = mediaActivityLabel("media.kind", job.mediaKind, String(job.mediaKind ?? "Media"));
+		const rawPhase = job.phaseLabel ?? job.phase ?? "processing";
+		const phase = sanitizeTerminalText(mediaActivityLabel("media.phase", rawPhase, String(rawPhase)));
+		const details = [];
+		if (job.queuePosition !== void 0) details.push(mediaUiText("media.detail.queue", { position: job.queuePosition }));
+		if (job.currentStep !== void 0 && job.totalSteps !== void 0) details.push(`${String(job.currentStep)}/${String(job.totalSteps)}`);
+		if (job.currentSegment !== void 0 && job.totalSegments !== void 0) details.push(mediaUiText("media.detail.segment", {
+			current: job.currentSegment,
+			total: job.totalSegments
+		}));
+		if (job.currentFrame !== void 0 && job.totalFrames !== void 0) details.push(`Frame ${String(job.currentFrame)}/${String(job.totalFrames)}`);
+		if (job.fps !== void 0) details.push(`${String(Math.round(job.fps * 10) / 10)} FPS`);
+		if (job.generatedSeconds !== void 0) details.push(mediaUiText("media.detail.audio", { seconds: Math.round(job.generatedSeconds) }));
+		if (job.durationSeconds !== void 0) details.push(mediaUiText("media.detail.duration", { duration: formatMediaDuration(job.durationSeconds) }));
+		if (job.width > 0 && job.height > 0) details.push(mediaUiText("media.detail.resolution", {
+			width: Math.round(job.width),
+			height: Math.round(job.height)
+		}));
+		const elapsed = job.elapsedSeconds ?? (Date.now() - job.startedAt) / 1e3;
+		const elapsedText = formatMediaDuration(elapsed);
+		if (elapsedText !== void 0) details.push(elapsedText);
+		if (job.remainingSeconds !== void 0) details.push(mediaUiText("media.detail.remaining", { duration: formatMediaDuration(job.remainingSeconds) }));
+		let progress = "";
+		if (mediaActivityShouldShowPercent(job)) {
+			const percent = Math.min(100, Math.max(0, job.percent));
+			progress = includeBar ? ` · ${renderProgressBar(percent / 100, 12)} · ${String(Math.round(percent))} %` : ` · ${String(Math.round(percent))} %`;
+		}
+		const line = `${currentTheme.boldFg("primary", kind)} · ${phase}${details.length === 0 ? "" : ` · ${details.join(" · ")}`}${progress}`;
+		return truncateToWidth(line, Math.max(1, width), "…");
+	}
+	chainLine(job, width) {
+		const chain = mediaActivityChainStates(job).map(({ phase, state }) => {
+			const symbol = state === "done" ? "[x]" : state === "active" ? "[>]" : "[ ]";
+			const label = mediaActivityLabel("media.phase", phase, phase);
+			return `${symbol} ${label}`;
+		});
+		return truncateToWidth(`  ${mediaUiText("media.activity.chain")} · ${chain.join(" · ")}`, Math.max(1, width), "…");
+	}
+	previewImage(job) {
+		if (typeof job.previewDataBase64 !== "string" || job.previewDataBase64.length === 0 || job.previewDataBase64.length > 2 * 1024 * 1024 || !/^[A-Za-z0-9+/=\r\n]+$/u.test(job.previewDataBase64)) return;
+		const mimeType = typeof job.previewMimeType === "string" ? job.previewMimeType.toLowerCase() : "";
+		if (!["image/png", "image/jpeg", "image/webp", "image/gif"].includes(mimeType)) return;
+		const key = `${job.id ?? job.toolCallId}:${mimeType}:${job.previewDataBase64.length}`;
+		let image = this.previewImages.get(key);
+		if (image === void 0) {
+			image = new Image(job.previewDataBase64, mimeType, { fallbackColor: (text) => currentTheme.fg("textDim", text) }, {
+				maxHeightCells: 5,
+				maxWidthCells: 24,
+				filename: mediaUiText("media.detail.preview")
+			});
+			this.previewImages.set(key, image);
+		}
+		return image;
+	}
+	extraLines(job, width) {
+		const lines = [this.chainLine(job, width)];
+		if (Array.isArray(job.waveform) && job.waveform.length > 0) {
+			const label = `${mediaUiText("media.detail.waveform")} · `;
+			const waveform = renderMediaWaveform(job.waveform, Math.max(1, width - visibleWidth(label) - 2));
+			lines.push(truncateToWidth(`  ${label}${waveform}`, Math.max(1, width), "…"));
+		}
+		const openUrl = mediaActivityOpenUrl(job);
+		if (openUrl !== void 0) {
+			const key = job.mediaKind === "voice" ? "media.detail.playSample" : job.localPath !== void 0 ? "media.detail.open" : "media.detail.preview";
+			lines.push(truncateToWidth(`  ${hyperlink(mediaUiText(key), openUrl)}`, Math.max(1, width), "…"));
+		}
+		const image = this.previewImage(job);
+		if (image !== void 0) lines.push(...image.render(Math.max(1, width - 2)).map((line) => `  ${line}`));
+		return lines;
+	}
+	render(width) {
+		if (this.jobs.length === 0) return [];
+		const safeWidth = Math.max(1, width);
+		const hint = mediaUiText(this.expanded ? "media.activity.collapse" : "media.activity.showJobs");
+		if (this.jobs.length > 1 && !this.expanded) {
+			const summary = `${currentTheme.boldFg("primary", mediaUiText("media.activity.jobs", { count: this.jobs.length }))} · ${currentTheme.fg("textDim", hint)}`;
+			return [truncateToWidth(summary, safeWidth, "…")];
+		}
+		const lines = [];
+		if (this.jobs.length === 1) lines.push(truncateToWidth(`${this.jobLine(this.jobs[0], safeWidth, true)} · ${currentTheme.fg("textDim", hint)}`, safeWidth, "…"));
+		else lines.push(truncateToWidth(`${currentTheme.boldFg("primary", mediaUiText("media.activity.jobs", { count: this.jobs.length }))} · ${currentTheme.fg("textDim", hint)}`, safeWidth, "…"));
+		if (!this.expanded) return lines;
+		for (const [index, job] of this.jobs.entries()) {
+			if (this.jobs.length > 1) lines.push(truncateToWidth(`  ${String(index + 1)}. ${this.jobLine(job, Math.max(1, safeWidth - 3), false)}`, safeWidth, "…"));
+			lines.push(...this.extraLines(job, safeWidth));
+		}
+		return lines;
+	}
+};
 //#endregion
 //#region src/tui/components/panes/queue-pane.copy.ts
 registerUiCatalogFragment({
@@ -504441,6 +504928,10 @@ var SessionEventHandler = class {
 		streamingUI.scheduleFlush();
 	}
 	handleToolProgress(event) {
+		if (event.update.kind === "custom" && event.update.customKind === MEDIA_PROGRESS_CUSTOM_KIND) {
+			this.host.updateMediaActivity(event.toolCallId, event.update.customData);
+			return;
+		}
 		const text = event.update.text;
 		if (text === void 0 || text.length === 0) return;
 		const tc = this.host.streamingUI.getToolComponent(event.toolCallId);
@@ -504461,7 +504952,13 @@ var SessionEventHandler = class {
 			is_error: event.isError,
 			synthetic: event.synthetic
 		};
+		const activeCall = streamingUI.getActiveToolCall(event.toolCallId);
+		if (shouldSuppressMediaPollTranscript(activeCall?.name, event.isError, event.output)) streamingUI.suppressToolCallTranscript(event.toolCallId);
 		const matchedCall = streamingUI.completeToolResult(event.toolCallId, resultData);
+		if (matchedCall !== void 0 && isMediaToolName(matchedCall.name) && event.isError === true) this.host.updateMediaActivity(event.toolCallId, {
+			mediaKind: mediaKindForToolName(matchedCall.name),
+			phase: "failed"
+		});
 		if (matchedCall?.name === "GetMedia" && event.isError !== true) this.host.runChannelMediaFallback(event.output);
 		this.subAgentEventHandler.handleAgentSwarmToolResult(event.toolCallId, resultData, event.isError === true);
 		if (matchedCall !== void 0 && matchedCall.name === "TodoList" && !event.isError) {
@@ -505773,6 +506270,7 @@ var SessionReplayRenderer = class {
 		};
 		call.result = result;
 		this.applyStepContext(context);
+		if (shouldSuppressMediaPollTranscript(call.name, message.isError, result.output)) this.host.streamingUI.suppressToolCallTranscript(toolCallId);
 		this.host.streamingUI.onToolCallEnd(toolCallId, result);
 		this.host.streamingUI.removeActiveToolCall(toolCallId);
 		context.completedToolCallIds.add(toolCallId);
@@ -506827,24 +507325,21 @@ function formatContextStatus(usage, tokens, maxTokens, colors, width, now = /* @
 	return truncateToWidth(current, available, "…");
 }
 function formatCompactionStatus(elapsedMs, estimatedInputTokens, progress, colors, width, now = /* @__PURE__ */ new Date()) {
-	const percent = progress?.estimatedProgressPercent ?? estimateCompactionPercent(elapsedMs, estimatedInputTokens);
-	const filled = Math.max(1, Math.ceil((1 - percent / 100) * CONTEXT_BAR_WIDTH));
-	const bar = chalk.hex(colors.primary)(`${"█".repeat(filled)}${"░".repeat(CONTEXT_BAR_WIDTH - filled)}`);
 	const label = formatCompactionRunningText(estimatedInputTokens);
 	const stageText = progress === void 0 ? "" : formatCompactionStageText(progress);
 	const compactStageText = progress?.stage === void 0 || progress.estimatedStageCount === void 0 ? "" : `${String(progress.stage)}/~${String(progress.estimatedStageCount)}${progress.windowUsagePercent === void 0 ? "" : ` · ${String(progress.windowUsagePercent)}%`}`;
-	const estimate = progress?.windowUsagePercent === void 0 ? `~${String(percent)} %` : "";
+	const elapsed = `${String(Math.max(0, Math.round(elapsedMs / 1e3)))}s`;
 	const clock = chalk.hex(colors.textDim)(` · ${clockHhmm(now)}`);
 	const variants = [
-		`${label}${stageText.length === 0 ? "" : ` · ${stageText}`} ${bar}${estimate.length === 0 ? "" : ` ${estimate}`}${clock}`,
+		`${label}${stageText.length === 0 ? "" : ` · ${stageText}`} · ${elapsed}${clock}`,
 		`${label}${stageText.length === 0 ? "" : ` · ${stageText}`}`,
 		compactStageText,
-		`${bar}${estimate.length === 0 ? "" : ` ${estimate}`}`,
-		stageText.length === 0 ? estimate : stageText
+		elapsed,
+		stageText
 	];
 	const available = Math.max(0, width);
 	for (const variant of variants) if (visibleWidth(variant) <= available) return variant;
-	return truncateToWidth(estimate, available, "…");
+	return truncateToWidth(elapsed, available, "…");
 }
 function contextMetrics(state) {
 	const tokens = Number.isFinite(state.contextTokens) ? Math.max(0, state.contextTokens) : 0;
@@ -507390,6 +507885,18 @@ var StreamingUIController = class {
 	removeToolComponent(id) {
 		this._pendingToolComponents.delete(id);
 	}
+	suppressToolCallTranscript(id) {
+		const { state } = this.host;
+		const component = this._pendingToolComponents.get(id);
+		this._pendingToolComponents.delete(id);
+		const transcriptEntryIndex = state.transcriptEntries.findIndex((entry) => entry.toolCallData?.id === id);
+		if (transcriptEntryIndex >= 0) state.transcriptEntries.splice(transcriptEntryIndex, 1);
+		if (component !== void 0) {
+			const childIndex = state.transcriptContainer.children.indexOf(component);
+			if (childIndex >= 0) state.transcriptContainer.children.splice(childIndex, 1);
+		}
+		state.ui.requestRender();
+	}
 	hasPendingAgentGroup() {
 		return this._pendingAgentGroup !== null;
 	}
@@ -512083,6 +512590,9 @@ var BlunTUI = class {
 	startupGoalPromptedSessionId;
 	lastActivityMode;
 	currentLoadingTip = void 0;
+	mediaActivityStore = new MediaActivityStore();
+	mediaActivityTickTimer;
+	mediaActivityExpanded = false;
 	lastHistoryContent;
 	shellOutputStreams = /* @__PURE__ */ new Map();
 	streamingUI;
@@ -512594,6 +513104,7 @@ var BlunTUI = class {
 		this.tasksBrowserController.close();
 		this.btwPanelController.clear();
 		this.stopActivitySpinner();
+		this.stopMediaActivityTicking();
 		this.disposeEditorReplacement();
 		this.streamingUI.disposeActiveCompactionBlock();
 		this.streamingUI.resetToolUi();
@@ -512742,6 +513253,13 @@ var BlunTUI = class {
 			return;
 		}
 		if (text.trimStart().startsWith("/")) {
+			if (shouldQueueBusySlashCommand(text, {
+				isStreaming: this.state.appState.streamingPhase !== "idle",
+				isCompacting: this.state.appState.isCompacting
+			})) {
+				this.enqueueSlashCommand(text);
+				return;
+			}
 			this.runSlashCommand(text);
 			return;
 		}
@@ -513749,6 +514267,8 @@ var BlunTUI = class {
 		this.setAppState({ mcpServersSummary: null });
 		this.streamingUI.setStep(0);
 		this.streamingUI.resetLiveText();
+		this.mediaActivityStore.clear();
+		this.stopMediaActivityTicking();
 		this.updateQueueDisplay();
 	}
 	async showResumeOtherWorkDirHint(session) {
@@ -514200,8 +514720,36 @@ var BlunTUI = class {
 		this.state.ui.requestRender();
 		return this.showLoginProgressSpinner(uiText("blunTui.login.waiting"));
 	}
+	updateMediaActivity(toolCallId, event) {
+		this.mediaActivityStore.update(toolCallId, event);
+		const mediaActivities = this.mediaActivityStore.active();
+		if (mediaActivities.length > 0) {
+			if (this.mediaActivityTickTimer === void 0) this.mediaActivityTickTimer = setInterval(() => this.state.ui.requestRender(), 1e3);
+		} else {
+			this.mediaActivityExpanded = false;
+			this.stopMediaActivityTicking();
+		}
+		this.lastActivityMode = void 0;
+		this.updateActivityPane();
+	}
+	stopMediaActivityTicking() {
+		if (this.mediaActivityTickTimer === void 0) return;
+		clearInterval(this.mediaActivityTickTimer);
+		this.mediaActivityTickTimer = void 0;
+	}
 	updateActivityPane() {
 		const effectiveMode = this.resolveActivityPaneMode();
+		const mediaActivities = effectiveMode === "hidden" ? [] : this.mediaActivityStore.active();
+		if (mediaActivities.length > 0) {
+			this.stopActivitySpinner();
+			this.syncAgentSwarmActivitySpinner(void 0);
+			this.lastActivityMode = `media:${this.mediaActivityExpanded ? "expanded" : "collapsed"}:${mediaActivities.map((job) => `${job.id ?? job.toolCallId}:${job.updatedAt}`).join(",")}`;
+			this.state.activityContainer.clear();
+			this.state.activityContainer.addChild(new Spacer(1));
+			this.state.activityContainer.addChild(new MediaActivityComponent(mediaActivities, this.mediaActivityExpanded));
+			this.state.ui.requestRender();
+			return;
+		}
 		const tipKind = loadingTipKind(effectiveMode);
 		if (effectiveMode === "idle" || effectiveMode === "session" || effectiveMode === "hidden") this.currentLoadingTip = void 0;
 		else if (tipKind !== void 0 && (this.currentLoadingTip === void 0 || this.currentLoadingTip.kind !== tipKind)) this.currentLoadingTip = {
@@ -514294,6 +514842,10 @@ var BlunTUI = class {
 		}));
 	}
 	toggleToolOutputExpansion() {
+		if (this.mediaActivityStore.active().length > 0) {
+			this.toggleMediaActivityExpansion();
+			return;
+		}
 		this.state.toolOutputExpanded = !this.state.toolOutputExpanded;
 		const children = this.state.transcriptContainer.children;
 		const boundaries = [];
@@ -514306,6 +514858,13 @@ var BlunTUI = class {
 		}
 		this.state.ui.requestRender(true);
 	}
+	toggleMediaActivityExpansion() {
+		if (this.mediaActivityStore.active().length === 0) return;
+		this.mediaActivityExpanded = !this.mediaActivityExpanded;
+		this.lastActivityMode = void 0;
+		this.updateActivityPane();
+		this.state.ui.requestRender(true);
+	}
 	toggleTodoPanelExpansion() {
 		this.state.todoPanel.toggleExpanded();
 		this.state.ui.requestRender();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.47",
+  "version": "9.1.49",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {