blun-king-cli 9.1.288 → 9.1.290

package/bin/context-doctor-policy.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+function wholeNonNegative(value) {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+
+function claimTokens(remaining, value) {
+  return Math.min(remaining, wholeNonNegative(value));
+}
+
+function buildContextDoctor(input = {}) {
+  const projectedTokens = wholeNonNegative(input.projectedTokenCount);
+  const maxTokens = wholeNonNegative(input.effectiveMaxContextTokens);
+  const conversationTokens = wholeNonNegative(input.conversationTokens);
+
+  const systemTotal = wholeNonNegative(input.systemPromptTokens);
+  let systemRemaining = systemTotal;
+  const personalityTokens = claimTokens(systemRemaining, input.personalityPromptTokens);
+  systemRemaining -= personalityTokens;
+  const socialTokens = claimTokens(systemRemaining, input.socialPromptTokens);
+  systemRemaining -= socialTokens;
+  const skillTokens = claimTokens(systemRemaining, input.skillPromptTokens);
+  systemRemaining -= skillTokens;
+  const runtimeTokens = claimTokens(systemRemaining, input.runtimePromptTokens);
+  systemRemaining -= runtimeTokens;
+
+  const toolTotal = wholeNonNegative(input.toolSchemaTokens);
+  let toolRemaining = toolTotal;
+  const builtinTokens = claimTokens(toolRemaining, input.builtinToolSchemaTokens);
+  toolRemaining -= builtinTokens;
+  const userTokens = claimTokens(toolRemaining, input.userToolSchemaTokens);
+  toolRemaining -= userTokens;
+  const mcpTokens = claimTokens(toolRemaining, input.mcpToolSchemaTokens);
+  toolRemaining -= mcpTokens;
+
+  const accountedTokens = systemTotal + conversationTokens + toolTotal;
+  const providerOverheadTokens = Math.max(0, projectedTokens - accountedTokens);
+  const freeTokens = Math.max(0, maxTokens - projectedTokens);
+  const ratio = maxTokens > 0 ? Math.min(1, projectedTokens / maxTokens) : 0;
+
+  return {
+    projectedTokens,
+    maxTokens,
+    freeTokens,
+    ratio,
+    providerOverheadTokens,
+    conversationTokens,
+    system: {
+      coreTokens: systemRemaining,
+      personalityTokens,
+      socialTokens,
+      skillTokens,
+      runtimeTokens,
+      totalTokens: systemTotal,
+    },
+    tools: {
+      builtinTokens,
+      userTokens,
+      mcpTokens,
+      otherTokens: toolRemaining,
+      totalTokens: toolTotal,
+    },
+  };
+}
+
+module.exports = {
+  buildContextDoctor,
+  wholeNonNegative,
+};

package/bin/launcher-runtime.js

@@ -927,6 +927,7 @@ async function runLauncher(options = {}) {
     const mnemoConnect = startMnemoConnectHeartbeat({
       env,
       profileName: PROFILE.profileName,
+      mcpConfigPath: path.join(profilePaths.home, 'mcp.json'),
       version: readPackageVersion(),
     });
     try {

package/bin/mnemo-connect-heartbeat.cjs

@@ -1,9 +1,11 @@
 'use strict';
 
+const fs = require('node:fs');
 const os = require('node:os');
 
 const DEFAULT_HEARTBEAT_MS = 60_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_INTERNAL_HUB_URL = 'http://100.85.21.103:7117';
 
 function resolveMnemoHubUrl(env = process.env) {
   const raw = [
@@ -32,6 +34,29 @@ function resolveMnemoAgentName(profileName, env = process.env) {
   return configured || String(profileName || '').trim();
 }
 
+function resolveMnemoProfileConnectConfig(configPath) {
+  if (typeof configPath !== 'string' || configPath.trim().length === 0) return null;
+  try {
+    const stat = fs.statSync(configPath);
+    if (!stat.isFile() || stat.size > 1024 * 1024) return null;
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const server = config?.mcpServers?.mnemo;
+    if (!server || server.enabled === false || !server.env || typeof server.env !== 'object') return null;
+    const agentName = String(server.env.BLUN_MNEMO_AGENT || server.env.MNEMO_AGENT || '').trim();
+    if (!agentName || /[\u0000-\u001f\u007f]/u.test(agentName) || agentName.length > 128) return null;
+    const configuredUrl = [
+      server.env.BLUN_MNEMO_HUB_URL,
+      server.env.MNEMO_HUB_URL,
+      server.env.MNEMO_URL,
+    ].some((value) => typeof value === 'string' && value.trim().length > 0);
+    const baseUrl = resolveMnemoHubUrl(server.env);
+    if (configuredUrl && !baseUrl) return null;
+    return { agentName, baseUrl: baseUrl || DEFAULT_INTERNAL_HUB_URL };
+  } catch {
+    return null;
+  }
+}
+
 async function postMnemoTool(baseUrl, tool, payload, options = {}) {
   const controller = new AbortController();
   const timeout = (options.setTimeoutImpl || setTimeout)(
@@ -62,8 +87,14 @@ async function postMnemoTool(baseUrl, tool, payload, options = {}) {
 
 function startMnemoConnectHeartbeat(options = {}) {
   const env = options.env || process.env;
-  const baseUrl = options.baseUrl || resolveMnemoHubUrl(env);
-  const agentName = options.agentName || resolveMnemoAgentName(options.profileName, env);
+  const profileConfig = options.profileConfig
+    || resolveMnemoProfileConnectConfig(options.mcpConfigPath);
+  const baseUrl = options.baseUrl || resolveMnemoHubUrl(env) || profileConfig?.baseUrl;
+  const configuredAgentName = resolveMnemoAgentName('', env);
+  const agentName = options.agentName
+    || configuredAgentName
+    || profileConfig?.agentName
+    || resolveMnemoAgentName(options.profileName, {});
   if (!baseUrl || !agentName) {
     return Object.freeze({ enabled: false, ready: Promise.resolve(false), stop: async () => {} });
   }
@@ -165,9 +196,11 @@ function startMnemoConnectHeartbeat(options = {}) {
 
 module.exports = {
   DEFAULT_HEARTBEAT_MS,
+  DEFAULT_INTERNAL_HUB_URL,
   DEFAULT_TIMEOUT_MS,
   postMnemoTool,
   resolveMnemoAgentName,
   resolveMnemoHubUrl,
+  resolveMnemoProfileConnectConfig,
   startMnemoConnectHeartbeat,
 };

package/blun.mjs

@@ -264324,6 +264324,16 @@ var init_tool$1 = __esmMin((() => {
 		data() {
 			return Array.from(this.toolInfos());
 		}
+		contextSchemaTokenBreakdown() {
+			const totals = { builtin: 0, user: 0, mcp: 0 };
+			for (const tool of this.loopTools) {
+				const tokens = estimateTokensForTools([tool]);
+				if (this.mcpTools.has(tool.name)) totals.mcp += tokens;
+				else if (this.userTools.has(tool.name)) totals.user += tokens;
+				else totals.builtin += tokens;
+			}
+			return totals;
+		}
 		storeData() {
 			return { ...this.store };
 		}
@@ -265275,15 +265285,30 @@ var init_agent = __esmMin((() => {
 				resumeGoal: () => this.goal.resumeGoal(),
 				cancelGoal: () => this.goal.cancelGoal(),
 				getBackgroundOutput: (payload) => this.background.readOutput(payload.taskId, payload.tail),
-				getContext: () => ({
-					...this.context.data(),
-					projectedTokenCount: this.fullCompaction.estimateCurrentRequestTokens(),
-					effectiveMaxContextTokens: this.fullCompaction.getEffectiveMaxContextTokens(),
-					compactionBudgetTokens: this.fullCompaction.getCompactionBudgetTokens(),
-					systemPromptTokens: estimateTokens$1(this.effectiveSystemPrompt),
-					conversationTokens: estimateTokensForMessages(this.context.messages),
-					toolSchemaTokens: estimateTokensForTools(this.tools.loopTools)
-				}),
+				getContext: () => {
+					const systemPrompt = this.effectiveSystemPrompt;
+					const includedTokens = (block) => block.length > 0 && systemPrompt.includes(block) ? estimateTokens$1(block) : 0;
+					const personalityPromptTokens = includedTokens(personaSystemBlock()) + includedTokens(soulSystemBlock());
+					const socialPromptTokens = includedTokens(identitySystemBlock()) + includedTokens(naturalPresenceSystemBlock());
+					const skillPrompt = this.skills?.registry.getModelSkillListing() ?? "";
+					const toolBreakdown = this.tools.contextSchemaTokenBreakdown();
+					return {
+						...this.context.data(),
+						projectedTokenCount: this.fullCompaction.estimateCurrentRequestTokens(),
+						effectiveMaxContextTokens: this.fullCompaction.getEffectiveMaxContextTokens(),
+						compactionBudgetTokens: this.fullCompaction.getCompactionBudgetTokens(),
+						systemPromptTokens: estimateTokens$1(systemPrompt),
+						personalityPromptTokens,
+						socialPromptTokens,
+						skillPromptTokens: includedTokens(skillPrompt),
+						runtimePromptTokens: includedTokens(this.runtimeSystemPromptAppend),
+						conversationTokens: estimateTokensForMessages(this.context.messages),
+						toolSchemaTokens: estimateTokensForTools(this.tools.loopTools),
+						builtinToolSchemaTokens: toolBreakdown.builtin,
+						userToolSchemaTokens: toolBreakdown.user,
+						mcpToolSchemaTokens: toolBreakdown.mcp
+					};
+				},
 				getConfig: () => this.config.data(),
 				getPermission: () => this.permission.data(),
 				getPlan: () => this.planMode.data(),
@@ -403318,6 +403343,13 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 		priority: 65,
 		availability: "always"
 	},
+	{
+		name: "context-doctor",
+		aliases: [],
+		descriptionKey: "contextDoctor.description",
+		priority: 66,
+		availability: "always"
+	},
 	{
 		name: "improve",
 		aliases: ["learning"],
@@ -416989,6 +417021,92 @@ registerUiCatalogFragment({
 		"usage.context.title": "Kontextové okno"
 	}
 });
+registerUiCatalogFragment({
+	en: {
+		"contextDoctor.title": "Context doctor",
+		"contextDoctor.description": "Break down injected context without calling the model",
+		"contextDoctor.core": "Core instructions",
+		"contextDoctor.personality": "Personality and soul",
+		"contextDoctor.social": "Relationships and presence",
+		"contextDoctor.skills": "Skills index",
+		"contextDoctor.runtime": "Runtime additions",
+		"contextDoctor.builtinTools": "Built-in tools",
+		"contextDoctor.userTools": "User tools",
+		"contextDoctor.mcpTools": "MCP tools",
+		"contextDoctor.otherTools": "Other tool schemas",
+		"contextDoctor.providerOverhead": "Provider overhead"
+	},
+	de: {
+		"contextDoctor.title": "Kontextdiagnose",
+		"contextDoctor.description": "Aufschlüsselung des eingefügten Kontexts ohne Modellaufruf",
+		"contextDoctor.core": "Kernanweisungen",
+		"contextDoctor.personality": "Persönlichkeit und Seele",
+		"contextDoctor.social": "Beziehungen und Präsenz",
+		"contextDoctor.skills": "Fähigkeitenverzeichnis",
+		"contextDoctor.runtime": "Laufzeitergänzungen",
+		"contextDoctor.builtinTools": "Integrierte Werkzeuge",
+		"contextDoctor.userTools": "Benutzerwerkzeuge",
+		"contextDoctor.mcpTools": "MCP-Werkzeuge",
+		"contextDoctor.otherTools": "Weitere Werkzeugschemata",
+		"contextDoctor.providerOverhead": "Anbieterbedingter Zusatzaufwand"
+	},
+	es: {
+		"contextDoctor.title": "Diagnóstico del contexto",
+		"contextDoctor.description": "Desglose del contexto insertado sin llamar al modelo",
+		"contextDoctor.core": "Instrucciones principales",
+		"contextDoctor.personality": "Personalidad y esencia",
+		"contextDoctor.social": "Relaciones y presencia",
+		"contextDoctor.skills": "Índice de habilidades",
+		"contextDoctor.runtime": "Adiciones en tiempo de ejecución",
+		"contextDoctor.builtinTools": "Herramientas integradas",
+		"contextDoctor.userTools": "Herramientas del usuario",
+		"contextDoctor.mcpTools": "Herramientas MCP",
+		"contextDoctor.otherTools": "Otros esquemas de herramientas",
+		"contextDoctor.providerOverhead": "Sobrecarga del proveedor"
+	},
+	fr: {
+		"contextDoctor.title": "Diagnostic du contexte",
+		"contextDoctor.description": "Répartition du contexte injecté sans appel au modèle",
+		"contextDoctor.core": "Instructions principales",
+		"contextDoctor.personality": "Personnalité et identité",
+		"contextDoctor.social": "Relations et présence",
+		"contextDoctor.skills": "Index des compétences",
+		"contextDoctor.runtime": "Ajouts à l’exécution",
+		"contextDoctor.builtinTools": "Outils intégrés",
+		"contextDoctor.userTools": "Outils de l’utilisateur",
+		"contextDoctor.mcpTools": "Outils MCP",
+		"contextDoctor.otherTools": "Autres schémas d’outils",
+		"contextDoctor.providerOverhead": "Surcoût du fournisseur"
+	},
+	sv: {
+		"contextDoctor.title": "Kontextdiagnos",
+		"contextDoctor.description": "Uppdelning av infogad kontext utan modellanrop",
+		"contextDoctor.core": "Grundinstruktioner",
+		"contextDoctor.personality": "Personlighet och identitet",
+		"contextDoctor.social": "Relationer och närvaro",
+		"contextDoctor.skills": "Färdighetsindex",
+		"contextDoctor.runtime": "Körtidstillägg",
+		"contextDoctor.builtinTools": "Inbyggda verktyg",
+		"contextDoctor.userTools": "Användarverktyg",
+		"contextDoctor.mcpTools": "MCP-verktyg",
+		"contextDoctor.otherTools": "Övriga verktygsscheman",
+		"contextDoctor.providerOverhead": "Leverantörspåslag"
+	},
+	cs: {
+		"contextDoctor.title": "Diagnostika kontextu",
+		"contextDoctor.description": "Rozpis vloženého kontextu bez volání modelu",
+		"contextDoctor.core": "Základní pokyny",
+		"contextDoctor.personality": "Osobnost a identita",
+		"contextDoctor.social": "Vztahy a přítomnost",
+		"contextDoctor.skills": "Přehled dovedností",
+		"contextDoctor.runtime": "Doplňky za běhu",
+		"contextDoctor.builtinTools": "Vestavěné nástroje",
+		"contextDoctor.userTools": "Uživatelské nástroje",
+		"contextDoctor.mcpTools": "Nástroje MCP",
+		"contextDoctor.otherTools": "Ostatní schémata nástrojů",
+		"contextDoctor.providerOverhead": "Režie poskytovatele"
+	}
+});
 const LEFT_MARGIN$1 = 2;
 const SIDE_PADDING$1 = 1;
 const BOX_OVERHEAD = LEFT_MARGIN$1 + 2 + 2 * SIDE_PADDING$1;
@@ -417117,6 +417235,7 @@ function buildManagedUsageReportLines(options) {
 var { buildApprovalRejectionStop } = createRequire(import.meta.url)("./bin/approval-rejection-stop.cjs");
 var { reconcileContextBudget } = createRequire(import.meta.url)("./bin/context-budget-ledger.cjs");
 var { buildContextInsight } = createRequire(import.meta.url)("./bin/context-insight-policy.cjs");
+var { buildContextDoctor } = createRequire(import.meta.url)("./bin/context-doctor-policy.cjs");
 var { buildValidatedLearningInsight } = createRequire(import.meta.url)("./bin/validated-learning-insight-policy.cjs");
 var { readValidatedLearningCandidates } = createRequire(import.meta.url)("./bin/validated-learning-signal.cjs");
 function buildUsageReportLines(options) {
@@ -418210,6 +418329,41 @@ async function showContextInsight(host) {
 	host.state.transcriptContainer.addChild(panel);
 	host.state.ui.requestRender();
 }
+function buildContextDoctorLines(doctor) {
+	const value = (text) => currentTheme.fg("text", text);
+	const muted = (text) => currentTheme.fg("textDim", text);
+	const locale = getCurrentUiLocale();
+	const tokenValue = (tokens) => value(formatExactTokenCount(tokens, locale));
+	const line = (key, tokens, indent = 2) => `${" ".repeat(indent)}${muted(`${uiText(key)}:`)} ${tokenValue(tokens)}`;
+	const bar = currentTheme.fg(doctor.ratio >= 0.9 ? "error" : doctor.ratio >= 0.75 ? "warning" : "success", renderProgressBar(doctor.ratio, 20));
+	const lines = [
+		`  ${bar}  ${value(`${(doctor.ratio * 100).toFixed(1)}%`.padStart(6, " "))}  ${muted(`(${formatExactTokenCount(doctor.projectedTokens, locale)} / ${formatExactTokenCount(doctor.maxTokens, locale)})`)}`,
+		"",
+		line("export.system", doctor.system.totalTokens),
+		line("contextDoctor.core", doctor.system.coreTokens, 4),
+		line("contextDoctor.personality", doctor.system.personalityTokens, 4),
+		line("contextDoctor.social", doctor.system.socialTokens, 4),
+		line("contextDoctor.skills", doctor.system.skillTokens, 4),
+		line("contextDoctor.runtime", doctor.system.runtimeTokens, 4),
+		"",
+		line("mcp.capability.tools", doctor.tools.totalTokens),
+		line("contextDoctor.builtinTools", doctor.tools.builtinTokens, 4),
+		line("contextDoctor.userTools", doctor.tools.userTokens, 4),
+		line("contextDoctor.mcpTools", doctor.tools.mcpTokens, 4),
+		line("contextDoctor.otherTools", doctor.tools.otherTokens, 4),
+		"",
+		line("export.conversation", doctor.conversationTokens),
+		line("contextDoctor.providerOverhead", doctor.providerOverheadTokens),
+		`  ${muted(uiText("usage.plan.metric.remaining", { count: formatExactTokenCount(doctor.freeTokens, locale) }))}`
+	];
+	return lines;
+}
+async function showContextDoctor(host) {
+	const doctor = buildContextDoctor(await host.requireSession().getContext());
+	const panel = new UsagePanelComponent(() => buildContextDoctorLines(doctor), "primary", uiText("contextDoctor.title"));
+	host.state.transcriptContainer.addChild(panel);
+	host.state.ui.requestRender();
+}
 async function showUsage(host) {
 	const [sessionUsage, managedUsage, runtimeStatus] = await Promise.all([
 		loadSessionUsageReport(host),
@@ -495460,6 +495614,9 @@ async function handleBuiltInSlashCommand(host, name, args) {
 		case "context":
 			await showContextInsight(host);
 			return;
+		case "context-doctor":
+			await showContextDoctor(host);
+			return;
 		case "usage":
 			await showUsage(host);
 			return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.288",
+  "version": "9.1.290",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -56,6 +56,5 @@
   "dependencies": {
     "blun-king-cli": "^9.1.62",
     "node-addon-api": "^7.1.1"
-  },
-  "devDependencies": {}
+  }
 }