blun-king-cli 9.1.514 → 9.1.516

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

@@ -77249,7 +77249,7 @@ var init_manager$3 = __esmMin((() => {
 			this.scheduler = createCronScheduler({
 				clocks: this.clocks,
 				source: () => this.store.list(),
-				isIdle: (task) => !agent.turn.hasActiveTurn && (task?.owner !== "session-loop" || !hasUnfinishedTodoWork(agent)),
+				isIdle: () => !agent.turn.hasActiveTurn,
 				isKilled: () => process.env["BLUN_DISABLE_CRON"] === "1",
 				onFire: (task, ctx) => {
 					this.handleFire(task, ctx);
@@ -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() {
@@ -423460,13 +423506,6 @@ function enforceGoalTodoPolicy(agent, context) {
 			};
 		}
 		progress.allVisibleWorkCompleted = nextTodos.length > 0 && nextTodos.every((todo) => todo?.status === "done");
-		if (progress.refreshRequired) {
-			const normalized = (value) => value.map((todo) => ({ title: String(todo?.title ?? "").trim(), status: todo?.status }));
-			if (JSON.stringify(normalized(nextTodos)) === JSON.stringify(normalized(todos))) return {
-				block: true,
-				reason: "TodoList is unchanged after extended work. Mark evidenced progress, advance the active item, or refine its title to the concrete verified substep before continuing."
-			};
-		}
 		progress.workCallsSinceRefresh = 0;
 		progress.refreshRequired = false;
 		return;
@@ -518339,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);
 		}
@@ -518469,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);
@@ -518654,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.514",
+  "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",
+    "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,7 +36,14 @@
     "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",
     "standard-skills/",
     "standard-tools/",

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 });
+}