From 1d77e5ab5e084b277770e52b742cd9dd2381e185 Mon Sep 17 00:00:00 2001 From: awork Date: Wed, 21 Oct 2026 16:59:48 +0800 Subject: [PATCH 1/2] fix: annotate the output-headroom effective window on every denominator surface (#4130) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The compression engine judges against the effective window (declared window minus the output-headroom reservation, #896), but every persistent display surface showed that denominator bare — a 200K model judging at 150K read as a misidentified window (three rounds of misdiagnosis in the field, #4130). handle() now records the declared pre-reservation window in session.metadata.outputHeadroomBase (cleared when no reservation is active, so a model/protocol switch never shows a stale note); one writer, all modes. The surfaces annotate from that single source: - nudge log line: usage=44% (65256/150000, window 200000 − output reserve 50000) - /acp panel: before-footer line 'Window: judging against 150K effective (200K declared − 50K output reserve)' + additive contextWindowBase JSON field - Web UI session bar: sub-line 'window 200K − output reserve 50K' (+ zh/en i18n) - session report MD/SVG: same note after the context fraction - admin stats JSON: additive contextWindowBase Display-only: the kernel keeps judging against the effective value; no config surface added, no behavior change to compression. --- src/plugin.ts | 14 +- src/server.ts | 14 +- src/server/admin.ts | 2 + src/server/handle.ts | 11 ++ src/server/prepare-anthropic.ts | 4 +- src/server/prepare-google.ts | 4 +- src/server/prepare-openai.ts | 4 +- src/server/prepare-responses.ts | 4 +- src/web/client.ts | 5 + src/web/i18n.ts | 4 + src/web/report.ts | 14 +- src/web/sessions-data.ts | 4 + tests/issue4130-headroom-denominator.test.ts | 149 +++++++++++++++++++ 13 files changed, 220 insertions(+), 13 deletions(-) create mode 100644 tests/issue4130-headroom-denominator.test.ts diff --git a/src/plugin.ts b/src/plugin.ts index fa02d130dd..afe528cc06 100644 --- a/src/plugin.ts +++ b/src/plugin.ts @@ -1,6 +1,6 @@ import { BLOCKED_REF, COMPRESS_TOOL_NAME, type CompressionCore, type Config, type CoreMessage, type NudgeDecision, type RetrievalExport, applyRetrieve, countMessageTokens, parseStoredPlaceholder, prune } from "acp-kernel"; import { imageRescaleEnabled, publicSnapshotCapBytes } from "./knobs.js"; -import { buildStatusPanel } from "acp-kernel/panel"; +import { buildStatusPanel, formatCompactTokens } from "acp-kernel/panel"; import { fileURLToPath } from "node:url"; import type { ServerResponse } from "node:http"; import fs from "node:fs"; @@ -1712,6 +1712,14 @@ export function handlePluginStatus(conversationId: string, res: import("node:htt if (obd !== undefined && obd.model !== undefined && obd.value !== undefined && obd.model === lastModel) { preFooter.push(`⚠️ OUTPUT BUDGET: model "${obd.model}" has NO known output ceiling — outgoing max_tokens restored to ${obd.value} tokens from the client's own estimate (no ceiling to back it); longer replies may cut off at the output limit. Declare an output limit in bili config or set maxTokens on the host model item (#2904).`); } + // #4130: the denominator above is the EFFECTIVE window (post output-headroom + // reservation) — tie it back to the declared one so a 200K model judging at + // 150K doesn't read as a misidentified window. Display-only note; the + // reservation itself is unchanged (#896 design). + const headroomBase = session.metadata.outputHeadroomBase; + if (typeof headroomBase === "number" && Number.isFinite(headroomBase) && headroomBase > modelContextLimit && modelContextLimit > 0) { + preFooter.push(`Window: judging against ${formatCompactTokens(modelContextLimit)} effective (${formatCompactTokens(headroomBase)} declared − ${formatCompactTokens(headroomBase - modelContextLimit)} output reserve)`); + } const upd = getUpdateVisibility(VERSION); if (upd.visible) { // #1870 visibility for the silent courier, #1977 display policy: @@ -1753,6 +1761,10 @@ export function handlePluginStatus(conversationId: string, res: import("node:htt ?? pluginRuntimeInfoForConversation(conversationIdForSession(session.id), typeof session.metadata.lastModel === "string" ? session.metadata.lastModel : undefined) ?? null, contextLimit: typeof limit === "number" ? limit : null, + // #4130: declared (pre-output-headroom) window while a reservation shrinks + // the effective denominator — additive field, machine-readable twin of the + // Window: note above; null when no reservation is active. + contextWindowBase: typeof headroomBase === "number" && Number.isFinite(headroomBase) ? headroomBase : null, contextTokens, contextTokensSource, contextTokensAt: observation?.at ?? null, diff --git a/src/server.ts b/src/server.ts index df98297b21..318d5e3c4a 100644 --- a/src/server.ts +++ b/src/server.ts @@ -2291,11 +2291,14 @@ export function diagTagSummary(messages: CoreMessage[], sessionId: string, strat return `[${sessionId}] processTurn: ${messages.length} msgs, renderTags=${strategy}, ${textTagged} text tagged, ${toolTagged} tool tagged (should be 0 with text-only)`; } -export function diagNudge(turn: { nudge?: { shouldInject: boolean; reason: string; contextUsage: number; tier: number | null; breakdown?: Record } | null }, sessionId: string, tokenCount: number, limit: number, model: string | undefined, willInject: boolean, decidePending = false, surfaceOff?: string): string { +export function diagNudge(turn: { nudge?: { shouldInject: boolean; reason: string; contextUsage: number; tier: number | null; breakdown?: Record } | null }, sessionId: string, tokenCount: number, limit: number, model: string | undefined, willInject: boolean, decidePending = false, surfaceOff?: string, windowBase?: number): string { const n = turn.nudge; if (!n) return `[${sessionId}] nudge: unavailable`; const b = n.breakdown ?? {}; const pct = limit > 0 ? `${Math.round((tokenCount / limit) * 100)}%` : "?"; + // #4130: when the denominator is the post-output-headroom effective window, + // say so inline — a bare "65256/150000" reads as a misidentified 150K model. + const winNote = typeof windowBase === "number" && Number.isFinite(windowBase) && windowBase > limit ? `, window ${windowBase} − output reserve ${windowBase - limit}` : ""; const growth = b["growth"] ?? 0; const floor = b["growthFloor"] ?? 0; const interval = b["nudgeGrowthTokens"] ?? 0; @@ -2315,7 +2318,14 @@ export function diagNudge(turn: { nudge?: { shouldInject: boolean; reason: strin // the observed top-level tools so the next omnibus rename is greppable here // (`surface=off(top-level=[...])`) instead of arriving as a user incident. const offTag = surfaceOff ? `, ${surfaceOff}` : ""; - return `[${sessionId}] nudge ${inject}: usage=${pct} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}${modelTag}${offTag}, reason="${n.reason.slice(0, 120)}"`; + return `[${sessionId}] nudge ${inject}: usage=${pct} (${tokenCount}/${limit}${winNote}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}${modelTag}${offTag}, reason="${n.reason.slice(0, 120)}"`; +} + +// #4130: the declared (pre-output-headroom) window handle() records while a +// reservation shrinks the effective denominator — display annotations only. +export function outputHeadroomBase(session: Session): number | undefined { + const v = session.metadata?.outputHeadroomBase; + return typeof v === "number" && Number.isFinite(v) ? v : undefined; } // Zero-baseline sessions are judged conservatively ONLY when they arrived diff --git a/src/server/admin.ts b/src/server/admin.ts index 39974a2a3f..8b6c8da6cb 100644 --- a/src/server/admin.ts +++ b/src/server/admin.ts @@ -1036,6 +1036,8 @@ function sendStats(res: http.ServerResponse): void { // largest input recent successful turns actually got through. A wide gap // means the provider overstates its window. contextWindow: typeof s.metadata.effectiveContextLimit === "number" ? s.metadata.effectiveContextLimit : undefined, + // #4130: declared pre-output-headroom window — pairs with contextWindow (the effective denominator). + contextWindowBase: typeof s.metadata.outputHeadroomBase === "number" ? s.metadata.outputHeadroomBase : undefined, lastSeen: new Date(s.lastSeen).toISOString(), restored: s.restored === true, }; diff --git a/src/server/handle.ts b/src/server/handle.ts index 60229b7698..269a1b6d11 100644 --- a/src/server/handle.ts +++ b/src/server/handle.ts @@ -2194,6 +2194,17 @@ async function handleRequest( // pre-self-heal and only for plugin sessions, so wire-mode panels fell // back to a hardcoded 200K. session.metadata.effectiveContextLimit = reqConfig.modelContextLimit; + // #4130: tie the effective denominator back to the DECLARED window for + // display surfaces (/acp panel, nudge log line, Web UI bar) — a 200K + // model judging at 150K must not read as a misidentified window. + // Written only while a reservation actually shrank the window; cleared + // otherwise so a model/protocol switch never shows a stale annotation. + // Display-only: the kernel keeps judging against the value above. + if (reqConfig.modelContextLimit < nativeWindow) { + session.metadata.outputHeadroomBase = nativeWindow; + } else { + delete session.metadata.outputHeadroomBase; + } // #955 runtime-info: record the model id + window source for this // session so /__bili/plugin/status can show them pre-first-request and // post-hoc forensics can tell which source sized the window. diff --git a/src/server/prepare-anthropic.ts b/src/server/prepare-anthropic.ts index aafb3fb290..a4cc517a63 100644 --- a/src/server/prepare-anthropic.ts +++ b/src/server/prepare-anthropic.ts @@ -6,7 +6,7 @@ import { rewriteInboundThreadContinue } from "./thread-tracking.js"; import { captureThreadsTurn, estimateThreadsTokens, isThreadsBody, threadsReforgeEnabled } from "./threads-lane.js"; import type { CompressReasoningConfig } from "../reasoning-drop.js"; import type { ProxyOptions } from "../config.js"; -import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, planReasoningDrop, reapOrphansLogged, runNudgeDecision, stripKernelSummaries, warnAnthropicThinkingPairs, type Prepared } from "../server.js"; +import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, outputHeadroomBase, planReasoningDrop, reapOrphansLogged, runNudgeDecision, stripKernelSummaries, warnAnthropicThinkingPairs, type Prepared } from "../server.js"; import { buildDecisionPrompt, buildDirectiveText, consumeFallback, ladderMode, resolveDecisionRange, stripDecisionReasoningFields, type DecideConfig } from "../nudge-decide.js"; import { excludeDeadRefRanges } from "../acp-status.js"; import { reconcileFoldCoverage, noteSystemPromptFingerprint, resolveFoldReconcileMode } from "../fold-reconcile.js"; @@ -363,7 +363,7 @@ export async function prepareAnthropic( growthFoldingArmed: growthFoldingArmed(loopConfig), modelWantsIt: turn.nudge !== undefined && (turn.nudge.shouldInject || emergencyNudgeArmed(session, turn.nudge, loopConfig.compress.minCompressRange, tokenCount, loopConfig.nudge.growthFloor)), }); - log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, resolvedModel ?? parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool))); + log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, resolvedModel ?? parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool), outputHeadroomBase(session))); processedMessages = applyReasoningDrop(stripKernelSummaries(turn.messages, turn.state), reasoningPlan, log, sessionId); // #1001: a silent client history rewrite takes the same archive+prune path // as an announced /compact boundary — syncBlocks above has already diff --git a/src/server/prepare-google.ts b/src/server/prepare-google.ts index 0cd9ed03c9..36d68a13a6 100644 --- a/src/server/prepare-google.ts +++ b/src/server/prepare-google.ts @@ -4,7 +4,7 @@ import { renderNudgeText, viableRanges } from "acp-kernel"; import { coreToGoogle, googleToCore, normalizeGoogleUserPartOrder, type BiliMessage, type GoogleContent, type GoogleRequestBody, type GoogleSystemInstruction, type GoogleTool } from "acp-kernel/wire"; import type { ProxyOptions } from "../config.js"; import { currentCalibrationFactor } from "../util.js"; -import { diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, usageGradeInputBaseline, type Prepared } from "../server.js"; +import { diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, outputHeadroomBase, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, usageGradeInputBaseline, type Prepared } from "../server.js"; import { buildDecisionPrompt, buildDirectiveText, consumeFallback, ladderMode, resolveDecisionRange, stripDecisionReasoningFields, type DecideConfig } from "../nudge-decide.js"; import { excludeDeadRefRanges } from "../acp-status.js"; import { reconcileFoldCoverage, noteSystemPromptFingerprint, resolveFoldReconcileMode } from "../fold-reconcile.js"; @@ -241,7 +241,7 @@ export async function prepareGoogle( growthFoldingArmed: growthFoldingArmed(loopConfig), modelWantsIt: turn.nudge !== undefined && (turn.nudge.shouldInject || emergencyNudgeArmed(session, turn.nudge, loopConfig.compress.minCompressRange, tokenCount, loopConfig.nudge.growthFloor)), }); - log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool))); + log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool), outputHeadroomBase(session))); processedMessages = stripKernelSummaries(turn.messages, turn.state); // #1001: a silent client history rewrite takes the same archive+prune path // as an announced /compact boundary — syncBlocks above has already diff --git a/src/server/prepare-openai.ts b/src/server/prepare-openai.ts index 9361302dc4..69a7bfc875 100644 --- a/src/server/prepare-openai.ts +++ b/src/server/prepare-openai.ts @@ -6,7 +6,7 @@ import type { CompressReasoningConfig } from "../reasoning-drop.js"; import type { ProxyOptions } from "../config.js"; import { currentCalibrationFactor, hardenOpenaiAssistantContent, systemToUser } from "../util.js"; import { conversationHeaderSource, resolveRelayAffinityPck } from "../session-id.js"; -import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, planReasoningDrop, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, warnDroppedOpenaiParts, warnReasoningPairs, type Prepared } from "../server.js"; +import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, outputHeadroomBase, planReasoningDrop, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, warnDroppedOpenaiParts, warnReasoningPairs, type Prepared } from "../server.js"; import { buildDecisionPrompt, buildDirectiveText, consumeFallback, ladderMode, resolveDecisionRange, stripDecisionReasoningFields, type DecideConfig } from "../nudge-decide.js"; import { excludeDeadRefRanges } from "../acp-status.js"; import { reconcileFoldCoverage, noteSystemPromptFingerprint, resolveFoldReconcileMode } from "../fold-reconcile.js"; @@ -260,7 +260,7 @@ export async function prepareOpenai( growthFoldingArmed: growthFoldingArmed(loopConfig), modelWantsIt: turn.nudge !== undefined && (turn.nudge.shouldInject || emergencyNudgeArmed(session, turn.nudge, loopConfig.compress.minCompressRange, tokenCount, loopConfig.nudge.growthFloor)), }); - log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool))); + log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool), outputHeadroomBase(session))); processedMessages = applyReasoningDrop(stripKernelSummaries(turn.messages, turn.state), reasoningPlan, log, sessionId); // #1001: a silent client history rewrite takes the same archive+prune path // as an announced /compact boundary — syncBlocks above has already diff --git a/src/server/prepare-responses.ts b/src/server/prepare-responses.ts index 67663b46c4..2bb7f13dd6 100644 --- a/src/server/prepare-responses.ts +++ b/src/server/prepare-responses.ts @@ -6,7 +6,7 @@ import type { CompressReasoningConfig } from "../reasoning-drop.js"; import { resolveAbsorbSettings } from "../compress-settings.js"; import { resolveCompressProtocol, type CompressSettings, type ProxyOptions } from "../config.js"; import { currentCalibrationFactor, strippedResponseIdWarning } from "../util.js"; -import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, planReasoningDrop, repairResponsesAssistantOrdering, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, usageGradeInputBaseline, warnResponsesReasoningPairs, type Prepared } from "../server.js"; +import { applyReasoningDrop, diagNudge, diagTagSummary, deriveTitle, effectiveTokenCount, imageBillingFor, imageReserveFor, imageTokenCapFor, isAutoInjectedNotification, outputHeadroomBase, planReasoningDrop, repairResponsesAssistantOrdering, reapOrphansLogged, resolveKnownOutputCeiling, runNudgeDecision, stripKernelSummaries, usageGradeInputBaseline, warnResponsesReasoningPairs, type Prepared } from "../server.js"; import { buildDecisionPrompt, buildDirectiveText, consumeFallback, ladderMode, resolveDecisionRange, stripDecisionReasoningFields, type DecideConfig } from "../nudge-decide.js"; import { excludeDeadRefRanges } from "../acp-status.js"; import { mergeAdjacentConfigurationUpdates, patchResponsesInputWithToolImages as patchResponsesInput, responsesToCoreWithToolImages as responsesToCore } from "../responses-tool-output.js"; @@ -361,7 +361,7 @@ export async function prepareResponses( growthFoldingArmed: growthFoldingArmed(loopConfig, codexLane && codexCompactMode() === "intercept" ? loopConfig.modelContextLimit * CODEX_COMPACT_HEALTH_RATIO : undefined), modelWantsIt: turn.nudge !== undefined && (turn.nudge.shouldInject || emergencyNudgeArmed(session, turn.nudge, loopConfig.compress.minCompressRange, tokenCount, loopConfig.nudge.growthFloor)), }); - log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool))); + log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge, decideTier1Arm && !decideFallbackOverride, surfaceOffDetail(laneDecisions, opts.compress.injectTool), outputHeadroomBase(session))); processedMessages = repairResponsesAssistantOrdering(applyReasoningDrop(stripKernelSummaries(turn.messages, turn.state), reasoningPlan, log, sessionId), originalMessages); // #3477: consume the announced native-compaction boundary (pi session_compact // → /__bili/plugin/compact → markCompactionBoundary) exactly once, after the diff --git a/src/web/client.ts b/src/web/client.ts index 320d197a7d..a3e2ca4a4d 100644 --- a/src/web/client.ts +++ b/src/web/client.ts @@ -2519,6 +2519,11 @@ if (d.keepalive) kv(parts, t("det.keepalive"), d.keepalive.tierLabel + " · " + const cls = pct >= 90 ? "bar-fill danger" : pct >= 70 ? "bar-fill warn" : "bar-fill"; parts.push('
' + t("common.context") + ctxMark + " / " + t("common.window") + '
' + fmtW(ctxVal) + " / " + fmtW(d.contextWindow) + " (" + pct + "%)" + ctxMark + "
"); const ctxSubBits = []; + // #4130: denominator is the post-output-headroom effective window — + // say so, or a reserved 200K model reads as a misidentified 150K one. + if ((d.contextWindowBase || 0) > (d.contextWindow || 0)) { + ctxSubBits.push('' + escapeHtml(t("det.window_reserve", { base: fmtW(d.contextWindowBase), res: fmtW(d.contextWindowBase - d.contextWindow) })) + ""); + } if ((d.contextUpperTokens || 0) > 0 && (!best || best.kind !== "upper") && d.contextUpperTokens !== ctxVal) { ctxSubBits.push(t("det.upper_bound", { v: fmtW(d.contextUpperTokens) })); } diff --git a/src/web/i18n.ts b/src/web/i18n.ts index a04aca9fab..d683936fd9 100644 --- a/src/web/i18n.ts +++ b/src/web/i18n.ts @@ -305,6 +305,8 @@ export const MESSAGES: Record> = { "det.obudget_degraded": "⚠️ 模型 {model} 无已知输出上限:输出预算被抬到 {value} tokens(客户端自身估算与绝对下限取大者,仍无权威上限兜底),较长的回复可能在输出上限处被截断。请在 bili 配置为该 provider/model 声明 output,或在宿主模型项显式设置 maxTokens (#2904/#3071)", "det.usage": "用量统计", "det.last_input": "最近单次输入", + "det.window_reserve": "窗口 {base} − 输出预留 {res}", + "det.window_reserve_tip": "分母是判压用的「可用窗口」:声明窗口 − 输出预留(min(max_tokens, 窗口×25%),可经 compress.outputHeadroomMaxPct 调整)。不是窗口识别错误——压缩按可用窗口判断,出站 max_tokens 仍受完整声明窗口保护", "det.upper_bound": "保守上界 {v}(字符数上界,只用于安全保护,不代表实际用量)", "det.ctx_age": "快照 {v}前", "det.ctx_age_tip": "该上下文数值的意量/估计时间;恢复或闲置后不再刷新,旧快照不代表当前发送视图", @@ -894,6 +896,8 @@ export const MESSAGES: Record> = { "det.obudget_degraded": "⚠️ Model {model} has NO known output ceiling: its output budget is raised to {value} tokens (the larger of the client's own estimate and the absolute minimum; no authoritative ceiling to back it), so longer replies may be cut off at the output limit. Declare an output limit for this provider/model in bili config, or set maxTokens on the model in the host profile (#2904/#3071)", "det.usage": "Usage", "det.last_input": "Last single-turn input", + "det.window_reserve": "window {base} − output reserve {res}", + "det.window_reserve_tip": "The denominator is the EFFECTIVE window compression judges against: declared window − output reserve (min(max_tokens, 25% of window), tunable via compress.outputHeadroomMaxPct). Not a misidentified window — outgoing max_tokens stays guarded by the full declared window", "det.upper_bound": "bound {v} (char-count upper bound — safety protection only, not actual usage)", "det.ctx_age": "snap {v} ago", "det.ctx_age_tip": "When this context number was measured/estimated; it stops refreshing on restore or idle — an old snapshot is not the current sent view", diff --git a/src/web/report.ts b/src/web/report.ts index 1886f02947..98d63afdf7 100644 --- a/src/web/report.ts +++ b/src/web/report.ts @@ -26,6 +26,8 @@ interface ReportData { systemPromptTokens?: number; contextTokens?: number; contextWindow?: number; + /** #4130: declared pre-output-headroom window (present while a reservation shrinks contextWindow). */ + contextWindowBase?: number; contextTokensSource?: string; contextBest?: { tokens?: number }; retrieveCalls?: number; @@ -132,12 +134,19 @@ function readLedger(d: ReportData) { return { led, tot, seam, st, folds, lines, seamEvents, ctxBest, win }; } +// #4130: the context denominator is the EFFECTIVE window (post output-headroom +// reservation) — append the declared-window note so the report can't be misread. +function windowReserveNote(d: ReportData, win: number, t: (k: string, a?: Record) => string, fmtW: (n: number) => string): string { + return d.contextWindowBase && d.contextWindowBase > win ? " (" + t("det.window_reserve", { base: fmtW(d.contextWindowBase), res: fmtW(d.contextWindowBase - win) }) + ")" : ""; +} + export function buildSessionReportMd(d: ReportData, opts: ReportOpts = {}): string { const mask = opts.mask !== false; const lang = opts.lang === "en" ? "en" : "zh-CN"; const t = (k: string, a?: Record) => tr(lang, k, a); const f = makeFmt(lang); const { tot, seam, st, folds, lines, seamEvents, ctxBest, win } = readLedger(d); + const winNote = windowReserveNote(d, win, t, f.W); const NL = String.fromCharCode(10); const L: string[] = []; L.push("# billion-context session report"); @@ -153,7 +162,7 @@ export function buildSessionReportMd(d: ReportData, opts: ReportOpts = {}): stri L.push("- protocol: " + (d.protocol || f.none)); L.push("- upstream: " + (f.host(d.upstreamOrigin) || f.none)); L.push("- requests: " + (d.requests != null ? d.requests : f.none)); - L.push("- context: " + f.W(ctxBest) + (win ? " / " + f.W(win) + " (" + (ctxBest / win * 100).toFixed(1) + "%)" : "") + (d.contextTokensSource === "estimate" ? " (estimate)" : "")); + L.push("- context: " + f.W(ctxBest) + (win ? " / " + f.W(win) + " (" + (ctxBest / win * 100).toFixed(1) + "%)" + winNote : "") + (d.contextTokensSource === "estimate" ? " (estimate)" : "")); if (Number(d.systemPromptTokens)) L.push("- system prompt: " + f.W(d.systemPromptTokens)); if (Array.isArray(d.blockDetails)) L.push("- blocks: " + d.blockDetails.filter((b) => b.active).length + " active / " + d.blockDetails.length + " total"); L.push("- compressions (folds): " + folds.length); @@ -238,6 +247,7 @@ export function buildSessionReportSvg(d: ReportData, opts: ReportOpts = {}): Svg const t = (k: string, a?: Record) => tr(lang, k, a); const f = makeFmt(lang); const { tot, seam, st, folds, lines, seamEvents, ctxBest, win } = readLedger(d); + const winNote = windowReserveNote(d, win, t, f.W); const W = 920, PAD = 28; const INK = "#1f2328", MUT = "#6e7681", LINEC = "#d0d7de", ACC = "#0969da", RED = "#cf222e", AMB = "#bf8700", SOFT = "#f6f8fa"; const SANS = "ui-sans-serif,-apple-system,'Segoe UI',Roboto,Helvetica,Arial,sans-serif"; @@ -297,7 +307,7 @@ export function buildSessionReportSvg(d: ReportData, opts: ReportOpts = {}): Svg kv(t("common.protocol"), d.protocol || f.none); kv(t("common.upstream"), f.host(d.upstreamOrigin) || f.none); kv(t("common.requests"), d.requests != null ? String(d.requests) : f.none, true); - kv(t("common.context"), f.W(ctxBest) + (win ? " / " + f.W(win) + " (" + (ctxBest / win * 100).toFixed(1) + "%)" : "") + (d.contextTokensSource === "estimate" ? " (est.)" : ""), true); + kv(t("common.context"), f.W(ctxBest) + (win ? " / " + f.W(win) + " (" + (ctxBest / win * 100).toFixed(1) + "%)" + winNote : "") + (d.contextTokensSource === "estimate" ? " (est.)" : ""), true); if (Number(d.systemPromptTokens)) kv("system prompt", f.W(d.systemPromptTokens), true); if (Array.isArray(d.blockDetails)) kv("blocks", d.blockDetails.filter((b) => b.active).length + " active / " + d.blockDetails.length + " total", true); kv("compressions", String(folds.length), true); diff --git a/src/web/sessions-data.ts b/src/web/sessions-data.ts index b28b5b7a69..3f0adbe0f6 100644 --- a/src/web/sessions-data.ts +++ b/src/web/sessions-data.ts @@ -56,6 +56,9 @@ interface WebSessionSummary { cacheHitPct: number | null; blocks: number; contextWindow?: number; + /** #4130: declared pre-output-headroom window — present only while a + * reservation shrinks the effective denominator (contextWindow = base − reserve). */ + contextWindowBase?: number; lastSeen: string; restored?: boolean; /** true when the per-request cache ledger holds samples — the token @@ -750,6 +753,7 @@ function summaryOf(s: SummarySource, live: boolean): WebSessionSummary { cacheHitPct: hitPct(inputTokens, cachedTokens), blocks: s.state.blocks.length, ...(typeof s.metadata.effectiveContextLimit === "number" ? { contextWindow: s.metadata.effectiveContextLimit } : {}), + ...(typeof s.metadata.outputHeadroomBase === "number" ? { contextWindowBase: s.metadata.outputHeadroomBase } : {}), ...(selfHeal ? { selfHeal } : {}), ...(autoModeForge ? { autoModeForge } : {}), ...(keepalive ? { keepalive } : {}), diff --git a/tests/issue4130-headroom-denominator.test.ts b/tests/issue4130-headroom-denominator.test.ts new file mode 100644 index 0000000000..1784f6fb49 --- /dev/null +++ b/tests/issue4130-headroom-denominator.test.ts @@ -0,0 +1,149 @@ +import assert from "node:assert/strict"; +import http from "node:http"; +import { once } from "node:events"; +import test from "node:test"; + +process.env.NODE_ENV = "test"; + +// #4130: the compression engine judges against the EFFECTIVE window (declared +// window − output-headroom reservation, #896/#2096), but every persistent +// display surface showed that denominator bare — a 200K model judging at 150K +// read as a misidentified window (three rounds of misdiagnosis in the field). +// Fix: handle() records the declared pre-reservation window in +// session.metadata.outputHeadroomBase (cleared when no reservation is active); +// the nudge log line, the /acp panel (before-footer slot), the Web UI session +// bar and the JSON surfaces annotate from that single source. These tests pin: +// A. the nudge-line annotation (present ⇔ reservation active, exact math); +// B. the helper guard (display-only reader, never invents values); +// C. end-to-end: reservation writes the base, a reservation-less request +// clears it, and the Web data projection follows. + +import { defaultConfig } from "acp-kernel"; +import { startServer, diagNudge, outputHeadroomBase } from "../src/server.ts"; +import type { ProxyOptions } from "../src/config.ts"; +import type { Session } from "../src/session.ts"; +import { SessionStore, _setStoreForTest } from "../src/persist.ts"; +import { _setForTest as setRegistryForTest } from "../src/registry.ts"; +import { setLogCapture } from "../src/logger.ts"; +import { buildSessionList } from "../src/web/sessions-data.ts"; + +const NUDGE_TURN = { nudge: { shouldInject: false, reason: "growth below floor", contextUsage: 0.05, tier: null, breakdown: { growth: 0, growthFloor: 50000, nudgeGrowthTokens: 50000, pendingT1: 0, growthReference: 0 } } }; + +test("#4130 unit: nudge line annotates the effective denominator with the declared window", () => { + const line = diagNudge(NUDGE_TURN, "s4130", 65256, 150000, "gpt-x", false, false, undefined, 200000); + assert.ok(line.includes("usage=44% (65256/150000, window 200000 − output reserve 50000)"), `annotation missing/mis-mathed: ${line}`); +}); + +test("#4130 unit: nudge line keeps the legacy shape when no reservation is recorded", () => { + const line = diagNudge(NUDGE_TURN, "s4130", 65256, 200000, "gpt-x", false); + assert.ok(line.includes("usage=33% (65256/200000), growth="), `legacy shape drifted: ${line}`); + assert.ok(!line.includes("output reserve"), `no annotation expected: ${line}`); +}); + +test("#4130 unit: annotation suppressed when the base does not exceed the limit", () => { + const line = diagNudge(NUDGE_TURN, "s4130", 65256, 200000, "gpt-x", false, false, undefined, 200000); + assert.ok(!line.includes("output reserve"), `equal base must not annotate: ${line}`); +}); + +test("#4130 unit: outputHeadroomBase passes numbers through and rejects everything else", () => { + const as = (v: unknown) => ({ metadata: v === undefined ? {} : { outputHeadroomBase: v } }) as unknown as Session; + assert.equal(outputHeadroomBase(as(200000)), 200000); + assert.equal(outputHeadroomBase(as(undefined)), undefined); + assert.equal(outputHeadroomBase(as("200000")), undefined); + assert.equal(outputHeadroomBase(as(Number.NaN)), undefined); + assert.equal(outputHeadroomBase({ metadata: {} } as unknown as Session), undefined); +}); + +const WINDOW = 100_000; +const MODEL = "gpt-basil"; + +function makeUpstream(): http.Server { + return http.createServer((_req, res) => { + res.writeHead(200, { "content-type": "text/event-stream" }); + res.write(`data: ${JSON.stringify({ id: "c4130", object: "chat.completion.chunk", created: 1, model: MODEL, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] })}\n\n`); + res.write(`data: ${JSON.stringify({ id: "c4130", object: "chat.completion.chunk", created: 1, model: MODEL, choices: [{ index: 0, delta: { content: "ok" }, finish_reason: null }] })}\n\n`); + res.write(`data: ${JSON.stringify({ id: "c4130", object: "chat.completion.chunk", created: 1, model: MODEL, choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 100, completion_tokens: 3, total_tokens: 103 } })}\n\n`); + res.end(`data: [DONE]\n\n`); + }); +} + +async function startHarness(): Promise<{ proxy: http.Server; upstream: http.Server; proxyPort: number; upstreamPort: number }> { + _setStoreForTest(new SessionStore({ enabled: false })); + setRegistryForTest({}); + const upstream = makeUpstream(); + upstream.listen(0, "127.0.0.1"); + await once(upstream, "listening"); + const upstreamPort = (upstream.address() as { port: number }).port; + const proxy = await startServer({ + port: 0, + host: "127.0.0.1", + upstream: "http://127.0.0.1", + routes: { [`http://127.0.0.1:${upstreamPort}`]: { models: { [MODEL]: { context: WINDOW } } } }, + modelContextLimit: WINDOW, + kernelConfig: defaultConfig(WINDOW), + compress: { injectTool: true, injectNudge: true }, + promptCache: { routing: "auto" }, + sessionHeader: "x-acp-session", + log: true, + debug: false, + passthrough: false, + autoUpdate: false, + mitm: { enabled: false, domains: [] }, + } as ProxyOptions); + await once(proxy, "listening"); + return { proxy, upstream, proxyPort: (proxy.address() as { port: number }).port, upstreamPort }; +} + +async function drive(proxyPort: number, upstreamPort: number, session: string, body: Record): Promise { + const r = await fetch(`http://127.0.0.1:${proxyPort}/bili/http://127.0.0.1:${upstreamPort}/v1/chat/completions`, { + method: "POST", + headers: { "content-type": "application/json", "x-acp-session": session }, + body: JSON.stringify({ model: MODEL, stream: true, messages: [{ role: "user", content: "hello" }], ...body }), + }); + assert.equal(r.status, 200, `request must succeed, got ${r.status}: ${await r.text().catch(() => "")}`); + await r.body?.cancel().catch(() => { /* drained */ }); +} + +async function webEntry(session: string) { + const list = await buildSessionList(); + const entry = list.find((s) => s.id === session); + assert.ok(entry, `session ${session} must be listed`); + return entry; +} + +test("#4130 e2e: reservation annotates the nudge line and the web projection; a reservation-less request clears both", async () => { + const logs: string[] = []; + setLogCapture((level, msg) => { logs.push(`${level} ${msg}`); }); + const h = await startHarness(); + try { + // max_tokens 30000 > 25% of 100000 -> reserved 25000 -> effective 75000. + await drive(h.proxyPort, h.upstreamPort, "s4130-e2e", { max_tokens: 30_000 }); + const annotated = logs.filter((l) => l.includes("s4130-e2e") && l.includes("usage=") && l.includes(", window 100000 − output reserve 25000)")); + assert.equal(annotated.length, 1, `exactly one annotated nudge line expected, got: ${JSON.stringify(logs.filter((l) => l.includes("s4130-e2e") && l.includes("usage=")))}`); + assert.ok(annotated[0].includes("/75000,"), `denominator must be the effective window, got: ${annotated[0]}`); + + let entry = await webEntry("s4130-e2e"); + assert.equal(entry.contextWindow, 75_000, `web projection must carry the effective denominator, got ${entry.contextWindow}`); + assert.equal(entry.contextWindowBase, WINDOW, `web projection must carry the declared base, got ${entry.contextWindowBase}`); + + // Same session, request WITHOUT any output budget -> no reservation -> + // the stale base must be cleared (model-switch safety, same writer). + logs.length = 0; + await drive(h.proxyPort, h.upstreamPort, "s4130-e2e", {}); + const bare = logs.filter((l) => l.includes("s4130-e2e") && l.includes("usage=")); + assert.equal(bare.length, 1, `one nudge line expected, got: ${JSON.stringify(bare)}`); + assert.ok(bare[0].includes("/100000), growth="), `denominator back to the full window, got: ${bare[0]}`); + assert.ok(!bare[0].includes("output reserve"), `stale annotation must be gone, got: ${bare[0]}`); + + entry = await webEntry("s4130-e2e"); + assert.equal(entry.contextWindow, WINDOW, `effective window restored, got ${entry.contextWindow}`); + assert.equal(entry.contextWindowBase, undefined, `base must be cleared when no reservation is active, got ${entry.contextWindowBase}`); + } finally { + setLogCapture(null); + h.proxy.close(); + h.proxy.closeIdleConnections?.(); + h.upstream.close(); + h.upstream.closeIdleConnections?.(); + await Promise.allSettled([once(h.proxy, "close"), once(h.upstream, "close")]); + } +}); From 18a85706a167bbabd241cee21fe3f3647ce9f534 Mon Sep 17 00:00:00 2001 From: awork Date: Fri, 23 Oct 2026 16:55:09 +0800 Subject: [PATCH 2/2] fix(ci): drop duplicate concurrency key that invalidated ci.yml (#4393) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit #4393 added a second top-level concurrency: block without noticing the owner-approved one already present further down (skip-scoped labeled runs, schedule-safe cancel-in-progress). The duplicate key makes the file fail GitHub's parser ('concurrency' is already defined), so NO main-CI run starts on any branch or on master since the merge — zero workflow runs on master commit 970bd4d40. The pre-existing block already delivers #4393's goal (same-ref supersede cancellation), so the redundant block goes. --- .github/workflows/ci.yml | 8 -------- 1 file changed, 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fb1f402196..b903f9e0d5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,13 +1,5 @@ name: CI -# Same-branch pushes supersede: cancel the branch's in-progress/queued CI run -# so a 12-leg matrix never piles up behind itself (the 8 e2e workflows have -# had this since their split; the main CI was the gap — see the 447-run queue -# incident on 2026-10-23). -concurrency: - group: ci-${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - on: push: # Release branches also run CI on push: ref updates made with a real