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

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/shared/preview.js

@@ -1,10 +1,34 @@
 const ENCODER = new TextEncoder();
 const DECODER = new TextDecoder();
+export function redactSecretsWithFindings(text) {
+    let findingCount = 0;
+    const replaceChanged = (match, replacement) => {
+        if (match !== replacement)
+            findingCount += 1;
+        return replacement;
+    };
+    let redacted = text.replace(/(["']?(?:api[_-]?key|token|password|secret|authorization)["']?\s*[:=]\s*["']?)((?:Bearer\s+)?[^"'\s,}]+)/gi, (match, prefix) => replaceChanged(match, `${prefix}***`));
+    redacted = redacted.replace(/(\b[A-Z][A-Z0-9_]*=)[^\s]+/g, (match, prefix) => replaceChanged(match, `${prefix}***`));
+    redacted = redacted.replace(/\bBearer\s+[^\s"']+/gi, (match) => replaceChanged(match, "Bearer ***"));
+    // High-confidence provider-style tokens (OpenAI sk-, GitHub ghp_/gho_,
+    // Slack xox*, AWS AKIA) are credential-like even without a key=value
+    // prefix (exec-plan 2026-08-25 D4: credential-like 默认阻断).
+    redacted = redacted.replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pos]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\b/g, (match) => replaceChanged(match, "***"));
+    return { redacted, findingCount };
+}
+export function redactSensitivePathsWithFindings(text) {
+    let findingCount = 0;
+    const replaceHome = (match) => {
+        if (match !== "<redacted-home>")
+            findingCount += 1;
+        return "<redacted-home>";
+    };
+    let redacted = text.replace(/\/(?:Users|home)\/[^/\s"'\\]+/g, replaceHome);
+    redacted = redacted.replace(/\b[A-Za-z]:\\Users\\[^\\/\s"']+/gi, replaceHome);
+    return { redacted, findingCount };
+}
 export function redactSecrets(text) {
-    return text
-        .replace(/\bBearer\s+[^\s"']+/gi, "Bearer ***")
-        .replace(/(\b[A-Z][A-Z0-9_]*=)[^\s]+/g, "$1***")
-        .replace(/(["']?(?:api[_-]?key|token|password|secret|authorization)["']?\s*[:=]\s*["']?)([^"'\s,}]+)/gi, "$1***");
+    return redactSecretsWithFindings(text).redacted;
 }
 export function truncateUtf8Preview(text, maxBytes = 4096) {
     if (maxBytes <= 0)

package/dist/task/config-types.js

@@ -14,6 +14,7 @@ export const taskKindSchema = z.enum([
     "frontend-implementation",
     "frontend-test",
     "backend-test",
+    "backend-test-analysis",
     "knowledge-sync",
     "knowledge-graph-bootstrap",
 ]);
@@ -163,7 +164,7 @@ const taskConfigObjectSchema = z.object({
     taskId: z.string(),
     title: z.string(),
     sourceFiles: z.array(z.string()),
-    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
+    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；frontend-test: 前端浏览器测试 DAG；backend-test-analysis: 只读后端测试分析 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
     taskKind: taskKindSchema.optional().default("standard"),
     /** true = taskKind 由人类显式选择（含显式 standard）；DAG 路由必须尊重，不做语义改写。 */
     taskKindExplicit: z.boolean().optional(),

package/dist/task/task-demand-routing.js

@@ -76,6 +76,7 @@ const SPECIAL_TEMPLATE_BY_TASK_KIND = {
     "frontend-implementation": "frontend-implementation",
     "frontend-test": "frontend-test-dag",
     "backend-test": "backend-test-dag",
+    "backend-test-analysis": "backend-test-analysis-dag",
     "knowledge-sync": "knowledge-sync-dag",
     "knowledge-graph-bootstrap": "knowledge-graph-bootstrap-dag",
 };
@@ -83,6 +84,7 @@ const TASK_KIND_ROUTING_REASON = {
     "frontend-implementation": 'taskKind "frontend-implementation" selects the dedicated frontend DAG template',
     "frontend-test": 'taskKind "frontend-test" selects the dedicated frontend test DAG template',
     "backend-test": 'taskKind "backend-test" selects the dedicated backend test DAG template',
+    "backend-test-analysis": 'taskKind "backend-test-analysis" selects the read-only backend test analysis DAG template',
     "knowledge-sync": 'taskKind "knowledge-sync" selects the dedicated knowledge-sync DAG template',
     "knowledge-graph-bootstrap": 'taskKind "knowledge-graph-bootstrap" selects the dedicated knowledge-graph bootstrap DAG template',
 };
@@ -90,6 +92,7 @@ const SPECIAL_REQUESTED_TEMPLATES = new Set([
     "frontend-implementation",
     "frontend-test-dag",
     "backend-test-dag",
+    "backend-test-analysis-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",
 ]);

package/dist/worker/console/chat/assistant-content.js

@@ -98,6 +98,13 @@ function isFinalAnswerBlock(block) {
 }
 export function splitFinalAssistantBlocks(blocks, options = {}) {
     const displayable = getDisplayableAssistantBlocks(blocks, options);
+    // A streaming Pi message is cumulative: a later update may append a toolCall
+    // after text that is already visible. Keep the whole live message in the
+    // chronological process subtree so that update appends the tool in place
+    // instead of reparenting the earlier text from answer -> process.
+    if (options.isStreaming) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     let lastProcessIndex = -1;
     for (let i = displayable.length - 1; i >= 0; i--) {
         if (!isFinalAnswerBlock(displayable[i])) {