@aexol/spectral 0.9.58 → 0.9.60

package/dist/sdk/coding-agent/core/compaction/dcp-lite.js

@@ -0,0 +1,411 @@
+import { deduplicateToolCalls, estimateCompactionTokenMetrics, } from "./compaction.js";
+import { computeFileLists, formatFileOperations } from "./utils.js";
+const DCP_LITE_VERSION = 1;
+const MAX_SUMMARY_CHARS = 12_000;
+const MAX_PREVIOUS_SUMMARY_CHARS = 3_000;
+const MAX_EXCERPT_CHARS = 480;
+const MAX_RESULT_SIGNAL_CHARS = 360;
+const MAX_TOOL_ARGS_CHARS = 220;
+const MAX_EXCERPTS_PER_SECTION = 6;
+const MAX_TOOL_CALLS_LISTED = 8;
+const MAX_SIGNALS_LISTED = 10;
+const MIN_CORE_SUMMARY_CHARS = 1_200;
+const MAX_FILE_OPERATIONS_CHARS = 2_000;
+const MAX_FILES_PER_OPERATION_SECTION = 40;
+const MAX_FILE_PATH_CHARS = 160;
+/**
+ * Deterministic, local-only compaction for manual DCP-lite mode.
+ *
+ * This intentionally performs no model, provider, extension, or network calls.
+ * It preserves bounded excerpts and counters from CompactionPreparation so the
+ * resulting summary is stable and usually much smaller than the discarded span.
+ */
+export function compactDcpLite(preparation) {
+    const dedupedMessages = deduplicateToolCalls(preparation.messagesToSummarize);
+    const dedupedTurnPrefix = deduplicateToolCalls(preparation.turnPrefixMessages);
+    const { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);
+    const messageCounts = countMessages(dedupedMessages);
+    const turnPrefixCounts = countMessages(dedupedTurnPrefix);
+    const userExcerpts = collectRoleExcerpts(dedupedMessages, "user", MAX_EXCERPTS_PER_SECTION);
+    const assistantExcerpts = collectRoleExcerpts(dedupedMessages, "assistant", MAX_EXCERPTS_PER_SECTION);
+    const toolCalls = collectToolCalls(dedupedMessages, MAX_TOOL_CALLS_LISTED);
+    const toolCounts = countToolCalls(dedupedMessages);
+    const signals = collectErrorSignals(dedupedMessages, MAX_SIGNALS_LISTED);
+    const splitTurnExcerpts = preparation.isSplitTurn
+        ? collectAnyExcerpts(dedupedTurnPrefix, MAX_EXCERPTS_PER_SECTION)
+        : [];
+    const sourceChars = estimateSourceChars(preparation.messagesToSummarize, preparation.turnPrefixMessages);
+    const maxSummaryChars = calculateSummaryBudget(sourceChars);
+    const sections = [
+        "# DCP-lite compaction summary",
+        formatContextSection(preparation, messageCounts, turnPrefixCounts),
+        formatPreviousSummary(preparation.previousSummary),
+        formatExcerptSection("User intent / request excerpts", userExcerpts),
+        formatExcerptSection("Assistant progress excerpts", assistantExcerpts),
+        formatToolSection(toolCounts, toolCalls, signals),
+    ];
+    if (preparation.isSplitTurn) {
+        sections.push(formatExcerptSection("Split-turn context", splitTurnExcerpts));
+    }
+    let coreSummary = sections.join("\n\n").replace(/\n{3,}/g, "\n\n").trim();
+    const fileOperations = formatBoundedFileOperations(readFiles, modifiedFiles, maxSummaryChars);
+    const coreBudget = fileOperations ? Math.max(MIN_CORE_SUMMARY_CHARS, maxSummaryChars - fileOperations.length) : maxSummaryChars;
+    coreSummary = truncateText(coreSummary, coreBudget);
+    const summary = `${coreSummary}${fileOperations}`;
+    const tokenMetrics = estimateCompactionTokenMetrics(preparation, summary);
+    return {
+        summary,
+        firstKeptEntryId: preparation.firstKeptEntryId,
+        tokensBefore: preparation.tokensBefore,
+        ...tokenMetrics,
+        details: {
+            readFiles,
+            modifiedFiles,
+            method: "dcp-lite",
+            version: DCP_LITE_VERSION,
+            compactionNumber: preparation.compactionNumber,
+            tokensCompacted: tokenMetrics.tokensCompacted,
+            tokensRemoved: tokenMetrics.tokensRemoved,
+            summaryTokens: tokenMetrics.summaryTokens,
+            reductionPercent: tokenMetrics.reductionPercent,
+            largestTokenSources: tokenMetrics.largestTokenSources ?? [],
+            summarizedMessages: dedupedMessages.length,
+            turnPrefixMessages: dedupedTurnPrefix.length,
+            isSplitTurn: preparation.isSplitTurn,
+        },
+    };
+}
+function formatBoundedFileOperations(readFiles, modifiedFiles, maxSummaryChars) {
+    const fullFileOperations = formatFileOperations(readFiles, modifiedFiles);
+    if (!fullFileOperations)
+        return "";
+    const maxFileOperationsChars = Math.min(MAX_FILE_OPERATIONS_CHARS, maxSummaryChars - MIN_CORE_SUMMARY_CHARS);
+    const hasTooManyFiles = readFiles.length > MAX_FILES_PER_OPERATION_SECTION || modifiedFiles.length > MAX_FILES_PER_OPERATION_SECTION;
+    if (!hasTooManyFiles && fullFileOperations.length <= maxFileOperationsChars) {
+        return fullFileOperations;
+    }
+    let readLimit = Math.min(readFiles.length, MAX_FILES_PER_OPERATION_SECTION);
+    let modifiedLimit = Math.min(modifiedFiles.length, MAX_FILES_PER_OPERATION_SECTION);
+    while (readLimit > 0 || modifiedLimit > 0) {
+        const candidate = formatFileOperations(formatFileListForSummary(readFiles, readLimit), formatFileListForSummary(modifiedFiles, modifiedLimit));
+        if (candidate.length <= maxFileOperationsChars) {
+            return candidate;
+        }
+        if (readLimit >= modifiedLimit && readLimit > 0) {
+            readLimit -= 1;
+        }
+        else {
+            modifiedLimit -= 1;
+        }
+    }
+    return formatFileOperations(formatFileListForSummary(readFiles, 0), formatFileListForSummary(modifiedFiles, 0));
+}
+function formatFileListForSummary(files, limit) {
+    if (files.length === 0)
+        return [];
+    const listedCount = Math.min(files.length, Math.max(0, limit));
+    const displayed = files.slice(0, listedCount).map((file) => truncateText(file, MAX_FILE_PATH_CHARS));
+    const omitted = files.length - listedCount;
+    if (omitted > 0) {
+        displayed.push(`… [${omitted} files omitted]`);
+    }
+    return displayed;
+}
+function countMessages(messages) {
+    const counts = {
+        total: messages.length,
+        user: 0,
+        assistant: 0,
+        toolResult: 0,
+        custom: 0,
+        bashExecution: 0,
+        branchSummary: 0,
+        compactionSummary: 0,
+        other: 0,
+    };
+    for (const message of messages) {
+        switch (message.role) {
+            case "user":
+                counts.user += 1;
+                break;
+            case "assistant":
+                counts.assistant += 1;
+                break;
+            case "toolResult":
+                counts.toolResult += 1;
+                break;
+            case "custom":
+                counts.custom += 1;
+                break;
+            case "bashExecution":
+                counts.bashExecution += 1;
+                break;
+            case "branchSummary":
+                counts.branchSummary += 1;
+                break;
+            case "compactionSummary":
+                counts.compactionSummary += 1;
+                break;
+            default:
+                counts.other += 1;
+        }
+    }
+    return counts;
+}
+function formatContextSection(preparation, messageCounts, turnPrefixCounts) {
+    return [
+        "## Context counters",
+        `- method: dcp-lite deterministic local summary`,
+        `- compaction: #${preparation.compactionNumber}`,
+        `- messages summarized: ${messageCounts.total} (${formatCounts(messageCounts)})`,
+        `- split turn: ${preparation.isSplitTurn ? "yes" : "no"} (turn prefix messages: ${turnPrefixCounts.total})`,
+        `- tokensBefore: ${preparation.tokensBefore}`,
+        `- firstKeptEntryId: ${preparation.firstKeptEntryId}`,
+    ].join("\n");
+}
+function formatCounts(counts) {
+    const parts = [
+        ["user", counts.user],
+        ["assistant", counts.assistant],
+        ["toolResult", counts.toolResult],
+        ["custom", counts.custom],
+        ["bashExecution", counts.bashExecution],
+        ["branchSummary", counts.branchSummary],
+        ["compactionSummary", counts.compactionSummary],
+        ["other", counts.other],
+    ];
+    return parts.filter(([, value]) => value > 0).map(([label, value]) => `${label} ${value}`).join(", ") || "none";
+}
+function formatPreviousSummary(previousSummary) {
+    if (!previousSummary?.trim()) {
+        return "## Previous summary\n- none";
+    }
+    return `## Previous summary\n${truncateBlock(previousSummary, MAX_PREVIOUS_SUMMARY_CHARS)}`;
+}
+function formatExcerptSection(title, excerpts) {
+    if (excerpts.length === 0) {
+        return `## ${title}\n- none captured`;
+    }
+    return [`## ${title}`, ...excerpts.map((excerpt) => `- m${excerpt.index + 1} ${excerpt.role}: ${excerpt.text}`)].join("\n");
+}
+function formatToolSection(toolCounts, toolCalls, signals) {
+    const lines = ["## Tool activity and error signals"];
+    if (toolCounts.size === 0) {
+        lines.push("- tool calls: none captured");
+    }
+    else {
+        const counts = [...toolCounts.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, count]) => `${name}: ${count}`)
+            .join("; ");
+        lines.push(`- tool calls: ${counts}`);
+    }
+    if (toolCalls.length > 0) {
+        lines.push("- recent tool calls:");
+        for (const call of toolCalls) {
+            lines.push(`  - m${call.index + 1} ${call.name} ${call.args}`);
+        }
+    }
+    if (signals.length > 0) {
+        lines.push("- signals:");
+        for (const signal of signals) {
+            lines.push(`  - m${signal.index + 1} ${signal.label}: ${signal.text}`);
+        }
+    }
+    else {
+        lines.push("- signals: none captured");
+    }
+    return lines.join("\n");
+}
+function collectRoleExcerpts(messages, role, limit) {
+    const excerpts = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role !== role)
+            continue;
+        const text = normalizeInline(extractMessageText(message));
+        if (!text)
+            continue;
+        excerpts.push({ index, role, text: truncateText(text, MAX_EXCERPT_CHARS) });
+    }
+    return selectBoundaryItems(excerpts, limit);
+}
+function collectAnyExcerpts(messages, limit) {
+    const excerpts = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        const text = normalizeInline(extractMessageText(message));
+        if (!text)
+            continue;
+        excerpts.push({ index, role: message.role, text: truncateText(text, MAX_EXCERPT_CHARS) });
+    }
+    return selectBoundaryItems(excerpts, limit);
+}
+function selectBoundaryItems(items, limit) {
+    if (items.length <= limit)
+        return items;
+    const firstCount = Math.min(2, limit);
+    const lastCount = Math.max(0, limit - firstCount);
+    return [...items.slice(0, firstCount), ...items.slice(items.length - lastCount)];
+}
+function collectToolCalls(messages, limit) {
+    const calls = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role !== "assistant")
+            continue;
+        for (const block of message.content) {
+            if (block.type !== "toolCall")
+                continue;
+            calls.push({
+                index,
+                name: block.name,
+                args: truncateText(stableJson(block.arguments), MAX_TOOL_ARGS_CHARS),
+            });
+        }
+    }
+    return calls.slice(Math.max(0, calls.length - limit));
+}
+function countToolCalls(messages) {
+    const counts = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        for (const block of message.content) {
+            if (block.type !== "toolCall")
+                continue;
+            counts.set(block.name, (counts.get(block.name) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function collectErrorSignals(messages, limit) {
+    const signals = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role === "assistant") {
+            if (message.stopReason === "error") {
+                signals.push({
+                    index,
+                    label: "assistant stopReason=error",
+                    text: truncateText(normalizeInline(message.errorMessage ?? extractMessageText(message)), MAX_RESULT_SIGNAL_CHARS),
+                });
+            }
+            else if (message.stopReason === "length") {
+                signals.push({
+                    index,
+                    label: "assistant stopReason=length",
+                    text: truncateText(normalizeInline(extractMessageText(message)), MAX_RESULT_SIGNAL_CHARS),
+                });
+            }
+            continue;
+        }
+        if (message.role === "toolResult" && message.isError) {
+            signals.push({
+                index,
+                label: `${message.toolName} toolResult error=true`,
+                text: truncateText(normalizeInline(extractMessageText(message)), MAX_RESULT_SIGNAL_CHARS),
+            });
+            continue;
+        }
+        if (message.role === "bashExecution") {
+            if (message.cancelled || message.truncated || (message.exitCode !== undefined && message.exitCode !== 0)) {
+                const flags = [
+                    message.cancelled ? "cancelled" : undefined,
+                    message.truncated ? "truncated" : undefined,
+                    message.exitCode !== undefined && message.exitCode !== 0 ? `exitCode=${message.exitCode}` : undefined,
+                ]
+                    .filter((flag) => Boolean(flag))
+                    .join(", ");
+                signals.push({
+                    index,
+                    label: `bashExecution ${flags}`,
+                    text: truncateText(normalizeInline(`${message.command}\n${message.output}`), MAX_RESULT_SIGNAL_CHARS),
+                });
+            }
+        }
+    }
+    return signals.slice(0, limit);
+}
+function extractMessageText(message) {
+    switch (message.role) {
+        case "user":
+            return contentToText(message.content);
+        case "assistant":
+            return message.content
+                .filter((block) => block.type === "text")
+                .map((block) => block.text)
+                .join("\n");
+        case "toolResult":
+            return contentToText(message.content);
+        case "custom":
+            return contentToText(message.content);
+        case "bashExecution":
+            return `${message.command}\n${message.output}`;
+        case "branchSummary":
+            return message.summary;
+        case "compactionSummary":
+            return message.summary;
+        default:
+            return "";
+    }
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n");
+}
+function estimateSourceChars(messagesToSummarize, turnPrefixMessages) {
+    let chars = 0;
+    for (const message of [...messagesToSummarize, ...turnPrefixMessages]) {
+        chars += extractMessageText(message).length;
+        if (message.role === "assistant") {
+            for (const block of message.content) {
+                if (block.type === "toolCall") {
+                    chars += block.name.length + stableJson(block.arguments).length;
+                }
+            }
+        }
+    }
+    return chars;
+}
+function calculateSummaryBudget(sourceChars) {
+    if (sourceChars >= 12_000) {
+        return Math.min(MAX_SUMMARY_CHARS, Math.max(3_000, Math.floor(sourceChars * 0.4)));
+    }
+    return MAX_SUMMARY_CHARS;
+}
+function truncateBlock(text, maxChars) {
+    return truncateText(text.trim(), maxChars);
+}
+function truncateText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const omitted = text.length - maxChars;
+    return `${text.slice(0, Math.max(0, maxChars - 36)).trimEnd()}… [${omitted} chars omitted]`;
+}
+function normalizeInline(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function stableJson(value) {
+    const seen = new WeakSet();
+    const normalize = (input) => {
+        if (input === null || typeof input !== "object")
+            return input;
+        if (seen.has(input))
+            return "[Circular]";
+        seen.add(input);
+        if (Array.isArray(input))
+            return input.map((item) => normalize(item));
+        const record = input;
+        const sorted = {};
+        for (const key of Object.keys(record).sort()) {
+            sorted[key] = normalize(record[key]);
+        }
+        return sorted;
+    };
+    return JSON.stringify(normalize(value)) ?? "null";
+}

package/dist/sdk/coding-agent/core/compaction/index.d.ts

@@ -3,5 +3,7 @@
  */
 export * from "./branch-summarization.js";
 export * from "./compaction.js";
+export * from "./dcp-lite.js";
+export * from "./policy.js";
 export * from "./utils.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/sdk/coding-agent/core/compaction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/sdk/coding-agent/core/compaction/index.js

@@ -3,4 +3,6 @@
  */
 export * from "./branch-summarization.js";
 export * from "./compaction.js";
+export * from "./dcp-lite.js";
+export * from "./policy.js";
 export * from "./utils.js";

package/dist/sdk/coding-agent/core/compaction/policy.d.ts

@@ -0,0 +1,71 @@
+export interface ConversationCompactionPolicy {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+    contextLimitRatio: number;
+}
+export interface ManualCompactionPolicy {
+    keepRecentTokens: number;
+    minKeepRecentTokens: number;
+    maxKeepRecentTokens: number;
+}
+export interface AutoOlderHistoryCompactionPolicy {
+    enabled: boolean;
+    contextLimitRatio: number;
+    keepRecentTokens: number;
+    cooldownTurns: number;
+    minRawTokens: number;
+}
+export interface AgentDrivenCompactionPolicy {
+    enabled: boolean;
+    cooldownTurns: number;
+    minRawTokens: number;
+    olderHistoryKeepRecentTokens: number;
+    olderHistoryMinKeepRecentTokens: number;
+    olderHistoryMaxKeepRecentTokens: number;
+    olderHistoryMinCompactableTokens: number;
+}
+export interface ToolOutputCompressorPolicy {
+    enabled: boolean;
+    maxResultChars: number;
+    maxReadLines: number;
+    maxLsLines: number;
+    maxSearchLines: number;
+    stripAnsi: boolean;
+    stripComments: boolean;
+    testFailuresOnly: boolean;
+    compactGit: boolean;
+}
+export interface TruncationContinuationPolicy {
+    maxAttempts: number;
+    totalOutputTokenBudget: number;
+}
+export interface CompactionPolicy {
+    conversation: ConversationCompactionPolicy;
+    manual: ManualCompactionPolicy;
+    autoOlderHistory: AutoOlderHistoryCompactionPolicy;
+    agentDriven: AgentDrivenCompactionPolicy;
+    toolOutputCompressor: ToolOutputCompressorPolicy;
+    truncationContinuation: TruncationContinuationPolicy;
+}
+export interface CompactionPolicySettings {
+    /** Legacy/current conversation compaction flag. Defaults to true. */
+    enabled?: boolean;
+    /** Legacy/current reserve tokens for compaction prompt/output. */
+    reserveTokens?: number;
+    /** Legacy/current recent raw suffix for automatic older-history compaction. */
+    keepRecentTokens?: number;
+    /** Context-window pressure ratio for automatic older-history compaction. */
+    contextLimitRatio?: number;
+    manual?: Partial<ManualCompactionPolicy>;
+    autoOlderHistory?: Partial<AutoOlderHistoryCompactionPolicy>;
+    agentDriven?: Partial<AgentDrivenCompactionPolicy>;
+    toolOutputCompressor?: Partial<ToolOutputCompressorPolicy>;
+    truncationContinuation?: Partial<TruncationContinuationPolicy>;
+}
+export declare const DEFAULT_COMPACTION_POLICY: CompactionPolicy;
+export declare function normalizeManualKeepRecentTokens(value: unknown, manualPolicy?: ManualCompactionPolicy): number;
+export declare function normalizeAgentDrivenOlderHistoryKeepRecentTokens(value: unknown, agentPolicy?: AgentDrivenCompactionPolicy): number;
+export declare function getAutoOlderHistoryContextThresholdTokens(policy: CompactionPolicy, contextWindow: number | null | undefined): number | null;
+export declare function normalizeCompactionPolicy(settings?: CompactionPolicySettings): CompactionPolicy;
+//# sourceMappingURL=policy.d.ts.map

package/dist/sdk/coding-agent/core/compaction/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/policy.ts"],"names":[],"mappings":"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"}

package/dist/sdk/coding-agent/core/compaction/policy.js

@@ -0,0 +1,147 @@
+export const DEFAULT_COMPACTION_POLICY = {
+    conversation: {
+        enabled: true,
+        reserveTokens: 16_384,
+        keepRecentTokens: 20_000,
+        contextLimitRatio: 0.8,
+    },
+    manual: {
+        keepRecentTokens: 8_000,
+        minKeepRecentTokens: 1_000,
+        maxKeepRecentTokens: 100_000,
+    },
+    autoOlderHistory: {
+        enabled: true,
+        contextLimitRatio: 0.4,
+        keepRecentTokens: 12_000,
+        cooldownTurns: 0,
+        minRawTokens: 0,
+    },
+    agentDriven: {
+        enabled: true,
+        cooldownTurns: 3,
+        minRawTokens: 8_000,
+        olderHistoryKeepRecentTokens: 12_000,
+        olderHistoryMinKeepRecentTokens: 1_000,
+        olderHistoryMaxKeepRecentTokens: 100_000,
+        olderHistoryMinCompactableTokens: 1_000,
+    },
+    toolOutputCompressor: {
+        enabled: true,
+        maxResultChars: 8_000,
+        maxReadLines: 500,
+        maxLsLines: 100,
+        maxSearchLines: 200,
+        stripAnsi: true,
+        stripComments: true,
+        testFailuresOnly: true,
+        compactGit: true,
+    },
+    truncationContinuation: {
+        maxAttempts: 3,
+        totalOutputTokenBudget: 32_000,
+    },
+};
+function normalizeBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function normalizeInteger(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const integer = Math.trunc(value);
+    return Math.min(max, Math.max(min, integer));
+}
+function normalizeNonNegativeInteger(value, fallback) {
+    return normalizeInteger(value, fallback, 0, Number.MAX_SAFE_INTEGER);
+}
+function normalizePositiveInteger(value, fallback) {
+    return normalizeInteger(value, fallback, 1, Number.MAX_SAFE_INTEGER);
+}
+function normalizeRatio(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > 1)
+        return fallback;
+    return value;
+}
+export function normalizeManualKeepRecentTokens(value, manualPolicy = DEFAULT_COMPACTION_POLICY.manual) {
+    return normalizeInteger(value, manualPolicy.keepRecentTokens, manualPolicy.minKeepRecentTokens, manualPolicy.maxKeepRecentTokens);
+}
+export function normalizeAgentDrivenOlderHistoryKeepRecentTokens(value, agentPolicy = DEFAULT_COMPACTION_POLICY.agentDriven) {
+    return normalizeInteger(value, agentPolicy.olderHistoryKeepRecentTokens, agentPolicy.olderHistoryMinKeepRecentTokens, agentPolicy.olderHistoryMaxKeepRecentTokens);
+}
+export function getAutoOlderHistoryContextThresholdTokens(policy, contextWindow) {
+    if (!policy.conversation.enabled || !policy.autoOlderHistory.enabled)
+        return null;
+    if (typeof contextWindow !== "number" || !Number.isFinite(contextWindow) || contextWindow <= 0)
+        return null;
+    return Math.max(1, Math.floor(contextWindow * policy.autoOlderHistory.contextLimitRatio));
+}
+function normalizeManualPolicy(settings) {
+    const defaults = DEFAULT_COMPACTION_POLICY.manual;
+    const manual = settings?.manual;
+    const minKeepRecentTokens = normalizePositiveInteger(manual?.minKeepRecentTokens, defaults.minKeepRecentTokens);
+    const maxKeepRecentTokens = Math.max(minKeepRecentTokens, normalizePositiveInteger(manual?.maxKeepRecentTokens, defaults.maxKeepRecentTokens));
+    const fallbackKeepRecentTokens = normalizeInteger(defaults.keepRecentTokens, defaults.keepRecentTokens, minKeepRecentTokens, maxKeepRecentTokens);
+    const keepRecentTokens = normalizeInteger(manual?.keepRecentTokens, fallbackKeepRecentTokens, minKeepRecentTokens, maxKeepRecentTokens);
+    return { keepRecentTokens, minKeepRecentTokens, maxKeepRecentTokens };
+}
+function normalizeAgentDrivenPolicy(settings) {
+    const defaults = DEFAULT_COMPACTION_POLICY.agentDriven;
+    const agentDriven = settings?.agentDriven;
+    const olderHistoryMinKeepRecentTokens = normalizePositiveInteger(agentDriven?.olderHistoryMinKeepRecentTokens, defaults.olderHistoryMinKeepRecentTokens);
+    const olderHistoryMaxKeepRecentTokens = Math.max(olderHistoryMinKeepRecentTokens, normalizePositiveInteger(agentDriven?.olderHistoryMaxKeepRecentTokens, defaults.olderHistoryMaxKeepRecentTokens));
+    const fallbackOlderHistoryKeepRecentTokens = normalizeInteger(defaults.olderHistoryKeepRecentTokens, defaults.olderHistoryKeepRecentTokens, olderHistoryMinKeepRecentTokens, olderHistoryMaxKeepRecentTokens);
+    return {
+        enabled: normalizeBoolean(agentDriven?.enabled, defaults.enabled),
+        cooldownTurns: normalizeNonNegativeInteger(agentDriven?.cooldownTurns, defaults.cooldownTurns),
+        minRawTokens: normalizeNonNegativeInteger(agentDriven?.minRawTokens, defaults.minRawTokens),
+        olderHistoryKeepRecentTokens: normalizeInteger(agentDriven?.olderHistoryKeepRecentTokens, fallbackOlderHistoryKeepRecentTokens, olderHistoryMinKeepRecentTokens, olderHistoryMaxKeepRecentTokens),
+        olderHistoryMinKeepRecentTokens,
+        olderHistoryMaxKeepRecentTokens,
+        olderHistoryMinCompactableTokens: normalizeNonNegativeInteger(agentDriven?.olderHistoryMinCompactableTokens, defaults.olderHistoryMinCompactableTokens),
+    };
+}
+function normalizeToolOutputCompressorPolicy(settings) {
+    const defaults = DEFAULT_COMPACTION_POLICY.toolOutputCompressor;
+    const compressor = settings?.toolOutputCompressor;
+    return {
+        enabled: normalizeBoolean(compressor?.enabled, defaults.enabled),
+        maxResultChars: normalizePositiveInteger(compressor?.maxResultChars, defaults.maxResultChars),
+        maxReadLines: normalizePositiveInteger(compressor?.maxReadLines, defaults.maxReadLines),
+        maxLsLines: normalizePositiveInteger(compressor?.maxLsLines, defaults.maxLsLines),
+        maxSearchLines: normalizePositiveInteger(compressor?.maxSearchLines, defaults.maxSearchLines),
+        stripAnsi: normalizeBoolean(compressor?.stripAnsi, defaults.stripAnsi),
+        stripComments: normalizeBoolean(compressor?.stripComments, defaults.stripComments),
+        testFailuresOnly: normalizeBoolean(compressor?.testFailuresOnly, defaults.testFailuresOnly),
+        compactGit: normalizeBoolean(compressor?.compactGit, defaults.compactGit),
+    };
+}
+export function normalizeCompactionPolicy(settings) {
+    const defaults = DEFAULT_COMPACTION_POLICY;
+    const conversation = {
+        enabled: normalizeBoolean(settings?.enabled, defaults.conversation.enabled),
+        reserveTokens: normalizePositiveInteger(settings?.reserveTokens, defaults.conversation.reserveTokens),
+        keepRecentTokens: normalizePositiveInteger(settings?.keepRecentTokens, defaults.conversation.keepRecentTokens),
+        contextLimitRatio: normalizeRatio(settings?.contextLimitRatio, defaults.conversation.contextLimitRatio),
+    };
+    const autoOlderHistory = settings?.autoOlderHistory;
+    const autoContextLimitRatioFallback = normalizeRatio(settings?.contextLimitRatio, defaults.autoOlderHistory.contextLimitRatio);
+    const autoPolicy = {
+        enabled: normalizeBoolean(autoOlderHistory?.enabled, conversation.enabled),
+        contextLimitRatio: normalizeRatio(autoOlderHistory?.contextLimitRatio, autoContextLimitRatioFallback),
+        keepRecentTokens: normalizePositiveInteger(autoOlderHistory?.keepRecentTokens, conversation.keepRecentTokens),
+        cooldownTurns: normalizeNonNegativeInteger(autoOlderHistory?.cooldownTurns, defaults.autoOlderHistory.cooldownTurns),
+        minRawTokens: normalizeNonNegativeInteger(autoOlderHistory?.minRawTokens, defaults.autoOlderHistory.minRawTokens),
+    };
+    const truncationContinuation = settings?.truncationContinuation;
+    return {
+        conversation,
+        manual: normalizeManualPolicy(settings),
+        autoOlderHistory: autoPolicy,
+        agentDriven: normalizeAgentDrivenPolicy(settings),
+        toolOutputCompressor: normalizeToolOutputCompressorPolicy(settings),
+        truncationContinuation: {
+            maxAttempts: normalizeNonNegativeInteger(truncationContinuation?.maxAttempts, defaults.truncationContinuation.maxAttempts),
+            totalOutputTokenBudget: normalizeNonNegativeInteger(truncationContinuation?.totalOutputTokenBudget, defaults.truncationContinuation.totalOutputTokenBudget),
+        },
+    };
+}

package/dist/sdk/coding-agent/core/extensions/native-extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-extensions.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/extensions/native-extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAAC;IAChD;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,cAAc,EAAE,OAAO,CAAC;IACxB,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,uBAAuB,EA8EtD,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAIjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC,CASD"}
+{"version":3,"file":"native-extensions.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/extensions/native-extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAAC;IAChD;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,cAAc,EAAE,OAAO,CAAC;IACxB,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,uBAAuB,EAuFtD,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAIjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC,CASD"}