blun-king-cli 9.1.612 → 9.1.613

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # BLUN King Changelog
 
-## 9.1.612
+## 9.1.613
+
+- King schätzt vor dem Senden nun die Größe der gesamten Modellanfrage, einschließlich Anweisungen, Verlauf, Werkzeugdefinitionen und Bilddaten. Nähert sie sich der Byte-Grenze des Servers, beginnt eine stufenweise Verdichtung. Lässt sich eine Anfrage nicht sicher aufteilen, bricht King ab, ohne den gespeicherten Verlauf stillschweigend zu verwerfen.
+- Die Nutzungsanzeige übernimmt gesondert gemeldete Denktoken, sofern der Anbieter sie liefert. Eine kürzere Modellwartezeit oder geringere Kosten sind damit nicht belegt.
+
+## 9.1.612 (Nicht veröffentlicht)
+
+9.1.612 wurde nicht als Kundenupdate freigegeben. Der frühe Byte-Schutz griff bei einer Anfrage über 900 KB nicht, wenn der Verlauf allein unter 600 KB blieb. 9.1.613 ersetzt diesen Stand.
 
 - King speichert abgeschlossene Werkzeugaufrufe lokal als Metadaten: Werkzeugname, Zeitpunkt, Status und bei Dateiwerkzeugen gegebenenfalls den Pfad. Eingaben, Ausgaben, Befehle und Schlüssel werden nicht gespeichert. Mit `/memory tools` kannst du die Einträge deines Profils durchsuchen.
 - Die Kontextdiagnose zeigt zusätzliche Zahlen zur Zusammensetzung von Anfragen. Eine zuschaltbare Phasenmessung erfasst die Zeit bis zum Modellaufruf, ohne Inhalte zu protokollieren. Diese Diagnose beschleunigt Modellantworten für sich genommen nicht.

package/LIESMICH.txt

@@ -26,7 +26,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.612
+  npm install -g blun-king-cli@9.1.613
 
 Start
 -----

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.612
+npm install -g blun-king-cli@9.1.613
 ```
 
 ### Windows: Node.js, npm und Git Bash

package/agent-spine-plugin/src/hook.js

@@ -431,6 +431,10 @@ async function runHookCore(input, payload, options) {
       }
       if (payload) return { blocked: false, context, briefing, preflight, signal, attentionEvent, channelEvent, lessonRecall, catalogPath };
       const output = hookOutput(event, context, process.env, sourceWarning);
+      if (preflight?.instructionNotice) {
+        output.hookSpecificOutput.message = [output.hookSpecificOutput.message, preflight.instructionNotice]
+          .filter(Boolean).join("\n");
+      }
       const handoff = await writeContextOutput(output, process.env.BLUN_PLUGIN_ROOT ? "king"
         : process.env.PLUGIN_ROOT ? "codex" : process.env.CLAUDE_PLUGIN_ROOT ? "claude" : scope.host);
       if (event === "UserPromptSubmit" && briefingOrigin) {

package/agent-spine-plugin/src/lib/preflight.js

@@ -1,13 +1,14 @@
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import { lstat, mkdir, open, readFile, realpath, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.js";
 import { ancestorsBetween, isInside, stateRoot } from "./paths.js";
 import { preflightDeliveryId } from "./preflight-delivery-id.js";
 import { resolveHostSourceCatalog } from "./source-roots.js";
-import { instructionBudget } from "./host-instruction-budget.js";
+import { instructionBudget, isKingHost } from "./host-instruction-budget.js";
 
 export const PREFLIGHT_SCHEMA = "agentspine.preflight/v2";
 export const PREFLIGHT_POLICY_SCHEMA = "agentspine.preflight-policy/v1";
@@ -326,7 +327,7 @@ async function assertNoSymlinkParents(path, allowedRoot) {
   }
   return { root, target };
 }
-async function safeReadRequired(path, allowedRoot, maximum = STANDARD_REQUIRED_INSTRUCTIONS_BYTES, fileHooks = null) {
+async function safeReadRequired(path, allowedRoot, maximum = STANDARD_REQUIRED_INSTRUCTIONS_BYTES, fileHooks = null, contentLimit = null) {
   const checked = await assertNoSymlinkParents(path, allowedRoot);
   const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW || 0);
   const handle = await open(checked.target, flags);
@@ -353,7 +354,10 @@ async function safeReadRequired(path, allowedRoot, maximum = STANDARD_REQUIRED_I
       || current.size !== before.size || current.mtimeMs !== before.mtimeMs || current.ctimeMs !== before.ctimeMs) {
       throw new Error(`required instruction ${basename(path)} was replaced during preflight`);
     }
-    return { content: buffer.toString("utf8"), bytes: buffer.length, sha256: sha256(buffer),
+    const decoder = new StringDecoder("utf8");
+    const content = contentLimit === null ? buffer.toString("utf8") : decoder.write(buffer.subarray(0, contentLimit));
+    const readBytes = Buffer.byteLength(content);
+    return { content, bytes: buffer.length, readBytes, omittedBytes: buffer.length - readBytes, sha256: sha256(buffer),
       identity: sha256(`${before.dev}\0${before.ino}\0${before.size}\0${before.mtimeMs}\0${before.ctimeMs}`) };
   } finally { await handle.close(); }
 }
@@ -492,16 +496,18 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
   const requiredInstructions = [];
   let instructionBytes = 0;
   const maximumInstructionBytes = instructionBudget(instructionHost, 0, env).hardLimitBytes;
+  const kingInstructions = instructionHost === "codex" && isKingHost(env);
   for (const document of documents) {
     const allowedRoot = document.sourceScope === "user" ? resolvedSources.hostHome : resolvedSources.projectRoot;
-    const snapshot = await safeReadRequired(document.path, allowedRoot, maximumInstructionBytes, fileHooks);
+    const snapshot = await safeReadRequired(document.path, allowedRoot, maximumInstructionBytes, fileHooks, kingInstructions ? 32768 : null);
     if (snapshot.sha256 !== document.sha256 || snapshot.bytes !== document.bytes) throw new Error(`required instruction changed after source resolution: ${document.relativePath}`);
-    instructionBytes += snapshot.bytes;
+    instructionBytes += kingInstructions ? snapshot.readBytes : snapshot.bytes;
     if (instructionBytes > maximumInstructionBytes) {
       throw new Error(`required host instructions total ${instructionBytes} bytes; mandatory limit is ${maximumInstructionBytes} bytes`);
     }
     requiredInstructions.push({ path: document.path, displayPath: document.relativePath, scope: document.sourceScope,
-      bytes: snapshot.bytes, sha256: snapshot.sha256, identity: snapshot.identity, content: snapshot.content });
+      bytes: snapshot.bytes, readBytes: snapshot.readBytes, omittedBytes: snapshot.omittedBytes,
+      sha256: snapshot.sha256, identity: snapshot.identity, content: snapshot.content });
   }
   const appliedInstructionBudget = instructionBudget(instructionHost, instructionBytes, env);
   const memoryState = validateMemories(await readJson(paths.memories, MAX_STATE_BYTES, emptyMemories));
@@ -548,6 +554,7 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
   const key = await signingKey(paths); const bodyDigest = digestObject(receiptBody);
   const receipt = { id: `preflight:${bodyDigest.slice(0, 32)}`, ...receiptBody, bodyDigest,
     signature: createHmac("sha256", key).update(bodyDigest).digest("hex") };
+  let instructionNotice = null;
   await withLock(paths, async () => {
     const state = await readVerifiedState(paths);
     state.receipts = state.receipts.filter((item) => new Date(item.receipt?.expiresAt || 0).getTime() >= new Date(createdAt).getTime() - RECEIPT_TTL_MS);
@@ -557,6 +564,16 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
     const envelope = { receipt, consumedAt: null, invalidatedAt: null, stateSignature: "" };
     envelope.stateSignature = createHmac("sha256", key).update(envelopeBody(envelope)).digest("hex");
     state.receipts.push(envelope); state.revision += 1;
+    if (kingInstructions) {
+      const notices = [];
+      for (const item of requiredInstructions.filter((instruction) => instruction.bytes > 8192)) {
+        const sessionDigest = sha256(`${exactScope.sessionId}\0${item.path}`);
+        if (state.history.some((event) => event.event === "instruction-notice" && event.sessionDigest === sessionDigest)) continue;
+        state.history.push({ event: "instruction-notice", sessionDigest, at: createdAt, authority: "diagnostic-only" });
+        notices.push(`${item.displayPath}: ${item.bytes} bytes; ${item.readBytes} read; ${item.omittedBytes} omitted.`);
+      }
+      instructionNotice = notices.join("\n") || null;
+    }
     state.lastTurn = { status: "ready", receiptId: receipt.id, at: createdAt, host: exactScope.host,
       instructionHost, instructionFiles: receipt.instructionFiles.length, recall: receipt.providerQueries.map((item) => ({
         providerId: item.providerId, status: item.status, rejected: item.rejected
@@ -564,7 +581,7 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
     state.history.push({ event: "ready", receiptId: receipt.id, at: createdAt, authority: "preflight-proof-only" });
     await writeJson(paths.state, state);
   });
-  return { receipt, briefing, policy: { configured: Boolean(profile), requiredProviderIds } };
+  return { receipt, briefing, instructionNotice, policy: { configured: Boolean(profile), requiredProviderIds } };
 }
 
 export async function verifyPreflightReceipt({ receipt, input, scope, resolvedSources, prompt, now = new Date(), env = process.env, consume = false }) {
@@ -607,12 +624,13 @@ export async function verifyPreflightReceipt({ receipt, input, scope, resolvedSo
       || currentDocuments.some((document, index) => document.path !== receipt.instructionFiles[index]?.path)) return false;
     let instructionBytes = 0;
     const maximumInstructionBytes = instructionBudget(receipt.instructionHost, 0, env).hardLimitBytes;
+    const kingInstructions = receipt.instructionHost === "codex" && isKingHost(env);
     for (const instruction of receipt.instructionFiles) {
       const allowedRoot = instruction.scope === "user" ? freshSources.hostHome : freshSources.projectRoot;
-      const currentSnapshot = await safeReadRequired(instruction.path, allowedRoot, maximumInstructionBytes);
+      const currentSnapshot = await safeReadRequired(instruction.path, allowedRoot, maximumInstructionBytes, null, kingInstructions ? 32768 : null);
       if (currentSnapshot.sha256 !== instruction.sha256 || currentSnapshot.bytes !== instruction.bytes
         || currentSnapshot.identity !== instruction.identity) return false;
-      instructionBytes += currentSnapshot.bytes;
+      instructionBytes += kingInstructions ? currentSnapshot.readBytes : currentSnapshot.bytes;
     }
     if (instructionBytes > maximumInstructionBytes
       || canonical(receipt.instructionBudget) !== canonical(instructionBudget(receipt.instructionHost, instructionBytes, env))) return false;