blun-king-cli 9.1.612 → 9.1.614

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # BLUN King Changelog
 
-## 9.1.612
+## 9.1.614
+
+- Zu große AGENTS.md- und AGENTS.override.md-Dateien stoppen einen Zug nicht mehr allein wegen ihrer Größe. Außerhalb der King-Konsole liest King insgesamt bis zu 32 KiB aus Anweisungsdateien und nennt dir einmal je Sitzung die Anzahl der ausgelassenen Bytes. In der King-Konsole bleiben die Dateien vollständig, solange die Anfragegrenze das zulässt. Verknüpfungen und unsichere Pfade bleiben gesperrt.
+
+## 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.614
 
 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.614
 ```
 
 ### 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/documents.js

@@ -86,7 +86,7 @@ export async function indexExplicitDocuments(entries) {
       if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error(`source is not a regular non-symlink file: ${entry.id}`);
       buffer = await readFile(path);
     }
-    if (buffer.byteLength > (entry.maxBytes || 4 * 1024 * 1024)) throw new Error(`source exceeds its byte limit: ${entry.id}`);
+    if (buffer.byteLength > (entry.maxBytes || 8 * 1024 * 1024)) throw new Error(`source exceeds its byte limit: ${entry.id}`);
     const classification = classify(entry.id);
     const document = {
       path,

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

@@ -44,6 +44,7 @@ return null;
 
 export function hostContextLimit(preflight) {
 if (preflight?.receipt?.instructionHost === "codex") return 32768 + Buffer.byteLength(JSON.stringify(preflight.briefing || {}));
+if (preflight?.briefing?.instructions?.length) return 32768 + Buffer.byteLength(JSON.stringify(preflight.briefing));
 const mode = preflight?.receipt?.instructionBudget?.mode;
 if (mode === "claude-required-overflow") return MAX_CLAUDE_OVERFLOW_CONTEXT_BYTES;
 return STANDARD_HOST_CONTEXT_BYTES;

package/agent-spine-plugin/src/lib/host-instruction-budget.js

@@ -4,8 +4,7 @@ const KING_TOTAL = 8388608;
 export const isKingHost = (env = process.env) => !!(env.BLUN_PLUGIN_ROOT && env.BLUN_HOME);
 
 export function instructionBudget(host, usedBytes = 0, env = process.env) {
-  const hardLimitBytes = host === "codex" && isKingHost(env) ? KING_TOTAL
-    : host === "claude" ? 16384 : host === "codex" ? 32768 : STANDARD;
+  const hardLimitBytes = KING_TOTAL;
   return { mode: usedBytes > STANDARD ? `${host}-required-overflow` : "standard",
     standardBytes: STANDARD, hardLimitBytes, usedBytes, overflowBytes: Math.max(0, usedBytes - STANDARD) };
 }

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,19 @@ 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);
+  const contentBudget = kingInstructions ? 900000 : 32768;
   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, Math.max(0, contentBudget - instructionBytes));
     if (snapshot.sha256 !== document.sha256 || snapshot.bytes !== document.bytes) throw new Error(`required instruction changed after source resolution: ${document.relativePath}`);
-    instructionBytes += snapshot.bytes;
+    instructionBytes += snapshot.readBytes;
     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 +555,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 +565,25 @@ 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 (requiredInstructions.length > 0) {
+      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.`);
+      }
+      const totalBytes = requiredInstructions.reduce((sum, item) => sum + item.bytes, 0);
+      const omittedBytes = totalBytes - instructionBytes;
+      if (omittedBytes > 0) {
+        const totalDigest = sha256(`${exactScope.sessionId}\0instruction-total`);
+        if (!state.history.some((event) => event.event === "instruction-notice" && event.sessionDigest === totalDigest)) {
+          state.history.push({ event: "instruction-notice", sessionDigest: totalDigest, at: createdAt, authority: "diagnostic-only" });
+          notices.push(`Instruction total: ${totalBytes} bytes; ${instructionBytes} read; ${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 +591,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 +634,14 @@ 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);
+    const contentBudget = kingInstructions ? 900000 : 32768;
     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, Math.max(0, contentBudget - instructionBytes));
       if (currentSnapshot.sha256 !== instruction.sha256 || currentSnapshot.bytes !== instruction.bytes
         || currentSnapshot.identity !== instruction.identity) return false;
-      instructionBytes += currentSnapshot.bytes;
+      instructionBytes += currentSnapshot.readBytes;
     }
     if (instructionBytes > maximumInstructionBytes
       || canonical(receipt.instructionBudget) !== canonical(instructionBudget(receipt.instructionHost, instructionBytes, env))) return false;

package/agent-spine-plugin/src/lib/source-roots.js

@@ -376,7 +376,7 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
     const codexHome = isKingHost(env) ? env.BLUN_HOME : env.CODEX_HOME || env.BLUN_HOME || join(homedir(), ".codex");
     hostHome = await existingDirectory(resolve(codexHome)) || resolve(codexHome);
     const config = await codexConfig(hostHome);
-    if (isKingHost(env)) config.maxBytes = KING_SOURCE_BYTES;
+    config.maxBytes = KING_SOURCE_BYTES;
     if (env.AGENTSPINE_ROOT) projectRoot = await canonicalPath(env.AGENTSPINE_ROOT);
     else ({ root: projectRoot, resolution: rootResolution } = await findRoot(canonicalCwd, config.rootMarkers));
     sources = await codexSources({ cwd: canonicalCwd, projectRoot, codexHome: hostHome, config });