blun-king-cli 9.1.62 → 9.1.63

package/bin/context-performance-policy.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+const DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS = 256_000;
+const DEFAULT_COMPACTION_BLOCK_MAX_TOKENS = 288_000;
+
+function capCompactionThreshold(threshold, phase) {
+  if (threshold === undefined) return undefined;
+  const maximum = phase === "block"
+    ? DEFAULT_COMPACTION_BLOCK_MAX_TOKENS
+    : DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS;
+  return Math.min(threshold, maximum);
+}
+
+module.exports = {
+  DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS,
+  DEFAULT_COMPACTION_BLOCK_MAX_TOKENS,
+  capCompactionThreshold,
+};

package/bin/launcher-runtime.js

@@ -18,7 +18,7 @@ const {
 const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
 const {
   availableStandardToolNames,
-  seedStandardDesignSkill,
+  seedStandardSkills,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
 const { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE } = require('./core-bootstrap');
@@ -552,7 +552,7 @@ async function runLauncher(options = {}) {
     });
 
   // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
-    seedStandardDesignSkill({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
+    seedStandardSkills({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
 
     // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
     if (mode === LAUNCHER_MODES.KING) {

package/bin/package-regression-policy.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('node:fs');
+const zlib = require('node:zlib');
+
+function tarText(buffer, start, length) {
+  return buffer.subarray(start, start + length).toString('utf8').replace(/\0.*$/s, '').trim();
+}
+
+function listTarGzPaths(tarballPath) {
+  const archive = zlib.gunzipSync(fs.readFileSync(tarballPath));
+  const paths = [];
+  let offset = 0;
+  while (offset + 512 <= archive.length) {
+    const header = archive.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const name = tarText(header, 0, 100);
+    const prefix = tarText(header, 345, 155);
+    const sizeText = tarText(header, 124, 12);
+    const size = sizeText ? Number.parseInt(sizeText, 8) : 0;
+    if (!Number.isFinite(size)) throw new Error(`Ungueltige TAR-Groesse bei ${name || '[ohne Namen]'}`);
+    const fullName = [prefix, name].filter(Boolean).join('/').replaceAll('\\', '/');
+    if (fullName) paths.push(fullName);
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+  return paths;
+}
+
+function isStablePackagePath(filePath) {
+  const normalized = String(filePath || '').replaceAll('\\', '/');
+  if (!normalized || normalized.endsWith('/')) return false;
+  if (normalized.startsWith('package/dist-web/assets/')) return false;
+  if (normalized.startsWith('package/dist-web/vis/')) return false;
+  return normalized.startsWith('package/');
+}
+
+function validatePlannedRemovals(document) {
+  const removals = Array.isArray(document?.removals) ? document.removals : [];
+  for (const removal of removals) {
+    if (!isStablePackagePath(removal?.path)) throw new Error(`Ungueltiger Entfernungspfad: ${removal?.path || '[leer]'}`);
+    if (!String(removal?.reason || '').trim()) throw new Error(`Entfernungsgrund fehlt: ${removal.path}`);
+    if (!String(removal?.decisionRef || '').trim()) throw new Error(`Entscheidungsreferenz fehlt: ${removal.path}`);
+  }
+  return new Set(removals.map((removal) => removal.path.replaceAll('\\', '/')));
+}
+
+function findUnexpectedRemovals(previousPaths, currentPaths, plannedDocument = { removals: [] }) {
+  const current = new Set(currentPaths.map((entry) => String(entry).replaceAll('\\', '/')));
+  const planned = validatePlannedRemovals(plannedDocument);
+  return [...new Set(previousPaths
+    .map((entry) => String(entry).replaceAll('\\', '/'))
+    .filter(isStablePackagePath)
+    .filter((entry) => !current.has(entry) && !planned.has(entry)))]
+    .sort();
+}
+
+function comparePackagePaths(previousPaths, currentPaths, plannedDocument = { removals: [] }) {
+  const previousStablePaths = [...new Set(previousPaths
+    .map((entry) => String(entry).replaceAll('\\', '/'))
+    .filter(isStablePackagePath))];
+  const currentStablePaths = [...new Set(currentPaths
+    .map((entry) => String(entry).replaceAll('\\', '/'))
+    .filter(isStablePackagePath))];
+  return {
+    checkedStablePaths: previousStablePaths.length,
+    currentStablePaths: currentStablePaths.length,
+    unexpectedRemovals: findUnexpectedRemovals(previousStablePaths, currentStablePaths, plannedDocument),
+  };
+}
+
+module.exports = {
+  comparePackagePaths,
+  findUnexpectedRemovals,
+  isStablePackagePath,
+  listTarGzPaths,
+  validatePlannedRemovals,
+};

package/bin/provider-idle-timeout-policy.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+const DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 30 * 1000;
+
+function resolveProviderIdleTimeoutMs(configuredSeconds) {
+  return configuredSeconds === undefined
+    ? DEFAULT_PROVIDER_IDLE_TIMEOUT_MS
+    : configuredSeconds * 1000;
+}
+
+module.exports = {
+  DEFAULT_PROVIDER_IDLE_TIMEOUT_MS,
+  resolveProviderIdleTimeoutMs,
+};

package/bin/skill-listing-performance-policy.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const SKILL_DESCRIPTION_MAX_CHARS = 80;
+const FIRST_USE_SKILLS = new Set([
+  'agent-browser',
+  'windows-mcp',
+  'translate-native',
+  'native-diacritics',
+  'blun-app-design-system',
+]);
+
+function compactDescription(value) {
+  const normalized = String(value || '').replace(/\s+/g, ' ').trim();
+  if (normalized.length <= SKILL_DESCRIPTION_MAX_CHARS) return normalized;
+  return `${normalized.slice(0, SKILL_DESCRIPTION_MAX_CHARS - 1).trimEnd()}...`;
+}
+
+function renderCompactSkillEntry(skill) {
+  const name = String(skill?.name || '').trim();
+  if (!FIRST_USE_SKILLS.has(name.toLowerCase())) return `- ${name}`;
+  const description = compactDescription(skill?.description);
+  return description ? `- ${name}: ${description}` : `- ${name}`;
+}
+
+function renderCompactSkillListing(skills) {
+  return (Array.isArray(skills) ? skills : []).map(renderCompactSkillEntry).join('\n');
+}
+
+module.exports = {
+  SKILL_DESCRIPTION_MAX_CHARS,
+  renderCompactSkillEntry,
+  renderCompactSkillListing,
+};

package/bin/standard-tools-bootstrap.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { randomUUID } = require('node:crypto');
+const { createHash, randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -218,42 +218,96 @@ function seedStandardTools({
   return { added, updated, configPath };
 }
 
-function seedStandardDesignSkill({ packageRoot, blunDir }) {
-  const sourcePath = path.join(
-    packageRoot,
-    'standard-skills',
-    'blun-app-design-system',
-  );
-  const sourceStat = fs.lstatSync(sourcePath);
-  if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
-    throw new Error(`Ungueltiger BLUN-Standard-Skill: ${sourcePath}`);
+function seedStandardSkills({ packageRoot, blunDir }) {
+  const sourceRoot = path.join(packageRoot, 'standard-skills');
+  const sourceRootStat = fs.lstatSync(sourceRoot);
+  if (!sourceRootStat.isDirectory() || sourceRootStat.isSymbolicLink()) {
+    throw new Error(`Ungueltiges BLUN-Standard-Skill-Verzeichnis: ${sourceRoot}`);
   }
-
   const skillsDir = path.join(blunDir, 'skills');
   ensurePrivateDirectory(skillsDir);
-  const destinationPath = path.join(skillsDir, 'blun-app-design-system');
-  const installed = !fs.existsSync(destinationPath);
-  if (!installed) {
-    const destinationStat = fs.lstatSync(destinationPath);
-    if (!destinationStat.isDirectory() || destinationStat.isSymbolicLink()) {
-      throw new Error(`Ungueltiges Ziel fuer BLUN-Standard-Skill: ${destinationPath}`);
+  const markerPath = path.join(skillsDir, '.blun-standard-skills.json');
+  const installed = [];
+  const updated = [];
+  const destinationPaths = [];
+
+  const entries = fs.readdirSync(sourceRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
+    .sort((left, right) => left.name.localeCompare(right.name));
+  const fingerprint = createHash('sha256');
+  const visit = (directory, relative = '') => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
+      .sort((left, right) => left.name.localeCompare(right.name))) {
+      const sourcePath = path.join(directory, entry.name);
+      const relativePath = path.join(relative, entry.name).replaceAll('\\', '/');
+      if (entry.isSymbolicLink()) throw new Error(`Symlink im BLUN-Standard-Skill: ${sourcePath}`);
+      fingerprint.update(relativePath);
+      if (entry.isDirectory()) visit(sourcePath, relativePath);
+      else if (entry.isFile()) fingerprint.update(fs.readFileSync(sourcePath));
+      else throw new Error(`Ungueltiger Eintrag im BLUN-Standard-Skill: ${sourcePath}`);
     }
-  } else {
-    ensurePrivateDirectory(destinationPath);
+  };
+  visit(sourceRoot);
+  const sourceFingerprint = fingerprint.digest('hex');
+  let marker = null;
+  try {
+    marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+  } catch {
+    marker = null;
   }
-
-  fs.cpSync(sourcePath, destinationPath, {
-    recursive: true,
-    force: true,
-    errorOnExist: false,
+  const allDestinationsExist = entries.every((entry) => {
+    const destinationPath = path.join(skillsDir, entry.name);
+    destinationPaths.push(destinationPath);
+    if (!fs.existsSync(destinationPath)) return false;
+    const stat = fs.lstatSync(destinationPath);
+    return stat.isDirectory() && !stat.isSymbolicLink();
   });
-  securePrivateTree(destinationPath);
-  return { installed, updated: !installed, destinationPath };
+  if (marker?.fingerprint === sourceFingerprint && allDestinationsExist) {
+    return { installed, updated, destinationPaths, unchanged: true };
+  }
+  destinationPaths.length = 0;
+
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const destinationPath = path.join(skillsDir, entry.name);
+    const isInstalled = !fs.existsSync(destinationPath);
+    if (!isInstalled) {
+      const destinationStat = fs.lstatSync(destinationPath);
+      if (!destinationStat.isDirectory() || destinationStat.isSymbolicLink()) {
+        throw new Error(`Ungueltiges Ziel fuer BLUN-Standard-Skill: ${destinationPath}`);
+      }
+    } else {
+      fs.mkdirSync(destinationPath, { mode: 0o700 });
+    }
+
+    fs.cpSync(sourcePath, destinationPath, {
+      recursive: true,
+      force: true,
+      errorOnExist: false,
+    });
+    (isInstalled ? installed : updated).push(entry.name);
+    destinationPaths.push(destinationPath);
+  }
+
+  fs.writeFileSync(markerPath, `${JSON.stringify({ fingerprint: sourceFingerprint, skills: entries.map((entry) => entry.name) }, null, 2)}\n`, 'utf8');
+  if (process.platform !== 'win32') securePrivateTree(skillsDir);
+  return { installed, updated, destinationPaths, unchanged: false };
+}
+
+function seedStandardDesignSkill(options) {
+  const result = seedStandardSkills(options);
+  const name = 'blun-app-design-system';
+  return {
+    installed: result.installed.includes(name),
+    updated: result.updated.includes(name),
+    destinationPath: path.join(options.blunDir, 'skills', name),
+  };
 }
 
 module.exports = {
   availableStandardToolNames,
   readCatalogue,
   seedStandardDesignSkill,
+  seedStandardSkills,
   seedStandardTools,
 };

package/bin/turn-thinking-policy.cjs

@@ -0,0 +1,66 @@
+"use strict";
+
+const EXPLICIT_THINKING_INTENT = /\b(?:analy[sz](?:e|ing|is)|root\s+cause|investigat(?:e|ion)|debug(?:ging)?|architect(?:ure|ural)|plan(?:ning)?|review|audit|threat\s+model|refactor|optim(?:ize|ise|ization)|migration|complex|thorough|deep(?:ly)?|untersuch(?:e|ung)|analysier(?:e|en)?|ursachenanalyse|architektur|plan(?:e|ung)|pruef(?:e|ung)|sicherheit|migration|komplex|gruendlich|analiz(?:a|iraj)|istrazi|arhitektur|planiraj|sigurnost|duboko)\b/iu;
+const ACTIONABLE_PROMPT = /\b(?:aender|analys|apply|bau|build|check|commit|cop(?:y|ier)|create|debug|delete|deploy|edit|entfern|erstelle|find|fix|implement|install|lad|loesch|merge|mess|move|napravi|oeffne|open|patch|pruef|publish|push|read|reparier|restart|run|schreib|search|starte?|stop|such|test|update|verschieb|write|zieh)\w*\b/iu;
+const STANDALONE_CHAT = /^(?:hi|hallo|hey|hello|hoi|moin|servus|yo|danke|thanks|thx|bye|tschau|ciao)[.!?]*$/iu;
+const IDENTITY_CHAT = /^(?:wer bist du|who are you|wie geht(?: es dir)?|how are you|na)[.!?]*$/iu;
+const STATUS_ONLY_CHECK_IN = /(?:\bstandabfrage\b|\bstatusabfrage\b|\bkurzes?\s+update\b|\bwo\s+stehst\s+du\b|\bwie\s+weit\s+bist\s+du\b|\bwhere\s+are\s+you\b|\bquick\s+status\b)/iu;
+const STATUS_FOLLOW_UP_ACTION = /\b(?:aendere|arbeite|baue|build|change|delete|deploy|deploye|fahr|fix|fixe|implement|implementiere|install|installiere|loesche|mach|patch|pruefe|repariere|run|schreibe|setze|start|starte|stop|stoppe|test|teste|write)\b/iu;
+const LIGHTWEIGHT_STEER = /\b(?:cool|danke|dankeschoen|gute arbeit|passt|perfekt|stolz|super|freut mich)\b/iu;
+
+function selectThinkingEffortForTurn(text, originKind) {
+  if (originKind !== "user") return undefined;
+
+  const normalized = String(text ?? "").replace(/\s+/gu, " ").trim();
+  if (!normalized) return "low";
+
+  const lower = normalized.toLowerCase();
+  if (STANDALONE_CHAT.test(lower) || IDENTITY_CHAT.test(lower)) return "low";
+  if (
+    STATUS_ONLY_CHECK_IN.test(normalized)
+    && !STATUS_FOLLOW_UP_ACTION.test(normalized)
+    && !EXPLICIT_THINKING_INTENT.test(normalized)
+  ) return "low";
+  if (normalized.length > 180 || String(text ?? "").split(/\r?\n/u).length > 2) return undefined;
+  if (ACTIONABLE_PROMPT.test(normalized) || EXPLICIT_THINKING_INTENT.test(normalized)) return undefined;
+
+  const shortQuestion = /[?]\s*$/u.test(normalized)
+    || /^(?:was|wer|wie|warum|wieso|weshalb|wo|wann|welche?r?s?|what|who|how|why|where|when|which|can you|kannst du)\b/iu.test(normalized);
+  return shortQuestion ? "low" : undefined;
+}
+
+function shouldEnableThinkingForTurn(text, originKind) {
+  return selectThinkingEffortForTurn(text, originKind) !== "off";
+}
+
+function selectThinkingEffortForWorkStep(stepNumber, previousToolOutcome) {
+  const normalizedStep = Number(stepNumber);
+  if (!Number.isInteger(normalizedStep) || normalizedStep <= 1) return undefined;
+  return previousToolOutcome === "success" ? "low" : undefined;
+}
+
+function selectThinkingEffortForBufferedSteer(text, originKind) {
+  const classified = selectThinkingEffortForTurn(text, originKind);
+  if (classified !== undefined) return classified;
+  if (originKind !== "user") return undefined;
+
+  const normalized = String(text ?? "").replace(/\s+/gu, " ").trim();
+  if (
+    !normalized
+    || normalized.length > 180
+    || String(text ?? "").split(/\r?\n/u).length > 2
+    || ACTIONABLE_PROMPT.test(normalized)
+    || EXPLICIT_THINKING_INTENT.test(normalized)
+  ) return undefined;
+
+  return LIGHTWEIGHT_STEER.test(normalized) ? "low" : undefined;
+}
+
+module.exports = {
+  ACTIONABLE_PROMPT,
+  EXPLICIT_THINKING_INTENT,
+  selectThinkingEffortForBufferedSteer,
+  selectThinkingEffortForWorkStep,
+  selectThinkingEffortForTurn,
+  shouldEnableThinkingForTurn,
+};

package/bin/turn-tool-performance-policy.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+const TOOL_SCHEMA_BUDGET_RATIO = 0.25;
+const TOOL_SCHEMA_MAX_TOKENS = 32_000;
+const DEFERRED_TOOL_LOADER_NAME = 'ToolSearch';
+const CORE_TOOL_NAMES = Object.freeze([
+  'Bash',
+  'Read',
+  'Edit',
+  'Grep',
+  'Write',
+  'TodoList',
+  'Glob',
+  'TaskList',
+  'Agent',
+  'GetGoal',
+  'CronList',
+  'ReadMediaFile',
+  'TaskOutput',
+  'Skill',
+  'mcp__plugin-telegram_telegram__reply',
+  'mcp__plugin-telegram_telegram__react',
+  'mcp__plugin-telegram_telegram__edit_message',
+  'mcp__plugin-telegram_telegram__download_attachment',
+]);
+
+function toolSchemaBudgetTokens(maxContextTokens) {
+  const context = Number(maxContextTokens);
+  if (!Number.isFinite(context) || context <= 0) return TOOL_SCHEMA_MAX_TOKENS;
+  return Math.min(TOOL_SCHEMA_MAX_TOKENS, Math.floor(context * TOOL_SCHEMA_BUDGET_RATIO));
+}
+
+function deferredToolNames(tools) {
+  return [...new Set((Array.isArray(tools) ? tools : [])
+    .map((tool) => String(tool?.name || '').trim())
+    .filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}
+
+function searchDeferredTools(tools, query) {
+  const normalized = String(query || '').trim().toLowerCase();
+  if (!normalized) return [];
+  if (normalized.startsWith('select:')) {
+    const selector = normalized.slice('select:'.length).trim();
+    if (!selector) return [];
+    const exact = tools.find((tool) => String(tool?.name || '').toLowerCase() === selector);
+    if (exact) return [exact];
+    return tools.filter((tool) => {
+      const name = String(tool?.name || '').toLowerCase();
+      const leaf = name.split(/__|:/).at(-1);
+      return leaf === selector;
+    });
+  }
+
+  const tokens = normalized.split(/\s+/).filter(Boolean);
+  const requiredNameTokens = tokens.filter((token) => token.startsWith('+')).map((token) => token.slice(1)).filter(Boolean);
+  const searchTokens = tokens.filter((token) => !token.startsWith('+'));
+  return tools.map((tool) => {
+    const name = String(tool?.name || '').toLowerCase();
+    const description = String(tool?.description || '').toLowerCase();
+    if (!requiredNameTokens.every((token) => name.includes(token))) return null;
+    if (!searchTokens.every((token) => name.includes(token) || description.includes(token))) return null;
+    const score = searchTokens.reduce((total, token) => total + (name.includes(token) ? 5 : 1), 0)
+      + requiredNameTokens.length * 5;
+    return { tool, score };
+  }).filter(Boolean).sort((left, right) => right.score - left.score || String(left.tool.name).localeCompare(String(right.tool.name))).slice(0, 5).map((entry) => entry.tool);
+}
+
+function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames = new Set()) {
+  if (!Array.isArray(selectedTools)) throw new TypeError('selectedTools must be an array');
+  if (!(loadedToolNames instanceof Set)) throw new TypeError('loadedToolNames must be a Set');
+  const available = new Map();
+  for (const tool of Array.isArray(deferredTools) ? deferredTools : []) {
+    const name = String(tool?.name || '').trim();
+    if (name && !available.has(name)) available.set(name, tool);
+  }
+  const names = deferredToolNames([...available.values()]);
+
+  return {
+    name: DEFERRED_TOOL_LOADER_NAME,
+    description: [
+      'Find and load deferred tool schemas into this running session.',
+      'Use select:leaf_name for one known tool, plain keywords to search, or +word to require that word in the tool name.',
+      'Loaded tools are available in the next step and remain loaded for this session.',
+      `Available deferred tool names: ${names.join(', ')}`,
+    ].join('\n'),
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Exact selection or keyword query, for example select:download_attachment or +slack send.',
+        },
+      },
+      required: ['query'],
+      additionalProperties: false,
+    },
+    resolveExecution(args) {
+      const query = String(args?.query || '').trim();
+      return {
+        description: query ? `Searching tool schemas for ${query}` : 'Searching tool schemas',
+        approvalRule: DEFERRED_TOOL_LOADER_NAME,
+        execute: async () => {
+          const matches = searchDeferredTools([...available.values()], query);
+          if (matches.length === 0) {
+            return {
+              isError: true,
+              output: `No deferred tools matched: ${query || '[empty query]'}`,
+            };
+          }
+          if (query.toLowerCase().startsWith('select:') && matches.length !== 1) {
+            return {
+              isError: true,
+              output: `Tool selection is ambiguous: ${matches.map((tool) => tool.name).join(', ')}`,
+            };
+          }
+          const loaded = [];
+          for (const tool of matches) {
+            const name = String(tool.name);
+            if (!selectedTools.some((candidate) => candidate?.name === name)) selectedTools.push(tool);
+            loadedToolNames.add(name);
+            loaded.push(name);
+          }
+          return {
+            isError: false,
+            output: `Loaded tool schemas: ${loaded.join(', ')}. Invoke them in the next step.`,
+          };
+        },
+      };
+    },
+  };
+}
+
+module.exports = {
+  CORE_TOOL_NAMES,
+  DEFERRED_TOOL_LOADER_NAME,
+  TOOL_SCHEMA_BUDGET_RATIO,
+  TOOL_SCHEMA_MAX_TOKENS,
+  createDeferredToolLoader,
+  deferredToolNames,
+  toolSchemaBudgetTokens,
+};