@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-next.1

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

@@ -0,0 +1,7 @@
+export { isContextOverflow, CONTEXT_OVERFLOW_PHRASES, OVERFLOW_FIXTURES, NORMALIZED_OVERFLOW_PREFIX, shouldRewriteAssistantOverflow, normalizeOverflowErrorMessage, buildGeneratedOverflowClassifierSource, } from "./overflow.js";
+export { parseCompactionPolicy, deriveEffectiveWindow, conservativeTokenEstimate, projectPromptPressure, applyProcessCompactionOverride, inMemoryCompactionSettings, PI_DEFAULT_RESERVE_TOKENS, DEFAULT_KEEP_RECENT_TOKENS, } from "./compaction-policy.js";
+export { buildOverflowCheckpoint } from "./checkpoint.js";
+export { createContextPressureExtension, createCompactionController, } from "./extension.js";
+export { createSiftBridgeState, parseSiftBridgeConfig, compressProviderPayload, executeSiftRetrieve, housekeepSiftStash, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, SIFT_POLICY_VERSION, } from "./sift-bridge.js";
+export { isConsoleSiftEnabled, isDagSiftEnabled, readContextPressureMode, parseEnabledFlag, parseContextPressureMode, } from "./env.js";
+export { emptyContextPressureCounters, projectSafeTelemetry, } from "./telemetry.js";

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

@@ -0,0 +1,252 @@
+/**
+ * Unique overflow classifier for Console UI, SDK extensions, and generated
+ * client-recovery plugins. Phrase match wins; type/code never classify alone.
+ */
+export const CONTEXT_OVERFLOW_PHRASES = [
+    "请求上下文过大",
+    "上下文过大",
+    "上下文太大",
+    "上下文过长",
+    "上下文超限",
+    "context_length_exceeded",
+    "context overflow",
+    "context length overflow",
+    "too many tokens",
+    "maximum context",
+    "prompt is too long",
+    "prompt too long",
+    "request_too_large",
+    "reduce the length of the messages",
+    "context window",
+];
+const OVERFLOW_PATTERN = new RegExp(CONTEXT_OVERFLOW_PHRASES.map(escapeRegExpLiteral).join("|"), "i");
+const AUTH_STATUS = new Set([401, 403]);
+export const OVERFLOW_FIXTURES = {
+    positives: {
+        P1: `{"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P2: `data:{"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P3: `400 {"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P4: "请求上下文过大",
+        P5: "请求上下文过大 (BadRequestError 400)",
+        P6: "LLMRequestError: 请求上下文过大 (BadRequestError 400)",
+        P7: "LLM upstream returned an error payload in a 200 stream: 请求上下文过大 (BadRequestError 400)",
+        P8: "LLM upstream returned HTTP 400: 请求上下文过大",
+        P9: `{"object":"error","type":"BadRequestError","code":"200","message":"{\\"object\\":\\"error\\",\\"code\\":400,\\"type\\":\\"BadRequestError\\",\\"param\\":null,\\"message\\":\\"请求上下文过大\\"}"}`,
+        P10: {
+            stopReason: "error",
+            errorMessage: "请求上下文过大 (BadRequestError 400)",
+            errorCode: "stream_payload_error",
+            providerType: "BadRequestError",
+            providerCode: "400",
+        },
+        // P11/P12: 2026-08-27 真实企业网关捕获（openai-completions / wizard-local /
+        // aicoder-plus）。HTTP 状态行 + 换行 + `data:` SSE 前缀 + JSON + 尾部空行
+        // 同串组合；完整事件样本见 exec-plan §1.1 附录 A。
+        P11: "400\n data:{\"object\":\"error\",\"message\":\"请求上下文过大\",\"type\":\"BadRequestError\",\"code\":400}\n\n",
+        P12: {
+            message: {
+                role: "assistant",
+                content: [],
+                api: "openai-completions",
+                provider: "wizard-local",
+                model: "aicoder-plus",
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                stopReason: "error",
+                errorMessage: "400\n data:{\"object\":\"error\",\"message\":\"请求上下文过大\",\"type\":\"BadRequestError\",\"code\":400}\n\n",
+            },
+        },
+    },
+    negatives: {
+        N1: `{"object":"error","message":"认证错误!","type":"BadRequestError","code":401}`,
+        N2: "当前请求超时, 请重试 (BadRequestError 502)",
+        N2b: "LLMRequestError: 当前请求超时, 请重试 (BadRequestError 502)",
+        N3: "The requested resource was not found. (BadRequestError 404)",
+        N3b: "The requested resource was not found. (NotFoundError 404)",
+        N4: "LLMRequestError: (BadRequestError 400)",
+        N5: `{"object":"error","type":"BadRequestError","code":"200","message":"{\\"object\\":\\"error\\",\\"code\\":502,\\"type\\":\\"BadRequestError\\",\\"message\\":\\"当前请求超时, 请重试\\"}"}`,
+    },
+};
+export const NORMALIZED_OVERFLOW_PREFIX = "context_length_exceeded:";
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function asText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value == null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function tryParseJson(text) {
+    const trimmed = text.trim();
+    const candidates = [trimmed];
+    const dataPrefix = trimmed.match(/^data:\s*(\{[\s\S]*)$/i);
+    if (dataPrefix)
+        candidates.push(dataPrefix[1] ?? "");
+    const statusPrefix = trimmed.match(/^\d{3}\s+(\{[\s\S]*)$/);
+    if (statusPrefix)
+        candidates.push(statusPrefix[1] ?? "");
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start)
+        candidates.push(trimmed.slice(start, end + 1));
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Keep scanning other envelopes.
+        }
+    }
+    return undefined;
+}
+function collectStringFields(value, depth, out) {
+    if (depth > 6 || value == null)
+        return;
+    if (typeof value === "string") {
+        if (value)
+            out.push(value);
+        const nested = tryParseJson(value);
+        if (nested !== undefined && nested !== value) {
+            collectStringFields(nested, depth + 1, out);
+        }
+        return;
+    }
+    if (typeof value !== "object")
+        return;
+    const record = value;
+    for (const key of ["message", "errorMessage", "error"]) {
+        if (key in record)
+            collectStringFields(record[key], depth + 1, out);
+    }
+}
+function extractStatus(text) {
+    const suffix = text.match(/\((?:BadRequestError|NotFoundError|AuthenticationError|RateLimitError)\s+(\d{3})\)/i);
+    if (suffix)
+        return Number(suffix[1]);
+    const http = text.match(/\bHTTP\s+(\d{3})\b/i);
+    if (http)
+        return Number(http[1]);
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+        const record = parsed;
+        const code = record.code ?? record.status ?? record.statusCode;
+        if (typeof code === "number" && Number.isFinite(code))
+            return code;
+        if (typeof code === "string" && /^\d{3}$/.test(code.trim())) {
+            return Number(code.trim());
+        }
+    }
+    return undefined;
+}
+export function collectOverflowHaystack(error) {
+    if (typeof error === "string")
+        return error;
+    if (!error || typeof error !== "object")
+        return asText(error);
+    const record = error;
+    const parts = [
+        asText(record.message),
+        asText(record.errorMessage),
+        asText(record.error),
+        asText(record.name),
+        asText(record.status),
+        asText(record.code),
+        asText(record.data),
+    ];
+    return parts.filter(Boolean).join("\n");
+}
+export function isContextOverflow(error) {
+    const haystack = collectOverflowHaystack(error);
+    const fields = [haystack];
+    collectStringFields(error, 0, fields);
+    collectStringFields(tryParseJson(haystack), 0, fields);
+    const combined = fields.join("\n");
+    if (!OVERFLOW_PATTERN.test(combined))
+        return false;
+    const status = extractStatus(combined);
+    if (status !== undefined && AUTH_STATUS.has(status))
+        return false;
+    return true;
+}
+export function normalizeOverflowErrorMessage(current) {
+    if (!current)
+        return undefined;
+    if (current.startsWith(NORMALIZED_OVERFLOW_PREFIX) ||
+        /context_length_exceeded/i.test(current)) {
+        return undefined;
+    }
+    if (!isContextOverflow(current))
+        return undefined;
+    const bounded = current.length <= 1500 ? current : `${current.slice(0, 1499)}…`;
+    return `${NORMALIZED_OVERFLOW_PREFIX} ${bounded}`;
+}
+export function shouldRewriteAssistantOverflow(message) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    const record = message;
+    if (record.role !== "assistant")
+        return undefined;
+    if (record.stopReason !== undefined && record.stopReason !== "error") {
+        return undefined;
+    }
+    const current = typeof record.errorMessage === "string" ? record.errorMessage : "";
+    if (!current)
+        return undefined;
+    return normalizeOverflowErrorMessage(current);
+}
+export function buildGeneratedOverflowClassifierSource() {
+    return `const CONTEXT_OVERFLOW_PHRASES = ${JSON.stringify([
+        ...CONTEXT_OVERFLOW_PHRASES,
+    ])};
+const OVERFLOW_PATTERN = new RegExp(
+  CONTEXT_OVERFLOW_PHRASES.map((phrase) =>
+    phrase.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&"),
+  ).join("|"),
+  "i",
+);
+function tryParseJson(text) {
+  if (typeof text !== "string") return undefined;
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  const dataPrefix = trimmed.match(/^data:\\s*(\\{[\\s\\S]*)$/i);
+  if (dataPrefix) candidates.push(dataPrefix[1]);
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) candidates.push(trimmed.slice(start, end + 1));
+  for (const candidate of candidates) {
+    try { return JSON.parse(candidate); } catch {}
+  }
+  return undefined;
+}
+function collectFields(value, depth, out) {
+  if (depth > 6 || value == null) return;
+  if (typeof value === "string") {
+    if (value) out.push(value);
+    const nested = tryParseJson(value);
+    if (nested !== undefined && nested !== value) collectFields(nested, depth + 1, out);
+    return;
+  }
+  if (typeof value !== "object") return;
+  if (typeof value.message === "string") collectFields(value.message, depth + 1, out);
+  if (typeof value.errorMessage === "string") collectFields(value.errorMessage, depth + 1, out);
+  if (value.error) collectFields(value.error, depth + 1, out);
+}
+function isOverflowMessage(text) {
+  if (typeof text !== "string" || !text) return false;
+  const fields = [text];
+  collectFields(text, 0, fields);
+  collectFields(tryParseJson(text), 0, fields);
+  const combined = fields.join("\\n");
+  if (!OVERFLOW_PATTERN.test(combined)) return false;
+  if (/\\((?:BadRequestError|AuthenticationError)\\s+40[13]\\)/i.test(combined)) return false;
+  return true;
+}`;
+}

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,
+    };
+}