@shanepadgett/tau-agent 0.28.1 → 0.30.0

package/shared/isolated-session.ts

@@ -0,0 +1,151 @@
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	getAgentDir,
+	ModelRuntime,
+	SessionManager,
+	type AgentSession,
+	type ExtensionContext,
+	type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+
+type IsolatedSessionThinkingLevel = NonNullable<ExtensionContext["thinkingLevel"]>;
+
+type SelectedModel = NonNullable<ExtensionContext["model"]>;
+type SelectedProvider = NonNullable<ReturnType<ExtensionContext["modelRegistry"]["getProvider"]>>;
+
+export interface IsolatedSessionInputs {
+	label: string;
+	extensionPaths: readonly string[];
+	cwd: string;
+	model: SelectedModel;
+	provider: SelectedProvider;
+	runtimeApiKey: string | undefined;
+	thinkingLevel: IsolatedSessionThinkingLevel;
+	tools: readonly string[];
+	customTools: readonly ToolDefinition[];
+	bindTarget: { mode: "print" } | { mode: "tui"; uiContext: ExtensionContext["ui"] };
+}
+
+export interface IsolatedSessionResource {
+	readonly session: AgentSession;
+	dispose(): Promise<void>;
+}
+
+export async function resolveIsolatedSessionModel(options: {
+	label: string;
+	preferredModel: string | undefined;
+	preferredThinkingLevel: IsolatedSessionThinkingLevel | undefined;
+	usePreferredThinkingAfterModelFallback: boolean;
+	ctx: ExtensionContext;
+	parentThinkingLevel: IsolatedSessionThinkingLevel;
+	signal: AbortSignal;
+	onWarning?: (warning: string) => void;
+}): Promise<Pick<IsolatedSessionInputs, "model" | "provider" | "runtimeApiKey" | "thinkingLevel">> {
+	const { ctx, signal, onWarning } = options;
+	let model = ctx.model;
+	let thinkingLevel = options.parentThinkingLevel;
+	let preferredModelSelected = false;
+	let selectedAuth: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>> | undefined;
+	if (options.preferredModel) {
+		const separator = options.preferredModel.indexOf("/");
+		const configured = ctx.modelRegistry.find(
+			options.preferredModel.slice(0, separator),
+			options.preferredModel.slice(separator + 1),
+		);
+		if (!configured) onWarning?.(`model ${options.preferredModel} is unavailable; using parent model`);
+		else {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configured);
+			if (!auth.ok) onWarning?.(`model ${options.preferredModel} is unavailable: ${auth.error}; using parent model`);
+			else {
+				model = configured;
+				selectedAuth = auth;
+				preferredModelSelected = true;
+			}
+		}
+	}
+	if (options.preferredThinkingLevel && (preferredModelSelected || options.usePreferredThinkingAfterModelFallback)) {
+		const preferred = options.preferredThinkingLevel;
+		const mapped = model?.thinkingLevelMap?.[preferred];
+		const unsupported =
+			!model?.reasoning ||
+			mapped === null ||
+			((preferred === "xhigh" || preferred === "max") && mapped === undefined);
+		if (unsupported)
+			onWarning?.(`thinking ${preferred} is unavailable for the selected model; using parent thinking`);
+		else thinkingLevel = preferred;
+	}
+	if (!model) throw new Error(`${options.label} startup failed: parent has no model`);
+	const auth = selectedAuth ?? (await ctx.modelRegistry.getApiKeyAndHeaders(model));
+	if (!auth.ok) throw new Error(`${options.label} startup failed: ${auth.error}`);
+	const provider = ctx.modelRegistry.getProvider(model.provider);
+	if (!provider) throw new Error(`${options.label} startup failed: provider ${model.provider} is unavailable`);
+	if (signal.aborted) throw new Error(`${options.label} startup aborted`);
+	return {
+		model,
+		provider,
+		runtimeApiKey:
+			auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model) ? auth.apiKey : undefined,
+		thinkingLevel,
+	};
+}
+
+export async function createIsolatedSessionResource(
+	inputs: IsolatedSessionInputs,
+	signal: AbortSignal,
+): Promise<IsolatedSessionResource> {
+	let session: AgentSession | undefined;
+	try {
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const modelRuntime = await ModelRuntime.create();
+		modelRuntime.registerNativeProvider(inputs.provider);
+		if (inputs.runtimeApiKey !== undefined)
+			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey, { allowNetwork: false });
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const resourceLoader = new DefaultResourceLoader({
+			cwd: inputs.cwd,
+			agentDir: getAgentDir(),
+			noExtensions: true,
+			additionalExtensionPaths: [...inputs.extensionPaths],
+		});
+		await resourceLoader.reload();
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const created = await createAgentSession({
+			cwd: inputs.cwd,
+			model: inputs.model,
+			modelRuntime,
+			thinkingLevel: inputs.thinkingLevel,
+			tools: [...inputs.tools],
+			excludeTools: ["subagent"],
+			resourceLoader,
+			customTools: [...inputs.customTools],
+			sessionManager: SessionManager.inMemory(inputs.cwd),
+		});
+		session = created.session;
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		await session.bindExtensions(inputs.bindTarget);
+		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
+		const active = session.getActiveToolNames().sort();
+		const expected = [...inputs.tools].sort();
+		if (active.join("\0") !== expected.join("\0") || active.includes("subagent")) {
+			const missing = expected.filter((tool) => !active.includes(tool));
+			throw new Error(
+				`${inputs.label} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
+			);
+		}
+		let disposed = false;
+		return {
+			session,
+			async dispose() {
+				if (disposed) return;
+				disposed = true;
+				if (session?.isStreaming) await session.abort().catch(() => undefined);
+				session?.dispose();
+			},
+		};
+	} catch (error) {
+		if (session?.isStreaming) await session.abort().catch(() => undefined);
+		session?.dispose();
+		throw error;
+	}
+}

package/shared/outline-injection.ts

@@ -0,0 +1,56 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { emitTauEvent, onTauEvent } from "./events.js";
+
+export interface OutlineInjectionDetails {
+	v: 1;
+	rowId: string;
+	path: string;
+	cwd: string;
+	batchId: string;
+}
+
+export interface PreparedOutlineInjection {
+	customType: "tau.explore.outline";
+	content: string;
+	display: true;
+	details: OutlineInjectionDetails;
+}
+
+export interface OutlineInjectionRequest {
+	cwd: string;
+	batchId: string;
+	paths: readonly string[];
+	signal: AbortSignal | undefined;
+	isLifecycleCurrent(): boolean;
+}
+
+export interface OutlineInjectionResponse {
+	messages: PreparedOutlineInjection[];
+	warnings: string[];
+}
+
+export type OutlineInjectionProvider = (request: OutlineInjectionRequest) => Promise<OutlineInjectionResponse>;
+
+export function registerOutlineInjectionProvider(pi: ExtensionAPI, provider: OutlineInjectionProvider): () => void {
+	return onTauEvent(pi, "shared.outline-injection-provider", "tau:outline-injection.requested", (event) => {
+		event.accept(provider(event.request));
+	});
+}
+
+export async function requestOutlineInjections(
+	pi: Pick<ExtensionAPI, "events">,
+	request: OutlineInjectionRequest,
+): Promise<OutlineInjectionResponse> {
+	let response: Promise<OutlineInjectionResponse> | undefined;
+	emitTauEvent(pi, "tau:outline-injection.requested", {
+		request,
+		accept(candidate) {
+			response ??= candidate;
+		},
+	});
+	if (response) return response;
+	return {
+		messages: [],
+		warnings: request.paths.map((path) => `${path}: Explore outline provider is unavailable`),
+	};
+}

package/extensions/context-pruning/README.md

@@ -1,39 +0,0 @@
-# Context Pruning
-
-Context Pruning gives the agent direct control over its future model context. It does not delete or rewrite the saved conversation.
-
-`context_prune` creates a hard checkpoint. Everything before that checkpoint leaves future model input unless the agent explicitly carries it forward. Messages after the checkpoint remain unchanged.
-
-Before calling the tool, the agent writes visible prose containing the durable conclusions, user constraints, conditional relevance, and next action that must survive. That prose is part of the checkpoint turn.
-
-## Selections
-
-The tool accepts three required lists:
-
-- `keepToolCalls` retains exact earlier tool exchanges by tool-call ID. Parallel calls remain independently selectable: retaining one call does not retain its siblings.
-- `keepFiles` reads each selected file from disk and carries its complete current contents forward as a fresh autoread snapshot. Each successful snapshot appears as its own autoread marker below the compact checkpoint result. It does not require an earlier complete read.
-- `deferFiles` carries forward a short advisory note explaining why a file is irrelevant now and when to reconsider it.
-
-Duplicate selections are collapsed. A file selected in both `keepFiles` and `deferFiles` is kept. Missing, unreadable, or otherwise unsnapshotable files produce warnings in the successful tool result; they do not block the checkpoint or other file snapshots.
-
-Context Pruning does not impose a minimum token saving and does not reject a checkpoint because old context has unusual bookkeeping. Pi supplies the current provider context. Tau removes unretained tool calls and their matching results with the same ID, drops other pre-checkpoint messages, and leaves the checkpoint turn and later messages intact.
-
-## Automatic and manual requests
-
-Tau checks active context size after tool-using turns and can send progressively stronger private instructions from `nudgeInstructions`. Hints occur at fixed token intervals rather than percentages of the model's context window. After a checkpoint, Tau suppresses boundaries already crossed by the resulting context and resumes at the next boundary. Branch navigation and compaction reconstruct that state from the active branch.
-
-Run `/prune` with no arguments to ask the agent to create a checkpoint and continue its task immediately.
-
-## Branches, compaction, and display
-
-Checkpoints belong to the active branch. Switching branches rebuilds the latest checkpoint, deferred-file state, automatic-hint baseline, and warning-colored pruned rows from that branch.
-
-Normal Pi compaction remains independent. When a compaction no longer includes an old checkpoint turn, that checkpoint has nothing left to filter.
-
-## Settings
-
-Settings live under `extensions.contextPruning` in Tau settings.
-
-- `enabled`: enables the tool, `/prune`, projection, markers, and branch replay. Defaults to `true`.
-- `nudgeEveryTokens`: active-context interval between automatic hints. Defaults to `30000`, producing the default instruction ladder at 30k, 60k, and 90k tokens.
-- `nudgeInstructions`: ordered list of one through five nonempty instructions. Later reminders repeat the final instruction. Defaults to three escalating instructions.

package/extensions/context-pruning/index.ts

@@ -1,382 +0,0 @@
-import {
-	defineTool,
-	type ExtensionAPI,
-	type ExtensionContext,
-	type SessionEntry,
-} from "@earendil-works/pi-coding-agent";
-import {
-	replayContextPruningState,
-	setContextPruningEnabled,
-	type ContextPruneDetailsV2,
-} from "../../shared/context-pruning-state.ts";
-import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
-import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { createToolRowStateStore } from "../../shared/tool-row-state.ts";
-import { contextPruneParameters, executeContextPrune } from "./prune.ts";
-import { projectContext } from "./projection.ts";
-import {
-	parseContextPruningNudgeDetailsV3,
-	renderContextPruneCall,
-	renderContextPruneResult,
-	renderContextPruningNudge,
-	type ContextPruningNudgeDetailsV3,
-} from "./render.ts";
-import contextPruningSettings from "./settings.ts";
-
-const TOOL_DESCRIPTION =
-	"Create a hard context checkpoint after broad exploration converges, when a context-pruning nudge directs it, or when stale evidence has accumulated. Everything before the checkpoint is removed from future model context unless selected for retention. Immediately before calling, state durable conclusions, conditional relevance, and the next action in visible prose.";
-const NUDGE_MESSAGE_TYPE = "tau.context-pruning.nudge";
-const NUDGE_BASELINE_ENTRY_TYPE = "tau.context-pruning.nudge-baseline";
-
-interface NudgeState {
-	anchorToolCallId: string | undefined;
-	suppressedThroughTokens: number | undefined;
-	highestBoundaryTokens: number;
-	highestTier: number;
-	terminalTierReached: boolean;
-}
-
-export default function contextPruningExtension(pi: ExtensionAPI): void {
-	let enabled = false;
-	let lifecycleGeneration = 0;
-	let nudgeEveryTokens = contextPruningSettings.defaults.nudgeEveryTokens;
-	let nudgeInstructions = contextPruningSettings.defaults.nudgeInstructions;
-	let toolRegistered = false;
-	let commandRegistered = false;
-	let visualRows = new Set<string>();
-	let nudgeState: NudgeState = {
-		anchorToolCallId: undefined,
-		suppressedThroughTokens: 0,
-		highestBoundaryTokens: 0,
-		highestTier: 0,
-		terminalTierReached: false,
-	};
-	const rowState = createToolRowStateStore(pi, "context-pruning.tool-row-state");
-	pi.registerMessageRenderer<ContextPruningNudgeDetailsV3>(NUDGE_MESSAGE_TYPE, (message, _options, theme) =>
-		renderContextPruningNudge(message.details, theme),
-	);
-
-	const pushVisualSnapshot = () => {
-		emitTauEvent(pi, "tau:tool-row-state.snapshot", {
-			states: [...visualRows].map((rowId) => ({ rowId, state: "pruned" as const })),
-		});
-	};
-	onTauEvent(
-		pi,
-		"context-pruning.tool-row-state-producer",
-		"tau:tool-row-state.snapshot.requested",
-		pushVisualSnapshot,
-	);
-
-	const clearEphemeralState = () => {
-		lifecycleGeneration += 1;
-	};
-	const setContextPruneToolActive = (active: boolean) => {
-		if (!toolRegistered) return;
-		const activeTools = pi.getActiveTools();
-		const currentlyActive = activeTools.includes("context_prune");
-		if (active === currentlyActive) return;
-		pi.setActiveTools(
-			active ? [...activeTools, "context_prune"] : activeTools.filter((toolName) => toolName !== "context_prune"),
-		);
-	};
-	const syncBranchState = (ctx: ExtensionContext) => {
-		const state = replayContextPruningState(ctx.sessionManager.getBranch(), enabled);
-		visualRows = new Set([...state.prunedToolCallIds, ...state.prunedAutoreadRowIds]);
-		nudgeState = reconstructNudgeState(ctx.sessionManager.getBranch(), state.latestAnchorToolCallId);
-		pushVisualSnapshot();
-	};
-
-	pi.on("session_start", async (_event, ctx) => {
-		clearEphemeralState();
-		enabled = false;
-		setContextPruneToolActive(false);
-		visualRows.clear();
-		setContextPruningEnabled(false);
-		pushVisualSnapshot();
-		const generation = lifecycleGeneration;
-		const settings = await loadTauExtensionSettings(ctx, contextPruningSettings);
-		if (generation !== lifecycleGeneration) return;
-		enabled = settings.enabled;
-		nudgeEveryTokens = settings.nudgeEveryTokens;
-		nudgeInstructions = settings.nudgeInstructions;
-		setContextPruningEnabled(enabled);
-		if (enabled && !toolRegistered) {
-			pi.registerTool(
-				defineTool<typeof contextPruneParameters, ContextPruneDetailsV2>({
-					name: "context_prune",
-					label: "context_prune",
-					description: TOOL_DESCRIPTION,
-					promptSnippet:
-						"Prune substantial stale tool evidence after stating durable conclusions and the next action",
-					promptGuidelines: [
-						"Use context_prune after broad exploration converges, when a context-pruning nudge directs it, or when substantial irrelevant evidence has accumulated.",
-						"A final-tier context-pruning nudge means preserve durable conclusions and prune before further tool work.",
-						"Everything before context_prune leaves future model context unless selected in keepFiles or keepToolCalls, so preserve durable conclusions, user constraints, conditional relevance, and the next action in visible prose immediately before calling it.",
-					],
-					parameters: contextPruneParameters,
-					executionMode: "sequential",
-					async execute(toolCallId, params, signal, _onUpdate, executionContext) {
-						const execution = await executeContextPrune({
-							toolCallId,
-							params,
-							signal,
-							ctx: executionContext,
-							generation: lifecycleGeneration,
-							currentGeneration: () => lifecycleGeneration,
-						});
-						for (const autoread of execution.autoreads) {
-							pi.sendMessage(autoread, { deliverAs: "steer" });
-						}
-						return execution.result;
-					},
-					renderCall(args, theme, context) {
-						return renderContextPruneCall(args, theme, {
-							rowState,
-							rowId: context.toolCallId,
-							invalidate: context.invalidate,
-							lastComponent: context.lastComponent,
-						});
-					},
-					renderResult(result, options, theme, context) {
-						return renderContextPruneResult(result, options.expanded, theme, context.lastComponent);
-					},
-				}),
-			);
-			toolRegistered = true;
-		}
-		setContextPruneToolActive(enabled);
-		if (enabled && !commandRegistered) {
-			pi.registerCommand("prune", {
-				description: "Ask the agent to create a context-pruning anchor and continue its task",
-				async handler(args, commandContext) {
-					if (!enabled) {
-						commandContext.ui.notify("Context pruning is disabled.", "info");
-						return;
-					}
-					if (args.trim().length > 0) {
-						commandContext.ui.notify("Usage: /prune", "info");
-						return;
-					}
-					const anchorToolCallId = replayContextPruningState(
-						commandContext.sessionManager.getBranch(),
-						true,
-					).latestAnchorToolCallId;
-					pi.sendMessage<ContextPruningNudgeDetailsV3>(
-						{
-							customType: NUDGE_MESSAGE_TYPE,
-							content: manualPruneSteeringMessage(),
-							display: true,
-							details: {
-								v: 3,
-								kind: "manual",
-								tokens: null,
-								boundaryTokens: null,
-								reminder: null,
-								tier: null,
-								tierCount: null,
-								tierFloor: null,
-								anchorToolCallId: anchorToolCallId ?? null,
-								suppressedThroughTokens: null,
-							},
-						},
-						{ deliverAs: "steer", triggerTurn: true },
-					);
-				},
-			});
-			commandRegistered = true;
-		}
-		syncBranchState(ctx);
-	});
-
-	pi.on("session_tree", (_event, ctx) => {
-		clearEphemeralState();
-		syncBranchState(ctx);
-	});
-	pi.on("session_compact", (_event, ctx) => {
-		clearEphemeralState();
-		syncBranchState(ctx);
-	});
-	pi.on("session_shutdown", () => {
-		clearEphemeralState();
-		enabled = false;
-		setContextPruneToolActive(false);
-		visualRows.clear();
-		nudgeState = {
-			anchorToolCallId: undefined,
-			suppressedThroughTokens: 0,
-			highestBoundaryTokens: 0,
-			highestTier: 0,
-			terminalTierReached: false,
-		};
-		setContextPruningEnabled(false);
-		pushVisualSnapshot();
-	});
-
-	pi.on("turn_end", (event, ctx) => {
-		if (!enabled || event.toolResults.length === 0) return undefined;
-		const usage = ctx.getContextUsage();
-		if (!usage || usage.tokens === null || !Number.isFinite(usage.tokens)) return undefined;
-		const tokens = Math.max(0, Math.floor(usage.tokens));
-		const activeAnchor = replayContextPruningState(ctx.sessionManager.getBranch(), true).latestAnchorToolCallId;
-		if (activeAnchor !== nudgeState.anchorToolCallId) {
-			nudgeState = reconstructNudgeState(ctx.sessionManager.getBranch(), activeAnchor);
-		}
-		if (activeAnchor !== undefined && nudgeState.suppressedThroughTokens === undefined) {
-			const suppressedThroughTokens = Math.floor(tokens / nudgeEveryTokens) * nudgeEveryTokens;
-			pi.appendEntry(NUDGE_BASELINE_ENTRY_TYPE, {
-				v: 2,
-				anchorToolCallId: activeAnchor,
-				suppressedThroughTokens,
-			});
-			nudgeState.suppressedThroughTokens = suppressedThroughTokens;
-			nudgeState.highestBoundaryTokens = suppressedThroughTokens;
-			return undefined;
-		}
-		const reminder = Math.floor(tokens / nudgeEveryTokens);
-		if (reminder < 1) return undefined;
-		const boundaryTokens = reminder * nudgeEveryTokens;
-		if (boundaryTokens <= nudgeState.highestBoundaryTokens) return undefined;
-		const tierCount = nudgeInstructions.length;
-		const tierFloor = nudgeState.terminalTierReached ? tierCount : Math.min(nudgeState.highestTier, tierCount);
-		const tier = Math.max(Math.min(reminder, tierCount), tierFloor);
-		const instruction = nudgeInstructions[tier - 1] ?? nudgeInstructions[0];
-		const details: ContextPruningNudgeDetailsV3 = {
-			v: 3,
-			kind: "automatic",
-			tokens,
-			boundaryTokens,
-			reminder,
-			tier,
-			tierCount,
-			tierFloor,
-			anchorToolCallId: activeAnchor ?? null,
-			suppressedThroughTokens: nudgeState.suppressedThroughTokens ?? 0,
-		};
-		pi.sendMessage<ContextPruningNudgeDetailsV3>(
-			{
-				customType: NUDGE_MESSAGE_TYPE,
-				content: automaticPruneSteeringMessage(instruction, tier === tierCount),
-				display: true,
-				details,
-			},
-			{ deliverAs: "steer" },
-		);
-		nudgeState.highestBoundaryTokens = boundaryTokens;
-		nudgeState.highestTier = Math.max(nudgeState.highestTier, tier);
-		nudgeState.terminalTierReached ||= tier === tierCount;
-		return undefined;
-	});
-
-	pi.on("context", (event, ctx) => {
-		if (!enabled) return undefined;
-		const state = replayContextPruningState(ctx.sessionManager.getBranch(), true);
-		const messages = projectContext(event.messages, state);
-		const nextRows = new Set([...state.prunedToolCallIds, ...state.prunedAutoreadRowIds]);
-		if (!setsEqual(visualRows, nextRows)) {
-			visualRows = nextRows;
-			pushVisualSnapshot();
-		}
-		return { messages };
-	});
-}
-
-function setsEqual(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean {
-	if (left.size !== right.size) return false;
-	for (const item of left) if (!right.has(item)) return false;
-	return true;
-}
-
-function reconstructNudgeState(branch: readonly SessionEntry[], anchorToolCallId: string | undefined): NudgeState {
-	let suppressedThroughTokens = anchorToolCallId === undefined ? 0 : undefined;
-	let highestBoundaryTokens = 0;
-	let highestTier = 0;
-	let terminalTierReached = false;
-	let anchorResultIndex = -1;
-	if (anchorToolCallId !== undefined) {
-		anchorResultIndex = branch.findIndex(
-			(entry) =>
-				entry.type === "message" &&
-				entry.message.role === "toolResult" &&
-				entry.message.toolName === "context_prune" &&
-				entry.message.toolCallId === anchorToolCallId,
-		);
-	}
-	for (let index = 0; index < branch.length; index += 1) {
-		const entry = branch[index];
-		if (!entry) continue;
-		if (entry.type === "custom" && entry.customType === NUDGE_BASELINE_ENTRY_TYPE) {
-			const baseline = parseNudgeBaseline(entry.data);
-			if (
-				baseline &&
-				suppressedThroughTokens === undefined &&
-				index > anchorResultIndex &&
-				baseline.anchorToolCallId === anchorToolCallId
-			) {
-				suppressedThroughTokens = baseline.suppressedThroughTokens;
-				highestBoundaryTokens = baseline.suppressedThroughTokens;
-			}
-			continue;
-		}
-		if (entry.type !== "custom_message" || entry.customType !== NUDGE_MESSAGE_TYPE) continue;
-		const details = parseContextPruningNudgeDetailsV3(entry.details);
-		if (
-			!details ||
-			details.kind !== "automatic" ||
-			index <= anchorResultIndex ||
-			details.anchorToolCallId !== (anchorToolCallId ?? null) ||
-			details.boundaryTokens === null ||
-			details.suppressedThroughTokens === null ||
-			(suppressedThroughTokens !== undefined && details.suppressedThroughTokens !== suppressedThroughTokens)
-		)
-			continue;
-		const expectedTierFloor: number = terminalTierReached
-			? details.tierCount
-			: Math.min(highestTier, details.tierCount);
-		if (details.boundaryTokens <= highestBoundaryTokens || details.tierFloor !== expectedTierFloor) continue;
-		highestBoundaryTokens = Math.max(highestBoundaryTokens, details.boundaryTokens);
-		highestTier = Math.max(highestTier, details.tier);
-		terminalTierReached ||= details.tier === details.tierCount;
-		suppressedThroughTokens = details.suppressedThroughTokens;
-	}
-	return { anchorToolCallId, suppressedThroughTokens, highestBoundaryTokens, highestTier, terminalTierReached };
-}
-
-function parseNudgeBaseline(
-	value: unknown,
-): { v: 2; anchorToolCallId: string; suppressedThroughTokens: number } | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	if (
-		Object.keys(record).length !== 3 ||
-		!Object.hasOwn(record, "v") ||
-		!Object.hasOwn(record, "anchorToolCallId") ||
-		!Object.hasOwn(record, "suppressedThroughTokens") ||
-		record.v !== 2 ||
-		typeof record.anchorToolCallId !== "string" ||
-		record.anchorToolCallId.length === 0 ||
-		typeof record.suppressedThroughTokens !== "number" ||
-		!Number.isSafeInteger(record.suppressedThroughTokens) ||
-		record.suppressedThroughTokens < 0
-	)
-		return undefined;
-	return {
-		v: 2,
-		anchorToolCallId: record.anchorToolCallId,
-		suppressedThroughTokens: record.suppressedThroughTokens,
-	};
-}
-
-function automaticPruneSteeringMessage(instruction: string, finalTier: boolean): string {
-	const silent =
-		"Internal context-management instruction. Follow it silently. Do not mention or acknowledge context-token counts, prune messages, or internal context management.";
-	const protocol =
-		"When pruning, first preserve durable conclusions, user constraints, conditional relevance, and the next action in visible prose, then call context_prune.";
-	return finalTier
-		? `${silent} ${instruction} This is the final reminder tier. Create a context anchor before further tool work. ${protocol}`
-		: `${silent} ${instruction} ${protocol}`;
-}
-
-function manualPruneSteeringMessage(): string {
-	return "Internal context-management instruction. Follow it silently without mentioning this request. Create a hard context checkpoint with context_prune, then continue unfinished work. First preserve durable conclusions, user constraints, conditional relevance, and the next action in visible prose.";
-}

package/extensions/context-pruning/projection.ts

@@ -1,60 +0,0 @@
-import type { ContextEvent } from "@earendil-works/pi-coding-agent";
-import type { ActiveContextPruningState } from "../../shared/context-pruning-state.ts";
-
-type ContextMessage = ContextEvent["messages"][number];
-
-export function projectContext(
-	messages: readonly ContextMessage[],
-	state: ActiveContextPruningState,
-): ContextMessage[] {
-	if (state.latestAnchorToolCallId === undefined) return [...messages];
-	let anchorIndex = -1;
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (
-			message?.role === "assistant" &&
-			message.content.some(
-				(block) =>
-					block.type === "toolCall" && block.id === state.latestAnchorToolCallId && block.name === "context_prune",
-			)
-		) {
-			anchorIndex = index;
-			break;
-		}
-	}
-	if (anchorIndex < 0) return [...messages];
-	const retainedCallNames = new Map<string, string>();
-	const retainedResultNames = new Map<string, string>();
-	for (let index = 0; index < anchorIndex; index += 1) {
-		const message = messages[index];
-		if (message?.role === "assistant") {
-			for (const block of message.content) {
-				if (block.type === "toolCall" && state.retainedToolCallIds.has(block.id)) {
-					retainedCallNames.set(block.id, block.name);
-				}
-			}
-		} else if (message?.role === "toolResult" && state.retainedToolCallIds.has(message.toolCallId)) {
-			retainedResultNames.set(message.toolCallId, message.toolName);
-		}
-	}
-	const retainableToolCallIds = new Set(
-		[...retainedCallNames].flatMap(([id, name]) => (retainedResultNames.get(id) === name ? [id] : [])),
-	);
-
-	const projected: ContextMessage[] = [];
-	for (let index = 0; index < anchorIndex; index += 1) {
-		const message = messages[index];
-		if (!message) continue;
-		if (message.role === "toolResult") {
-			if (retainableToolCallIds.has(message.toolCallId)) projected.push(message);
-			continue;
-		}
-		if (message.role !== "assistant") continue;
-		const content = message.content.filter(
-			(block) => block.type === "toolCall" && retainableToolCallIds.has(block.id),
-		);
-		if (content.length > 0) projected.push({ ...message, content });
-	}
-	projected.push(...messages.slice(anchorIndex));
-	return projected;
-}