npm - @xopcai/xopc - Versions diffs - 0.0.170 → 0.0.172 - Mend

@xopcai/xopc 0.0.170 → 0.0.172

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (242) hide show

package/dist/gateway/static/root/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png?v=20260713-1" />
     <link rel="manifest" href="/site.webmanifest?v=20260713-1" />
     <title>XOPC — Turn goals into loops. Keep what matters moving.</title>
-    <script type="module" crossorigin src="/assets/index-Dfq2laZe.js"></script>
+    <script type="module" crossorigin src="/assets/index-DUasAutC.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-aKtaBQYM.js">
     <link rel="modulepreload" crossorigin href="/assets/preload-helper-zJ_50EbN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BOUWij0V.js">
@@ -24,17 +24,17 @@
     <link rel="modulepreload" crossorigin href="/assets/check-DUBLcKHA.js">
     <link rel="modulepreload" crossorigin href="/assets/circle-alert-BEjgurr2.js">
     <link rel="modulepreload" crossorigin href="/assets/middleware-Pd0e8Igk.js">
-    <link rel="modulepreload" crossorigin href="/assets/messages-KEk-hTFt.js">
-    <link rel="modulepreload" crossorigin href="/assets/locale-store-Dqp9H2Uf.js">
+    <link rel="modulepreload" crossorigin href="/assets/messages-BWtP5TFz.js">
+    <link rel="modulepreload" crossorigin href="/assets/locale-store-BP0vD37A.js">
     <link rel="modulepreload" crossorigin href="/assets/cn-JdwAhgNB.js">
     <link rel="modulepreload" crossorigin href="/assets/schemas-DgQq6Z5S.js">
     <link rel="modulepreload" crossorigin href="/assets/product-delivery-BTRT9kCS.js">
     <link rel="modulepreload" crossorigin href="/assets/config-reload-event-Bjh2zoKp.js">
     <link rel="modulepreload" crossorigin href="/assets/copy-to-clipboard-HOJ79TWv.js">
-    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-CXITih5d.js">
-    <link rel="modulepreload" crossorigin href="/assets/activity-store-CkUp1qvf.js">
-    <link rel="modulepreload" crossorigin href="/assets/theme-store-BiC0gIBa.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-o4uaOGKT.css">
+    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-D3USVm9D.js">
+    <link rel="modulepreload" crossorigin href="/assets/activity-store-C3Y-bESI.js">
+    <link rel="modulepreload" crossorigin href="/assets/theme-store-C3KnnjcU.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-C_XSKOH6.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js CHANGED Viewed

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.170";
+var version = "0.0.172";
 //#endregion
 export { version };

package/dist/src/agent/embedded/run-for-session.js CHANGED Viewed

@@ -2,6 +2,8 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
+import { evaluateContextBudget } from "../memory/context-budget.js";
+import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { runXopcEmbeddedTurn } from "./run-turn.js";
 import { applyStartupContextToUserMessage } from "../reply/apply-turn-user-enrichment.js";
 import { mergeTurnTools, resolveEmbeddedMcpToolsForTurn } from "../mcp/resolve-embedded-mcp-tools.js";
@@ -46,14 +48,6 @@ async function runEmbeddedTurnForSession(params) {
 	const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
 	const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);
 	const config = params.getConfig?.();
-	await maybeAutoCompactBeforeTurn({
-		sessionKey,
-		sessionStore,
-		agentManager,
-		model,
-		config,
-		onEvent: params.onEvent
-	});
 	let userMessageForTurn = userMessage;
 	if (params.applyStartupContext !== false) userMessageForTurn = await applyStartupContextToUserMessage({
 		userMessage,
@@ -74,6 +68,20 @@ async function runEmbeddedTurnForSession(params) {
 		});
 		const turnTools = mergeTurnTools(tools, mcpResolved.tools);
 		try {
+			await maybeAutoCompactBeforeTurn({
+				sessionKey,
+				sessionStore,
+				agentManager,
+				model,
+				config,
+				systemPrompt,
+				userMessage: userMessageForTurn,
+				tools: turnTools,
+				imageCount: params.llmImages?.length ?? 0,
+				fallbackModels: resolvedCandidates.slice(1).map((candidate) => candidate.model),
+				abortSignal: params.abortSignal,
+				onEvent: params.onEvent
+			});
 			log.info({
 				sessionKey,
 				runId,
@@ -167,28 +175,61 @@ async function runEmbeddedTurnForSession(params) {
 		}
 	})();
 }
+function serializedTranscriptBytes(messages) {
+	return Buffer.byteLength(JSON.stringify(messages), "utf8");
+}
 async function maybeAutoCompactBeforeTurn(opts) {
-	const { sessionKey, sessionStore, agentManager, model, config, onEvent } = opts;
-	if (config) try {
-		if (config.userContext.memory.retention?.compaction === false) return;
-	} catch {}
+	const { sessionKey, sessionStore, agentManager, model, config, systemPrompt, userMessage, tools, imageCount, fallbackModels, abortSignal, onEvent } = opts;
+	const policy = resolveCompactionPolicy(config);
 	const contextWindow = model.contextWindow ?? 128e3;
 	const messages = await sessionStore.load(sessionKey);
-	const prep = sessionStore.prepareCompaction(sessionKey, messages, contextWindow);
-	if (!prep.needsCompaction) return;
+	const activeTranscriptBytes = serializedTranscriptBytes(messages);
+	const byteLimitExceeded = policy.enabled && activeTranscriptBytes > policy.maxActiveTranscriptBytes;
+	const budget = evaluateContextBudget({
+		messages,
+		contextWindow,
+		systemPrompt,
+		currentUserMessage: userMessage,
+		tools,
+		imageCount,
+		triggerThreshold: policy.triggerThreshold,
+		reserveTokens: policy.reserveTokens,
+		minToolResultKeepChars: policy.minToolResultKeepChars,
+		canCompact: messages.length >= policy.minMessagesBeforeCompact
+	});
+	if (!byteLimitExceeded && (budget.route === "fits" || budget.route === "truncate_tool_results_only")) return;
+	if (!policy.enabled) {
+		if (budget.estimatedTokens <= budget.hardLimitTokens) return;
+		if (budget.estimatedTokens - budget.reducibleToolResultTokens <= budget.hardLimitTokens) return;
+		throw new Error(`Context budget exceeded (${budget.estimatedTokens}/${budget.hardLimitTokens} tokens) and compaction is disabled`);
+	}
 	log.info({
 		sessionKey,
-		reason: prep.stats?.reason,
-		usagePercent: prep.stats?.usagePercent,
-		contextWindow
+		route: budget.route,
+		estimatedTokens: budget.estimatedTokens,
+		usagePercent: budget.usagePercent,
+		contextWindow,
+		activeTranscriptBytes,
+		maxActiveTranscriptBytes: policy.maxActiveTranscriptBytes,
+		byteLimitExceeded
 	}, "Pre-turn auto-compaction triggered");
 	onEvent?.({
 		type: "compaction",
 		status: "started",
-		tokensBefore: prep.stats?.usagePercent != null ? Math.round(prep.stats.usagePercent * contextWindow) : void 0
+		tokensBefore: budget.estimatedTokens
 	});
 	try {
-		const result = await sessionStore.compact(sessionKey, messages, contextWindow);
+		let summaryModel = model;
+		let summaryFallbackModels = fallbackModels;
+		if (policy.model) {
+			summaryModel = resolveModel(policy.model);
+			const summaryRef = `${summaryModel.provider}/${summaryModel.id}`;
+			summaryFallbackModels = [model, ...fallbackModels].filter((candidate) => `${candidate.provider}/${candidate.id}` !== summaryRef);
+		}
+		const result = await sessionStore.compact(sessionKey, messages, summaryModel, void 0, byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens, {
+			fallbackModels: summaryFallbackModels,
+			signal: abortSignal
+		});
 		if (result.compacted) {
 			agentManager.removeAgent(sessionKey);
 			log.info({
@@ -203,20 +244,26 @@ async function maybeAutoCompactBeforeTurn(opts) {
 				tokensAfter: result.tokensAfter,
 				summary: result.summary.length > 200 ? `${result.summary.slice(0, 200)}…` : result.summary
 			});
-		} else onEvent?.({
-			type: "compaction",
-			status: "skipped"
-		});
+		} else {
+			if (byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens) throw new Error(byteLimitExceeded ? `Active transcript size exceeded (${activeTranscriptBytes}/${policy.maxActiveTranscriptBytes} bytes) but no safe compaction range was available` : `Context budget exceeded (${budget.estimatedTokens}/${budget.hardLimitTokens} tokens) but no safe compaction range was available`);
+			onEvent?.({
+				type: "compaction",
+				status: "skipped"
+			});
+		}
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		log.warn({
 			err,
-			sessionKey
+			sessionKey,
+			estimatedTokens: budget.estimatedTokens,
+			activeTranscriptBytes
 		}, `Pre-turn auto-compaction failed: ${errorMessage}`);
 		onEvent?.({
 			type: "compaction",
 			status: "skipped"
 		});
+		if (byteLimitExceeded || budget.estimatedTokens > budget.hardLimitTokens) throw err;
 	}
 }
 //#endregion

package/dist/src/agent/embedded/run-turn.js CHANGED Viewed

@@ -3,11 +3,13 @@ import { init_logger } from "../../utils/logger.js";
 import { resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
 import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { acquireEmbeddedSessionRunner, resolveEmbeddedTranscriptInputs } from "./session-runner.js";
-import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure } from "../orchestration/llm-turn-retry.js";
+import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
+import { pruneToolResultsToFit } from "../memory/context-budget.js";
 import { abortEmbeddedRun, queueEmbeddedSteer, registerEmbeddedRun, unregisterEmbeddedRun } from "./runs.js";
 import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
 import { detectToolLoops } from "../orchestration/loop-guard.js";
 import { tryApplySessionTranscriptHygiene } from "../transcript/transcript-hygiene.js";
+import { isContextOverflowError } from "../orchestration/context-overflow.js";
 //#region src/agent/embedded/run-turn.ts
 init_logger();
 const log = createLogger("EmbeddedRun");
@@ -23,6 +25,13 @@ function extractTextFromContent(content) {
 	}).map((block) => block.text).join("");
 }
 function extractRecentToolCalls(messages) {
+	const resultByToolCallId = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "toolResult") continue;
+		const toolCallId = message.toolCallId;
+		if (typeof toolCallId !== "string" || !toolCallId) continue;
+		resultByToolCallId.set(toolCallId, truncateForLog(extractTextFromContent(message.content)));
+	}
 	const calls = [];
 	for (const message of messages) {
 		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
@@ -30,7 +39,8 @@ function extractRecentToolCalls(messages) {
 			const toolCall = block;
 			calls.push({
 				name: toolCall.name,
-				params: toolCall.arguments
+				params: toolCall.arguments,
+				...toolCall.id && resultByToolCallId.has(toolCall.id) ? { resultPreview: resultByToolCallId.get(toolCall.id) } : {}
 			});
 		}
 	}
@@ -56,6 +66,33 @@ function userMessageToPromptText(message) {
 	}).map((block) => block.text).join("");
 	return "";
 }
+async function maybeRecoverContextOverflow(params) {
+	const errorMessage = getAssistantTurnErrorMessage(params.agent);
+	if (!errorMessage || !isContextOverflowError(errorMessage)) return false;
+	const messages = stripTrailingErrorAssistantMessages(params.agent.state.messages);
+	log.warn({
+		sessionKey: params.sessionKey,
+		errorMessage,
+		messageCount: messages.length
+	}, "Provider rejected the context window; compacting and retrying the same turn");
+	params.onEvent?.({
+		type: "compaction",
+		status: "started"
+	});
+	const result = await params.sessionStore.compact(params.sessionKey, messages, params.model, "Preserve the current pending user request verbatim and retain every fact needed to answer it.", true);
+	if (!result.compacted) throw new Error(`Context overflow recovery could not find a safe compaction range: ${errorMessage}`);
+	params.agent.state.messages = await params.sessionStore.load(params.sessionKey);
+	params.onEvent?.({
+		type: "compaction",
+		status: "completed",
+		tokensBefore: result.tokensBefore,
+		tokensAfter: result.tokensAfter,
+		summary: result.summary.length > 200 ? `${result.summary.slice(0, 200)}…` : result.summary
+	});
+	await params.agent.continue();
+	await params.agent.waitForIdle();
+	return true;
+}
 async function runXopcEmbeddedTurn(params) {
 	const { sessionKey, runId, userMessage, model, tools, systemPrompt, thinkingLevel, workspaceDir, sessionStore, onEvent } = params;
 	const timeoutMs = params.timeoutMs || resolveAgentTurnTimeoutMs();
@@ -85,11 +122,11 @@ async function runXopcEmbeddedTurn(params) {
 				messages: hygienicMessages
 			};
 			if (loopGuard.injection || loopGuard.hiddenTools.size > 0) {
-				const messages = loopGuard.injection ? [...context.messages, {
+				const messages = loopGuard.injection ? [...hygienicMessages, {
 					role: "user",
 					content: loopGuard.injection,
 					timestamp: Date.now()
-				}] : context.messages;
+				}] : hygienicMessages;
 				const contextTools = loopGuard.hiddenTools.size > 0 && context.tools ? context.tools.filter((t) => !loopGuard.hiddenTools.has(t.name)) : context.tools;
 				effectiveContext = {
 					...context,
@@ -97,6 +134,26 @@ async function runXopcEmbeddedTurn(params) {
 					tools: contextTools
 				};
 			}
+			const pruned = pruneToolResultsToFit({
+				messages: effectiveContext.messages,
+				contextWindow: streamModel.contextWindow ?? 128e3,
+				systemPrompt: effectiveContext.systemPrompt,
+				tools: effectiveContext.tools,
+				canCompact: false
+			});
+			if (pruned.prunedToolResults > 0) {
+				effectiveContext = {
+					...effectiveContext,
+					messages: pruned.messages
+				};
+				log.warn({
+					sessionKey,
+					runId,
+					prunedToolResults: pruned.prunedToolResults,
+					estimatedTokens: pruned.evaluation.estimatedTokens,
+					hardLimitTokens: pruned.evaluation.hardLimitTokens
+				}, "Pruned old tool results to fit the model context window");
+			}
 			log.debug({
 				sessionKey,
 				runId,
@@ -157,6 +214,13 @@ async function runXopcEmbeddedTurn(params) {
 					sessionKey,
 					log
 				});
+				await maybeRecoverContextOverflow({
+					agent: session.agent,
+					model: resolvedModel,
+					sessionKey,
+					sessionStore,
+					onEvent
+				});
 			}, timeoutMs);
 			if (isAssistantTurnAborted(session.agent)) return {
 				ok: true,

package/dist/src/agent/inbound/inbound-loop.d.ts CHANGED Viewed

@@ -13,7 +13,6 @@
  * dependencies are injected so this class is unit-testable and the inbound
  * pipeline can evolve without touching `AgentService`.
  */
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { MessageBus } from '../../infra/bus/index.js';
 import type { Config } from '../../config/schema.js';
 import type { ChannelManager } from '../../channels/manager.js';
@@ -52,7 +51,6 @@ export interface InboundLoopConfig {
     /** Returns the visible last assistant text used for outbound + persistent-goal hook. */
     getLastAssistantPlainText: (sessionKey: string) => string;
     /** Pre-turn auto-compaction (only used by system messages). */
-    checkAndCompact: (sessionKey: string, messages: AgentMessage[]) => Promise<void>;
     /** Fire-and-forget auto-title (no-ops for cron/heartbeat keys). */
     enqueueMaybeAutoTitleAfterPersist: (sessionKey: string) => void;
     /** Effective merged config snapshot. */

package/dist/src/agent/inbound/inbound-loop.js CHANGED Viewed

@@ -206,8 +206,6 @@ var InboundLoop = class {
 		this.log.debug({ sessionKey: context.sessionKey }, "Processing system message");
 		await this.cfg.sessionHydrator.workspace(context.sessionKey);
 		await this.cfg.sessionHydrator.model(context.sessionKey);
-		const messages = await this.cfg.sessionStore.load(context.sessionKey);
-		await this.cfg.checkAndCompact(context.sessionKey, messages);
 		const systemMessage = {
 			role: "user",
 			content: [{

package/dist/src/agent/memory/builtin-provider.js CHANGED Viewed

@@ -170,8 +170,8 @@ var BuiltinMemoryProvider = class {
 				projectId: request.scope?.projectId,
 				content: request.content,
 				source: {
-					...request.source ?? {},
-					provider: this.id
+					provider: this.id,
+					...request.source ?? {}
 				},
 				confidence: request.confidence,
 				tags: request.tags,
@@ -208,9 +208,9 @@ var BuiltinMemoryProvider = class {
 				sessionKey: request.scope?.sessionKey,
 				content: request.content,
 				source: {
-					...request.source ?? {},
 					provider: this.id,
-					path: sourcePathForTarget(target)
+					path: sourcePathForTarget(target),
+					...request.source ?? {}
 				},
 				tags: request.tags,
 				canonicalKey: request.canonicalKey,

package/dist/src/agent/memory/compaction-planner.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+export interface CompactionUnit {
+    messages: AgentMessage[];
+    text: string;
+    estimatedTokens: number;
+}
+export interface CompactionChunk {
+    text: string;
+    estimatedTokens: number;
+    messageCount: number;
+    oversized: boolean;
+}
+export declare function serializeMessageForCompaction(message: AgentMessage): string;
+export declare function buildCompactionUnits(messages: readonly AgentMessage[]): CompactionUnit[];
+export declare function planCompactionChunks(messages: readonly AgentMessage[], maxChunkTokens: number): CompactionChunk[];
+export declare function extractExactIdentifiers(messages: readonly AgentMessage[], limit?: number): string[];

package/dist/src/agent/memory/compaction-planner.js ADDED Viewed

@@ -0,0 +1,152 @@
+import { readAgentMessageContent } from "./agent-message-access.js";
+import { estimateTextTokens } from "./context-budget.js";
+//#region src/agent/memory/compaction-planner.ts
+function safeJson(value, maxChars = 8e3) {
+	let text;
+	try {
+		text = JSON.stringify(value, (_key, nested) => {
+			if (typeof nested === "string" && nested.length > 4e3) return `${nested.slice(0, 2e3)}\n… [${nested.length - 4e3} chars omitted] …\n${nested.slice(-2e3)}`;
+			return nested;
+		});
+	} catch {
+		text = String(value);
+	}
+	if (text.length <= maxChars) return text;
+	const half = Math.floor((maxChars - 80) / 2);
+	return `${text.slice(0, half)}\n… [structured value truncated] …\n${text.slice(-half)}`;
+}
+function valueRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function serializeContentBlock(block) {
+	const record = valueRecord(block);
+	if (!record) return safeJson(block);
+	const type = String(record.type ?? "unknown");
+	if (type === "text") return String(record.text ?? "");
+	if (type === "toolCall") return [
+		"[Tool call]",
+		`name: ${String(record.name ?? "unknown")}`,
+		`id: ${String(record.id ?? record.toolCallId ?? "unknown")}`,
+		`arguments: ${safeJson(record.arguments ?? record.args ?? {})}`
+	].join("\n");
+	if (type === "image" || type === "audio" || type === "video" || type === "file") {
+		const metadata = { ...record };
+		delete metadata.data;
+		delete metadata.bytes;
+		delete metadata.base64;
+		return `[${type} content]\nmetadata: ${safeJson(metadata, 2e3)}`;
+	}
+	if (type === "thinking" || type === "reasoning" || type === "reasoning_details") return "[Assistant private reasoning omitted from compaction input]";
+	return `[${type} block]\n${safeJson(record)}`;
+}
+function serializeMessageForCompaction(message) {
+	const record = message;
+	const raw = readAgentMessageContent(message);
+	const content = typeof raw === "string" ? raw : Array.isArray(raw) ? raw.map(serializeContentBlock).filter(Boolean).join("\n\n") : safeJson(raw);
+	const metadata = [];
+	if (message.role === "toolResult") {
+		metadata.push(`tool: ${String(record.toolName ?? "unknown")}`);
+		metadata.push(`toolCallId: ${String(record.toolCallId ?? "unknown")}`);
+		metadata.push(`status: ${record.isError === true ? "error" : "success"}`);
+		if (record.details != null) metadata.push(`details: ${safeJson(record.details, 4e3)}`);
+	}
+	return [
+		`### ${message.role}`,
+		...metadata,
+		content
+	].filter(Boolean).join("\n");
+}
+function toolCallIds(message) {
+	if (message.role !== "assistant") return /* @__PURE__ */ new Set();
+	const raw = readAgentMessageContent(message);
+	if (!Array.isArray(raw)) return /* @__PURE__ */ new Set();
+	const ids = /* @__PURE__ */ new Set();
+	for (const block of raw) {
+		const record = valueRecord(block);
+		if (record?.type !== "toolCall") continue;
+		const id = record.id ?? record.toolCallId;
+		if (typeof id === "string" && id) ids.add(id);
+	}
+	return ids;
+}
+function isMatchingToolResult(message, ids) {
+	if (message.role !== "toolResult") return false;
+	const id = message.toolCallId;
+	return typeof id === "string" && ids.has(id);
+}
+function buildCompactionUnits(messages) {
+	const units = [];
+	for (let index = 0; index < messages.length; index += 1) {
+		const group = [messages[index]];
+		const ids = toolCallIds(messages[index]);
+		if (ids.size > 0) while (index + 1 < messages.length && isMatchingToolResult(messages[index + 1], ids)) {
+			index += 1;
+			group.push(messages[index]);
+		}
+		const text = group.map(serializeMessageForCompaction).join("\n\n");
+		units.push({
+			messages: group,
+			text,
+			estimatedTokens: estimateTextTokens(text) + 16
+		});
+	}
+	return units;
+}
+function truncateOversizedUnit(text, maxTokens) {
+	const maxChars = Math.max(800, maxTokens * 4);
+	if (text.length <= maxChars) return text;
+	const marker = `\n\n[Oversized atomic message group: ${text.length - maxChars} characters omitted from the middle]\n\n`;
+	const side = Math.max(200, Math.floor((maxChars - marker.length) / 2));
+	return `${text.slice(0, side)}${marker}${text.slice(-side)}`;
+}
+function planCompactionChunks(messages, maxChunkTokens) {
+	const chunks = [];
+	let parts = [];
+	let tokens = 0;
+	let messageCount = 0;
+	const flush = () => {
+		if (parts.length === 0) return;
+		chunks.push({
+			text: parts.join("\n\n"),
+			estimatedTokens: tokens,
+			messageCount,
+			oversized: false
+		});
+		parts = [];
+		tokens = 0;
+		messageCount = 0;
+	};
+	for (const unit of buildCompactionUnits(messages)) {
+		if (unit.estimatedTokens > maxChunkTokens) {
+			flush();
+			const text = truncateOversizedUnit(unit.text, maxChunkTokens);
+			chunks.push({
+				text,
+				estimatedTokens: estimateTextTokens(text),
+				messageCount: unit.messages.length,
+				oversized: true
+			});
+			continue;
+		}
+		if (tokens > 0 && tokens + unit.estimatedTokens > maxChunkTokens) flush();
+		parts.push(unit.text);
+		tokens += unit.estimatedTokens;
+		messageCount += unit.messages.length;
+	}
+	flush();
+	return chunks;
+}
+const IDENTIFIER_PATTERN = /(?:\/?[\w.-]+\/)+(?:[\w.@-]+)|https?:\/\/[^\s)>]+|\b[0-9a-f]{8,64}\b|\b\d{4}-\d{2}-\d{2}\b|\bport\s+\d{2,5}\b/gi;
+function extractExactIdentifiers(messages, limit = 12) {
+	const text = messages.map(serializeMessageForCompaction).join("\n");
+	const found = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(IDENTIFIER_PATTERN)) {
+		const identifier = match[0].trim();
+		if (identifier.length < 4) continue;
+		found.add(identifier);
+		if (found.size >= limit) break;
+	}
+	return [...found];
+}
+//#endregion
+export { buildCompactionUnits, extractExactIdentifiers, planCompactionChunks, serializeMessageForCompaction };

package/dist/src/agent/memory/compaction-policy.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { Config } from '../../config/schema.js';
+import { type CompactionConfig } from './compaction.js';
+export interface ResolvedCompactionPolicy extends CompactionConfig {
+    reserveTokens: number;
+    model?: string;
+    minToolResultKeepChars: number;
+    maxActiveTranscriptBytes: number;
+    postCompactionSections: string[];
+}
+export declare function resolveCompactionPolicy(config?: Config): ResolvedCompactionPolicy;

package/dist/src/agent/memory/compaction-policy.js ADDED Viewed

@@ -0,0 +1,24 @@
+import { DEFAULT_COMPACTION_CONFIG } from "./compaction.js";
+//#region src/agent/memory/compaction-policy.ts
+const POLICY_DEFAULTS = {
+	...DEFAULT_COMPACTION_CONFIG,
+	reserveTokens: 8192,
+	minToolResultKeepChars: 1e3,
+	maxActiveTranscriptBytes: 2e6,
+	postCompactionSections: ["Session Startup", "Red Lines"]
+};
+function resolveCompactionPolicy(config) {
+	const configured = config?.userContext.memory.retention?.compaction;
+	if (!configured) return {
+		...POLICY_DEFAULTS,
+		postCompactionSections: [...POLICY_DEFAULTS.postCompactionSections]
+	};
+	return {
+		...POLICY_DEFAULTS,
+		...configured,
+		accumulateUsage: true,
+		postCompactionSections: [...configured.postCompactionSections]
+	};
+}
+//#endregion
+export { resolveCompactionPolicy };

package/dist/src/agent/memory/compaction.d.ts CHANGED Viewed

@@ -1,13 +1,14 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import { type Model, type Api } from '@earendil-works/pi-ai/compat';
-import { type ConversationSummary } from './summary-generator.js';
+import { type Api, type Model } from '@earendil-works/pi-ai/compat';
 export interface CompactionResult {
     summary: string;
     firstKeptIndex: number;
     tokensBefore: number;
     tokensAfter: number;
     compacted: boolean;
-    structuredSummary?: ConversationSummary;
+    plannerVersion?: number;
+    summaryModelRef?: string;
+    qualityAudit?: 'passed' | 'disabled';
     compactedUsage?: {
         input: number;
         output: number;
@@ -17,17 +18,22 @@ export interface CompactionResult {
 }
 export interface CompactionConfig {
     enabled: boolean;
-    mode: 'extractive' | 'abstractive' | 'structured';
-    reserveTokens: number;
     triggerThreshold: number;
     minMessagesBeforeCompact: number;
-    keepRecentMessages: number;
+    keepRecentTokens: number;
+    recentTurnsPreserve: number;
     summaryMaxTokens: number;
-    evictionWindow: number;
-    retentionWindow: number;
-    preserveReasoning: boolean;
+    summaryChunkTokens: number;
+    summaryTimeoutMs: number;
+    summaryRetries: number;
+    qualityGuard: boolean;
     accumulateUsage: boolean;
 }
+export interface CompactionExecutionOptions {
+    fallbackModels?: Array<Model<Api>>;
+    signal?: AbortSignal;
+}
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
 interface MessageUsage {
     input: number;
     output: number;
@@ -36,20 +42,13 @@ interface MessageUsage {
 }
 export declare function accumulateUsage(messages: AgentMessage[]): MessageUsage | undefined;
 export declare class SessionCompactor {
-    private model?;
-    private config;
-    constructor(config?: Partial<CompactionConfig>, model?: Model<Api>);
-    needsCompaction(messages: AgentMessage[], contextWindow: number): {
-        needed: boolean;
-        reason: string;
-        usagePercent?: number;
-    };
-    compact(messages: AgentMessage[], instructions?: string, force?: boolean): Promise<CompactionResult>;
+    private readonly config;
+    constructor(config?: Partial<CompactionConfig>);
+    getConfig(): Readonly<CompactionConfig>;
+    compact(messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, options?: CompactionExecutionOptions): Promise<CompactionResult>;
     private generateSummary;
-    private llmAbstractiveSummary;
-    private formatMessages;
-    private extractiveSummary;
-    estimateTotalTokens(messages: AgentMessage[]): number;
+    private callSummaryModels;
     applyCompaction(messages: AgentMessage[], result: CompactionResult): AgentMessage[];
+    estimateTotalTokens(messages: AgentMessage[]): number;
 }
 export {};