@tea-agent/loop-agent 0.44.0-next.12 → 0.44.0-next.14

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

@@ -1,17 +1,20 @@
 import { shouldRewriteAssistantTransientProviderError } from "../pi-provider-recovery.js";
 import { buildOverflowCheckpoint } from "./checkpoint.js";
+import { prunePiToolResultMessages, } from "./tool-result-pruner.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,
+        pruneArmed: false,
         counters: emptyContextPressureCounters(),
     };
 }
 export function createContextPressureExtension(options) {
     const l2 = options.policy.mode !== "off";
     const l1 = Boolean(options.sift);
+    const pruner = l2 && options.prune !== undefined;
     const transientRecovery = options.normalizeTransientProviderErrors === true;
     if (!l2 && !l1 && !transientRecovery)
         return undefined;
@@ -54,6 +57,8 @@ export function createContextPressureExtension(options) {
                     const reason = event.reason;
                     if (reason === "overflow") {
                         incrementCounter(options.controller.counters, "overflow");
+                        if (pruner)
+                            options.controller.pruneArmed = true;
                     }
                     if (reason === "manual") {
                         incrementCounter(options.controller.counters, "manual");
@@ -79,6 +84,24 @@ export function createContextPressureExtension(options) {
                     };
                 });
             }
+            if (pruner) {
+                api.on("context", (event) => {
+                    if (!options.controller.pruneArmed)
+                        return undefined;
+                    const messages = Array.isArray(event.messages) ? event.messages : [];
+                    try {
+                        const result = prunePiToolResultMessages(messages, options.prune);
+                        if (!result.changed)
+                            return undefined;
+                        options.controller.counters.toolResultPruned += result.messagesPruned;
+                        options.controller.counters.charsPrunedEstimate += result.charsRemoved;
+                        return { messages: result.messages };
+                    }
+                    catch {
+                        return undefined;
+                    }
+                });
+            }
             if (l1 && options.sift) {
                 const sift = options.sift;
                 api.on("before_provider_request", (event) => {

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

@@ -1,6 +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 { PI_TOOL_RESULT_PRUNE_MARKER, DEFAULT_PI_TOOL_RESULT_PRUNE_CONFIG, resolvePiToolResultPruneConfig, parsePiToolResultPruneConfig, piCodePointLength, prunePiToolResultMessages, } from "./tool-result-pruner.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";

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

@@ -9,6 +9,8 @@ export function emptyContextPressureCounters() {
         l0CompactFailed: 0,
         tokensSavedEstimate: 0,
         blocksCompressed: 0,
+        toolResultPruned: 0,
+        charsPrunedEstimate: 0,
     };
 }
 export function incrementCounter(counters, reason, amount = 1) {
@@ -47,5 +49,7 @@ export function projectSafeTelemetry(counters) {
         failOpen: counters.failOpen,
         tokensSavedEstimate: counters.tokensSavedEstimate,
         blocksCompressed: counters.blocksCompressed,
+        toolResultPruned: counters.toolResultPruned,
+        charsPrunedEstimate: counters.charsPrunedEstimate,
     };
 }

package/dist/shared/pi-context-pressure/tool-result-pruner.js

@@ -0,0 +1,98 @@
+/** Deterministic, model-free pruning of Pi tool-result messages. */
+import { parseBoundedNumber, parseEnabledFlag } from "./env.js";
+export const PI_TOOL_RESULT_PRUNE_MARKER = "\n\n[... tool result middle pruned ...]\n\n";
+export const DEFAULT_PI_TOOL_RESULT_PRUNE_CONFIG = Object.freeze({ thresholdChars: 8192, headChars: 4096, tailChars: 1024 });
+export function parsePiToolResultPruneConfig(env = process.env) {
+    const enabled = parseEnabledFlag(env.HARNESS_TOOL_RESULT_PRUNE, true);
+    const diagnostics = enabled.diagnostic ? [enabled.diagnostic] : [];
+    const threshold = parseBoundedNumber(env.HARNESS_TOOL_RESULT_PRUNE_THRESHOLD_CHARS, 8192, 1, 1_000_000);
+    const head = parseBoundedNumber(env.HARNESS_TOOL_RESULT_PRUNE_HEAD_CHARS, 4096, 0, 1_000_000);
+    const tail = parseBoundedNumber(env.HARNESS_TOOL_RESULT_PRUNE_TAIL_CHARS, 1024, 0, 1_000_000);
+    for (const item of [threshold, head, tail])
+        if (item.diagnostic)
+            diagnostics.push(item.diagnostic);
+    try {
+        return { enabled: enabled.enabled, config: resolvePiToolResultPruneConfig({ thresholdChars: Math.floor(threshold.value), headChars: Math.floor(head.value), tailChars: Math.floor(tail.value) }), diagnostics };
+    }
+    catch (error) {
+        diagnostics.push(error instanceof Error ? error.message : String(error));
+        return { enabled: false, config: DEFAULT_PI_TOOL_RESULT_PRUNE_CONFIG, diagnostics };
+    }
+}
+export function resolvePiToolResultPruneConfig(config = {}) {
+    const keys = new Set(["thresholdChars", "headChars", "tailChars"]);
+    for (const key of Object.keys(config))
+        if (!keys.has(key))
+            throw new Error(`PiToolResultPruneConfig: unknown key "${key}"`);
+    const out = { thresholdChars: config.thresholdChars ?? 8192, headChars: config.headChars ?? 4096, tailChars: config.tailChars ?? 1024 };
+    if (!Number.isInteger(out.thresholdChars) || out.thresholdChars <= 0)
+        throw new Error("thresholdChars must be positive integer");
+    if (!Number.isInteger(out.headChars) || out.headChars < 0)
+        throw new Error("headChars must be non-negative integer");
+    if (!Number.isInteger(out.tailChars) || out.tailChars < 0)
+        throw new Error("tailChars must be non-negative integer");
+    if (out.headChars + Array.from(PI_TOOL_RESULT_PRUNE_MARKER).length + out.tailChars > out.thresholdChars)
+        throw new Error("prune budgets exceed threshold");
+    return Object.freeze(out);
+}
+export function piCodePointLength(text) { return Array.from(text).length; }
+function textBlock(value) { return value && typeof value === "object" && value.type === "text" && typeof value.text === "string"; }
+function isToolResult(message) { return message.role === "tool" || message.role === "toolResult" || message.type === "tool_result" || message.role === "tool_result"; }
+function pruneBlocks(input, cfg) {
+    const before = input.reduce((n, b) => n + (textBlock(b) ? piCodePointLength(b.text) : 0), 0);
+    if (before <= cfg.thresholdChars)
+        return { blocks: null, before, after: before };
+    const cutStart = cfg.headChars, cutEnd = before - cfg.tailChars;
+    let consumed = 0, inserted = false;
+    const out = [];
+    for (const block of input) {
+        if (!textBlock(block)) {
+            out.push(block);
+            continue;
+        }
+        const points = Array.from(block.text);
+        const bs = consumed, be = bs + points.length;
+        const headEnd = Math.min(points.length, Math.max(0, cutStart - bs));
+        const tailStart = Math.min(points.length, Math.max(0, cutEnd - bs));
+        const marker = !inserted && bs < cutEnd && be > cutStart ? PI_TOOL_RESULT_PRUNE_MARKER : "";
+        if (marker)
+            inserted = true;
+        const text = points.slice(0, headEnd).join("") + marker + points.slice(tailStart).join("");
+        if (text)
+            out.push({ ...block, text });
+        consumed = be;
+    }
+    const after = out.reduce((n, b) => n + (textBlock(b) ? piCodePointLength(b.text) : 0), 0);
+    if (!inserted || after > cfg.thresholdChars || after >= before)
+        throw new Error("Pi tool-result prune invariant failed");
+    return { blocks: out, before, after };
+}
+/** Returns a new transcript; input/full originals are never mutated or persisted. */
+export function prunePiToolResultMessages(messages, config) {
+    const cfg = resolvePiToolResultPruneConfig(config);
+    const output = messages.slice();
+    let charsRemoved = 0, messagesPruned = 0;
+    for (let i = 0; i < output.length; i++) {
+        const message = output[i];
+        if (!message || !isToolResult(message))
+            continue;
+        if (typeof message.content === "string") {
+            const r = pruneBlocks([{ type: "text", text: message.content }], cfg);
+            if (r.blocks) {
+                output[i] = { ...message, content: r.blocks[0].text };
+                charsRemoved += r.before - r.after;
+                messagesPruned++;
+            }
+            continue;
+        }
+        if (!Array.isArray(message.content))
+            continue;
+        const r = pruneBlocks(message.content, cfg);
+        if (r.blocks) {
+            output[i] = { ...message, content: r.blocks };
+            charsRemoved += r.before - r.after;
+            messagesPruned++;
+        }
+    }
+    return { messages: output, changed: messagesPruned > 0, charsRemoved, messagesPruned };
+}

package/dist/shared/update/npm-client.js

@@ -4,6 +4,39 @@ import path from "node:path";
 import semver from "semver";
 const PACKAGE_NAME = "@tea-agent/loop-agent";
 export const DEFAULT_NPM_QUERY_TIMEOUT_MS = 15_000;
+function quoteWindowsCommandArgument(value) {
+    if (/[%!^&|<>]/.test(value)) {
+        throw new Error("unsafe Windows update command argument");
+    }
+    return /^[A-Za-z0-9_@./:\\=,+-]+$/.test(value)
+        ? value
+        : `"${value.replaceAll('"', '""')}"`;
+}
+export function resolveUpdateCommandLaunch(command, args, platform = process.platform, comspec = process.env.ComSpec ?? "cmd.exe") {
+    if (platform !== "win32") {
+        return { command, args: [...args], windowsVerbatimArguments: false };
+    }
+    const isExplicitPath = command.includes("/") || command.includes("\\");
+    const isKnownBareShim = !isExplicitPath &&
+        path.win32.extname(command) === "" &&
+        new Set(["npm", "npx", "loop-agent"]).has(command.toLowerCase());
+    const isCommandShim = isKnownBareShim || /\.(?:cmd|bat)$/i.test(command);
+    if (!isCommandShim) {
+        return { command, args: [...args], windowsVerbatimArguments: false };
+    }
+    const windowsCommand = isKnownBareShim ? `${command}.cmd` : command;
+    const commandLine = [windowsCommand, ...args]
+        .map(quoteWindowsCommandArgument)
+        .join(" ");
+    const commandPayload = commandLine.startsWith('"')
+        ? `"${commandLine}"`
+        : commandLine;
+    return {
+        command: comspec,
+        args: [`/d /s /c ${commandPayload}`],
+        windowsVerbatimArguments: true,
+    };
+}
 export function createNpmUpdateClient(options) {
     const npmCommand = options.npmCommand ?? "npm";
     const loopAgentCommand = options.loopAgentCommand ?? "loop-agent";
@@ -166,11 +199,26 @@ function isAllowedChannelVersion(version, channel) {
 }
 async function runCommand(command, args, options) {
     return new Promise((resolve) => {
-        const child = spawn(command, [...args], {
+        let launch;
+        try {
+            launch = resolveUpdateCommandLaunch(command, args);
+        }
+        catch (error) {
+            resolve({
+                exitCode: null,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                timedOut: false,
+            });
+            return;
+        }
+        const child = spawn(launch.command, launch.args, {
             cwd: options.cwd,
             env: options.env ? { ...process.env, ...options.env } : process.env,
             stdio: ["ignore", "pipe", "pipe"],
             shell: false,
+            windowsHide: true,
+            windowsVerbatimArguments: launch.windowsVerbatimArguments,
         });
         let stdout = "";
         let stderr = "";

package/dist/task/config-types.js

@@ -126,7 +126,8 @@ export const frontendOpenspecConfigSchema = z.object({
 export const frontendTestConfigSchema = z.object({
     /**
      * Repository-relative frontend-test artifact root.
-     * Default "testcase/frontend". Semantic validation lives in
+     * Default ".harness/testcase/frontend" (canonical harness test-artifact
+     * namespace). Semantic validation lives in
      * resolveFrontendTestLayout (fail-closed), not in this schema.
      */
     testRoot: z.string().min(1).optional(),
@@ -239,7 +240,8 @@ const backendTestModuleLayoutSchema = z
 /** Backend-test artifact layout and pipeline mode configuration (plan A/B/D). */
 export const backendTestConfigSchema = z
     .object({
-    /** Repository-relative test root. Default "testcase". */
+    /** Repository-relative test root. Default ".harness/testcase" (canonical
+     * harness test-artifact namespace). */
     testRoot: z.string().min(1).optional(),
     /** Markdown subdirectory relative to testRoot. Default "md". */
     markdownRel: z.string().min(1).optional(),

package/dist/task/source-prepare/build-draft.js

@@ -233,6 +233,7 @@ export function buildPrepareDraft(input) {
         allowedPaths,
         forbiddenPaths: finalForbidden,
         noDefaultForbiddenPaths: flags.noDefaultForbiddenPaths,
+        taskKind,
     });
     const draft = {
         schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,

package/dist/task/source-prepare/path-policy.js

@@ -1,5 +1,6 @@
 import { canonicalizePath } from "../contract/canonicalize.js";
 import { PREPARE_DEFAULT_FORBIDDEN_PATHS } from "./types.js";
+import { isAnyTestArtifactPath, isTestArtifactTaskKind, } from "../../workflows/dag/test-artifact-namespace.js";
 function hasNul(value) {
     return value.includes("\0");
 }
@@ -133,6 +134,7 @@ export function assessPreparePaths(input) {
         forbidden.push(result.value);
     }
     const allowedSet = new Set(allowed);
+    const testArtifactTaskKind = isTestArtifactTaskKind(input.taskKind);
     for (const f of forbidden) {
         if (allowedSet.has(f)) {
             blocking.push({
@@ -145,14 +147,22 @@ export function assessPreparePaths(input) {
     }
     for (const a of allowed) {
         for (const f of forbidden) {
-            if (forbiddenAncestorCoversAllowed(a, f)) {
-                blocking.push({
-                    code: "ALLOWED_UNDER_FORBIDDEN_ANCESTOR",
-                    level: "blocking",
-                    message: `allowed path ${a} is fully covered by forbidden ancestor ${f}`,
-                    path: a,
-                });
+            if (!forbiddenAncestorCoversAllowed(a, f))
+                continue;
+            // D3 test-artifact exception: a dedicated test task may allow exactly
+            // the canonical `.harness/testcase` roots under the default `.harness/**`
+            // forbidden ancestor; every other overlap stays blocking.
+            if (testArtifactTaskKind &&
+                f === ".harness/**" &&
+                isAnyTestArtifactPath(a)) {
+                continue;
             }
+            blocking.push({
+                code: "ALLOWED_UNDER_FORBIDDEN_ANCESTOR",
+                level: "blocking",
+                message: `allowed path ${a} is fully covered by forbidden ancestor ${f}`,
+                path: a,
+            });
         }
     }
     for (const a of allowed) {

package/dist/worker/cli.js

@@ -873,12 +873,10 @@ export async function runConsoleServe(options) {
             await server.close();
             return;
         }
-        await new Promise((resolve) => {
-            const shutdown = () => resolve();
-            process.once("SIGINT", shutdown);
-            process.once("SIGTERM", shutdown);
+        const { holdConsoleUntilSignal } = await import("./console/console-shutdown.js");
+        await holdConsoleUntilSignal({
+            close: () => server.close(),
         });
-        await server.close();
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);