@shanepadgett/tau-agent 0.28.1 → 0.29.0

package/schemas/tau.schema.json

@@ -53,39 +53,6 @@
 					},
 					"additionalProperties": false
 				},
-				"contextPruning": {
-					"type": "object",
-					"properties": {
-						"enabled": {
-							"type": "boolean",
-							"default": true,
-							"description": "Enable context pruning."
-						},
-						"nudgeEveryTokens": {
-							"type": "integer",
-							"default": 30000,
-							"minimum": 1,
-							"description": "Active-context token interval between automatic pruning hints."
-						},
-						"nudgeInstructions": {
-							"type": "array",
-							"items": {
-								"type": "string",
-								"minLength": 1,
-								"maxLength": 2000
-							},
-							"default": [
-								"No prune is required yet unless broad exploration has converged or substantial evidence is already irrelevant. Continue coherent work.",
-								"Move toward a pruning point now. Finish the current coherent step, then prune before starting another broad exploration. Managed context is materially increasing model cost.",
-								"Prune now before further tool work. Continuing with stale managed context is wasting money."
-							],
-							"minItems": 1,
-							"maxItems": 5,
-							"description": "Ordered automatic pruning instructions. Later reminders repeat the final instruction, and the final tier requires an anchor before further tool work."
-						}
-					},
-					"additionalProperties": false
-				},
 				"explore": {
 					"type": "object",
 					"properties": {
@@ -114,12 +81,6 @@
 									"default": 200,
 									"minimum": 1,
 									"description": "Registered source at or under this line count may be full-read. Above it, full read model-visible result is outline only."
-								},
-								"maxRangeLines": {
-									"type": "integer",
-									"default": 200,
-									"minimum": 1,
-									"description": "Maximum lines returned by one ranged read on registered source."
 								}
 							},
 							"additionalProperties": false
@@ -315,6 +276,39 @@
 						}
 					},
 					"additionalProperties": false
+				},
+				"workingMemory": {
+					"type": "object",
+					"properties": {
+						"enabled": {
+							"type": "boolean",
+							"default": true,
+							"description": "Enable working-memory checkpoints."
+						},
+						"nudgeEveryTokens": {
+							"type": "integer",
+							"default": 40000,
+							"minimum": 1,
+							"description": "Active-context token interval between advisory working-memory reminders."
+						},
+						"nudgeInstructions": {
+							"type": "array",
+							"items": {
+								"type": "string",
+								"minLength": 1,
+								"maxLength": 2000
+							},
+							"default": [
+								"Reassess working memory. Continue coherent exploration when its evidence remains useful; otherwise prune known dead ends, obsolete outputs, and other context with no expected value.",
+								"Context is materially larger. Prune stale or bulky irrelevant evidence when safe, but keep active working evidence that would otherwise need to be reread.",
+								"Strongly reassess before more broad work. Remove accumulated waste and carry useful information at cheapest sufficient fidelity without scrubbing the active working set."
+							],
+							"minItems": 1,
+							"maxItems": 5,
+							"description": "Ordered advisory working-memory instructions. Later reminders repeat final instruction."
+						}
+					},
+					"additionalProperties": false
 				}
 			},
 			"additionalProperties": true,

package/shared/events.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { OutlineInjectionRequest, OutlineInjectionResponse } from "./outline-injection.js";
 import type { ToolRowVisualState } from "./tool-row-state.js";
 
 export type TauAgentEvents = {
@@ -36,6 +37,10 @@ export type TauAgentEvents = {
 		batchId: string;
 		files: Array<{ path: string }>;
 	};
+	"tau:outline-injection.requested": {
+		request: OutlineInjectionRequest;
+		accept(response: Promise<OutlineInjectionResponse>): void;
+	};
 	"tau:footer-item": {
 		id: string;
 		text?: string;

package/shared/full-file-knowledge.ts

@@ -16,7 +16,6 @@ export interface ReadCacheMetaV1 {
 }
 
 const COMPLETE_FILE_SCOPE = "full";
-export const MAX_COMPLETE_FILE_SNAPSHOT_BYTES = 1024 * 1024;
 
 export function createCompleteFileMeta(options: {
 	pathKey: string;

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;
-}