blun-king-cli 9.1.526 → 9.1.536

package/bin/todo-list-turn-policy.cjs

@@ -1,6 +1,109 @@
 'use strict';
 
 const TODO_LIST_TOOL_NAME = 'TodoList';
+const MAX_TODO_ITEMS = 32;
+const BASE_TODO_REFRESH_WORK_CALL_LIMIT = 8;
+const MAX_TODO_REFRESH_WORK_CALL_LIMIT = 64;
+const TODO_STALLED_WARNING_STREAK = 3;
+
+function canonicalStoredTodos(todos) {
+  if (!Array.isArray(todos)) return [];
+  return todos
+    .filter((todo) => todo?.status !== 'done')
+    .map((todo) => ({
+      title: String(todo?.title ?? ''),
+      status: String(todo?.status ?? ''),
+    }));
+}
+
+function semanticTodoFingerprint(todos) {
+  return JSON.stringify(canonicalStoredTodos(todos)
+    .map((todo) => `${todo.status}\0${todo.title}`)
+    .sort());
+}
+
+function todoTitleCounts(todos) {
+  const counts = new Map();
+  for (const todo of Array.isArray(todos) ? todos : []) {
+    const title = String(todo?.title ?? '');
+    counts.set(title, (counts.get(title) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function sameTitleCounts(left, right) {
+  if (left.size !== right.size) return false;
+  for (const [title, count] of left) {
+    if (right.get(title) !== count) return false;
+  }
+  return true;
+}
+
+function assessTodoListBounds(input) {
+  const currentTodos = canonicalStoredTodos(input?.currentTodos);
+  const nextTodos = canonicalStoredTodos(input?.nextTodos);
+  if (currentTodos.length > MAX_TODO_ITEMS) {
+    const currentTitles = todoTitleCounts(currentTodos);
+    const submittedTitles = todoTitleCounts(input?.nextTodos);
+    if (!sameTitleCounts(currentTitles, submittedTitles)) {
+      return {
+        block: true,
+        reason: `An oversized legacy TodoList may remove an unresolved legacy item only by submitting it as done. Do not add, omit, or rename items until the visible list is at or below ${String(MAX_TODO_ITEMS)}.`,
+      };
+    }
+
+    if (nextTodos.length > currentTodos.length) {
+      return {
+        block: true,
+        reason: `An oversized legacy TodoList must stay unchanged or shrink toward ${String(MAX_TODO_ITEMS)} visible items.`,
+      };
+    }
+
+    return undefined;
+  }
+
+  if (nextTodos.length <= MAX_TODO_ITEMS) return undefined;
+  return {
+    block: true,
+    reason: `TodoList accepts at most ${String(MAX_TODO_ITEMS)} visible items. Group the work into task-specific phases before continuing.`,
+  };
+}
+
+function todoRefreshWorkCallLimit(unchangedRefreshStreak) {
+  const exponent = Math.min(Math.max(Number(unchangedRefreshStreak) || 0, 0), 3);
+  return Math.min(
+    MAX_TODO_REFRESH_WORK_CALL_LIMIT,
+    BASE_TODO_REFRESH_WORK_CALL_LIMIT * (2 ** exponent),
+  );
+}
+
+function assessTodoMaintenanceUpdate(input) {
+  const changed = semanticTodoFingerprint(input?.currentTodos)
+    !== semanticTodoFingerprint(input?.nextTodos);
+  if (changed) {
+    return {
+      changed: true,
+      unchangedRefreshStreak: 0,
+      refreshWorkCallLimit: BASE_TODO_REFRESH_WORK_CALL_LIMIT,
+      preserveRecentEvidence: false,
+      requireConcreteProgress: false,
+      emitStalledWarning: false,
+    };
+  }
+
+  const previousStreak = Math.max(Number(input?.unchangedRefreshStreak) || 0, 0);
+  const hasNewEvidence = (Number(input?.recentEvidenceCount) || 0) > 0;
+  const unchangedRefreshStreak = hasNewEvidence ? previousStreak + 1 : previousStreak;
+  return {
+    changed: false,
+    unchangedRefreshStreak,
+    refreshWorkCallLimit: todoRefreshWorkCallLimit(unchangedRefreshStreak),
+    preserveRecentEvidence: true,
+    requireConcreteProgress: unchangedRefreshStreak >= 2,
+    emitStalledWarning: hasNewEvidence
+      && unchangedRefreshStreak === TODO_STALLED_WARNING_STREAK,
+  };
+}
 
 function enforceSingleTodoWritePerStep(context) {
   if (context?.toolCall?.name !== TODO_LIST_TOOL_NAME) return undefined;
@@ -18,4 +121,11 @@ function enforceSingleTodoWritePerStep(context) {
   };
 }
 
-module.exports = { enforceSingleTodoWritePerStep };
+module.exports = {
+  MAX_TODO_ITEMS,
+  assessTodoListBounds,
+  assessTodoMaintenanceUpdate,
+  canonicalStoredTodos,
+  enforceSingleTodoWritePerStep,
+  todoRefreshWorkCallLimit,
+};

package/bin/tool-result-offload-policy.cjs

@@ -78,6 +78,33 @@ function freshToolResultIds(messages) {
   return resultIds;
 }
 
+function currentUserTurnStartIndex(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return -1;
+
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === 'user' && message.origin?.kind === 'user') return index;
+  }
+  return -1;
+}
+
+function currentTurnReadToolResultIds(messages) {
+  const turnStart = currentUserTurnStartIndex(messages);
+  if (turnStart < 0) return new Set();
+
+  const resultIds = new Set();
+  for (let index = turnStart + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      if (call?.name !== 'Read') continue;
+      const id = call.id ?? call.toolCallId;
+      if (typeof id === 'string' && id.length > 0) resultIds.add(id);
+    }
+  }
+  return resultIds;
+}
+
 function compactPersistedToolResultReference(content) {
   if (!isPersistedToolResultReference(content)) return content;
 
@@ -318,6 +345,8 @@ module.exports = {
   compactHistoricalSuccessfulToolResults,
   compactPersistedToolResultReference,
   createToolResultPreview,
+  currentTurnReadToolResultIds,
+  currentUserTurnStartIndex,
   dedupeRepeatedSuccessfulToolResults,
   freshToolResultIds,
   isPersistedToolResultReference,

package/bin/turn-thinking-policy.cjs

@@ -7,7 +7,6 @@ const BOSNIAN_STANDALONE_CHAT = /^(?:zdravo|pozdrav|hvala|ćao|cao)[.!?]*$/iu;
 const IDENTITY_CHAT = /^(?:wer bist du|who are you|wie geht(?: es dir)?|how are you|na|kako si|kako je king|ko si ti|ko stoji iza tebe)[.!?]*$/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;
 const STANDALONE_CHAT_COMPLETION_TOKENS = 1024;
 const ADAPTIVE_LOW_COMPLETION_TOKENS = 4096;
 const STANDARD_TURN_MAX_COMPLETION_TOKENS = 24_576;
@@ -68,20 +67,12 @@ function capTurnCompletionTokens(maxOutputSize) {
 }
 
 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;
+  // A buffered steer belongs to an already-running work turn. It may add
+  // context, but must never replace that turn's model effort, tool catalog,
+  // history projection, or completion budget with the fast-chat profile.
+  void text;
+  void originKind;
+  return undefined;
 }
 
 module.exports = {

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

@@ -1,11 +1,11 @@
 'use strict';
 
-const TOOL_SCHEMA_BUDGET_RATIO = 0.25;
-const TOOL_SCHEMA_MAX_TOKENS = 32_000;
+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 = 4;
+const MAX_PERSISTENT_DEFERRED_TOOLS = 12;
 const MAX_TOOL_SEARCH_QUERY_CHARS = 1_000;
-const MAX_AUTO_RANKED_TOOLS = 2;
+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',
@@ -469,6 +469,7 @@ 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,

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

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+  hasHistoricalOffloadPressure,
+  historyTextChars,
+} = require('./history-offload-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;
@@ -14,6 +19,7 @@ function shouldOffloadUserMessage(textChars) {
 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)
@@ -24,7 +30,9 @@ function shouldOffloadHistoricalUserMessage(options = {}) {
     || historyIndex >= historyLength
   ) return false;
   const cutoff = Math.max(0, historyLength - USER_MESSAGE_KEEP_RECENT_MESSAGES);
-  return historyIndex < cutoff && textChars > HISTORICAL_USER_MESSAGE_MAX_CHARS;
+  return hasHistoricalOffloadPressure({ historyLength, historyChars })
+    && historyIndex < cutoff
+    && textChars > HISTORICAL_USER_MESSAGE_MAX_CHARS;
 }
 
 function createUserMessagePreview(text) {
@@ -87,6 +95,7 @@ module.exports = {
   USER_MESSAGE_PREVIEW_LINE_CHARS,
   compactHistoricalPersistedUserMessageReferences,
   createUserMessagePreview,
+  historyTextChars,
   shouldOffloadHistoricalUserMessage,
   shouldOffloadUserMessage,
 };