pi-roundtable 0.9.5 → 0.9.6

package/CHANGELOG.md

@@ -5,6 +5,12 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.6] - 2026-10-10
+
+### Fixed
+
+- The compaction tiers measure the context a compaction left as a request sends it, system prompt and tool definitions included: the first request after the compaction reports it, and until then the conversation's estimate gets the fixed part the last request before it carried (what it sent less the estimate of its messages). They measured the conversation alone, so a session with a large fixed part (over 100k of tools) that compacted to about 270k kept its next compaction at 300k and compacted again every few tool results. `LatestCompaction` adds `measured`, and the `conversation compacted` log adds `contextAfter`, the measure the tiers use, beside `tokensAfter`.
+
 ## [0.9.5] - 2026-10-10
 
 0.9.4 was tagged but never published (its release checks failed on the recorded prompt texts); everything listed under it is released in 0.9.5.

package/docs/plugins.md

@@ -68,7 +68,7 @@ Use the kit's building blocks for a plugin that runs Pi itself, such as a coding
 - Tools: `textToolsExtension`, `requiredString`, `stringList` (with `toolText` and `toolError`) for tools that return text.
 - Mirroring a built-in tool in a worker that cannot reach the host: `SCHEDULE_TOOLS`, `scheduleToolSpecs({ locale, timeZone })`, `isScheduleTool`, `callScheduleTool`, `DELEGATE_TOOL` and `DELEGATE_TOOL_SPEC`.
   The specs take the locale and time zone for their descriptions, so the worker needs no process-wide setting.
-- Compaction: `CompactionTiers` gives a session the core's compaction tiers (`settings()` for Pi's `SettingsManager`, `wrapCompactor(factory, onBypass, prepare?)` to hold a compaction extension back past the ceiling and change what it is given first, `latest()`), with `SOFT_COMPACT_TOKENS` (300,000), `HARD_COMPACT_TOKENS` (500,000), `COMPACT_HEADROOM_TOKENS` (50,000), `compactionEngine(details, engine)` and the types `CompactionEngine`, `CompactionHistory` and `LatestCompaction`. `summaryProjection(messages, history?)` is what a shared conversation's compaction may summarize, without anyone's private memory, prompt states, or reasoning, and `privateCompaction(preparation, additionalMessages?)` sets a `session_before_compact` preparation to it. Optional surrounding history pairs calls/results split across summary, prefix and kept context. Independent shared sessions use `memoryProjection(messages, view)` on requests and `hidesPrivateExchange(messages, view)` for raw replay guards (`MemoryView`: `shared` and `reader`; legacy attribution is internal to the bridge guard, not a projection option). `recordMemoryTurn(manager, reader, privateMemory)` appends `MEMORY_TURN_ENTRY` (`roundtable-memory-turn`) before prompting and returns a marker for memory first used later in that turn; `carriesMemory(message)` recognizes built-in memory calls/results and custom `privateTo` results, including immediate failures and unanswered calls. `bridgeHistoryHidesMemory(rawBranch, reader)` checks those records and raw exchanges across compaction; SYSTEM is a reader of its own there, and the core's SYSTEM-as-primary-owner attribution and its pre-scope legacy attribution stay inside the core.
+- Compaction: `CompactionTiers` gives a session the core's compaction tiers (`settings()` for Pi's `SettingsManager`, `wrapCompactor(factory, onBypass, prepare?)` to hold a compaction extension back past the ceiling and change what it is given first, `latest()`: the latest compaction's `contextTokens`, the context it left as a request sends it, system prompt and tools included, `measured` once a request after it reported its usage), with `SOFT_COMPACT_TOKENS` (300,000), `HARD_COMPACT_TOKENS` (500,000), `COMPACT_HEADROOM_TOKENS` (50,000), `compactionEngine(details, engine)` and the types `CompactionEngine`, `CompactionHistory` and `LatestCompaction`. `summaryProjection(messages, history?)` is what a shared conversation's compaction may summarize, without anyone's private memory, prompt states, or reasoning, and `privateCompaction(preparation, additionalMessages?)` sets a `session_before_compact` preparation to it. Optional surrounding history pairs calls/results split across summary, prefix and kept context. Independent shared sessions use `memoryProjection(messages, view)` on requests and `hidesPrivateExchange(messages, view)` for raw replay guards (`MemoryView`: `shared` and `reader`; legacy attribution is internal to the bridge guard, not a projection option). `recordMemoryTurn(manager, reader, privateMemory)` appends `MEMORY_TURN_ENTRY` (`roundtable-memory-turn`) before prompting and returns a marker for memory first used later in that turn; `carriesMemory(message)` recognizes built-in memory calls/results and custom `privateTo` results, including immediate failures and unanswered calls. `bridgeHistoryHidesMemory(rawBranch, reader)` checks those records and raw exchanges across compaction; SYSTEM is a reader of its own there, and the core's SYSTEM-as-primary-owner attribution and its pre-scope legacy attribution stay inside the core.
 - Jev compaction: `jevCompact(input, options)` compacts through Jev (pi-jev-compaction 1.0.0) and returns `{ compaction }` or `{ skipped, detail? }` (a `JevSkipReason`: pi-jev-compaction's fallbacks `no_key`, `aborted`, `nothing_to_compact`, `no_candidates`, `cannot_fit`, `jev_error`, `reduction_too_small`, or `previous_summary_too_large`), for Pi's own summary to run instead.
   Its summary carries the previous summary once, as the transcript's `[previous compaction]` message, with `estimatedTokensAfter` measured on the final text; a previous summary over `previousSummaryLimitTokens` (default `JEV_PREVIOUS_SUMMARY_LIMIT_TOKENS`, 60,000) skips without calling Jev, so Pi's summary condenses the chain.
   Jev judges with `goal` (default `JEV_GOAL`: keep the tool results that set rules still in force, drop stale lookups, listings and finished edits), and the summary ends with a `## Rules loaded before this compaction` section naming each rule load among the summarized messages (tool name and JSON arguments cut at 200 characters) for the agent to load again; `ruleLoad(tool, args)` picks them (default `isRuleLoad`: tools ending in `invoke-skill` or `get-system-prompt`, and tools ending in `read` whose `path` is a `SKILL.md`, an `AGENTS.md` or under `.agents/skills/`).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.9.5",
+	"version": "0.9.6",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/runtime/compaction-tiers.ts

@@ -1,9 +1,12 @@
 import {
+	buildSessionProjection,
 	type ExtensionAPI,
 	type ExtensionFactory,
 	estimateTokens,
 	type SessionBeforeCompactEvent,
+	type SessionEntry,
 	type SessionManager,
+	type SessionProjection,
 	SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 
@@ -29,8 +32,14 @@ export type CompactionHistory = Pick<
 export interface LatestCompaction {
 	id: string;
 	engine: CompactionEngine;
-	/** Estimated context the compaction left: its summary and the entries it kept. */
+	/**
+	 * The context the compaction left, as a request sends it: system prompt and tools included.
+	 * The first request after it reports this; until then, its summary and kept entries plus the
+	 * fixed part the last request before it carried.
+	 */
 	contextTokens: number;
+	/** Whether a request after the compaction reported `contextTokens`, or it is still estimated. */
+	measured: boolean;
 }
 
 /** The extension's compactions record its `engine` in their details; Pi's own do not. */
@@ -44,6 +53,41 @@ export function compactionEngine(
 		: "pi";
 }
 
+/** What a request sent, as its reply's usage reports it: undefined for a reply without usable usage. */
+function sentTokens(entry: SessionEntry | undefined): number | undefined {
+	if (entry?.type !== "message") return undefined;
+	const message = entry.message;
+	if (message.role !== "assistant") return undefined;
+	if (message.stopReason === "aborted" || message.stopReason === "error")
+		return undefined;
+	const { input, cacheRead, cacheWrite } = message.usage;
+	const sent = input + cacheRead + cacheWrite;
+	return sent > 0 ? sent : undefined;
+}
+
+function estimated(messages: SessionProjection["messages"]): number {
+	let tokens = 0;
+	for (const message of messages) tokens += estimateTokens(message);
+	return tokens;
+}
+
+/**
+ * The part of a request that is not the conversation, system prompt and tool definitions, as the
+ * last reply before `index` reported it: what that request sent less the estimate of its messages.
+ */
+function fixedTokens(branch: readonly SessionEntry[], index: number): number {
+	for (let at = index - 1; at >= 0; at--) {
+		const sent = sentTokens(branch[at]);
+		if (sent === undefined) continue;
+		const messages = buildSessionProjection(
+			branch.slice(0, at),
+			branch[at - 1]?.id ?? null,
+		).messages;
+		return Math.max(0, sent - estimated(messages));
+	}
+	return 0;
+}
+
 /** The branch's latest compaction, measured from the session as it stands now. */
 export function latestCompaction(
 	history: CompactionHistory,
@@ -56,16 +100,22 @@ export function latestCompaction(
 	const upToCompaction = new Set(
 		branch.slice(0, index + 1).map((each) => each.id),
 	);
-	let contextTokens = 0;
+	const engine = compactionEngine(entry.details, extensionEngine);
+	for (const after of branch.slice(index + 1)) {
+		const sent = sentTokens(after);
+		if (sent !== undefined)
+			return { id: entry.id, engine, contextTokens: sent, measured: true };
+	}
+	let messages = 0;
 	for (const projected of history.buildSessionProjection().entries) {
 		if (!upToCompaction.has(projected.sourceEntry.id)) continue;
-		for (const message of projected.messages)
-			contextTokens += estimateTokens(message);
+		messages += estimated(projected.messages);
 	}
 	return {
 		id: entry.id,
-		engine: compactionEngine(entry.details, extensionEngine),
-		contextTokens,
+		engine,
+		contextTokens: messages + fixedTokens(branch, index),
+		measured: false,
 	};
 }
 
@@ -124,12 +174,15 @@ export class CompactionTiers {
 		this.#extensionEngine = extensionEngine;
 	}
 
-	/** The latest compaction; measured once per compaction, since pi checks before every request. */
+	/**
+	 * The latest compaction; pi checks before every request, so it is measured once per compaction
+	 * after a request reports it, and estimated again until one does.
+	 */
 	latest(): LatestCompaction | undefined {
 		const branch = this.#history.getBranch();
 		const entry = branch.findLast((each) => each.type === "compaction");
 		if (!entry) return undefined;
-		if (this.#cached?.id !== entry.id) {
+		if (this.#cached?.id !== entry.id || !this.#cached.latest.measured) {
 			const latest = latestCompaction(this.#history, this.#extensionEngine);
 			if (!latest) return undefined;
 			this.#cached = { id: entry.id, latest };

package/src/core/runtime/session-factory.ts

@@ -207,12 +207,14 @@ export class SessionFactory {
 
 	/**
 	 * Logs who compacted a conversation, the compaction extension or Pi's summary, by how much, and the context size
-	 * that compacts it next, so a move to the hard ceiling shows.
+	 * that compacts it next, so a move to the hard ceiling shows. `contextAfter` is the context the tiers measure,
+	 * system prompt and tools included, which `tokensAfter`, the conversation alone, leaves out.
 	 */
 	#logCompaction(
 		channel: ChannelKey,
 		event: CompactionEnd,
 		session: AgentSession,
+		tiers: CompactionTiers,
 	): void {
 		const { logger } = this.#options;
 		const trigger = event.reason === "manual" ? "self" : event.reason;
@@ -239,6 +241,7 @@ export class SessionFactory {
 				),
 				tokensBefore: event.result.tokensBefore,
 				tokensAfter: event.result.estimatedTokensAfter,
+				contextAfter: tiers.latest()?.contextTokens,
 				nextCompactionAt:
 					model &&
 					model.contextWindow -
@@ -423,7 +426,7 @@ export class SessionFactory {
 		await this.#awaitTools(session, awaited);
 		session.subscribe((event) => {
 			if (event.type === "compaction_end")
-				this.#logCompaction(channel, event, session);
+				this.#logCompaction(channel, event, session, tiers);
 		});
 		return Object.assign(state, { session });
 	}