blun-king-cli 9.1.180 → 9.1.181

package/bin/launcher-runtime.js

@@ -18,6 +18,7 @@ const {
 const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
 const {
   availableStandardToolNames,
+  seedConfiguredMnemoMcp,
   seedStandardSkills,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
@@ -683,6 +684,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.181",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {