blun-king-cli 9.1.611 → 9.1.613

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # BLUN King Changelog
 
+## 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.
+
 ## 9.1.611
 
 - Große Verdichtungsanfragen teilt King jetzt nach Anfragegröße in chronologische Schritte auf. Passt eine einzelne Nachricht nicht unter die Byte-Grenze, bleibt der gespeicherte Verlauf unverändert. So überschreitet die Verdichtungsanfrage die Servergrenze nicht mehr, obwohl im Tokenfenster noch Platz ist. Eine kürzere Modellwartezeit oder geringerer Tokenverbrauch ist damit nicht belegt.

package/LIESMICH.txt

@@ -26,7 +26,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.611
+  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.611
+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;