blun-king-cli 9.1.180 → 9.1.182

package/bin/launcher-mode.js

@@ -27,13 +27,19 @@ function launcherModeFromArgv(argv) {
 function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion) {
   return {
     ...sourceEnv,
-    BLUN_NO_AUTO_UPDATE: '1',
     BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
     BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',
     BLUN_TELEGRAM_HEADLESS: 'off',
   };
 }
 
+function createProtectedCoreEnvironment(sourceEnv) {
+  return {
+    ...sourceEnv,
+    BLUN_NO_AUTO_UPDATE: '1',
+  };
+}
+
 function isNpmPackageUpdateRequest(args) {
   if (!Array.isArray(args) || args.length !== 1) return false;
   const command = String(args[0] || '').toLowerCase();
@@ -47,6 +53,7 @@ function launcherHelpText() {
 module.exports = {
   LAUNCHER_MODES,
   createLauncherEnvironment,
+  createProtectedCoreEnvironment,
   isNpmPackageUpdateRequest,
   launcherHelpText,
   launcherModeFromArgv,

package/bin/launcher-runtime.js

@@ -11,6 +11,7 @@ const { spawn } = require('node:child_process');
 const {
   LAUNCHER_MODES,
   createLauncherEnvironment,
+  createProtectedCoreEnvironment,
   isNpmPackageUpdateRequest,
   launcherHelpText,
   launcherModeFromArgv,
@@ -18,6 +19,7 @@ const {
 const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
 const {
   availableStandardToolNames,
+  seedConfiguredMnemoMcp,
   seedStandardSkills,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
@@ -178,7 +180,7 @@ function spawnProtectedCore(args, env, cwd, options = {}) {
     {
       cwd,
       detached: shouldDetachProtectedCore(),
-      env,
+      env: createProtectedCoreEnvironment(env),
       stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
       windowsHide: true,
     },
@@ -683,6 +685,7 @@ async function runLauncher(options = {}) {
       blunDir,
       names: standardMcpNames,
     });
+    seedConfiguredMnemoMcp({ blunDir, env: process.env });
 
   // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
     seedStandardSkills({ packageRoot: PKG, blunDir: privatePaths.sharedHome });

package/bin/repeated-user-message-projection.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+const LONG_DUPLICATE_MIN_CHARS = 512;
+
+function userMessageText(message) {
+  if (
+    message?.role !== 'user'
+    || message.origin?.kind !== 'user'
+    || !Array.isArray(message.content)
+  ) return '';
+
+  const textParts = message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text);
+  return textParts.length > 0 ? textParts.join('\n') : '';
+}
+
+function channelAttribute(attributes, name) {
+  const match = String(attributes).match(new RegExp(`(?:^|\\s)${name}="([^"]+)"`, 'u'));
+  return match?.[1] ?? '';
+}
+
+function telegramDeliveryIdentity(text) {
+  const channel = String(text).match(/<channel\b([^>]*)>/u);
+  if (channel === null) return '';
+
+  const source = channelAttribute(channel[1], 'source');
+  const chatId = channelAttribute(channel[1], 'chat_id');
+  const messageId = channelAttribute(channel[1], 'message_id');
+  if (source !== 'telegram' || !chatId || !messageId) return '';
+  return `${chatId}:${messageId}`;
+}
+
+function repeatedUserMessageKey(message) {
+  const text = userMessageText(message);
+  if (!text) return '';
+
+  const telegramIdentity = telegramDeliveryIdentity(text);
+  if (telegramIdentity) return `telegram:${telegramIdentity}`;
+  return text.length >= LONG_DUPLICATE_MIN_CHARS ? `text:${text}` : '';
+}
+
+function dedupeRepeatedUserMessages(messages) {
+  if (!Array.isArray(messages) || messages.length < 2) return messages;
+
+  const lastIndexByKey = new Map();
+  const keys = messages.map((message, index) => {
+    const key = repeatedUserMessageKey(message);
+    if (key) lastIndexByKey.set(key, index);
+    return key;
+  });
+
+  let changed = false;
+  const projected = messages.filter((message, index) => {
+    const key = keys[index];
+    const keep = !key || lastIndexByKey.get(key) === index;
+    if (!keep) changed = true;
+    return keep;
+  });
+  return changed ? projected : messages;
+}
+
+module.exports = {
+  LONG_DUPLICATE_MIN_CHARS,
+  dedupeRepeatedUserMessages,
+  telegramDeliveryIdentity,
+  userMessageText,
+};

package/bin/standard-tools-bootstrap.js

@@ -255,6 +255,44 @@ function seedStandardTools({
   return { added, updated, configPath };
 }
 
+function seedConfiguredMnemoMcp({
+  blunDir,
+  env = process.env,
+  execPath = process.execPath,
+}) {
+  const configPath = path.join(blunDir, 'mcp.json');
+  const entry = typeof env.BLUN_MNEMO_MCP === 'string' ? env.BLUN_MNEMO_MCP.trim() : '';
+  const agent = typeof env.BLUN_MNEMO_AGENT === 'string' ? env.BLUN_MNEMO_AGENT.trim() : '';
+  if (entry.length === 0 || agent.length === 0) {
+    return { added: false, reason: 'not_configured', configPath };
+  }
+  if (!fs.existsSync(entry)) return { added: false, reason: 'entry_missing', configPath };
+
+  ensurePrivateDirectory(blunDir);
+  if (fs.existsSync(configPath)) securePrivateFile(configPath);
+  const document = readMcpDocument(configPath);
+  const servers = { ...document.mcpServers };
+  const equivalent = Object.values(servers).some((config) => (
+    isObject(config)
+      && Array.isArray(config.args)
+      && config.args.some((argument) => argument === entry)
+  ));
+  if (Object.hasOwn(servers, 'mnemo') || equivalent) {
+    return { added: false, reason: 'already_configured', configPath };
+  }
+
+  const configuredNode = typeof env.BLUN_MNEMO_NODE === 'string'
+    ? env.BLUN_MNEMO_NODE.trim()
+    : '';
+  servers.mnemo = {
+    command: configuredNode || execPath,
+    args: [entry],
+    env: { MNEMO_AGENT: agent },
+  };
+  writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  return { added: true, reason: 'added', configPath };
+}
+
 function seedStandardSkills({ packageRoot, blunDir }) {
   const sourceRoot = path.join(packageRoot, 'standard-skills');
   const sourceRootStat = fs.lstatSync(sourceRoot);
@@ -344,6 +382,7 @@ function seedStandardDesignSkill(options) {
 module.exports = {
   availableStandardToolNames,
   readCatalogue,
+  seedConfiguredMnemoMcp,
   seedStandardDesignSkill,
   seedStandardSkills,
   seedStandardTools,

package/blun.mjs

@@ -75985,11 +75985,12 @@ var init_full = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/micro.ts
-var selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, projectHistoricalUnaddressedTelegramMessages, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, DEFAULT_CONFIG, MicroCompaction;
+var selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS, isPersistedToolResultReference, projectHistoricalUnaddressedTelegramMessages, dedupeRepeatedUserMessages, compactHistoricalSkillActivations, dedupeRecurringCronWakeups, dedupeRepeatedInjections, DEFAULT_CONFIG, MicroCompaction;
 var init_micro = __esmMin((() => {
 	({ selectMicroCompactionCutoff, MICRO_COMPACTION_RECENT_MESSAGES, MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED, MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS } = createRequire(import.meta.url)("./bin/micro-compaction-policy.cjs"));
 	({ isPersistedToolResultReference } = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs"));
 	({ projectHistoricalUnaddressedTelegramMessages } = createRequire(import.meta.url)("./bin/telegram-context-projection-policy.cjs"));
+	({ dedupeRepeatedUserMessages } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ compactHistoricalSkillActivations } = createRequire(import.meta.url)("./bin/skill-activation-performance-policy.cjs"));
 	({ dedupeRecurringCronWakeups, dedupeRepeatedInjections } = createRequire(import.meta.url)("./bin/repeated-injection-projection.cjs"));
 	init_tokens();
@@ -78967,7 +78968,8 @@ var init_context$2 = __esmMin((() => {
 			const anomalies = [];
 			const userOffloaded = this.agent.userMessageOffload.compact(messages);
 			const historicalUserReferencesProjected = compactHistoricalPersistedUserMessageReferences(userOffloaded);
-			const historicalTelegramProjected = projectHistoricalUnaddressedTelegramMessages(historicalUserReferencesProjected);
+			const duplicateUserMessagesProjected = dedupeRepeatedUserMessages(historicalUserReferencesProjected);
+			const historicalTelegramProjected = projectHistoricalUnaddressedTelegramMessages(duplicateUserMessagesProjected);
 			const result = project(this.agent.assistantMessageOffload.compact(this.agent.microCompaction.compact(compactHistoricalSuccessfulToolResults(this.agent.toolResultBatchOffload.compact(dedupeRecurringCronWakeups(dedupeRepeatedInjections(compactHistoricalSkillActivations(compactBaselineSkillInjections(historicalTelegramProjected)))))))), {
 				...options,
 				onAnomaly: (anomaly) => {

package/package.json

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