blun-king-cli 9.1.47 → 9.1.48

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.48
 
 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
 ---------------------------
 

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.48
 ```
 
 ## 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

package/blun.mjs

@@ -75066,10 +75066,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 +75550,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 +75573,6 @@ var init_full = __esmMin((() => {
 							stage,
 							estimatedStageCount,
 							estimatedInputTokens: estimatedCompactionRequestTokens,
-							estimatedProgressPercent,
 							...windowUsagePercent === void 0 ? {} : { windowUsagePercent },
 							charsReceived,
 							attempt: attemptCount,
@@ -77688,12 +77682,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 +261944,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();
@@ -261984,16 +262034,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)}`
@@ -262070,6 +262126,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 +262143,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 +262216,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 +262230,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 +262258,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 +262271,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 +310801,47 @@ 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 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"])
+	};
+	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 +310851,8 @@ function parseStatus(payload, expectedId) {
 	return {
 		kind: "status",
 		id,
-		status
+		status,
+		progress: mediaProgressFromPayload(payload)
 	};
 }
 async function assertSuccess(response, operation) {
@@ -401449,6 +401564,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 +426274,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 +426345,6 @@ var CompactionComponent = class extends Container {
 	stage = 1;
 	estimatedStageCount;
 	stageCount;
-	estimatedProgressPercent;
 	windowUsagePercent;
 	constructor(ui, instruction, tip, showRunning = true) {
 		super();
@@ -426297,7 +426401,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 +426422,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 +427940,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 +498001,208 @@ var ActivityPaneComponent = class extends Container {
 		return lines;
 	}
 };
+registerUiCatalogFragment({
+	en: {
+		"media.activity.jobs": "{count} media jobs active",
+		"media.detail.queue": "Position {position}",
+		"media.detail.segment": "Segment {current}/{total}",
+		"media.detail.audio": "{seconds}s audio",
+		"media.detail.remaining": "about {duration} remaining",
+		"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.detail.queue": "Platz {position}",
+		"media.detail.segment": "Abschnitt {current}/{total}",
+		"media.detail.audio": "{seconds}s Audio",
+		"media.detail.remaining": "noch etwa {duration}",
+		"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));
+}
+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";
+		this.jobs.set(key, {
+			...previous,
+			...event,
+			id: id ?? previous?.id,
+			mediaKind,
+			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;
+	constructor(jobs) {
+		this.jobs = jobs;
+	}
+	invalidate() {}
+	render(width) {
+		if (this.jobs.length === 0) return [];
+		const job = this.jobs[0];
+		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) }));
+		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 (job.percent !== void 0 && Number.isFinite(job.percent)) {
+			const percent = Math.min(100, Math.max(0, job.percent));
+			progress = ` · ${renderProgressBar(percent / 100, 12)} · ${String(Math.round(percent))} %`;
+		}
+		const summary = this.jobs.length > 1 ? ` · ${mediaUiText("media.activity.jobs", { count: this.jobs.length })}` : "";
+		const line = `${currentTheme.boldFg("primary", kind)} · ${phase}${details.length === 0 ? "" : ` · ${details.join(" · ")}`}${progress}${summary}`;
+		return [truncateToWidth(line, Math.max(1, width), "…")];
+	}
+};
 //#endregion
 //#region src/tui/components/panes/queue-pane.copy.ts
 registerUiCatalogFragment({
@@ -504441,6 +504729,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);
@@ -504462,6 +504754,10 @@ var SessionEventHandler = class {
 			synthetic: event.synthetic
 		};
 		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) {
@@ -506827,24 +507123,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;
@@ -512083,6 +512376,8 @@ var BlunTUI = class {
 	startupGoalPromptedSessionId;
 	lastActivityMode;
 	currentLoadingTip = void 0;
+	mediaActivityStore = new MediaActivityStore();
+	mediaActivityTickTimer;
 	lastHistoryContent;
 	shellOutputStreams = /* @__PURE__ */ new Map();
 	streamingUI;
@@ -512594,6 +512889,7 @@ var BlunTUI = class {
 		this.tasksBrowserController.close();
 		this.btwPanelController.clear();
 		this.stopActivitySpinner();
+		this.stopMediaActivityTicking();
 		this.disposeEditorReplacement();
 		this.streamingUI.disposeActiveCompactionBlock();
 		this.streamingUI.resetToolUi();
@@ -512742,6 +513038,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 +514052,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 +514505,32 @@ var BlunTUI = class {
 		this.state.ui.requestRender();
 		return this.showLoginProgressSpinner(uiText("blunTui.login.waiting"));
 	}
+	updateMediaActivity(toolCallId, event) {
+		this.mediaActivityStore.update(toolCallId, event);
+		if (this.mediaActivityStore.active().length > 0) {
+			if (this.mediaActivityTickTimer === void 0) this.mediaActivityTickTimer = setInterval(() => this.state.ui.requestRender(), 1e3);
+		} else 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:${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.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 = {

package/package.json

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