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

package/CHANGELOG.md

@@ -2,12 +2,18 @@
 
 ## [Unreleased]
 
+- 修复 Console 轨迹视图引用未声明 CSS 自定义属性导致仓库发布门禁失败的问题，补齐品牌色、警告色与字体别名并保持现有视觉回退值。
+
 ### 重点更新
 
+- Console 对话页「轨迹」视图响应式优化：轨迹列宽跟随面板实际宽度收缩（`.oc-trajectory` 加 `width:100%`、`.oc-trajectory-turn/.step` 加 `min-width:0` 修 flex 收缩链），窄窗口（≤720px）自动隐藏耗时列，避免工具行被固定项挤爆。
+- Console 对话页新增「轨迹」视图（详情侧栏 tab）：仿 DSH ui-trajectory，用本仓库 turnGroups 数据把对话按「用户 → 过程 → AI 回复」渲染成统一单元格列表，每行带 kind 标签 + 图标（用户/ AI / 思考 / 工具 / 活动 / 错误 / 压缩）；用户与 AI 用标签颜色 + 图标区分，AI 中间文本也标注；思考、工具、以及超长用户/AI 消息默认单行截断、可展开/收起看全文（含工具参数与结果、状态与耗时）。支持一键「导出 HTML」自包含文件（长内容用 `<details>` 折叠，短内容内联）。主会话思考块标签由英文 Think 改为「思考」。
+- DAG 检查器节点「执行过程」的「导出 HTML」改为复用页面真实渲染与样式，导出的独立 HTML 排版与页面一致；Pi 会话节点导出会带上原始协议事件，左上角提供「展开/隐藏原始协议事件」按钮（默认隐藏，每项仍可单独展开），shell/静态节点导出同样与页面一致。
 - backend-test 的 pytest repair 现在继续使用 run-owned plan，不再搜索测试目录 README；correspondence finding 会直接指向 docstring、参数 ID、符号、脚本或 payload 的修复位置，collection/scenario repair 与 generated-local Python 写边界保持一致，并在单次 Pi 会话达到 24 轮或 80K 最大 usage snapshot 前受控返回 partial failure。
 - Operator Chat 现在可以在同一个页面管理多个工作区；每个会话始终使用创建它的工作区，切换对话时地址栏保持简洁稳定。
 - 对话消息流整体调整为更紧凑、清晰的布局，思考过程、工具执行、阶段性结果和最终回答会按真实发生顺序展示。
 - 上下文过大时会自动压缩并继续原请求，消息流会依次展示触发原因、压缩进度和压缩结果；手动压缩也使用同一套展示方式。
+- Operator Chat 与 DAG Pi 节点默认开启上下文压力处理：发送前接近窗口时压缩一次、识别网关「请求上下文过大」后压缩续跑，并对 OpenAI 格式的大工具输出做线路压缩；可用环境变量关闭，不必改会话记录。
 - 对话进行中可以连续提交多条消息，并支持编辑、删除或立即插入当前回复；刷新页面或重启 Console 后，未发送内容仍会保留。
 
 ### 新增
@@ -18,6 +24,9 @@
 
 ### 改进
 
+- Operator Chat 发送前会在接近模型窗口时主动压缩，压缩失败仍发送当前输入，不会把消息丢掉。DAG 节点同步启用 overflow 识别与线路压缩，但不在 streaming 中主动 compact。
+- 网关「请求上下文过大」及常见包装/嵌套 JSON 由共享分类器识别；目标项目 `loop-agent init` 生成的 Pi overflow extension 与控制器使用同一套短语表。
+- `@agent-context/sift@0.0.1-alpha.6` 作为可选依赖接入 Console 与 DAG：默认开启，`HARNESS_CONSOLE_SIFT` / `HARNESS_DAG_SIFT` 设为 `0`、`false` 或 `off` 即可关闭。Anthropic 缺省 prompt cache 形态保持 no-op，避免破坏缓存。
 - 后端测试的计划与生成阶段只读取任务明确绑定的需求、环境报告和本轮产物，减少无关仓库内容干扰结果，并让后续步骤继续使用同一份已确认计划。
 - Operator Chat 的任务清单工具描述补齐多步骤与 DAG 使用纪律：开始前按具体步骤规划、保持进行中约束、完成后立即更新完整列表，并用面向用户的阶段呈现 DAG 进度，简单任务自动跳过。
 - 正式发布会自动同步更新版本日志和文档站摘要；发布说明优先生成简洁自然的中文，生成服务不可用时也能安全完成发布。
@@ -28,6 +37,7 @@
 
 ### 修复
 
+- 修复 backend-test 的 Scenario Partition 计划表只提示 `each-value`/`omitted`、却由下游确定性门禁强制要求 `not-in-set` 的合同漂移；计划、Markdown Case 与 pytest 现在统一明确唯一补集槽位，避免 PI 因表格指令遗漏 `TP-<Partition ID>-NOT-IN-SET` 后触发 `MISSING_COMPLEMENT_SLOT`。
 - 修复文档审计扫描本地 `.scratch/` 临时证据与打包目录、导致仓库 preflight 和发布前验证被非治理文件阻断的问题。
 - 修复 backend-test 把 Markdown 明确声明的 enum-invalid、wrong-type、null、empty 和精确非法 custom literal 当作 payload enum 契约漂移、错误消耗唯一一次 pytest repair 的问题；豁免现在按 pytest parameter ID、目标字段和值逐 TP 绑定，positive/nominal drift 与 path 缺陷仍严格阻断。
 - 修复 backend-test 无法从同一生成模块的安全 payload helper 中绑定 field-target positional/keyword/default 参数，以及无法识别精确 `_without(payload, field)` 删除语义的问题；computed、动态、二层、跨模块和危险 helper 仍保持 `UNDETERMINED`。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.40.0-next.11",
-  "gitSha": "a23cf8d31616835f9fa670d7135ee4a5bd84feba",
-  "builtAt": "2026-08-28T16:52:35.690Z"
+  "version": "0.40.0-next.12",
+  "gitSha": "41c2688fb25e22404d7dd6f9a7c884a2e638d500",
+  "builtAt": "2026-08-29T08:53:25.216Z"
 }

package/dist/commands/client-recovery.js

@@ -19,36 +19,11 @@ export const MAX_SESSION_RETRIES = 5;
 /** Hard cap for OpenCode overflow compact+resume recoveries (≤ 2). */
 export const MAX_OVERFLOW_RECOVERIES = 1;
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+import { CONTEXT_OVERFLOW_PHRASES, buildGeneratedOverflowClassifierSource, isContextOverflow as classifySharedOverflow, } from "../shared/pi-context-pressure/overflow.js";
 export { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY };
-/**
- * Shared overflow phrase sources used by isContextOverflow and generated plugins.
- * Keep English + Chinese intranet gateway messages in one place to avoid drift.
- */
-export const CONTEXT_OVERFLOW_PHRASES = [
-    "请求上下文过大",
-    "context_length_exceeded",
-    "context overflow",
-    "context length overflow",
-    "too many tokens",
-    "maximum context",
-    "prompt is too long",
-    "request_too_large",
-    "context window",
-];
-function escapeRegExpLiteral(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-const CONTEXT_OVERFLOW_PATTERN = new RegExp(CONTEXT_OVERFLOW_PHRASES.map(escapeRegExpLiteral).join("|"), "i");
+export { CONTEXT_OVERFLOW_PHRASES };
 function buildGeneratedContextOverflowPatternSource() {
-    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",
-);`;
+    return buildGeneratedOverflowClassifierSource();
 }
 const PERMANENT_MESSAGE_PATTERNS = [
     {
@@ -65,7 +40,7 @@ const PERMANENT_MESSAGE_PATTERNS = [
     },
     {
         reason: "context-overflow",
-        pattern: CONTEXT_OVERFLOW_PATTERN,
+        pattern: /context_length_exceeded|请求上下文过大/i,
     },
     {
         reason: "cancelled",
@@ -180,6 +155,8 @@ function permanentReason(error) {
         return "api-error";
     }
     const text = collectErrorText(error);
+    if (isContextOverflow(error))
+        return "context-overflow";
     for (const entry of PERMANENT_MESSAGE_PATTERNS) {
         if (entry.pattern.test(text))
             return entry.reason;
@@ -192,7 +169,7 @@ function permanentReason(error) {
  * business validation, or standard 502/LLMRequestError as overflow.
  */
 export function isContextOverflow(error) {
-    return CONTEXT_OVERFLOW_PATTERN.test(collectErrorText(error));
+    return classifySharedOverflow(error);
 }
 function looksTransient(error) {
     const text = collectErrorText(error);
@@ -887,7 +864,7 @@ function textOf(error) {
 }
 
 function isContextOverflow(error) {
-  return OVERFLOW_PATTERN.test(textOf(error));
+  return isOverflowMessage(textOf(error));
 }
 
 function buildOverflowResumePrompt(sessionId, error, attempt) {
@@ -1163,11 +1140,6 @@ const EXTENSION_PATH = ${JSON.stringify(PI_CONTEXT_OVERFLOW_EXTENSION_PATH)};
 ${buildGeneratedContextOverflowPatternSource()}
 const NORMALIZED_PREFIX = "context_length_exceeded:";
 
-function isOverflowMessage(text) {
-  if (typeof text !== "string" || !text) return false;
-  return OVERFLOW_PATTERN.test(text);
-}
-
 export default function loopAgentContextOverflowExtension(pi) {
   void EXTENSION_PATH;
   pi.on("message_end", (event) => {

package/dist/executors/pi-sdk-executor.js

@@ -1,9 +1,12 @@
 import { appendFile, mkdir } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { computeExtensionToolAllowlistExtras } from "./pi-extension-resolver.js";
 import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
 /** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
 export const PI_SDK_STALL_CONTINUE_MAX = 1;
 /**
@@ -215,15 +218,37 @@ async function createSdkSession(sdk, input, shared) {
     // Inject rate-limit-tolerant auto-retry settings for the session lifecycle.
     // Prefer SettingsManager.inMemory so harness runs do not depend on ~/.pi or
     // project .pi/settings.json being present/trusted.
+    const policy = parseCompactionPolicy();
+    const compaction = {
+        ...PI_RECOMMENDED_COMPACTION,
+        ...inMemoryCompactionSettings(policy),
+    };
     const settingsManager = typeof SettingsManager?.inMemory === "function"
         ? SettingsManager.inMemory({
             retry: {
                 ...PI_RECOMMENDED_RETRY,
                 provider: { ...PI_RECOMMENDED_RETRY.provider },
             },
-            compaction: { ...PI_RECOMMENDED_COMPACTION },
+            compaction,
         }, { projectTrusted: true })
         : undefined;
+    const nodeSessionId = `dag-${randomUUID()}`;
+    const controller = createCompactionController();
+    const siftEnabled = isDagSiftEnabled();
+    const sift = siftEnabled.enabled
+        ? createSiftBridgeState(parseSiftBridgeConfig({
+            sessionId: nodeSessionId,
+            defaultStashRoot: path.join(os.tmpdir(), "loop-agent-dag-sift"),
+        }))
+        : undefined;
+    if (sift)
+        sift.counters = controller.counters;
+    const pressureExtension = createContextPressureExtension({
+        name: "dag-pi-context-pressure",
+        policy,
+        controller,
+        sift,
+    });
     const loader = new DefaultResourceLoader({
         cwd: input.cwd,
         agentDir,
@@ -233,6 +258,7 @@ async function createSdkSession(sdk, input, shared) {
         ...(input.additionalExtensionPaths && input.additionalExtensionPaths.length > 0
             ? { additionalExtensionPaths: input.additionalExtensionPaths }
             : {}),
+        ...(pressureExtension ? { extensionFactories: [pressureExtension] } : {}),
         ...(settingsManager ? { settingsManager } : {}),
         appendSystemPromptOverride: (base) => [
             ...base,
@@ -247,10 +273,12 @@ async function createSdkSession(sdk, input, shared) {
     // extras into the create-time allowlist; protected builtins, the deny
     // surface, and write-capable extension tools never join.
     const extensionToolExtras = [];
-    if (input.additionalExtensionPaths &&
-        input.additionalExtensionPaths.length > 0) {
-        const registered = collectLoaderExtensionToolNames(loader);
-        extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    const registered = collectLoaderExtensionToolNames(loader);
+    extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    if (siftEnabled.enabled &&
+        !extensionToolExtras.includes(SIFT_RETRIEVE_TOOL_NAME) &&
+        !input.toolNames.includes(SIFT_RETRIEVE_TOOL_NAME)) {
+        extensionToolExtras.push(...computeExtensionToolAllowlistExtras([{ name: SIFT_RETRIEVE_TOOL_NAME }], input.toolNames));
     }
     const sessionToolNames = [...input.toolNames, ...extensionToolExtras];
     if (input.requireWriterCustomTools) {

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

@@ -0,0 +1,116 @@
+const CHECKPOINT_MAX_BYTES = 12 * 1024;
+function boundText(value, maxChars) {
+    if (typeof value !== "string" || !value.trim())
+        return "";
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars - 1)}…`;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function extractLastUserGoal(messages) {
+    if (!Array.isArray(messages))
+        return "";
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = asRecord(messages[index]);
+        if (!message || message.role !== "user")
+            continue;
+        const content = message.content;
+        if (typeof content === "string")
+            return boundText(content, 800);
+        if (Array.isArray(content)) {
+            const texts = content
+                .map((block) => {
+                const rec = asRecord(block);
+                return typeof rec?.text === "string" ? rec.text : "";
+            })
+                .filter(Boolean);
+            if (texts.length > 0)
+                return boundText(texts.join("\n"), 800);
+        }
+    }
+    return "";
+}
+function extractTodos(details) {
+    const record = asRecord(details);
+    const todos = record?.todos ?? record?.items;
+    if (!Array.isArray(todos))
+        return "";
+    const lines = todos
+        .slice(0, 24)
+        .map((item) => {
+        const rec = asRecord(item);
+        const status = typeof rec?.status === "string" ? rec.status : "pending";
+        const content = typeof rec?.content === "string"
+            ? rec.content
+            : typeof rec?.title === "string"
+                ? rec.title
+                : "";
+        return content ? `- [${status}] ${content}` : "";
+    })
+        .filter(Boolean);
+    return boundText(lines.join("\n"), 1200);
+}
+function extractFileOps(fileOps) {
+    const record = asRecord(fileOps);
+    if (!record)
+        return "";
+    const parts = [];
+    for (const key of ["edited", "written", "read", "deleted", "ops"]) {
+        const value = record[key];
+        if (Array.isArray(value)) {
+            parts.push(`${key}: ${value
+                .slice(0, 20)
+                .map((item) => (typeof item === "string" ? item : JSON.stringify(item)))
+                .join(", ")}`);
+        }
+        else if (typeof value === "string" && value) {
+            parts.push(`${key}: ${value}`);
+        }
+    }
+    if (parts.length === 0) {
+        try {
+            return boundText(JSON.stringify(fileOps), 800);
+        }
+        catch {
+            return "";
+        }
+    }
+    return boundText(parts.join("\n"), 800);
+}
+export function buildOverflowCheckpoint(input) {
+    const preparation = input.preparation;
+    const firstKeptEntryId = typeof preparation?.firstKeptEntryId === "string" &&
+        preparation.firstKeptEntryId
+        ? preparation.firstKeptEntryId
+        : undefined;
+    const tokensBefore = typeof preparation?.tokensBefore === "number" &&
+        Number.isFinite(preparation.tokensBefore)
+        ? preparation.tokensBefore
+        : undefined;
+    if (!firstKeptEntryId || tokensBefore === undefined)
+        return undefined;
+    const sections = [
+        "Deterministic overflow checkpoint (no extra summary request).",
+        boundText(preparation?.previousSummary, 2000)
+            ? `Previous summary:\n${boundText(preparation?.previousSummary, 2000)}`
+            : "",
+        extractLastUserGoal(preparation?.messagesToSummarize)
+            ? `Latest user goal:\n${extractLastUserGoal(preparation?.messagesToSummarize)}`
+            : "",
+        extractTodos(input.todos) ? `Open todos:\n${extractTodos(input.todos)}` : "",
+        extractFileOps(preparation?.fileOps)
+            ? `File ops:\n${extractFileOps(preparation?.fileOps)}`
+            : "",
+        typeof input.lastError === "string" && input.lastError
+            ? `Latest error:\n${boundText(input.lastError, 400)}`
+            : "",
+        "Next step: continue the interrupted turn from the kept recent messages. Do not repeat completed file writes.",
+    ].filter(Boolean);
+    let summary = sections.join("\n\n");
+    if (Buffer.byteLength(summary, "utf8") > CHECKPOINT_MAX_BYTES) {
+        summary = `${summary.slice(0, CHECKPOINT_MAX_BYTES - 1)}…`;
+    }
+    return { summary, firstKeptEntryId, tokensBefore };
+}

package/dist/shared/pi-context-pressure/compaction-policy.js

@@ -0,0 +1,151 @@
+import { parseBoundedNumber, readContextPressureMode, } from "./env.js";
+export const PI_DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_TRAILING_BUDGET_TOKENS = 8_192;
+export const DEFAULT_SAFETY_MARGIN_TOKENS = 4_096;
+export const DEFAULT_MINIMUM_WORKING_SET = 32_768;
+export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
+export function parseCompactionPolicy(env = process.env) {
+    const diagnostics = [];
+    const modeResult = readContextPressureMode(env);
+    if (modeResult.diagnostic)
+        diagnostics.push(modeResult.diagnostic);
+    const k = parseBoundedNumber(env.HARNESS_CONTEXT_GATEWAY_K, 1, 1, 8);
+    if (k.diagnostic)
+        diagnostics.push(k.diagnostic);
+    const trailing = parseBoundedNumber(env.HARNESS_CONTEXT_TRAILING_BUDGET_TOKENS, DEFAULT_TRAILING_BUDGET_TOKENS, 256, 128_000);
+    if (trailing.diagnostic)
+        diagnostics.push(trailing.diagnostic);
+    const safety = parseBoundedNumber(env.HARNESS_CONTEXT_SAFETY_MARGIN_TOKENS, DEFAULT_SAFETY_MARGIN_TOKENS, 0, 64_000);
+    if (safety.diagnostic)
+        diagnostics.push(safety.diagnostic);
+    const explicit = env.HARNESS_COMPACTION_RESERVE_TOKENS;
+    const explicitReserve = explicit === undefined || explicit.trim() === ""
+        ? undefined
+        : parseBoundedNumber(explicit, PI_DEFAULT_RESERVE_TOKENS, 1_024, 1_000_000);
+    if (explicitReserve?.diagnostic)
+        diagnostics.push(explicitReserve.diagnostic);
+    return {
+        mode: modeResult.mode,
+        k: k.value,
+        trailingBudgetTokens: trailing.value,
+        safetyMarginTokens: safety.value,
+        minimumWorkingSet: DEFAULT_MINIMUM_WORKING_SET,
+        ...(explicitReserve ? { explicitReserveTokens: explicitReserve.value } : {}),
+        diagnostics,
+    };
+}
+export function deriveEffectiveWindow(contextWindow, policy) {
+    const W = Math.floor(contextWindow);
+    if (!Number.isFinite(W) || W <= 0) {
+        return {
+            recommendedReserve: PI_DEFAULT_RESERVE_TOKENS,
+            triggerTokens: 0,
+            fallback: true,
+        };
+    }
+    if (policy.explicitReserveTokens !== undefined) {
+        const recommendedReserve = Math.min(Math.max(policy.explicitReserveTokens, 1), Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: false,
+        };
+    }
+    const rawTrigger = Math.floor(W / policy.k) -
+        policy.trailingBudgetTokens -
+        policy.safetyMarginTokens;
+    const rawReserve = W - rawTrigger;
+    const maxReserve = Math.max(1, W - policy.minimumWorkingSet);
+    if (!Number.isFinite(rawTrigger) ||
+        !Number.isFinite(rawReserve) ||
+        maxReserve < PI_DEFAULT_RESERVE_TOKENS) {
+        const recommendedReserve = Math.min(PI_DEFAULT_RESERVE_TOKENS, Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: true,
+        };
+    }
+    const recommendedReserve = Math.min(Math.max(PI_DEFAULT_RESERVE_TOKENS, rawReserve), maxReserve);
+    return {
+        recommendedReserve,
+        triggerTokens: Math.max(0, W - recommendedReserve),
+        fallback: false,
+    };
+}
+export function conservativeTokenEstimate(text, imageCount = 0) {
+    const chars = Array.from(text);
+    let cjk = 0;
+    let other = 0;
+    for (const char of chars) {
+        if (/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/u.test(char)) {
+            cjk += 1;
+        }
+        else {
+            other += 1;
+        }
+    }
+    const utf8 = Buffer.byteLength(text, "utf8");
+    const fromChars = cjk + Math.ceil(other / 2);
+    const fromBytes = Math.ceil(utf8 / 2);
+    return (Math.max(fromChars, fromBytes, Math.ceil(chars.length / 2)) +
+        Math.max(0, imageCount) * 1024);
+}
+export function projectPromptPressure(input) {
+    if (input.currentContextTokens === null ||
+        input.currentContextTokens === undefined ||
+        !Number.isFinite(input.currentContextTokens)) {
+        return { projected: 0, usageUnavailable: true };
+    }
+    return {
+        projected: Math.max(0, input.currentContextTokens) +
+            conservativeTokenEstimate(input.promptText, input.imageCount ?? 0),
+        usageUnavailable: false,
+    };
+}
+function isExplicitlyDisabled(manager) {
+    const project = manager.getProjectSettings?.()?.compaction?.enabled;
+    const global = manager.getGlobalSettings?.()?.compaction?.enabled;
+    return project === false || (project === undefined && global === false);
+}
+export function applyProcessCompactionOverride(manager, input) {
+    if (!manager?.applyOverrides || input.policy.mode === "off") {
+        return { applied: false };
+    }
+    const explicitOff = input.policy.mode === "safe" && isExplicitlyDisabled(manager);
+    const enabled = input.policy.mode === "strict" ? true : explicitOff ? false : true;
+    const window = typeof input.contextWindow === "number" && input.contextWindow > 0
+        ? deriveEffectiveWindow(input.contextWindow, input.policy)
+        : undefined;
+    const compaction = { enabled };
+    if (window && enabled) {
+        compaction.reserveTokens = window.recommendedReserve;
+        compaction.keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
+    }
+    manager.applyOverrides({ compaction });
+    return {
+        applied: true,
+        enabled,
+        ...(typeof compaction.reserveTokens === "number"
+            ? { reserveTokens: compaction.reserveTokens }
+            : {}),
+        ...(typeof compaction.keepRecentTokens === "number"
+            ? { keepRecentTokens: compaction.keepRecentTokens }
+            : {}),
+        ...(window?.fallback
+            ? { diagnostic: "small-or-invalid-window-fell-back-to-pi-default-reserve" }
+            : {}),
+    };
+}
+export function inMemoryCompactionSettings(policy) {
+    if (policy.mode === "off") {
+        return { enabled: true };
+    }
+    return {
+        enabled: true,
+        keepRecentTokens: DEFAULT_KEEP_RECENT_TOKENS,
+        ...(policy.explicitReserveTokens
+            ? { reserveTokens: policy.explicitReserveTokens }
+            : {}),
+    };
+}

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

@@ -0,0 +1,58 @@
+const TRUTHY = new Set(["1", "true", "on"]);
+const FALSY = new Set(["0", "false", "off"]);
+export function parseEnabledFlag(raw, defaultEnabled) {
+    if (raw === undefined || raw.trim() === "") {
+        return { enabled: defaultEnabled };
+    }
+    const value = raw.trim().toLowerCase();
+    if (TRUTHY.has(value))
+        return { enabled: true };
+    if (FALSY.has(value))
+        return { enabled: false };
+    return {
+        enabled: defaultEnabled,
+        diagnostic: `invalid flag ${JSON.stringify(raw)}; clamped to default ${defaultEnabled}`,
+    };
+}
+export function parseContextPressureMode(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return { mode: "safe" };
+    const value = raw.trim().toLowerCase();
+    if (value === "off" || value === "safe" || value === "strict") {
+        return { mode: value };
+    }
+    return {
+        mode: "safe",
+        diagnostic: `invalid HARNESS_CONTEXT_PRESSURE_MODE ${JSON.stringify(raw)}; clamped to safe`,
+    };
+}
+export function parseBoundedNumber(raw, fallback, min, max) {
+    if (raw === undefined || raw.trim() === "") {
+        return { value: fallback };
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+        return {
+            value: fallback,
+            diagnostic: `invalid number ${JSON.stringify(raw)}; clamped to ${fallback}`,
+        };
+    }
+    const clamped = Math.min(max, Math.max(min, parsed));
+    if (clamped !== parsed) {
+        return {
+            value: clamped,
+            diagnostic: `number ${parsed} clamped to [${min}, ${max}] => ${clamped}`,
+        };
+    }
+    return { value: parsed };
+}
+/** Console/DAG sift: default ON; `0|false|off` disables. */
+export function isConsoleSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_CONSOLE_SIFT, true);
+}
+export function isDagSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_DAG_SIFT, true);
+}
+export function readContextPressureMode(env = process.env) {
+    return parseContextPressureMode(env.HARNESS_CONTEXT_PRESSURE_MODE);
+}

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

@@ -0,0 +1,100 @@
+import { buildOverflowCheckpoint } from "./checkpoint.js";
+import { shouldRewriteAssistantOverflow } from "./overflow.js";
+import { clearRetrieveBypass, compressProviderPayload, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, } from "./sift-bridge.js";
+import { emptyContextPressureCounters, incrementCounter, } from "./telemetry.js";
+export function createCompactionController() {
+    return {
+        proactiveCompaction: false,
+        counters: emptyContextPressureCounters(),
+    };
+}
+export function createContextPressureExtension(options) {
+    const l2 = options.policy.mode !== "off";
+    const l1 = Boolean(options.sift);
+    if (!l2 && !l1)
+        return undefined;
+    return {
+        name: options.name ?? "operator-chat-context-pressure",
+        hidden: true,
+        factory: (api) => {
+            if (l2) {
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (!message || typeof message !== "object")
+                        return undefined;
+                    const rec = message;
+                    if (typeof rec.errorMessage === "string") {
+                        options.controller.lastError = rec.errorMessage;
+                    }
+                    if (rec.role === "assistant") {
+                        clearRetrieveBypassIfPresent(options.sift);
+                    }
+                    const rewritten = shouldRewriteAssistantOverflow(message);
+                    if (!rewritten)
+                        return undefined;
+                    incrementCounter(options.controller.counters, "overflow");
+                    return {
+                        message: {
+                            ...rec,
+                            errorMessage: rewritten,
+                        },
+                    };
+                });
+                api.on("session_before_compact", (event) => {
+                    const reason = event.reason;
+                    if (reason === "overflow") {
+                        incrementCounter(options.controller.counters, "overflow");
+                    }
+                    if (reason === "manual") {
+                        incrementCounter(options.controller.counters, "manual");
+                    }
+                    const useCheckpoint = options.policy.mode === "strict" &&
+                        (reason === "overflow" ||
+                            (reason === "manual" && options.controller.proactiveCompaction));
+                    if (!useCheckpoint)
+                        return undefined;
+                    const checkpoint = buildOverflowCheckpoint({
+                        preparation: event.preparation,
+                        todos: options.controller.todos,
+                        lastError: options.controller.lastError,
+                    });
+                    if (!checkpoint)
+                        return undefined;
+                    return {
+                        compaction: {
+                            summary: checkpoint.summary,
+                            firstKeptEntryId: checkpoint.firstKeptEntryId,
+                            tokensBefore: checkpoint.tokensBefore,
+                        },
+                    };
+                });
+            }
+            if (l1 && options.sift) {
+                const sift = options.sift;
+                api.on("before_provider_request", (event) => {
+                    return compressProviderPayload(sift, event.payload);
+                });
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (message &&
+                        typeof message === "object" &&
+                        message.role === "assistant") {
+                        clearRetrieveBypass(sift);
+                    }
+                    return undefined;
+                });
+                try {
+                    api.registerTool?.(createSiftRetrieveToolDefinition(sift));
+                }
+                catch {
+                    sift.diagnostics.add("register-tool-failed");
+                }
+            }
+        },
+    };
+}
+function clearRetrieveBypassIfPresent(sift) {
+    if (sift)
+        clearRetrieveBypass(sift);
+}
+export { SIFT_RETRIEVE_TOOL_NAME };

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";