@jetcrab/pi-desk-ctx 0.0.0-stage → 1.0.1-dev.9001

package/dist/context-history-tool.js

@@ -0,0 +1,90 @@
+import { Type } from 'typebox';
+export const HISTORY_TOOL_RESULT_NAME = 'history_tool_result';
+function findHistoricalToolMatch(entries, toolCallId) {
+    let toolName;
+    let result;
+    for (const entry of entries) {
+        if (entry.type !== 'message')
+            continue;
+        const message = entry.message;
+        if (message.role === 'assistant') {
+            for (const block of message.content) {
+                if (block.type === 'toolCall' && block.id === toolCallId) {
+                    toolName = block.name;
+                    break;
+                }
+            }
+            continue;
+        }
+        if (message.role === 'toolResult' && message.toolCallId === toolCallId) {
+            result = message;
+        }
+    }
+    if (toolName === undefined)
+        return undefined;
+    return { toolCallId, toolName, result };
+}
+function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return Number.isNaN(date.getTime()) ? String(timestamp) : date.toISOString();
+}
+function createHistoryHeader(ref, match, status) {
+    const timestamp = match.result ? `，timestamp=${formatTimestamp(match.result.timestamp)}` : '';
+    return `历史 ToolResult：ref=${ref}，tool=${match.toolName}，status=${status}${timestamp}。这是当时快照，不代表当前状态。`;
+}
+export function registerHistoryToolResult(pi, getToolReferences) {
+    pi.registerTool({
+        name: HISTORY_TOOL_RESULT_NAME,
+        label: 'History Tool Result',
+        description: '仅在确实需要当时原始结果时，按当前 compressed_tool_context 中的 ref 只读返回完整历史 ToolResult。该结果不是当前状态；需要最新结果时重新调用原工具。',
+        parameters: Type.Object({
+            ref: Type.Integer({
+                minimum: 1,
+                description: 'compressed_tool_context 记录中的历史工具引用序号'
+            })
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const historicalToolCallId = getToolReferences().get(params.ref);
+            if (historicalToolCallId === undefined) {
+                throw new Error(`当前模型上下文中不存在历史工具引用 ref=${params.ref}，请使用当前 compressed_tool_context 中的 ref。`);
+            }
+            const match = findHistoricalToolMatch(ctx.sessionManager.getBranch(), historicalToolCallId);
+            if (match === undefined) {
+                throw new Error(`历史工具引用 ref=${params.ref} 已不属于当前 Session 分支。`);
+            }
+            if (match.result === undefined) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: createHistoryHeader(params.ref, match, 'missing')
+                        }
+                    ],
+                    details: {
+                        ref: params.ref,
+                        toolCallId: match.toolCallId,
+                        toolName: match.toolName,
+                        historicalStatus: 'missing'
+                    }
+                };
+            }
+            const historicalStatus = match.result.isError ? 'error' : 'ok';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: createHistoryHeader(params.ref, match, historicalStatus)
+                    },
+                    ...match.result.content.map((block) => ({ ...block }))
+                ],
+                details: {
+                    ref: params.ref,
+                    toolCallId: match.toolCallId,
+                    toolName: match.toolName,
+                    historicalStatus,
+                    timestamp: match.result.timestamp
+                }
+            };
+        }
+    });
+}

package/dist/context-settings-store.d.ts

@@ -0,0 +1,4 @@
+import { type ContextIgnoreSettings } from './context-settings.js';
+export declare function defaultContextIgnoreSettingsPath(): string;
+export declare function readContextIgnoreSettings(path?: string): Promise<ContextIgnoreSettings>;
+export declare function writeContextIgnoreSettings(value: unknown, path?: string): Promise<ContextIgnoreSettings>;

package/dist/context-settings-store.js

@@ -0,0 +1,51 @@
+import { randomBytes } from 'node:crypto';
+import { copyFileSync, existsSync } from 'node:fs';
+import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getAgentDir } from '@earendil-works/pi-coding-agent';
+import { defaultContextIgnoreSettings, parseContextIgnoreSettings } from './context-settings.js';
+const MAX_CONFIG_BYTES = 128 * 1024;
+export function defaultContextIgnoreSettingsPath() {
+    const agentDir = getAgentDir();
+    const path = join(agentDir, 'pi-desk-ctx.json');
+    const previous = join(agentDir, 'pi-super-ctx.json');
+    if (!existsSync(path) && existsSync(previous))
+        copyFileSync(previous, path);
+    return path;
+}
+export async function readContextIgnoreSettings(path = defaultContextIgnoreSettingsPath()) {
+    try {
+        const metadata = await lstat(path);
+        if (!metadata.isFile())
+            throw new Error('上下文忽略配置必须是普通文件');
+        if (metadata.size > MAX_CONFIG_BYTES) {
+            throw new Error(`上下文忽略配置不能超过 ${Math.round(MAX_CONFIG_BYTES / 1024)}KB`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return defaultContextIgnoreSettings();
+        throw error;
+    }
+    let value;
+    try {
+        value = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`读取上下文忽略配置失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseContextIgnoreSettings(value);
+}
+export async function writeContextIgnoreSettings(value, path = defaultContextIgnoreSettingsPath()) {
+    const settings = parseContextIgnoreSettings(value);
+    const temporaryPath = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+    await mkdir(dirname(path), { recursive: true });
+    try {
+        await writeFile(temporaryPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+        await rename(temporaryPath, path);
+    }
+    finally {
+        await rm(temporaryPath, { force: true });
+    }
+    return settings;
+}

package/dist/context-settings.d.ts

@@ -0,0 +1,23 @@
+export interface ContextIgnoreRule {
+    currentTokensAtLeast?: number;
+    projectedTokensAtMost?: number;
+}
+export interface ContextIgnoreProfile {
+    /** Undefined is the lowest-priority fallback for any model context window. */
+    maxContextTokens?: number;
+    checkpointTokens?: number;
+    keepRecentUserTurns: number;
+    processTokenBudget: number;
+    rules: ContextIgnoreRule[];
+}
+export interface ContextIgnoreSettings {
+    enabled: boolean;
+    profiles: ContextIgnoreProfile[];
+}
+export declare const RECOMMENDED_CONTEXT_IGNORE_SETTINGS: ContextIgnoreSettings;
+export declare function normalizeContextIgnoreSettings(settings: ContextIgnoreSettings): ContextIgnoreSettings;
+export declare function parseContextIgnoreSettings(value: unknown): ContextIgnoreSettings;
+export declare function defaultContextIgnoreSettings(): ContextIgnoreSettings;
+export declare function selectContextIgnoreProfile(settings: ContextIgnoreSettings, contextWindow: number): ContextIgnoreProfile;
+export declare function matchesContextIgnoreRule(rule: ContextIgnoreRule, currentTokens: number, projectedTokens: number): boolean;
+export declare function findMatchingContextIgnoreRule(rules: readonly ContextIgnoreRule[], currentTokens: number, projectedTokens: number): number | undefined;

package/dist/context-settings.js

@@ -0,0 +1,146 @@
+export const RECOMMENDED_CONTEXT_IGNORE_SETTINGS = {
+    enabled: true,
+    profiles: [
+        {
+            maxContextTokens: 400_000,
+            checkpointTokens: 320_000,
+            keepRecentUserTurns: 3,
+            processTokenBudget: 30_000,
+            rules: [{ currentTokensAtLeast: 280_000, projectedTokensAtMost: 50_000 }]
+        },
+        {
+            maxContextTokens: 600_000,
+            checkpointTokens: 480_000,
+            keepRecentUserTurns: 3,
+            processTokenBudget: 40_000,
+            rules: [
+                { currentTokensAtLeast: 400_000, projectedTokensAtMost: 50_000 },
+                { currentTokensAtLeast: 500_000, projectedTokensAtMost: 100_000 }
+            ]
+        },
+        {
+            checkpointTokens: 800_000,
+            keepRecentUserTurns: 3,
+            processTokenBudget: 40_000,
+            rules: [{ currentTokensAtLeast: 800_000, projectedTokensAtMost: 150_000 }]
+        }
+    ]
+};
+const MAX_PROFILES = 20;
+const MAX_RULES_PER_PROFILE = 50;
+const MAX_TOKEN_VALUE = 100_000_000;
+const MAX_KEEP_TURNS = 100;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function requiredInteger(value, field, minimum, maximum) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`${field} 必须是 ${minimum} 到 ${maximum} 的整数`);
+    }
+    return value;
+}
+function optionalToken(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    return requiredInteger(value, field, 0, MAX_TOKEN_VALUE);
+}
+function parseRule(value, path) {
+    if (!isRecord(value))
+        throw new Error(`${path} 必须是对象`);
+    const currentTokensAtLeast = optionalToken(value.currentTokensAtLeast, `${path}.currentTokensAtLeast`);
+    const projectedTokensAtMost = optionalToken(value.projectedTokensAtMost, `${path}.projectedTokensAtMost`);
+    if (currentTokensAtLeast === undefined && projectedTokensAtMost === undefined) {
+        throw new Error(`${path} 至少需要一个判断条件`);
+    }
+    return {
+        ...(currentTokensAtLeast === undefined ? {} : { currentTokensAtLeast }),
+        ...(projectedTokensAtMost === undefined ? {} : { projectedTokensAtMost })
+    };
+}
+function parseProfile(value, index) {
+    const path = `profiles.${index}`;
+    if (!isRecord(value))
+        throw new Error(`${path} 必须是对象`);
+    const maxContextTokens = optionalToken(value.maxContextTokens, `${path}.maxContextTokens`);
+    if (maxContextTokens !== undefined && maxContextTokens === 0) {
+        throw new Error(`${path}.maxContextTokens 必须大于 0`);
+    }
+    const checkpointTokens = optionalToken(value.checkpointTokens, `${path}.checkpointTokens`);
+    if (checkpointTokens !== undefined && checkpointTokens === 0) {
+        throw new Error(`${path}.checkpointTokens 必须大于 0`);
+    }
+    const keepRecentUserTurns = requiredInteger(value.keepRecentUserTurns, `${path}.keepRecentUserTurns`, 1, MAX_KEEP_TURNS);
+    const processTokenBudget = requiredInteger(value.processTokenBudget, `${path}.processTokenBudget`, 0, MAX_TOKEN_VALUE);
+    if (!Array.isArray(value.rules) || value.rules.length > MAX_RULES_PER_PROFILE) {
+        throw new Error(`${path}.rules 必须是最多 ${MAX_RULES_PER_PROFILE} 条规则的数组`);
+    }
+    return {
+        ...(maxContextTokens === undefined ? {} : { maxContextTokens }),
+        ...(checkpointTokens === undefined ? {} : { checkpointTokens }),
+        keepRecentUserTurns,
+        processTokenBudget,
+        rules: value.rules.map((rule, ruleIndex) => parseRule(rule, `${path}.rules.${ruleIndex}`))
+    };
+}
+export function normalizeContextIgnoreSettings(settings) {
+    const profiles = settings.profiles
+        .map((profile) => ({
+        ...(profile.maxContextTokens === undefined
+            ? {}
+            : { maxContextTokens: profile.maxContextTokens }),
+        ...(profile.checkpointTokens === undefined
+            ? {}
+            : { checkpointTokens: profile.checkpointTokens }),
+        keepRecentUserTurns: profile.keepRecentUserTurns,
+        processTokenBudget: profile.processTokenBudget,
+        rules: profile.rules.map((rule) => ({ ...rule }))
+    }))
+        .sort((left, right) => {
+        if (left.maxContextTokens === undefined)
+            return 1;
+        if (right.maxContextTokens === undefined)
+            return -1;
+        return left.maxContextTokens - right.maxContextTokens;
+    });
+    return { enabled: settings.enabled, profiles };
+}
+export function parseContextIgnoreSettings(value) {
+    if (!isRecord(value))
+        throw new Error('上下文忽略配置必须是对象');
+    if (typeof value.enabled !== 'boolean')
+        throw new Error('enabled 必须是布尔值');
+    if (!Array.isArray(value.profiles) ||
+        value.profiles.length === 0 ||
+        value.profiles.length > MAX_PROFILES) {
+        throw new Error(`profiles 必须包含 1 到 ${MAX_PROFILES} 个模型配置`);
+    }
+    const profiles = value.profiles.map(parseProfile);
+    const fallbackCount = profiles.filter((profile) => profile.maxContextTokens === undefined).length;
+    if (fallbackCount !== 1)
+        throw new Error('必须且只能有一个不限制模型窗口的通用配置');
+    const boundedLimits = profiles
+        .map((profile) => profile.maxContextTokens)
+        .filter((limit) => limit !== undefined);
+    if (new Set(boundedLimits).size !== boundedLimits.length) {
+        throw new Error('模型窗口上限不能重复');
+    }
+    return normalizeContextIgnoreSettings({ enabled: value.enabled, profiles });
+}
+export function defaultContextIgnoreSettings() {
+    return normalizeContextIgnoreSettings(RECOMMENDED_CONTEXT_IGNORE_SETTINGS);
+}
+export function selectContextIgnoreProfile(settings, contextWindow) {
+    const normalized = normalizeContextIgnoreSettings(settings);
+    const fallback = normalized.profiles.find((profile) => profile.maxContextTokens === undefined);
+    if (contextWindow <= 0)
+        return fallback;
+    return (normalized.profiles.find((profile) => profile.maxContextTokens === undefined || contextWindow <= profile.maxContextTokens) ?? fallback);
+}
+export function matchesContextIgnoreRule(rule, currentTokens, projectedTokens) {
+    return ((rule.currentTokensAtLeast === undefined || currentTokens >= rule.currentTokensAtLeast) &&
+        (rule.projectedTokensAtMost === undefined || projectedTokens <= rule.projectedTokensAtMost));
+}
+export function findMatchingContextIgnoreRule(rules, currentTokens, projectedTokens) {
+    const index = rules.findIndex((rule) => matchesContextIgnoreRule(rule, currentTokens, projectedTokens));
+    return index < 0 ? undefined : index;
+}

package/dist/context-skill-path.d.ts

@@ -0,0 +1,17 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { ToolCall } from '@earendil-works/pi-ai';
+export interface ContextIgnoreTransformOptions {
+    cwd?: string;
+    /** Pi 已发现的目录型 Skill 根目录。 */
+    skillBaseDirs?: string[];
+    /** Pi 已发现的根目录直放 Markdown Skill 文件。 */
+    skillFilePaths?: string[];
+    /** 从完整会话投影到压缩切片的严格消息身份。 */
+    ignoredMessages?: WeakSet<AgentMessage>;
+}
+/**
+ * Uses Pi's discovered Skill roots for active sessions. Restored sessions can only
+ * recover a root when their own read result proves that SKILL.md was a valid skill.
+ */
+export declare function getSkillBaseDirs(messages: AgentMessage[], options?: ContextIgnoreTransformOptions): string[];
+export declare function isSkillContentRead(toolCall: ToolCall, skillBaseDirs: string[], options?: ContextIgnoreTransformOptions): boolean;

package/dist/context-skill-path.js

@@ -0,0 +1,64 @@
+import { basename, dirname, relative, resolve, sep } from 'node:path';
+function normalizePath(path) {
+    const normalized = resolve(path).replace(/[\\/]+$/, '');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function resolveReadPath(path, cwd) {
+    return resolve(cwd, path.startsWith('@') ? path.slice(1) : path);
+}
+function isWithinPath(path, root) {
+    const pathRelative = relative(normalizePath(root), normalizePath(path));
+    return (pathRelative === '' || (!pathRelative.startsWith('..') && !pathRelative.includes(`..${sep}`)));
+}
+function getReadPath(toolCall, cwd) {
+    if (toolCall.name !== 'read')
+        return undefined;
+    const path = toolCall.arguments.path;
+    return typeof path === 'string' && path.trim() ? resolveReadPath(path, cwd) : undefined;
+}
+function isSkillDefinitionResult(result) {
+    if (result === undefined || result.isError)
+        return false;
+    const text = result.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n');
+    return /^---\s*$/m.test(text) && /^name:\s*\S+/m.test(text) && /^description:\s*\S+/m.test(text);
+}
+/**
+ * Uses Pi's discovered Skill roots for active sessions. Restored sessions can only
+ * recover a root when their own read result proves that SKILL.md was a valid skill.
+ */
+export function getSkillBaseDirs(messages, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const roots = new Set((options.skillBaseDirs ?? []).map(normalizePath));
+    const toolResults = new Map();
+    for (const message of messages) {
+        if (message.role === 'toolResult')
+            toolResults.set(message.toolCallId, message);
+    }
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            continue;
+        for (const block of message.content) {
+            if (block.type !== 'toolCall')
+                continue;
+            const path = getReadPath(block, cwd);
+            if (path !== undefined &&
+                basename(path).toLowerCase() === 'skill.md' &&
+                isSkillDefinitionResult(toolResults.get(block.id))) {
+                roots.add(normalizePath(dirname(path)));
+            }
+        }
+    }
+    return [...roots];
+}
+export function isSkillContentRead(toolCall, skillBaseDirs, options = {}) {
+    const path = getReadPath(toolCall, options.cwd ?? process.cwd());
+    if (path === undefined)
+        return false;
+    if ((options.skillFilePaths ?? []).some((filePath) => normalizePath(filePath) === normalizePath(path))) {
+        return true;
+    }
+    return skillBaseDirs.some((root) => isWithinPath(path, root));
+}

package/dist/context-state.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { type ContextIgnoreState } from './types.js';
+export declare function defaultContextIgnoreState(): ContextIgnoreState;
+export declare function loadContextIgnoreState(sessionManager: ExtensionContext['sessionManager']): ContextIgnoreState;
+export declare function persistContextIgnoreState(pi: ExtensionAPI, state: ContextIgnoreState): void;

package/dist/context-state.js

@@ -0,0 +1,104 @@
+import { CONTEXT_IGNORE_ENTRY_TYPE, DEFAULT_KEEP_TURNS } from './types.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function parseState(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.enabled !== 'boolean')
+        return undefined;
+    if (typeof value.keepTurns !== 'number')
+        return undefined;
+    if (typeof value.updatedAt !== 'number')
+        return undefined;
+    if (value.mode !== undefined &&
+        value.mode !== 'user-turns' &&
+        value.mode !== 'internal-turns' &&
+        value.mode !== 'combined') {
+        return undefined;
+    }
+    if (value.cutoffTimestamp !== undefined && typeof value.cutoffTimestamp !== 'number') {
+        return undefined;
+    }
+    if (value.internalTurnCutoffs !== undefined &&
+        (!Array.isArray(value.internalTurnCutoffs) ||
+            value.internalTurnCutoffs.some((cutoff) => !isRecord(cutoff) ||
+                typeof cutoff.cutoffTimestamp !== 'number' ||
+                (cutoff.userTimestamp !== undefined && typeof cutoff.userTimestamp !== 'number')))) {
+        return undefined;
+    }
+    if (value.internalTurnCutoffTimestamp !== undefined &&
+        typeof value.internalTurnCutoffTimestamp !== 'number') {
+        return undefined;
+    }
+    if (value.internalTurnUserTimestamp !== undefined &&
+        typeof value.internalTurnUserTimestamp !== 'number') {
+        return undefined;
+    }
+    if (value.pendingUsageRefreshAfterTimestamp !== undefined &&
+        typeof value.pendingUsageRefreshAfterTimestamp !== 'number') {
+        return undefined;
+    }
+    if (value.estimatedContextTokens !== undefined &&
+        typeof value.estimatedContextTokens !== 'number') {
+        return undefined;
+    }
+    if (value.skillBaseDirs !== undefined &&
+        (!Array.isArray(value.skillBaseDirs) ||
+            value.skillBaseDirs.some((path) => typeof path !== 'string'))) {
+        return undefined;
+    }
+    if (value.skillFilePaths !== undefined &&
+        (!Array.isArray(value.skillFilePaths) ||
+            value.skillFilePaths.some((path) => typeof path !== 'string'))) {
+        return undefined;
+    }
+    if (value.keepInternalTurns !== undefined && typeof value.keepInternalTurns !== 'number') {
+        return undefined;
+    }
+    const legacyInternalCutoff = value.internalTurnCutoffTimestamp ??
+        (value.mode === 'internal-turns' ? value.cutoffTimestamp : undefined);
+    const internalTurnCutoffs = value.internalTurnCutoffs ??
+        (legacyInternalCutoff === undefined
+            ? undefined
+            : [{ cutoffTimestamp: legacyInternalCutoff, userTimestamp: value.internalTurnUserTimestamp }]);
+    return {
+        enabled: value.enabled,
+        mode: value.mode ?? 'user-turns',
+        cutoffTimestamp: value.mode === 'internal-turns' ? undefined : value.cutoffTimestamp,
+        internalTurnCutoffs,
+        pendingUsageRefreshAfterTimestamp: value.pendingUsageRefreshAfterTimestamp,
+        estimatedContextTokens: value.estimatedContextTokens === undefined
+            ? undefined
+            : Math.max(0, value.estimatedContextTokens),
+        skillBaseDirs: value.skillBaseDirs,
+        skillFilePaths: value.skillFilePaths,
+        keepTurns: Math.max(1, Math.floor(value.keepTurns)),
+        updatedAt: value.updatedAt
+    };
+}
+export function defaultContextIgnoreState() {
+    return {
+        enabled: false,
+        mode: 'user-turns',
+        keepTurns: DEFAULT_KEEP_TURNS,
+        updatedAt: Date.now()
+    };
+}
+export function loadContextIgnoreState(sessionManager) {
+    const state = defaultContextIgnoreState();
+    const branch = sessionManager.getBranch();
+    for (let index = branch.length - 1; index >= 0; index -= 1) {
+        const entry = branch[index];
+        if (entry.type !== 'custom' || entry.customType !== CONTEXT_IGNORE_ENTRY_TYPE) {
+            continue;
+        }
+        const parsed = parseState(entry.data);
+        if (parsed)
+            return parsed;
+    }
+    return state;
+}
+export function persistContextIgnoreState(pi, state) {
+    pi.appendEntry(CONTEXT_IGNORE_ENTRY_TYPE, state);
+}

package/dist/context-token-estimate.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCall } from '@earendil-works/pi-ai';
+export declare function estimateContextTextTokens(text: string): number;
+export declare function estimateThinkingBlockTokens(block: {
+    thinking: string;
+}): number;
+export declare function estimateReasoningReplayTokens(block: {
+    thinkingSignature?: string;
+}): number;
+export declare function estimateToolCallTokens(toolCall: Pick<ToolCall, 'name' | 'arguments'>): number;

package/dist/context-token-estimate.js

@@ -0,0 +1,14 @@
+const CHARS_PER_ESTIMATED_TOKEN = 4;
+export function estimateContextTextTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_ESTIMATED_TOKEN);
+}
+export function estimateThinkingBlockTokens(block) {
+    return estimateContextTextTokens(block.thinking);
+}
+export function estimateReasoningReplayTokens(block) {
+    return estimateContextTextTokens(block.thinkingSignature ?? '');
+}
+export function estimateToolCallTokens(toolCall) {
+    const serializedArguments = JSON.stringify(toolCall.arguments) ?? '';
+    return estimateContextTextTokens(toolCall.name + serializedArguments);
+}

package/dist/context-transform.d.ts

@@ -0,0 +1,24 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { ToolCall, ToolResultMessage } from '@earendil-works/pi-ai';
+import { type ContextIgnoreTransformOptions } from './context-skill-path.js';
+import type { ContextIgnoreState } from './types.js';
+export declare const COMPRESSED_TOOL_CONTEXT_TAG = "compressed_tool_context";
+export declare const COMPRESSED_TOOL_CONTEXT_CUSTOM_TYPE = "context-ignore-compressed-tools";
+export type CompressedToolStatus = 'ok' | 'error' | 'missing';
+export interface CompressedToolRecord {
+    ref: number;
+    name: string;
+    arguments: ToolCall['arguments'];
+    status: CompressedToolStatus;
+}
+export declare function createCompressedToolRecord(ref: number, toolCall: ToolCall, result: ToolResultMessage | undefined): CompressedToolRecord;
+export declare function createToolSummaryText(records: CompressedToolRecord[]): string;
+/** Returns message indexes whose process details are replaced by the current ignore boundaries. */
+export declare function getIgnoredMessageIndexes(messages: AgentMessage[], state: ContextIgnoreState, ignoredMessages?: WeakSet<AgentMessage>): Set<number>;
+/** Captures full-session ignore decisions for strict projection onto compaction slices. */
+export declare function getIgnoredMessageReferences(messages: AgentMessage[], state: ContextIgnoreState): WeakSet<AgentMessage>;
+export interface TransformResult {
+    messages: AgentMessage[];
+    toolReferences: Map<number, string>;
+}
+export declare function transformContextMessages(messages: AgentMessage[], state: ContextIgnoreState, options?: ContextIgnoreTransformOptions): TransformResult;