@shanepadgett/tau-agent 0.33.1 → 0.35.0

package/extensions/explore/outline-injection.ts

@@ -1,151 +0,0 @@
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { Marker } from "@shanepadgett/tau-tui";
-import { BoundedTextResultBuilder } from "../../shared/bounded-text-result.ts";
-import {
-	registerOutlineInjectionProvider,
-	type OutlineInjectionDetails,
-	type PreparedOutlineInjection,
-} from "../../shared/outline-injection.ts";
-import type { TemporaryOutputStore } from "../../shared/temporary-output-store.ts";
-import type { ToolRowStateStore } from "../../shared/tool-row-state.ts";
-import type { ExploreEngine } from "./ast/engine.ts";
-import { formatOutlineEmpty, formatOutlineFile } from "./ast/format/outline.ts";
-import { outlinePath } from "./ast/queries/outline.ts";
-import { formatPathForDisplay, stripLeadingAt } from "./traverse.ts";
-
-const OPTIONS = { includePrivate: false, includeDocs: false, names: [] as readonly string[] };
-
-export function registerExploreOutlineInjection(
-	pi: ExtensionAPI,
-	rowState: ToolRowStateStore,
-	temporaryOutput: TemporaryOutputStore,
-	engineFor: (cwd: string) => ExploreEngine,
-): void {
-	registerOutlineInjectionProvider(pi, async (request) => {
-		const messages: PreparedOutlineInjection[] = [];
-		const warnings: string[] = [];
-		const engine = engineFor(request.cwd);
-		for (let index = 0; index < request.paths.length; index += 1) {
-			const path = stripLeadingAt(request.paths[index] ?? "");
-			assertCurrent(request.signal, request.isLifecycleCurrent);
-			try {
-				const abort = request.signal ?? new AbortController().signal;
-				const result = await outlinePath(engine, path, OPTIONS, abort);
-				if (result.mode !== "file") throw new Error("Working-memory outlines require a file path");
-				const body =
-					result.file.rows.length === 0
-						? formatOutlineEmpty(OPTIONS.names)
-						: formatOutlineFile(result.file, engine.cwd, false);
-				const builder = new BoundedTextResultBuilder(temporaryOutput, "completeBlocks");
-				let content: string;
-				try {
-					await builder.appendBlock(
-						result.file.path,
-						formatPathForDisplay(result.file.path, engine.cwd),
-						`${path}\n${body}`,
-					);
-					assertCurrent(request.signal, request.isLifecycleCurrent);
-					content = (await builder.finish()).content;
-				} catch (error) {
-					await builder.abort();
-					throw error;
-				}
-				messages.push({
-					customType: "tau.explore.outline" as const,
-					content,
-					display: true as const,
-					details: {
-						v: 1 as const,
-						rowId: `${request.batchId}:${index}`,
-						path,
-						cwd: request.cwd,
-						batchId: request.batchId,
-					},
-				});
-			} catch (error) {
-				if (request.signal?.aborted || !request.isLifecycleCurrent()) throw error;
-				warnings.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
-			}
-		}
-		return { messages, warnings };
-	});
-
-	pi.registerMessageRenderer<OutlineInjectionDetails>("tau.explore.outline", (message, options, theme) => {
-		const details = parseDetails(message.details);
-		if (!details) return undefined;
-		return new OutlineMessageComponent(
-			rowState,
-			details.rowId,
-			details.path,
-			typeof message.content === "string" ? message.content : "",
-			options.expanded,
-			theme,
-		);
-	});
-}
-
-function assertCurrent(signal: AbortSignal | undefined, isLifecycleCurrent: () => boolean): void {
-	signal?.throwIfAborted();
-	if (!isLifecycleCurrent()) throw new Error("Outline preparation crossed a session lifecycle boundary");
-}
-
-function parseDetails(value: unknown): OutlineInjectionDetails | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const details = value as Record<string, unknown>;
-	if (
-		details.v !== 1 ||
-		typeof details.rowId !== "string" ||
-		typeof details.path !== "string" ||
-		typeof details.cwd !== "string" ||
-		typeof details.batchId !== "string"
-	) {
-		return undefined;
-	}
-	return {
-		v: 1,
-		rowId: details.rowId,
-		path: details.path,
-		cwd: details.cwd,
-		batchId: details.batchId,
-	};
-}
-
-class OutlineMessageComponent {
-	private readonly rowState: ToolRowStateStore;
-	private readonly rowId: string;
-	private readonly path: string;
-	private readonly content: string;
-	private readonly expanded: boolean;
-	private readonly theme: Theme;
-
-	constructor(
-		rowState: ToolRowStateStore,
-		rowId: string,
-		path: string,
-		content: string,
-		expanded: boolean,
-		theme: Theme,
-	) {
-		this.rowState = rowState;
-		this.rowId = rowId;
-		this.path = path;
-		this.content = content;
-		this.expanded = expanded;
-		this.theme = theme;
-		this.rowState.watch(this.rowId, () => this.invalidate());
-	}
-
-	render(width: number): string[] {
-		const marker = new Marker({
-			theme: this.theme,
-			state: this.rowState.get(this.rowId) === "pruned" ? "warning" : "complete",
-			label: "outline",
-			parts: [this.path],
-		}).render(width);
-		if (!this.expanded) return marker;
-		return [...marker, ...new Text(this.theme.fg("dim", this.content), 1, 0).render(width)];
-	}
-
-	invalidate(): void {}
-}

package/extensions/explore/read/autoread.ts

@@ -1,118 +0,0 @@
-import { createHash } from "node:crypto";
-import { resolve } from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { prepareAutoreadMessage, registerAutoread, type PreparedAutoreadMessage } from "../../../shared/autoread.ts";
-import { createCompleteFileMeta } from "../../../shared/full-file-knowledge.ts";
-import { loadTauExtensionSettings } from "../../../shared/settings/load.ts";
-import type { ToolRowStateStore } from "../../../shared/tool-row-state.ts";
-import type { ExploreEngine } from "../ast/engine.ts";
-import { formatOutlineFile } from "../ast/format/outline.ts";
-import { formatLargeReadOutline, shouldOutlineFullRead, type ExploreReadSettings } from "../ast/read/policy.ts";
-import { outlinePath } from "../ast/queries/outline.ts";
-import exploreSettings from "../settings.ts";
-import { resolveExplorePath } from "../traverse.ts";
-
-const DEFAULT_OUTLINE_OPTIONS = {
-	includePrivate: false,
-	includeDocs: false,
-	names: [] as readonly string[],
-};
-
-export function registerExploreAutoread(
-	pi: ExtensionAPI,
-	rowState: ToolRowStateStore,
-	engineFor: (cwd: string) => ExploreEngine,
-): void {
-	let readSettings: ExploreReadSettings = exploreSettings.defaults.read;
-
-	pi.on("session_start", async (_event, ctx) => {
-		const settings = await loadTauExtensionSettings(ctx, exploreSettings);
-		readSettings = settings.read;
-	});
-
-	registerAutoread(pi, rowState, async (options) => {
-		return prepareExploreAutoreadMessage({
-			...options,
-			engine: engineFor(options.cwd),
-			readSettings,
-		});
-	});
-}
-
-async function prepareExploreAutoreadMessage(options: {
-	rowId: string;
-	path: string;
-	cwd: string;
-	source: string;
-	batchId: string;
-	signal: AbortSignal | undefined;
-	isLifecycleCurrent: () => boolean;
-	maximumBytes?: number;
-	engine: ExploreEngine;
-	readSettings: ExploreReadSettings;
-}): Promise<PreparedAutoreadMessage> {
-	const { engine, readSettings, ...shared } = options;
-	if (!readSettings.enabled) return prepareAutoreadMessage(shared);
-
-	const absolutePath = resolveExplorePath(options.cwd, options.path);
-	if (engine.registry.adapterForPath(absolutePath) === undefined) {
-		return prepareAutoreadMessage(shared);
-	}
-
-	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
-
-	let lineCount: number;
-	try {
-		const source = await engine.sourceForFile(absolutePath);
-		lineCount = source.ir.lineCount;
-	} catch {
-		return prepareAutoreadMessage(shared);
-	}
-
-	if (!shouldOutlineFullRead(lineCount, readSettings.structureThresholdLines)) {
-		return prepareAutoreadMessage(shared);
-	}
-
-	const abort = options.signal ?? new AbortController().signal;
-	const result = await outlinePath(engine, options.path, DEFAULT_OUTLINE_OPTIONS, abort);
-	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
-	if (result.mode !== "file") {
-		return prepareAutoreadMessage(shared);
-	}
-
-	const outlineBody =
-		result.file.rows.length === 0 ? "No declarations" : formatOutlineFile(result.file, engine.cwd, false);
-	const outlineText = formatLargeReadOutline(outlineBody);
-	const messageContent = `${options.path}\n${outlineText}`;
-	const pathKey = resolve(options.cwd, options.path);
-	const readCache = createCompleteFileMeta({
-		pathKey,
-		presentation: "plain",
-		servedHash: createHash("sha256").update(outlineText, "utf8").digest("hex"),
-		mode: "baseline",
-		sourceText: outlineText,
-		returnedText: messageContent,
-		totalLines: lineCount,
-		summary: `outline (${lineCount} lines)`,
-	});
-
-	return {
-		customType: "tau.autoread",
-		content: messageContent,
-		display: true,
-		details: {
-			rowId: options.rowId,
-			path: options.path,
-			cwd: options.cwd,
-			source: options.source,
-			batchId: options.batchId,
-			status: "read",
-			readCache,
-		},
-	};
-}
-
-function assertPreparationCurrent(signal: AbortSignal | undefined, isLifecycleCurrent: () => boolean): void {
-	signal?.throwIfAborted();
-	if (!isLifecycleCurrent()) throw new Error("Autoread preparation crossed a session lifecycle boundary");
-}

package/extensions/review/panel.ts

@@ -1,128 +0,0 @@
-import { bindingHint, bindingsHint, rawHint, ToolPanel } from "@shanepadgett/tau-tui";
-import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
-import { Markdown, type Component, type KeybindingsManager, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
-import { formatReviewMarkdown, reviewModeLabel, type ReviewMode, type ReviewRecord } from "./model.ts";
-
-export class ReviewProgressPanel implements Component {
-	private readonly tui: TUI;
-	private readonly panel: ToolPanel;
-	private readonly lines: string[] = [];
-
-	constructor(tui: TUI, theme: Theme, mode: ReviewMode, keys: KeybindingsManager, cancel: () => void) {
-		this.tui = tui;
-		this.panel = new ToolPanel(theme, {
-			title: `${reviewModeLabel(mode)} review`,
-			secondary: "Fresh isolated review · hidden from parent context",
-			body: {
-				render: (width) =>
-					(this.lines.length ? this.lines.slice(-5) : ["Starting review"]).map((line) =>
-						truncateToWidth(theme.fg("muted", line), width, "…"),
-					),
-				invalidate() {},
-			},
-			footer: { kind: "hints", hints: [bindingHint("tui.select.cancel", "cancel")] },
-			border: "box",
-		});
-		this.handleInput = (data) => {
-			if (!keys.matches(data, "tui.select.cancel")) return;
-			cancel();
-			this.update("Cancelling review");
-		};
-	}
-
-	handleInput: (data: string) => void;
-
-	update(status: string): void {
-		if (this.lines.at(-1) !== status) {
-			this.lines.push(status);
-			if (this.lines.length > 5) this.lines.shift();
-		}
-		this.tui.requestRender();
-	}
-
-	render(width: number): string[] {
-		return this.panel.render(width);
-	}
-
-	invalidate(): void {
-		this.panel.invalidate();
-	}
-}
-
-export type ReviewResultAction = "send" | "export" | "close";
-
-export class ReviewResultPanel implements Component {
-	private readonly panel: ToolPanel;
-	private readonly body: ReviewMarkdownBody;
-
-	constructor(
-		tui: TUI,
-		theme: Theme,
-		keys: KeybindingsManager,
-		review: ReviewRecord,
-		done: (action: ReviewResultAction) => void,
-	) {
-		this.body = new ReviewMarkdownBody(tui, formatReviewMarkdown(review));
-		this.panel = new ToolPanel(theme, {
-			title: `${reviewModeLabel(review.mode)} review · ${review.verdict}`,
-			secondary: `${review.findings.length} finding${review.findings.length === 1 ? "" : "s"} · not in parent context`,
-			body: this.body,
-			footer: {
-				kind: "hints",
-				hints: [
-					bindingsHint(["tui.select.up", "tui.select.down"], "scroll"),
-					rawHint("a", "send to agent"),
-					rawHint("e", "export"),
-					bindingHint("tui.select.cancel", "close"),
-				],
-			},
-			border: "box",
-		});
-		this.handleInput = (data) => {
-			if (keys.matches(data, "tui.select.up")) this.body.scroll(-1);
-			else if (keys.matches(data, "tui.select.down")) this.body.scroll(1);
-			else if (data === "a") done("send");
-			else if (data === "e") done("export");
-			else if (keys.matches(data, "tui.select.cancel")) done("close");
-		};
-	}
-
-	handleInput: (data: string) => void;
-
-	render(width: number): string[] {
-		return this.panel.render(width);
-	}
-
-	invalidate(): void {
-		this.panel.invalidate();
-	}
-}
-
-class ReviewMarkdownBody implements Component {
-	private readonly tui: TUI;
-	private readonly markdown: Markdown;
-	private offset = 0;
-	private maxOffset = 0;
-
-	constructor(tui: TUI, content: string) {
-		this.tui = tui;
-		this.markdown = new Markdown(content, 0, 0, getMarkdownTheme());
-	}
-
-	scroll(delta: number): void {
-		this.offset = Math.max(0, Math.min(this.maxOffset, this.offset + delta));
-		this.tui.requestRender();
-	}
-
-	render(width: number): string[] {
-		const lines = this.markdown.render(width);
-		const height = Math.max(4, Math.floor(this.tui.terminal.rows * 0.9) - 9);
-		this.maxOffset = Math.max(0, lines.length - height);
-		this.offset = Math.min(this.offset, this.maxOffset);
-		return lines.slice(this.offset, this.offset + height);
-	}
-
-	invalidate(): void {
-		this.markdown.invalidate();
-	}
-}

package/extensions/working-memory/README.md

@@ -1,17 +0,0 @@
-# Working Memory
-
-Working Memory gives agent selective checkpoints without changing saved conversation.
-
-`working_memory` retains at least one referenced user message or visible assistant text. Keep task framing, constraints, decisions, and active work chain; continuation and file tiers support that conversation context. It has three file tiers:
-
-- Auto-read full source into next turn when agent needs its body to decide, edit, or debug.
-- Carry a structural outline when symbols and locations will support a later scoped read.
-- Defer inactive files with reason and condition that makes them relevant again.
-
-Use one tier for each path. `readFiles` publishes Tau's built-in autoread request; `outlineFiles` injects a structural outline; `deferFiles` records a conditional reminder.
-
-`continuation` is a working note for next step: keep durable decisions, findings, unresolved questions, remaining work, and next action. It should carry enough reasoning to resume without rereading discarded results.
-
-Automatic reminders begin at 40,000 active-context tokens and remain advisory. Run `/prune` to request reassessment manually.
-
-Settings live under `extensions.workingMemory`.

package/extensions/working-memory/checkpoint.ts

@@ -1,242 +0,0 @@
-import { resolve } from "node:path";
-import { type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
-import { type Static, Type } from "typebox";
-import { truncateBoundedHead } from "../../shared/bounded-text-result.ts";
-import { emitTauEvent } from "../../shared/events.ts";
-import { requestOutlineInjections, type PreparedOutlineInjection } from "../../shared/outline-injection.ts";
-import { buildMemoryCatalog, collectPrunedRowIds } from "./memory.ts";
-import {
-	replayWorkingMemoryState,
-	WORKING_MEMORY_TOOL,
-	type DeferredFile,
-	type WorkingMemoryCheckpointDetailsV2,
-} from "./state.ts";
-
-const PATH = Type.String({ minLength: 1, maxLength: 500, pattern: "\\S" });
-
-export const workingMemoryParameters = Type.Object(
-	{
-		continuation: Type.String({
-			minLength: 1,
-			maxLength: 8_000,
-			pattern: "\\S",
-			description:
-				"Working note for resuming mid-task. Carry durable decisions, concrete findings, live reasoning, unresolved questions, remaining work, and next action; include enough detail to continue without rereading discarded results.",
-		}),
-		keep: Type.Array(Type.String({ minLength: 3, maxLength: 100 }), { minItems: 1, maxItems: 100 }),
-		readFiles: Type.Array(PATH, {
-			maxItems: 12,
-			description:
-				"Files whose source should be auto-read into the next turn. Use when the next work needs the complete file; do not also outline or defer these files.",
-		}),
-		outlineFiles: Type.Array(PATH, {
-			maxItems: 12,
-			description:
-				"Files whose structural outline should be carried into the next turn. Use when symbols and locations will guide later scoped inspection; do not use when the full source is still needed.",
-		}),
-		deferFiles: Type.Array(
-			Type.Object(
-				{
-					path: PATH,
-					reason: Type.String({ minLength: 1, maxLength: 300, pattern: "\\S" }),
-					relevantWhen: Type.String({ minLength: 1, maxLength: 300, pattern: "\\S" }),
-				},
-				{ additionalProperties: false },
-			),
-			{
-				maxItems: 8,
-				description:
-					"Files to leave out of active context. Record why they are inactive and the concrete condition that would make them relevant.",
-			},
-		),
-	},
-	{ additionalProperties: false },
-);
-
-export type WorkingMemoryInput = Static<typeof workingMemoryParameters>;
-
-interface ExecuteWorkingMemoryOptions {
-	pi: Pick<ExtensionAPI, "events">;
-	toolCallId: string;
-	params: WorkingMemoryInput;
-	signal: AbortSignal | undefined;
-	ctx: ExtensionContext;
-	generation: number;
-	currentGeneration(): number;
-}
-
-export interface WorkingMemoryExecution {
-	result: {
-		content: Array<{ type: "text"; text: string }>;
-		details: WorkingMemoryCheckpointDetailsV2;
-	};
-	outlines: PreparedOutlineInjection[];
-}
-
-export async function executeWorkingMemory(options: ExecuteWorkingMemoryOptions): Promise<WorkingMemoryExecution> {
-	assertCurrent(options);
-	const branch = options.ctx.sessionManager.getBranch();
-	const catalog = buildMemoryCatalog(branch);
-	const anchorIndex = findAnchorEntry(branch, options.toolCallId);
-	const previousState = replayWorkingMemoryState(branch, true);
-	const previousAnchorIndex =
-		previousState.latestAnchorToolCallId === undefined
-			? -1
-			: findAnchorEntry(branch, previousState.latestAnchorToolCallId);
-	const requestedRefs = [...new Set(options.params.keep)];
-	const retained = requestedRefs
-		.flatMap((ref) => {
-			const unit = catalog.get(ref);
-			return unit ? [unit] : [];
-		})
-		.sort((left, right) => left.order - right.order);
-	const retainedRefs = retained.map((unit) => unit.ref);
-	if (retained.length === 0) {
-		throw new Error("working_memory requires at least one valid keep reference");
-	}
-	const warnings = requestedRefs
-		.filter((ref) => !catalog.has(ref))
-		.map((ref) => `${ref}: memory reference is unavailable and was not retained`);
-
-	const rootInstructionsKey = resolve(options.ctx.cwd, "AGENTS.md");
-	const requestedRootInstructions = [
-		...options.params.readFiles,
-		...options.params.outlineFiles,
-		...options.params.deferFiles.map((file) => file.path),
-	].some((path) => resolve(options.ctx.cwd, normalizePath(path)) === rootInstructionsKey);
-	if (requestedRootInstructions) {
-		warnings.push(
-			"AGENTS.md: omitted from working-memory checkpoint because it is already in your context window. Read it directly only when actively changing it.",
-		);
-	}
-
-	const readPaths = dedupePaths(options.params.readFiles, options.ctx.cwd).filter(
-		(path) => resolve(options.ctx.cwd, path) !== rootInstructionsKey,
-	);
-	const readKeys = new Set(readPaths.map((path) => resolve(options.ctx.cwd, path)));
-	const outlinePaths = dedupePaths(options.params.outlineFiles, options.ctx.cwd).filter(
-		(path) => resolve(options.ctx.cwd, path) !== rootInstructionsKey && !readKeys.has(resolve(options.ctx.cwd, path)),
-	);
-	const outlineResponse = await requestOutlineInjections(options.pi, {
-		cwd: options.ctx.cwd,
-		batchId: options.toolCallId,
-		paths: outlinePaths,
-		signal: options.signal,
-		isLifecycleCurrent: () => options.generation === options.currentGeneration(),
-	});
-	warnings.push(...outlineResponse.warnings.map((warning) => boundedWarning(warning)));
-	assertCurrent(options);
-
-	const carriedKeys = new Set([
-		...readKeys,
-		...outlineResponse.messages.map((message) => resolve(options.ctx.cwd, message.details.path)),
-	]);
-	const deferredFiles: DeferredFile[] = [];
-	const deferredKeys = new Set<string>();
-	for (const file of options.params.deferFiles) {
-		const path = normalizePath(file.path);
-		const key = resolve(options.ctx.cwd, path);
-		if (key === rootInstructionsKey || carriedKeys.has(key) || deferredKeys.has(key)) continue;
-		deferredKeys.add(key);
-		deferredFiles.push({ path, reason: file.reason.trim(), relevantWhen: file.relevantWhen.trim() });
-	}
-
-	if (readPaths.length > 0) {
-		emitTauEvent(options.pi, "tau:autoread.requested", {
-			source: WORKING_MEMORY_TOOL,
-			title: "Working-memory checkpoint",
-			cwd: options.ctx.cwd,
-			batchId: options.toolCallId,
-			files: readPaths.map((path) => ({ path })),
-		});
-	}
-
-	const prunedRowIds = collectPrunedRowIds(branch, anchorIndex);
-	const activeRefs = new Set(previousState.retainedRefs.filter((ref) => catalog.has(ref)));
-	for (const unit of catalog.values()) {
-		if (unit.order > previousAnchorIndex && unit.order < anchorIndex) activeRefs.add(unit.ref);
-	}
-	const newlyPrunedRows = prunedRowIds.filter((rowId) => !previousState.prunedRowIds.has(rowId));
-	const droppedBlocks = [...activeRefs].filter((ref) => !retainedRefs.includes(ref)).length + newlyPrunedRows.length;
-	const details: WorkingMemoryCheckpointDetailsV2 = {
-		v: 2,
-		anchorToolCallId: options.toolCallId,
-		retainedRefs,
-		retainedLabels: retained.map((unit) => ({ ref: unit.ref, label: unit.label, preview: unit.preview })),
-		prunedRowIds,
-		readFiles: readPaths,
-		outlinedFiles: outlineResponse.messages.map((message) => ({
-			path: message.details.path,
-			rowId: message.details.rowId,
-		})),
-		deferredFiles,
-		removedUnits: droppedBlocks,
-		warnings,
-	};
-	const markdown = formatResult(options.params.continuation.trim(), deferredFiles, warnings);
-	return {
-		result: { content: [{ type: "text", text: truncateBoundedHead(markdown).content }], details },
-		outlines: outlineResponse.messages,
-	};
-}
-
-function formatResult(continuation: string, deferred: readonly DeferredFile[], warnings: readonly string[]): string {
-	const sections = [`## Continue\n\n${continuation}`];
-	if (deferred.length > 0) {
-		sections.push(
-			`## Deferred files\n\n${deferred
-				.map((file) => `- \`${escapeCode(file.path)}\` — ${file.reason} Reconsider when: ${file.relevantWhen}.`)
-				.join("\n")}`,
-		);
-	}
-	if (warnings.length > 0) sections.push(`## Warnings\n\n${warnings.map((warning) => `- ${warning}`).join("\n")}`);
-	return sections.join("\n\n");
-}
-
-function dedupePaths(paths: readonly string[], cwd: string): string[] {
-	const keys = new Set<string>();
-	const result: string[] = [];
-	for (const raw of paths) {
-		const path = normalizePath(raw);
-		const key = resolve(cwd, path);
-		if (keys.has(key)) continue;
-		keys.add(key);
-		result.push(path);
-	}
-	return result;
-}
-
-function findAnchorEntry(branch: readonly SessionEntry[], toolCallId: string): number {
-	for (let index = branch.length - 1; index >= 0; index -= 1) {
-		const entry = branch[index];
-		if (
-			entry?.type === "message" &&
-			entry.message.role === "assistant" &&
-			entry.message.content.some(
-				(block) => block.type === "toolCall" && block.id === toolCallId && block.name === WORKING_MEMORY_TOOL,
-			)
-		) {
-			return index;
-		}
-	}
-	return -1;
-}
-
-function normalizePath(path: string): string {
-	return path.trim().replace(/^@/, "");
-}
-
-function escapeCode(path: string): string {
-	return path.replaceAll("`", "\\`");
-}
-
-function boundedWarning(warning: string): string {
-	return warning.length <= 500 ? warning : `${warning.slice(0, 499)}…`;
-}
-
-function assertCurrent(options: ExecuteWorkingMemoryOptions): void {
-	options.signal?.throwIfAborted();
-	if (options.generation !== options.currentGeneration()) {
-		throw new Error("Working-memory checkpoint crossed a session lifecycle boundary");
-	}
-}