@tea-agent/loop-agent 0.39.0-beta.12 → 0.39.0-beta.13

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/task/frontend-project-capability.js

@@ -205,6 +205,7 @@ export async function listOpenspecDiscovery(repoRoot, options = {}) {
     const collected = [];
     let excludedGovernanceCount = 0;
     let scannedFiles = 0;
+    let maxFilesHit = false;
     let scannedBytes = 0;
     const warnings = [];
     const maxDepth = options.maxDepth ?? 4;
@@ -250,7 +251,7 @@ export async function listOpenspecDiscovery(repoRoot, options = {}) {
         .filter((candidate) => !defaultPaths.includes(candidate))
         .sort();
     const deduped = [...defaultPaths, ...customPaths];
-    const truncated = deduped.length > MAX_OPENSPEC_CANDIDATE_PATHS;
+    const truncated = maxFilesHit || deduped.length > MAX_OPENSPEC_CANDIDATE_PATHS;
     const paths = truncated
         ? deduped.slice(0, MAX_OPENSPEC_CANDIDATE_PATHS)
         : deduped;
@@ -289,6 +290,7 @@ export async function listOpenspecDiscovery(repoRoot, options = {}) {
             if (scannedFiles >= maxFiles) {
                 if (!warnings.includes("max-files-exceeded"))
                     warnings.push("max-files-exceeded");
+                maxFilesHit = true;
                 return;
             }
             const full = path.join(dir, name);

package/dist/task/source-prepare/fragment-inventory.js

@@ -175,8 +175,11 @@ export function splitDocumentIntoFragments(doc) {
         const explicitSectionAc = matchExplicitAcHeading(lastHeadingSegment);
         const sectionKind = classifySectionHeading(section.headingPath);
         const effectiveKind = explicitSectionAc ? "acceptance" : sectionKind;
+        // V4 显式 AC 标题行已在下方入口 emit（explicitSectionAc 分支）；正文循环
+        // 必须从标题行的下一行开始，否则同一标题行会被正文循环的 heading 分支
+        // 再次 emit，产生结构性 duplicate（每个 AC 标题式片段出现两次）。
         const bodyStart = section.headingPath
-            ? section.startLine + (explicitSectionAc ? 0 : 1)
+            ? section.startLine + 1
             : section.startLine;
         const bodyEnd = section.endLine;
         const bodyLines = lines.slice(Math.max(0, bodyStart - 1), Math.min(bodyEnd, lines.length));