blun-king-cli 9.1.102 → 9.1.104

package/LIESMICH.txt

@@ -91,6 +91,8 @@ Ab BLUN King 9.1.98 kann King einen abgeschlossenen Arbeitsabschnitt verdichten,
 
 Große textbasierte Werkzeugergebnisse bleiben nicht mehr vollständig im Modellkontext. Ab 12.001 Zeichen speichert BLUN King das vollständige Ergebnis in einer privaten Datei im Sitzungsordner `tool-results`. Im Modellkontext verbleiben die ersten 1.000 und die letzten 1.000 Zeichen, die genaue Zahl der ausgelassenen Zeichen und der `output_path`. Der Agent kann das vollständige Ergebnis anschließend mit `Read` seitenweise über diesen Pfad lesen. Ergebnisse bis einschließlich 12.000 Zeichen, gemischte Medienergebnisse und bereits gekürzte Ergebnisse bleiben unverändert. Auch eine spätere Mikroverdichtung bewahrt den Dateiverweis. Beispiel: Bei einem Suchergebnis mit 30.000 Zeichen sehen folgende Modellanfragen den Anfang und das abschließende Ergebnis oder den Fehler; der vollständige Text bleibt lokal verfügbar.
 
+Version 9.1.104 lässt Shell-Befehle im Vordergrund auch bei sehr großen Ausgaben bis zum regulären Ende laufen. King schreibt bis zu 16 MiB fortlaufend in das private Aufgabenprotokoll, verwirft darüber hinausgehende Ausgaben und meldet den tatsächlichen Exit-Code, statt den Prozess wegen der Ausgabemenge zu beenden. Kleine Ausgaben, Hintergrundaufgaben, Zeitgrenzen und manuelle Abbrüche bleiben unverändert.
+
 Ab BLUN King 9.1.99 werden auch direkt aufeinanderfolgende reine Textergebnisse als Stapel betrachtet. Enthalten sie zusammen mehr als 12.000 Zeichen, obwohl kein einzelnes Ergebnis diese Grenze überschreitet, speichert King so viele der größten geeigneten Ergebnisse wie nötig in privaten Dateien. In der Modellprojektion verbleiben lesbare Verweise. Der unveränderte Sitzungsrohverlauf bleibt vollständig erhalten. Gemischte Medienergebnisse, einzelne Ergebnisse unter 3.000 Zeichen und Stapel bis einschließlich 12.000 Zeichen bleiben unverändert. Beispiel: Bei zwei Suchergebnissen mit 7.000 und 6.000 Zeichen wird das größere Ergebnis privat gespeichert; Anfang, Ende, ausgelassene Zeichenzahl und `output_path` bleiben für den Agenten sichtbar.
 
 Ab BLUN King 9.1.100 beendet eine begrenzte Grep-Inhaltssuche ripgrep, sobald der Versatz, die angeforderten Zeilen und eine zusätzliche Vorschauzeile vollständig vorliegen. Die Vorschauzeile belegt, ob eine weitere Seite existiert, ohne vorher bis zu 10 MB einzulesen. Unbegrenzte Suchen, Trefferzählungen und nach Änderungszeit sortierte Dateilisten laufen weiterhin vollständig durch.
@@ -103,7 +105,7 @@ Das Telemetrieereignis `tool_result_batch_offloaded` meldet ausschließlich die
 
 Reguläre `Agent`-Teilaufgaben verwenden eine eigene `ContextMemory` und eine eigene `wire.jsonl` in einem getrennten Agentenverzeichnis. Der Hauptagent erhält nur die Ergebniszusammenfassung, sodass lange Teilaufgaben nicht den Hauptverlauf füllen. `TodoList` speichert Pläne weiterhin maschinenlesbar im Sitzungs-Wire; `blun handoff` übergibt sie zusammen mit prüfbaren Hashes zwischen CLI, Desktop und Web.
 
-Verliert ein delegierter Einzelagent die Provider-Verbindung, erhält er eine leere Provider-Antwort, trifft er auf einen Leerlaufabbruch des Streams oder meldet der Server einen wiederholbaren Status, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Die erste Fortsetzung wartet zwei Sekunden, die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. Die Fortsetzungsanweisung fordert den Agenten ausdrücklich auf, den erhaltenen Arbeitsstand zu prüfen und abgeschlossene Schritte nicht zu wiederholen. Authentifizierungs-, Guthaben-, Sicherheits-, Kontext- sowie beliebige Code- und Werkzeugfehler und manuelle Abbrüche bleiben endgültig. Dieser Schutz gilt für einen delegierten Einzelagenten; für Schwärme gelten weiterhin deren bestehende Zeitgrenzen- und Überlastungsregeln.
+Verliert ein delegierter Einzelagent oder ein Mitglied eines Agentenschwarms die Provider-Verbindung, erhält es eine leere Provider-Antwort, bricht sein Stream wegen Leerlaufs ab oder meldet der Server HTTP 408/500/502/503/504, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Bei Einzelagenten sowie bei Schwarm-Unterbrechungen außerhalb von HTTP 429 wartet die erste Fortsetzung zwei Sekunden und die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. HTTP 429 behält im Schwarm seine getrennte, längere Überlastungsregel. Authentifizierungs-, Zahlungs- oder Kontingent-, Richtlinien-, Kontext-, Werkzeug- und Codefehler sowie manuelle Abbrüche lösen keine automatische Fortsetzung aus. Jeder Fortsetzungsversuch verwendet die bestehende Agenten-ID, damit bereits abgeschlossene Arbeit nicht wiederholt wird.
 
 Rein lesende Sitzungsdiagnose
 --------------------------------

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.100
+npm install -g blun-king-cli@9.1.104
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -111,6 +111,8 @@ Ab BLUN King 9.1.98 kann King einen abgeschlossenen Arbeitsabschnitt verdichten,
 
 Große textbasierte Werkzeugergebnisse bleiben nicht mehr vollständig im Modellkontext. Ab 12.001 Zeichen speichert BLUN King das vollständige Ergebnis in einer privaten Datei im Sitzungsordner `tool-results`. Im Modellkontext verbleiben die ersten 1.000 und die letzten 1.000 Zeichen, die genaue Zahl der ausgelassenen Zeichen und der `output_path`. Der Agent kann das vollständige Ergebnis anschließend mit `Read` seitenweise über diesen Pfad lesen. Ergebnisse bis einschließlich 12.000 Zeichen, gemischte Medienergebnisse und bereits gekürzte Ergebnisse bleiben unverändert. Auch eine spätere Mikroverdichtung bewahrt den Dateiverweis. Beispiel: Bei einem Suchergebnis mit 30.000 Zeichen sehen folgende Modellanfragen den Anfang und das abschließende Ergebnis oder den Fehler; der vollständige Text bleibt lokal verfügbar.
 
+Version 9.1.104 lässt Shell-Befehle im Vordergrund auch bei sehr großen Ausgaben bis zum regulären Ende laufen. King schreibt bis zu 16 MiB fortlaufend in das private Aufgabenprotokoll, verwirft darüber hinausgehende Ausgaben und meldet den tatsächlichen Exit-Code, statt den Prozess wegen der Ausgabemenge zu beenden. Kleine Ausgaben, Hintergrundaufgaben, Zeitgrenzen und manuelle Abbrüche bleiben unverändert.
+
 Ab BLUN King 9.1.99 werden auch direkt aufeinanderfolgende reine Textergebnisse als Stapel betrachtet. Enthalten sie zusammen mehr als 12.000 Zeichen, obwohl kein einzelnes Ergebnis diese Grenze überschreitet, speichert King so viele der größten geeigneten Ergebnisse wie nötig in privaten Dateien. In der Modellprojektion verbleiben lesbare Verweise. Der unveränderte Sitzungsrohverlauf bleibt vollständig erhalten. Gemischte Medienergebnisse, einzelne Ergebnisse unter 3.000 Zeichen und Stapel bis einschließlich 12.000 Zeichen bleiben unverändert. Beispiel: Bei zwei Suchergebnissen mit 7.000 und 6.000 Zeichen wird das größere Ergebnis privat gespeichert; Anfang, Ende, ausgelassene Zeichenzahl und `output_path` bleiben für den Agenten sichtbar.
 
 Ab BLUN King 9.1.100 beendet eine begrenzte Grep-Inhaltssuche ripgrep, sobald der Versatz, die angeforderten Zeilen und eine zusätzliche Vorschauzeile vollständig vorliegen. Die Vorschauzeile belegt, ob eine weitere Seite existiert, ohne vorher bis zu 10 MB einzulesen. Unbegrenzte Suchen, Trefferzählungen und nach Änderungszeit sortierte Dateilisten laufen weiterhin vollständig durch.

package/bin/foreground-output-capture-policy.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+const MAX_FOREGROUND_CAPTURE_BYTES = 16 * 1024 * 1024;
+
+function utf8PrefixWithinBytes(text, maxBytes) {
+  if (maxBytes <= 0 || text.length === 0) return '';
+  if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text;
+
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, middle), 'utf8') <= maxBytes) low = middle;
+    else high = middle - 1;
+  }
+  if (low > 0 && low < text.length) {
+    const last = text.charCodeAt(low - 1);
+    if (last >= 0xD800 && last <= 0xDBFF) low -= 1;
+  }
+  return text.slice(0, low);
+}
+
+function captureForegroundOutputChunk(text, capturedBytes, maxBytes = MAX_FOREGROUND_CAPTURE_BYTES) {
+  const observedBytes = Buffer.byteLength(text, 'utf8');
+  const remainingBytes = Math.max(0, maxBytes - Math.max(0, capturedBytes));
+  const capturedText = utf8PrefixWithinBytes(text, remainingBytes);
+  const newCapturedBytes = Buffer.byteLength(capturedText, 'utf8');
+  return {
+    capturedText,
+    observedBytes,
+    capturedBytes: newCapturedBytes,
+    droppedBytes: observedBytes - newCapturedBytes,
+    capped: newCapturedBytes < observedBytes,
+  };
+}
+
+module.exports = {
+  MAX_FOREGROUND_CAPTURE_BYTES,
+  captureForegroundOutputChunk,
+  utf8PrefixWithinBytes,
+};

package/bin/subagent-timeout-policy.cjs

@@ -74,6 +74,18 @@ function isRetryableSubagentFailure(error) {
   return RETRYABLE_MESSAGE_RE.test(message);
 }
 
+function transientSubagentRetryDelayMs(retryCount) {
+  if (!Number.isInteger(retryCount) || retryCount < 1) {
+    throw new Error("retryCount must be a positive integer.");
+  }
+  return DEFAULT_TRANSIENT_RETRY_DELAYS_MS[retryCount - 1]
+    ?? DEFAULT_TRANSIENT_RETRY_DELAYS_MS.at(-1);
+}
+
+function shouldStopTransientSubagentContinuation(retryCount) {
+  return retryCount >= MAX_TRANSIENT_SUBAGENT_CONTINUATIONS;
+}
+
 function waitForRetryDelay(delayMs, signal) {
   if (delayMs <= 0) return Promise.resolve();
   if (signal.aborted) return Promise.reject(abortError(signal.reason));
@@ -134,7 +146,8 @@ async function runAgentWithTimeoutContinuation({
         throw result.error;
       }
       const attempt = transientContinuations + 1;
-      const delayMs = retryDelaysMs[transientContinuations] ?? retryDelaysMs.at(-1) ?? 0;
+      const delayMs = retryDelaysMs[transientContinuations]
+        ?? transientSubagentRetryDelayMs(attempt);
       transientContinuations = attempt;
       await waitForRetryDelay(delayMs, signal);
       currentHandle = await retrySameAgent(currentHandle.agentId, {
@@ -164,4 +177,6 @@ module.exports = {
   isRetryableSubagentFailure,
   resolveSubagentTimeoutMs,
   runAgentWithTimeoutContinuation,
+  shouldStopTransientSubagentContinuation,
+  transientSubagentRetryDelayMs,
 };

package/blun.mjs

@@ -29316,9 +29316,6 @@ function isBackgroundTaskTerminal(status) {
 	return TERMINAL_STATUSES.has(status);
 }
 /** Terminal `stopReason` recorded when a foreground command trips the output ceiling. */
-function foregroundOutputLimitReason() {
-	return `Output limit exceeded: the command produced more than ${Math.floor(MAX_FOREGROUND_OUTPUT_BYTES / (1024 * 1024))} MiB and was terminated. Redirect large output to a file (e.g. \`command > out.txt\`) and inspect it in slices instead.`;
-}
 /**
 * Generate `{prefix}-{8 base36 chars}`.
 *
@@ -29378,7 +29375,7 @@ function buildBackgroundTaskNotificationBody(info) {
 		"The subagent retains its full prior context across the restart, but any in-flight tool call lost its result and may need to be redone."
 	].join("\n")}`;
 }
-var MAX_OUTPUT_BYTES$2, NOTIFICATION_FALLBACK_PREVIEW_BYTES, MAX_FOREGROUND_OUTPUT_BYTES, SIGTERM_GRACE_MS$1, USER_INTERRUPT_REASON$1, _ALPHABET, BackgroundManager;
+var MAX_OUTPUT_BYTES$2, NOTIFICATION_FALLBACK_PREVIEW_BYTES, MAX_FOREGROUND_CAPTURE_BYTES, captureForegroundOutputChunk, SIGTERM_GRACE_MS$1, USER_INTERRUPT_REASON$1, _ALPHABET, BackgroundManager;
 var init_background = __esmMin((() => {
 	init_dist$4();
 	init_errors$4();
@@ -29392,7 +29389,7 @@ var init_background = __esmMin((() => {
 	init_question_task();
 	MAX_OUTPUT_BYTES$2 = 1024 * 1024;
 	NOTIFICATION_FALLBACK_PREVIEW_BYTES = 3e3;
-	MAX_FOREGROUND_OUTPUT_BYTES = 16 * 1024 * 1024;
+	({ MAX_FOREGROUND_CAPTURE_BYTES, captureForegroundOutputChunk } = createRequire(import.meta.url)("./bin/foreground-output-capture-policy.cjs"));
 	SIGTERM_GRACE_MS$1 = 5e3;
 	USER_INTERRUPT_REASON$1 = "Interrupted by user";
 	_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
@@ -29470,7 +29467,8 @@ var init_background = __esmMin((() => {
 				outputChunks: [],
 				outputRingChars: 0,
 				outputSizeBytes: 0,
-				outputLimitTripped: false,
+				outputCapturedBytes: 0,
+				outputCaptureCapped: false,
 				status: "running",
 				options: entryOptions,
 				startedAt: Date.now(),
@@ -29708,27 +29706,32 @@ var init_background = __esmMin((() => {
 			return entry.persistWriteQueue;
 		}
 		appendOutput(entry, chunk) {
-			entry.outputSizeBytes += Buffer.byteLength(chunk, "utf-8");
-			entry.outputChunks.push(chunk);
-			entry.outputRingChars += chunk.length;
+			const capture = this.isDetached(entry) ? {
+				capturedText: chunk,
+				observedBytes: Buffer.byteLength(chunk, "utf-8"),
+				capturedBytes: Buffer.byteLength(chunk, "utf-8"),
+				droppedBytes: 0,
+				capped: false
+			} : captureForegroundOutputChunk(chunk, entry.outputCapturedBytes);
+			entry.outputSizeBytes += capture.observedBytes;
+			entry.outputCapturedBytes += capture.capturedBytes;
+			if (capture.capped) entry.outputCaptureCapped = true;
+			if (capture.capturedText.length === 0) return;
+			entry.outputChunks.push(capture.capturedText);
+			entry.outputRingChars += capture.capturedText.length;
 			while (entry.outputRingChars > MAX_OUTPUT_BYTES$2 && entry.outputChunks.length > 1) {
 				const removed = entry.outputChunks.shift();
 				if (removed === void 0) break;
 				entry.outputRingChars -= removed.length;
 			}
-			if (!entry.outputLimitTripped && !this.isDetached(entry) && entry.outputSizeBytes > MAX_FOREGROUND_OUTPUT_BYTES) {
-				entry.outputLimitTripped = true;
-				this.stop(entry.taskId, foregroundOutputLimitReason());
-			}
-			if (entry.outputLimitTripped) return;
 			if (this.persistence === void 0) return;
 			if (!entry.outputPersistStarted) {
-				entry.pendingOutput.push(chunk);
-				entry.pendingOutputBytes += Buffer.byteLength(chunk, "utf-8");
+				entry.pendingOutput.push(capture.capturedText);
+				entry.pendingOutputBytes += capture.capturedBytes;
 				if (entry.pendingOutputBytes > MAX_OUTPUT_BYTES$2) this.startOutputPersist(entry);
 				return;
 			}
-			this.appendTaskOutput(entry, chunk);
+			this.appendTaskOutput(entry, capture.capturedText);
 		}
 		/** Enqueue an `output.log` append, serialized per task. No-op when detached managers omit persistence. */
 		appendTaskOutput(entry, chunk) {
@@ -29925,6 +29928,7 @@ var init_background = __esmMin((() => {
 				endedAt: entry.endedAt,
 				stopReason: entry.stopReason,
 				terminalNotificationSuppressed: entry.terminalNotificationSuppressed,
+				outputCaptureCapped: entry.outputCaptureCapped,
 				timeoutMs: entry.options.timeoutMs
 			};
 			return entry.task.toInfo(base);
@@ -251353,18 +251357,20 @@ function resolveSwarmMaxConcurrency(env = process.env) {
 	if (!Number.isInteger(value) || value <= 0) throw new Error(`${AGENT_SWARM_MAX_CONCURRENCY_ENV} must be a positive integer, got ${JSON.stringify(raw)}.`);
 	return value;
 }
-var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, MAX_AUTOMATIC_RATE_LIMIT_RESUMES, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume, SubagentBatch;
+var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, TRANSIENT_PROVIDER_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, MAX_AUTOMATIC_RATE_LIMIT_RESUMES, MAX_TRANSIENT_SUBAGENT_CONTINUATIONS, isRetryableSubagentFailure, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume, shouldStopTransientSubagentContinuation, transientSubagentRetryDelayMs, SubagentBatch;
 var init_subagent_batch = __esmMin((() => {
 	init_src$4();
 	import_retry = /* @__PURE__ */ __toESM(require_retry$1(), 1);
 	init_abort();
 	({ MAX_AUTOMATIC_RATE_LIMIT_RESUMES, RATE_LIMIT_RETRY_BASE_MS, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume } = createRequire(import.meta.url)("./bin/rate-limit-recovery-policy.cjs"));
+	({ MAX_TRANSIENT_SUBAGENT_CONTINUATIONS, isRetryableSubagentFailure, shouldStopTransientSubagentContinuation, transientSubagentRetryDelayMs } = createRequire(import.meta.url)("./bin/subagent-timeout-policy.cjs"));
 	INITIAL_LAUNCH_LIMIT = 5;
 	INITIAL_LAUNCH_INTERVAL_MS = 700;
 	RATE_LIMIT_RETRY_FACTOR = 2;
 	RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS = 2e3;
 	RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS = 180 * 1e3;
 	RATE_LIMIT_SUSPENDED_REASON = "Provider rate limit; subagent requeued for retry.";
+	TRANSIENT_PROVIDER_SUSPENDED_REASON = "Transient provider interruption; subagent requeued for continuation.";
 	AGENT_SWARM_MAX_CONCURRENCY_ENV = "BLUN_AGENT_SWARM_MAX_CONCURRENCY";
 	SubagentBatch = class {
 		launcher;
@@ -251379,6 +251385,7 @@ var init_subagent_batch = __esmMin((() => {
 		normalLaunchCount = 0;
 		normalLaunchTimer;
 		rateLimitLaunchTimer;
+		transientRetryTimers = /* @__PURE__ */ new Set();
 		resolve;
 		reject;
 		finished = false;
@@ -251398,6 +251405,7 @@ var init_subagent_batch = __esmMin((() => {
 				index,
 				task,
 				retryCount: 0,
+				transientRetryCount: 0,
 				retryReadyAt: 0,
 				started: false
 			}));
@@ -251540,6 +251548,11 @@ var init_subagent_batch = __esmMin((() => {
 					agentId: handle.agentId,
 					error: this.attemptErrorMessage(attempt, error, "failed")
 				};
+				if (isRetryableSubagentFailure(error)) return {
+					type: "transient_provider",
+					agentId: handle.agentId,
+					error: this.attemptErrorMessage(attempt, error, "failed")
+				};
 				return this.failedAttemptOutcome(attempt, error);
 			}
 		}
@@ -251571,6 +251584,14 @@ var init_subagent_batch = __esmMin((() => {
 				this.requeueTimedOut(attempt, outcome.agentId);
 			}
 			else if ("status" in outcome) this.results[attempt.state.index] = outcome;
+			else if (outcome.type === "transient_provider" && shouldStopTransientSubagentContinuation(attempt.state.transientRetryCount)) this.results[attempt.state.index] = {
+				task: attempt.state.task,
+				agentId: outcome.agentId,
+				status: "failed",
+				state: "started",
+				error: `${outcome.error} Automatic continuation stopped after ${String(MAX_TRANSIENT_SUBAGENT_CONTINUATIONS)} attempts; agent ${outcome.agentId} remains resumable.`
+			};
+			else if (outcome.type === "transient_provider") this.requeueTransientProvider(attempt, outcome.agentId);
 			else if (shouldStopAutomaticRateLimitResume(attempt.state.retryCount)) this.results[attempt.state.index] = {
 				task: attempt.state.task,
 				agentId: outcome.agentId,
@@ -251604,6 +251625,26 @@ var init_subagent_batch = __esmMin((() => {
 			attempt.cleanup();
 			return true;
 		}
+		requeueTransientProvider(attempt, agentId) {
+			const state = attempt.state;
+			state.agentId = agentId;
+			state.retryAgentId = agentId;
+			state.transientRetryCount += 1;
+			this.launcher.suspended?.({
+				task: state.task,
+				agentId,
+				reason: TRANSIENT_PROVIDER_SUSPENDED_REASON
+			});
+			const retryDelay = transientSubagentRetryDelayMs(state.transientRetryCount);
+			const timer = setTimeout(() => {
+				this.transientRetryTimers.delete(timer);
+				if (this.finished || this.controller.signal.aborted) return;
+				state.retryReadyAt = 0;
+				this.pending.unshift(state);
+				this.schedule();
+			}, retryDelay);
+			this.transientRetryTimers.add(timer);
+		}
 		requeueRateLimited(attempt, agentId) {
 			const state = attempt.state;
 			state.agentId = agentId;
@@ -251714,6 +251755,8 @@ var init_subagent_batch = __esmMin((() => {
 			this.batchSignal?.removeEventListener("abort", this.batchAbortListener);
 			this.clearNormalTimer();
 			this.clearRateLimitTimer();
+			for (const timer of this.transientRetryTimers) clearTimeout(timer);
+			this.transientRetryTimers.clear();
 			for (const attempt of this.active.values()) attempt.cleanup();
 			this.active.clear();
 		}
@@ -262103,7 +262146,7 @@ var init_bash = __esmMin((() => {
 		MAX_TIMEOUT_S,
 		MAX_BACKGROUND_TIMEOUT_S
 	};
-	bash_default = "Execute a `{{ SHELL_NAME }}` command for pipes, environment variables, processes, git, package managers, build or test runners, and other genuine shell semantics.\n\nPrefer the dedicated tools when they fit: `Read` for a known file, `Write` to create or replace a file, `Edit` for exact changes, `Glob` to locate files, and `Grep` to search contents. Their output is bounded and their permissions are clearer.\n\nStdout and stderr are combined. Long output may be truncated. A non-zero command ends with its exit code; timeouts and user interrupts are reported separately.\n\nEach call runs in a fresh shell environment. Variables, `cd`, and shell history do not carry into later calls; pass `cwd` or use absolute paths. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s through `timeout`. Do not run interactive commands or commands that may run forever in the foreground.\n\nWith `run_in_background=true`, provide a short `description`; the tool returns a task ID and notifies you on completion. Background tasks default to {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s and allow up to {{ MAX_BACKGROUND_TIMEOUT_S }}s. Use `disable_timeout=true` only when no deadline is appropriate. Use `TaskOutput` for a status or output snapshot and `TaskStop` only to cancel. After launch, normally return control instead of immediately waiting.\n\nQuote paths containing spaces. Chain dependent commands with `&&`; issue independent read-only checks as parallel tool calls. Use `;`, `||`, pipes, redirects, and shell control flow when their semantics are required.\n\nStay inside the working directory unless the user explicitly requests otherwise. Avoid `..`, and never require superuser privileges without explicit instruction. Command availability depends on the host; verify unfamiliar commands before relying on them.";
+	bash_default = "Execute a `{{ SHELL_NAME }}` command for pipes, environment variables, processes, git, package managers, build or test runners, and other genuine shell semantics.\n\nPrefer the dedicated tools when they fit: `Read` for a known file, `Write` to create or replace a file, `Edit` for exact changes, `Glob` to locate files, and `Grep` to search contents. Their output is bounded and their permissions are clearer.\n\nStdout and stderr are combined. Long foreground output is streamed to a private file; capture stops at a safe size while the command continues to its real exit code. A non-zero command ends with its exit code; timeouts and user interrupts are reported separately.\n\nEach call runs in a fresh shell environment. Variables, `cd`, and shell history do not carry into later calls; pass `cwd` or use absolute paths. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s through `timeout`. Do not run interactive commands or commands that may run forever in the foreground.\n\nWith `run_in_background=true`, provide a short `description`; the tool returns a task ID and notifies you on completion. Background tasks default to {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s and allow up to {{ MAX_BACKGROUND_TIMEOUT_S }}s. Use `disable_timeout=true` only when no deadline is appropriate. Use `TaskOutput` for a status or output snapshot and `TaskStop` only to cancel. After launch, normally return control instead of immediately waiting.\n\nQuote paths containing spaces. Chain dependent commands with `&&`; issue independent read-only checks as parallel tool calls. Use `;`, `||`, pipes, redirects, and shell control flow when their semantics are required.\n\nStay inside the working directory unless the user explicitly requests otherwise. Avoid `..`, and never require superuser privileges without explicit instruction. Command availability depends on the host; verify unfamiliar commands before relying on them.";
 	BashTool = class {
 		kaos;
 		cwd;
@@ -262269,8 +262312,10 @@ var init_bash = __esmMin((() => {
 			if (!result.truncated) return result;
 			const output = await this.backgroundManager.getOutputSnapshot(taskId, 0);
 			if (!output.fullOutputAvailable || output.outputPath === void 0) return result;
+			const captureCapped = this.backgroundManager.getTask(taskId)?.outputCaptureCapped === true;
 			const taskOutputHint = this.allowBackground ? `, or TaskOutput(task_id="${taskId}", block=false)` : "";
-			const reference = `\n\n[Full output saved]\ntask_id: ${taskId}\noutput_path: ${output.outputPath}\noutput_size_bytes: ${String(output.outputSizeBytes)}\nnext_step: Use Read with output_path to page through the full log${taskOutputHint}.`;
+			const captureNotice = captureCapped ? `\n[Capture capped at ${String(MAX_FOREGROUND_CAPTURE_BYTES)} bytes. Additional output was discarded, but the command continued to its real exit code.]` : "";
+			const reference = `\n\n[Full output saved]\ntask_id: ${taskId}\noutput_path: ${output.outputPath}\noutput_size_bytes: ${String(output.outputSizeBytes)}${captureNotice}\nnext_step: Use Read with output_path to page through the full log${taskOutputHint}.`;
 			return {
 				...result,
 				output: `${result.output}${reference}`

package/package.json

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