blun-king-cli 9.1.515 → 9.1.516

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 9.1.516 - 2026-08-31
+
+- Caps the first tool-capable turn's wait for the initial MCP catalogue at 2.5 seconds, so a cold optional desktop server can finish in the background instead of blocking Read, Bash, Grep, TodoList, Telegram, and AgentSpine.
+- Verifies and installs AgentSpine only for the active profile at startup; dormant profiles are verified when they are launched, preventing startup time from growing with abandoned proof profiles.
+- Reuses the immutable packaged plugin source snapshot across managed-plugin checks while still reading and byte-verifying every active installed plugin tree, and logs each MCP server's startup status for reproducible timing evidence.
+- Retires an active-steer queue entry exactly once as soon as the core has durably accepted its `turn.steer`, instead of restoring an already delivered message after a 15-second UI confirmation timeout; genuine rejections remain queued.
+- Restarts an owned Telegram bridge after an unexpected exit or launch error with one deduplicated timer, while ownership loss and normal shutdown still prevent respawn.
+- Reconstructs a missing assistant step when a persisted `content.part` or tool call follows full compaction without its `step.begin`, preserving the continuation instead of making `king -c` fail during replay.
+- Allows only the first TodoList write in a model step, preventing parallel list replacements from racing while leaving read-only list queries untouched.
+- Extends the package gates for Ctrl+S, Escape, durable queue acknowledgement, rejection replay, stable urgent/direct/addressed/bot/normal priority, Todo lifecycle, visible pending markers, valid initial Todo state, and single-bridge recovery.
+
 ## 9.1.515 - 2026-08-31
 
 - Accepts a truthful unchanged TodoList during mandatory maintenance instead of terminating the turn after five identical retries.

package/LIESMICH.txt

@@ -9,11 +9,11 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.515
+  npm install -g blun-king-cli@9.1.516
 
 AgentSpine 0.10.1
 -----------------
-Version 9.1.515 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.516 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 Start
 -----

package/README.md

@@ -9,12 +9,12 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.515
+npm install -g blun-king-cli@9.1.516
 ```
 
 ## AgentSpine 0.10.1
 
-Version 9.1.515 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.516 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 ## Reproduzierbares Staging und Packen
 

package/bin/launcher-runtime.js

@@ -282,36 +282,13 @@ function installAgentSpineForProfile(packageRoot, blunDir) {
   installManagedAgentSpinePlugin({ packageRoot, blunDir });
 }
 
-function installAgentSpineForExistingProfiles(packageRoot, sharedHome, currentProfileHome) {
-  const profileRoot = path.join(sharedHome, 'profile');
-  const profileHomes = new Map();
-  const addProfileHome = (profileHome) => {
-    const resolved = path.resolve(profileHome);
-    const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
-    profileHomes.set(key, resolved);
-  };
-
-  addProfileHome(currentProfileHome);
-  if (fs.existsSync(profileRoot)) {
-    for (const entry of fs.readdirSync(profileRoot, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-      let profileHome;
-      try {
-        profileHome = resolveProfilePaths(sharedHome, entry.name).home;
-      } catch {
-        continue;
-      }
-      const stat = fs.lstatSync(profileHome);
-      if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
-      addProfileHome(profileHome);
-    }
-  }
-
-  for (const profileHome of profileHomes.values()) {
-    ensurePrivateDirectory(profileHome);
-    installAgentSpineForProfile(packageRoot, profileHome);
-  }
-  return [...profileHomes.values()];
+function installAgentSpineForExistingProfiles(packageRoot, _sharedHome, currentProfileHome) {
+  // A dormant profile is verified when that profile is launched. Rescanning all
+  // profiles here makes every startup slower as old profiles accumulate.
+  const profileHome = path.resolve(currentProfileHome);
+  ensurePrivateDirectory(profileHome);
+  installAgentSpineForProfile(packageRoot, profileHome);
+  return [profileHome];
 }
 
 function createManagedNodeEnvironment(binary, env = process.env, platform = process.platform) {

package/bin/plugin-bootstrap.js

@@ -11,6 +11,8 @@ const {
   writePrivateFile,
 } = require('./private-paths');
 
+const managedPluginSourceSnapshots = new Map();
+
 function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -42,9 +44,18 @@ function snapshotPluginTree(root) {
   return visit(root) ? entries : null;
 }
 
+function snapshotManagedPluginSource(root) {
+  const resolvedRoot = path.resolve(root);
+  const cacheKey = process.platform === 'win32' ? resolvedRoot.toLowerCase() : resolvedRoot;
+  if (!managedPluginSourceSnapshots.has(cacheKey)) {
+    managedPluginSourceSnapshots.set(cacheKey, snapshotPluginTree(resolvedRoot));
+  }
+  return managedPluginSourceSnapshots.get(cacheKey);
+}
+
 function pluginTreesAreIdentical(sourceRoot, pluginRoot) {
   try {
-    const source = snapshotPluginTree(sourceRoot);
+    const source = snapshotManagedPluginSource(sourceRoot);
     const installed = snapshotPluginTree(pluginRoot);
     if (source === null || installed === null || source.length !== installed.length) return false;
     return source.every((entry, index) => {
@@ -59,7 +70,7 @@ function pluginTreesAreIdentical(sourceRoot, pluginRoot) {
 }
 
 function pluginTreeDigest(root) {
-  const entries = snapshotPluginTree(root);
+  const entries = snapshotManagedPluginSource(root);
   if (entries === null) throw new Error(`Invalid managed plugin tree: ${root}`);
   const hash = createHash('sha256');
   for (const entry of entries) {

package/bin/todo-list-turn-policy.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const TODO_LIST_TOOL_NAME = 'TodoList';
+
+function enforceSingleTodoWritePerStep(context) {
+  if (context?.toolCall?.name !== TODO_LIST_TOOL_NAME) return undefined;
+  if (!Array.isArray(context.args?.todos)) return undefined;
+
+  const todoWrites = Array.isArray(context.toolCalls)
+    ? context.toolCalls.filter((call) => call?.name === TODO_LIST_TOOL_NAME)
+    : [];
+  if (todoWrites.length <= 1) return undefined;
+  if (context.toolCall.id === todoWrites[0]?.id) return undefined;
+
+  return {
+    block: true,
+    reason: 'Only one TodoList write is allowed per model step. Use the first update, then continue from its stored result in the next step.',
+  };
+}
+
+module.exports = { enforceSingleTodoWritePerStep };

package/blun.mjs

@@ -79167,6 +79167,25 @@ var init_context$2 = __esmMin((() => {
 		closeAbandonedToolExchange(output) {
 			return this.closePendingToolResults(output).length;
 		}
+		recoverMissingOpenStep(event) {
+			const resolvedStepUuid = resolveStepEventUuid(this.openSteps, event);
+			const existingStep = this.openSteps.get(resolvedStepUuid);
+			if (existingStep !== void 0) return existingStep;
+			const recoveredStepUuid = event.stepUuid ?? `recovered-${this._history.length}-${event.type}`;
+			const message = {
+				role: "assistant",
+				content: [],
+				toolCalls: []
+			};
+			this.pushHistory(message);
+			this.openSteps.set(recoveredStepUuid, message);
+			this.agent.log.warn("recovered loop event without step.begin", {
+				eventType: event.type,
+				stepUuid: event.stepUuid,
+				restoring: this.agent.records.restoring !== null
+			});
+			return message;
+		}
 		appendLoopEvent(event) {
 			this.agent.records.logRecord({
 				type: "context.append_loop_event",
@@ -79208,17 +79227,13 @@ var init_context$2 = __esmMin((() => {
 					return;
 				}
 				case "content.part": {
-					const stepEventUuid = resolveStepEventUuid(this.openSteps, event);
-					const openStep = this.openSteps.get(stepEventUuid);
-					if (openStep === void 0) throw new Error(`Received content_part for unknown step_uuid '${stepEventUuid}' (no open step_begin)`);
+					const openStep = this.recoverMissingOpenStep(event);
 						openStep.content.push(event.part);
 						this.markPendingTokenEstimateDirty();
 					return;
 				}
 				case "tool.call": {
-					const stepEventUuid = resolveStepEventUuid(this.openSteps, event);
-					const openStep = this.openSteps.get(stepEventUuid);
-					if (openStep === void 0) throw new Error(`Received tool_call for unknown step_uuid '${stepEventUuid}' (no open step_begin)`);
+					const openStep = this.recoverMissingOpenStep(event);
 						openStep.toolCalls.push({
 						type: "function",
 						id: event.toolCallId,
@@ -261610,6 +261625,13 @@ function blunTurnNeedsInitialMcp(input, origin) {
 	if (blunTurnNeedsTools(input, origin)) return true;
 	return BLUN_TELEGRAM_CHANNEL_RE.test(blunExtractText(input)) || blunTurnHasAttachment(input);
 }
+async function blunWaitForInitialMcpBudget(mcp, signal) {
+	if (mcp === void 0) return;
+	await Promise.race([
+		mcp.waitForInitialLoad(signal),
+		new Promise((resolve) => setTimeout(resolve, 2500))
+	]);
+}
 function blunMessageTextChars(message) {
 	return message.content.reduce((total, part) => total + (part.type === "text" ? part.text.length : 0), 0);
 }
@@ -261919,7 +261941,7 @@ function durablePromptOrigin(origin) {
 	void externalReportSources;
 	return durableOrigin;
 }
-var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, enforceSingleTodoWritePerStep, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -261937,6 +261959,7 @@ var init_turn = __esmMin((() => {
 	init_user_message_offload();
 	init_assistant_message_offload();
 	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
+	({ enforceSingleTodoWritePerStep } = createRequire(import.meta.url)("./bin/todo-list-turn-policy.cjs"));
 	({ projectRecurringCronHistory } = createRequire(import.meta.url)("./bin/recurring-cron-history-policy.cjs"));
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.cjs"));
@@ -262750,7 +262773,7 @@ var init_turn = __esmMin((() => {
 			let goalOutcomeMessageContinuationUsed = false;
 			const directReplyTurnStop = createDirectReplyTurnStop(blunExtractText(input));
 			const deduper = new ToolCallDeduplicator({ telemetry: this.agent.telemetry });
-			if (blunTurnNeedsInitialMcp(input, origin)) await this.agent.mcp?.waitForInitialLoad(signal);
+			if (blunTurnNeedsInitialMcp(input, origin)) await blunWaitForInitialMcpBudget(this.agent.mcp, signal);
 			const personalMemoryRecall = await this.agent.injection.injectPersonalMemoryForTurn(turnId, input, origin, signal);
 			await this.agent.injection.injectGoal();
 			const cognitiveProjection = this.projectCognitiveState(turnId, input);
@@ -262953,6 +262976,8 @@ var init_turn = __esmMin((() => {
 								return { continue: false };
 							},
 							prepareToolExecution: async (ctx) => {
+								const todoTurnPolicy = enforceSingleTodoWritePerStep(ctx);
+								if (todoTurnPolicy !== void 0) return todoTurnPolicy;
 								const goalTodoPolicy = enforceGoalTodoPolicy(this.agent, ctx);
 								if (goalTodoPolicy !== void 0) return goalTodoPolicy;
 								const ideaPolicy = enforceIdeaToolPolicy(this.agent, ctx);
@@ -298308,6 +298333,11 @@ var init_session$1 = __esmMin((() => {
 			});
 		}
 		onMcpServerStatusChange(entry) {
+			this.log.info("mcp server startup status", {
+				server: entry.name,
+				status: entry.status,
+				toolCount: entry.toolCount
+			});
 			this.rpc.emitEvent({
 				type: "mcp.server.status",
 				agentId: "main",
@@ -419872,7 +419902,7 @@ const OWNERSHIP_SETTLE_MS = 50;
 const OWNERSHIP_HANDOFF_WARNING_MS = 5e3;
 const BRIDGE_STOP_TIMEOUT_MS = 2500;
 const BRIDGE_FORCE_STOP_TIMEOUT_MS = 500;
-const CHANNEL_STEER_CONFIRM_TIMEOUT_MS = 15e3;
+const BRIDGE_RESTART_DELAY_MS = 1e3;
 const CHANNEL_DELIVERY_MAX_FAILURES = 3;
 const BLUN_NODE_FALLBACK_SUBCOMMAND = "__plugin_run_node";
 function isBlunNativeBinary(execPath) {
@@ -419990,6 +420020,7 @@ var TelegramChannelController = class {
 	ownershipTimer;
 	activationTimer;
 	handoffTimer;
+	bridgeRestartTimer;
 	offset = 0;
 	checkpointOffset = 0;
 	queueFileId = "";
@@ -420006,6 +420037,7 @@ var TelegramChannelController = class {
 	spawnBridge;
 	bridgeStopTimeoutMs;
 	bridgeForceStopTimeoutMs;
+	bridgeRestartDelayMs;
 	ownerId;
 	ownershipPollMs;
 	ownershipSettleMs;
@@ -420017,6 +420049,7 @@ var TelegramChannelController = class {
 		this.spawnBridge = options.spawnBridge ?? spawn;
 		this.bridgeStopTimeoutMs = options.bridgeStopTimeoutMs ?? BRIDGE_STOP_TIMEOUT_MS;
 		this.bridgeForceStopTimeoutMs = options.bridgeForceStopTimeoutMs ?? BRIDGE_FORCE_STOP_TIMEOUT_MS;
+		this.bridgeRestartDelayMs = options.bridgeRestartDelayMs ?? BRIDGE_RESTART_DELAY_MS;
 		this.ownerId = options.ownerId ?? randomUUID();
 		this.ownershipPollMs = options.ownershipPollMs ?? OWNERSHIP_POLL_MS;
 		this.ownershipSettleMs = options.ownershipSettleMs ?? OWNERSHIP_SETTLE_MS;
@@ -420192,6 +420225,7 @@ var TelegramChannelController = class {
 		if (this.ownershipTimer !== void 0) clearInterval(this.ownershipTimer);
 		if (this.activationTimer !== void 0) clearTimeout(this.activationTimer);
 		if (this.handoffTimer !== void 0) clearTimeout(this.handoffTimer);
+		if (this.bridgeRestartTimer !== void 0) clearTimeout(this.bridgeRestartTimer);
 		try {
 			if (parseInt(readFileSync(this.leaseFile, "utf8"), 10) === process.pid) rmSync(this.leaseFile);
 		} catch {}
@@ -420362,6 +420396,15 @@ var TelegramChannelController = class {
 	* (it will see our fresh lease and route to us). Otherwise start one bridge
 	* owned by this controller; shutdown never signals a pre-existing process.
 	*/
+	scheduleBridgeRestart() {
+		if (this.stopped || !this.activeOwner || !this.ownsChannel() || this.bridgeRestartTimer !== void 0) return;
+		this.bridgeRestartTimer = setTimeout(() => {
+			this.bridgeRestartTimer = void 0;
+			if (this.stopped || !this.activeOwner || !this.ownsChannel()) return;
+			this.ensureBridgeRunning();
+		}, this.bridgeRestartDelayMs);
+		this.bridgeRestartTimer.unref?.();
+	}
 	ensureBridgeRunning() {
 		if (this.liveBridgePid() !== void 0) return;
 		const bridge = this.resolveBridgeEntry();
@@ -420384,14 +420427,17 @@ var TelegramChannelController = class {
 			child.once("exit", () => {
 				this.removeOwnedBridgePid(child.pid);
 				if (this.ownedBridge === child) this.ownedBridge = void 0;
+				this.scheduleBridgeRestart();
 			});
 			child.once("error", (error) => {
 				this.removeOwnedBridgePid(child.pid);
 				if (this.ownedBridge === child) this.ownedBridge = void 0;
 				if (!this.stopped) this.host.warn(uiText("telegramChannel.bridgeStartFailed", { error: String(error) }));
+				this.scheduleBridgeRestart();
 			});
 		} catch (error) {
 			this.host.warn(uiText("telegramChannel.bridgeStartFailed", { error: String(error) }));
+			this.scheduleBridgeRestart();
 		}
 	}
 	resolveBridgeEntry() {
@@ -518332,21 +518378,7 @@ var BlunTUI = class {
 		try {
 			const result = await this.harness.withInteractiveAgent(item.agentId ?? "main", () => session.steerActive(input, expectedTurnId === void 0 ? {} : { expectedTurnId }));
 			if (!result.accepted) return this.recoverRejectedActiveSteer(inFlight);
-			inFlight.turnId = String(result.turnId);
-			inFlight.accepted = true;
-			for (const queued of items) this.traceTelegramDelivery?.({ stage: "accepted", ...queued.channelDeliveryTrace, route: "active_steer", turnId: inFlight.turnId });
-			if (result.duplicate === true) {
-				inFlight.duplicate = true;
-				return this.commitQueuedSteer(inFlight);
-			}
-			if (inFlight.turnEnded) return restoreHead();
-			if (!inFlight.stepStarted) {
-				inFlight.confirmationTimer = setTimeout(() => {
-					if (this.queueSteerInFlight === inFlight && inFlight.accepted && !inFlight.stepStarted) restoreHead(new Error("channel steer confirmation timed out"));
-				}, CHANNEL_STEER_CONFIRM_TIMEOUT_MS);
-				inFlight.confirmationTimer.unref?.();
-			}
-			this.commitQueuedSteerIfReady(inFlight);
+			return this.acceptQueuedSteer(inFlight, result, true);
 		} catch (error) {
 			return restoreHead(error);
 		}
@@ -518462,6 +518494,15 @@ var BlunTUI = class {
 		this.updateQueueDisplay();
 		this.state.ui.requestRender();
 	}
+	acceptQueuedSteer(inFlight, result, traceDelivery = false) {
+		if (this.queueSteerInFlight !== inFlight || !result.accepted) return false;
+		inFlight.turnId = String(result.turnId);
+		inFlight.accepted = true;
+		inFlight.duplicate = result.duplicate === true;
+		if (traceDelivery) for (const queued of inFlight.items) this.traceTelegramDelivery?.({ stage: "accepted", ...queued.channelDeliveryTrace, route: "active_steer", turnId: inFlight.turnId });
+		this.commitQueuedSteer(inFlight);
+		return true;
+	}
 	commitQueuedSteerIfReady(inFlight) {
 		if (this.queueSteerInFlight !== inFlight || !inFlight.accepted || !inFlight.stepStarted || inFlight.turnEnded) return;
 		this.commitQueuedSteer(inFlight);
@@ -518647,12 +518688,7 @@ var BlunTUI = class {
 		session.steerActive(items.map((item) => item.text.trim()).join("\n\n"), expectedTurnId === void 0 ? {} : { expectedTurnId }).then((result) => {
 			if (this.queueSteerInFlight !== inFlight) return;
 			if (!result.accepted) this.recoverRejectedActiveSteer(inFlight);
-			else {
-				inFlight.turnId = String(result.turnId);
-				inFlight.accepted = true;
-				if (inFlight.turnEnded) this.restoreQueuedSteer(inFlight);
-				else this.commitQueuedSteerIfReady(inFlight);
-			}
+			else this.acceptQueuedSteer(inFlight, result);
 		}).catch((error) => {
 			this.restoreQueuedSteer(inFlight, error);
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.515",
+  "version": "9.1.516",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
-    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js",
+    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
     "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
@@ -36,6 +36,12 @@
     "native/",
     "release-planned-removals.json",
     "scripts/check-package-regression.js",
+    "scripts/check-active-profile-plugin-startup.js",
+    "scripts/check-mcp-startup-wait-budget.js",
+    "scripts/check-plugin-startup-regression.js",
+    "scripts/check-queue-controls-regression.js",
+    "scripts/check-telegram-bridge-watchdog.js",
+    "scripts/check-resume-replay-regression.js",
     "scripts/check-release-metadata.js",
     "scripts/check-todo-loop-regression.js",
     "scripts/fix-node-pty-perms.js",

package/scripts/check-active-profile-plugin-startup.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { installAgentSpineForExistingProfiles } = require('../bin/launcher-runtime');
+
+const packageRoot = path.resolve(__dirname, '..');
+const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-active-profile-plugin-'));
+const sharedHome = path.join(temporaryRoot, '.blun');
+const currentProfile = path.join(sharedHome, 'profile', 'current');
+const dormantProfile = path.join(sharedHome, 'profile', 'dormant');
+
+try {
+  fs.mkdirSync(currentProfile, { recursive: true });
+  fs.mkdirSync(dormantProfile, { recursive: true });
+
+  installAgentSpineForExistingProfiles(packageRoot, sharedHome, currentProfile);
+
+  assert.equal(
+    fs.existsSync(path.join(currentProfile, 'plugins', 'installed.json')),
+    true,
+    'the active profile must receive the managed AgentSpine plugin',
+  );
+  assert.equal(
+    fs.existsSync(path.join(dormantProfile, 'plugins', 'installed.json')),
+    false,
+    'startup must not rescan or mutate dormant profiles',
+  );
+
+  process.stdout.write('active profile plugin startup regression: PASS\n');
+} finally {
+  fs.rmSync(temporaryRoot, { recursive: true, force: true });
+}

package/scripts/check-mcp-startup-wait-budget.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const bundlePath = path.resolve(__dirname, '..', 'blun.mjs');
+const source = fs.readFileSync(bundlePath, 'utf8');
+const match = source.match(
+  /async function blunWaitForInitialMcpBudget\(mcp, signal\) \{[\s\S]*?\n\}/u,
+);
+assert.ok(match, 'the bundle must contain the bounded initial MCP wait helper');
+assert.match(
+  source,
+  /await blunWaitForInitialMcpBudget\(this\.agent\.mcp, signal\)/u,
+  'tool-capable turns must use the bounded initial MCP wait helper',
+);
+
+const context = vm.createContext({ setTimeout });
+vm.runInContext(`${match[0]}; globalThis.waitForInitialMcp = blunWaitForInitialMcpBudget;`, context);
+
+let initialLoadFinished = false;
+const mcp = {
+  waitForInitialLoad() {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        initialLoadFinished = true;
+        resolve();
+      }, 20_000);
+      timer.unref();
+    });
+  },
+};
+
+(async () => {
+  const startedAt = performance.now();
+  await context.waitForInitialMcp(mcp, undefined);
+  const elapsedMs = performance.now() - startedAt;
+
+  assert.ok(elapsedMs >= 2_300, `wait budget returned too early: ${elapsedMs} ms`);
+  assert.ok(elapsedMs < 3_200, `slow optional MCP blocked the turn: ${elapsedMs} ms`);
+  assert.equal(initialLoadFinished, false, 'the slow MCP must continue loading in the background');
+  process.stdout.write(`MCP startup wait regression: PASS (${Math.round(elapsedMs)} ms)\n`);
+})().catch((error) => {
+  process.stderr.write(`${error.stack || error}\n`);
+  process.exitCode = 1;
+});

package/scripts/check-plugin-startup-regression.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { installManagedAgentSpinePlugin } = require('../bin/plugin-bootstrap');
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-plugin-startup-'));
+const packageRoot = path.join(root, 'package');
+const sourceRoot = path.join(packageRoot, 'agent-spine-plugin');
+const profileA = path.join(root, 'profiles', 'a');
+const profileB = path.join(root, 'profiles', 'b');
+
+fs.mkdirSync(path.join(sourceRoot, 'src'), { recursive: true });
+fs.writeFileSync(path.join(sourceRoot, 'package.json'), '{"name":"agent-spine"}\n');
+fs.writeFileSync(path.join(sourceRoot, 'src', 'mcp.js'), 'export const ready = true;\n');
+
+const originalReadFileSync = fs.readFileSync;
+let sourceReads = 0;
+fs.readFileSync = function countedReadFileSync(filePath, ...args) {
+  const absolutePath = path.resolve(String(filePath));
+  if (absolutePath === sourceRoot || absolutePath.startsWith(`${sourceRoot}${path.sep}`)) {
+    sourceReads += 1;
+  }
+  return originalReadFileSync.call(this, filePath, ...args);
+};
+
+try {
+  const first = installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA });
+  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA });
+  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileB });
+  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileB });
+
+  assert.equal(
+    sourceReads,
+    2,
+    'one launcher process must read each managed source file only once',
+  );
+
+  fs.writeFileSync(path.join(first.pluginRoot, 'src', 'mcp.js'), 'tampered\n');
+  assert.throws(
+    () => installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA }),
+    /digest mismatch/,
+    'source caching must not weaken installed-tree verification',
+  );
+
+  process.stdout.write('Plugin startup regression gate: PASS\n');
+} finally {
+  fs.readFileSync = originalReadFileSync;
+  fs.rmSync(root, { recursive: true, force: true });
+}

package/scripts/check-queue-controls-regression.js

@@ -0,0 +1,189 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { enqueueTelegramAddressed } = require('../bin/telegram-addressed-priority.cjs');
+const { enqueueTelegramBotPriority } = require('../bin/telegram-bot-priority.cjs');
+const { enqueueTelegramDirect } = require('../bin/telegram-direct-focus-policy.cjs');
+const { enqueueTelegramUrgent } = require('../bin/telegram-urgent-policy.cjs');
+
+const bundle = fs.readFileSync(path.join(__dirname, '..', 'blun.mjs'), 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function method(name, nextName) {
+  const source = between(`\n\t${name}(`, `\n\t${nextName}(`).trim();
+  return Function(`"use strict"; return ({${source}}).${name};`)();
+}
+
+const ctrlS = between('\n\t\teditor.onCtrlS = () => {', '\n\t\teditor.onCtrlB =');
+assert.match(ctrlS, /host\.flushQueuedMessages\(/);
+assert.doesNotMatch(ctrlS, /toggleTodoPanelExpansion|shortcut_todo_expand/);
+
+const escape = between('\n\t\teditor.onEscape =', '\n\t\teditor.onShiftTab =');
+const releaseIndex = escape.indexOf('host.releaseNextQueuedMessage()');
+const cancelIndex = escape.indexOf('host.markCurrentRunCancelledByUser()');
+assert.ok(releaseIndex >= 0, 'Escape must release queued work');
+assert.ok(cancelIndex > releaseIndex, 'Escape must release queued work before cancelling the run');
+
+const releaseNextQueuedMessage = method('releaseNextQueuedMessage', 'markCurrentRunCancelledByUser');
+const releaseHost = {
+  queueSteerInFlight: undefined,
+  queueFlushBatchRemaining: 0,
+  state: {
+    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
+    ui: { requestRender() {} },
+  },
+  steerQueueFlushPrefixCalls: 0,
+  updateQueueDisplayCalls: 0,
+  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
+  updateQueueDisplay() { this.updateQueueDisplayCalls += 1; },
+};
+
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 1);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 2);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
+assert.equal(releaseHost.queueFlushBatchRemaining, 3);
+assert.equal(releaseNextQueuedMessage.call(releaseHost), false);
+assert.equal(releaseHost.queueFlushBatchRemaining, 3);
+assert.equal(releaseHost.steerQueueFlushPrefixCalls, 3);
+
+const flushQueuedMessages = method('flushQueuedMessages', 'steerQueueFlushPrefix');
+const flushHost = {
+  queueSteerInFlight: { items: [{ text: 'already accepted' }] },
+  queueFlushBatchRemaining: 0,
+  state: {
+    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
+    editor: { setText() {}, inputMode: 'prompt' },
+  },
+  steerQueueFlushPrefixCalls: 0,
+  scheduleQueueDrainCalls: 0,
+  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
+  scheduleQueueDrain() { this.scheduleQueueDrainCalls += 1; },
+};
+
+flushQueuedMessages.call(flushHost, '', 'prompt');
+assert.equal(flushHost.queueFlushBatchRemaining, 4);
+assert.equal(flushHost.steerQueueFlushPrefixCalls, 1);
+assert.equal(flushHost.scheduleQueueDrainCalls, 1);
+
+const commitQueuedSteer = method('commitQueuedSteer', 'recoverRejectedActiveSteer');
+let commits = 0;
+const inFlight = {
+  items: [{ text: 'telegram message' }],
+  confirmationTimer: undefined,
+  onCommit() { commits += 1; },
+};
+const commitHost = {
+  queueSteerInFlight: inFlight,
+  updateQueueDisplay() {},
+  state: { ui: { requestRender() {} } },
+  steerQueueFlushPrefix() {},
+  scheduleQueueDrain() {},
+};
+
+commitQueuedSteer.call(commitHost, inFlight);
+commitQueuedSteer.call(commitHost, inFlight);
+assert.equal(commits, 1);
+assert.equal(commitHost.queueSteerInFlight, undefined);
+
+const acceptQueuedSteer = method('acceptQueuedSteer', 'commitQueuedSteerIfReady');
+let acceptedCommits = 0;
+const acceptedInFlight = {
+  items: [{ channelDeliveryTrace: { messageId: '63508' } }],
+  accepted: false,
+  stepStarted: false,
+  turnEnded: false,
+  onCommit() { acceptedCommits += 1; },
+};
+const acceptedHost = {
+  queueSteerInFlight: acceptedInFlight,
+  traced: [],
+  traceTelegramDelivery(event) { this.traced.push(event); },
+  commitQueuedSteer(item) {
+    assert.equal(item, acceptedInFlight);
+    if (this.queueSteerInFlight !== item) return;
+    this.queueSteerInFlight = undefined;
+    item.onCommit();
+  },
+};
+
+assert.equal(acceptQueuedSteer.call(acceptedHost, acceptedInFlight, {
+  accepted: true,
+  duplicate: false,
+  turnId: 77,
+}, true), true);
+assert.equal(acceptedCommits, 1, 'durably accepted steer must commit before a delayed step event');
+assert.equal(acceptedHost.queueSteerInFlight, undefined);
+assert.equal(acceptedHost.traced.length, 1);
+assert.equal(acceptedHost.traced[0].stage, 'accepted');
+
+const recoverRejectedActiveSteer = method('recoverRejectedActiveSteer', 'quarantineQueuedSteer');
+let restored = 0;
+const rejectedInFlight = {
+  items: [{ text: 'keep me queued', channelDeliveryFailures: 2 }],
+  onRestore() { restored += 1; },
+};
+const rejectedHost = {
+  queueSteerInFlight: rejectedInFlight,
+  state: { queuedMessages: [], ui: { requestRender() {} } },
+  traced: [],
+  traceTelegramDelivery(event) { this.traced.push(event); },
+  updateQueueDisplay() {},
+  streamingUI: { hasActiveTurn() { return true; } },
+};
+
+assert.equal(recoverRejectedActiveSteer.call(rejectedHost, rejectedInFlight), false);
+assert.equal(restored, 1);
+assert.equal(rejectedHost.state.queuedMessages.length, 1, 'rejected steer must remain queued');
+assert.equal(rejectedHost.state.queuedMessages[0].text, 'keep me queued');
+assert.equal('channelDeliveryFailures' in rejectedHost.state.queuedMessages[0], false);
+
+const channelDelivery = between('\n\tasync deliverQueuedChannelHead() {', '\n\tinstallChannelReplyGuard(');
+assert.match(
+  channelDelivery,
+  /if \(!result\.accepted\) return this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*return this\.acceptQueuedSteer\(inFlight, result, true\);/,
+  'channel delivery must commit a durably accepted active steer',
+);
+assert.doesNotMatch(
+  channelDelivery,
+  /channel steer confirmation timed out|CHANNEL_STEER_CONFIRM_TIMEOUT_MS/,
+  'durably accepted channel messages must not be restored by a wall-clock timeout',
+);
+
+const ctrlSDelivery = between('\n\tsteerQueueFlushPrefix() {', '\n\tdrainOneQueuedMessage() {');
+assert.match(
+  ctrlSDelivery,
+  /if \(!result\.accepted\) this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*else this\.acceptQueuedSteer\(inFlight, result\);/,
+  'Ctrl+S delivery must use the same durable acceptance rule',
+);
+
+const priorityQueue = [{ id: 'normal-a' }, { id: 'normal-b' }];
+enqueueTelegramBotPriority(priorityQueue, { id: 'bot-a', channelBotPriority: true });
+enqueueTelegramBotPriority(priorityQueue, { id: 'bot-b', channelBotPriority: true });
+enqueueTelegramAddressed(priorityQueue, { id: 'addressed-a', channelAddressed: true });
+enqueueTelegramAddressed(priorityQueue, { id: 'addressed-b', channelAddressed: true });
+enqueueTelegramDirect(priorityQueue, { id: 'direct-a', channelDirect: true });
+enqueueTelegramDirect(priorityQueue, { id: 'direct-b', channelDirect: true });
+enqueueTelegramUrgent(priorityQueue, { id: 'urgent-a', channelUrgent: true });
+enqueueTelegramUrgent(priorityQueue, { id: 'urgent-b', channelUrgent: true });
+assert.deepEqual(
+  priorityQueue.map((item) => item.id),
+  [
+    'urgent-a', 'urgent-b',
+    'direct-a', 'direct-b',
+    'addressed-a', 'addressed-b',
+    'bot-a', 'bot-b',
+    'normal-a', 'normal-b',
+  ],
+  'Telegram queue priority must be urgent, direct, addressed, bot, normal with stable FIFO inside each class',
+);
+
+console.log('queue controls regression: PASS');

package/scripts/check-resume-replay-regression.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function compileMethod(name, nextName, dependencies = {}) {
+  const source = between(`\n\t\t${name}(`, `\n\t\t${nextName}(`).trim();
+  const names = Object.keys(dependencies);
+  const values = Object.values(dependencies);
+  return Function(...names, `"use strict"; return ({${source}}).${name};`)(...values);
+}
+
+function resolveStepEventUuid(openSteps, event) {
+  if (event.stepUuid !== undefined) return event.stepUuid;
+  let latest;
+  for (const uuid of openSteps.keys()) latest = uuid;
+  return latest;
+}
+
+function resolveCompletedStepUuid(openSteps, event) {
+  if (event.uuid !== undefined) return event.uuid;
+  let latest;
+  for (const uuid of openSteps.keys()) latest = uuid;
+  return latest;
+}
+
+const recoverMissingOpenStep = compileMethod(
+  'recoverMissingOpenStep',
+  'appendLoopEvent',
+  { resolveStepEventUuid },
+);
+const appendLoopEvent = compileMethod(
+  'appendLoopEvent',
+  'appendMessage',
+  {
+    projectLoopEventForRecord: (event) => event,
+    resolveCompletedStepUuid,
+    createToolMessage: (toolCallId, content) => ({ toolCallId, content, toolCalls: [] }),
+    toolResultOutputForModel: (result) => result.output,
+    estimateTokensForMessages: () => 0,
+  },
+);
+
+const records = [];
+const warnings = [];
+const host = {
+  _history: [],
+  _tokenCount: 0,
+  tokenCountCoveredMessageCount: 0,
+  openSteps: new Map(),
+  pendingToolResultIds: new Set(),
+  agent: {
+    records: {
+      restoring: { time: Date.now() },
+      logRecord(record) { records.push(record); },
+    },
+    log: { warn(message, fields) { warnings.push({ message, fields }); } },
+  },
+  recoverMissingOpenStep,
+  pushHistory(...messages) { this._history.push(...messages); },
+  markPendingTokenEstimateDirty() {},
+  flushDeferredMessagesIfToolExchangeClosed() {},
+  closePendingToolResults() { return []; },
+};
+
+// Exact shape measured after context.apply_compaction: no step.begin survives,
+// then text, a tool call/result pair, and step.end continue the interrupted turn.
+appendLoopEvent.call(host, { type: 'content.part', part: { type: 'text', text: 'continued after compaction' } });
+appendLoopEvent.call(host, { type: 'tool.call', toolCallId: 'tool-1', name: 'Read', args: { path: 'SPEC.md' } });
+appendLoopEvent.call(host, { type: 'tool.result', toolCallId: 'tool-1', result: { output: 'ok', isError: false } });
+appendLoopEvent.call(host, { type: 'step.end', contextTokens: 100 });
+
+assert.equal(warnings.length, 1, 'one missing step must produce one bounded repair warning');
+assert.equal(warnings[0].fields.eventType, 'content.part');
+assert.equal(warnings[0].fields.restoring, true);
+assert.equal(host._history.length, 2, 'repair must retain the assistant continuation and its tool result');
+assert.deepEqual(host._history[0].content, [{ type: 'text', text: 'continued after compaction' }]);
+assert.equal(host._history[0].toolCalls.length, 1);
+assert.equal(host._history[0].toolCalls[0].id, 'tool-1');
+assert.equal(host._history[1].toolCallId, 'tool-1');
+assert.equal(host.pendingToolResultIds.size, 0);
+assert.equal(host.openSteps.size, 0);
+assert.equal(records.filter((record) => record.type === 'context.append_loop_event').length, 4);
+
+process.stdout.write('resume-replay-regression PASS\n');

package/scripts/check-telegram-bridge-watchdog.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundle = fs.readFileSync(path.join(__dirname, '..', 'blun.mjs'), 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function method(name, nextName) {
+  const source = between(`\n\t${name}(`, `\n\t${nextName}(`).trim();
+  return Function(`"use strict"; return ({${source}}).${name};`)();
+}
+
+async function main() {
+  const scheduleBridgeRestart = method('scheduleBridgeRestart', 'ensureBridgeRunning');
+  const host = {
+    stopped: false,
+    activeOwner: true,
+    bridgeRestartTimer: undefined,
+    bridgeRestartDelayMs: 5,
+    ownsChannel() { return true; },
+    starts: 0,
+    ensureBridgeRunning() { this.starts += 1; },
+  };
+
+  scheduleBridgeRestart.call(host);
+  const firstTimer = host.bridgeRestartTimer;
+  assert.notEqual(firstTimer, undefined);
+  scheduleBridgeRestart.call(host);
+  assert.equal(host.bridgeRestartTimer, firstTimer, 'restart scheduling must be deduplicated');
+  await new Promise((resolve) => setTimeout(resolve, 25));
+  assert.equal(host.starts, 1, 'a dead owned bridge must be restarted once');
+  assert.equal(host.bridgeRestartTimer, undefined);
+
+  host.stopped = true;
+  scheduleBridgeRestart.call(host);
+  assert.equal(host.bridgeRestartTimer, undefined, 'stopped controllers must not restart bridges');
+
+  const ensureBridgeRunning = between('\n\tensureBridgeRunning() {', '\n\tresolveBridgeEntry() {');
+  assert.match(ensureBridgeRunning, /child\.once\("exit",[\s\S]*this\.scheduleBridgeRestart\(\)/);
+  assert.match(ensureBridgeRunning, /child\.once\("error",[\s\S]*this\.scheduleBridgeRestart\(\)/);
+  const beginStop = between('\n\tbeginStop() {', '\n\tasync stopOwnedBridge(');
+  assert.match(beginStop, /clearTimeout\(this\.bridgeRestartTimer\)/);
+
+  process.stdout.write('telegram-bridge-watchdog PASS\n');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/check-todo-loop-regression.js

@@ -3,8 +3,11 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { enforceSingleTodoWritePerStep } = require('../bin/todo-list-turn-policy.cjs');
 
-const bundlePath = path.resolve(__dirname, '..', 'blun.mjs');
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.resolve(__dirname, '..', 'blun.mjs');
 const bundle = fs.readFileSync(bundlePath, 'utf8');
 
 function assert(condition, message) {
@@ -23,5 +26,53 @@ assert(
   /isIdle:\s*\(\)\s*=>\s*!agent\.turn\.hasActiveTurn/.test(bundle),
   'TODO_LOOP_REGRESSION: expected idle-only session loop scheduler wiring is missing',
 );
+assert(
+  /todos\.filter\(\(todo\)\s*=>\s*todo\.status\s*!==\s*["']done["']\)/.test(bundle),
+  'TODO_LIFECYCLE_REGRESSION: completed items must be pruned from the stored visible list',
+);
+assert(
+  /const PENDING_TEXT\s*=\s*["']#aeb8c6["']/.test(bundle)
+    && !/const PENDING_TEXT\s*=\s*["']#2a3550["']/.test(bundle),
+  'TODO_UI_REGRESSION: pending markers must remain visible on ANSI16 terminals',
+);
+assert(
+  /activeGoal\s*===\s*null\s*&&\s*!startsTrackedList/.test(bundle)
+    && /The first TodoList must contain at least one item, exactly one in_progress item/.test(bundle),
+  'TODO_INITIAL_STATE_REGRESSION: a new non-goal TodoList must not accept an all-pending list',
+);
+assert(
+  /enforceSingleTodoWritePerStep\(ctx\)/.test(bundle),
+  'TODO_PARALLEL_REGRESSION: per-step TodoList write guard is not wired',
+);
+
+const calls = [
+  { id: 'todo-first', name: 'TodoList' },
+  { id: 'todo-second', name: 'TodoList' },
+];
+assert(
+  enforceSingleTodoWritePerStep({
+    toolCall: calls[0],
+    toolCalls: calls,
+    args: { todos: [{ title: 'first', status: 'in_progress' }] },
+  }) === undefined,
+  'TODO_PARALLEL_REGRESSION: first TodoList write must remain executable',
+);
+const duplicateWrite = enforceSingleTodoWritePerStep({
+  toolCall: calls[1],
+  toolCalls: calls,
+  args: { todos: [{ title: 'second', status: 'in_progress' }] },
+});
+assert(
+  duplicateWrite?.block === true,
+  'TODO_PARALLEL_REGRESSION: later TodoList writes in the same step must be blocked',
+);
+assert(
+  enforceSingleTodoWritePerStep({
+    toolCall: { id: 'todo-read', name: 'TodoList' },
+    toolCalls: calls,
+    args: {},
+  }) === undefined,
+  'TODO_PARALLEL_REGRESSION: read-only TodoList queries must not be blocked',
+);
 
 process.stdout.write('todo-loop-regression PASS\n');