@shanepadgett/tau-agent 0.33.0 → 0.34.0

package/schemas/tau.schema.json

@@ -12,6 +12,26 @@
 		"extensions": {
 			"type": "object",
 			"properties": {
+				"checkpoint": {
+					"type": "object",
+					"required": [
+						"checkpointTokenLimit"
+					],
+					"properties": {
+						"showToolRows": {
+							"type": "boolean",
+							"default": false,
+							"description": "Show checkpoint and injected-file rows in the TUI for debugging."
+						},
+						"checkpointTokenLimit": {
+							"type": "integer",
+							"minimum": 1,
+							"default": 150000,
+							"description": "Context-token ceiling before a checkpoint is required."
+						}
+					},
+					"additionalProperties": false
+				},
 				"context": {
 					"type": "object",
 					"properties": {
@@ -262,39 +282,6 @@
 						}
 					},
 					"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/bounded-text-result.ts

@@ -63,6 +63,7 @@ export class BoundedTextResultBuilder {
 		this.strategy = strategy;
 	}
 
+	// fallow-ignore-next-line unused-class-member -- head/tail strategy API; callers use completeBlocks today
 	async append(text: string): Promise<void> {
 		if (this.strategy === "completeBlocks") throw new Error("Complete-block results require appendBlock");
 		this.requireOpen();

package/shared/checkpoint-visibility.ts

@@ -0,0 +1,9 @@
+let showCheckpointRows = false;
+
+export function setCheckpointRowsVisible(visible: boolean): void {
+	showCheckpointRows = visible;
+}
+
+export function areCheckpointRowsVisible(): boolean {
+	return showCheckpointRows;
+}

package/shared/events.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ModelEffort } from "./model-effort.ts";
-import type { OutlineInjectionRequest, OutlineInjectionResponse } from "./outline-injection.js";
 import type { ToolRowVisualState } from "./tool-row-state.js";
+import type { FileInjectionRequest, PreparedFileInjection } from "../src/file-injection/index.ts";
 
 export type TauAgentEvents = {
 	"tau:agent.blocked": {
@@ -31,16 +31,14 @@ export type TauAgentEvents = {
 			snapshotRanges?: Array<{ startLine: number; endLine: number }>;
 		}>;
 	};
-	"tau:autoread.requested": {
-		source: string;
-		title?: string;
-		cwd: string;
-		batchId: string;
-		files: Array<{ path: string }>;
+	/** @internal Runtime-scoped discovery for deferred tool groups. */
+	"tau:deferred-tool-group.request": {
+		accept(group: { id: string; description: string; toolNames: readonly string[] }): void;
 	};
-	"tau:outline-injection.requested": {
-		request: OutlineInjectionRequest;
-		accept(response: Promise<OutlineInjectionResponse>): void;
+	/** @internal Runtime-scoped request for Explore-owned file preparation. */
+	"tau:file-injection.prepare": {
+		request: FileInjectionRequest;
+		accept(preparation: Promise<PreparedFileInjection[]>): void;
 	};
 	"tau:footer-item": {
 		id: string;
@@ -105,6 +103,25 @@ export function onTauEvent<Name extends keyof TauAgentEvents>(
 	owner: string,
 	name: Name,
 	handler: TauEventHandler<Name>,
+): () => void {
+	return subscribeToTauEvent(pi, owner, name, handler, false);
+}
+
+export function onTauEventImmediately<Name extends keyof TauAgentEvents>(
+	pi: TauEventAPI,
+	owner: string,
+	name: Name,
+	handler: TauEventHandler<Name>,
+): () => void {
+	return subscribeToTauEvent(pi, owner, name, handler, true);
+}
+
+function subscribeToTauEvent<Name extends keyof TauAgentEvents>(
+	pi: TauEventAPI,
+	owner: string,
+	name: Name,
+	handler: TauEventHandler<Name>,
+	attachImmediately: boolean,
 ): () => void {
 	if (owner.length === 0) throw new Error("Tau event owner is required.");
 
@@ -135,6 +152,7 @@ export function onTauEvent<Name extends keyof TauAgentEvents>(
 	}
 
 	subscriptions.set(name, subscription);
+	if (attachImmediately) attach();
 	pi.on("session_start", attach);
 	pi.on("session_shutdown", detach);
 	return subscription.stop;

package/shared/isolated-session.ts

@@ -32,6 +32,61 @@ export interface IsolatedSessionResource {
 	dispose(): Promise<void>;
 }
 
+type ModelAuth = Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>>;
+
+async function tryPreferredModel(
+	ctx: ExtensionContext,
+	preferredModel: string,
+	onWarning?: (warning: string) => void,
+): Promise<{ model: SelectedModel; auth: ModelAuth } | undefined> {
+	const separator = preferredModel.indexOf("/");
+	const configured = ctx.modelRegistry.find(preferredModel.slice(0, separator), preferredModel.slice(separator + 1));
+	if (!configured) {
+		onWarning?.(`model ${preferredModel} is unavailable; using parent model`);
+		return undefined;
+	}
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configured);
+	if (!auth.ok) {
+		onWarning?.(`model ${preferredModel} is unavailable: ${auth.error}; using parent model`);
+		return undefined;
+	}
+	return { model: configured, auth };
+}
+
+function thinkingSupported(
+	model: SelectedModel | undefined,
+	preferred: IsolatedSessionThinkingLevel,
+): preferred is IsolatedSessionThinkingLevel {
+	const mapped = model?.thinkingLevelMap?.[preferred];
+	if (!model?.reasoning || mapped === null) return false;
+	if ((preferred === "xhigh" || preferred === "max") && mapped === undefined) return false;
+	return true;
+}
+
+function resolveThinkingLevel(
+	model: SelectedModel | undefined,
+	parentThinkingLevel: IsolatedSessionThinkingLevel,
+	preferredThinkingLevel: IsolatedSessionThinkingLevel | undefined,
+	allowPreferred: boolean,
+	onWarning?: (warning: string) => void,
+): IsolatedSessionThinkingLevel {
+	if (!preferredThinkingLevel || !allowPreferred) return parentThinkingLevel;
+	if (thinkingSupported(model, preferredThinkingLevel)) return preferredThinkingLevel;
+	onWarning?.(`thinking ${preferredThinkingLevel} is unavailable for the selected model; using parent thinking`);
+	return parentThinkingLevel;
+}
+
+function runtimeApiKeyFor(
+	ctx: ExtensionContext,
+	model: SelectedModel,
+	provider: SelectedProvider,
+	auth: ModelAuth,
+): string | undefined {
+	if (!auth.ok) return undefined;
+	if (!(auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model))) return undefined;
+	return auth.apiKey;
+}
+
 export async function resolveIsolatedSessionModel(options: {
 	label: string;
 	preferredModel: string | undefined;
@@ -44,37 +99,25 @@ export async function resolveIsolatedSessionModel(options: {
 }): Promise<Pick<IsolatedSessionInputs, "model" | "provider" | "runtimeApiKey" | "thinkingLevel">> {
 	const { ctx, signal, onWarning } = options;
 	let model = ctx.model;
-	let thinkingLevel = options.parentThinkingLevel;
+	let selectedAuth: ModelAuth | undefined;
 	let preferredModelSelected = false;
-	let selectedAuth: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>> | undefined;
+
 	if (options.preferredModel) {
-		const separator = options.preferredModel.indexOf("/");
-		const configured = ctx.modelRegistry.find(
-			options.preferredModel.slice(0, separator),
-			options.preferredModel.slice(separator + 1),
-		);
-		if (!configured) onWarning?.(`model ${options.preferredModel} is unavailable; using parent model`);
-		else {
-			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configured);
-			if (!auth.ok) onWarning?.(`model ${options.preferredModel} is unavailable: ${auth.error}; using parent model`);
-			else {
-				model = configured;
-				selectedAuth = auth;
-				preferredModelSelected = true;
-			}
+		const preferred = await tryPreferredModel(ctx, options.preferredModel, onWarning);
+		if (preferred) {
+			model = preferred.model;
+			selectedAuth = preferred.auth;
+			preferredModelSelected = true;
 		}
 	}
-	if (options.preferredThinkingLevel && (preferredModelSelected || options.usePreferredThinkingAfterModelFallback)) {
-		const preferred = options.preferredThinkingLevel;
-		const mapped = model?.thinkingLevelMap?.[preferred];
-		const unsupported =
-			!model?.reasoning ||
-			mapped === null ||
-			((preferred === "xhigh" || preferred === "max") && mapped === undefined);
-		if (unsupported)
-			onWarning?.(`thinking ${preferred} is unavailable for the selected model; using parent thinking`);
-		else thinkingLevel = preferred;
-	}
+
+	const thinkingLevel = resolveThinkingLevel(
+		model,
+		options.parentThinkingLevel,
+		options.preferredThinkingLevel,
+		preferredModelSelected || options.usePreferredThinkingAfterModelFallback,
+		onWarning,
+	);
 	if (!model) throw new Error(`${options.label} startup failed: parent has no model`);
 	const auth = selectedAuth ?? (await ctx.modelRegistry.getApiKeyAndHeaders(model));
 	if (!auth.ok) throw new Error(`${options.label} startup failed: ${auth.error}`);
@@ -84,8 +127,7 @@ export async function resolveIsolatedSessionModel(options: {
 	return {
 		model,
 		provider,
-		runtimeApiKey:
-			auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model) ? auth.apiKey : undefined,
+		runtimeApiKey: runtimeApiKeyFor(ctx, model, provider, auth),
 		thinkingLevel,
 	};
 }

package/shared/model-effort.ts

@@ -3,7 +3,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resolveCandidates } from "./model-fallback/index.ts";
 import type { ModelCandidate } from "./model-fallback/types.ts";
 
-export type ModelEffort = "low" | "medium" | "high";
+export type ModelEffort = "quick" | "standard" | "deep";
 
 interface ModelPreference {
 	model: string;
@@ -25,42 +25,32 @@ export interface EffortProviderCandidates {
 }
 
 const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
-	low: [
+	quick: [
 		{
 			provider: "openai-codex",
-			models: [
-				{ model: "gpt-5.6-luna", reasoning: "high" },
-				{ model: "gpt-5.5", reasoning: "low" },
-			],
+			models: [{ model: "gpt-5.6-luna", reasoning: "medium" }],
 		},
 		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "medium" }] },
 		{ provider: "anthropic", models: [{ model: "claude-haiku-4-5", reasoning: "high" }] },
 	],
-	medium: [
+	standard: [
 		{
 			provider: "openai-codex",
-			models: [
-				{ model: "gpt-5.6-terra", reasoning: "high" },
-				{ model: "gpt-5.5", reasoning: "medium" },
-			],
+			models: [{ model: "gpt-5.6-luna", reasoning: "max" }],
 		},
 		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "high" }] },
 		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "high" }] },
 	],
-	high: [
+	deep: [
 		{
 			provider: "openai-codex",
-			models: [
-				{ model: "gpt-5.6-sol", reasoning: "high" },
-				{ model: "gpt-5.5", reasoning: "high" },
-			],
+			models: [{ model: "gpt-5.6-sol", reasoning: "high" }],
 		},
-		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "high" }] },
 		{
 			provider: "anthropic",
 			models: [
 				{ model: "claude-opus-5", reasoning: "high" },
-				{ model: "claude-opus-4-8", reasoning: "high" },
+				{ model: "claude-fable-5", reasoning: "low" },
 			],
 		},
 	],
@@ -72,7 +62,7 @@ export function effortForSelection(
 	reasoning: string | undefined,
 ): ModelEffort | undefined {
 	if (!provider || !model || !reasoning) return undefined;
-	for (const effort of ["high", "medium", "low"] as const) {
+	for (const effort of ["deep", "standard", "quick"] as const) {
 		const preference = MODEL_PREFERENCES[effort].find((item) => item.provider === provider);
 		if (preference?.models.some((item) => item.model === model && item.reasoning === reasoning)) return effort;
 	}

package/shared/model-fallback/index.ts

@@ -98,6 +98,20 @@ export async function generateToolValidated<T>(
 	);
 }
 
+async function noteCandidateFailure(
+	ctx: GenerationContext,
+	options: ModelFallbackOptions | undefined,
+	label: string,
+	message: string,
+	hasMore: boolean,
+): Promise<void> {
+	if (!hasMore) return;
+	await options?.onStatus?.(`Model failed (${label}); trying next model`);
+	if (options?.notifyOnFallback ?? false) {
+		ctx.ui.notify(`Model failed (${label}): ${message}\nTrying next model.`, "info");
+	}
+}
+
 async function withModelFallback<T>(
 	ctx: GenerationContext,
 	candidates: readonly ModelCandidate[],
@@ -106,13 +120,11 @@ async function withModelFallback<T>(
 ): Promise<T> {
 	const failures: string[] = [];
 	const statusKey = options?.statusKey;
-	const notifyOnFallback = options?.notifyOnFallback ?? false;
 
 	for (const [index, candidate] of candidates.entries()) {
 		const label = `${candidate.model.provider}/${candidate.model.id}`;
 		if (statusKey) ctx.ui.setStatus(statusKey, `generating (${label})`);
 		await options?.onStatus?.(`Generating with ${label}`);
-
 		try {
 			return await request(candidate);
 		} catch (error) {
@@ -120,16 +132,42 @@ async function withModelFallback<T>(
 			if (shouldCooldownProvider(error)) await markProviderUnavailable(candidate.model.provider);
 			const message = errorText(error);
 			failures.push(`- ${label}: ${message}`);
-			if (index < candidates.length - 1) await options?.onStatus?.(`Model failed (${label}); trying next model`);
-			if (index < candidates.length - 1 && notifyOnFallback) {
-				ctx.ui.notify(`Model failed (${label}): ${message}\nTrying next model.`, "info");
-			}
+			await noteCandidateFailure(ctx, options, label, message, index < candidates.length - 1);
 		}
 	}
 
 	throw new Error(["Model generation failed for all candidates:", ...failures].join("\n"));
 }
 
+function throwUnlessRetryableStopError(response: AssistantMessage, attempt: number, maxAttempts: number): void {
+	if (response.stopReason !== "error") return;
+	const error = new Error(response.errorMessage || "model returned an error");
+	if (attempt < maxAttempts && !shouldCooldownProvider(error)) return;
+	throw error;
+}
+
+function pushCorrection(
+	messages: Message[],
+	error: Error,
+	output: string,
+	correctionPrompt: (error: Error, output: string) => string,
+): void {
+	messages.push({
+		role: "user",
+		content: [{ type: "text", text: correctionPrompt(error, truncAt(output, 4_000)) }],
+		timestamp: Date.now(),
+	});
+}
+
+function shouldRetryValidation(
+	error: unknown,
+	attempt: number,
+	maxAttempts: number,
+	correctionPrompt: ((error: Error, output: string) => string) | undefined,
+): error is Error {
+	return error instanceof Error && attempt < maxAttempts && correctionPrompt !== undefined;
+}
+
 async function requestValidated<T>(
 	ctx: GenerationContext,
 	candidate: ModelCandidate,
@@ -137,37 +175,36 @@ async function requestValidated<T>(
 	validate: (text: string) => T,
 	correctionPrompt?: (error: Error, text: string) => string,
 ): Promise<T> {
-	const userMessage: Message = { role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() };
-	const messages: Message[] = [userMessage];
+	const messages: Message[] = [{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() }];
 	const sessionId = randomUUID();
 
 	for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
 		const response = await completeCandidate(ctx, candidate, messages, sessionId);
 		const text = responseText(response);
-		if (response.stopReason === "error") {
-			const error = new Error(response.errorMessage || "model returned an error");
-			if (attempt < MAX_ATTEMPTS && !shouldCooldownProvider(error)) continue;
-			throw error;
-		}
-
 		try {
+			throwUnlessRetryableStopError(response, attempt, MAX_ATTEMPTS);
+			if (response.stopReason === "error") continue;
 			return validate(text);
 		} catch (error) {
-			if (!(error instanceof Error) || attempt >= MAX_ATTEMPTS) throw error;
-			if (!correctionPrompt) throw error;
-
+			if (!shouldRetryValidation(error, attempt, MAX_ATTEMPTS, correctionPrompt) || !correctionPrompt) {
+				throw error;
+			}
 			if (text) messages.push({ ...response, content: [{ type: "text", text }] });
-			messages.push({
-				role: "user",
-				content: [{ type: "text", text: correctionPrompt(error, truncAt(text, 4_000)) }],
-				timestamp: Date.now(),
-			});
+			pushCorrection(messages, error, text, correctionPrompt);
 		}
 	}
 
 	throw new Error("Model generation failed.");
 }
 
+function validateSingleToolCall(tool: Tool, toolCalls: readonly { name: string; arguments: unknown }[]): unknown {
+	if (toolCalls.length !== 1) throw new Error(`Model must call ${tool.name} exactly once.`);
+	const toolCall = toolCalls[0];
+	if (!toolCall) throw new Error(`Model must call ${tool.name}.`);
+	if (toolCall.name !== tool.name) throw new Error(`Model called ${toolCall.name}; expected ${tool.name}.`);
+	return toolCall.arguments;
+}
+
 async function requestToolValidated<T>(
 	ctx: GenerationContext,
 	candidate: ModelCandidate,
@@ -185,27 +222,15 @@ async function requestToolValidated<T>(
 		const text = responseText(response);
 		const toolCalls = response.content.flatMap((part) => (part.type === "toolCall" ? [part] : []));
 		const output = text || formatToolCalls(toolCalls);
-		if (response.stopReason === "error") {
-			const error = new Error(response.errorMessage || "model returned an error");
-			if (attempt < maxAttempts && !shouldCooldownProvider(error)) continue;
-			throw error;
-		}
-
 		try {
-			if (toolCalls.length !== 1) throw new Error(`Model must call ${tool.name} exactly once.`);
-			const [toolCall] = toolCalls;
-			if (!toolCall) throw new Error(`Model must call ${tool.name}.`);
-			if (toolCall.name !== tool.name) throw new Error(`Model called ${toolCall.name}; expected ${tool.name}.`);
-			return validate(toolCall.arguments);
+			throwUnlessRetryableStopError(response, attempt, maxAttempts);
+			if (response.stopReason === "error") continue;
+			return validate(validateSingleToolCall(tool, toolCalls));
 		} catch (error) {
-			if (!(error instanceof Error) || attempt >= maxAttempts) throw error;
-			if (!correctionPrompt) throw error;
-
-			messages.push({
-				role: "user",
-				content: [{ type: "text", text: correctionPrompt(error, truncAt(output, 4_000)) }],
-				timestamp: Date.now(),
-			});
+			if (!shouldRetryValidation(error, attempt, maxAttempts, correctionPrompt) || !correctionPrompt) {
+				throw error;
+			}
+			pushCorrection(messages, error, output, correctionPrompt);
 		}
 	}
 

package/shared/settings/load.ts

@@ -1,5 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { IsObject, type TSchema } from "typebox";
+import { IsObject, type TObject, type TSchema } from "typebox";
 import { Value } from "typebox/value";
 import type { JsonObject, TauExtensionSettingsSpec } from "./define.ts";
 import { asObject, readJsonStatus, writeJsonObject } from "./json.ts";
@@ -63,6 +63,47 @@ function extensionSection(root: JsonObject, key: string): JsonObject | undefined
 
 const NO_DEFAULT = Symbol("no-default");
 
+function repairKnownProperties(
+	schema: TObject,
+	valueObject: JsonObject,
+	defaultObject: JsonObject | undefined,
+): JsonObject | typeof NO_DEFAULT {
+	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 NO_DEFAULT;
+			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 NO_DEFAULT;
+	}
+	return repaired;
+}
+
+function repairAdditionalProperties(schema: TObject, valueObject: JsonObject, repaired: JsonObject): void {
+	const additionalProperties = asObject(schema)?.additionalProperties;
+	if (additionalProperties === false) return;
+	for (const [key, additionalValue] of Object.entries(valueObject)) {
+		if (Object.hasOwn(schema.properties, key)) continue;
+		if (additionalProperties === undefined || additionalProperties === true) {
+			repaired[key] = additionalValue;
+			continue;
+		}
+		const repairedAdditional = replaceInvalidProperties(additionalProperties as TSchema, additionalValue, NO_DEFAULT);
+		if (repairedAdditional !== NO_DEFAULT) repaired[key] = repairedAdditional;
+	}
+}
+
 function replaceInvalidProperties(
 	schema: TSchema,
 	value: unknown,
@@ -73,43 +114,9 @@ function replaceInvalidProperties(
 	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;
-				}
-			}
-		}
-
+		const repaired = repairKnownProperties(schema, valueObject, defaultObject);
+		if (repaired === NO_DEFAULT) return validatedDefault(schema, documentedDefault);
+		repairAdditionalProperties(schema, valueObject, repaired);
 		if (Value.Check(schema, repaired)) return repaired;
 	}
 

package/shared/temporary-output-store.ts

@@ -126,6 +126,7 @@ export class TemporaryOutputStore {
 		return writer;
 	}
 
+	// fallow-ignore-next-line unused-class-member -- called via createTemporaryOutputStore() from explore session lifecycle
 	async shutdown(): Promise<void> {
 		if (this.shutdownPromise) return this.shutdownPromise;
 		this.shutdownPromise = this.performShutdown();
@@ -177,6 +178,20 @@ export class TemporaryOutputStore {
 		this.active.delete(writer);
 	}
 
+	private async isRemovableOrphan(path: string): Promise<boolean> {
+		const metadata = await stat(path);
+		if (Date.now() - metadata.mtimeMs < this.orphanLifetimeMs) return false;
+		const marker = JSON.parse(await readFile(join(path, OWNER_FILE), "utf8")) as Partial<OwnerMarker>;
+		if (marker.kind !== "tau-tool-output" || marker.version !== 1 || typeof marker.pid !== "number") return false;
+		try {
+			process.kill(marker.pid, 0);
+			return false;
+		} catch (error) {
+			if (!isErrorCode(error, "ESRCH")) return false;
+		}
+		return true;
+	}
+
 	private async removeStaleOrphans(): Promise<void> {
 		let directory;
 		try {
@@ -188,16 +203,7 @@ export class TemporaryOutputStore {
 			if (!entry.isDirectory() || !entry.name.startsWith(DIRECTORY_PREFIX)) continue;
 			const path = join(this.baseDirectory, entry.name);
 			try {
-				const metadata = await stat(path);
-				if (Date.now() - metadata.mtimeMs < this.orphanLifetimeMs) continue;
-				const marker = JSON.parse(await readFile(join(path, OWNER_FILE), "utf8")) as Partial<OwnerMarker>;
-				if (marker.kind !== "tau-tool-output" || marker.version !== 1 || typeof marker.pid !== "number") continue;
-				try {
-					process.kill(marker.pid, 0);
-					continue;
-				} catch (error) {
-					if (!isErrorCode(error, "ESRCH")) continue;
-				}
+				if (!(await this.isRemovableOrphan(path))) continue;
 				await rm(path, { recursive: true, force: true });
 			} catch {
 				// An untrusted or concurrently changing directory is not ours to remove.