@tea-agent/loop-agent 0.40.0-next.10 → 0.40.0-next.12

package/dist/shared/pi-context-pressure/sift-bridge.js

@@ -0,0 +1,386 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { parseBoundedNumber, parseEnabledFlag } from "./env.js";
+import { emptyContextPressureCounters, incrementCounter, } from "./telemetry.js";
+export const SIFT_POLICY_VERSION = "sift-v1-query-undefined";
+export const SIFT_RETRIEVE_TOOL_NAME = "sift_retrieve";
+export const SIFT_STASH_KEY_PATTERN = /^[0-9a-f]{24}$/;
+export const SIFT_RETRIEVE_DEFAULT_BYTES = 24 * 1024;
+export const SIFT_RETRIEVE_MAX_BYTES = 48 * 1024;
+export const DEFAULT_MEMO_MAX_ENTRIES = 128;
+export const DEFAULT_MEMO_MAX_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_STASH_RETENTION_DAYS = 14;
+class BoundedMemo {
+    maxEntries;
+    maxBytes;
+    entries = new Map();
+    bytes = 0;
+    constructor(maxEntries, maxBytes) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        const hit = this.entries.get(key);
+        if (!hit)
+            return undefined;
+        this.entries.delete(key);
+        this.entries.set(key, hit);
+        try {
+            return JSON.parse(hit.json);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        const json = JSON.stringify(value);
+        const size = Buffer.byteLength(json);
+        if (size > this.maxBytes)
+            return;
+        this.delete(key);
+        while (this.entries.size >= this.maxEntries ||
+            this.bytes + size > this.maxBytes) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.delete(oldest);
+        }
+        this.entries.set(key, { json, bytes: size });
+        this.bytes += size;
+    }
+    delete(key) {
+        const current = this.entries.get(key);
+        if (!current)
+            return;
+        this.entries.delete(key);
+        this.bytes -= current.bytes;
+    }
+}
+export function parseSiftBridgeConfig(input) {
+    const env = input.env ?? process.env;
+    const override = env.HARNESS_CONSOLE_SIFT_STASH_DIR?.trim();
+    const root = override || input.defaultStashRoot;
+    const stashDir = path.join(root, input.sessionId);
+    const entries = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_MEMO_MAX_ENTRIES, DEFAULT_MEMO_MAX_ENTRIES, 8, 4096);
+    const bytes = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_MEMO_MAX_BYTES, DEFAULT_MEMO_MAX_BYTES, 1024, 256 * 1024 * 1024);
+    const retention = parseBoundedNumber(env.HARNESS_CONSOLE_SIFT_STASH_RETENTION_DAYS, DEFAULT_STASH_RETENTION_DAYS, 1, 365);
+    return {
+        sessionId: input.sessionId,
+        stashDir,
+        memoMaxEntries: entries.value,
+        memoMaxBytes: bytes.value,
+        retentionDays: retention.value,
+        ...(input.siftFactory ? { siftFactory: input.siftFactory } : {}),
+        ...(input.importSift ? { importSift: input.importSift } : {}),
+    };
+}
+export function createSiftBridgeState(config) {
+    return {
+        sessionId: config.sessionId,
+        stashDir: config.stashDir,
+        config,
+        counters: emptyContextPressureCounters(),
+        retrieveBypassIds: new Set(),
+        diagnostics: new Set(),
+        memo: new BoundedMemo(config.memoMaxEntries, config.memoMaxBytes),
+        importFailed: false,
+    };
+}
+function noteOnce(state, code) {
+    if (state.diagnostics.has(code))
+        return;
+    state.diagnostics.add(code);
+    incrementCounter(state.counters, "fail-open");
+}
+function memoKey(payload) {
+    return createHash("sha256")
+        .update(SIFT_POLICY_VERSION)
+        .update("\0")
+        .update(JSON.stringify(payload))
+        .digest("hex");
+}
+function ensureStashDir(stashDir) {
+    mkdirSync(stashDir, { recursive: true, mode: 0o700 });
+}
+async function ensureSift(state) {
+    if (state.sift)
+        return state.sift;
+    if (state.importFailed)
+        return undefined;
+    try {
+        ensureStashDir(state.stashDir);
+        if (state.config.siftFactory) {
+            state.sift = state.config.siftFactory({ stashDir: state.stashDir });
+            return state.sift;
+        }
+        const importer = state.config.importSift ??
+            (async () => (await import("@agent-context/sift")));
+        const mod = await importer();
+        if (typeof mod.createSift !== "function") {
+            state.importFailed = true;
+            noteOnce(state, "sift-import-invalid");
+            return undefined;
+        }
+        state.sift = mod.createSift({ stashDir: state.stashDir });
+        return state.sift;
+    }
+    catch {
+        state.importFailed = true;
+        noteOnce(state, "sift-import-failed");
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasTrailingAnthropicCacheAnchor(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.messages))
+        return false;
+    const last = payload.messages[payload.messages.length - 1];
+    if (!isRecord(last))
+        return false;
+    const content = last.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return false;
+    const lastBlock = content[content.length - 1];
+    return isRecord(lastBlock) && lastBlock.cache_control !== undefined;
+}
+function restoreProtectedToolResults(originalPayload, compressed, protectedIds) {
+    if (protectedIds.size === 0)
+        return compressed;
+    const original = structuredClone(originalPayload);
+    const next = structuredClone(compressed);
+    restoreInMessages(original, next, protectedIds);
+    restoreInResponsesInput(original, next, protectedIds);
+    return next;
+}
+function restoreInMessages(original, next, protectedIds) {
+    if (!isRecord(original) || !isRecord(next))
+        return;
+    if (!Array.isArray(original.messages) || !Array.isArray(next.messages))
+        return;
+    for (let index = 0; index < next.messages.length; index += 1) {
+        const origMsg = original.messages[index];
+        const nextMsg = next.messages[index];
+        if (!isRecord(origMsg) || !isRecord(nextMsg))
+            continue;
+        const origId = typeof origMsg.tool_call_id === "string"
+            ? origMsg.tool_call_id
+            : undefined;
+        if (origId && protectedIds.has(origId)) {
+            next.messages[index] = origMsg;
+            continue;
+        }
+        if (Array.isArray(origMsg.content) && Array.isArray(nextMsg.content)) {
+            for (let blockIndex = 0; blockIndex < nextMsg.content.length; blockIndex += 1) {
+                const origBlock = origMsg.content[blockIndex];
+                if (!isRecord(origBlock))
+                    continue;
+                const toolUseId = typeof origBlock.tool_use_id === "string"
+                    ? origBlock.tool_use_id
+                    : undefined;
+                if (toolUseId && protectedIds.has(toolUseId)) {
+                    nextMsg.content[blockIndex] = origBlock;
+                }
+            }
+        }
+    }
+}
+function restoreInResponsesInput(original, next, protectedIds) {
+    if (!isRecord(original) || !isRecord(next))
+        return;
+    if (!Array.isArray(original.input) || !Array.isArray(next.input))
+        return;
+    for (let index = 0; index < next.input.length; index += 1) {
+        const origItem = original.input[index];
+        if (!isRecord(origItem))
+            continue;
+        const callId = typeof origItem.call_id === "string" ? origItem.call_id : undefined;
+        if (callId && protectedIds.has(callId)) {
+            next.input[index] = origItem;
+        }
+    }
+}
+export async function compressProviderPayload(state, payload) {
+    if (payload === undefined)
+        return undefined;
+    if (!isRecord(payload)) {
+        noteOnce(state, "unknown-format");
+        return undefined;
+    }
+    const key = memoKey(payload);
+    const cached = state.memo.get(key);
+    if (cached !== undefined)
+        return cached;
+    if (hasTrailingAnthropicCacheAnchor(payload)) {
+        const sift = await ensureSift(state);
+        if (!sift)
+            return undefined;
+        try {
+            const result = sift.siftRequest(payload, undefined);
+            if (result.changed === false &&
+                result.blocksExamined === 0 &&
+                result.frozenMessages ===
+                    (Array.isArray(payload.messages)
+                        ? (payload.messages.length)
+                        : 0)) {
+                return undefined;
+            }
+            if (!result.changed)
+                return undefined;
+            noteOnce(state, "anthropic-unexpected-change");
+            return undefined;
+        }
+        catch {
+            noteOnce(state, "sift-handler-error");
+            return undefined;
+        }
+    }
+    const sift = await ensureSift(state);
+    if (!sift)
+        return undefined;
+    try {
+        const result = sift.siftRequest(payload, undefined);
+        if (!result || result.changed !== true)
+            return undefined;
+        const restored = restoreProtectedToolResults(payload, result.body, state.retrieveBypassIds);
+        state.counters.tokensSavedEstimate += Math.max(0, result.tokensSaved ?? 0);
+        state.counters.blocksCompressed += Math.max(0, result.blocksCompressed ?? 0);
+        incrementCounter(state.counters, "wire-compression");
+        state.memo.set(key, restored);
+        return restored;
+    }
+    catch {
+        noteOnce(state, "sift-handler-error");
+        return undefined;
+    }
+}
+export function clearRetrieveBypass(state) {
+    state.retrieveBypassIds.clear();
+}
+export function sliceUtf8Range(text, offset, maxBytes) {
+    const totalBytes = Buffer.byteLength(text, "utf8");
+    const start = Math.max(0, Math.floor(offset));
+    const limit = Math.min(SIFT_RETRIEVE_MAX_BYTES, Math.max(1, Math.floor(maxBytes)));
+    if (start >= totalBytes) {
+        return { slice: "", nextOffset: null, totalBytes, complete: true };
+    }
+    const buffer = Buffer.from(text, "utf8");
+    let end = Math.min(totalBytes, start + limit);
+    while (end > start && (buffer[end] & 0b1100_0000) === 0b1000_0000) {
+        end -= 1;
+    }
+    const slice = buffer.subarray(start, end).toString("utf8");
+    const complete = end >= totalBytes;
+    return {
+        slice,
+        nextOffset: complete ? null : end,
+        totalBytes,
+        complete,
+    };
+}
+export async function executeSiftRetrieve(state, toolCallId, params) {
+    const key = typeof params.key === "string" ? params.key.trim() : "";
+    if (!SIFT_STASH_KEY_PATTERN.test(key)) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "STASH_NOT_FOUND_OR_EXPIRED",
+                        complete: true,
+                    }),
+                },
+            ],
+        };
+    }
+    const sift = await ensureSift(state);
+    const original = sift?.retrieve(key) ?? null;
+    if (original === null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "STASH_NOT_FOUND_OR_EXPIRED",
+                        complete: true,
+                    }),
+                },
+            ],
+        };
+    }
+    const offset = typeof params.offset === "number" && Number.isFinite(params.offset)
+        ? Math.max(0, Math.floor(params.offset))
+        : 0;
+    const maxBytes = typeof params.maxBytes === "number" && Number.isFinite(params.maxBytes)
+        ? params.maxBytes
+        : SIFT_RETRIEVE_DEFAULT_BYTES;
+    const page = sliceUtf8Range(original, offset, maxBytes);
+    if (toolCallId)
+        state.retrieveBypassIds.add(toolCallId);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    key,
+                    offset,
+                    maxBytes: Math.min(SIFT_RETRIEVE_MAX_BYTES, Math.max(1, Math.floor(maxBytes))),
+                    totalBytes: page.totalBytes,
+                    nextOffset: page.nextOffset,
+                    complete: page.complete,
+                    text: page.slice,
+                }),
+            },
+        ],
+    };
+}
+export function housekeepSiftStash(input) {
+    let removed = 0;
+    try {
+        const entries = readdirSync(input.root, { withFileTypes: true });
+        const cutoff = (input.now ?? Date.now()) - input.retentionDays * 24 * 60 * 60 * 1000;
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (input.activeSessionId && entry.name === input.activeSessionId)
+                continue;
+            const full = path.join(input.root, entry.name);
+            let mtime = 0;
+            try {
+                mtime = statSync(full).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (mtime <= cutoff) {
+                rmSync(full, { recursive: true, force: true });
+                removed += 1;
+            }
+        }
+        return { removed, failed: false };
+    }
+    catch {
+        return { removed, failed: true };
+    }
+}
+export function createSiftRetrieveToolDefinition(state) {
+    return {
+        name: SIFT_RETRIEVE_TOOL_NAME,
+        label: "Sift Retrieve",
+        description: "Retrieve a previously compressed tool-output page by 24-hex stash key. Use offset/maxBytes to page; default 24KiB, max 48KiB.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                key: { type: "string", description: "24-hex stash key" },
+                offset: { type: "number", description: "UTF-8 byte offset" },
+                maxBytes: { type: "number", description: "Page size in bytes" },
+            },
+            required: ["key"],
+        },
+        execute: (toolCallId, params) => executeSiftRetrieve(state, toolCallId, params),
+    };
+}
+export { parseEnabledFlag };

package/dist/shared/pi-context-pressure/telemetry.js

@@ -0,0 +1,51 @@
+export function emptyContextPressureCounters() {
+    return {
+        prePromptThreshold: 0,
+        overflow: 0,
+        manual: 0,
+        wireCompression: 0,
+        failOpen: 0,
+        usageUnavailable: 0,
+        l0CompactFailed: 0,
+        tokensSavedEstimate: 0,
+        blocksCompressed: 0,
+    };
+}
+export function incrementCounter(counters, reason, amount = 1) {
+    switch (reason) {
+        case "pre-prompt-threshold":
+            counters.prePromptThreshold += amount;
+            break;
+        case "overflow":
+            counters.overflow += amount;
+            break;
+        case "manual":
+            counters.manual += amount;
+            break;
+        case "wire-compression":
+            counters.wireCompression += amount;
+            break;
+        case "fail-open":
+            counters.failOpen += amount;
+            break;
+        case "usage-unavailable":
+            counters.usageUnavailable += amount;
+            break;
+        case "l0-compact-failed":
+            counters.l0CompactFailed += amount;
+            break;
+        default:
+            break;
+    }
+}
+export function projectSafeTelemetry(counters) {
+    return {
+        prePromptThreshold: counters.prePromptThreshold,
+        overflow: counters.overflow,
+        manual: counters.manual,
+        wireCompression: counters.wireCompression,
+        failOpen: counters.failOpen,
+        tokensSavedEstimate: counters.tokensSavedEstimate,
+        blocksCompressed: counters.blocksCompressed,
+    };
+}

package/dist/worker/console/chat/pi-runtime.js

@@ -36,6 +36,8 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteTo
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
 import { applySkillAutoInvocationPreferences, isAutoInvocationEnabled, loadResourcePreferences, skillResourceId, } from "./resource-preferences-store.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
+import { applyProcessCompactionOverride, createCompactionController, createContextPressureExtension, createSiftBridgeState, housekeepSiftStash, isConsoleSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, projectPromptPressure, deriveEffectiveWindow, projectSafeTelemetry, emptyContextPressureCounters, } from "../../../shared/pi-context-pressure/index.js";
+import { incrementCounter as incrementPressureCounter } from "../../../shared/pi-context-pressure/telemetry.js";
 import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
@@ -845,6 +847,9 @@ export class ConsolePiRuntime {
     sessionModels = new Map();
     /** SessionIds disposed while materialization was still in flight. */
     disposedSessions = new Set();
+    compactionControllers = new Map();
+    siftStates = new Map();
+    /** Session-less tool definition caches (no AgentSession state). */
     /** Session-less tool definition caches (no AgentSession state). */
     operatorCustomToolsPromise;
     exploreCustomToolsPromise;
@@ -892,14 +897,15 @@ export class ConsolePiRuntime {
                 registry: this.options.todoRegistry,
             })
             : undefined;
+        const pressureExtension = sessionId
+            ? this.createContextPressureInlineExtension(sessionId)
+            : undefined;
+        const extraFactories = [todoContextExtension, pressureExtension].filter((item) => Boolean(item));
         return {
             ...base,
-            ...(todoContextExtension
+            ...(extraFactories.length > 0
                 ? {
-                    extensionFactories: [
-                        ...inheritedFactories,
-                        todoContextExtension,
-                    ],
+                    extensionFactories: [...inheritedFactories, ...extraFactories],
                 }
                 : {}),
             skillsOverride: (current) => {
@@ -924,6 +930,126 @@ export class ConsolePiRuntime {
         this.cachedSkillPrefs = prefs;
         return prefs;
     }
+    getCompactionController(sessionId) {
+        let controller = this.compactionControllers.get(sessionId);
+        if (!controller) {
+            controller = createCompactionController();
+            this.compactionControllers.set(sessionId, controller);
+        }
+        if (this.options.todoRegistry) {
+            controller.todos = this.options.todoRegistry.get(sessionId);
+        }
+        return controller;
+    }
+    createContextPressureInlineExtension(sessionId) {
+        const policy = parseCompactionPolicy();
+        const siftEnabled = isConsoleSiftEnabled();
+        let sift;
+        if (siftEnabled.enabled) {
+            sift = this.siftStates.get(sessionId);
+            if (!sift) {
+                const config = parseSiftBridgeConfig({
+                    sessionId,
+                    defaultStashRoot: path.join(this.options.sessionDir, "sift-stash"),
+                });
+                sift = createSiftBridgeState(config);
+                sift.counters = this.getCompactionController(sessionId).counters;
+                this.siftStates.set(sessionId, sift);
+                const housekeep = housekeepSiftStash({
+                    root: path.dirname(config.stashDir),
+                    activeSessionId: sessionId,
+                    retentionDays: config.retentionDays,
+                });
+                if (housekeep.failed)
+                    sift.diagnostics.add("housekeep-failed");
+            }
+        }
+        return createContextPressureExtension({
+            name: "operator-chat-context-pressure",
+            policy,
+            controller: this.getCompactionController(sessionId),
+            sift,
+        });
+    }
+    applySessionCompactionOverride(sessionId, services, session) {
+        const manager = services?.settingsManager;
+        const window = session?.getSessionStats?.()?.contextUsage?.contextWindow;
+        applyProcessCompactionOverride(manager, {
+            policy: parseCompactionPolicy(),
+            ...(typeof window === "number" ? { contextWindow: window } : {}),
+        });
+        void sessionId;
+    }
+    async runPrePromptCompaction(sessionId, session, promptText, imageCount, onEvent) {
+        const policy = parseCompactionPolicy();
+        if (policy.mode === "off")
+            return;
+        const controller = this.getCompactionController(sessionId);
+        const stats = session.getSessionStats?.();
+        const window = stats?.contextUsage?.contextWindow;
+        const tokens = stats?.contextUsage?.tokens;
+        if (typeof window === "number" && window > 0) {
+            this.applySessionCompactionOverride(sessionId, this.serviceScopes.get(sessionId) ?? {}, session);
+        }
+        const projection = projectPromptPressure({
+            currentContextTokens: tokens,
+            promptText,
+            imageCount,
+        });
+        if (projection.usageUnavailable) {
+            incrementPressureCounter(controller.counters, "usage-unavailable");
+            return;
+        }
+        const effective = typeof window === "number" && window > 0
+            ? deriveEffectiveWindow(window, policy)
+            : undefined;
+        if (!effective || projection.projected < effective.triggerTokens)
+            return;
+        if (typeof session.compact !== "function")
+            return;
+        const compactionId = newCompactionId(sessionId);
+        onEvent({
+            type: "compaction_start",
+            sessionId,
+            compactionId,
+            reason: "threshold",
+        });
+        controller.proactiveCompaction = true;
+        try {
+            incrementPressureCounter(controller.counters, "pre-prompt-threshold");
+            const result = await session.compact();
+            const snapshot = projectCompactSnapshot(result ?? {});
+            onEvent({
+                type: "compaction_end",
+                sessionId,
+                compactionId,
+                reason: "threshold",
+                status: "completed",
+                willRetry: false,
+                summary: snapshot.summary,
+                ...(snapshot.firstKeptEntryId
+                    ? { firstKeptEntryId: snapshot.firstKeptEntryId }
+                    : {}),
+                ...(snapshot.tokensBefore === undefined
+                    ? {}
+                    : { tokensBefore: snapshot.tokensBefore }),
+            });
+        }
+        catch {
+            incrementPressureCounter(controller.counters, "l0-compact-failed");
+            onEvent({
+                type: "compaction_end",
+                sessionId,
+                compactionId,
+                reason: "threshold",
+                status: "failed",
+                willRetry: false,
+            });
+        }
+        finally {
+            controller.proactiveCompaction = false;
+        }
+    }
     /**
      * Resolve a skill in the current session inventory by server-issued resourceId.
      * Returns undefined when the id is unknown (caller maps to PI_SKILL_NOT_FOUND).
@@ -1156,6 +1282,7 @@ export class ConsolePiRuntime {
             resourceLoader: services.resourceLoader,
             settingsManager: services.settingsManager,
         });
+        this.applySessionCompactionOverride(sessionId, services, session);
         this.revisions.set(sessionId, 1);
         if (!this.thinkingSelections.has(sessionId)) {
             this.thinkingSelections.set(sessionId, "auto");
@@ -1470,6 +1597,9 @@ export class ConsolePiRuntime {
             // the latest resource-preferences.json written by PATCH.
             await this.refreshSkillPrefsCache().catch(() => undefined);
             await session.reload();
+            const services = this.serviceScopes.get(sessionId);
+            if (services)
+                this.applySessionCompactionOverride(sessionId, services, session);
         }
         catch (error) {
             return {
@@ -2076,6 +2206,7 @@ export class ConsolePiRuntime {
         });
         await bindSessionExtensions(session);
         pinOperatorChatTools(session);
+        this.applySessionCompactionOverride(init.sessionId, services, session);
         return {
             session,
             modelRuntime,
@@ -2117,6 +2248,12 @@ export class ConsolePiRuntime {
                 session?.hasPendingBashMessages === true,
         };
     }
+    /** Low-cardinality context-pressure counters; never includes payload text. */
+    getContextPressureTelemetry(sessionId) {
+        const counters = this.compactionControllers.get(sessionId)?.counters ??
+            this.siftStates.get(sessionId)?.counters;
+        return projectSafeTelemetry(counters ?? emptyContextPressureCounters());
+    }
     /**
      * Send a prompt and stream events. Gate 3: each tool invocation is
      * re-authorized by authorizeOperatorChatTool before the dispatcher runs it
@@ -2212,6 +2349,7 @@ export class ConsolePiRuntime {
                 }
             };
             emitContextUsage();
+            await this.runPrePromptCompaction(sessionId, session, text, options?.images?.length ?? 0, onEvent);
             let stepStartedAt;
             let firstTokenAt;
             let pendingProviderError;
@@ -2461,6 +2599,7 @@ export class ConsolePiRuntime {
             throw new Error("CHAT_TURN_ACTIVE");
         if (typeof session.compact !== "function")
             throw new Error("COMPACTION_UNSUPPORTED");
+        incrementPressureCounter(this.getCompactionController(sessionId).counters, "manual");
         const result = await session.compact(customInstructions);
         return projectCompactSnapshot(result ?? {});
     }
@@ -2468,6 +2607,8 @@ export class ConsolePiRuntime {
         // Mark disposed first so a late materialization never registers ready.
         this.disposedSessions.add(sessionId);
         this.sessionInit.delete(sessionId);
+        this.compactionControllers.delete(sessionId);
+        this.siftStates.delete(sessionId);
         const session = this.sessions.get(sessionId);
         if (session) {
             try {

package/dist/worker/console/chat/provider-error.js

@@ -1,3 +1,4 @@
+import { isContextOverflow } from "../../../shared/pi-context-pressure/overflow.js";
 const MAX_RAW_CHARS = 8_000;
 const MAX_MESSAGE_CHARS = 1_000;
 function asRecord(value) {
@@ -52,7 +53,7 @@ function classify(input) {
         status === 403 ||
         /认证|鉴权|unauthori[sz]ed|forbidden|authentication|invalid api[-_ ]?key/.test(haystack))
         return "authentication";
-    if (/请求上下文过大|上下文.{0,12}(?:过大|太大|过长|超限)|context_length_exceeded|maximum context|context.{0,24}(?:length|window|limit|large|long)|too many tokens/.test(haystack))
+    if (isContextOverflow(`${input.message}\n${input.raw}`))
         return "context-overflow";
     if (status === 429 ||
         /rate.?limit|too many requests|请求.{0,8}(?:频繁|过多)|限流/.test(haystack))

package/dist/worker/console/chat/routes.js

@@ -759,6 +759,9 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
+        contextPressure: typeof deps.runtime.getContextPressureTelemetry === "function"
+            ? deps.runtime.getContextPressureTelemetry(sessionId)
+            : undefined,
         compactions: snapshot
             .filter((event) => event.kind === "compact" ||
             event.kind === "compaction_start" ||

package/dist/worker/console/chat/sift-bridge.js

@@ -0,0 +1 @@
+export { createSiftBridgeState, parseSiftBridgeConfig, compressProviderPayload, executeSiftRetrieve, housekeepSiftStash, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, SIFT_POLICY_VERSION, } from "../../../shared/pi-context-pressure/sift-bridge.js";