blun-king-cli 9.1.527 → 9.1.550

package/bin/subagent-context-fork-policy.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+const DEFAULT_MAX_MESSAGES = 16;
+const DEFAULT_MAX_CHARS = 64 * 1024;
+const MAX_CONFIGURED_MESSAGES = 64;
+const MAX_CONFIGURED_CHARS = 256 * 1024;
+
+const SUBAGENT_FORK_REMINDER = [
+  'You received a bounded, redacted projection of the parent conversation.',
+  'It contains only direct local user text and completed text-only assistant replies.',
+  'It excludes system injections, private channel messages, attachments, tool calls, tool arguments, and tool results.',
+  'Treat that history as already happened. Your actual delegated task below is authoritative.',
+  'Do not launch another context fork. Return the requested result to the parent agent.',
+].join(' ');
+
+function boundedPositiveInteger(value, fallback, maximum, name) {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+    throw new TypeError(`${name} must be an integer between 1 and ${String(maximum)}`);
+  }
+  return value;
+}
+
+function resolveSubagentContextMode(options = {}) {
+  const requested = options.requested ?? 'isolated';
+  if (requested !== 'isolated' && requested !== 'fork') {
+    throw new TypeError('context_mode must be either "isolated" or "fork"');
+  }
+  if (requested === 'isolated') return requested;
+  if (options.resume === true) {
+    throw new Error('context_mode="fork" is available only when creating a new subagent, not while resuming one');
+  }
+  if (options.isRoot !== true) {
+    throw new Error('context_mode="fork" is available only to the root agent');
+  }
+  return requested;
+}
+
+function redactSecrets(value) {
+  return String(value)
+    .replaceAll(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/giu, '[redacted]')
+    .replaceAll(/\b(authorization)\s*:\s*(?:basic|bearer)\s+\S+/giu, '$1: [redacted]')
+    .replaceAll(/\b(api[_ -]?(?:key|token)|access[_ -]?token|refresh[_ -]?token|id[_ -]?token|token|secret|password|passwd|pwd|credential)\b\s*([:=])\s*(?:"[^"]*"|'[^']*'|\S+)/giu, '$1$2[redacted]')
+    .replaceAll(/\b(?:sk|ghp|xoxb|xoxp|token)[-_][A-Za-z0-9_-]{16,}\b/gu, '[redacted]')
+    .replaceAll(/\b[A-Za-z0-9][A-Za-z0-9+/=_-]{39,}\b/gu, '[redacted]');
+}
+
+function textContent(message) {
+  if (!Array.isArray(message?.content)) return '';
+  return message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n')
+    .trim();
+}
+
+function eligibleMessage(message) {
+  if (message?.role === 'user') {
+    if (message.origin?.kind !== 'user') return undefined;
+  } else if (message?.role === 'assistant') {
+    if (message.origin !== undefined) return undefined;
+    if (!Array.isArray(message.toolCalls) || message.toolCalls.length > 0) return undefined;
+  } else {
+    return undefined;
+  }
+  const text = textContent(message);
+  if (text.length === 0) return undefined;
+  return { role: message.role, text: redactSecrets(text) };
+}
+
+function modelMessage(role, text) {
+  return {
+    role,
+    content: [{ type: 'text', text }],
+    toolCalls: [],
+  };
+}
+
+function mergeAdjacent(messages) {
+  const merged = [];
+  for (const message of messages) {
+    const previous = merged.at(-1);
+    if (previous?.role === message.role) {
+      previous.content[0].text += `\n\n${message.content[0].text}`;
+    } else {
+      merged.push(modelMessage(message.role, message.content[0].text));
+    }
+  }
+  while (merged[0]?.role === 'assistant') merged.shift();
+  return merged;
+}
+
+function emptyProjection() {
+  return {
+    messages: [],
+    sourceMessageCount: 0,
+    sourceChars: 0,
+    truncatedOlderContext: false,
+  };
+}
+
+function projectSubagentForkContext(history, options = {}) {
+  if (!Array.isArray(history)) throw new TypeError('history must be an array');
+  const maxMessages = boundedPositiveInteger(
+    options.maxMessages,
+    DEFAULT_MAX_MESSAGES,
+    MAX_CONFIGURED_MESSAGES,
+    'maxMessages',
+  );
+  const maxChars = boundedPositiveInteger(
+    options.maxChars,
+    DEFAULT_MAX_CHARS,
+    MAX_CONFIGURED_CHARS,
+    'maxChars',
+  );
+  const eligible = history.map(eligibleMessage).filter((message) => message !== undefined);
+  const newestUserIndex = eligible.findLastIndex((message) => message.role === 'user');
+  if (newestUserIndex < 0) return emptyProjection();
+  const throughCurrentUser = eligible.slice(0, newestUserIndex + 1);
+  const newestUser = throughCurrentUser.at(-1);
+  if (newestUser.text.length > maxChars) {
+    throw new Error(`newest direct user message exceeds the ${String(maxChars)}-character fork context limit`);
+  }
+
+  const selected = [];
+  let sourceChars = 0;
+  let truncatedOlderContext = false;
+  for (let index = throughCurrentUser.length - 1; index >= 0; index -= 1) {
+    const message = throughCurrentUser[index];
+    if (selected.length >= maxMessages || sourceChars + message.text.length > maxChars) {
+      truncatedOlderContext = true;
+      break;
+    }
+    selected.push(modelMessage(message.role, message.text));
+    sourceChars += message.text.length;
+  }
+  selected.reverse();
+  const messages = mergeAdjacent(selected);
+  const retainedMessageCount = selected.length - selected.findIndex((message) => message.role === 'user');
+  return {
+    messages,
+    sourceMessageCount: retainedMessageCount,
+    sourceChars: messages.reduce((total, message) => total + message.content[0].text.replaceAll('\n\n', '').length, 0),
+    truncatedOlderContext,
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_CHARS,
+  DEFAULT_MAX_MESSAGES,
+  SUBAGENT_FORK_REMINDER,
+  projectSubagentForkContext,
+  redactSecrets,
+  resolveSubagentContextMode,
+};

package/bin/subagent-skill-policy.cjs

@@ -0,0 +1,204 @@
+'use strict';
+
+const { createHash } = require('node:crypto');
+
+const POLICY_VERSION = 1;
+const MAX_SKILLS = 32;
+const MAX_NAME_BYTES = 160;
+const INVALID_CODE = 'SUBAGENT_SKILL_POLICY_INVALID';
+const CHANGED_CODE = 'SUBAGENT_SKILL_POLICY_CHANGED';
+
+class SubagentSkillPolicyError extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.name = 'SubagentSkillPolicyError';
+    this.code = code;
+  }
+}
+
+function normalizeName(name) {
+  return name.toLowerCase();
+}
+
+function sha256(value) {
+  return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+
+function digestJson(value) {
+  return sha256(JSON.stringify(value));
+}
+
+function isInlineSkill(skill) {
+  const type = skill?.metadata?.type;
+  return type === undefined || type === 'prompt' || type === 'inline';
+}
+
+function frozenSkill(skill) {
+  const metadata = Object.freeze({ ...(skill.metadata || {}) });
+  const plugin = skill.plugin === undefined
+    ? undefined
+    : Object.freeze({ ...skill.plugin });
+  return Object.freeze({ ...skill, metadata, ...(plugin === undefined ? {} : { plugin }) });
+}
+
+function catalogEntry(skill) {
+  return {
+    name: normalizeName(skill.name),
+    source: skill.source ?? null,
+    path: skill.path ?? null,
+    metadata: {
+      type: skill.metadata.type ?? null,
+      disableModelInvocation: skill.metadata.disableModelInvocation === true,
+      isSubSkill: skill.metadata.isSubSkill === true,
+    },
+    plugin: skill.plugin === undefined
+      ? null
+      : {
+          id: skill.plugin.id ?? null,
+          instructionsSha256: sha256(skill.plugin.instructions ?? ''),
+        },
+    contentSha256: sha256(skill.content ?? ''),
+  };
+}
+
+function defaultModelListing(skills) {
+  if (skills.length === 0) return '';
+  return [
+    'Only the profile-allowed skills are available to this subagent.',
+    ...skills.map((skill) => `- ${skill.name}: ${skill.description ?? ''}`.trimEnd()),
+  ].join('\n');
+}
+
+function createRegistryView(selected, sourceRegistry, options) {
+  const ordered = Object.freeze([...selected].sort((a, b) => a.name.localeCompare(b.name)));
+  const byName = new Map(ordered.map((skill) => [normalizeName(skill.name), skill]));
+  const renderModelListing = options.renderModelListing ?? defaultModelListing;
+
+  return Object.freeze({
+    getSkill(name) {
+      return typeof name === 'string' ? byName.get(normalizeName(name)) : undefined;
+    },
+    listSkills() {
+      return [...ordered];
+    },
+    listInvocableSkills() {
+      return [...ordered];
+    },
+    getModelSkillListing() {
+      return renderModelListing([...ordered]);
+    },
+    renderSkillPrompt(skill, args) {
+      const expected = skill && typeof skill.name === 'string'
+        ? byName.get(normalizeName(skill.name))
+        : undefined;
+      if (expected === undefined || expected !== skill) {
+        throw new SubagentSkillPolicyError(INVALID_CODE, 'skill object is outside the profile allowlist');
+      }
+      return sourceRegistry.renderSkillPrompt(skill, args);
+    },
+  });
+}
+
+function validateNames(rawNames) {
+  if (rawNames === undefined) return [];
+  if (!Array.isArray(rawNames)) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, 'skills must be an array');
+  }
+  if (rawNames.length > MAX_SKILLS) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, `skills exceeds the ${MAX_SKILLS}-entry limit`);
+  }
+  const seen = new Set();
+  return rawNames.map((name) => {
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, 'skill names must be non-empty strings');
+    }
+    if (Buffer.byteLength(name, 'utf8') > MAX_NAME_BYTES) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill name exceeds ${MAX_NAME_BYTES} UTF-8 bytes`);
+    }
+    const normalized = normalizeName(name);
+    if (seen.has(normalized)) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `duplicate skill name "${name}"`);
+    }
+    seen.add(normalized);
+    return { requested: name, normalized };
+  });
+}
+
+function prepareSubagentSkillPolicy(rawNames, sourceRegistry, options = {}) {
+  if (sourceRegistry === undefined || sourceRegistry === null) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, 'session skill registry is unavailable');
+  }
+  const requested = validateNames(rawNames);
+  const selected = requested.map(({ requested: name, normalized }) => {
+    const skill = sourceRegistry.getSkill(name);
+    if (skill === undefined || normalizeName(skill.name) !== normalized) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" is not registered`);
+    }
+    if (skill.metadata?.disableModelInvocation === true) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" disables model invocation`);
+    }
+    if (!isInlineSkill(skill)) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" is not inline`);
+    }
+    return frozenSkill(skill);
+  });
+  const normalizedNames = Object.freeze(requested.map((entry) => entry.normalized));
+  const metadata = Object.freeze({
+    version: POLICY_VERSION,
+    names: normalizedNames,
+    profileDigest: digestJson(normalizedNames),
+    catalogDigest: digestJson(selected.map(catalogEntry)),
+  });
+  const enabled = selected.length > 0;
+  return Object.freeze({
+    enabled,
+    registry: enabled ? createRegistryView(selected, sourceRegistry, options) : null,
+    metadata,
+  });
+}
+
+function validPersistedPolicy(policy) {
+  return policy !== null
+    && typeof policy === 'object'
+    && policy.version === POLICY_VERSION
+    && Array.isArray(policy.names)
+    && typeof policy.profileDigest === 'string'
+    && typeof policy.catalogDigest === 'string';
+}
+
+function restoreSubagentSkillPolicy(rawNames, persistedPolicy, sourceRegistry, options = {}) {
+  if (!validPersistedPolicy(persistedPolicy)) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, 'persisted skill policy is missing or invalid');
+  }
+  let prepared;
+  try {
+    prepared = prepareSubagentSkillPolicy(rawNames, sourceRegistry, options);
+  } catch (error) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, error instanceof Error ? error.message : String(error));
+  }
+  if (JSON.stringify(prepared.metadata.names) !== JSON.stringify(persistedPolicy.names)
+      || prepared.metadata.profileDigest !== persistedPolicy.profileDigest
+      || prepared.metadata.catalogDigest !== persistedPolicy.catalogDigest) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, 'profile or selected skill catalog changed; spawn a new subagent');
+  }
+  return prepared;
+}
+
+function profileWithSubagentSkillTools(profile, policy) {
+  const withoutSkill = profile.tools.filter((name) => name !== 'Skill');
+  const tools = policy.enabled ? [...withoutSkill, 'Skill'] : withoutSkill;
+  return Object.freeze({ ...profile, tools: Object.freeze(tools) });
+}
+
+module.exports = {
+  CHANGED_CODE,
+  INVALID_CODE,
+  MAX_NAME_BYTES,
+  MAX_SKILLS,
+  POLICY_VERSION,
+  SubagentSkillPolicyError,
+  prepareSubagentSkillPolicy,
+  profileWithSubagentSkillTools,
+  restoreSubagentSkillPolicy,
+};
+

package/bin/telegram-approval-relay.cjs

@@ -168,11 +168,12 @@ function beginTelegramApprovalRelay(payload, options = {}) {
     if (settled) return false;
     settled = true;
     if (interval !== undefined) clearInterval(interval);
+    const persistedResponse = response?.decision === 'edited' ? { decision: 'edited' } : response;
     atomicWriteJson(resolvedFile, {
       v: RELAY_VERSION,
       requestId: request.requestId,
       resolvedAt: Date.now(),
-      response,
+      response: persistedResponse,
     });
     resolvePromise(response);
     return true;

package/bin/telegram-direct-focus-policy.cjs

@@ -10,6 +10,9 @@ const CONVERSATION_CLOSE = /^(?:danke(?: dir)?|dankesch(?:oe|\u00f6)n|alles klar
 const EXPLICIT_PAUSE = /^(?:(?:bitte\s+)?(?:pause|pausier(?:e)?|stop|stopp|warte|halt(?:e)?\s+an|nicht\s+weiter(?:machen)?))(?:[\s.!?,].*)?$/iu;
 const DIRECT_TELEGRAM_CHANNEL = /<channel\b(?=[^>]*\bsource=["']telegram["'])(?=[^>]*\bpriority=["']direct["'])[^>]*>/iu;
 const TELEGRAM_REPLY_TOOL = /^mcp__[^\s]*telegram[^\s]*__reply$/iu;
+const DIRECT_CHANNEL_PAYLOAD = /<channel\b(?=[^>]*\bsource=["']telegram["'])(?=[^>]*\bpriority=["']direct["'])[^>]*>([\s\S]*?)<\/channel>/giu;
+const DIRECT_WORK_INTENT = /\b(?:auftrag|arbeite|bau(?:e|en)?|build|check|continue|edit|feuer\s+frei|fix|fortsetzen|implement|install|lies|mach(?:e)?\s+weiter|mess|patch|pruef|resume|run|schreib|starte?|test|update|weiterarbeiten|weiterbauen|write)\b/iu;
+const DIRECT_WORK_PAUSE = /\b(?:halt(?:e)?\s+an|nicht\s+weiter(?:machen)?|pause|pausier(?:e)?|stop|stopp|warte)\b/iu;
 
 function isPrivateTelegramChat(chatId) {
   return /^[1-9]\d*$/u.test(String(chatId ?? '').trim());
@@ -55,8 +58,26 @@ function isExplicitPauseRequest(text) {
   return EXPLICIT_PAUSE.test(String(text ?? '').trim());
 }
 
+function directTelegramPayloadText(inputText) {
+  const matches = [...String(inputText ?? '').matchAll(DIRECT_CHANNEL_PAYLOAD)];
+  return String(matches.at(-1)?.[1] ?? '').trim();
+}
+
+function directMessageAllowsWorkContinuation(inputText) {
+  if (!DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''))) return false;
+  const payload = directTelegramPayloadText(inputText);
+  return payload.length > 0 && !DIRECT_WORK_PAUSE.test(payload);
+}
+
+function directMessageStartsOrResumesWork(inputText) {
+  if (!directMessageAllowsWorkContinuation(inputText)) return false;
+  const payload = directTelegramPayloadText(inputText);
+  return isResumeApproval(payload) || DIRECT_WORK_INTENT.test(payload);
+}
+
 function createDirectReplyTurnStop(inputText) {
-  const direct = DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''));
+  const direct = DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''))
+    && !directMessageStartsOrResumesWork(inputText);
   let delivered = false;
   return {
     noteToolResult(toolName, isError) {
@@ -236,6 +257,9 @@ module.exports = {
   DEFAULT_SILENCE_MS,
   createDirectFocusController,
   createDirectReplyTurnStop,
+  directMessageAllowsWorkContinuation,
+  directMessageStartsOrResumesWork,
+  directTelegramPayloadText,
   directFocusCheckpointPath,
   enqueueTelegramDirect,
   isConversationClose,

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

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+  DEFAULT_CONTEXT_PRESSURE_RATIO,
+  hasContextPressure,
+} = require('./context-pressure-policy.cjs');
+
 const TOOL_RESULT_MAX_CHARS = 12_000;
 const TOOL_RESULT_PREVIEW_CHARS = 2_000;
 const TOOL_RESULT_HISTORICAL_PREVIEW_CHARS = 400;
@@ -16,8 +21,13 @@ const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 1_000;
 const TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES = 12;
 const TOOL_RESULT_HISTORICAL_SUCCESS_MARKER = '[Old tool result content cleared]';
 const TOOL_RESULT_REPEAT_MARKER = '[Repeated tool result omitted]';
+const TOOL_RESULT_OFFLOAD_PRESSURE_RATIO = DEFAULT_CONTEXT_PRESSURE_RATIO;
 const READ_CONTINUATION_LINE_OFFSET_RE = /^Continue reading with line_offset=(\d+)\. Do not assume you have reached the end of the file\.$/mu;
 
+function hasToolResultOffloadPressure(options = {}) {
+  return hasContextPressure(options);
+}
+
 function shouldOffloadToolResult(textLength) {
   return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
 }
@@ -78,6 +88,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;
 
@@ -127,8 +164,9 @@ function compactPersistedToolResultReference(content) {
   return changed ? compacted : content;
 }
 
-function compactHistoricalSuccessfulToolResults(messages) {
+function compactHistoricalSuccessfulToolResults(messages, options = {}) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
+  if (!hasToolResultOffloadPressure(options)) return messages;
 
   const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
   const freshIds = freshToolResultIds(messages);
@@ -299,6 +337,7 @@ function selectHistoricalToolResultOffloads(textLengths) {
 }
 
 module.exports = {
+  TOOL_RESULT_OFFLOAD_PRESSURE_RATIO,
   TOOL_RESULT_BATCH_MAX_CHARS,
   TOOL_RESULT_BATCH_MIN_ITEM_CHARS,
   TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS,
@@ -318,8 +357,11 @@ module.exports = {
   compactHistoricalSuccessfulToolResults,
   compactPersistedToolResultReference,
   createToolResultPreview,
+  currentTurnReadToolResultIds,
+  currentUserTurnStartIndex,
   dedupeRepeatedSuccessfulToolResults,
   freshToolResultIds,
+  hasToolResultOffloadPressure,
   isPersistedToolResultReference,
   readContinuationLineOffset,
   selectHistoricalToolResultOffloads,

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,