blun-king-cli 9.1.586 → 9.1.588

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

@@ -1,486 +0,0 @@
-'use strict';
-
-const TOOL_SCHEMA_BUDGET_RATIO = 0.35;
-const TOOL_SCHEMA_MAX_TOKENS = 64_000;
-const DEFERRED_TOOL_LOADER_NAME = 'ToolSearch';
-const MAX_PERSISTENT_DEFERRED_TOOLS = 12;
-const MAX_TOOL_SEARCH_QUERY_CHARS = 1_000;
-const MAX_AUTO_RANKED_TOOLS = 6;
-const TOOL_RANK_EMBEDDED_CONTENT_RE = /<(attached_documents?|attachment_content|document_content|file_content)\b[^>]*>[\s\S]*?<\/\1>/giu;
-const TOOL_RANK_STOP_WORDS = new Set([
-  'aber', 'also', 'and', 'aus', 'bitte', 'can', 'das', 'den', 'der', 'des', 'die', 'dies', 'diese',
-  'du', 'ein', 'eine', 'einer', 'eines', 'for', 'fuer', 'für', 'haben', 'ich', 'ist', 'kann', 'kannst',
-  'mal', 'me', 'mein', 'meine', 'mir', 'mit', 'of', 'please', 'soll', 'the', 'und', 'uns', 'von',
-  'was', 'wir', 'with', 'you', 'zeige', 'zeig', 'pruefe', 'prüfe', 'lies', 'read', 'show', 'get',
-]);
-const TOOL_SEARCH_INTENT_WORDS = new Set([
-  'find', 'fetch', 'get', 'holen', 'list', 'read', 'search', 'show', 'anzeigen', 'lesen', 'suchen',
-]);
-const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
-  Object.freeze([
-    'checklist', 'list', 'liste', 'listen',
-  ]),
-  Object.freeze([
-    'aufgabe', 'aufgaben', 'aufgabenliste', 'todo', 'todos',
-  ]),
-  Object.freeze([
-    'current', 'inbox', 'latest', 'message', 'messages', 'nachricht', 'nachrichten', 'queue', 'queued',
-    'recent', 'letzte', 'letzten', 'letzter', 'vergangen', 'update', 'updates',
-  ]),
-  Object.freeze([
-    'chat', 'conversation', 'history', 'log', 'logs', 'processed', 'protokoll', 'transcript', 'verlauf',
-  ]),
-  Object.freeze([
-    'fact', 'facts', 'fakt', 'fakten', 'memory', 'memories', 'merk', 'merken', 'note', 'notes',
-    'persist', 'persistent', 'profile', 'remember', 'save', 'speichern', 'store',
-  ]),
-]);
-const TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS = new Set([
-  'fact', 'facts', 'fakt', 'fakten', 'memory', 'memories', 'merk', 'merken', 'note', 'notes',
-  'persist', 'persistent', 'profile', 'remember', 'save', 'speichern', 'store', 'transcript',
-]);
-const CORE_TOOL_NAMES = Object.freeze([
-  'Bash',
-  'Read',
-  'ReadBatch',
-  'Edit',
-  'Grep',
-  'Write',
-  'Glob',
-  'TodoList',
-  'mcp__plugin-telegram_telegram__reply',
-]);
-
-const IMAGE_MEDIA_TERM_RE = /(?:^|[^\p{L}])(?:bild(?:er)?|foto(?:s)?|grafik(?:en)?|illustration(?:en)?|logo(?:s)?|image|images|photo|photos|picture|pictures|illustration|illustrations|visual|visuals)(?=$|[^\p{L}])/u;
-const VIDEO_MEDIA_TERM_RE = /(?:^|[^\p{L}])(?:video(?:s)?|clip(?:s)?|film(?:e)?|animation(?:en)?|movie|movies)(?=$|[^\p{L}])/u;
-const ANIMATE_ACTION_RE = /(?:^|[^\p{L}])(?:animier(?:e|en|t)?|animate|animated|animating)(?=$|[^\p{L}])/u;
-const CREATE_ACTION_RE = /(?:^|[^\p{L}])(?:erstell(?:e|en|t)?|generier(?:e|en|t)?|erzeug(?:e|en|t)?|produzier(?:e|en|t)?|zeichn(?:e|en|et)?|mal(?:e|en|t)?|render(?:e|n|t)?|mach(?:e|en|t)?|create|creates|creating|generate|generates|generating|make|makes|making|draw|draws|drawing|paint|paints|painting|render|renders|rendering|produce|produces|producing)(?=$|[^\p{L}])/u;
-const REQUEST_PREFIX_RE = /^(?:bitte\s+|please\s+)?(?:erstell|generier|erzeug|produzier|zeichn|mal|render|mach|animier|create|generate|make|draw|paint|render|produce|animate)/u;
-const REQUEST_PHRASE_RE = /(?:^|[^\p{L}])(?:bitte|kannst du|könntest du|ich möchte|ich will|ich brauche|please|can you|could you|i want|i need)(?=$|[^\p{L}])/u;
-
-function mediaGenerationToolNamesForText(value) {
-  const text = String(value || '').normalize('NFKC').trim().toLowerCase();
-  const selected = new Set();
-  if (!text) return selected;
-  if (/(?:^|[^a-z])generateimage(?=$|[^a-z])/u.test(text)) selected.add('GenerateImage');
-  if (/(?:^|[^a-z])generatevideo(?=$|[^a-z])/u.test(text)) selected.add('GenerateVideo');
-  if (selected.size > 0) return selected;
-
-  const animate = ANIMATE_ACTION_RE.test(text);
-  const create = CREATE_ACTION_RE.test(text);
-  const explicitRequest = REQUEST_PREFIX_RE.test(text) || REQUEST_PHRASE_RE.test(text);
-  if (!explicitRequest || (!create && !animate)) return selected;
-  if (animate && (IMAGE_MEDIA_TERM_RE.test(text) || VIDEO_MEDIA_TERM_RE.test(text))) {
-    selected.add('GenerateVideo');
-    return selected;
-  }
-  if (IMAGE_MEDIA_TERM_RE.test(text)) selected.add('GenerateImage');
-  if (VIDEO_MEDIA_TERM_RE.test(text)) selected.add('GenerateVideo');
-  return selected;
-}
-
-function mediaToolNamesForTurnText(value) {
-  const text = String(value || '');
-  const selected = new Set();
-  const channelBodies = [...text.matchAll(
-    /(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu,
-  )].map((match) => match[1]);
-  const intentTexts = channelBodies.length > 0 ? channelBodies : [text];
-
-  for (const intentText of intentTexts) {
-    for (const name of mediaGenerationToolNamesForText(intentText)) selected.add(name);
-  }
-
-  if (/\bimage_path\s*=\s*["'][^"']+["']/iu.test(text)) {
-    selected.add('ReadMediaFile');
-    selected.add('UnderstandImage');
-  }
-  if (/\battachment_file_id\s*=\s*["'][^"']+["']/iu.test(text)) {
-    selected.add('mcp__plugin-telegram_telegram__download_attachment');
-    selected.add('UnderstandImage');
-  }
-  return selected;
-}
-
-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 deferredToolCatalog(tools) {
-  const names = deferredToolNames(tools);
-  const leaves = names.map((name) => name.split(/__|:/).at(-1) || name);
-  const leafCounts = new Map();
-  for (const leaf of leaves) leafCounts.set(leaf, (leafCounts.get(leaf) || 0) + 1);
-  return names.map((name, index) => leafCounts.get(leaves[index]) === 1 ? leaves[index] : name)
-    .sort((left, right) => left.localeCompare(right));
-}
-
-function normalizeDeferredToolQuery(value) {
-  const query = String(value ?? '').trim();
-  if (query.length <= MAX_TOOL_SEARCH_QUERY_CHARS) return query;
-  const bounded = query.slice(0, MAX_TOOL_SEARCH_QUERY_CHARS);
-  const wordBoundary = bounded.lastIndexOf(' ');
-  return (wordBoundary >= MAX_TOOL_SEARCH_QUERY_CHARS * 0.8
-    ? bounded.slice(0, wordBoundary)
-    : bounded).trimEnd();
-}
-
-function searchDeferredTools(tools, query) {
-  const normalized = normalizeDeferredToolQuery(query).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('+'));
-  const eligibleTools = tools.filter((tool) => {
-    const name = String(tool?.name || '').toLowerCase();
-    return requiredNameTokens.every((token) => name.includes(token));
-  });
-  const firstSelector = searchTokens[0];
-  if (firstSelector) {
-    const exactNameMatches = eligibleTools.filter((tool) => String(tool?.name || '').toLowerCase() === firstSelector);
-    if (exactNameMatches.length === 1) return exactNameMatches;
-    const exactLeafMatches = eligibleTools.filter((tool) => {
-      const name = String(tool?.name || '').toLowerCase();
-      return name.split(/__|:/).at(-1) === firstSelector;
-    });
-    if (exactLeafMatches.length === 1) return exactLeafMatches;
-  }
-  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 relatedSearchTerms(token) {
-  const group = TOOL_SEARCH_RELATED_TERM_GROUPS.find((terms) => terms.includes(token));
-  return group || [token];
-}
-
-function rankingIntentTexts(value) {
-  const text = String(value || '');
-  const channelBodies = [...text.matchAll(
-    /(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu,
-  )].map((match) => match[1]);
-  const intentTexts = channelBodies.length > 0 ? channelBodies : [text];
-  return intentTexts.map((intentText) => normalizeDeferredToolQuery(
-    intentText.replace(TOOL_RANK_EMBEDDED_CONTENT_RE, ' '),
-  ));
-}
-
-function rankingTokens(value) {
-  return [...new Set(String(value || '')
-    .normalize('NFKC')
-    .toLowerCase()
-    .match(/[\p{L}\p{N}]{3,}/gu) || [])]
-    .filter((token) => !TOOL_RANK_STOP_WORDS.has(token));
-}
-
-function toolRankingDocument(tool) {
-  const name = String(tool?.name || '');
-  const leaf = name.split(/__|:/).at(-1) || name;
-  const splitToolName = (value) => String(value || '')
-    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-    .replaceAll('_', ' ');
-  const nameTokens = rankingTokens(`${splitToolName(name)} ${splitToolName(leaf)}`);
-  const descriptionTokens = rankingTokens(tool?.description);
-  const parameterText = [];
-  const properties = tool?.parameters?.properties;
-  if (properties && typeof properties === 'object') {
-    for (const [parameterName, definition] of Object.entries(properties)) {
-      parameterText.push(parameterName, definition?.description || '');
-    }
-  }
-  const exampleText = Array.isArray(tool?.examples)
-    ? tool.examples.map((example) => example?.prompt || '').join(' ')
-    : '';
-  return {
-    name,
-    nameTokens: new Set(nameTokens),
-    descriptionTokens: new Set(descriptionTokens),
-    detailTokens: new Set(rankingTokens(`${parameterText.join(' ')} ${exampleText}`)),
-  };
-}
-
-function tokenMatchScore(document, token) {
-  if (document.nameTokens.has(token)) return 10;
-  if (document.descriptionTokens.has(token)) return 5;
-  if (document.detailTokens.has(token)) return 4;
-  const related = relatedSearchTerms(token).filter((term) => term !== token);
-  if (related.some((term) => document.nameTokens.has(term))) return 5;
-  if (related.some((term) => document.descriptionTokens.has(term))) return 3;
-  if (related.some((term) => document.detailTokens.has(term))) return 2;
-  return 0;
-}
-
-/**
- * Select a tiny, high-confidence subset of deferred schemas for the current
- * request. This mirrors AnythingLLM's tool-reranker boundary without adding an
- * embedding runtime: King reuses the descriptions it already owns and keeps
- * ToolSearch available whenever the lexical evidence is weak or ambiguous.
- */
-function rankedToolNamesForTurnText(tools, value, options = {}) {
-  const maxTools = Math.max(0, Math.min(
-    MAX_AUTO_RANKED_TOOLS,
-    Number.isInteger(options.maxTools) ? options.maxTools : MAX_AUTO_RANKED_TOOLS,
-  ));
-  if (maxTools === 0) return new Set();
-  const queryTokens = [...new Set(rankingIntentTexts(value).flatMap(rankingTokens))];
-  if (queryTokens.length === 0) return new Set();
-
-  const ranked = (Array.isArray(tools) ? tools : []).map((tool) => {
-    const document = toolRankingDocument(tool);
-    if (!document.name) return null;
-    let score = 0;
-    let matchedTokens = 0;
-    let exactNameMatches = 0;
-    let relatedNameMatches = 0;
-    for (const token of queryTokens) {
-      const tokenScore = tokenMatchScore(document, token);
-      if (tokenScore === 0) continue;
-      score += tokenScore;
-      matchedTokens += 1;
-      if (document.nameTokens.has(token)) exactNameMatches += 1;
-      else if (relatedSearchTerms(token).some((term) => document.nameTokens.has(term))) relatedNameMatches += 1;
-    }
-    const highConfidence = matchedTokens >= 2
-      || (exactNameMatches >= 1 && score >= 10)
-      || (relatedNameMatches >= 1 && score >= 5);
-    return highConfidence ? { name: document.name, score, matchedTokens, exactNameMatches } : null;
-  }).filter(Boolean).sort((left, right) => (
-    right.matchedTokens - left.matchedTokens
-    || right.score - left.score
-    || right.exactNameMatches - left.exactNameMatches
-    || left.name.localeCompare(right.name)
-  ));
-
-  return new Set(ranked.slice(0, maxTools).map((entry) => entry.name));
-}
-
-function rankedSupportToolNamesForGoal(tools, goal, origin) {
-  if (origin?.kind !== 'system_trigger' || origin?.name !== 'goal_continuation') return new Set();
-  if (goal?.status !== 'active') return new Set();
-  const checkpoint = goal.actionCheckpoint;
-  if (checkpoint?.phase === 'wait' || checkpoint?.nextTrigger?.kind !== 'immediate') return new Set();
-  const supportChoice = String(checkpoint?.problemFrame?.supportChoice ?? '').trim();
-  const explicitSupport = supportChoice.match(/^(?:tool|skill)\s*:\s*(.+)$/iu);
-  if (!explicitSupport?.[1]) return new Set();
-  return rankedToolNamesForTurnText(tools, supportChoice, { maxTools: 1 });
-}
-
-function searchRelatedDeferredTools(tools, query, options = {}) {
-  const normalized = normalizeDeferredToolQuery(query).toLowerCase();
-  if (!normalized || normalized.startsWith('select:')) return [];
-  const tokens = normalized.split(/\s+/).filter(Boolean);
-  const requestedNameTokens = tokens
-    .filter((token) => token.startsWith('+'))
-    .map((token) => token.slice(1))
-    .filter(Boolean);
-  const relaxRequiredNameTokens = options.relaxRequiredNameTokens === true
-    && requestedNameTokens.length > 0;
-  const requiredNameTokens = relaxRequiredNameTokens ? [] : requestedNameTokens;
-  const searchTokens = [
-    ...tokens.filter((token) => !token.startsWith('+')),
-    ...(relaxRequiredNameTokens ? requestedNameTokens : []),
-  ]
-    .filter((token) => !TOOL_SEARCH_INTENT_WORDS.has(token));
-  if (searchTokens.length < 2 && !TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS.has(searchTokens[0])) return [];
-  const minimumMatchedTokens = searchTokens.length === 1 ? 1 : Math.max(2, Math.ceil(searchTokens.length * 0.75));
-
-  const ranked = tools.map((tool) => {
-    const name = String(tool?.name || '').toLowerCase();
-    const description = String(tool?.description || '').toLowerCase();
-    if (!requiredNameTokens.every((token) => name.includes(token))) return null;
-    let matchedTokens = 0;
-    let score = requiredNameTokens.length * 8;
-    for (const token of searchTokens) {
-      if (name.includes(token)) {
-        matchedTokens += 1;
-        score += 8;
-        continue;
-      }
-      if (description.includes(token)) {
-        matchedTokens += 1;
-        score += 4;
-        continue;
-      }
-      const related = relatedSearchTerms(token).filter((term) => term !== token);
-      if (related.some((term) => name.includes(term))) {
-        matchedTokens += 1;
-        score += 3;
-      } else if (related.some((term) => description.includes(term))) {
-        matchedTokens += 1;
-        score += 2;
-      }
-    }
-    return matchedTokens >= minimumMatchedTokens ? { tool, score, matchedTokens } : null;
-  }).filter(Boolean).sort((left, right) => (
-    right.matchedTokens - left.matchedTokens
-    || right.score - left.score
-    || String(left.tool.name).localeCompare(String(right.tool.name))
-  ));
-  if (relaxRequiredNameTokens && ranked.length > 0) {
-    const best = ranked[0];
-    return ranked.filter((entry) => (
-      entry.matchedTokens === best.matchedTokens && entry.score === best.score
-    )).slice(0, 5).map((entry) => entry.tool);
-  }
-  return ranked.slice(0, 5).map((entry) => entry.tool);
-}
-
-function rememberLoadedTool(loadedToolNames, name) {
-  loadedToolNames.delete(name);
-  loadedToolNames.add(name);
-  while (loadedToolNames.size > MAX_PERSISTENT_DEFERRED_TOOLS) {
-    loadedToolNames.delete(loadedToolNames.values().next().value);
-  }
-}
-
-function rememberDeferredToolAfterNotFound(loadedToolNames, toolName, result) {
-  if (!(loadedToolNames instanceof Set) || result?.isError !== true) return false;
-  const name = String(toolName || '').trim();
-  if (!name || String(result?.output || '').trim() !== `Tool "${name}" not found`) return false;
-  rememberLoadedTool(loadedToolNames, name);
-  return true;
-}
-
-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 deferredCount = available.size;
-  const deferredLabel = deferredCount === 1 ? 'tool schema' : 'tool schemas';
-
-  return {
-    name: DEFERRED_TOOL_LOADER_NAME,
-    description: [
-      `Search ${deferredCount} deferred ${deferredLabel} without loading all definitions.`,
-      '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; the ${MAX_PERSISTENT_DEFERRED_TOOLS} most recently selected schemas remain loaded.`,
-    ].join('\n'),
-    parameters: {
-      type: 'object',
-      properties: {
-        query: {
-          type: 'string',
-          maxLength: MAX_TOOL_SEARCH_QUERY_CHARS,
-          description: 'Exact selection or keyword query, for example select:download_attachment or +slack send.',
-        },
-      },
-      required: ['query'],
-      additionalProperties: false,
-    },
-    resolveExecution(args) {
-      const query = normalizeDeferredToolQuery(args?.query);
-      return {
-        description: query ? `Searching tool schemas for ${query}` : 'Searching tool schemas',
-        approvalRule: DEFERRED_TOOL_LOADER_NAME,
-        execute: async () => {
-          let matches = searchDeferredTools([...available.values()], query);
-          let relatedFallback = false;
-          if (matches.length === 0) {
-            matches = searchRelatedDeferredTools([...available.values()], query);
-            relatedFallback = matches.length > 0;
-          }
-          if (matches.length === 0) {
-            matches = searchRelatedDeferredTools([...available.values()], query, {
-              relaxRequiredNameTokens: true,
-            });
-            relatedFallback = matches.length > 0;
-          }
-          if (matches.length === 0) {
-            const alreadyLoaded = query.toLowerCase().startsWith('select:')
-              ? searchDeferredTools(
-                selectedTools.filter((tool) => tool?.name !== DEFERRED_TOOL_LOADER_NAME),
-                query,
-              )
-              : [];
-            if (alreadyLoaded.length === 1) {
-              return {
-                isError: false,
-                output: `Tool schema already loaded: ${alreadyLoaded[0].name}. Invoke it now.`,
-              };
-            }
-            const loaderIndex = selectedTools.findIndex(
-              (tool) => tool?.name === DEFERRED_TOOL_LOADER_NAME,
-            );
-            if (loaderIndex >= 0) selectedTools.splice(loaderIndex, 1);
-            return {
-              isError: false,
-              output: [
-                `No eligible deferred tool is available for: ${query || '[empty query]'}.`,
-                'Do not retry ToolSearch with synonyms; removed for this turn.',
-                'use a loaded alternative or report the integration as unavailable.',
-              ].join(' '),
-            };
-          }
-          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);
-            rememberLoadedTool(loadedToolNames, name);
-            loaded.push(name);
-          }
-          return {
-            isError: false,
-            output: `${relatedFallback ? 'Loaded related tool schemas' : 'Loaded tool schemas'}: ${loaded.join(', ')}. Invoke them in the next step.`,
-          };
-        },
-      };
-    },
-  };
-}
-
-module.exports = {
-  CORE_TOOL_NAMES,
-  DEFERRED_TOOL_LOADER_NAME,
-  MAX_PERSISTENT_DEFERRED_TOOLS,
-  MAX_AUTO_RANKED_TOOLS,
-  MAX_TOOL_SEARCH_QUERY_CHARS,
-  TOOL_SCHEMA_BUDGET_RATIO,
-  TOOL_SCHEMA_MAX_TOKENS,
-  createDeferredToolLoader,
-  deferredToolCatalog,
-  deferredToolNames,
-  mediaGenerationToolNamesForText,
-  mediaToolNamesForTurnText,
-  normalizeDeferredToolQuery,
-  rankedSupportToolNamesForGoal,
-  rankedToolNamesForTurnText,
-  rememberDeferredToolAfterNotFound,
-  toolSchemaBudgetTokens,
-};

package/bin/usage-cache-efficiency-policy.cjs

@@ -1,26 +0,0 @@
-'use strict';
-
-function wholeNonNegative(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.floor(value);
-}
-
-function buildCacheEfficiency(usage = {}) {
-  const uncachedTokens = wholeNonNegative(usage.inputOther);
-  const readTokens = wholeNonNegative(usage.inputCacheRead);
-  const writeTokens = wholeNonNegative(usage.inputCacheCreation);
-  const inputTokens = uncachedTokens + readTokens + writeTokens;
-
-  return {
-    hasActivity: readTokens > 0 || writeTokens > 0,
-    hitRate: inputTokens > 0 ? Math.min(1, readTokens / inputTokens) : 0,
-    inputTokens,
-    readTokens,
-    writeTokens,
-  };
-}
-
-module.exports = {
-  buildCacheEfficiency,
-  wholeNonNegative,
-};

package/bin/user-home-path-policy.cjs

@@ -1,13 +0,0 @@
-"use strict";
-
-function quotedPath(path) {
-  return `'${path.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
-}
-
-function unsupportedUserHomePathError(path) {
-  if (typeof path !== "string" || !path.startsWith("~")) return undefined;
-  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) return undefined;
-  return `Named home-directory paths are not supported: ${quotedPath(path)}. Use '~/' for the current user or './' for a literal path.`;
-}
-
-module.exports = { unsupportedUserHomePathError };

package/bin/user-message-offload-policy.cjs

@@ -1,103 +0,0 @@
-'use strict';
-
-const {
-  hasHistoricalOffloadPressure,
-  historyTextChars,
-} = require('./history-offload-pressure-policy.cjs');
-const { hasContextPressure } = require('./context-pressure-policy.cjs');
-
-const USER_MESSAGE_MAX_CHARS = 200_000;
-const HISTORICAL_USER_MESSAGE_MAX_CHARS = 4_000;
-const USER_MESSAGE_KEEP_RECENT_MESSAGES = 20;
-const USER_MESSAGE_PREVIEW_LINES = 5;
-const USER_MESSAGE_PREVIEW_LINE_CHARS = 1_000;
-const USER_MESSAGE_OFFLOAD_MARKER = '[User message offloaded]';
-
-function shouldOffloadUserMessage(textChars) {
-  return Number.isSafeInteger(textChars) && textChars >= USER_MESSAGE_MAX_CHARS;
-}
-
-function shouldOffloadHistoricalUserMessage(options = {}) {
-  const historyIndex = Number(options.historyIndex);
-  const historyLength = Number(options.historyLength);
-  const historyChars = Number(options.historyChars);
-  const textChars = Number(options.textChars);
-  if (
-    !Number.isSafeInteger(historyIndex)
-    || !Number.isSafeInteger(historyLength)
-    || !Number.isSafeInteger(textChars)
-    || historyIndex < 0
-    || historyLength < 0
-    || historyIndex >= historyLength
-  ) return false;
-  const cutoff = Math.max(0, historyLength - USER_MESSAGE_KEEP_RECENT_MESSAGES);
-  return hasContextPressure(options)
-    && hasHistoricalOffloadPressure({ historyLength, historyChars })
-    && historyIndex < cutoff
-    && textChars > HISTORICAL_USER_MESSAGE_MAX_CHARS;
-}
-
-function createUserMessagePreview(text) {
-  const lines = String(text).split(/\r?\n/u);
-  const render = (line, index) => `${index}: ${line.slice(0, USER_MESSAGE_PREVIEW_LINE_CHARS)}`;
-  if (lines.length <= USER_MESSAGE_PREVIEW_LINES * 2) {
-    return lines.map((line, index) => render(line, index + 1)).join('\n');
-  }
-  const head = lines.slice(0, USER_MESSAGE_PREVIEW_LINES)
-    .map((line, index) => render(line, index + 1));
-  const tailStart = lines.length - USER_MESSAGE_PREVIEW_LINES;
-  const tail = lines.slice(tailStart)
-    .map((line, index) => render(line, tailStart + index + 1));
-  return [
-    ...head,
-    `... [${lines.length - USER_MESSAGE_PREVIEW_LINES * 2} lines omitted] ...`,
-    ...tail,
-  ].join('\n');
-}
-
-function compactHistoricalPersistedUserMessageReferences(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-
-  const recentStart = Math.max(0, messages.length - USER_MESSAGE_KEEP_RECENT_MESSAGES);
-  return messages.map((message, index) => {
-    if (
-      index >= recentStart
-      || message?.role !== 'user'
-      || message.origin?.kind !== 'user'
-      || !Array.isArray(message.content)
-    ) return message;
-
-    let changed = false;
-    const content = message.content.map((part) => {
-      if (
-        part?.type !== 'text'
-        || typeof part.text !== 'string'
-        || !part.text.startsWith(`${USER_MESSAGE_OFFLOAD_MARKER}\n`)
-        || !part.text.includes('\noutput_path: ')
-      ) return part;
-      const previewIndex = part.text.indexOf('\n[preview: head and tail]\n');
-      if (previewIndex < 0) return part;
-      changed = true;
-      return {
-        ...part,
-        text: part.text.slice(0, previewIndex).trimEnd(),
-      };
-    });
-
-    return changed ? { ...message, content } : message;
-  });
-}
-
-module.exports = {
-  HISTORICAL_USER_MESSAGE_MAX_CHARS,
-  USER_MESSAGE_MAX_CHARS,
-  USER_MESSAGE_KEEP_RECENT_MESSAGES,
-  USER_MESSAGE_OFFLOAD_MARKER,
-  USER_MESSAGE_PREVIEW_LINES,
-  USER_MESSAGE_PREVIEW_LINE_CHARS,
-  compactHistoricalPersistedUserMessageReferences,
-  createUserMessagePreview,
-  historyTextChars,
-  shouldOffloadHistoricalUserMessage,
-  shouldOffloadUserMessage,
-};

package/bin/user-prompt-hook-origin-policy.cjs

@@ -1,34 +0,0 @@
-'use strict';
-
-const CHANNEL_TAG = /<channel\b([^>]*)>/iu;
-const SOURCE_ATTRIBUTE = /\bsource=["']([^"']+)["']/iu;
-const CHANNEL_SYSTEM_TRIGGERS = new Set(['channel', 'telegram']);
-
-function promptText(input) {
-  if (typeof input === 'string') return input;
-  if (!Array.isArray(input)) return '';
-  return input.map((part) => {
-    if (typeof part === 'string') return part;
-    return part && typeof part === 'object' && typeof part.text === 'string' ? part.text : '';
-  }).join(' ');
-}
-
-function channelSource(input) {
-  const tag = promptText(input).match(CHANNEL_TAG)?.[1] || '';
-  return tag.match(SOURCE_ATTRIBUTE)?.[1]?.trim().toLowerCase() || '';
-}
-
-function userPromptHookContext(input, origin = {}) {
-  const source = channelSource(input);
-  if (source) return Object.freeze({ turnSource: 'channel', channel: source, actor: 'channel' });
-  if (origin.kind === 'cron_job') {
-    return Object.freeze({ turnSource: 'schedule', channel: 'cron', actor: 'scheduler' });
-  }
-  if (origin.kind === 'system_trigger' && CHANNEL_SYSTEM_TRIGGERS.has(String(origin.name || '').toLowerCase())) {
-    return Object.freeze({ turnSource: 'channel', channel: String(origin.name).toLowerCase(), actor: 'channel' });
-  }
-  if (origin.kind === 'user') return Object.freeze({ turnSource: 'user', channel: 'blun-code', actor: 'user' });
-  return null;
-}
-
-module.exports = { channelSource, promptText, userPromptHookContext };

package/bin/user-tool-record-policy.cjs

@@ -1,7 +0,0 @@
-'use strict';
-
-function shouldRecordUserToolUnregister({ hasUserTool, isEnabled }) {
-  return Boolean(hasUserTool || isEnabled);
-}
-
-module.exports = { shouldRecordUserToolUnregister };