blun-king-cli 9.1.232 → 9.1.234

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

@@ -13,6 +13,7 @@ const TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS = 600;
 const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 600;
 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]';
 
 function shouldOffloadToolResult(textLength) {
   return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
@@ -102,6 +103,102 @@ function compactHistoricalSuccessfulToolResults(messages) {
   return changed ? projected : messages;
 }
 
+function toolCallSignaturesById(messages) {
+  const signatures = new Map();
+
+  for (const message of messages) {
+    if (!Array.isArray(message?.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      const id = call?.id ?? call?.toolCallId;
+      if (typeof id !== 'string' || typeof call?.name !== 'string') continue;
+      const args = typeof call.arguments === 'string'
+        ? call.arguments
+        : JSON.stringify(call.arguments ?? null);
+      signatures.set(id, `${call.name}\n${args}`);
+    }
+  }
+
+  return signatures;
+}
+
+function repeatedToolResultReference(newestToolCallId) {
+  return [
+    TOOL_RESULT_REPEAT_MARKER,
+    `same_as_tool_call_id: ${newestToolCallId}`,
+    'reason: identical successful result for the same tool call arguments',
+  ].join('\n');
+}
+
+function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages = sourceMessages) {
+  if (
+    !Array.isArray(sourceMessages)
+    || !Array.isArray(projectedMessages)
+    || sourceMessages.length === 0
+    || sourceMessages.length !== projectedMessages.length
+  ) return projectedMessages;
+
+  const callSignatures = toolCallSignaturesById(sourceMessages);
+  const seenResultsByCall = new Map();
+  let changed = false;
+  const projected = projectedMessages.slice();
+
+  for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
+    const message = sourceMessages[index];
+    const toolCallId = message?.toolCallId;
+    if (
+      message?.role !== 'tool'
+      || message.isError === true
+      || typeof toolCallId !== 'string'
+      || !Array.isArray(message.content)
+      || message.content.length === 0
+      || isPersistedToolResultReference(message.content)
+      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
+    ) continue;
+
+    const callSignature = callSignatures.get(toolCallId);
+    if (callSignature === undefined) continue;
+    const resultShape = message.content.length;
+    const resultSignature = resultShape === 1
+      ? message.content[0].text
+      : JSON.stringify(message.content.map((part) => part.text));
+    let seenResults = seenResultsByCall.get(callSignature);
+    if (seenResults === undefined) {
+      seenResults = new Map();
+      seenResultsByCall.set(callSignature, seenResults);
+    }
+    let seenResultsForShape = seenResults.get(resultShape);
+    if (seenResultsForShape === undefined) {
+      seenResultsForShape = new Map();
+      seenResults.set(resultShape, seenResultsForShape);
+    }
+    const newest = seenResultsForShape.get(resultSignature);
+    if (newest === undefined) {
+      seenResultsForShape.set(resultSignature, { toolCallId, index });
+      continue;
+    }
+
+    const reference = repeatedToolResultReference(newest.toolCallId);
+    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
+    const projectedMessage = projected[index];
+    if (
+      reference.length >= textChars
+      || projectedMessage?.role !== 'tool'
+      || projectedMessage.toolCallId !== toolCallId
+    ) continue;
+    projected[index] = {
+      ...projectedMessage,
+      content: [{ type: 'text', text: reference }],
+    };
+    projected[newest.index] = {
+      ...projected[newest.index],
+      content: sourceMessages[newest.index].content,
+    };
+    changed = true;
+  }
+
+  return changed ? projected : projectedMessages;
+}
+
 function selectToolResultBatchOffloads(textLengths) {
   if (!Array.isArray(textLengths) || textLengths.length < 2) return [];
 
@@ -170,6 +267,7 @@ module.exports = {
   TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
   TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
   TOOL_RESULT_HISTORICAL_SUCCESS_MARKER,
+  TOOL_RESULT_REPEAT_MARKER,
   TOOL_RESULT_MAX_CHARS,
   TOOL_RESULT_PREVIEW_CHARS,
   TOOL_RESULT_RECOVERY_PAGE_LINES,
@@ -178,6 +276,7 @@ module.exports = {
   compactHistoricalSuccessfulToolResults,
   compactPersistedToolResultReference,
   createToolResultPreview,
+  dedupeRepeatedSuccessfulToolResults,
   isPersistedToolResultReference,
   selectHistoricalToolResultOffloads,
   selectToolResultBatchOffloads,

package/bin/write-continuation-policy.cjs

@@ -15,6 +15,41 @@ function resolveWriteContinuationContract({ continuation, current, mode }) {
   };
 }
 
+function resolvePlainWriteContract({
+  contentBytes,
+  maxContinuationChunkBytes,
+  continuationRequired = false,
+}) {
+  if (!Number.isSafeInteger(contentBytes) || contentBytes < 0) {
+    throw new TypeError('contentBytes must be a non-negative safe integer');
+  }
+  if (!Number.isSafeInteger(maxContinuationChunkBytes) || maxContinuationChunkBytes < 1) {
+    throw new TypeError('maxContinuationChunkBytes must be a positive safe integer');
+  }
+
+  const directWriteLimit = Math.max(4_096, maxContinuationChunkBytes);
+  if (continuationRequired) {
+    return {
+      allowed: false,
+      directWriteLimit,
+      reason: 'continuation_required',
+    };
+  }
+  if (contentBytes > directWriteLimit) {
+    return {
+      allowed: false,
+      directWriteLimit,
+      reason: 'too_large',
+    };
+  }
+  return {
+    allowed: true,
+    directWriteLimit,
+    reason: 'direct',
+  };
+}
+
 module.exports = {
+  resolvePlainWriteContract,
   resolveWriteContinuationContract,
 };

package/blun.mjs

@@ -79000,7 +79000,7 @@ var init_context$2 = __esmMin((() => {
 			const historicalTelegramProjected = projectHistoricalUnaddressedTelegramMessages(duplicateUserMessagesProjected);
 			const assistantOffloaded = this.agent.assistantMessageOffload.compact(historicalTelegramProjected);
 			const repeatedAssistantProjected = projectRepeatedAssistantResponses(assistantOffloaded);
-			const result = project(this.agent.microCompaction.compact(compactHistoricalSuccessfulToolResults(this.agent.toolResultBatchOffload.compact(dedupeRecurringCronWakeups(dedupeRepeatedInjections(compactHistoricalSkillActivations(compactBaselineSkillInjections(repeatedAssistantProjected))))))), {
+			const result = project(this.agent.microCompaction.compact(compactHistoricalSuccessfulToolResults(dedupeRepeatedSuccessfulToolResults(repeatedAssistantProjected, this.agent.toolResultBatchOffload.compact(dedupeRecurringCronWakeups(dedupeRepeatedInjections(compactHistoricalSkillActivations(compactBaselineSkillInjections(repeatedAssistantProjected)))))))), {
 				...options,
 				onAnomaly: (anomaly) => {
 					anomalies.push(anomaly);
@@ -259580,8 +259580,8 @@ var init_write$1 = __esmMin((() => {
 	write_default = "Create, append to, or replace a file entirely.\n\n- Missing parent directories are created automatically (like `mkdir(parents=True, exist_ok=True)`).\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Do not create unsolicited documentation files (`*.md` write-ups, `README`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- Source files may contain at most 500 lines. Split larger implementations into focused files; append cannot bypass the limit.\n- Set `single_file_override=true` only when the latest direct user message explicitly requires one single file. The accepted override is reported visibly.\n- For any new or completely replaced file with content too large for one call, use `continuation`. Keep each chunk at or below the configured limit. The default is 2,048 UTF-8 bytes, a conservative safety margin for unstable model output rather than a measured hard model limit; operators can set `BLUN_WRITE_CONTINUATION_MAX_BYTES` from 512 through 16,384. End every chunk on a complete line with `\\n`. Set the exact final `expected_lines`; include `expected_sha256` when a source hash is available. Use overwrite and `start_line=1` for the first chunk, then use append for every later chunk and copy the exact `next_start_line` returned by the previous Write result; never continue from a planned boundary. Use consecutive part numbers. The target file remains unchanged until the final line-count and optional SHA-256 checks pass. To discard an unfinished sequence, restart with part 1, overwrite, `start_line=1`, and `reset=true`.\n- Never use continuation to modify an existing file incrementally. Use Edit for incremental changes.\n- Runaway generated JavaScript/TypeScript identifiers are rejected before disk I/O. Regenerate only the affected section as a smaller focused chunk.\n";
 }));
 //#endregion
-write_default = "Create, append to, or completely replace a file. Missing parent directories are created automatically. Overwrite is the default; append adds content at EOF without adding a newline.\n\nUse Write for a new file or a complete replacement. For every incremental change to an existing file, Use Edit instead, even when it is small. Read before overwriting an existing file. Do not create unsolicited documentation, README, summary, or report files unless the user or project instructions require them.\n\nContent is written literally. Never include Read/Edit line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nFor a new or completely replaced file too large for one call, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Set exact `expected_lines` and, when available, `expected_sha256`. Part 1 uses overwrite, `part=1`, and `start_line=1`; every later part uses append, the next consecutive part, and the exact `next_start_line` returned by Write. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence only with part 1, overwrite, `start_line=1`, and `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
-write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nFor a new or completely replaced file too large for one call, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Optionally set exact `expected_lines` and, when available, `expected_sha256`. Part number, start line, and mode are derived from actually staged content when omitted. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence with `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
+write_default = "Create, append to, or completely replace a file. Missing parent directories are created automatically. Overwrite is the default; append adds content at EOF without adding a newline.\n\nUse Write for a new file or a complete replacement. For every incremental change to an existing file, Use Edit instead, even when it is small. Read before overwriting an existing file. Do not create unsolicited documentation, README, summary, or report files unless the user or project instructions require them.\n\nContent is written literally. Never include Read/Edit line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nWrite complete files up to 4,096 UTF-8 bytes atomically. For a larger new or completely replaced file, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Set exact `expected_lines` and, when available, `expected_sha256`. Part 1 uses overwrite, `part=1`, and `start_line=1`; every later part uses append, the next consecutive part, and the exact `next_start_line` returned by Write. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. After an oversized plain Write is refused, that path accepts only continuation calls until the sequence completes. Restart an unfinished sequence only with part 1, overwrite, `start_line=1`, and `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
+write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nWrite complete files up to 4,096 UTF-8 bytes atomically. For a larger new or completely replaced file, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Optionally set exact `expected_lines` and, when available, `expected_sha256`. Part number, start line, and mode are derived from actually staged content when omitted. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. After an oversized plain Write is refused, that path accepts only continuation calls until the sequence completes. Restart an unfinished sequence with `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
 //#region ../../packages/agent-core/src/tools/builtin/file/generated-source-health.ts
 /**
 * Find runaway generated identifiers while ignoring comments and strings.
@@ -259704,7 +259704,7 @@ function countCompletedLines(content) {
 	for (const character of content) if (character === "\n") count += 1;
 	return count;
 }
-var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract;
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract, resolvePlainWriteContract;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -259716,7 +259716,7 @@ var init_write = __esmMin((() => {
 	init_write$1();
 	init_generated_source_health();
 	init_lsp_diagnostics();
-	({ resolveWriteContinuationContract } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
+	({ resolveWriteContinuationContract, resolvePlainWriteContract } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
 	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
@@ -259751,6 +259751,7 @@ bytesWritten: number$1().int().nonnegative() });
 		description = write_default;
 		parameters = toInputJsonSchema(WriteInputSchema);
 		pendingContinuations = /* @__PURE__ */ new Map();
+		continuationRequiredPaths = /* @__PURE__ */ new Set();
 		constructor(kaos, workspace, history, lsp, maxContinuationChunkBytes = resolveWriteContinuationChunkBytes()) {
 			this.kaos = kaos;
 			this.workspace = workspace;
@@ -259872,6 +259873,7 @@ bytesWritten: number$1().int().nonnegative() });
 				...percent === void 0 ? {} : { percent }
 			});
 			if (!final) {
+				this.continuationRequiredPaths.delete(safePath);
 				this.pendingContinuations.set(safePath, staged);
 				const progress = expectedLines === void 0 ? `${String(completedLines)} lines staged; final count not predeclared` : `${String(completedLines)} of ${String(expectedLines)} lines (${String(percent)}%)`;
 				return { output: `Write continuation part ${String(part)} staged lines ${boundary} (${progress}, ${String(chunkBytes)} bytes). Target unchanged. Continue with the next chunk; mode=append, part=${String(part + 1)}, and start_line=${String(completedLines + 1)} are inferred when omitted.` };
@@ -259904,6 +259906,7 @@ bytesWritten: number$1().int().nonnegative() });
 				output: `Write continuation integrity failure for ${args.path}: staged SHA-256 ${actualSha256}, persisted SHA-256 ${persistedSha256}. The target may be incomplete; inspect it before continuing.`
 			};
 			this.pendingContinuations.delete(safePath);
+			this.continuationRequiredPaths.delete(safePath);
 			const writeOutput = typeof result.output === "string" ? result.output : "Write completed.";
 			return {
 				...result,
@@ -259937,10 +259940,19 @@ bytesWritten: number$1().int().nonnegative() });
 				output: lineLimit.error
 			};
 			const contentBytes = Buffer.byteLength(args.content, "utf8");
-			if (!allowLargeContent && contentBytes > this.maxContinuationChunkBytes) return {
-				isError: true,
-				output: `Refused to write ${args.path}: the content is ${String(contentBytes)} UTF-8 bytes. Long generated writes must use the continuation protocol with complete-line chunks of at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} bytes. No file was written.`
-			};
+			const plainWrite = resolvePlainWriteContract({
+				contentBytes,
+				maxContinuationChunkBytes: this.maxContinuationChunkBytes,
+				continuationRequired: this.continuationRequiredPaths.has(safePath)
+			});
+			if (!allowLargeContent && !plainWrite.allowed) {
+				if (plainWrite.reason === "too_large") this.continuationRequiredPaths.add(safePath);
+				const reason = plainWrite.reason === "continuation_required" ? "an earlier oversized Write locked this path to the continuation protocol" : `the content is ${String(contentBytes)} UTF-8 bytes, above the ${String(plainWrite.directWriteLimit)}-byte direct-write limit`;
+				return {
+					isError: true,
+					output: `Refused to write ${args.path}: ${reason}. Start or resume continuation with {\"path\":${JSON.stringify(args.path)},\"content\":\"<complete-line chunk ending in \\\\n>\",\"continuation\":{}}. Each chunk may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes. No file was written.`
+				};
+			}
 			const parentError = await this.ensureParentDirectory(safePath);
 			if (parentError !== void 0) return {
 				isError: true,
@@ -260541,7 +260553,7 @@ function renderHistoricalToolResultReference(toolName, toolCallId, text, outputP
 function safeToolResultFileStem(toolName, toolCallId) {
 	return `${toolName}-${toolCallId}`.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "tool-result";
 }
-var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
+var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, dedupeRepeatedSuccessfulToolResults, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
 var init_tool_result_budget = __esmMin((() => {
 	init_dist$6();
 	const toolResultOffloadPolicy = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs");
@@ -260555,6 +260567,7 @@ var init_tool_result_budget = __esmMin((() => {
 	createToolResultPreview = toolResultOffloadPolicy.createToolResultPreview;
 	compactPersistedToolResultReference = toolResultOffloadPolicy.compactPersistedToolResultReference;
 	compactHistoricalSuccessfulToolResults = toolResultOffloadPolicy.compactHistoricalSuccessfulToolResults;
+	dedupeRepeatedSuccessfulToolResults = toolResultOffloadPolicy.dedupeRepeatedSuccessfulToolResults;
 	selectToolResultBatchOffloads = toolResultOffloadPolicy.selectToolResultBatchOffloads;
 	selectHistoricalToolResultOffloads = toolResultOffloadPolicy.selectHistoricalToolResultOffloads;
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.232",
+  "version": "9.1.234",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {