blun-king-cli 9.1.412 → 9.1.414

package/LIESMICH.txt

@@ -467,6 +467,22 @@ Weiterarbeiten nutzen. Begrüßungen, gewöhnliche Einzelschrittanfragen und vag
 Aufgaben erzeugen weiterhin kein Ziel. Der Problemrahmen bleibt beschreibender
 Arbeitsstand und erteilt niemals Berechtigungen.
 
+Ab BLUN King 9.1.413 werden Antworten aus Telegram-Zügen nicht mehr als fertig
+versendet, wenn der letzte Modellschritt am Ausgabelimit max_tokens endete. Der
+unvollständige Entwurf bleibt ausschließlich im Sitzungskontext. King erstellt
+daraus automatisch eine kurze, vollständige Antwort und sendet erst diese.
+Bereits über das Reply-Werkzeug zugestellte Antworten werden dabei nicht
+wiederholt. Die Fortsetzung ist auf drei Versuche begrenzt; danach wird niemals
+ein abgeschnittener Text als Ergebnis ausgegeben.
+
+Ab BLUN King 9.1.414 trägt jeder neue dauerhafte Aktions-Checkpoint zusätzlich
+den genauen Auslöser für seinen nächsten Schritt. Außerhalb einer Wartephase
+muss dieser Auslöser „sofort“ sein. Eine Wartephase benennt stattdessen ein
+äußeres Ereignis, einen Zeitpunkt, eine Abhängigkeit oder eine ausstehende
+Nutzerentscheidung. Auslöser und Bedingung bleiben bei Fortsetzung und Neustart
+erhalten, ohne Berechtigungen zu erteilen. Bereits gespeicherte ältere
+Checkpoints bleiben lesbar.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/README.md

@@ -473,6 +473,22 @@ Weiterarbeiten nutzen. Begrüßungen, gewöhnliche Einzelschrittanfragen und vag
 Aufgaben erzeugen weiterhin kein Ziel. Der Problemrahmen bleibt beschreibender
 Arbeitsstand und erteilt niemals Berechtigungen.
 
+Ab BLUN King 9.1.413 werden Antworten aus Telegram-Zügen nicht mehr als fertig
+versendet, wenn der letzte Modellschritt am Ausgabelimit `max_tokens` endete.
+Der unvollständige Entwurf bleibt ausschließlich im Sitzungskontext. King
+erstellt daraus automatisch eine kurze, vollständige Antwort und sendet erst
+diese. Bereits über das Reply-Werkzeug zugestellte Antworten werden dabei nicht
+wiederholt. Die Fortsetzung ist auf drei Versuche begrenzt; danach wird niemals
+ein abgeschnittener Text als Ergebnis ausgegeben.
+
+Ab BLUN King 9.1.414 trägt jeder neue dauerhafte Aktions-Checkpoint zusätzlich
+den genauen Auslöser für seinen nächsten Schritt. Außerhalb einer Wartephase
+muss dieser Auslöser „sofort“ sein. Eine Wartephase benennt stattdessen ein
+äußeres Ereignis, einen Zeitpunkt, eine Abhängigkeit oder eine ausstehende
+Nutzerentscheidung. Auslöser und Bedingung bleiben bei Fortsetzung und Neustart
+erhalten, ohne Berechtigungen zu erteilen. Bereits gespeicherte ältere
+Checkpoints bleiben lesbar.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/bin/cognitive-action-checkpoint.cjs

@@ -9,14 +9,18 @@ const EVIDENCE_BASES = new Set([
 const EPISTEMIC_STATES = new Set([
   'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown',
 ]);
+const TRIGGER_KINDS = new Set([
+  'immediate', 'external_event', 'time', 'dependency', 'user_decision',
+]);
 const MODEL_KEYS = new Set([
-  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'problemFrame', 'updatedAt',
+  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'nextTrigger', 'problemFrame', 'updatedAt',
 ]);
 const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
 const PROBLEM_FRAME_KEYS = new Set([
   'successCriterion', 'missingKnowledge', 'candidateActions', 'selectedAction',
   'selectionReason', 'supportChoice', 'risk', 'reversibility',
 ]);
+const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition']);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
@@ -77,6 +81,27 @@ function normalizeProblemFrame(input) {
   });
 }
 
+function normalizeNextTrigger(input, phase) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('nextTrigger must be an object');
+  }
+  for (const key of Object.keys(input)) {
+    if (!NEXT_TRIGGER_KEYS.has(key)) throw new TypeError(`nextTrigger field is unsupported: ${key}`);
+  }
+  const kind = String(input.kind ?? '').trim();
+  if (!TRIGGER_KINDS.has(kind)) throw new TypeError('nextTrigger kind is invalid');
+  if (phase === 'wait' && kind === 'immediate') {
+    throw new TypeError('wait phase requires a non-immediate nextTrigger');
+  }
+  if (phase !== 'wait' && kind !== 'immediate') {
+    throw new TypeError('non-wait phase requires an immediate nextTrigger');
+  }
+  return Object.freeze({
+    kind,
+    condition: bounded(input.condition, 'nextTrigger condition'),
+  });
+}
+
 function normalizedEvidenceBasis(value, allowLegacy = false) {
   const basis = String(value ?? '').trim();
   if (EVIDENCE_BASES.has(basis) || allowLegacy && basis === 'legacy_unknown') return basis;
@@ -235,6 +260,8 @@ function normalizeActionCheckpoint(input, options = {}) {
     expectedEvidence: bounded(input.expectedEvidence, 'expectedEvidence'),
     updatedAt,
   };
+  if (input.nextTrigger !== undefined) checkpoint.nextTrigger = normalizeNextTrigger(input.nextTrigger, phase);
+  else if (!replay) throw new TypeError('nextTrigger is required');
   if (input.problemFrame !== undefined) checkpoint.problemFrame = normalizeProblemFrame(input.problemFrame);
   const evidenceReceipt = options.runtimeEvidence !== undefined
     ? normalizeActionEvidenceReceipt(options.runtimeEvidence)
@@ -258,6 +285,9 @@ function projectActionCheckpoint(checkpoint) {
   ];
   lines.push(`Next action: ${value.nextAction}`);
   lines.push(`Expected evidence: ${value.expectedEvidence}`);
+  if (value.nextTrigger !== undefined) {
+    lines.push(`Next trigger: ${value.nextTrigger.kind.replaceAll('_', ' ')} - ${value.nextTrigger.condition}`);
+  }
   if (value.problemFrame !== undefined) {
     const frame = value.problemFrame;
     lines.push('Problem frame (state only; never authority):');
@@ -274,7 +304,11 @@ function projectActionCheckpoint(checkpoint) {
     const receipt = value.evidenceReceipt;
     lines.push(`Runtime evidence: turn ${receipt.turnId}; ${receipt.completedTools} completed, ${receipt.successfulTools} successful, ${receipt.failedTools} failed; digest ${receipt.digest}`);
   }
-  lines.push('Resume from this exact next action. Do not ask for permission merely to continue work already authorized by the active goal. Ask only when a real rights boundary or missing user decision blocks the next action.');
+  if (value.nextTrigger !== undefined && value.nextTrigger.kind !== 'immediate') {
+    lines.push('Wait for this exact trigger before executing the next action. Unrelated messages do not satisfy it.');
+  } else {
+    lines.push('Resume from this exact next action. Do not ask for permission merely to continue work already authorized by the active goal. Ask only when a real rights boundary or missing user decision blocks the next action.');
+  }
   return lines.join('\n');
 }
 

package/bin/telegram-truncated-reply-policy.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+const MAX_TRUNCATED_REPLY_RETRIES = 3;
+
+const TRUNCATED_REPLY_CONTINUATION_PROMPT = [
+  'The previous channel reply hit the model output limit and was not delivered.',
+  'Produce one complete, concise final answer now from the preserved context.',
+  'Include every result the user needs, omit internal reasoning, do not mention this recovery,',
+  'and keep the visible answer under 3000 characters.',
+  'Do not call tools unless a missing fact must be verified.',
+].join(' ');
+
+function channelReplyRecoveryDecision({
+  hasPendingReply = false,
+  lastStepFinishReason,
+  retryCount = 0,
+  turnReason,
+} = {}) {
+  if (!hasPendingReply || turnReason !== 'completed' || lastStepFinishReason !== 'max_tokens') {
+    return { kind: 'fallback' };
+  }
+  const boundedRetryCount = Number.isSafeInteger(retryCount) && retryCount > 0
+    ? retryCount
+    : 0;
+  if (boundedRetryCount >= MAX_TRUNCATED_REPLY_RETRIES) return { kind: 'exhausted' };
+  return {
+    kind: 'retry',
+    nextRetryCount: boundedRetryCount + 1,
+    prompt: TRUNCATED_REPLY_CONTINUATION_PROMPT,
+  };
+}
+
+module.exports = {
+  MAX_TRUNCATED_REPLY_RETRIES,
+  TRUNCATED_REPLY_CONTINUATION_PROMPT,
+  channelReplyRecoveryDecision,
+};

package/blun.mjs

@@ -231135,7 +231135,8 @@ function buildGoalReminder(goal) {
 	if (checkpointProjection !== null) {
 		lines.push("");
 		lines.push(checkpointProjection);
-		lines.push("Execute the exact checkpointed next action before exploring alternatives. Update the checkpoint only after new evidence changes the verified state.");
+		if (goal.actionCheckpoint?.nextTrigger?.kind === "immediate" || goal.actionCheckpoint?.nextTrigger === void 0) lines.push("Execute the exact checkpointed next action before exploring alternatives. Update the checkpoint only after new evidence changes the verified state.");
+		else lines.push("Keep the goal active, but do not execute the next action until its projected trigger is observed. Unrelated messages do not satisfy that trigger.");
 	}
 	const budget = goal.budget;
 	const budgetLines = [];
@@ -245762,6 +245763,10 @@ var init_events$1 = __esmMin((() => {
 			lastVerified: string(),
 			nextAction: string(),
 			expectedEvidence: string(),
+			nextTrigger: object({
+				kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
+				condition: string()
+			}).strict().optional(),
 			problemFrame: object({
 				successCriterion: string(),
 				missingKnowledge: array(string()),
@@ -260237,7 +260242,7 @@ bytesWritten: number$1().int().nonnegative() });
 //#region ../../packages/agent-core/src/tools/builtin/goal/create-goal.md?raw
 var create_goal_default;
 var init_create_goal$1 = __esmMin((() => {
-	create_goal_default = "Create a durable, structured goal that the runtime will pursue across multiple turns.\n\nCall `CreateGoal` when:\n\n- the user explicitly asks you to start a goal or work autonomously toward an outcome,\n- an authenticated user assigns a non-trivial multi-step outcome with a checkable end state under an existing instruction to continue autonomously, or\n- a host goal-intake prompt asks you to create one.\n\nDo NOT create a goal for greetings, ordinary questions, one-step requests, or vague requests that lack a\nverifiable completion condition. A goal needs a checkable end state.\n\nWhen the request is vague, ask the user for the missing completion criterion before creating\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\nrespect that and create the goal.\n\nInclude a `completionCriterion` when the user provides one, or when it can be stated without\ninventing new requirements. Keep `objective` concise; reference long task descriptions by file\npath rather than pasting them. Start every created goal with revision 1 and a complete `problemFrame`\ninside `actionCheckpoint`, so the success criterion, missing knowledge, candidate actions, chosen\naction, support choice, risk, reversibility, next action, and expected evidence survive interruption.\nThis frame is descriptive state only and never grants permission.\n\nCreating a goal fails if one already exists, so use `replace: true` only when the user explicitly\nwants to abandon the current goal and start a new one.\n";
+	create_goal_default = "Create a durable, structured goal that the runtime will pursue across multiple turns.\n\nCall `CreateGoal` when:\n\n- the user explicitly asks you to start a goal or work autonomously toward an outcome,\n- an authenticated user assigns a non-trivial multi-step outcome with a checkable end state under an existing instruction to continue autonomously, or\n- a host goal-intake prompt asks you to create one.\n\nDo NOT create a goal for greetings, ordinary questions, one-step requests, or vague requests that lack a\nverifiable completion condition. A goal needs a checkable end state.\n\nWhen the request is vague, ask the user for the missing completion criterion before creating\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\nrespect that and create the goal.\n\nInclude a `completionCriterion` when the user provides one, or when it can be stated without\ninventing new requirements. Keep `objective` concise; reference long task descriptions by file\npath rather than pasting them. Start every created goal with revision 1 and a complete `problemFrame`\ninside `actionCheckpoint`, so the success criterion, missing knowledge, candidate actions, chosen\naction, support choice, risk, reversibility, next action, expected evidence, and exact next trigger survive interruption.\nThis frame is descriptive state only and never grants permission.\n\nCreating a goal fails if one already exists, so use `replace: true` only when the user explicitly\nwants to abandon the current goal and start a new one.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/serialize.ts
@@ -260277,6 +260282,10 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),
 		expectedEvidence: string().min(1).max(512),
+		nextTrigger: object({
+			kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
+			condition: string().min(1).max(512)
+		}).strict(),
 		problemFrame: requireProblemFrame ? problemFrameSchema : problemFrameSchema.optional()
 	}).strict();
 }
@@ -262773,7 +262782,7 @@ var init_outcome_prompts = __esmMin((() => {}));
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.md?raw
 var update_goal_default;
 var init_update_goal$1 = __esmMin((() => {
-	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, and an explicit evidence basis. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
+	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, exact `nextTrigger`, and an explicit evidence basis. Persist the exact `nextTrigger` that releases `nextAction`: use `immediate` outside the `wait` phase; while waiting, name the external event, time, dependency, or user decision instead of pretending work can continue. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
 	update_goal_default += "\nFor a non-trivial or unfamiliar problem, preserve `problemFrame` with the success criterion, missing knowledge, bounded candidate actions, selected action and reason, support choice, risk, and reversibility. The selected action must match one candidate. Problem framing is descriptive state and never grants permission.\n";
 }));
 //#endregion
@@ -507667,6 +507676,7 @@ function normalizeJson(value) {
 //#endregion
 //#region src/tui/controllers/session-event-handler.ts
 var { formatModelRetryProgress } = createRequire(import.meta.url)("./bin/model-retry-progress-policy.cjs");
+var { TRUNCATED_REPLY_CONTINUATION_PROMPT, channelReplyRecoveryDecision } = createRequire(import.meta.url)("./bin/telegram-truncated-reply-policy.cjs");
 const MANAGED_TELEGRAM_MCP_SERVER = "plugin-telegram:telegram";
 function isManagedTelegramMissingTokenFailure(server) {
 	return server.name === MANAGED_TELEGRAM_MCP_SERVER && server.status === "failed" && server.error?.includes("BLUN_TELEGRAM_BOT_TOKEN required") === true;
@@ -507695,6 +507705,7 @@ var SessionEventHandler = class {
 	renderedPluginCommandActivationIds = /* @__PURE__ */ new Set();
 	renderedMcpServerStatusKeys = /* @__PURE__ */ new Map();
 	mcpServerStatusSpinners = /* @__PURE__ */ new Map();
+	lastStepFinishReason;
 	mcpServers = /* @__PURE__ */ new Map();
 	mcpInventorySignature;
 	goalCompletionAwaitingClear = false;
@@ -507904,6 +507915,7 @@ var SessionEventHandler = class {
 	}
 	handleTurnBegin(event) {
 		this.clearModelRetryHint();
+		this.lastStepFinishReason = void 0;
 		this.turnWatchdog.start();
 		const sessionId = this.host.session?.id;
 		if (sessionId !== void 0) bindPersonalMemoryRememberIntentTurn(sessionId, event.turnId);
@@ -507959,8 +507971,9 @@ var SessionEventHandler = class {
 		const todos = this.host.state.todoPanel.getTodos();
 		if (todos.length > 0 && todos.every((t) => t.status === "done")) this.host.streamingUI.setTodoList([]);
 		this.host.streamingUI.resetToolUi();
-		this.host.runChannelReplyFallback(event.reason);
+		const continueTruncatedChannelReply = this.host.runChannelReplyFallback(event.reason, this.lastStepFinishReason);
 		this.host.streamingUI.finalizeTurn(sendQueued);
+		if (continueTruncatedChannelReply) this.host.continueTruncatedChannelReply();
 		if (shouldShowMetrics) this.appendTurnMetrics(event);
 		this.renderPendingModelBlockedFallback();
 		this.currentTurnHasAssistantText = false;
@@ -507990,6 +508003,7 @@ var SessionEventHandler = class {
 	}
 	handleStepCompleted(event) {
 		this.clearModelRetryHint();
+		this.lastStepFinishReason = event.finishReason;
 		this.host.streamingUI.flushNow();
 		if (event.usage !== void 0) this.currentTurnTokenCount = (this.currentTurnTokenCount ?? 0) + totalTokenUsage(event.usage);
 		this.maybeShowDebugTiming(event);
@@ -517625,10 +517639,11 @@ var BlunTUI = class {
 			if (sent && this.pendingChannelReplyGuard === guard) guard.outboxMarker = outboxMarker();
 		});
 	}
-	runChannelReplyFallback(reason) {
+	runChannelReplyFallback(reason, lastStepFinishReason) {
 		const guards = [...this.pendingChannelReplyGuards];
 		this.pendingChannelReplyGuards = [];
-		if (guards.length === 0) return;
+		if (guards.length === 0) return false;
+		let continueTruncatedReply = false;
 		const latestByChat = /* @__PURE__ */ new Map();
 		for (const guard of guards) latestByChat.set(guard.chatId, guard);
 		for (const guard of latestByChat.values()) {
@@ -517639,7 +517654,6 @@ var BlunTUI = class {
 				this.channelMediaDeliveryFailures.delete(deliveryKey);
 				if (!outboxDeliveredFile(guard.outboxMarker, guard.chatId, filePath)) this.showError(uiText("blunTui.session.sendFailed", { error: "Telegram media" }));
 			}
-			if (reason !== "completed") continue;
 			if (this.state.transcriptEntries.slice(guard.transcriptStart).some((entry) => {
 				if (entry.kind !== "tool_call") return false;
 				if (!/(?:^|__|:)(?:reply|edit_message)$/i.test(entry.toolCallData?.name ?? "")) return false;
@@ -517649,6 +517663,24 @@ var BlunTUI = class {
 				if (guard.directFocus === true) this.directFocusController.noteReplyDelivered(guard.chatId);
 				continue;
 			}
+			const decision = channelReplyRecoveryDecision({
+				hasPendingReply: true,
+				lastStepFinishReason,
+				retryCount: guard.truncationRetryCount,
+				turnReason: reason
+			});
+			if (decision.kind === "retry") {
+				guard.truncationRetryCount = decision.nextRetryCount;
+				guard.transcriptStart = this.state.transcriptEntries.length;
+				this.pendingChannelReplyGuards.push(guard);
+				continueTruncatedReply = true;
+				continue;
+			}
+			if (decision.kind === "exhausted") {
+				this.showError("Telegram reply recovery exhausted after repeated max_tokens responses.");
+				continue;
+			}
+			if (reason !== "completed") continue;
 			const finalText = this.state.transcriptEntries.slice(guard.transcriptStart).filter((entry) => entry.kind === "assistant" && entry.content.trim().length > 0).map((entry) => entry.content.trim()).at(-1) ?? "";
 			if (finalText.length === 0) continue;
 			sendReplyFallback(guard.chatId, finalText, guard.contextOnly).then((sent) => {
@@ -517657,6 +517689,28 @@ var BlunTUI = class {
 				this.showStatus(uiText("blunTui.telegram.fallbackDelivered"));
 			});
 		}
+		return continueTruncatedReply;
+	}
+	continueTruncatedChannelReply() {
+		const session = this.session;
+		if (session === void 0) {
+			this.failTruncatedChannelReplyRecovery(new Error("session unavailable"));
+			return;
+		}
+		this.beginSessionRequest();
+		this.setAppState({
+			model: BLUN_KING_MODEL_ALIAS,
+			modelFallbackAllowed: false
+		});
+		session.promptAccepted(TRUNCATED_REPLY_CONTINUATION_PROMPT).then((result) => {
+			if (!result.accepted) this.failTruncatedChannelReplyRecovery(new Error("continuation prompt rejected"));
+		}).catch((error) => {
+			this.failTruncatedChannelReplyRecovery(error);
+		});
+	}
+	failTruncatedChannelReplyRecovery(error) {
+		this.pendingChannelReplyGuards = [];
+		this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
 	}
 	/**
 	* Attach the Telegram channel to this TUI when a bot token is configured.

package/package.json

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