@shanepadgett/tau-agent 0.15.0 → 0.17.0

package/shared/context-pruning-state.ts

@@ -0,0 +1,364 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+const CONTEXT_PRUNE_TOOL = "context_prune";
+const AUTOREAD_MESSAGE_TYPE = "tau.autoread";
+
+export interface ContextPruneRefreshedFileV1 {
+	path: string;
+	rowId: string;
+	servedHash: string;
+}
+
+export interface ContextPruneDeferredFileV1 {
+	path: string;
+	reason: string;
+	relevantWhen: string;
+}
+
+export interface ContextPruneDetailsV1 {
+	v: 1;
+	status: "applied" | "skipped";
+	anchorToolCallId: string;
+	newlyPrunedToolCallIds: string[];
+	newlyPrunedAutoreadRowIds: string[];
+	retainedToolCallIds: string[];
+	retainedAutoreadRowIds: string[];
+	refreshedFiles: ContextPruneRefreshedFileV1[];
+	deferredFiles: ContextPruneDeferredFileV1[];
+	tokensBefore: number;
+	tokensAfter: number;
+	tokensReclaimed: number;
+}
+
+export interface ActiveContextPruningState {
+	latestAnchorToolCallId: string | undefined;
+	prunedToolCallIds: ReadonlySet<string>;
+	prunedAutoreadRowIds: ReadonlySet<string>;
+	deferredFiles: readonly ContextPruneDeferredFileV1[];
+}
+
+const RUNTIME_ENABLED_KEY = Symbol.for("@earendil-works/tau-agent/context-pruning-enabled");
+const runtimeState = globalThis as typeof globalThis & { [key: symbol]: unknown };
+
+export function setContextPruningEnabled(enabled: boolean): void {
+	runtimeState[RUNTIME_ENABLED_KEY] = enabled;
+}
+
+function isContextPruningEnabled(): boolean {
+	return runtimeState[RUNTIME_ENABLED_KEY] === true;
+}
+
+export function parseContextPruneDetailsV1(value: unknown): ContextPruneDetailsV1 | undefined {
+	if (
+		!hasExactKeys(value, [
+			"v",
+			"status",
+			"anchorToolCallId",
+			"newlyPrunedToolCallIds",
+			"newlyPrunedAutoreadRowIds",
+			"retainedToolCallIds",
+			"retainedAutoreadRowIds",
+			"refreshedFiles",
+			"deferredFiles",
+			"tokensBefore",
+			"tokensAfter",
+			"tokensReclaimed",
+		])
+	)
+		return undefined;
+	if (value.v !== 1 || (value.status !== "applied" && value.status !== "skipped")) return undefined;
+	if (!isNonEmptyString(value.anchorToolCallId)) return undefined;
+
+	const newlyPrunedToolCallIds = parseUniqueStrings(value.newlyPrunedToolCallIds);
+	const newlyPrunedAutoreadRowIds = parseUniqueStrings(value.newlyPrunedAutoreadRowIds);
+	const retainedToolCallIds = parseUniqueStrings(value.retainedToolCallIds);
+	const retainedAutoreadRowIds = parseUniqueStrings(value.retainedAutoreadRowIds);
+	const refreshedFiles = parseRefreshedFiles(value.refreshedFiles);
+	const deferredFiles = parseDeferredFiles(value.deferredFiles);
+	if (
+		!newlyPrunedToolCallIds ||
+		!newlyPrunedAutoreadRowIds ||
+		!retainedToolCallIds ||
+		!retainedAutoreadRowIds ||
+		!refreshedFiles ||
+		!deferredFiles
+	)
+		return undefined;
+	if (
+		!isNonNegativeFinite(value.tokensBefore) ||
+		!isNonNegativeFinite(value.tokensAfter) ||
+		!isFiniteNumber(value.tokensReclaimed) ||
+		value.tokensBefore - value.tokensAfter !== value.tokensReclaimed
+	)
+		return undefined;
+	if (hasOverlap(newlyPrunedToolCallIds, retainedToolCallIds)) return undefined;
+	if (hasOverlap(newlyPrunedAutoreadRowIds, retainedAutoreadRowIds)) return undefined;
+	if (value.status === "skipped" && (newlyPrunedToolCallIds.length > 0 || newlyPrunedAutoreadRowIds.length > 0))
+		return undefined;
+
+	return {
+		v: 1,
+		status: value.status,
+		anchorToolCallId: value.anchorToolCallId,
+		newlyPrunedToolCallIds,
+		newlyPrunedAutoreadRowIds,
+		retainedToolCallIds,
+		retainedAutoreadRowIds,
+		refreshedFiles,
+		deferredFiles,
+		tokensBefore: value.tokensBefore,
+		tokensAfter: value.tokensAfter,
+		tokensReclaimed: value.tokensReclaimed,
+	};
+}
+
+export function replayContextPruningState(
+	branch: readonly SessionEntry[],
+	enabled = isContextPruningEnabled(),
+): ActiveContextPruningState {
+	const prunedToolCallIds = new Set<string>();
+	const prunedAutoreadRowIds = new Set<string>();
+	const state: ActiveContextPruningState = {
+		latestAnchorToolCallId: undefined,
+		prunedToolCallIds,
+		prunedAutoreadRowIds,
+		deferredFiles: [],
+	};
+	if (!enabled) return state;
+
+	const toolCalls = new Map<string, { count: number; name: string; index: number }>();
+	const toolResults = new Map<string, { count: number; name: string; index: number }>();
+	const autoreads = new Map<
+		string,
+		{ count: number; path: string; servedHash: string; source: string; batchId: string; index: number }
+	>();
+	for (let index = 0; index < branch.length; index += 1) {
+		const entry = branch[index];
+		if (entry.type === "message") {
+			const message = entry.message;
+			if (message.role === "assistant") {
+				for (const block of message.content) {
+					if (block.type !== "toolCall") continue;
+					const current = toolCalls.get(block.id);
+					toolCalls.set(block.id, { count: (current?.count ?? 0) + 1, name: block.name, index });
+				}
+			} else if (message.role === "toolResult") {
+				const current = toolResults.get(message.toolCallId);
+				toolResults.set(message.toolCallId, {
+					count: (current?.count ?? 0) + 1,
+					name: message.toolName,
+					index,
+				});
+			}
+			continue;
+		}
+		if (entry.type !== "custom_message" || entry.customType !== AUTOREAD_MESSAGE_TYPE) continue;
+		const autoread = parseAutoreadReference(entry.details);
+		if (!autoread) continue;
+		const current = autoreads.get(autoread.rowId);
+		autoreads.set(autoread.rowId, {
+			count: (current?.count ?? 0) + 1,
+			path: autoread.path,
+			servedHash: autoread.servedHash,
+			source: autoread.source,
+			batchId: autoread.batchId,
+			index,
+		});
+	}
+
+	for (let resultIndex = 0; resultIndex < branch.length; resultIndex += 1) {
+		const entry = branch[resultIndex];
+		if (entry.type !== "message" || entry.message.role !== "toolResult") continue;
+		const result = entry.message;
+		if (result.toolName !== CONTEXT_PRUNE_TOOL) continue;
+		const details = parseContextPruneDetailsV1(result.details);
+		if (!details || details.status !== "applied" || details.anchorToolCallId !== result.toolCallId) continue;
+		if (!isCompleteExchange(details.anchorToolCallId, CONTEXT_PRUNE_TOOL, toolCalls, toolResults)) continue;
+		const anchorCallIndex = toolCalls.get(details.anchorToolCallId)?.index;
+		if (anchorCallIndex === undefined || anchorCallIndex >= resultIndex) continue;
+		if (details.newlyPrunedToolCallIds.includes(details.anchorToolCallId)) continue;
+		if (details.retainedToolCallIds.includes(details.anchorToolCallId)) continue;
+		if (
+			!allCompleteExchanges(details.newlyPrunedToolCallIds, toolCalls, toolResults) ||
+			!allCompleteExchanges(details.retainedToolCallIds, toolCalls, toolResults) ||
+			!allAutoreads(details.newlyPrunedAutoreadRowIds, autoreads) ||
+			!allAutoreads(details.retainedAutoreadRowIds, autoreads)
+		)
+			continue;
+		if (
+			details.newlyPrunedToolCallIds.some((id) => !exchangePrecedes(id, anchorCallIndex, toolCalls, toolResults)) ||
+			details.retainedToolCallIds.some((id) => !exchangePrecedes(id, anchorCallIndex, toolCalls, toolResults)) ||
+			details.newlyPrunedAutoreadRowIds.some((id) => {
+				const row = autoreads.get(id);
+				return row === undefined || row.index >= anchorCallIndex;
+			})
+		)
+			continue;
+		if (
+			details.newlyPrunedToolCallIds.some((id) => prunedToolCallIds.has(id)) ||
+			details.retainedToolCallIds.some((id) => prunedToolCallIds.has(id)) ||
+			details.newlyPrunedAutoreadRowIds.some((id) => prunedAutoreadRowIds.has(id)) ||
+			details.retainedAutoreadRowIds.some((id) => prunedAutoreadRowIds.has(id))
+		)
+			continue;
+		if (
+			details.refreshedFiles.some((file) => {
+				const row = autoreads.get(file.rowId);
+				return (
+					row?.count !== 1 ||
+					row.path !== file.path ||
+					row.servedHash !== file.servedHash ||
+					row.source !== "context-pruning" ||
+					row.batchId !== details.anchorToolCallId ||
+					!details.retainedAutoreadRowIds.includes(file.rowId)
+				);
+			})
+		)
+			continue;
+		const refreshedRowIds = new Set(details.refreshedFiles.map((file) => file.rowId));
+		if (
+			details.retainedAutoreadRowIds.some((id) => {
+				const row = autoreads.get(id);
+				return row === undefined || (row.index >= anchorCallIndex && !refreshedRowIds.has(id));
+			})
+		)
+			continue;
+
+		for (const id of details.newlyPrunedToolCallIds) prunedToolCallIds.add(id);
+		for (const id of details.newlyPrunedAutoreadRowIds) prunedAutoreadRowIds.add(id);
+		state.latestAnchorToolCallId = details.anchorToolCallId;
+		state.deferredFiles = details.deferredFiles;
+	}
+	return state;
+}
+
+function parseRefreshedFiles(value: unknown): ContextPruneRefreshedFileV1[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const files: ContextPruneRefreshedFileV1[] = [];
+	const rowIds = new Set<string>();
+	for (const item of value) {
+		if (!hasExactKeys(item, ["path", "rowId", "servedHash"])) return undefined;
+		if (!isNonEmptyString(item.path) || !isNonEmptyString(item.rowId) || !isNonEmptyString(item.servedHash))
+			return undefined;
+		if (rowIds.has(item.rowId)) return undefined;
+		rowIds.add(item.rowId);
+		files.push({ path: item.path, rowId: item.rowId, servedHash: item.servedHash });
+	}
+	return files;
+}
+
+function parseDeferredFiles(value: unknown): ContextPruneDeferredFileV1[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const files: ContextPruneDeferredFileV1[] = [];
+	for (const item of value) {
+		if (!hasExactKeys(item, ["path", "reason", "relevantWhen"])) return undefined;
+		if (!isNonEmptyString(item.path) || !isNonEmptyString(item.reason) || !isNonEmptyString(item.relevantWhen))
+			return undefined;
+		files.push({ path: item.path, reason: item.reason, relevantWhen: item.relevantWhen });
+	}
+	return files;
+}
+
+function parseUniqueStrings(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const strings: string[] = [];
+	const seen = new Set<string>();
+	for (const item of value) {
+		if (!isNonEmptyString(item) || seen.has(item)) return undefined;
+		seen.add(item);
+		strings.push(item);
+	}
+	return strings;
+}
+
+function parseAutoreadReference(
+	value: unknown,
+): { rowId: string; path: string; servedHash: string; source: string; batchId: string } | undefined {
+	if (!isRecord(value) || value.status !== "read") return undefined;
+	if (
+		!isNonEmptyString(value.rowId) ||
+		!isNonEmptyString(value.path) ||
+		!isNonEmptyString(value.cwd) ||
+		!isNonEmptyString(value.source) ||
+		!isNonEmptyString(value.batchId)
+	)
+		return undefined;
+	if (!isRecord(value.readCache) || !isNonEmptyString(value.readCache.servedHash)) return undefined;
+	return {
+		rowId: value.rowId,
+		path: value.path,
+		servedHash: value.readCache.servedHash,
+		source: value.source,
+		batchId: value.batchId,
+	};
+}
+
+function allCompleteExchanges(
+	ids: readonly string[],
+	calls: ReadonlyMap<string, { count: number; name: string; index: number }>,
+	results: ReadonlyMap<string, { count: number; name: string; index: number }>,
+): boolean {
+	return ids.every((id) => {
+		const call = calls.get(id);
+		return call !== undefined && isCompleteExchange(id, call.name, calls, results);
+	});
+}
+
+function isCompleteExchange(
+	id: string,
+	name: string,
+	calls: ReadonlyMap<string, { count: number; name: string; index: number }>,
+	results: ReadonlyMap<string, { count: number; name: string; index: number }>,
+): boolean {
+	const call = calls.get(id);
+	const result = results.get(id);
+	return (
+		call?.count === 1 &&
+		result?.count === 1 &&
+		call.name === name &&
+		result.name === name &&
+		call.index < result.index
+	);
+}
+
+function exchangePrecedes(
+	id: string,
+	anchorCallIndex: number,
+	calls: ReadonlyMap<string, { index: number }>,
+	results: ReadonlyMap<string, { index: number }>,
+): boolean {
+	const call = calls.get(id);
+	const result = results.get(id);
+	return call !== undefined && result !== undefined && call.index < result.index && result.index < anchorCallIndex;
+}
+
+function allAutoreads(ids: readonly string[], autoreads: ReadonlyMap<string, { count: number }>): boolean {
+	return ids.every((id) => autoreads.get(id)?.count === 1);
+}
+
+function hasOverlap(left: readonly string[], right: readonly string[]): boolean {
+	const rightSet = new Set(right);
+	return left.some((item) => rightSet.has(item));
+}
+
+function hasExactKeys(value: unknown, keys: readonly string[]): value is Record<string, unknown> {
+	if (!isRecord(value)) return false;
+	const actual = Object.keys(value);
+	return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
+function isNonNegativeFinite(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function isFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}

package/shared/events.ts

@@ -7,6 +7,13 @@ export type TauAgentEvents = {
 		body?: string;
 		source?: string;
 	};
+	"tau:attention.hold.acquire": {
+		id: string;
+	};
+	"tau:attention.hold.release": {
+		id: string;
+		disposition: "notify" | "discard";
+	};
 	"tau:file-mutation.applied": {
 		source: "patch";
 		toolCallId: string;
@@ -37,6 +44,17 @@ export type TauAgentEvents = {
 		rowId: string;
 		state?: ToolRowVisualState;
 	};
+	/** @internal Complete-state replay for Tau-owned tool-row renderers. */
+	"tau:tool-row-state.snapshot.requested": {
+		requester: string;
+	};
+	/** @internal Complete-state replay for Tau-owned tool-row renderers. */
+	"tau:tool-row-state.snapshot": {
+		states: ReadonlyArray<{
+			rowId: string;
+			state: ToolRowVisualState;
+		}>;
+	};
 };
 
 export interface TauFooterItem {

package/shared/model-fallback/index.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import type { Api, AssistantMessage, Message, Model, ThinkingLevel, Tool } from "@earendil-works/pi-ai";
-import { completeSimple } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadTauExtensionSettings, updateTauExtensionSettings } from "../settings/load.ts";
 import { errorText, truncAt } from "../text.ts";
@@ -38,11 +37,20 @@ export async function resolveCandidates(
 		const key = `${model.provider}/${model.id}`;
 		if (seen.has(key)) return;
 
+		const provider = ctx.modelRegistry.getProvider(model.provider);
+		if (!provider) return;
 		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!auth.ok || !auth.apiKey) return;
+		if (!auth.ok) return;
 
 		seen.add(key);
-		candidates.push({ model, apiKey: auth.apiKey, headers: auth.headers, reasoning });
+		candidates.push({
+			model,
+			provider,
+			apiKey: auth.apiKey,
+			headers: auth.headers,
+			env: auth.env,
+			reasoning,
+		});
 	};
 
 	for (const preferred of preferredModels) {
@@ -211,13 +219,16 @@ function completeCandidate(
 	sessionId: string,
 	tools?: Tool[],
 ): Promise<AssistantMessage> {
-	return completeSimple(candidate.model, tools ? { messages: [...messages], tools } : { messages: [...messages] }, {
-		apiKey: candidate.apiKey,
-		headers: candidate.headers,
-		signal: ctx.signal,
-		reasoning: candidate.reasoning,
-		sessionId,
-	});
+	return candidate.provider
+		.streamSimple(candidate.model, tools ? { messages: [...messages], tools } : { messages: [...messages] }, {
+			apiKey: candidate.apiKey,
+			headers: candidate.headers,
+			env: candidate.env,
+			signal: ctx.signal,
+			reasoning: candidate.reasoning,
+			sessionId,
+		})
+		.result();
 }
 
 function responseText(response: AssistantMessage): string {

package/shared/model-fallback/types.ts

@@ -1,8 +1,10 @@
-import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+import type { Api, Model, Provider, ProviderEnv, ProviderHeaders, ThinkingLevel } from "@earendil-works/pi-ai";
 
 export interface ModelCandidate {
 	model: Model<Api>;
-	apiKey: string;
-	headers: Record<string, string> | undefined;
+	provider: Provider;
+	apiKey: string | undefined;
+	headers: ProviderHeaders | undefined;
+	env: ProviderEnv | undefined;
 	reasoning: ThinkingLevel | undefined;
 }

package/shared/settings/load.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { IsObject, type TSchema } from "typebox";
 import { Value } from "typebox/value";
 import type { JsonObject, TauExtensionSettingsSpec } from "./define.ts";
 import { asObject, readJsonStatus, writeJsonObject } from "./json.ts";
@@ -22,7 +23,9 @@ export async function loadTauExtensionSettings<TDefaults extends JsonObject>(
 	if (projectStatus?.exists && projectStatus.ok)
 		merged = mergeSettings(merged, extensionSection(projectStatus.value, spec.key));
 
-	return Value.Check(spec.schema, merged) ? merged : spec.defaults;
+	if (Value.Check(spec.schema, merged)) return merged;
+	const repaired = replaceInvalidProperties(spec.schema, merged, spec.defaults);
+	return repaired !== NO_DEFAULT && Value.Check(spec.schema, repaired) ? (repaired as TDefaults) : spec.defaults;
 }
 
 export async function updateTauExtensionSettings<TDefaults extends JsonObject>(
@@ -57,3 +60,77 @@ async function updateTauSettings(
 function extensionSection(root: JsonObject, key: string): JsonObject | undefined {
 	return asObject(asObject(root.extensions)?.[key]);
 }
+
+const NO_DEFAULT = Symbol("no-default");
+
+function replaceInvalidProperties(
+	schema: TSchema,
+	value: unknown,
+	documentedDefault: unknown | typeof NO_DEFAULT,
+): unknown | typeof NO_DEFAULT {
+	if (Value.Check(schema, value)) return value;
+
+	const valueObject = asObject(value);
+	if (IsObject(schema) && valueObject) {
+		const defaultObject = documentedDefault === NO_DEFAULT ? undefined : asObject(documentedDefault);
+		const repaired: JsonObject = {};
+		const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+		for (const [key, propertySchema] of Object.entries(schema.properties)) {
+			if (!Object.hasOwn(valueObject, key)) {
+				if (!required.has(key)) continue;
+				const requiredDefault = propertyDefault(propertySchema, defaultObject, key);
+				if (requiredDefault === NO_DEFAULT) return validatedDefault(schema, documentedDefault);
+				repaired[key] = Value.Clone(requiredDefault);
+				continue;
+			}
+
+			const propertyValue = replaceInvalidProperties(
+				propertySchema,
+				valueObject[key],
+				propertyDefault(propertySchema, defaultObject, key),
+			);
+			if (propertyValue !== NO_DEFAULT) repaired[key] = propertyValue;
+			else if (required.has(key)) return validatedDefault(schema, documentedDefault);
+		}
+
+		const schemaObject = asObject(schema);
+		const additionalProperties = schemaObject?.additionalProperties;
+		if (additionalProperties !== false) {
+			for (const [key, additionalValue] of Object.entries(valueObject)) {
+				if (Object.hasOwn(schema.properties, key)) continue;
+				if (additionalProperties === undefined || additionalProperties === true) repaired[key] = additionalValue;
+				else {
+					const repairedAdditional = replaceInvalidProperties(
+						additionalProperties as TSchema,
+						additionalValue,
+						NO_DEFAULT,
+					);
+					if (repairedAdditional !== NO_DEFAULT) repaired[key] = repairedAdditional;
+				}
+			}
+		}
+
+		if (Value.Check(schema, repaired)) return repaired;
+	}
+
+	return validatedDefault(schema, documentedDefault);
+}
+
+function propertyDefault(
+	schema: TSchema,
+	defaultObject: JsonObject | undefined,
+	key: string,
+): unknown | typeof NO_DEFAULT {
+	if (defaultObject && Object.hasOwn(defaultObject, key)) return defaultObject[key];
+	const schemaObject = asObject(schema);
+	return schemaObject && Object.hasOwn(schemaObject, "default") ? schemaObject.default : NO_DEFAULT;
+}
+
+function validatedDefault(
+	schema: TSchema,
+	documentedDefault: unknown | typeof NO_DEFAULT,
+): unknown | typeof NO_DEFAULT {
+	return documentedDefault !== NO_DEFAULT && Value.Check(schema, documentedDefault)
+		? Value.Clone(documentedDefault)
+		: NO_DEFAULT;
+}

package/shared/tool-row-state.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { onTauEvent } from "./events.js";
+import { emitTauEvent, onTauEvent } from "./events.js";
 
 export type ToolRowVisualState = "pruned";
 
@@ -17,11 +17,30 @@ export interface ToolRowStateStore {
 export function createToolRowStateStore(pi: EventAPI, owner: string): ToolRowStateStore {
 	const states = new Map<string, ToolRowVisualState>();
 	const invalidators = new Map<string, () => void>();
+
+	function requestSnapshot(): void {
+		emitTauEvent(pi, "tau:tool-row-state.snapshot.requested", { requester: owner });
+	}
+
 	onTauEvent(pi, owner, "tau:tool-row-state.set", ({ rowId, state }) => {
 		if (state === undefined) states.delete(rowId);
 		else states.set(rowId, state);
 		invalidators.get(rowId)?.();
 	});
+	onTauEvent(pi, owner, "tau:tool-row-state.snapshot", ({ states: snapshot }) => {
+		const nextStates = new Map(snapshot.map(({ rowId, state }) => [rowId, state] as const));
+		const changedRows = [...new Set([...states.keys(), ...nextStates.keys()])].filter(
+			(rowId) => states.get(rowId) !== nextStates.get(rowId),
+		);
+		states.clear();
+		for (const [rowId, state] of nextStates) states.set(rowId, state);
+		for (const rowId of changedRows) invalidators.get(rowId)?.();
+	});
+	pi.on("session_start", () => {
+		states.clear();
+		invalidators.clear();
+		requestSnapshot();
+	});
 
 	return {
 		get(rowId) {
@@ -33,6 +52,7 @@ export function createToolRowStateStore(pi: EventAPI, owner: string): ToolRowSta
 		clear() {
 			states.clear();
 			invalidators.clear();
+			requestSnapshot();
 		},
 	};
 }