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

package/dist/governance/resource-catalog.js

@@ -0,0 +1,151 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { findPackageRoot } from "../shared/package-metadata.js";
+const SHA256_RE = /^[a-f0-9]{64}$/;
+function isSafePackagePath(value) {
+    if (!value || path.isAbsolute(value) || value.includes("\\"))
+        return false;
+    const parts = value.split("/");
+    return parts.every((part) => part !== "" && part !== "." && part !== "..");
+}
+export const resourceCatalogEntrySchema = z
+    .object({
+    id: z.string().trim().min(1).regex(/^[A-Za-z0-9][A-Za-z0-9:._/-]*$/),
+    path: z.string().refine(isSafePackagePath, "path must stay within the package root"),
+    kind: z.enum(["document", "skill", "template", "schema", "prompt", "script", "other"]),
+    bytes: z.number().int().nonnegative(),
+    sha256: z.string().regex(SHA256_RE),
+    schemaVersion: z.number().int().positive(),
+})
+    .strict();
+export const resourceCatalogSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    entries: z.array(resourceCatalogEntrySchema),
+})
+    .strict()
+    .superRefine((catalog, ctx) => {
+    const ids = new Set();
+    const paths = new Set();
+    for (const [index, entry] of catalog.entries.entries()) {
+        if (ids.has(entry.id))
+            ctx.addIssue({ code: "custom", path: ["entries", index, "id"], message: "duplicate resource id" });
+        if (paths.has(entry.path))
+            ctx.addIssue({ code: "custom", path: ["entries", index, "path"], message: "duplicate resource path" });
+        ids.add(entry.id);
+        paths.add(entry.path);
+    }
+});
+export const CONTROLLER_RESOURCE_IDS = {
+    loopAgentBridgeSkill: "agent-bridge:loop-agent",
+};
+export function builtinSkillResourceId(name) {
+    return `builtin-skill:${name}`;
+}
+export function builtinSkillReferenceResourceId(name, relativePath) {
+    return `builtin-skill-resource:${name}/${relativePath}`;
+}
+export class ResourceCatalogError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ResourceCatalogError";
+    }
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+async function assertContainedRegularFile(root, candidate) {
+    const [rootReal, candidateReal, linkInfo] = await Promise.all([
+        realpath(root),
+        realpath(candidate),
+        lstat(candidate),
+    ]);
+    const relative = path.relative(rootReal, candidateReal);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new ResourceCatalogError("RESOURCE_PATH_ESCAPE", `resource resolves outside package root: ${candidate}`);
+    }
+    if (!linkInfo.isFile() || linkInfo.isSymbolicLink() || linkInfo.nlink !== 1) {
+        throw new ResourceCatalogError("RESOURCE_NOT_REGULAR", `resource is not a regular file: ${candidate}`);
+    }
+}
+/** Lazy package resource provider: load the small catalog once, hash bytes only when used. */
+export class ControllerContextProvider {
+    packageRoot;
+    identity;
+    entries;
+    constructor(packageRoot, catalog, catalogBytes) {
+        this.packageRoot = packageRoot;
+        this.entries = new Map(catalog.entries.map((entry) => [entry.id, entry]));
+        this.identity = { schemaVersion: 1, catalogDigest: sha256(catalogBytes) };
+    }
+    static async load(packageRoot, catalogName = "resource-catalog.v1.json") {
+        const catalogPath = path.join(packageRoot, catalogName);
+        await assertContainedRegularFile(packageRoot, catalogPath);
+        const bytes = await readFile(catalogPath);
+        let parsed;
+        try {
+            parsed = JSON.parse(bytes.toString("utf8"));
+        }
+        catch (error) {
+            throw new ResourceCatalogError("RESOURCE_CATALOG_INVALID", `invalid resource catalog JSON: ${String(error)}`);
+        }
+        const catalog = resourceCatalogSchema.safeParse(parsed);
+        if (!catalog.success) {
+            throw new ResourceCatalogError("RESOURCE_CATALOG_INVALID", `invalid resource catalog: ${catalog.error.message}`);
+        }
+        return new ControllerContextProvider(packageRoot, catalog.data, bytes);
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => ({ ...entry }));
+    }
+    entry(id) {
+        const entry = this.entries.get(id);
+        return entry ? { ...entry } : undefined;
+    }
+    async read(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new ResourceCatalogError("RESOURCE_NOT_FOUND", `resource not found: ${id}`);
+        const file = path.join(this.packageRoot, ...entry.path.split("/"));
+        await assertContainedRegularFile(this.packageRoot, file);
+        const before = await stat(file);
+        const bytes = await readFile(file);
+        const after = await stat(file);
+        if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+            throw new ResourceCatalogError("RESOURCE_CHANGED_DURING_READ", `resource changed while reading: ${id}`);
+        }
+        if (bytes.byteLength !== entry.bytes || sha256(bytes) !== entry.sha256) {
+            throw new ResourceCatalogError("RESOURCE_HASH_MISMATCH", `resource does not match catalog: ${id}`);
+        }
+        return bytes;
+    }
+    async readText(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new ResourceCatalogError("RESOURCE_NOT_FOUND", `resource not found: ${id}`);
+        const bytes = await this.read(id);
+        return {
+            id,
+            relativePath: entry.path,
+            absolutePath: path.join(this.packageRoot, ...entry.path.split("/")),
+            kind: entry.kind,
+            schemaVersion: entry.schemaVersion,
+            bytes: entry.bytes,
+            sha256: entry.sha256,
+            text: bytes.toString("utf8"),
+        };
+    }
+}
+export async function createControllerContextProvider(options = {}) {
+    const packageRoot = options.packageRoot
+        ?? findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    if (!packageRoot) {
+        throw new ResourceCatalogError("PACKAGE_ROOT_NOT_FOUND", "cannot locate the loop-agent package root for controller resources");
+    }
+    return ControllerContextProvider.load(packageRoot, options.catalogName ?? "resource-catalog.v1.json");
+}

package/dist/infrastructure/console/app-data.js

@@ -290,13 +290,17 @@ export async function removeStaged(filePath) {
     await rm(filePath, { force: true });
 }
 /** Synchronous helpers used by boot-time path checks. */
-export function writeSecureJsonSync(filePath, value) {
+export function writeSecureJsonSync(filePath, value, options) {
     const dir = path.dirname(filePath);
     ensureSecureDir(dir);
     const resolved = assertSafeAppDataPath(dir, filePath);
     const tmp = `${resolved}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    const pretty = options?.pretty !== false;
+    const body = pretty
+        ? `${JSON.stringify(value, null, 2)}\n`
+        : `${JSON.stringify(value)}\n`;
     try {
-        writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, {
+        writeFileSync(tmp, body, {
             encoding: "utf8",
             mode: 0o600,
         });

package/dist/shared/operator/capabilities.js

@@ -395,7 +395,7 @@ export function buildOperatorCapabilitiesDocument() {
         {
             action: "prepareScheduledTask", cli: "console scheduled task preparation", kind: "mutation",
             inputSchemaVersion: 1, resultSchemaVersion: 1, envelopeSchemaVersion: 1, requiredErrorCodes: ["INVALID_INPUT"],
-            description: "Preferred entry for natural-language one-time scheduled tasks, including read-only inspection reports. Call this directly after understanding the goal, output scope, executable acceptance and time; the server uses the CURRENT project directory and creates the immutable PRD, managed Task and strict writeSet gate, binds THIS Chat automatically and returns a REAL planned goal/confirmation card. No pre-existing task, worktree or session ID is needed: never ask the user for these internal fields and do not manually create/edit them with bash/write/newTask/importPrd. Keep preparation concise: preserve the user goal without inventing extra requirements. Omit budget for ordinary tasks. Use minimal independent acceptance commands (AC-1, AC-2), preferably existing test/build scripts or test -s scheduled-report.md for a report; no compound shell/pipelines/substitution, language-specific grep checks or redundant scope assertions (the host enforces scope). Infer routine defaults and verification commands from the repository; ask only about genuinely ambiguous goal/scope/time. For read-only requests allow just an ordinary report file in the current project directory, e.g. scheduled-report.md, not .harness/. Use schedule.delayMinutes for relative time (counted after preparation finishes), or localAt + IANA timezone for an exact date/time. The current workspace must match committed HEAD; never auto-commit/stash/reset existing changes. The card exposes the exact time, bounded defaults and committed base before one human confirmation. Same request in this Chat is idempotent. Only a returned goalId with state=planned is a prepared reservation; textual drafts, Tasks or failed operations are NOT bookings. Never replace a requested schedule with immediate execution or sleep, never call runDag or self-confirm. On failure explain the returned stage, correct business inputs and retry this tool; do not mutate imported PRD/runtime artifacts. For a new distinct appointment, make its goal/time distinct.",
+            description: "Preferred entry for natural-language one-time scheduled tasks, including read-only inspection reports. Call this directly after understanding the goal, output scope, executable acceptance and time; the server uses the CURRENT project directory and creates the immutable PRD, managed Task and strict writeSet gate, binds THIS Chat automatically and returns a REAL planned goal/confirmation card. No pre-existing task, worktree or session ID is needed: never ask the user for these internal fields and do not manually create/edit them with bash/write/newTask/importPrd. Keep preparation concise: preserve the user goal without inventing extra requirements. Omit budget for ordinary tasks: the host freezes 5 goal attempts, 5 DAG runs and 4 supervisor calls, with a 15-minute latest-start grace and a 240-minute execution window, all shown before confirmation. maxTurns counts goal attempts, not model tool calls. Explicit budget or maxDurationMinutes is never raised. Use minimal independent acceptance commands (AC-1, AC-2), preferably existing test/build scripts or test -s scheduled-report.md for a report; no compound shell/pipelines/substitution, language-specific grep checks or redundant scope assertions (the host enforces scope). Infer routine defaults and verification commands from the repository; ask only about genuinely ambiguous goal/scope/time. For read-only requests allow just an ordinary report file in the current project directory, e.g. scheduled-report.md, not .harness/. Use schedule.delayMinutes for relative time (counted after preparation finishes), or localAt + IANA timezone for an exact date/time. The current workspace must match committed HEAD; never auto-commit/stash/reset existing changes. The card exposes the exact time, bounded defaults and committed base before one human confirmation. Same request in this Chat is idempotent. Only a returned goalId with state=planned is a prepared reservation; textual drafts, Tasks or failed operations are NOT bookings. Never replace a requested schedule with immediate execution or sleep, never call runDag or self-confirm. On failure explain the returned stage, correct business inputs and retry this tool; do not mutate imported PRD/runtime artifacts. For a new distinct appointment, make its goal/time distinct.",
             inputParams: [{ name: "request", type: "object", required: true, description: "Business goal, workflow, allowedPaths, acceptance and schedule; optional forbiddenPaths/budget. Runtime identity is server-owned." }],
             modelCallable: "always", humanConfirmation: "none",
         },
@@ -409,7 +409,7 @@ export function buildOperatorCapabilitiesDocument() {
             "requiredErrorCodes": [
                 "INVALID_INPUT"
             ],
-            "description": "Advanced entry ONLY for an already prepared Task. For a new natural-language reservation use prepareScheduledTask instead. Requires the current repository or its linked worktree at frozenBase and a managed Task already strict-prepared at its writeSet gate. booking must include managedTaskId, originalGoal, chatSessionRef, workflow, worktreeRef, frozenBase, allowedPaths, forbiddenPaths, acceptance {policy, criteria [{acId,description,command}]}, budget {maxTurns,maxDagRuns,maxSupervisorCalls}, time {executeAtUtc,latestStartUtc,stopAtUtc,expiresAt,timezone,allowedHours,misfirePolicy}. Resolve natural-language dates with the user timezone; ask about ambiguous time/AC/scope. No execution or authorization occurs. Show the complete scope/time/budget for one browser confirmation. Never call runDag for this reservation.",
+            "description": "Advanced entry ONLY for an already prepared Task. For a new natural-language reservation use prepareScheduledTask instead. Requires the current repository or its linked worktree at frozenBase and a managed Task already strict-prepared at its writeSet gate. booking must include managedTaskId, originalGoal, chatSessionRef, workflow, worktreeRef, frozenBase, allowedPaths, forbiddenPaths, acceptance {policy, criteria [{acId,description,command}]}, budget {maxTurns,maxDagRuns,maxSupervisorCalls}, time {executeAtUtc,latestStartUtc,stopAtUtc,expiresAt,timezone,allowedHours,misfirePolicy}. This entry never fills omitted budget; for implementation work supply at least maxTurns=5, maxDagRuns=5, maxSupervisorCalls=4. Resolve natural-language dates with the user timezone; ask about ambiguous time/AC/scope. No execution or authorization occurs. Show the complete scope/time/budget for one browser confirmation. Never call runDag for this reservation.",
             "inputParams": [
                 {
                     "name": "booking",

package/dist/shared/package-metadata.js

@@ -106,8 +106,9 @@ export function computeBinarySha256(filePath) {
  * Compute a portable, deterministic content fingerprint for the installed
  * package rooted at `packageRoot`.
  *
- * The fingerprint covers four scopes (package.json, bin/**, dist/**,
- * skills/**) and is independent of the absolute installation path.
+ * The fingerprint covers executable code plus package-owned Skills, templates,
+ * bridge resources, and their generated catalog. It is independent of the
+ * absolute installation path.
  *
  * Sorting uses code-point order (UTF-8 byte comparison), NOT localeCompare,
  * to ensure deterministic behaviour across locales.
@@ -118,17 +119,23 @@ export function computePackageFingerprint(packageRoot) {
         "bin/**",
         "dist/**",
         "skills/**",
+        "docs/templates/**",
+        "resources/**",
+        "resource-catalog.v1.json",
     ];
     // Collecting entries ---------------------------------------------------
     const entries = [];
     // 1) package.json (required single file)
     addRequiredFile(entries, path.join(packageRoot, "package.json"), "");
-    // 2) bin/**, dist/**, skills/** via recursive walk
-    for (const dir of ["bin", "dist", "skills"]) {
+    // 2) Package-owned executable and controller-resource trees.
+    for (const dir of ["bin", "dist", "skills", "docs/templates", "resources"]) {
         const absoluteDir = path.join(packageRoot, dir);
         collectTree(entries, absoluteDir, dir);
     }
-    // 3) Deterministic sort by relative path (code-point / byte order)
+    // 3) The generated catalog binds logical resource ids to those bytes. It is
+    // optional only for source/test fixtures; published packages always ship it.
+    addOptionalFile(entries, path.join(packageRoot, "resource-catalog.v1.json"), "");
+    // 4) Deterministic sort by relative path (code-point / byte order)
     entries.sort((a, b) => {
         const aBuf = Buffer.from(a.relativePath, "utf-8");
         const bBuf = Buffer.from(b.relativePath, "utf-8");
@@ -141,14 +148,14 @@ export function computePackageFingerprint(packageRoot) {
         }
         return aBuf.length - bBuf.length;
     });
-    // 4) Cumulative hash: hash of (<relativePath> + "\t" + <contentHash>) lines
+    // 5) Cumulative hash: hash of (<relativePath> + "\t" + <contentHash>) lines
     const cumulative = createHash("sha256");
     for (const entry of entries) {
         cumulative.update(`${entry.relativePath}\t${entry.contentHash}\n`);
     }
     return {
         algorithm: "sha256",
-        scopeVersion: 1,
+        scopeVersion: 2,
         scope,
         value: `sha256:${cumulative.digest("hex")}`,
         fileCount: entries.length,
@@ -316,6 +323,15 @@ function addRequiredFile(entries, absolutePath, relativeDir) {
         : path.basename(absolutePath);
     entries.push({ relativePath, contentHash });
 }
+function addOptionalFile(entries, absolutePath, relativeDir) {
+    try {
+        addRequiredFile(entries, absolutePath, relativeDir);
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+    }
+}
 function collectTree(entries, absoluteDir, relativeDir) {
     let stats;
     try {

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/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);