@shanepadgett/tau-agent 0.33.1 → 0.35.0

package/extensions/working-memory/render.ts

@@ -1,185 +0,0 @@
-import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
-import { Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { Marker } from "@shanepadgett/tau-tui";
-import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.ts";
-import type { WorkingMemoryInput } from "./checkpoint.ts";
-import { parseWorkingMemoryDetails } from "./state.ts";
-
-const MAX_ITEMS = 20;
-const MAX_LINE = 240;
-const MAX_TEXT = 4_000;
-
-export type WorkingMemoryNudgeDetails =
-	| {
-			v: 1;
-			kind: "automatic";
-			tokens: number;
-			boundaryTokens: number;
-			reminder: number;
-			tier: number;
-			tierCount: number;
-			anchorToolCallId: string | null;
-	  }
-	| {
-			v: 1;
-			kind: "manual";
-			tokens: null;
-			boundaryTokens: null;
-			reminder: null;
-			tier: null;
-			tierCount: null;
-			anchorToolCallId: string | null;
-	  };
-
-export function parseWorkingMemoryNudge(value: unknown): WorkingMemoryNudgeDetails | undefined {
-	if (!isRecord(value) || value.v !== 1 || (value.kind !== "automatic" && value.kind !== "manual")) return undefined;
-	if (value.anchorToolCallId !== null && !nonempty(value.anchorToolCallId)) return undefined;
-	if (value.kind === "manual") {
-		if (
-			value.tokens !== null ||
-			value.boundaryTokens !== null ||
-			value.reminder !== null ||
-			value.tier !== null ||
-			value.tierCount !== null
-		) {
-			return undefined;
-		}
-		return {
-			v: 1,
-			kind: "manual",
-			tokens: null,
-			boundaryTokens: null,
-			reminder: null,
-			tier: null,
-			tierCount: null,
-			anchorToolCallId: value.anchorToolCallId,
-		};
-	}
-	if (
-		!count(value.tokens, 0) ||
-		!count(value.boundaryTokens, 1) ||
-		!count(value.reminder, 1) ||
-		!count(value.tier, 1, 5) ||
-		!count(value.tierCount, 1, 5) ||
-		value.boundaryTokens > value.tokens ||
-		value.tier > value.tierCount ||
-		value.tier !== Math.min(value.reminder, value.tierCount)
-	) {
-		return undefined;
-	}
-	return {
-		v: 1,
-		kind: "automatic",
-		tokens: value.tokens,
-		boundaryTokens: value.boundaryTokens,
-		reminder: value.reminder,
-		tier: value.tier,
-		tierCount: value.tierCount,
-		anchorToolCallId: value.anchorToolCallId,
-	};
-}
-
-export function renderWorkingMemoryNudge(details: unknown, theme: Theme): Marker | undefined {
-	const parsed = parseWorkingMemoryNudge(details);
-	if (!parsed) return undefined;
-	return new Marker({
-		theme,
-		state: "muted",
-		label: "Memory:",
-		parts:
-			parsed.kind === "manual" ? ["Reassessment requested."] : [formatTokens(parsed.boundaryTokens), "Reassess."],
-	});
-}
-
-export function renderWorkingMemoryCall(
-	args: WorkingMemoryInput,
-	theme: Theme,
-	context: {
-		rowState: ToolRowStateStore;
-		rowId: string;
-		invalidate: () => void;
-		lastComponent: unknown;
-		executionStarted: boolean;
-	},
-): Text {
-	context.rowState.watch(context.rowId, context.invalidate);
-	const component = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-	if (context.executionStarted) {
-		component.setText("");
-		return component;
-	}
-	const kept = Array.isArray(args.keep) ? args.keep.length : 0;
-	const read = Array.isArray(args.readFiles) ? args.readFiles.length : 0;
-	const outlined = Array.isArray(args.outlineFiles) ? args.outlineFiles.length : 0;
-	const deferred = Array.isArray(args.deferFiles) ? args.deferFiles.length : 0;
-	component.setText(
-		`${formatToolRowTitle(context.rowState, context.rowId, "working_memory", theme)} ${theme.fg("muted", `${kept} kept · ${read} read · ${outlined} outline · ${deferred} deferred`)}`,
-	);
-	return component;
-}
-
-export function renderWorkingMemoryResult(
-	result: AgentToolResult<unknown>,
-	expanded: boolean,
-	theme: Theme,
-	lastComponent: unknown,
-): Text {
-	const component = lastComponent instanceof Text ? lastComponent : new Text("", 0, 0);
-	const details = parseWorkingMemoryDetails(result.details);
-	if (!details) {
-		component.setText(
-			theme.fg("warning", bounded(firstText(result) || "working_memory returned invalid details", 1_000)),
-		);
-		return component;
-	}
-	let text = theme.fg(
-		details.warnings.length === 0 ? "success" : "warning",
-		`Checkpoint · kept ${details.retainedRefs.length} · read ${details.readFiles.length} · outlined ${details.outlinedFiles.length} · deferred ${details.deferredFiles.length} · pruned ${details.removedUnits}${details.warnings.length === 0 ? "" : ` · warnings ${details.warnings.length}`}`,
-	);
-	if (expanded) {
-		const lines = [
-			bounded(firstText(result), 1_500),
-			...details.retainedLabels.map((item) => `${item.ref} ${item.label}: ${item.preview}`),
-			...details.readFiles.map((path) => `read: ${path}`),
-			...details.outlinedFiles.map((file) => `outlined: ${file.path}`),
-			...details.deferredFiles.map((file) => `deferred: ${file.path} — ${file.reason}; when ${file.relevantWhen}`),
-			...details.warnings.map((warning) => `warning: ${warning}`),
-		].filter(Boolean);
-		let remaining = MAX_TEXT - visibleWidth(text);
-		for (const line of lines.slice(0, MAX_ITEMS)) {
-			if (remaining <= 1) break;
-			const styled = theme.fg("dim", bounded(line, MAX_LINE));
-			text += `\n${truncateToWidth(styled, remaining - 1, "…")}`;
-			remaining -= 1 + Math.min(visibleWidth(styled), remaining - 1);
-		}
-		if (lines.length > MAX_ITEMS && remaining > 10)
-			text += `\n${theme.fg("dim", `… ${lines.length - MAX_ITEMS} more`)}`;
-	}
-	component.setText(text);
-	return component;
-}
-
-function firstText(result: AgentToolResult<unknown>): string {
-	for (const part of result.content) if (part.type === "text") return part.text;
-	return "";
-}
-
-function bounded(text: string, maximum: number): string {
-	return text.length <= maximum ? text : `${text.slice(0, maximum - 1)}…`;
-}
-
-function formatTokens(tokens: number): string {
-	return tokens < 1_000 ? `${tokens}` : `${Math.round(tokens / 1_000)}k`;
-}
-
-function count(value: unknown, minimum: number, maximum = Number.MAX_SAFE_INTEGER): value is number {
-	return Number.isSafeInteger(value) && (value as number) >= minimum && (value as number) <= maximum;
-}
-
-function nonempty(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/extensions/working-memory/settings.ts

@@ -1,38 +0,0 @@
-import { Type } from "typebox";
-import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
-
-const DEFAULT_NUDGE_INSTRUCTIONS: [string, ...string[]] = [
-	"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.",
-];
-
-export default defineTauExtensionSettings({
-	key: "workingMemory",
-	defaults: {
-		enabled: true as boolean,
-		nudgeEveryTokens: 40_000 as number,
-		nudgeInstructions: DEFAULT_NUDGE_INSTRUCTIONS,
-	},
-	schema: Type.Object(
-		{
-			enabled: Type.Optional(Type.Boolean({ default: true, description: "Enable working-memory checkpoints." })),
-			nudgeEveryTokens: Type.Optional(
-				Type.Integer({
-					default: 40_000,
-					minimum: 1,
-					description: "Active-context token interval between advisory working-memory reminders.",
-				}),
-			),
-			nudgeInstructions: Type.Optional(
-				Type.Array(Type.String({ minLength: 1, maxLength: 2_000 }), {
-					default: DEFAULT_NUDGE_INSTRUCTIONS,
-					minItems: 1,
-					maxItems: 5,
-					description: "Ordered advisory working-memory instructions. Later reminders repeat final instruction.",
-				}),
-			),
-		},
-		{ additionalProperties: false },
-	),
-});

package/extensions/working-memory/state.ts

@@ -1,158 +0,0 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-
-export const WORKING_MEMORY_TOOL = "working_memory";
-
-export interface DeferredFile {
-	path: string;
-	reason: string;
-	relevantWhen: string;
-}
-
-export interface RetainedLabel {
-	ref: string;
-	label: string;
-	preview: string;
-}
-
-export interface WorkingMemoryCheckpointDetailsV2 {
-	v: 2;
-	anchorToolCallId: string;
-	retainedRefs: string[];
-	retainedLabels: RetainedLabel[];
-	prunedRowIds: string[];
-	readFiles: string[];
-	outlinedFiles: Array<{ path: string; rowId: string }>;
-	deferredFiles: DeferredFile[];
-	removedUnits: number;
-	warnings: string[];
-}
-
-export interface ActiveWorkingMemoryState {
-	latestAnchorToolCallId: string | undefined;
-	retainedRefs: readonly string[];
-	prunedRowIds: ReadonlySet<string>;
-}
-
-export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpointDetailsV2 | undefined {
-	if (!isRecord(value) || value.v !== 2 || !nonempty(value.anchorToolCallId)) return undefined;
-	const keys = [
-		"v",
-		"anchorToolCallId",
-		"retainedRefs",
-		"retainedLabels",
-		"prunedRowIds",
-		"readFiles",
-		"outlinedFiles",
-		"deferredFiles",
-		"removedUnits",
-		"warnings",
-	];
-	if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return undefined;
-	const retainedRefs = uniqueStrings(value.retainedRefs);
-	const prunedRowIds = uniqueStrings(value.prunedRowIds);
-	const readFiles = uniqueStrings(value.readFiles);
-	const warnings = strings(value.warnings);
-	const retainedLabels = parseRetainedLabels(value.retainedLabels);
-	const outlinedFiles = parseOutlinedFiles(value.outlinedFiles);
-	const deferredFiles = parseDeferredFiles(value.deferredFiles);
-	if (
-		!retainedRefs ||
-		retainedRefs.length === 0 ||
-		!prunedRowIds ||
-		!readFiles ||
-		!warnings ||
-		!retainedLabels ||
-		retainedLabels.length !== retainedRefs.length ||
-		retainedLabels.some((label, index) => label.ref !== retainedRefs[index]) ||
-		!outlinedFiles ||
-		!deferredFiles ||
-		!Number.isSafeInteger(value.removedUnits) ||
-		(value.removedUnits as number) < 0
-	) {
-		return undefined;
-	}
-	return {
-		v: 2,
-		anchorToolCallId: value.anchorToolCallId,
-		retainedRefs,
-		retainedLabels,
-		prunedRowIds,
-		readFiles,
-		outlinedFiles,
-		deferredFiles,
-		removedUnits: value.removedUnits as number,
-		warnings,
-	};
-}
-
-export function replayWorkingMemoryState(branch: readonly SessionEntry[], enabled: boolean): ActiveWorkingMemoryState {
-	let prunedRowIds = new Set<string>();
-	let latestAnchorToolCallId: string | undefined;
-	let retainedRefs: readonly string[] = [];
-	if (enabled) {
-		for (const entry of branch) {
-			if (entry.type !== "message" || entry.message.role !== "toolResult") continue;
-			if (entry.message.toolName !== WORKING_MEMORY_TOOL) continue;
-			const details = parseWorkingMemoryDetails(entry.message.details);
-			if (!details || details.anchorToolCallId !== entry.message.toolCallId) continue;
-			prunedRowIds = new Set(details.prunedRowIds);
-			latestAnchorToolCallId = details.anchorToolCallId;
-			retainedRefs = details.retainedRefs;
-		}
-	}
-	return { latestAnchorToolCallId, retainedRefs, prunedRowIds };
-}
-
-function parseRetainedLabels(value: unknown): RetainedLabel[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const labels: RetainedLabel[] = [];
-	for (const item of value) {
-		if (!isRecord(item) || !nonempty(item.ref) || !nonempty(item.label) || typeof item.preview !== "string") {
-			return undefined;
-		}
-		labels.push({ ref: item.ref, label: item.label, preview: item.preview });
-	}
-	return labels;
-}
-
-function parseOutlinedFiles(value: unknown): Array<{ path: string; rowId: string }> | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const files: Array<{ path: string; rowId: string }> = [];
-	for (const item of value) {
-		if (!isRecord(item) || !nonempty(item.path) || !nonempty(item.rowId)) return undefined;
-		files.push({ path: item.path, rowId: item.rowId });
-	}
-	return files;
-}
-
-function parseDeferredFiles(value: unknown): DeferredFile[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const files: DeferredFile[] = [];
-	for (const item of value) {
-		if (!isRecord(item) || !nonempty(item.path) || !nonempty(item.reason) || !nonempty(item.relevantWhen)) {
-			return undefined;
-		}
-		files.push({ path: item.path, reason: item.reason, relevantWhen: item.relevantWhen });
-	}
-	return files;
-}
-
-function uniqueStrings(value: unknown): string[] | undefined {
-	const parsed = strings(value, true);
-	if (!parsed || new Set(parsed).size !== parsed.length) return undefined;
-	return parsed;
-}
-
-function strings(value: unknown, requireNonempty = false): string[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	if (!value.every((item) => typeof item === "string" && (!requireNonempty || item.length > 0))) return undefined;
-	return [...value];
-}
-
-function nonempty(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/shared/autoread.ts

@@ -1,234 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { Marker, type MarkerState } from "@shanepadgett/tau-tui";
-import { onTauEvent, type TauAgentEvents } from "./events.js";
-import { createCompleteFileMeta, type ReadCacheMetaV1 } from "./full-file-knowledge.ts";
-import type { ToolRowStateStore } from "./tool-row-state.js";
-
-const AUTOREAD_MESSAGE_TYPE = "tau.autoread";
-
-type AutoreadStatus = "reading" | "read" | "failed";
-
-export interface AutoreadDetails {
-	rowId: string;
-	path: string;
-	cwd: string;
-	source: string;
-	batchId: string;
-	status: AutoreadStatus;
-	error?: string;
-	readCache?: ReadCacheMetaV1;
-}
-
-export interface PreparedAutoreadMessage {
-	customType: typeof AUTOREAD_MESSAGE_TYPE;
-	content: string;
-	display: true;
-	details: AutoreadDetails & { status: "read"; readCache: ReadCacheMetaV1 };
-}
-
-export type PrepareAutoreadMessage = (options: {
-	rowId: string;
-	path: string;
-	cwd: string;
-	source: string;
-	batchId: string;
-	signal: AbortSignal | undefined;
-	isLifecycleCurrent: () => boolean;
-	maximumBytes?: number;
-}) => Promise<PreparedAutoreadMessage>;
-
-export async function prepareAutoreadMessage(options: {
-	rowId: string;
-	path: string;
-	cwd: string;
-	source: string;
-	batchId: string;
-	signal: AbortSignal | undefined;
-	isLifecycleCurrent: () => boolean;
-	maximumBytes?: number;
-}): Promise<PreparedAutoreadMessage> {
-	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
-	const pathKey = resolve(options.cwd, options.path);
-	const bytes = options.signal ? await readFile(pathKey, { signal: options.signal }) : await readFile(pathKey);
-	if (options.maximumBytes !== undefined && bytes.byteLength > options.maximumBytes) {
-		throw new Error(`File exceeds the ${options.maximumBytes}-byte complete-file snapshot limit`);
-	}
-	const content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-	const messageContent = `${options.path}\n${content}`;
-	const totalLines = content.split("\n").length;
-	const readCache = createCompleteFileMeta({
-		pathKey,
-		presentation: "plain",
-		servedHash: createHash("sha256").update(content, "utf8").digest("hex"),
-		mode: "baseline",
-		sourceText: content,
-		returnedText: messageContent,
-		totalLines,
-		summary: `${totalLines} lines`,
-	}) satisfies ReadCacheMetaV1;
-	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
-	return {
-		customType: AUTOREAD_MESSAGE_TYPE,
-		content: messageContent,
-		display: true,
-		details: {
-			rowId: options.rowId,
-			path: options.path,
-			cwd: options.cwd,
-			source: options.source,
-			batchId: options.batchId,
-			status: "read",
-			readCache,
-		},
-	};
-}
-
-export function registerAutoread(
-	pi: ExtensionAPI,
-	rowState: ToolRowStateStore,
-	prepare: PrepareAutoreadMessage = prepareAutoreadMessage,
-): void {
-	let lifecycleGeneration = 0;
-	pi.on("session_start", () => {
-		lifecycleGeneration += 1;
-	});
-	pi.on("session_compact", () => {
-		lifecycleGeneration += 1;
-	});
-	pi.on("session_tree", () => {
-		lifecycleGeneration += 1;
-	});
-	pi.on("session_shutdown", () => {
-		lifecycleGeneration += 1;
-	});
-	onTauEvent(pi, "shared.autoread", "tau:autoread.requested", async (data) => {
-		const event = readAutoreadRequestedEvent(data);
-		if (!event) return;
-		const generation = lifecycleGeneration;
-		await Promise.all(
-			event.files.map(async (file, index) => {
-				const rowId = `${event.batchId}:${index}`;
-				const details = {
-					rowId,
-					path: file.path,
-					cwd: event.cwd,
-					source: event.source,
-					batchId: event.batchId,
-				} satisfies Omit<AutoreadDetails, "status" | "error">;
-				try {
-					const message = await prepare({
-						...details,
-						signal: undefined,
-						isLifecycleCurrent: () => generation === lifecycleGeneration,
-					});
-					pi.sendMessage(message);
-				} catch (error) {
-					if (generation !== lifecycleGeneration) return;
-					const message = error instanceof Error ? error.message : String(error);
-					pi.sendMessage({
-						customType: AUTOREAD_MESSAGE_TYPE,
-						content: `${file.path}\nAutoread failed: ${message}`,
-						display: true,
-						details: { ...details, status: "failed", error: message },
-					});
-				}
-			}),
-		);
-	});
-
-	pi.registerMessageRenderer<AutoreadDetails>(AUTOREAD_MESSAGE_TYPE, (message, _options, theme) => {
-		const details = readDetails(message.details);
-		if (!details) return undefined;
-		return new AutoreadMessageComponent(rowState, details.rowId, details.path, details.status, theme);
-	});
-}
-
-function assertPreparationCurrent(signal: AbortSignal | undefined, isLifecycleCurrent: () => boolean): void {
-	signal?.throwIfAborted();
-	if (!isLifecycleCurrent()) throw new Error("Autoread preparation crossed a session lifecycle boundary");
-}
-
-function readAutoreadRequestedEvent(value: unknown): TauAgentEvents["tau:autoread.requested"] | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	if (typeof record.source !== "string") return undefined;
-	if (typeof record.cwd !== "string") return undefined;
-	if (typeof record.batchId !== "string") return undefined;
-	if (record.title !== undefined && typeof record.title !== "string") return undefined;
-	if (!Array.isArray(record.files)) return undefined;
-	const files: Array<{ path: string }> = [];
-	for (const file of record.files) {
-		if (!file || typeof file !== "object") return undefined;
-		const path = (file as Record<string, unknown>).path;
-		if (typeof path !== "string") return undefined;
-		files.push({ path });
-	}
-
-	return {
-		source: record.source,
-		...(record.title === undefined ? {} : { title: record.title }),
-		cwd: record.cwd,
-		batchId: record.batchId,
-		files,
-	};
-}
-
-function readDetails(value: unknown): AutoreadDetails | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	if (typeof record.rowId !== "string") return undefined;
-	if (typeof record.path !== "string") return undefined;
-	if (typeof record.cwd !== "string") return undefined;
-	if (typeof record.source !== "string") return undefined;
-	if (typeof record.batchId !== "string") return undefined;
-	if (record.status !== "reading" && record.status !== "read" && record.status !== "failed") return undefined;
-	return {
-		rowId: record.rowId,
-		path: record.path,
-		cwd: record.cwd,
-		source: record.source,
-		batchId: record.batchId,
-		status: record.status,
-		...(typeof record.error === "string" ? { error: record.error } : {}),
-	};
-}
-
-class AutoreadMessageComponent {
-	private readonly rowState: ToolRowStateStore;
-	private readonly rowId: string;
-	private readonly path: string;
-	private readonly status: AutoreadStatus;
-	private readonly theme: Theme;
-
-	constructor(rowState: ToolRowStateStore, rowId: string, path: string, status: AutoreadStatus, theme: Theme) {
-		this.rowState = rowState;
-		this.rowId = rowId;
-		this.path = path;
-		this.status = status;
-		this.theme = theme;
-		this.rowState.watch(this.rowId, () => this.invalidate());
-	}
-
-	render(width: number): string[] {
-		return new Marker({
-			theme: this.theme,
-			state: this.markerState(),
-			label: "autoread",
-			parts: [this.path],
-		}).render(width);
-	}
-
-	invalidate(): void {
-		// Rendering is stateless; this watcher gives the owning custom-message row
-		// the invalidation signal needed to redraw after a row-state snapshot.
-	}
-
-	private markerState(): MarkerState {
-		if (this.rowState.get(this.rowId) === "pruned") return "warning";
-		if (this.status === "failed") return "error";
-		return this.status === "reading" ? "busy" : "complete";
-	}
-}

package/shared/context-messages.ts

@@ -1,19 +0,0 @@
-import type { ContextEvent } from "@earendil-works/pi-coding-agent";
-
-type ContextMessage = ContextEvent["messages"][number];
-
-export const CONTEXT_PROJECTION_TYPE = "tau.context.projection";
-
-export function isContextProjectionMessage(message: ContextMessage): boolean {
-	return message.role === "custom" && message.customType === CONTEXT_PROJECTION_TYPE;
-}
-
-export function isLegacyContextMessage(message: ContextMessage): boolean {
-	if (message.role !== "custom") return false;
-	if (message.customType !== "tau.injected-context" && message.customType !== "tau.autoread") return false;
-	return (
-		message.details !== undefined &&
-		typeof message.details === "object" &&
-		(message.details as Record<string, unknown>).source === "context"
-	);
-}

package/shared/outline-injection.ts

@@ -1,56 +0,0 @@
-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`),
-	};
-}